个人学习笔记------Linux内核杂项设备

混杂设备是在字符设备之上的一层，它们拥有部分相同的特性。内核中，则将这些共同的特性抽象至一个API中，简化了这些杂项设备驱动程序的初始化方式。下面，我们来看看字符设备驱动的初始化过程：

（1）alloc_chrdev_region分配主/次设备号

（2）device_create()创建/dev和/sys节点

（3）cdev_init()和cdev_add()注册成为字符驱动程序

混杂设备只要调用misc_register即可完成以上的操作

miscdevice共享一个主设备号MISC_MAJOR(即设备号为10)，但是次设备号不同。所有的miscdevice设备形成了一个链表，对设备访问时内核根据次设备号查找对应的miscdevice设备，然后调用其file_operations结构中注册的文件操作接口进行操作。在内核中用struct miscdevice表示miscdevicd设备，然后调用其file_operations结构中注册的文件操作接口进行操作。miscdevice的API实现在drivers/char/misc.c中。struct miscdevice结构体如下：

struct miscdevice{
	int minor;		//次设备号
	const char *name;		//设备名称
	const struct file_operations *fops;		//文件操作
	struct list_head list;		//misc_list链表头
	struct device *parent;		//父设备
	struct device *this_device;		//当前设备，device_create的返回值
};

下面是misc子系统初始化函数：

struct int __init misc_init(void)
{
	int err;

#ifdef CONFIG_PROC_FS
	/*创建一个proc入口项*/
#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_MAJOR,为10.设备名为misc,misc_fops是操作函数的集合*/
	if(register_chrdev(MISC_MAJOR, "misc", &misc_fops))
		goto fail_printk;
	return 0;

fail_printk:
	printk("unable to get major %d for misc devices\n", MISC_MAJOR);
	class_destory(misc_class);
fail_remove:
	remove_proc_entry("misc", NULL);
	return err;
}

/*misc作为一个子系统被注册到Linux内核中*/
subsys_initcall(misc_init);

下面是register_chrdev函数的实现：

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;
	/*主设备号是10，次设备号为从0开始，分配256个设备*/
	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;
	/*Linux设备模型中的，设置kobject的名字*/
	kobject_set_name(&cdev->kobj, "%s", name);
	for(s = strchr(kobject_name(&cdev->kobj), '/'); 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->cdev;
out:
	kobject_put(&cdev->kobj);
out2:
	kfree(__unregister_chrdev_region(cd->major, 0, 256));
	return err;
}

下面来看看这个设备的操作函数的集合：

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

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

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, *news_fops = NULL;

    lock_kernel();
    mutex_lock(&misc_mtx);
    /*找到次设备号对应的操作函数集合，让new_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);
        /*重新遍历misc_list链表，如果没有找到就退出，否则让new_fops指向这个具体设备的操作函数集合*/
        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;
    /*保存旧打开函数的地址*/
    old_fops = file->f_op;
    /*让主设备号的操作函数集合指向具体设备的操作函数集合*/
    file->f_op = new_fops;
    if(file->f_op->open){
    /*使用具体设备的打开函数打开设备*/
        err = file->f_op->open(inode, file);
        if(err){
            fops_put(file->f_op);
            file->f_op = fops_get(old_fops);
        }
    }
    fops_put(old_fops);
fail:
    mutex_unlock(&misc_mtx);
    unlock_kernel();

    return ret;
}

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

int misc_register(struct miscdevice *misc)
{
    struct miscdevice *c;
    dev_t dev;
    int err = 0;
    /*初始化misc_list链表*/
    INIT_LIST_HEAD(&misc->list);
    mutex_lock(&misc_mtx);
    /*遍历misc_list链表，看这个次设备号以前有没有被用过，如果次设备号被占用则退出*/
    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){
        /*
            #define DYNAMIC_MINORS 64 //like dyanamic majors
            这里存在一个次设备号的位图，一共64位。下边是遍历每一位
            如果这个位为0，表示没有被占用，可以使用，为1表示被占用
        */
        int i = DYNAMIC_MINORS;
        while(--i >= 0)
            if((misc_minors[i>>3]&(1<<(i&7))) == 0)
                break;    
        if(i<0){
            mutex_unlock(&misc_mtx);
            return -EBUSY;
        }
        /*得到这个设备号*/
        misc->minor = i;
    }
    /*设置位图中相应位为1*/
    if(misc->minor < DYNAMIC_MINORS)
        misc_minors[misc->minor >> 3] |= 1 << (misc->minor&7);
    /*计算出设备号*/
    dev = MKDEV(MISC_MAJOR, misc->minor);
    /*在/dev下创建设备节点，这就是有些驱动程序没有显示式调用device_create，却出现了设备节点的原因*/
    misc->this_device = device_create(misc_class, misc->parent, dev, NULL, "%s", misc->name);
    if(IS_ERR(misc->this_device)){
        err = PTR_ERR(misc->this_device);
        goto out;
    }

    /*
        Add it to the front, so that later devices can "override"
        earlier defaults
    */
    /*将这个miscdevice添加到misc_list链表中*/
    list_add(&misc->list, &misc_list);
out:
    mutex_unlock(&misc_mtx);
    return err;
}

下面是miscdevice的卸载函数：

int misc_deregister(struct miscdevice *misc)
{
	int i = misc->minor;

	if(list_empty(&misc->list))
		return -EINVAL;

	mutex_lock(&misc_mtx);
	/*在misc_list链表中删除miscdevice设备*/
	list_del(&misc->list);
	/*删除设备节点*/
	device_destroy(misc_class, MKDEV(MISC_MAJOR, misc->minor));
	if(i<DYNAMIC_MINORS && i>0){
		/*释放位图相应位*/
		misc_minors[i>>3]&=~(1<<(misc->minor&7));
	}
	mutex_unlock(&misc_mtx);
	return 0;
}

总结：

miscdevice注册流程

misc_register:匹配次设备号->找到一个没有占用的次设备号(如果需要动态分配的话)->计算设备号->创建设备文件->miscdevice结构体添加到misc_list链表中。

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