linux驅動修煉之道-混雜設備

Linux驅動中把無法歸類的五花八門的設備定義爲混雜設備(用miscdevice結構體表述)。miscdevice共享一個主設備號MISC_MAJOR(即10)，但次設備號不同。 所有的miscdevice設備形成了一個鏈表，對設備訪問時內核根據次設備號查找對應的miscdevice設備，然後調用其file_operations結構中註冊的文件操作接口進行操作。 在內核中用struct miscdevice表示miscdevice設備，然後調用其file_operations結構中註冊的文件操作接口進行操作。miscdevice的API實現在drivers/char/misc.c中。

下邊是描述這個設備的結構體：

struct miscdevice  {
    int minor;                               //次設備號
    const char *name;                        //設備的名稱
    const struct file_operations *fops;     //文件操作
    struct list_head list;                  //misc_list的鏈表頭
    struct device *parent;                  //父設備(Linux設備模型中的東東了，哈哈)
    struct device *this_device;             //當前設備，是device_create的返回值，下邊會看到
};

然後來看看misc子系統的初始化函數：

static int __init misc_init(void)
{
    int err;

#ifdef CONFIG_PROC_FS
    /*創建一個proc入口項*/
    proc_create("misc", 0, NULL, &misc_proc_fops);
#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_destroy(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->major;
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,   
};   
可以看到這裏只有一個打開函數，用戶打開miscdevice設備是通過主設備號對應的打開函數，在這個函數中找到次設備號對應的相應的具體設備的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, *new_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 err;
}
再來看看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 dynamic majors */
         *static unsigned char misc_minors[DYNAMIC_MINORS / 8];
         *這裏存在一個次設備號的位圖，一共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->刪除設備文件->位圖位清零。
static const struct file_operations misc_fops = {
    .owner      = THIS_MODULE,
    .open       = misc_open,
};