字符设备驱动模型浅析

admin

在linux系统中，很多驱动是字符型驱动，有些是直接编译集成在内核中，另一些是单独编译成“。ko”动态加载的。其实字符驱动只是个外壳，用于内核与应用程序间通信，无非是调用open，release，read，write和ioctl等例程。所以根据应用不同，字符驱动能会调用其他驱动模块，如i2c、spi和v4l2等，于是字符驱动还可分WDT驱动、RTC驱动和MTD驱动等。所以在分析其他驱动模块之前有必要好好分析下字符设备驱动模型。本篇文章要讲的就是字符设备驱动模型，也就是字符设备驱动是怎么注册和注销的，怎么生成设备节点的，怎么和应用程序关联的，例程调用具体如何实现的等等。
       
        一、字符设备驱动的注册和注销
       
        对于写过linux-2.6内核（本文采用linux-2.6.18内核）字符驱动的程序员来说，对下面这段程序的形式肯定不陌生。int result；
       
        /*
       
        * Register the driver in the kernel
       
        * Dynmically get the major number for the driver using
       
        * alloc_chrdev_region function
       
        */
       
        result = alloc_chrdev_region（ 0， 1，“testchar”）；
       
        /* if it fails return error */
       
        if （result dev = 1；
       
        base->range = ~0； /*初始的范围很大*/
       
        base->get = base_probe； /*保存函数指针*/
       
        for （i = 0； i probes = base； /*所有指针都指向同一个base */
       
        p->lock = lock；
       
        return p；
       
        }.
       
        复制代码该函数只是分配了一个结构体struct kobj_map，并做了初始化，保存了函数指针base_probe和全局锁lock。
       
        下面就按照驱动注册流程一个个解析这些例程调用吧。首先是alloc_chrdev_region（）函数，解析它之前，先看看结构体（定义了255个结构体指针），static struct char_device_struct {
       
        /*被255整除后相同的设备号链成一个单向链表*/
       
        struct char_device_struct *next；
       
        unsigned int major； /*主设备号*/
       
        unsigned int baseminor； /*次设备起始号*/
       
        int minorct； /*次设备号范围*/
       
        char name[64]； /*驱动的名字*/
       
        struct file_operations *fops； /*保存文件操作指针，目前没有使用*/
       
        struct cdev *cdev； /* will die */ /*目前没有使用*/
       
        } *chrdevs[CHRDEV_MAJOR_HASH_SIZE]； /* CHRDEV_MAJOR_HASH_SIZE = 255 */
       
        复制代码它的作用仅仅是用于注册字符设备驱动，保存已经注册字符驱动的一些信息，如主次设备号，次设备号的数量，驱动的名字等，便于字符设备驱动注册时索引查找。
         
        alloc_chrdev_region（）函数很简单，通过调用__register_chrdev_region（）来实现，通过英语注释你也可以明白，这个函数有两个作用，一是，如果主设备号为0，则分配一个最近的主设备号，返回给调用者；二是，如果主设备号不为0，则占用好该主设备号对应的位置，返回给调用者。如下，static struct char_device_struct *
       
        __register_chrdev_region（unsigned int major， unsigned int baseminor，
       
        int minorct， const char *name）
       
        {
       
        struct char_device_struct *cd， **cp；
       
        int ret = 0；
       
        int i；
       
        cd = kzalloc（sizeof（struct char_device_struct）， GFP_KERNEL）；
       
        if （cd == NULL）
       
        return ERR_PTR（-ENOMEM）；
       
        mutex_lock（ /*这下看到了吧，加锁，就允许你一个人进来*/
       
        /* temporary */
       
        if （major == 0） { /*如果主设备号为零，则找一个最近空闲的号码分配*/
       
        for （i = ARRAY_SIZE（chrdevs）-1； i > 0； i——） {
       
        if （chrdevs == NULL）
       
        break；
       
        }
       
        if （i == 0） {
       
        ret = -EBUSY；
       
        goto out；
       
        }
       
        major = i；
       
        ret = major；
       
        }
       
        /*这些不用说你懂的*/
       
        cd->major = major；
       
        cd->baseminor = baseminor；
       
        cd->minorct = minorct；
       
        strncpy（cd->name，name， 64）；
       
        i = major_to_index（major）；
       
        /*如果主设备号不为0，则占用好该主设备号对应的位置*/
       
        for （cp = *cp； cp =
       
        if （（*cp）->major > major ||
       
        （（*cp）->major == major （*cp）->baseminor >= baseminor））
       
        break；
       
        if （*cp （*cp）->major == major
       
        （*cp）->baseminor next = *cp；
       
        *cp = cd；
       
        mutex_unlock（ /*开锁，队列里的下一个人可以进来了*/
       
        return cd；
       
        out：
       
        mutex_unlock（
       
        kfree（cd）；
       
        return ERR_PTR（ret）；
       
        }
       
        复制代码接着是cdev_init（）函数，先说说cdev的结构体，struct cdev {
       
        struct kobject kobj； /*不多解释了，看看鄙人前面写的文章吧*/
       
        struct module *owner； /*模块锁定和加载时用得着*/
       
        const struct file_operations *ops； /*保存文件操作例程结构体*/
       
        struct list_head list； /* open时，会将其inode加到该链表中，方便判别是否空闲*/
       
        dev_t dev； /*设备号*/
       
        unsigned int count；
       
        }；
       
        复制代码cdev结构体把字符设备驱动和文件系统相关联，后面解析字符设备驱动怎样运行的时候会详谈。
       
        cdev_init（）函数如下，void cdev_init（struct cdev *cdev， const struct file_operations *fops）
       
        {
       
        memset（cdev， 0， sizeof *cdev）；
       
        INIT_LIST_HEAD（
       
        cdev->kobj.ktype = /*卸载驱动时会用到，别急，后面详讲*/
       
        kobject_init（
       
        cdev->ops = fops； /*用户写的字符设备驱动fops就保存在这了*/
       
        }.
       
        复制代码你也看到了，该函数就是对变量做了初始化，关于kobject的解析，建议你看看鄙人博客上写的《Linux设备模型浅析之设备篇》和《Linux设备模型浅析之驱动篇》两篇文章，这里就不详谈了。
       
        用户的fops，在本文中是test_fops，一般形式是这样的，
       
        static const struct file_operations test_fops = {
       
        。owner = THIS_MODULE，
       
        。open = test_fops_open，
       
        。release = test_fops_release，
       
        。ioctl = test_fops_ioctl，
       
        。read = test_fops_read，
       
        。write = test_fops_write，
       
        }；
       
        复制代码
       
        接着又调用了函数cdev_add（），这个函数又调用了kobj_map（）函数，其作用就是分配一个struct probe结构体，填充该结构体中的变量并将其加入到全局的cdev_map中，说白了，就是分个一亩三分田给该字符设备驱动，并做好标记，放到主设备号对应的地方，等主人下次来找的时候能找到（使用kobj_lookup（）函数，后面会讲到）。该函数是这样的，int kobj_map（struct kobj_map *domain， dev_t dev， unsigned long range，
       
        struct module *module， kobj_probe_t *probe，
       
        int （*lock）（dev_t， void *）， void *data）
       
        {
       
        unsigned n = MAJOR（dev + range - 1） - MAJOR（dev） + 1；
       
        unsigned index = MAJOR（dev）；
       
        unsigned i；
       
        struct probe *p；
       
        if （n > 255）
       
        n = 255；
       
        /*分配了一亩三分田*/
       
        p = kmalloc（sizeof（struct probe） * n， GFP_KERNEL）；
       
        if （p == NULL）
       
        return -ENOMEM；
       
        /*填充些私有的东西*/
       
        for （i = 0； i owner = module；
       
        p->get = probe； /*是exact_match （）函数，获取cdev结构体的kobject指针*/
       
        p->lock = lock； /*是exact_lock（）函数，增加引用*/
       
        p->dev = dev；
       
        p->range = range；
       
        p->data = data； /* cdev保存到p->data中*/
       
        }
       
        mutex_lock（domain->lock）；
       
        /*将这一亩三分田加到主设备号对应的位置上去*/
       
        for （i = 0， p -= n； i probes[index % 255]；
       
        while （*s （*s）->range next；
       
        p->next = *s；
       
        *s = p；
       
        }
       
        mutex_unlock（domain->lock）；
       
        return 0；
       
        }
       
        复制代码接下来有class_create（）函数和class_device_create（）函数，前者生成一个名字为"testchar"的class，后者作用就是在/dev目录下生成设备节点，当然，需要uevent和UDEVD的支持，具体可见鄙人博客上的文章《Linux设备模型浅析之uevent篇》。
       
        顺带说下register_chrdev（）函数，其也是注册字符设备驱动，只不过是封装好的，包含了所有前面讲的注册步骤——分配一个设备号，由一个主设备号和255个次设备号组成。如下，int register_chrdev（unsigned int major， const char *name，
       
        const struct file_operations *fops）
       
        {
       
        struct char_device_struct *cd；
       
        struct cdev *cdev；
       
        char *s；
       
        int err = -ENOMEM；
       
        cd = __register_chrdev_region（major， 0， 256， name）；
       
        if （IS_ERR（cd））
       
        return PTR_ERR（cd）；
       
        cdev = cdev_alloc（）； /*这个有点不一样，动态分配的，不是调用者提供*/
       
        if （！cdev）
       
        goto out2；
       
        cdev->owner = fops->owner；
       
        cdev->ops = fops；
       
        kobject_set_name（ "%s"， name）；
       
        for （s = strchr（kobject_name（ s； s = strchr（s， '/'））
       
        *s = '！'；
       
        err = cdev_add（cdev， MKDEV（cd->major， 0）， 256）；
       
        if （err）
       
        goto out；
       
        cd->cdev = cdev；
       
        return major ？ 0 ： cd->major；
       
        out：
       
        kobject_put（
       
        out2：
       
        kfree（__unregister_chrdev_region（cd->major， 0， 256））；
       
        return err；
       
        }