linux驱动修炼之道-混杂设备

最新推荐文章于 2024-07-22 21:49:24 发布
最新推荐文章于 2024-07-22 21:49:24 发布
阅读量592 收藏 1
点赞数
分类专栏： 驱动开发 文章标签： linux list class linux内核 module file

Linux驱动中把无法归类的五花八门的设备定义为混杂设备(用miscdevice结构体表述)。miscdevice共享一个主设备号MISC_MAJOR(即10)，但次设备号不同。 所有的miscdevice设备形成了一个链表，对设备访问时内核根据次设备号查找对应的miscdevice设备，然后调用其file_operations结构中注册的文件操作接口进行操作。 在内核中用struct miscdevice表示miscdevice设备，然后调用其file_operations结构中注册的文件操作接口进行操作。miscdevice的API实现在drivers/char/misc.c中。

下边是描述这个设备的结构体：

  1. struct miscdevice  {      
  2.     int minor;                               //次设备号   
  3.     const char *name;                        //设备的名称      
  4.     const struct file_operations *fops;     //文件操作    
  5.     struct list_head list;                  //misc_list的链表头  
  6.     struct device *parent;                  //父设备(Linux设备模型中的东东了，哈哈)      
  7.     struct device *this_device;             //当前设备，是device_create的返回值，下边会看到  
  8. };  

然后来看看misc子系统的初始化函数：

  1. static int __init misc_init(void)   
  2. {   
  3.     int err;   
  4.   
  5. #ifdef CONFIG_PROC_FS   
  6.     /*创建一个proc入口项*/  
  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_MAJOR，为10。设备名为misc，misc_fops是操作函数的集合*/   
  17.     if (register_chrdev(MISC_MAJOR,"misc",&misc_fops))   
  18.         goto fail_printk;   
  19.     return 0;   
  20.    
  21. fail_printk:   
  22.     printk("unable to get major %d for misc devices/n", MISC_MAJOR);   
  23.     class_destroy(misc_class);   
  24. fail_remove:   
  25.     remove_proc_entry("misc", NULL);   
  26.     return err;   
  27. }   
  28. /*misc作为一个子系统被注册到linux内核中*/  
  29. subsys_initcall(misc_init);   

下边是register_chrdev函数的实现：

  1. int register_chrdev(unsigned int major, const char *name,  
  2.             const struct file_operations *fops)  
  3. {  
  4.     struct char_device_struct *cd;  
  5.     struct cdev *cdev;  
  6.     char *s;  
  7.     int err = -ENOMEM;  
  8.     /*主设备号是10，次设备号为从0开始，分配256个设备*/  
  9.     cd = __register_chrdev_region(major, 0, 256, name);  
  10.     if (IS_ERR(cd))  
  11.         return PTR_ERR(cd);  
  12.     /*分配字符设备*/  
  13.     cdev = cdev_alloc();  
  14.     if (!cdev)  
  15.         goto out2;  
  16.   
  17.     cdev->owner = fops->owner;  
  18.     cdev->ops = fops;  
  19.     /*Linux设备模型中的,设置kobject的名字*/  
  20.     kobject_set_name(&cdev->kobj, "%s", name);  
  21.     for (s = strchr(kobject_name(&cdev->kobj),'/'); s; s = strchr(s, '/'))  
  22.         *s = '!';  
  23.     /*把这个字符设备注册到系统中*/     
  24.     err = cdev_add(cdev, MKDEV(cd->major, 0), 256);  
  25.     if (err)  
  26.         goto out;  
  27.   
  28.     cd->cdev = cdev;  
  29.   
  30.     return major ? 0 : cd->major;  
  31. out:  
  32.     kobject_put(&cdev->kobj);  
  33. out2:  
  34.     kfree(__unregister_chrdev_region(cd->major, 0, 256));  
  35.     return err;  
  36. }  

  37. 来看看这个设备的操作函数的集合：

    1. static const struct file_operations misc_fops = {   
    2.     .owner      = THIS_MODULE,   
    3.     .open       = misc_open,   
    4. };   

    可以看到这里只有一个打开函数，用户打开miscdevice设备是通过主设备号对应的打开函数，在这个函数中找到次设备号对应的相应的具体设备的open函数。它的实现如下：

    1. static int misc_open(struct inode * inode, struct file * file)   
    2. {   
    3.     int minor = iminor(inode);   
    4.     struct miscdevice *c;   
    5.     int err = -ENODEV;   
    6.     const struct file_operations *old_fops, *new_fops = NULL;   
    7.       
    8.     lock_kernel();   
    9.     mutex_lock(&misc_mtx);   
    10.     /*找到次设备号对应的操作函数集合，让new_fops指向这个具体设备的操作函数集合*/  
    11.     list_for_each_entry(c, &misc_list, list) {   
    12.         if (c->minor == minor) {   
    13.             new_fops = fops_get(c->fops);           
    14.             break;   
    15.         }   
    16.     }   
    17.            
    18.     if (!new_fops) {   
    19.         mutex_unlock(&misc_mtx);   
    20.         /*如果没有找到，则请求加载这个次设备号对应的模块*/  
    21.         request_module("char-major-%d-%d", MISC_MAJOR, minor);   
    22.         mutex_lock(&misc_mtx);   
    23.         /*重新遍历misc_list链表，如果没有找到就退出，否则让new_fops指向这个具体设备的操作函数集合*/  
    24.         list_for_each_entry(c, &misc_list, list) {   
    25.             if (c->minor == minor) {   
    26.                 new_fops = fops_get(c->fops);   
    27.                 break;   
    28.             }   
    29.         }   
    30.         if (!new_fops)   
    31.             goto fail;   
    32.     }   
    33.    
    34.     err = 0;   
    35.     /*保存旧打开函数的地址*/  
    36.     old_fops = file->f_op;   
    37.     /*让主设备号的操作函数集合指针指向具体设备的操作函数集合*/  
    38.     file->f_op = new_fops;   
    39.     if (file->f_op->open) {  
    40.         /*使用具体设备的打开函数打开设备*/   
    41.         err=file->f_op->open(inode,file);   
    42.         if (err) {   
    43.             fops_put(file->f_op);   
    44.             file->f_op = fops_get(old_fops);   
    45.         }   
    46.     }   
    47.     fops_put(old_fops);   
    48. fail:   
    49.     mutex_unlock(&misc_mtx);   
    50.     unlock_kernel();   
    51.     return err;   
    52. }   

    再来看看misc子系统对外提供的两个重要的API,misc_register,misc_deregister：

    1. int misc_register(struct miscdevice * misc)   
    2. {   
    3.     struct miscdevice *c;   
    4.     dev_t dev;   
    5.     int err = 0;   
    6.     /*初始化misc_list链表*/  
    7.     INIT_LIST_HEAD(&misc->list);   
    8.     mutex_lock(&misc_mtx);   
    9.     /*遍历misc_list链表，看这个次设备号以前有没有被用过，如果次设备号已被占有则退出*/  
    10.     list_for_each_entry(c, &misc_list, list) {   
    11.         if (c->minor == misc->minor) {   
    12.             mutex_unlock(&misc_mtx);   
    13.             return -EBUSY;   
    14.         }   
    15.     }   
    16.     /*看是否是需要动态分配次设备号*/  
    17.     if (misc->minor == MISC_DYNAMIC_MINOR) {  
    18.         /* 
    19.          *#define DYNAMIC_MINORS 64 /* like dynamic majors */  
    20.          *static unsigned char misc_minors[DYNAMIC_MINORS / 8];   
    21.          *这里存在一个次设备号的位图，一共64位。下边是遍历每一位，  
    22.          *如果这位为0，表示没有被占有，可以使用，为1表示被占用。         
    23.          */  
    24.         int i = DYNAMIC_MINORS;   
    25.         while (--i >= 0)   
    26.             if ( (misc_minors[i>>3] & (1 << (i&7))) == 0)   
    27.                 break;   
    28.         if (i<0) {   
    29.             mutex_unlock(&misc_mtx);   
    30.             return -EBUSY;   
    31.         }   
    32.         /*得到这个次设备号*/  
    33.         misc->minor = i;                                           
    34.     }   
    35.     /*设置位图中相应位为1*/  
    36.     if (misc->minor < DYNAMIC_MINORS)   
    37.         misc_minors[misc->minor >> 3] |= 1 << (misc->minor & 7);   
    38.     /*计算出设备号*/  
    39.     dev = MKDEV(MISC_MAJOR, misc->minor);   
    40.     /*在/dev下创建设备节点，这就是有些驱动程序没有显式调用device_create，却出现了设备节点的原因*/  
    41.     misc->this_device = device_create(misc_class, misc->parent, dev, NULL,   
    42.                       "%s", misc->name);   
    43.     if (IS_ERR(misc->this_device)) {   
    44.         err = PTR_ERR(misc->this_device);   
    45.         goto out;   
    46.     }   
    47.    
    48.     /*  
    49.      * Add it to the front, so that later devices can "override"  
    50.      * earlier defaults  
    51.      */   
    52.     /*将这个miscdevice添加到misc_list链表中*/  
    53.     list_add(&misc->list, &misc_list);   
    54.  out:   
    55.     mutex_unlock(&misc_mtx);   
    56.     return err;   
    57. }   

    这个是miscdevice的卸载函数：

    1. int misc_deregister(struct miscdevice *misc)   
    2. {   
    3.     int i = misc->minor;   
    4.    
    5.     if (list_empty(&misc->list))   
    6.         return -EINVAL;   
    7.    
    8.     mutex_lock(&misc_mtx);   
    9.     /*在misc_list链表中删除miscdevice设备*/  
    10.     list_del(&misc->list);     
    11.     /*删除设备节点*/                            
    12.     device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));             
    13.     if (i < DYNAMIC_MINORS && i>0) {  
    14.         /*释放位图相应位*/   
    15.         misc_minors[i>>3] &= ~(1 << (misc->minor & 7));   
    16.     }   
    17.     mutex_unlock(&misc_mtx);   
    18.     return 0;   
    19. }   

    总结一下miscdevice驱动的注册和卸载流程：

    misc_register:

    匹配次设备号->找到一个没有占用的次设备号(如果需要动态分配的话)->计算设号->创建设备文-

    miscdevice结构体添加到misc_list链表中。

    misc_deregister:

    从mist_list中删除miscdevice->删除设备文件->位图位清零。


jidonghui
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux块设备驱动的实现
Mini_sheep的专栏
06-05 851
以内存作为存储介质，在无队列模式下实现的一个简单块设备驱动程序，在最新的Linux3.3.7测试可用。 块设备驱动编写的主要过程： 1.注册块设备驱动 register_blkdev 可以申请获得主设备号； 2.设计自己设备对应的数据结构 代码里面的mybd_info结构，便于管理设备信息，这个数据机构里面的data，是通过vmalloc申请的一块内存，用于存放块设备的数据，这个数据结构
Linux设备驱动-中断
Leo-夜空的博客
08-13 538
由于中断服务程序的执行并不存在于进程上下文中，所以要求中断服务程序的时间要尽量短。因此，Linux在中断处理中引入了顶半部和底半部分离的机制。
linux内核源码分析之proc文件系统（二）
03-26 4162
proc文件系统的实例 先看一下在proc注册的目录 procfs_example，在此目录下建立了bar,foo,jiffies文件以及一个软连接jiffies_too (base) root@ubuntu:/proc/procfs_example# ls -l total 0 -r--r--r-- 1 root root 0 Mar 25 06:50 bar -r--r--r-- 1 root root 0 Mar 25 06:50 foo -r--r--r-- 1 root ro
（2.1）file_operation 实现设具体操作：概述与实现
Under the Pine
10-21 1327
/* AUTHOR: Pinus * Creat on : 2018-10-11 * KERNEL : linux-4.4.145 * BOARD : JZ2440(arm9 s3c2440) * REFS : 韦东山视频教程第二期 《LINUX内核源码情景分析》 */ 概述        Unix类系统将设备也看作是文件，通过操作文件的方式操作硬件。而操作文件的方式无非就是ope...
file_operation结构体详解
05-02 8233
file_operation结构体详解 2012/4/26 file_operation结构体详解 　　ile_operations结构体分析 　　结构体file_operations在头文件 linux/fs.h中定义，用来存储驱动内核模块提供的对 设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的事务的函数的地址。 　　举个例子，每个字符设备需
Linux字符设备驱动file_operations详解
bin__yan的博客
02-03 998
struct _file_operations struct _file_operations在Fs.h这个文件里面被定义的，如下所示： struct file_operations { 　　struct module *owner;//拥有该结构的模块的指针，一般为THIS_MODULES loff_t (*llseek) (struct file *, loff_t, int);//用来修改文件当前的读写位置 ssize_t (*read) (struct file *, char __user *,
在struct file_operations结构体中获取struct cdev，struct device以及自定义数据结构
ZLK1214的专栏
05-21 1094
在正点原子的linux驱动教程中，dev_t设备号、struct cdev、struct class、struct device等结构体都是存放在一个自定义结构体中的，并不是定义成全局变量。这个自定义结构体所占用的内存则是在probe函数中由kzalloc函数分配，例如： struct test_data { struct gpio_desc *gpios[4]; dev_t devid; u8 devid_valid; struct cdev cdev; struct class *clas
Linux常见驱动源码分析(kernel hacker修炼之道全集)--李万鹏
07-03
kernel hacker修炼之道之驱动-混杂设备.pdf kernel hacker修炼之道之驱动-按键.pdf kernel hacker修炼之道之PCI subsystem(五).pdf kernel hacker修炼之道之PCI subsystem(四).pdf kernel hacker修炼之...
Linux混杂设备驱动（watchdog）
08-19
Linux混杂设备驱动，也称为Misc驱动，是一种用于简化简单字符设备驱动程序初始化的方法。它主要针对具有共同特性的设备，这些特性被内核抽象成API，这些API在`drivers/char/misc.c`中实现。混杂设备共享同一个主设备...
linux混杂设备驱动讲解
04-29
该文档主要讲述了linux混杂设备的驱动编程。混杂设备可以理解为一种主设备号固定为10的一种字符设备。但是编程的过程要比字符设备简单很多。可以达到和字符设备一样的效果。有兴趣可以了解一下。
混杂字符设备之LED设备驱动设计
08-10
混杂字符设备是一种特殊的Linux设备模型，主要用于那些不完全符合标准字符设备模型或者需要特殊处理的设备。在Linux内核中，它们通过主设备号10进行标识，并且通过次设备号来区分不同的混杂设备。设备驱动设计时，...
linux混杂设备
07-30
本文档主要是本人在工作中对于混杂设备的一些总结及个人见解，从中分析了应该如何应用混杂设备，并且比较了linux2.6和linux3.0版本在混杂设备上的区别，方便移植linux2.6驱动到linux3.0版本上。
linux驱动 seq_file学习测试实例
海月汐辰
06-19 495
linux驱动 seq_file学习测试实例 一、从内核中导出信息到用户空间有很多方法，可以自己去实现file_operations的read函数或者mmap函数，但是这种方法不够简单，而且也会有一些限制，比如一次read读取大于1页时，驱动里就不得不去进行复杂的缓冲区管理。为此，就需要学习一下seq_file的用法，为了更简单和方...
linux驱动file_operations结构体的ioctl函数
目前从事linux驱动开发，多交流多学习吧
09-18 934
最近太忙了，一直没有更新博客，虽然是个搬运工，但是写博客是督促自己学习的一个过程，当然了也希望能够帮助到更多的人。话不多说了下面讲一下file_operations结构体的ioctl函数的坑。顺便写file_operations结构体的ioctl函数的一些分析。 ...
Linux中的File_operations结构体
O1O1O1o的专栏
08-19 4948
 Linux中的File_operations结构体2008-07-07 12:34File_operations结构体       file_operation就是把系统调用和驱动程序关联起来的关键数据结构。这个结构的每一个成员都对应着一个系统调用。读取file_operation中相应的函数指针，接着把控制权转交给函数，从而完成了Linux设备驱动程序的工作
关于file_operations结构体
feiyangyangfei的专栏
03-22 786
结构体file_operations在头文件 linux/fs.h中定义，用来存储驱动内核模块提供的对设备进行各种操作的函数的指针。该结构体的每个域都对应着驱动内核模块用来处理某个被请求的 事务的函数的地址。 举个例子，每个字符设备需要定义一个用来读取设备数据的函数。结构体 file_operations中存储着内核模块中执行这项操作的函数的地址。一下是该结构体 在内核2.6.5中看起来的样子：
static struct file_operations结构体介绍(转)
weixiuc的专栏
09-17 7871
1、 驱动与内核接口层　　驱动与内核接口层主要完成驱动模块在Linux内核的注册加载、卸载清除工作。这部分工作分别由初始化和退出函数完成。　　① 初始化函数完成驱动模块加载：static int __init DS18B20_init(void){　　……　　register_chrdev(DS18B20_MAJOR,DEVICE_NAME, &DS18B20_fops);//完成设备注册　　#i
ioctl与unlocked_ioctl区别
热门推荐
cbl709的专栏
02-26 3万+
今天调一个程序调了半天，发现应用程序的ioctl的cmd参数传送到驱动程序的ioctl发生改变。而根据《linux设备驱动》这个cmd应该是不变的。因为在kernel 2.6.36 中已经完全删除了struct file_operations 中的ioctl 函数指针，取而代之的是unlocked_ioctl ，所以我怀疑二者是不是兼容的。上网查了一些资料，很多文章只是泛泛谈了一下，说在应用程
Linux：Linux发展史
最新发布
weixin_51142926的博客
07-22 4355
大家好！此篇文章并非技术博文，而是简单了解Linux的时代背景和发展史，只有知其所以然才能让我们更好地让走进Liunx的世界！
ARM嵌入式Linux：设备分类与驱动开发基础
首先，它强调了在Linux 2.6.39内核的ARM架构下进行设备驱动的开发，着重介绍了设备分类的四种方法： 1. 基本设备分类：将设备分为字符设备（如UART、PWM）和块设备（如硬盘、内存）两大类，它们分别以"c"和"b"开头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值