Chinaunix首页 | 论坛 | 博客

jin7992273的ChinaUnix博客

首页　| 　博文目录　| 　关于我

jin7992273

  • 博客访问： 52445
  • 博文数量： 18
  • 博客积分： 445
  • 博客等级： 下士
  • 技术积分： 185
  • 用 户 组： 普通用户
  • 注册时间： 2012-09-26 16:57
文章分类

全部博文（18）

文章存档

2012年（18）

我的朋友
最近访客
推荐博文
相关博文
misc设备驱动模型

分类： LINUX

2012-10-23 22:32:43

1、misc设备驱动模型

      本节我们来看一下misc设备驱动模型的有关内容，首先是看看它的设备结构体，定义在include/linux/miscdevice.h中：

 
  1. struct miscdevice  {  
  2.     int minor;                  //次设备号，若为 MISC_DYNAMIC_MINOR 自动分配   
  3.     const char *name;           //设备名   
  4.     const struct file_operations *fops; //设备文件操作结构体   
  5.     struct list_head list;          //misc_list链表头   
  6.     struct device *parent;  
  7.     struct device *this_device;  
  8.     const char *nodename;  
  9.     mode_t mode;  
  10. };  
struct miscdevice { int minor; //次设备号，若为 MISC_DYNAMIC_MINOR 自动分配 const char *name; //设备名 const struct file_operations *fops; //设备文件操作结构体 struct list_head list; //misc_list链表头 struct device *parent; struct device *this_device; const char *nodename; mode_t mode; };      结构体中的部分成员我们是一目了然的，主要是来看看有疑惑的几点：

1、为什么只有次设备号呢？一个设备不是有主、次设备号吗？

      其实，我想大家应该能够想到了，此时没有明确指定，那就说明应该是使用默认值。

2、主设备号的默认值是多少呢？难道所有注册为misc的设备都有相同的主设备号？怎么区分各个设备呢？

      这个主设备号是10.的确，所有注册为misc的设备都有相同的主设备号：10.在使用过程中我们主要是通过次设备号来区分各个设备。这一点不难理解，内核将所有注册为misc的设备都归为一大类。

3、结构体中的list_head结构体类型的list成员的作用是什么呢？

      内核自己会维护一个misc_list链表，所有注册为misc的设备都必须挂在这个链表上，这个list就是该链表的链表头。

4、结构体中的两个device结构体类型指针作用是什么呢？

      作用就是创建设备文件，稍候就可以看到了！

5、我们如何定义自己的misc类型的设备呢？

      可如下定义：

[cpp] view plaincopyprint?
  1. static struct miscdevice misc = {  
  2.     .minor = MISC_DYNAMIC_MINOR,  
  3.     .name = DEVICE_NAME,  
  4.     .fops = &dev_fops,  
  5. };  
static struct miscdevice misc = { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &dev_fops, };       其中的设备文件操作结构体和字符设备类似，这里就不再细讲。

6、定义了自己的misc设备，那么我们如何向内核注册/注销设备呢？

     使用如下两个函数：

[cpp] view plaincopyprint?
  1. int misc_register(struct miscdevice * misc);    //在加载模块时会自动创建设备文件，是主设备号为10的字符设备   
  2. int misc_deregister(struct miscdevice *misc);   //在卸载模块时会自动删除设备文件  
int misc_register(struct miscdevice * misc); //在加载模块时会自动创建设备文件，是主设备号为10的字符设备 int misc_deregister(struct miscdevice *misc); //在卸载模块时会自动删除设备文件      好了，至此，整个设备驱动的流程就完了，接下来深入了解一下misc设备模型的工作原理。

       首先看看misc初始化函数：

[cpp] view plaincopyprint?
  1. static int __init misc_init(void)  
  2. {  
  3.     int err;  
  4.   
  5. #ifdef CONFIG_PROC_FS   
  6.     /*如果使用proc文件系统，则创建misc项*/  
  7.     proc_create("misc", 0, NULL, &misc_proc_fops);  
  8. #endif   
  9.     /*在/sys/class/目录下创建一个名为misc的类*/  
  10.     misc_class = class_create(THIS_MODULE, "misc");  
  11.     err = PTR_ERR(misc_class);  
  12.     if (IS_ERR(misc_class))  
  13.         goto fail_remove;  
  14.   
  15.     err = -EIO;  
  16.     /*咦，怎么misc设备驱动调用字符驱动的注册函数呢？设备的主设备号为MISC_MAJOR，为10*/  
  17.     if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))  
  18.         goto fail_printk;  
  19.     misc_class->devnode = misc_devnode;  
  20.     return 0;  
  21.   
  22. fail_printk:  
  23.     printk("unable to get major %d for misc devices\n", MISC_MAJOR);  
  24.     class_destroy(misc_class);  
  25. fail_remove:  
  26.     remove_proc_entry("misc", NULL);  
  27.     return err;  
  28. }  
  29. /*向内核注册misc子系统*/    
  30. subsys_initcall(misc_init);   
static int __init misc_init(void) { int err; #ifdef CONFIG_PROC_FS /*如果使用proc文件系统，则创建misc项*/ proc_create("misc", 0, NULL, &misc_proc_fops); #endif /*在/sys/class/目录下创建一个名为misc的类*/ misc_class = class_create(THIS_MODULE, "misc"); err = PTR_ERR(misc_class); if (IS_ERR(misc_class)) goto fail_remove; err = -EIO; /*咦，怎么misc设备驱动调用字符驱动的注册函数呢？设备的主设备号为MISC_MAJOR，为10*/ if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) goto fail_printk; misc_class->devnode = misc_devnode; return 0; fail_printk: printk("unable to get major %d for misc devices\n", MISC_MAJOR); class_destroy(misc_class); fail_remove: remove_proc_entry("misc", NULL); return err; } /*向内核注册misc子系统*/ subsys_initcall(misc_init);         接下来看看misc设备驱动的注册与注销函数：

注册函数：

[cpp] view plaincopyprint?
  1. int misc_register(struct miscdevice * misc)  
  2. {  
  3.     struct miscdevice *c;  
  4.     dev_t dev;  
  5.     int err = 0;  
  6.   
  7.     /*内核初始化一个链表头*/  
  8.     INIT_LIST_HEAD(&misc->list);  
  9.   
  10.     mutex_lock(&misc_mtx);  
  11.     /*遍历已经注册的misc，如果和当前准备注册的相同(依据次设备号来判断),就返回设备忙*/  
  12.     list_for_each_entry(c, &misc_list, list) {  
  13.         if (c->minor == misc->minor) {  
  14.             mutex_unlock(&misc_mtx);  
  15.             return -EBUSY;  
  16.         }  
  17.     }  
  18.   
  19.     /*动态分配设备的次设备号*/  
  20.     if (misc->minor == MISC_DYNAMIC_MINOR) {  
  21.         int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS);  
  22.         if (i >= DYNAMIC_MINORS) {  
  23.             mutex_unlock(&misc_mtx);  
  24.             return -EBUSY;  
  25.         }  
  26.         misc->minor = DYNAMIC_MINORS - i - 1;  
  27.         set_bit(i, misc_minors);  
  28.     }  
  29.   
  30.     /*使用固定的主设备号，动态分配的次设备号构造设备号*/  
  31.     dev = MKDEV(MISC_MAJOR, misc->minor);  
  32.   
  33.     /*创建设备文件，这里就是使用miscdevice结构体中两个device类型指针的地方， 
  34.       当然，这是和linux设备驱动模型相关的*/  
  35.     misc->this_device = device_create(misc_class, misc->parent, dev,  
  36.                       misc, "%s", misc->name);  
  37.     if (IS_ERR(misc->this_device)) {  
  38.         int i = DYNAMIC_MINORS - misc->minor - 1;  
  39.         if (i < DYNAMIC_MINORS && i >= 0)  
  40.             clear_bit(i, misc_minors);  
  41.         err = PTR_ERR(misc->this_device);  
  42.         goto out;  
  43.     }  
  44.   
  45.     /* 
  46.      * Add it to the front, so that later devices can "override" 
  47.      * earlier defaults 
  48.      */  
  49.      /*到这一步也就注册成功了，将新注册的misc设备加入到内核维护的misc_list链表中*/  
  50.     list_add(&misc->list, &misc_list);  
  51.  out:  
  52.     mutex_unlock(&misc_mtx);  
  53.     return err;  
  54. }  
int misc_register(struct miscdevice * misc) { struct miscdevice *c; dev_t dev; int err = 0; /*内核初始化一个链表头*/ INIT_LIST_HEAD(&misc->list); mutex_lock(&misc_mtx); /*遍历已经注册的misc，如果和当前准备注册的相同(依据次设备号来判断),就返回设备忙*/ list_for_each_entry(c, &misc_list, list) { if (c->minor == misc->minor) { mutex_unlock(&misc_mtx); return -EBUSY; } } /*动态分配设备的次设备号*/ if (misc->minor == MISC_DYNAMIC_MINOR) { int i = find_first_zero_bit(misc_minors, DYNAMIC_MINORS); if (i >= DYNAMIC_MINORS) { mutex_unlock(&misc_mtx); return -EBUSY; } misc->minor = DYNAMIC_MINORS - i - 1; set_bit(i, misc_minors); } /*使用固定的主设备号，动态分配的次设备号构造设备号*/ dev = MKDEV(MISC_MAJOR, misc->minor); /*创建设备文件，这里就是使用miscdevice结构体中两个device类型指针的地方， 当然，这是和linux设备驱动模型相关的*/ misc->this_device = device_create(misc_class, misc->parent, dev, misc, "%s", misc->name); if (IS_ERR(misc->this_device)) { int i = DYNAMIC_MINORS - misc->minor - 1; if (i < DYNAMIC_MINORS && i >= 0) clear_bit(i, misc_minors); err = PTR_ERR(misc->this_device); goto out; } /* * Add it to the front, so that later devices can "override" * earlier defaults */ /*到这一步也就注册成功了，将新注册的misc设备加入到内核维护的misc_list链表中*/ list_add(&misc->list, &misc_list); out: mutex_unlock(&misc_mtx); return err; }注销函数：

[cpp] view plaincopyprint?
  1. int misc_deregister(struct miscdevice *misc)  
  2. {  
  3.     int i = DYNAMIC_MINORS - misc->minor - 1;  
  4.   
  5.     if (WARN_ON(list_empty(&misc->list)))  
  6.         return -EINVAL;  
  7.   
  8.     mutex_lock(&misc_mtx);  
  9.     /*删除链表节点*/  
  10.     list_del(&misc->list);  
  11.     /*销毁设备文件*/  
  12.     device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));  
  13.     if (i < DYNAMIC_MINORS && i >= 0)  
  14.         clear_bit(i, misc_minors);  
  15.     mutex_unlock(&misc_mtx);  
  16.     return 0;  
  17. }  
int misc_deregister(struct miscdevice *misc) { int i = DYNAMIC_MINORS - misc->minor - 1; if (WARN_ON(list_empty(&misc->list))) return -EINVAL; mutex_lock(&misc_mtx); /*删除链表节点*/ list_del(&misc->list); /*销毁设备文件*/ device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor)); if (i < DYNAMIC_MINORS && i >= 0) clear_bit(i, misc_minors); mutex_unlock(&misc_mtx); return 0; }       到这里，差不多misc设备驱动模型就差不多了。

2、misc设备驱动实例

      这里贴一个简单的misc设备驱动程序，方便大家对照上面的理论部分进行分析，此驱动程序是友善之臂6410开发板的LED驱动程序，可以看看：

[cpp] view plaincopyprint?
  1. #include    
  2. #include    
  3. #include    
  4. //#include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12. #include    
  13. #include    
  14. #include    
  15. #include    
  16. #include    
  17. #include    
  18. #include    
  19. #include    
  20. #include    
  21. #include    
  22. #include    
  23. #include    
  24.   
  25. #include    
  26. #include    
  27. #include    
  28.   
  29. #include    
  30. #include    
  31. #include    
  32.   
  33. #define DEVICE_NAME "leds"   
  34.   
  35. static long sbc2440_leds_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)  
  36. {  
  37.     switch(cmd) {  
  38.         unsigned tmp;  
  39.     case 0:  
  40.     case 1:  
  41.         if (arg > 4) {  
  42.             return -EINVAL;  
  43.         }  
  44.         tmp = readl(S3C64XX_GPKDAT);  
  45.         tmp &= ~(1 << (4 + arg));  
  46.         tmp |= ( (!cmd) << (4 + arg) );  
  47.         writel(tmp, S3C64XX_GPKDAT);  
  48.         return 0;  
  49.     default:  
  50.         return -EINVAL;  
  51.     }  
  52. }  
  53.   
  54. static struct file_operations dev_fops = {  
  55.     .owner          = THIS_MODULE,  
  56.     .unlocked_ioctl = sbc2440_leds_ioctl,  
  57. };  
  58.   
  59. static struct miscdevice misc = {  
  60.     .minor = MISC_DYNAMIC_MINOR,  
  61.     .name = DEVICE_NAME,  
  62.     .fops = &dev_fops,  
  63. };  
  64.   
  65. static int __init dev_init(void)  
  66. {  
  67.     int ret;  
  68.   
  69.     {  
  70.         unsigned tmp;  
  71.         tmp = readl(S3C64XX_GPKCON);  
  72.         tmp = (tmp & ~(0xffffU<<16))|(0x1111U<<16);  
  73.         writel(tmp, S3C64XX_GPKCON);  
  74.           
  75.         tmp = readl(S3C64XX_GPKDAT);  
  76.         tmp |= (0xF << 4);  
  77.         writel(tmp, S3C64XX_GPKDAT);  
  78.     }  
  79.   
  80.     ret = misc_register(&misc);  
  81.   
  82.     printk (DEVICE_NAME"\tinitialized\n");  
  83.   
  84.     return ret;  
  85. }  
  86.   
  87. static void __exit dev_exit(void)  
  88. {  
  89.     misc_deregister(&misc);  
  90. }  
  91.   
  92. module_init(dev_init);  
  93. module_exit(dev_exit);  
  94. MODULE_LICENSE("GPL");  
  95. MODULE_AUTHOR("FriendlyARM Inc.");  
#include #include #include //#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define DEVICE_NAME "leds" static long sbc2440_leds_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) { switch(cmd) { unsigned tmp; case 0: case 1: if (arg > 4) { return -EINVAL; } tmp = readl(S3C64XX_GPKDAT); tmp &= ~(1 << (4 + arg)); tmp |= ( (!cmd) << (4 + arg) ); writel(tmp, S3C64XX_GPKDAT); return 0; default: return -EINVAL; } } static struct file_operations dev_fops = { .owner = THIS_MODULE, .unlocked_ioctl = sbc2440_leds_ioctl, }; static struct miscdevice misc = { .minor = MISC_DYNAMIC_MINOR, .name = DEVICE_NAME, .fops = &dev_fops, }; static int __init dev_init(void) { int ret; { unsigned tmp; tmp = readl(S3C64XX_GPKCON); tmp = (tmp & ~(0xffffU<<16))|(0x1111U<<16); writel(tmp, S3C64XX_GPKCON); tmp = readl(S3C64XX_GPKDAT); tmp |= (0xF << 4); writel(tmp, S3C64XX_GPKDAT); } ret = misc_register(&misc); printk (DEVICE_NAME"\tinitialized\n"); return ret; } static void __exit dev_exit(void) { misc_deregister(&misc); } module_init(dev_init); module_exit(dev_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("FriendlyARM Inc.");

阅读(2391) | 评论(0) | 转发(1) |
0

上一篇：一个简单的字符驱动程序

下一篇：设备驱动中的中断问题及实例解析

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6