Linux驱动—实现一个驱动支持多个设备

转x33g5p2x  于2022-05-11 转载在 Linux  
字(6.4k)|赞(0)|评价(0)|浏览(607)

前面内容：
前面内容：
1 Linux驱动—内核模块基本使用

2 Linux驱动—内核模块参数，依赖(进一步讨论）

3 字符设备驱动

4 虚拟串口设备驱动

每个设备都写一个驱动太麻烦了，所以要Linux驱动—实现一个驱动支持多个设备。

对于多设备引入的变化：
我们首先要向 内核注册多个设备号
其次就是在添加cdev对象时指明改cdev对象管理了多个设备;
或者添加多个cdev对象，每个cdev对象管理一个设备。

接下来最麻烦的部分在于读写操作，因为设备是多个，那么设备对应的资源也应该是多个(比如虚拟串口驱动中的FIFO)。 在读写操作时，怎么来区分究竟应该对哪个设备进行操作呢(对于虚拟串口驱动而言，就是要确定对哪个FIFO进行操作) ?

观察读和写函数，没有发现能够区别设备的形参。
再观察open接口，我们会发现有一个inode 形参，通过前面的内容我们知道，inode里面包含了对应设备的设备号以及所对应的cdev对象的地址。

因此，我们可以在open接口函数中取出这些信息（inode里面包含了对应设备的设备号以及所对应的cdev对象的地址），并存放在file结构对象的某个成员中，再在读写的接口函数中获取该file结构的成员，从而可以区分出对哪个设备进行操作。

下面首先展示用一个cdev实现对多个设备的支持

  1. #include <linux/init.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/kfifo.h>
  9. #define VSER_MAJOR	256
  10. #define VSER_MINOR	0
  11. #define VSER_DEV_CNT	2
  12. #define VSER_DEV_NAME	"vser"
  14. static struct cdev vsdev;
  15. static DEFINE_KFIFO(vsfifo0, char, 32);
  16. static DEFINE_KFIFO(vsfifo1, char, 32);
  18. static int vser_open(struct inode *inode, struct file *filp)
  19. {
  20. 	switch (MINOR(inode->i_rdev)) {
  21. 	default:
  22. 	case 0:
  23. 		filp->private_data = &vsfifo0;
  24. 		break;
  25. 	case 1:
  26. 		filp->private_data = &vsfifo1;
  27. 		break;
  28. 	}
  29. 	return 0;
  30. }
  32. static int vser_release(struct inode *inode, struct file *filp)
  33. {
  34. 	return 0;
  35. }
  37. static ssize_t vser_read(struct file *filp, char __user *buf, size_t count, loff_t *pos)
  38. {
  39. 	unsigned int copied = 0;
  40. 	struct kfifo *vsfifo = filp->private_data;
  42. 	kfifo_to_user(vsfifo, buf, count, &copied);
  44. 	return copied;
  45. }
  47. static ssize_t vser_write(struct file *filp, const char __user *buf, size_t count, loff_t *pos)
  48. {
  49. 	unsigned int copied = 0;
  50. 	struct kfifo *vsfifo = filp->private_data;
  52. 	kfifo_from_user(vsfifo, buf, count, &copied);
  54. 	return copied;
  55. }
  57. static struct file_operations vser_ops = {
  58. 	.owner = THIS_MODULE,
  59. 	.open = vser_open,
  60. 	.release = vser_release,
  61. 	.read = vser_read,
  62. 	.write = vser_write,
  63. };
  65. static int __init vser_init(void)
  66. {
  67. 	int ret;
  68. 	dev_t dev;
  70. 	dev = MKDEV(VSER_MAJOR, VSER_MINOR);
  71. 	ret = register_chrdev_region(dev, VSER_DEV_CNT, VSER_DEV_NAME);
  72. 	if (ret)
  73. 		goto reg_err;
  75. 	cdev_init(&vsdev, &vser_ops);
  76. 	vsdev.owner = THIS_MODULE;
  78. 	ret = cdev_add(&vsdev, dev, VSER_DEV_CNT);
  79. 	if (ret)
  80. 		goto add_err;
  82. 	return 0;
  84. add_err:
  85. 	unregister_chrdev_region(dev, VSER_DEV_CNT);
  86. reg_err:
  87. 	return ret;
  88. }
  90. static void __exit vser_exit(void)
  91. {
  92. 	
  93. 	dev_t dev;
  95. 	dev = MKDEV(VSER_MAJOR, VSER_MINOR);
  97. 	cdev_del(&vsdev);
  98. 	unregister_chrdev_region(dev, VSER_DEV_CNT);
  99. }
  101. module_init(vser_init);
  102. module_exit(vser_exit);
  104. MODULE_LICENSE("GPL");
  105. MODULE_AUTHOR("Kevin Jiang <jiangxg@farsight.com.cn>");
  106. MODULE_DESCRIPTION("A simple character device driver");
  107. MODULE_ALIAS("virtual-serial");

来分析下代码：

这里把CNT改成2 说明支持2个设备

  1. static struct cdev vsdev;
  2. static DEFINE_KFIFO(vsfifo0, char, 32);
  3. static DEFINE_KFIFO(vsfifo1, char, 32);

定义了二个FIFO，vsfifo0和1 （这里用的是动态分配fifo要更好，但是后面会涉及内存分配的知识，所以先用静态的）

在open接口函数中根据次设备号的值来确定保存哪个FIFO结构的(vsfifo0还是1）地址到file结构中的private_data 的值，即FIFO结构的地址

  1. static int vser_open(struct inode *inode, struct file *filp)
  2. {
  3. 	switch (MINOR(inode->i_rdev)) {
  4. 	default:
  5. 	case 0:
  6. 		filp->private_data = &vsfifo0;
  7. 		break;
  8. 	case 1:
  9. 		filp->private_data = &vsfifo1;
  10. 		break;
  11. 	}
  12. 	return 0;
  13. }

次设备号 0 选择存 vsfifo0
次设备号 1 选择存 vsfifo1

接下来演示如何将每一个cdev对象对应到一个设备来实现一个驱动对多个设备的支持

  1. #include <linux/init.h>
  2. #include <linux/kernel.h>
  3. #include <linux/module.h>
  5. #include <linux/fs.h>
  6. #include <linux/cdev.h>
  7. #include <linux/kfifo.h>
  9. #define VSER_MAJOR	256
  10. #define VSER_MINOR	0
  11. #define VSER_DEV_CNT	2
  12. #define VSER_DEV_NAME	"vser"
  14. static DEFINE_KFIFO(vsfifo0, char, 32);
  15. static DEFINE_KFIFO(vsfifo1, char, 32);
  17. struct vser_dev {
  18. 	struct kfifo *fifo;
  19. 	struct cdev cdev;
  20. };
  22. static struct vser_dev vsdev[2];
  24. static int vser_open(struct inode *inode, struct file *filp)
  25. {
  26. 	filp->private_data = container_of(inode->i_cdev, struct vser_dev, cdev);
  27. 	return 0;
  28. }
  30. static int vser_release(struct inode *inode, struct file *filp)
  31. {
  32. 	return 0;
  33. }
  35. static ssize_t vser_read(struct file *filp, char __user *buf, size_t count, loff_t *pos)
  36. {
  37. 	unsigned int copied = 0;
  38. 	struct vser_dev *dev = filp->private_data;
  40. 	kfifo_to_user(dev->fifo, buf, count, &copied);
  42. 	return copied;
  43. }
  45. static ssize_t vser_write(struct file *filp, const char __user *buf, size_t count, loff_t *pos)
  46. {
  47. 	unsigned int copied = 0;
  48. 	struct vser_dev *dev = filp->private_data;
  50. 	kfifo_from_user(dev->fifo, buf, count, &copied);
  52. 	return copied;
  53. }
  55. static struct file_operations vser_ops = {
  56. 	.owner = THIS_MODULE,
  57. 	.open = vser_open,
  58. 	.release = vser_release,
  59. 	.read = vser_read,
  60. 	.write = vser_write,
  61. };
  63. static int __init vser_init(void)
  64. {
  65. 	int i;
  66. 	int ret;
  67. 	dev_t dev;
  69. 	dev = MKDEV(VSER_MAJOR, VSER_MINOR);
  70. 	ret = register_chrdev_region(dev, VSER_DEV_CNT, VSER_DEV_NAME);
  71. 	if (ret)
  72. 		goto reg_err;
  74. 	for (i = 0; i < VSER_DEV_CNT; i++) {
  75. 		cdev_init(&vsdev[i].cdev, &vser_ops);
  76. 		vsdev[i].cdev.owner = THIS_MODULE;
  77. 		vsdev[i].fifo = i == 0 ? (struct kfifo *) &vsfifo0 : (struct kfifo*)&vsfifo1;
  79. 		ret = cdev_add(&vsdev[i].cdev, dev + i, 1);
  80. 		if (ret)
  81. 			goto add_err;
  82. 	}
  84. 	return 0;
  86. add_err:
  87. 	for (--i; i > 0; --i)
  88. 		cdev_del(&vsdev[i].cdev);
  89. 	unregister_chrdev_region(dev, VSER_DEV_CNT);
  90. reg_err:
  91. 	return ret;
  92. }
  94. static void __exit vser_exit(void)
  95. {
  96. 	int i;
  97. 	dev_t dev;
  99. 	dev = MKDEV(VSER_MAJOR, VSER_MINOR);
  101. 	for (i = 0; i < VSER_DEV_CNT; i++)
  102. 		cdev_del(&vsdev[i].cdev);
  103. 	unregister_chrdev_region(dev, VSER_DEV_CNT);
  104. }
  106. module_init(vser_init);
  107. module_exit(vser_exit);
  109. MODULE_LICENSE("GPL");
  110. MODULE_AUTHOR("Kevin Jiang <jiangxg@farsight.com.cn>");
  111. MODULE_DESCRIPTION("A simple character device driver");
  112. MODULE_ALIAS("virtual-serial");

代码：

  1. struct vser_dev {
  2. 	struct kfifo *fifo;
  3. 	struct cdev cdev;
  4. };

这里定义了一个结构类型 vser_dev，代表一种具体的设备类

通常和设备有关的内容都可以跟cdev一起定义到一个结构中这样更容易

cdev 是所有字符设备的一个抽象，是一个基类，而一个具体类型的设备应该是由该基类派生出来的一个子类，子类包含了特定设备所特有的属性，比如vser_ dev 中的fifo,这样子类就更能刻画好一类具体的设备。

代码

  1. static struct vser_dev vsdev[2];

创建了两个vser_dev 类型的对象，和C++不同的是，创建这两个对象仅仅是为其分配了内存，并没有调用构造函数来初始化这两个对象，但在代码的第74行到第77行完成了这个操作。

  1. for (i = 0; i < VSER_DEV_CNT; i++) {
  2. 		cdev_init(&vsdev[i].cdev, &vser_ops);
  3. 		vsdev[i].cdev.owner = THIS_MODULE;
  4. 		vsdev[i].fifo = i == 0 ? (struct kfifo *) &vsfifo0 : (struct kfifo*)&vsfifo1;

你看，初始化init cdev

查看内核源码，会发现这种面向对象的思想处处可见，只能说因为语言的特性，并没有把这种形式体现得很明显而已。

代码的第74行到第82行通过两次循环完成了两个cdev对象的初始化和添加工作，并且初始化了fifo 成员的指向。

  1. for (i = 0; i < VSER_DEV_CNT; i++) {
  2. 		cdev_init(&vsdev[i].cdev, &vser_ops);
  3. 		vsdev[i].cdev.owner = THIS_MODULE;
  4. 		vsdev[i].fifo = i == 0 ? (struct kfifo *) &vsfifo0 : (struct kfifo*)&vsfifo1;
  6. 		ret = cdev_add(&vsdev[i].cdev, dev + i, 1);
  7. 		if (ret)
  8. 			goto add_err;
  9. 	}

如果i为0是第一个，指向vsfifo0这个结构的地址
如果i为1是第二个，指向vsfifo1这个结构的地址

这里需要说明的是，用DEFINE_ KFIFO定义的FIFO,每定义一个FIFO就会新定义一种数据类型，所以严格来说vsfifo0和vsfifo1是两种不同类型的对象，但好在这里能和struct kfifo类型兼容。

代码第26行

  1. filp->private_data = container_of(inode->i_cdev, struct vser_dev, cdev);

用到了一个container_ of宏，这是在Linux内核中设计得非常巧妙的一个宏，在整个Linux内核源码中几乎随处可见。

它的作用就是**根据结构成员的地址来反向得到结构的起始地址**

在代码中,inode->i_cdev 给出了struct vser_dev 结构类型中cdev成员的地址(见图3.2)，通过container_ of宏就得到了包含该cdev的结构地址。

使用上面两种方式都可以实现一个驱动对多个同类型设备的支持。使用下面的命令可以测试这两个驱动程序。

完成

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/qq_35629971/article/details/124671479

内容来源于网络，如有侵权，请联系作者删除！

linux运维驱动开发linux驱动

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com