在Linux系统中，存在一类字符设备，他们共享一个主设备号（10），但此设备号不同，我们称这类设备为混杂设备（miscdeivce），查看/proc/device中可以看到一个名为misc的主设备号为10.所有的混杂设备形成一个链表，对设备访问时内核根据次设备号找到对应的miscdevice设备。相对于普通字符设备驱动，它不需要自己去生成设备文件。

Linux内核使用struct miscdeivce来描述一个混杂设备

struct miscdevice  {

    int minor;

    const char *name;

    const struct file_operations *fops;

    struct list_head list;

    struct device *parent;

    struct device *this_device;

    const char *nodename;

    mode_t mode;

};

scull 设备驱动只实现最重要的设备方法. 它的 file_operations 结构是如下初始化的:

struct file_operations scull_fops = {
     .owner =  THIS_MODULE, 
     .llseek =  scull_llseek, 
     .read =  scull_read, 
     .write =  scull_write, 
     .ioctl =  scull_ioctl, 
     .open =  scull_open, 
     .release =  scull_release,  
   };  

minor是这个混杂设备的次设备号，若由系统自动配置，则可以设置为MISC_DYNANIC_MINOR，name是设备名.使用时只需填写minor次设备号，*name设备名，*fops文件操作函数集即可。

Linux内核使用misc_register函数注册一个混杂设备，使用misc_deregister移除一个混杂设备。注册成功后，linux内核为自动为该设备创建设备节点，在/dev/下会产生相应的节点。

 注册函数：

int misc_register(struct miscdevice * misc)

输入参数：struct miscdevice

返回值：

0   表示注册成功。

负数 表示未成功。

卸载函数：

int  misc_deregister(struct miscdevice *misc)

0  表示成功。

负数 表示失败。

在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是操作函数的集合；包含了open方法*/   
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. }