前言

在linux驱动中，需要提供主设备号和次设备号号，通常使用的主设备号是从
0到 255之间的数，仅仅使用主设备号，还是不叫紧张的，因此需要利用次设备号。

linux中，提供了miscdevice这种杂项设备，指定主设备号为10，次设备号可以设置为
系统动态分配。

在具体分析miscdevice之前，先给出miscdevice的核心设计思想。

应用层，打开/dev/xxx 节点，会得到 文件描述符 fd，通过fd,可以执行 read()、
wriete()、ioctl()、mmap()等对这个文件的操作。

应用层调用 open()函数，经过系统调用后，会调用驱动程序的 open()函数。 在前边分析
调用过程时，分析过这个open()的调用过程。

驱动程序中，调用file_opeartions的open()的时候，此时，调用到另外一个 file_operations的
open()，此时应用层会得到这个open()时的 文件描述符fd,此时应用层 read()、write()等操作，
就调用到了这个file_operations。故在cdev_init时的 fops 充当一个中转的作用，转到具体的
fops 来操作。

给出在linux驱动开发之字符设备–自动创建设备节点
代码上的一个 diff

@@ -134,6 +135,19 @@ static struct file_operations fops ={
     .unlocked_ioctl = cdev_demo_ioctl,
 };

+static int misc_open(struct inode * inode, struct file * file)
+{
+    printk("%s,%d\n",__func__,__LINE__);
+   
+   file->f_op = &fops;
+   return file->f_op->open(inode,file) ;
+}
+
+static struct file_operations misc_fops = {
+   .owner = THIS_MODULE;
+   .open = misc_open,
+};
+
 char cdev_buf[2] = "a";

 static ssize_t cdev_demo_show(struct device *dev,struct device_attribute *attr,    char *buf)  
@@ -171,7 +185,7 @@ static int __init cdev_demo_init(void)
         return -ENOMEM;
     }

-    cdev_init(pdev,&fops);
+    cdev_init(pdev,&misc_fops);

     ret = alloc_chrdev_region(&dev,minor,count,DEVICE_NAME);
     if(ret){

关键的代码是

    file->f_op = &fops;
    return file->f_op->open(inode,file) ;

将变量 fops 赋值给了 file 的 f_op (const struct file_operations *f_op;)

在返回的时候，调用这个file->f_op-open，其实质是调用到 fops的open()。

这样的一种方式，实现了 中转的作用。 利用这种中转，可以进行代码的分层，在通用层中
实现抽象的open(),在具体的设备中，实现具体的open()、read()、write()。

miscdevice分析

miscdevice 结构体

struct miscdevice  {
    int minor;            //次设备号  通常为MISC_DYNAMIC_MINOR  动态分配
    const char *name;     //设备为的名字
    const struct file_operations *fops;//函数操作集
    struct list_head list;
    struct device *parent;
    struct device *this_device;
    const char *nodename;
    umode_t mode;
};

通常 miscdevice的 minor 、name 和 fops是需要实现的。

int misc_register(struct miscdevice * misc)

misc 注册函数，成功返回0 ，失败返回负数

int misc_deregister(struct miscdevice *misc)

misc 注销函数，成功返回0 ，失败返回负数

/*
 * Head entry for the doubly linked miscdevice list
 */
static LIST_HEAD(misc_list);
static DEFINE_MUTEX(misc_mtx);

/*
 * Assigned numbers, used for dynamic minors
 */
#define DYNAMIC_MINORS 64 /* like dynamic majors */
static DECLARE_BITMAP(misc_minors, DYNAMIC_MINORS);
static int misc_open(struct inode * inode, struct file * file)
{
    //取出次设备号
    int minor = iminor(inode);
    struct miscdevice *c;
    int err = -ENODEV;
    const struct file_operations *old_fops, *new_fops = NULL;

    mutex_lock(&misc_mtx);
    //misc_list中，取出具体设备的misc_device来，得到fops
    list_for_each_entry(c, &misc_list, list) {
        if (c->minor == minor) {
            new_fops = fops_get(c->fops);       
            break;
        }
    }

    if (!new_fops) {
        mutex_unlock(&misc_mtx);
        request_module("char-major-%d-%d", MISC_MAJOR, minor);
        mutex_lock(&misc_mtx);

        list_for_each_entry(c, &misc_list, list) {
            if (c->minor == minor) {    
                new_fops = fops_get(c->fops);
                break;
            }
        }
        if (!new_fops)
            goto fail;
    }

    err = 0;
    //保存原有的fops
    old_fops = file->f_op;
    //赋值新的fops
    file->f_op = new_fops;
    //如果设备实现了open函数
    if (file->f_op->open) {


        /*
         * FIXME: this is a workaround for pmem
         * PMEM need private_data to be NULL for an unmapped file.
         * The private_data is used to store PMEM internal data strucutre.
         * Leakage may happen if we just override this field in pmem_open function
         */
        if (strcmp(c->name, "pmem_multimedia") != 0 && strcmp(c->name, "vmem_multimedia") != 0)
            file->private_data = c;

        //调用open函数
        err=file->f_op->open(inode,file);
        if (err) {
            //调用失败，恢复fops为保存old_fops
            fops_put(file->f_op);
            file->f_op = fops_get(old_fops);
        }
    }
    fops_put(old_fops);
fail:
    mutex_unlock(&misc_mtx);
    return err;
}

static struct class *misc_class;

static const struct file_operations misc_fops = {
    .owner      = THIS_MODULE,
    .open       = misc_open,
    .llseek     = noop_llseek,
};

/**
 *  misc_register   -   register a miscellaneous device
 *  @misc: device structure
 *  
 *  Register a miscellaneous device with the kernel. If the minor
 *  number is set to %MISC_DYNAMIC_MINOR a minor number is assigned
 *  and placed in the minor field of the structure. For other cases
 *  the minor number requested is used.
 *
 *  The structure passed is linked into the kernel and may not be
 *  destroyed until it has been unregistered.
 *
 *  A zero is returned on success and a negative errno code for
 *  failure.
 */

int misc_register(struct miscdevice * misc)
{
    dev_t dev;
    int err = 0;

    INIT_LIST_HEAD(&misc->list);

    mutex_lock(&misc_mtx);
    //动态分配次设备号
    if (misc->minor == MISC_DYNAMIC_MINOR) {
        //从位图中，从 misc_minors 开始，查找最小的 zero位，做多查找64次
        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);
    } else {
        //指定次设备号
        struct miscdevice *c;
        //从 misc_list中，查看是否制定的这个 minor是否已经注册 
        list_for_each_entry(c, &misc_list, list) {
            if (c->minor == misc->minor) {
                mutex_unlock(&misc_mtx);
                return -EBUSY;
            }
        }
    }
    //使用MKDEV创建设备号
    dev = MKDEV(MISC_MAJOR, misc->minor);
    //创建设备
    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_list的头部
    list_add(&misc->list, &misc_list);
 out:
    mutex_unlock(&misc_mtx);
    return err;
}

/**
 *  misc_deregister - unregister a miscellaneous device
 *  @misc: device to unregister
 *
 *  Unregister a miscellaneous device that was previously
 *  successfully registered with misc_register(). Success
 *  is indicated by a zero return, a negative errno code
 *  indicates an error.
 */

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);
    //删除链表 misc->list,相当于同时在misc_list 中删除了这个 misc
    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;
}

EXPORT_SYMBOL(misc_register);
EXPORT_SYMBOL(misc_deregister);

static char *misc_devnode(struct device *dev, umode_t *mode)
{
    struct miscdevice *c = dev_get_drvdata(dev);

    if (mode && c->mode)
        *mode = c->mode;
    if (c->nodename)
        return kstrdup(c->nodename, GFP_KERNEL);
    return NULL;
}

static int __init misc_init(void)
{
    int err;
//创建proc 文件系统
#ifdef CONFIG_PROC_FS
    proc_create("misc", 0, NULL, &misc_proc_fops);
#endif
    misc_class = class_create(THIS_MODULE, "misc");
    err = PTR_ERR(misc_class);
    if (IS_ERR(misc_class))
        goto fail_remove;

    err = -EIO;
    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;
}
subsys_initcall(misc_init);

1.利用链表，进行存储具体的设备
2.使用open时的中转功能
3.通用层: miscdevice，提供结构体、创建类，提供创建设备的核心函数
具体设备层: 填充结构题，实现具体功能； 利用提供的核心函数实现注册设备 。

参考文献

linux驱动开发之字符设备框架 -调用过程分析