输入子系统(一)字符设备驱动框架分析

很多分析输入子系统的文章已经讲得很清楚了，这里主要是记录自己的学习过程。参考的几篇文章：

输入子系统学习笔记之按键实例编程

输入子系统学习笔记之源码分析1_框架性分析

输入子系统学习笔记之源码分析2＿数据结构分析

输入子系统学习笔记之源码分析3_流程分析

输入子系统也是字符设备驱动，也遵循字符设备驱动的流程：

a. 分配主设备号

b. 构建file_operations结构体中的open,write,read...等函数

c. 调用register_chrdev()函数注册字符设备

d. 调用class_register()注册类

e. 调用device_create()创建设备，linux会在sysfs目录下自动创建字符设备。

以上的步骤同样适用于分析输入子系统，只不过上面的各个步骤可能分散在不同的文件与函数中完成。

1. input.c中的函数input_init()完成上述a,b,c,d四步。

/*
*b. 构建file_operations结构体,只实现了open函数
*/
static const struct file_operations input_fops = {
    .owner = THIS_MODULE,
    .open = input_open_file,
    .llseek = noop_llseek,
};

static int __init input_init(void)
{
    int err;

    err = class_register(&input_class);/*d. 调用class_register()注册类*/
    if (err) {
        pr_err("unable to register input_dev class\n");
        return err;
    }

    err = input_proc_init();
    if (err)
        goto fail1;
    /*
    *a. 分配主设备号INPUT_MAJOR=13
    *c. 调用register_chrdev()函数注册字符设备
    */
    err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
    if (err) {
        pr_err("unable to register char major %d", INPUT_MAJOR);
        goto fail2;
    }

    return 0;

 fail2:    input_proc_exit();
 fail1:    class_unregister(&input_class);
    return err;
}

2. 那么谁来调用device_create()创建设备？这里直接给出结论，后面再分析过程。

handler->connect函数中会完成设备的创建工作。这里已 evdev_connect()函数为例来分析。

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,const struct input_device_id *id)

　　-->for (minor = 0; minor < EVDEV_MINORS; minor++)  确定次设备号

　　　　if (!evdev_table[minor]) break;

　　-->evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);确定设备号

　　-->evdev->dev.class = &input_class;

　　-->dev_set_name(&evdev->dev, "event%d", minor);  设置设备名字

　　　　-->kobject_set_name_vargs(&dev->kobj, fmt, vargs);

　　-->device_initialize(&evdev->dev);

　　-->device_add(&evdev->dev);

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
             const struct input_device_id *id)
{
    struct evdev *evdev;
    int minor;
    int error;

    for (minor = 0; minor < EVDEV_MINORS; minor++)
        if (!evdev_table[minor])
            break;

    if (minor == EVDEV_MINORS) {
        pr_err("no more free evdev devices\n");
        return -ENFILE;
    }

    evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
    if (!evdev)
        return -ENOMEM;

    INIT_LIST_HEAD(&evdev->client_list);
    spin_lock_init(&evdev->client_lock);
    mutex_init(&evdev->mutex);
    init_waitqueue_head(&evdev->wait);

    dev_set_name(&evdev->dev, "event%d", minor);
    evdev->exist = true;
    evdev->minor = minor;

    evdev->handle.dev = input_get_device(dev);
    evdev->handle.name = dev_name(&evdev->dev);
    evdev->handle.handler = handler;
    evdev->handle.private = evdev;

    evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
    evdev->dev.class = &input_class;
    evdev->dev.parent = &dev->dev;
    evdev->dev.release = evdev_free;
    device_initialize(&evdev->dev);

    error = input_register_handle(&evdev->handle);
    if (error)
        goto err_free_evdev;

    error = evdev_install_chrdev(evdev);
    if (error)
        goto err_unregister_handle;

    error = device_add(&evdev->dev);
    if (error)
        goto err_cleanup_evdev;

    return 0;

 err_cleanup_evdev:
    evdev_cleanup(evdev);
 err_unregister_handle:
    input_unregister_handle(&evdev->handle);
 err_free_evdev:
    put_device(&evdev->dev);
    return error;
}

int dev_set_name(struct device *dev, const char *fmt, ...)
{
    va_list vargs;
    int err;

    va_start(vargs, fmt);
    err = kobject_set_name_vargs(&dev->kobj, fmt, vargs);
    va_end(vargs);
    return err;
}

 

上面的分析没有看到调用device_create()函数，但分析device_create()函数可知起始上面的步骤和device_create()内执行的一致。

struct device *device_create(struct class *class, struct device *parent,dev_t devt, void *drvdata, const char *fmt, ...)

　　-->device_create_vargs(class, parent, devt, drvdata, fmt, vargs);

　　　　-->dev->class = class;

　　　　-->dev->devt = devt;

　　　　-->kobject_set_name_vargs(&dev->kobj, fmt, args);

　　　　-->device_register(dev);

　　　　　　-->device_initialize(dev);

　　　　　　-->device_add(dev);

struct device *device_create(struct class *class, struct device *parent,
                 dev_t devt, void *drvdata, const char *fmt, ...)
{
    va_list vargs;
    struct device *dev;

    va_start(vargs, fmt);
    dev = device_create_vargs(class, parent, devt, drvdata, fmt, vargs);
    va_end(vargs);
    return dev;
}

struct device *device_create_vargs(struct class *class, struct device *parent,
                   dev_t devt, void *drvdata, const char *fmt,
                   va_list args)
{
    struct device *dev = NULL;
    int retval = -ENODEV;

    if (class == NULL || IS_ERR(class))
        goto error;

    dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    if (!dev) {
        retval = -ENOMEM;
        goto error;
    }

    dev->devt = devt;
    dev->class = class;
    dev->parent = parent;
    dev->release = device_create_release;
    dev_set_drvdata(dev, drvdata);

    retval = kobject_set_name_vargs(&dev->kobj, fmt, args);
    if (retval)
        goto error;

    retval = device_register(dev);
    if (retval)
        goto error;

    return dev;

error:
    put_device(dev);
    return ERR_PTR(retval);
}

int device_register(struct device *dev)
{
    device_initialize(dev);
    return device_add(dev);
}