内核input子系统分析

打开/driver/input/input.c 这就是input代码的核心

找到

static int __init input_init(void)

{

err = class_register(&input_class);注册一个类，注册后会在sys/class出现input目录.

......

err = register_chrdev(INPUT_MAJOR, "input", &input_fops);注册一个主设备号为13的input设备，

}

打开input_fops

static const struct file_operations input_fops = {
    .owner = THIS_MODULE,
    .open = input_open_file,
};

只有一个往内核中注册一个open函数，那么read,write，等函数也应该注册，则应该在input_open_file中注册，

分析static int input_open_file(struct inode *inode, struct file *file)

{

struct input_handler *handler = input_table[iminor(inode) >> 5];把input_table数组中的某一个成员赋值给handler,这个下面会具体分析

if (!handler || !(new_fops = fops_get(handler->fops)))获取handler中的file_operations结构体
        return -ENODEV;

old_fops = file->f_op;
    file->f_op = new_fops;

err = new_fops->open(inode, file);打开这个handler->fops->open函数

}

问1：input_table[iminor(inode) >> 5]这个数组是有谁来赋值的

int input_register_handler(struct input_handler *handler)

{

INIT_LIST_HEAD(&handler->h_list);

input_table[handler->minor >> 5] = handler;把handler赋值给input_table数组，位置以此设备号除以32

list_add_tail(&handler->node, &input_handler_list);把这个handler的节点加入input_handler_list链表中

list_for_each_entry(dev, &input_dev_list, node)一次遍历input_dev_list链表中的input_dev设备，然后对传进的handler进行匹配，寻找input_dev_list中有没有支持这个handler的设备
        input_attach_handler(dev, handler);具体的匹配方法接下来会详细分析

}

问2：那谁来调用input_register_handler，也就是handler从哪里来

搜索得到

Evbug.c (drivers\input):106:    return input_register_handler(&evbug_handler);
Evdev.c (drivers\input):745:    return input_register_handler(&evdev_handler);
Input.c (drivers\input):1193:int input_register_handler(struct input_handler *handler)
Input.c (drivers\input):1219:EXPORT_SYMBOL(input_register_handler);
Input.h (include\linux):1130:int input_register_handler(struct input_handler *);
Joydev.c (drivers\input):647:    return input_register_handler(&joydev_handler);
Keyboard.c (drivers\char):1367:    error = input_register_handler(&kbd_handler);
---- = input_register_handler(&kbd_handler); Matches (1 in 1 files) ----
Keyboard.c (drivers\char):1367:    error = input_register_handler(&kbd_handler);
那就打开keyboard.c以它为例详细分析这个是怎么注册的
static struct input_handler kbd_handler = {
    .event        = kbd_event,
    .connect    = kbd_connect,
    .disconnect    = kbd_disconnect,
    .start        = kbd_start,
    .name        = "kbd",
    .id_table    = kbd_ids,
};
int __init kbd_init(void)

{

error = input_register_handler(&kbd_handler);

}

其实就是吧kbd_handler这个结构体传递给input_table；

再总结一下：

int __init kbd_init(void)->error = input_register_handler(&kbd_handler)

{  input_table[handler->minor >> 5] = handler;

list_add_tail(&handler->node, &input_handler_list);

list_for_each_entry(dev, &input_dev_list, node)
        input_attach_handler(dev, handler);

}

分析如何匹配的 input_attach_handler(dev, kbd_hander)

{

id = input_match_device(handler->id_table, dev);如果匹配成功返回一个id

error = handler->connect(handler, dev, id);然后会根据返回的id找到设备和kbd_handler进行连接，这个连接connect函数就是kbd_handler->kbd_connect

}

接下来详细分析input_match_device

{

for (; id->flags || id->driver_info; id++) {

if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
            if (id->bustype != dev->id.bustype)
                continue;

.......
             //针对handler->id->flags，比较不同的类型，如果比较成功
                    //进入下面的宏比较，否则进入下一个id

MATCH_BIT(evbit,  EV_MAX);
          .............
           //安位比较所支持事件的类型，只有所有未匹配成功才能成功返回，否则进入下一id
        return id;
    }

return NULL;

}

如果匹配成功就会进入连接，分析kbd_connect

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

{

struct input_handle *handle;定义一个input_hanlde指针

handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);分配input_handle结构体空间

handle->dev = dev;使分配的handle中的dev指向和handler匹配的input_dev
    handle->handler = handler;使handle中的handler指向和input_dev匹配的input_handler
    handle->name = "kbd";

error = input_register_handle(handle);注册这个新分配的handle;

error = input_open_device(handle);

}

继续分析

int input_register_handle(struct input_handle *handle)
{
    struct input_handler *handler = handle->handler;

list_add_tail(&handle->d_node, &handle->dev->h_list); 把handle->d_node挂在input_dev->h_list上
    list_add_tail(&handle->h_node, &handler->h_list);吧handle->h_node挂载handler->h_list上
    这样就可以通过input_handler中的h_list找到handle,然后通过handle->dev找到匹配的input_dev

同样也可以通过input_dev中的h_list找到handl,然后通过handle->handler找到匹配的input_handler

这样input_handler,input
    if (handler->start)
        handler->start(handle);

return 0;
}继续分析

int input_open_device(struct input_handle *handle)
{
    struct input_dev *dev = handle->dev;
    int err;
    handle->open++;//handle的打开计数加1，注意和evdev的open的区别

if (!dev->users++ && dev->open)
        err = dev->open(dev);//如果此input-dev没有进程引用，并且定义了open
        //方法，就调用open方法，

if (err) //retval=1说明，没有成功打开，
        handle->open--;
}

总结connect的作用就是根据匹配成功的input_dev和input_handler，创建一个新的结构体input_handle，然后把结构体中的dev和handler分配指向input_dev和input_handler

这样的话，就可以通过input_handle这个结构体把input_dev和input_hanlder连接起来；

static int __init input_init(void)->err = register_chrdev(INPUT_MAJOR, "input", &input_fops)->input_fops-> input_open_file

{struct input_handler *handler = input_table[iminor(inode) >> 5];

if (!new_fops->open) {
        fops_put(new_fops);
        return -ENODEV;
    }

err = new_fops->open(inode, file);这个open函数就是kbd_handler中的fops中的open；这个keyboard中没有初始化fops；

}

对于注册输入设备:
input_register_device
    // 放入链表
    list_add_tail(&dev->node, &input_dev_list);
    
    // 对于每一个input_handler，都调用input_attach_handler
    list_for_each_entry(handler, &input_handler_list, node)
        input_attach_handler(dev, handler); // 根据input_handler的id_table判断能否支持这个input_dev

input_attach_handler
    id = input_match_device(handler->id_table, dev);
    
    error = handler->connect(handler, dev, id);

和input_handler类似，大家自行分析