27 miscdevice设备驱动应用及实现原理

miscdevice是字符设备驱动的简化版本，方便实现一个简单的字符设备驱动.
//只适用于没有同类型的设备驱动. 也就是一个驱动只对应一个硬件.

#include <linux/miscdevice.h>

struct miscdevice  {
    int minor; //指定次设备号，次设备号为255则会自分配空闲的次设备号. 主设备号已固定为10.
           //次设备号在(0~255)之间.
    const char *name; //名字， 指定的名字也是设备文件的名字.设备文件会在注册时自动创建
    const struct file_operations *fops; //文件操作对象的地址
    ...
};

extern int misc_register(struct miscdevice * misc); //注册miscdevice对象
extern int misc_deregister(struct miscdevice *misc);//反注册

测试代码, test.c:

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>

ssize_t myread(struct file *fl, char __user *buf, size_t len, loff_t *off)
{
    printk("in myread ...\n");
    return 0;
}

struct file_operations fops = {
    .read = myread,
};

struct miscdevice mymdev = {
    .minor = MISC_DYNAMIC_MINOR, // 255
    .name = "mymdev",
    .fops = &fops,
};

static int __init test_init(void)
{
    return misc_register(&mymdev);
}

static void __exit test_exit(void)
{
    misc_deregister(&mymdev);
}

module_init(test_init);
module_exit(test_exit);

MODULE_LICENSE("GPL");

//编译加载驱动后，设备文件会自动创建.
// miscdevice设备驱动实现起来比较简单，但无法实现一个设备驱动支持多个同类的设备.因miscdevice只能指定一个次设备号, 也就一个设备号。同类的设备是由不同的次设备号区分开的。所以miscdevice只适用于只有一个设备的设备驱动,例如: RTC, 看门狗.

//
miscdevice的工作原理.

首先可修改file对象的f_op指针，指向另一个file_operations对象的地址。修改后，新的file_operations对象里的操作函数会得到调用.
测试代码：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>

#define MYMA 4095

ssize_t myread2(struct file *fl, char __user *buf, size_t len, loff_t *off)
{
    printk("in myread2 ...\n");
    return 0;
}

struct file_operations fops2 = {
    .read = myread2,
};

int myopen(struct inod *ind, struct file *fl)
{
    fl->f_op = &fops2; //在open函数里修改file对象的f_op成员，指向fops2对象的地址.
               //当read函数调用时，则fops2对象的read函数会得到调用.
    return 0;
}

ssize_t myread(struct file *fl, char __user *buf, size_t len, loff_t *off)
{
    printk("in myread ...\n");
    return 0;
}

struct file_operations  fops = {
    .open = myopen,
    .read = myread,
};

static int __init test_init(void)
{
    int ret;

    ret = register_chrdev(MYMA, "mydev", &fops);
    return ret;
}

static void __exit test_exit(void)
{
    unregister_chrdev(MYMA, "mydev");
}

miscdevice设备驱动的实现原理:
在内核源码drivers/char/misc.c文件里:

static int __init misc_init(void)
{
    int err;
    ...
    misc_class = class_create(THIS_MODULE, "misc");//创建/sys/class/misc子目录,稍后创建设备信息用.
    ...
    if (register_chrdev(MISC_MAJOR,"misc",&misc_fops)) //当主设备号为10，次设备号(0~255)的所有设备文件打开操作时，会调用misc_fops对象里的open函数.
        goto fail_printk;
    ...
}
subsys_initcall(misc_init); //会在内核子系统初始化自动调用misc_init函数.

///
当我们实现miscdevice设备驱动时，初始化一个miscdevice对象, 调用misc_register(对象的地址)注册.
misc_list是在misc.c文件里的一个全局内核链表头, 用于通过miscdevice对象的list成员，存放所有的miscdevice对象.

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

    INIT_LIST_HEAD(&misc->list);

    mutex_lock(&misc_mtx);
    //遍历链表，确认指定次设备号是否已用.
    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) {
    //当需要动态分配空闲的次设备号时的操作
    ...
    }

    //创建设备文件
    dev = MKDEV(MISC_MAJOR, misc->minor);
    misc->this_device = device_create(misc_class, misc->parent, dev,
                      misc, "%s", misc->name);

    list_add(&misc->list, &misc_list); //通过list成员，把miscdevice对象加入misc_list链表.
                    //也可以在misc_list链表里根据次设备号找到相应的miscdevice对象
 out:
    mutex_unlock(&misc_mtx);
    return err;
}

//

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

//当主设备号为10，次设备号(0~255)的所有设备文件打开操作时，会调用misc_fops对象里的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;

    mutex_lock(&misc_mtx);
    //遍历misc_list链表, 根据次设备号minor找到对应的miscdevice对象
    list_for_each_entry(c, &misc_list, list) {
        if (c->minor == minor) {
            new_fops = fops_get(c->fops); //找到后，则用new_fops指定存放miscdevice对象的fops成员存放file_operations对象的地址. 也就是我们自己miscdevice设备驱动里实现file_operatins对象的地址
            break;
        }
    }


    err = 0;
    old_fops = file->f_op;
    file->f_op = new_fops; //把file对象的f_op成员指向我们的file_operations对象的地址, 以后我们的file_operations里实现的函数就会得到调用.

    //如果我们实现的file_operations对象里有open函数，则调用
    if (file->f_op->open) {
        file->private_data = c;
        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);
    return err;
}