1. struct input_dev {
2. void *private;              //输入设备私有指针，一般指向用于描述设备驱动层的设备结构
3. const char *name;           //提供给用户的输入设备的名称
4. const char *phys;           //提供给编程者的设备节点的名称
5. const char *uniq;           //指定唯一的ID号，就像MAC地址一样
6. struct input_id id;         //输入设备标识ID，用于和事件处理层进行匹配
7. unsigned long evbit[NBITS(EV_MAX)];     //位图，记录设备支持的事件类型
8. unsigned long keybit[NBITS(KEY_MAX)];       //位图，记录设备支持的按键类型
9. unsigned long relbit[NBITS(REL_MAX)];       //位图，记录设备支持的相对坐标
10. unsigned long absbit[NBITS(ABS_MAX)];       //位图，记录设备支持的绝对坐标
11. unsigned long mscbit[NBITS(MSC_MAX)];   //位图，记录设备支持的其他功能
12. unsigned long ledbit[NBITS(LED_MAX)];       //位图，记录设备支持的指示灯
13. unsigned long sndbit[NBITS(SND_MAX)];       //位图，记录设备支持的声音或警报
14. unsigned long ffbit[NBITS(FF_MAX)];     //位图，记录设备支持的作用力功能
15. unsigned long swbit[NBITS(SW_MAX)];     //位图，记录设备支持的开关功能
16. unsigned int keycodemax;        //设备支持的最大按键值个数
17. unsigned int keycodesize;       //每个按键的字节大小
18. void *keycode;              //指向按键池，即指向按键值数组首地址
19. int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);    //修改按键值
20. int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);   //获取按键值
21. struct ff_device *ff;           //用于强制更新输入设备的部分内容
22. unsigned int repeat_key;        //重复按键的键值
23. struct timer_list timer;        //设置当有连击时的延时定时器
24. int state;      //设备状态
25. int sync;       //同步事件完成标识，为1说明事件同步完成
26. int abs[ABS_MAX + 1];       //记录坐标的值
27. int rep[REP_MAX + 1];       //记录重复按键的参数值
28. unsigned long key[NBITS(KEY_MAX)];      //位图，按键的状态
29. unsigned long led[NBITS(LED_MAX)];      //位图，led的状态
30. unsigned long snd[NBITS(SND_MAX)];      //位图，声音的状态
31. unsigned long sw[NBITS(SW_MAX)];            //位图，开关的状态
32. int absmax[ABS_MAX + 1];                    //位图，记录坐标的最大值
33. int absmin[ABS_MAX + 1];                    //位图，记录坐标的最小值
34. int absfuzz[ABS_MAX + 1];                   //位图，记录坐标的分辨率
35. int absflat[ABS_MAX + 1];                   //位图，记录坐标的基准值
36. int (*open)(struct input_dev *dev);         //输入设备打开函数
37. void (*close)(struct input_dev *dev);           //输入设备关闭函数
38. int (*flush)(struct input_dev *dev, struct file *file); //输入设备断开后刷新函数
39. int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);   //事件处理
40. struct input_handle *grab;      //类似私有指针，可以直接访问到事件处理接口event
41. struct mutex mutex;     //用于open、close函数的连续访问互斥
42. unsigned int users;     //设备使用计数
43. struct class_device cdev;   //输入设备的类信息
44. union {             //设备结构体
45. struct device *parent;
46. } dev;
47. struct list_head    h_list; //handle链表
48. struct list_head    node;   //input_dev链表
49. };

1. struct input_dev *input_allocate_device(void)
2. {
3. struct input_dev *dev;
4. //动态申请内存，使用GFP_KERNEL方式，注意GFP_KERNEL可能导致睡眠，不能在中断中调用这个函数
5. dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);
6. //分配成功执行的代码，进行成员的默认填充
7. if (dev) {
8. dev->cdev.class = &input_class;          //支持热插拔的结构体
9. dev->cdev.groups = input_dev_attr_groups; //描述设备的硬件信息和支持的事件类型
10. class_device_initialize(&dev->cdev);     //类设备初始化，添加进input类设备模型中
11. mutex_init(&dev->mutex);             //初始化互斥锁
12. INIT_LIST_HEAD(&dev->h_list);        //初始化handle链表
13. INIT_LIST_HEAD(&dev->node);          //初始化输入设备链表
14. }
15. }

1. struct input_dev *input_dev = input_allocate_device();
2. input_dev->name = "s3c2410 Touchscreen";
3. input_dev->phys = "s3c2410ts/input0";
4. input_dev->id.bustype = BUS_HOST;
5. input_dev->id.vendor = 0x0001;
6. input_dev->id.product = 0x0002;
7. input_dev->id.version = 0x0100;
8. input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
9. input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
10. input_set_abs_params(input_dev, ABS_X, X_AXIS_MIN, X_AXIS_MAX, 0, 0);
11. input_set_abs_params(input_dev, ABS_Y, Y_AXIS_MIN, Y_AXIS_MAX, 0, 0);
12. input_set_abs_params(input_dev, ABS_PRESSURE, PRESSURE_MIN, PRESSURE_MAX, 0, 0);

1. int input_register_device(struct input_dev *dev)
2. {
3. /* 用于记录输入设备名称的索引值 */
4. static atomic_t input_no = ATOMIC_INIT(0);
5. /* 输入事件的处理接口指针，用于和设备的事件类型进行匹配 */
6. struct input_handler *handler;
7. const char *path;
8. int error;
9. /* 默认所有的输入设备都支持EV_SYN同步事件 */
10. set_bit(EV_SYN, dev->evbit);
11. /*
12. * 如果设备驱动没有指定重复按键（连击），系统默认提供以下的支持
13. * 其中init_timer为连击产生的定时器，时间到调用input_repeat_key函数
14. * 上报，REP_DELAY用于设置重复按键的键值，REP_PERIOD设置延时时间
15. */
16. init_timer(&dev->timer);
17. if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {
18. dev->timer.data = (long) dev;
19. dev->timer.function = input_repeat_key;
20. dev->rep[REP_DELAY] = 250;
21. dev->rep[REP_PERIOD] = 33;
22. }
23. /* 如果设备驱动没有设置自己的获取键值的函数，系统默认 */
24. if (!dev->getkeycode)
25. dev->getkeycode = input_default_getkeycode;
26. /* 如果设备驱动没有指定按键重置函数，系统默认 */
27. if (!dev->setkeycode)
28. dev->setkeycode = input_default_setkeycode;
29. /* 重要，把设备挂到全局的input子系统设备链表input_dev_list上 */
30. list_add_tail(&dev->node, &input_dev_list);
31. /* 动态获取input设备的ID号，名称为input*，其中后面的“*”动态获得，唯一的 */
32. snprintf(dev->cdev.class_id, sizeof(dev->cdev.class_id),
33. "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1);
34. /* 如果这个值没有设置，系统把输入设备挂入设备链表 */
35. if (!dev->cdev.dev)
36. dev->cdev.dev = dev->dev.parent;
37. /* 在/sys目录下创建设备目录和文件 */
38. error = class_device_add(&dev->cdev);
39. if (error)
40. return error;
41. /* 获取并打印设备的绝对路径名称 */
42. path = kobject_get_path(&dev->cdev.kobj, GFP_KERNEL);
43. printk(KERN_INFO "input: %s as %s\n",
44. dev->name ? dev->name : "Unspecified device", path ? path : "N/A");
45. kfree(path);
46. /* 核心重点，input设备在增加到input_dev_list链表上之后，会查找
47. * input_handler_list事件处理链表上的handler进行匹配，这里的匹配
48. * 方式与设备模型的device和driver匹配过程很相似，所有的input
49. * 都挂在input_dev_list上，所有类型的事件都挂在input_handler_list
50. * 上，进行“匹配相亲”*/
51. list_for_each_entry(handler, &input_handler_list, node)
52. input_attach_handler(dev, handler);
53. input_wakeup_procfs_readers();
54. return 0;
55. }

1. const struct input_device_id *id;
2. int error;
3. /* 如果handler的blacklist被赋值了并且则优先匹配 */
4. if (handler->blacklist && input_match_device(handler->blacklist, dev))
5. return -ENODEV;
6. /* 否则利用handler->id_table和dev进行匹配，后面讲述匹配什么和过程 */
7. id = input_match_device(handler->id_table, dev);
8. if (!id)
9. return -ENODEV;
10. /* 这是一根“红线”，虽然你可能觉的是黑色的，但不可否认，他们真的匹配上了
11. * 调用handler->connnect函数进行匹配，匹配详细过程后面讲述
12. */
13. error = handler->connect(handler, dev, id);
14. if (error && error != -ENODEV)
15. printk(KERN_ERR
16. "input: failed to attach handler %s to device %s, "
17. "error: %d\n",
18. handler->name, kobject_name(&dev->cdev.kobj), error);
19. return error;

1. /* 事件处理层中的对应flags如果设置或者driver_info被设置则进行匹配 */
2. for (; id->flags || id->driver_info; id++) {
3. /* 以下通过flags中设置的位来匹配设备的总线类型、经销商、生产ID和版本ID
4. 如果没有匹配上将进行MATCH_BIT匹配 */
5. if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
6. if (id->bustype != dev->id.bustype)
7. continue;
8. if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
9. if (id->vendor != dev->id.vendor)
10. continue;
11. if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
12. if (id->product != dev->id.product)
13. continue;
14. if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)
15. if (id->version != dev->id.version)
16. continue;
17. /* MATCH_BIT用于匹配设备驱动中是否设置了这些为，MATCH_BIT的宏
18. * 被定义在input.c中，我们在设备驱动中设置的事件类型会与事件链表中的
19. * 所有事件类型进行比较，匹配成功了将返回id，证明真的很合适，否则NULL
20. */
21. MATCH_BIT(evbit,  EV_MAX);
22. MATCH_BIT(keybit, KEY_MAX);
23. MATCH_BIT(relbit, REL_MAX);
24. MATCH_BIT(absbit, ABS_MAX);
25. MATCH_BIT(mscbit, MSC_MAX);
26. MATCH_BIT(ledbit, LED_MAX);
27. MATCH_BIT(sndbit, SND_MAX);
28. MATCH_BIT(ffbit,  FF_MAX);
29. MATCH_BIT(swbit,  SW_MAX);
30. return id;
31. }
32. return NULL;

1. struct evdev *evdev;
2. struct class_device *cdev;
3. dev_t devt;
4. int minor;
5. int error;
6. /* EVDEV_MINORS为32，代表共能容纳32个evdev事件层设备，下面代码在找到空的地方，用于保存evdev事件层的数据，即上面定义的evdev */
7. for (minor = 0; minor < EVDEV_MINORS && evdev_table[minor]; minor++);
8. /* 这说明内核已经没办法再分配这种类型的设备了 */
9. if (minor == EVDEV_MINORS) {
10. printk(KERN_ERR "evdev: no more free evdev devices\n");
11. return -ENFILE;
12. }
13. /* 开始给evdev事件层驱动分配空间了 */
14. evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);
15. if (!evdev)
16. return -ENOMEM;
17. /* 初始化client_list列表和evdev_wait队列，后面介绍 */
18. INIT_LIST_HEAD(&evdev->client_list);
19. init_waitqueue_head(&evdev->wait);
20. /* 初始化evdev结构体，其中handle为输入设备和事件处理的关联接口 */
21. evdev->exist = 1;
22. evdev->minor = minor;
23. evdev->handle.dev = dev;
24. evdev->handle.name = evdev->name;
25. evdev->handle.handler = handler;
26. evdev->handle.private = evdev;
27. sprintf(evdev->name, "event%d", minor);
28. /* 重要，上层访问时通过次设备号找到事件处理的接口 */
29. evdev_table[minor] = evdev;
30. /* evdev事件设备的此设备号的基准值INPUT_MAJOR, EVDEV_MINOR_BASE */
31. devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor),
32. /* 创建用户事件驱动层设备访问接口/dev/input/event* */
33. cdev = class_device_create(&input_class, &dev->cdev, devt,
34. dev->cdev.dev, evdev->name);
35. if (IS_ERR(cdev)) {
36. error = PTR_ERR(cdev);
37. goto err_free_evdev;
38. }
39. /* 提供/sys目录的用户空间接口 */
40. error = sysfs_create_link(&input_class.subsys.kobj,
41. &cdev->kobj, evdev->name);
42. if (error)
43. goto err_cdev_destroy;
44. /* input_dev设备驱动和handler事件处理层的关联，由handle完成 */
45. error = input_register_handle(&evdev->handle);

1. struct input_handler *handler = handle->handler;
2. /* 将d_node链接到输入设备的h_list，h_node链接到事件层的h_list链表上
3. * 因此，在handle中是输入设备和事件层的关联结构体，通过输入设备可以
4. * 找到对应的事件处理层接口，通过事件处理层也可找到匹配的输入设备
5. */
6. list_add_tail(&handle->d_node, &handle->dev->h_list);
7. list_add_tail(&handle->h_node, &handler->h_list);
8. /* 如果start函数有定义则调用，但是evdev结构体中并未初始化这个函数 */
9. if (handler->start)
10. handler->start(handle);

crw-r-----1 root root 13, 64 2012-07-26 14:32 /dev/input/event0

1. /* 输入设备初始化函数 */
2. static int __init input_init(void)
3. {
4. class_register(&input_class);
5. input_proc_init();
6. register_chrdev(INPUT_MAJOR,"input", &input_fops);
7. }

1. static const struct file_operations input_fops = {
2. .owner = THIS_MODULE,
3. .open = input_open_file,
4. };

1. static int input_open_file(struct inode *inode, struct file *file)
2. {
3. struct input_handler *handler =input_table[iminor(inode) >> 5];
4. const struct file_operations *old_fops,*new_fops = NULL;
5. if (!handler || !(new_fops =fops_get(handler->fops)))
6. return -ENODEV;
7. old_fops = file->f_op;
8. file->f_op = new_fops;
9. new_fops->open(inode, file);
10. }

1. static struct input_handler evdev_handler = {
2. .event =   evdev_event,                               //事件处理
3. .connect =      evdev_connect,                    //设备连接
4. .disconnect =  evdev_disconnect,                //注销连接
5. .fops =           &evdev_fops,                      //驱动功能接口
6. .minor =  EVDEV_MINOR_BASE,              //evdev的值为64
7. .name =          "evdev",                              //设备名称
8. .id_table =      evdev_ids,                           //用于匹配设备驱动的数组
9. };
10. static int __init evdev_init(void)
11. {
12. return input_register_handler(&evdev_handler);          //evdev设备驱动注册
13. }

1. int input_register_handler(struct input_handler *handler)
2. {
3. ……
4. input_table[handler->minor>> 5] = handler;
5. ……
6. }

1. input_table[2]=&evdev_handler；

1. evdev_handler.evdev_fops.open（inode, file）；

1. /*evdev字符设备驱动接口 */
2. static const struct file_operations evdev_fops = {
3. .owner = THIS_MODULE,
4. .read =           evdev_read,
5. .write =   evdev_write,
6. .poll =            evdev_poll,
7. .open =          evdev_open,
8. .release = evdev_release,
9. .unlocked_ioctl = evdev_ioctl,
10. #ifdef CONFIG_COMPAT
11. .compat_ioctl =      evdev_ioctl_compat,
12. #endif
13. .fasync = evdev_fasync,
14. .flush =   evdev_flush
15. };
16. /*evdev设备open函数的实现过程 */
17. static int evdev_open(struct inode *inode, struct file *file)
18. {
19. struct evdev_client *client;
20. struct evdev *evdev;
21. /* 如果是event0，对于evdev设备来说，次设备号当然是0 */
22. int i = iminor(inode) - EVDEV_MINOR_BASE;
23. int error;
24. /* 如果大于32，说明超出了evdev能够容纳的最大输入设备个数 */
25. if (i >= EVDEV_MINORS)
26. return -ENODEV;
27. /* 由于evdev中能容纳32个输入设备，因此通过设备号event0中的0定位到是要处理的是哪一个输入设备，evdev_table中的内容在输入设备驱动注册时通过evdev_connect填充 */
28. evdev = evdev_table[i];
29. /* 判断是否设备接口存在，evdev_exist也是在evdev_connect填充为1 */
30. if (!evdev || !evdev->exist)
31. return -ENODEV;
32. /* 存在则分配evdev中的client来处理event* */
33. client = kzalloc(sizeof(struct evdev_client),GFP_KERNEL);
34. if (!client)
35. return -ENOMEM;
36. /* 把event*中的接口指向evdev_table中对应项 */
37. client->evdev = evdev;
38. /* 把client->node链接到evdev子集中 */
39. list_add_tail(&client->node,&evdev->client_list);
40. /* 如果open是第一个打开，则会执行input_open_device*/
41. if (!evdev->open++ &&evdev->exist) {
42. error =input_open_device(&evdev->handle);
43. if (error) {
44. list_del(&client->node);
45. kfree(client);
46. return error;
47. }
48. }
49. /* 将file私有指针指向client*/
50. file->private_data = client;
51. return 0;
52. }
53. 由上的代码可以看出，最终是要执行input_open_device去执行设备驱动程序中的代码，然而我们在定义设备驱动的时候并没有给input_dev中的open字段填充内容，因此可以看到input_open_device函数的执行过程：
54. if(!dev->users++ && dev->open)
55. err = dev->open(dev);
56. if (err)
57. handle->open--;

1. input_report_abs(dev,ABS_X, s3c2440_ts->tc.xp);
2. input_report_abs(dev,ABS_Y, s3c2440_ts->tc.yp);
3. input_report_abs(dev,ABS_PRESSURE, s3c2440_ts->tc.pressure);
4. input_report_key(dev,BTN_TOUCH, s3c2440_ts->pendown);
5. input_sync(dev);

1. void input_event(struct input_dev *dev, unsigned int type, unsigned int code, intvalue)
2. {
3. struct input_handle *handle;
4. if (type > EV_MAX || !test_bit(type,dev->evbit))
5. return;
6. switch (type) {
7. case EV_SYN:
8. switch (code) {
9. case SYN_CONFIG:
10. if(dev->event)
11. dev->event(dev,type, code, value);
12. break;
13. case SYN_REPORT:
14. if(dev->sync)
15. return;
16. dev->sync= 1;
17. break;
18. }
19. break;
20. case EV_KEY:
21. case EV_SW:
22. case EV_ABS:
23. case EV_REL:
24. case EV_MSC:
25. case EV_LED:
26. case EV_SND:
27. case EV_REP:
28. case EV_FF:
29. }
30. if (type != EV_SYN)
31. dev->sync = 0;
32. if (dev->grab)
33. dev->grab->handler->event(dev->grab,type, code, value);
34. else
35. list_for_each_entry(handle,&dev->h_list, d_node)
36. if (handle->open)
37. handle->handler->event(handle,type, code, value);
38. }

1. list_for_each_entry(client,&evdev->client_list, node) {
2. client->buffer[client->head].type= type;
3. client->buffer[client->head].code= code;
4. client->buffer[client->head].value= value;
5. client->head= (client->head + 1) & (EVDEV_BUFFER_SIZE - 1);
6. }

1. static ssize_t evdev_read(struct file *file, char __user *buffer, size_t count, loff_t*ppos)
2. {
3. struct evdev_client *client =file->private_data;
4. struct evdev *evdev = client->evdev;
5. int retval;
6. /* 判断用户给的count是否能够容纳事件数据的大小*/
7. if (count < evdev_event_size())
8. return -EINVAL;
9. /* 如果数据不为空并且设备存在并且是阻塞访问方式才能继续执行 */
10. if (client->head == client->tail&& evdev->exist && (file->f_flags & O_NONBLOCK))
11. return -EAGAIN;
12. /* 如果数据为空，设置进程等待底层驱动层上报事件到client->buffer中 */
13. retval =wait_event_interruptible(evdev->wait,
14. client->head != client->tail|| !evdev->exist);
15. if (retval)
16. return retval;
17. if (!evdev->exist)
18. return -ENODEV;
19. /* 循环读取数据 */
20. while (client->head != client->tail&& retval + evdev_event_size() <= count) {
21. struct input_event *event =(struct input_event *) client->buffer + client->tail;
22. if (evdev_event_to_user(buffer +retval, event))
23. return -EFAULT;
24. client->tail = (client->tail+ 1) & (EVDEV_BUFFER_SIZE - 1);
25. retval += evdev_event_size();
26. }
27. return retval;
28. }

1. static ssize_t evdev_write(struct file *file, const char __user *buffer, size_t count,loff_t *ppos)
2. {
3. /* 循环写入，调用input_inject_event函数 */
4. while (retval < count) {
5. if (evdev_event_from_user(buffer +retval, &event))
6. return -EFAULT;
7. input_inject_event(&evdev->handle,event.type, event.code, event.value);
8. retval += evdev_event_size();
9. }
10. return retval;
11. }