Android输入子系统浅析（一）

Linux输入子系统框架

1：Input输入子系统总体框架

    Linux内核的输入子系统是对分散的，多种不同类别的输入设备（如键盘，鼠标，触摸屏）等字符设备进行统一处理的一层抽象，就是在字符设备驱动上抽象出的一层。但是这些输入设备都各有不同，那么输入子系统也就只能实现他们的共性，差异性则由设备驱动来实现,而差异性最直观的表现在这些设备功能上的不同。但是，为了更好的理解Linux的输入子系统，我们有必要仔细研究下它的框架。

    Linux输入子系统将输入驱动抽象为三层：设备驱动层、核心层、事件处理层，其内在联系如下图所示：

下面先对这三个部分做一个简要的概括，后面的分析也是基于这三个部分：

        设备驱动层：主要实现对硬件设备的读写访问，中断设置，并把硬件产生的事件转换为核心层定义的规范提交给事件处理层

        核心层：为设备驱动层提供了规范和接口。设备驱动层只关心如何驱动硬件并获得硬件数据，然后调用核心层提供的接口，核心层自动把数据提交给事件处理层

        事件处理层：是用户编程的接口（设备节点），并处理驱动层提交的数据处理

本篇博文所述均是基于linux 3.4.5内核，android 4.2.2版本，硬件平台基于MT6589平台.

2：Input子系统分层分析

        2.1：在分析这三部分之前，首先我们先看看input.h这个头文件，因为输入子系统的很多重要结构体都是在里面定义的。

        路径：kernel/include/linux/input.h

       重要结构体之input_dev：

1. struct input_dev {
2. const char *name; //设备名称
3. const char *phys; //设备在系统的物理路径
4. const char *uniq; //设备唯一识别符
5. struct input_id id; //设备ID，包含总线ID(PCI,USB)、厂商ID，与input_handler匹配时用到
7. unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)]; //bitmap of device properties and quirks
9. unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; //支持的所有 事件类型
10. unsigned long keybit[BITS_TO_LONGS(KEY_CNT)]; //支持的键盘事件
11. unsigned long relbit[BITS_TO_LONGS(REL_CNT)]; //支持的鼠标相对值事件
12. unsigned long absbit[BITS_TO_LONGS(ABS_CNT)]; //支持的鼠标绝对值事件
13. unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)]; //支持的其他事件类型
14. unsigned long ledbit[BITS_TO_LONGS(LED_CNT)]; //支持的led灯事件
15. unsigned long sndbit[BITS_TO_LONGS(SND_CNT)]; //支持的声效事件
16. unsigned long ffbit[BITS_TO_LONGS(FF_CNT)]; //支持的力反馈事件
17. unsigned long swbit[BITS_TO_LONGS(SW_CNT)]; //支持的开关事件
19. unsigned int hint_events_per_packet;
21. unsigned int keycodemax; //keycode表的大小
22. unsigned int keycodesize; //keycode表中的元素个数
23. void *keycode; //设备的键盘表
25. //配置keycode表
26. int (*setkeycode)(struct input_dev *dev,
27. const struct input_keymap_entry *ke,
28. unsigned int *old_keycode);
30. //获取keycode表
31. int (*getkeycode)(struct input_dev *dev,
32. struct input_keymap_entry *ke);
34. struct ff_device *ff;
36. unsigned int repeat_key; //保存上一个键值
37. struct timer_list timer; //定时器
39. int rep[REP_CNT];
41. struct input_mt_slot *mt;
42. int mtsize;
43. int slot;
44. int trkid;
46. struct input_absinfo *absinfo;
48. unsigned long key[BITS_TO_LONGS(KEY_CNT)];
49. unsigned long led[BITS_TO_LONGS(LED_CNT)];
50. unsigned long snd[BITS_TO_LONGS(SND_CNT)];
51. unsigned long sw[BITS_TO_LONGS(SW_CNT)];
53. //操作接口
54. int (*open)(struct input_dev *dev);
55. void (*close)(struct input_dev *dev);
56. int (*flush)(struct input_dev *dev, struct file *file);
57. int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);
59. struct input_handle __rcu *grab; //当前使用的handle
61. spinlock_t event_lock;
62. struct mutex mutex;
64. unsigned int users;
65. bool going_away;
67. bool sync;
69. struct device dev;
71. struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
72. struct list_head node; //这个node是用来连到input_dev_list上的
73. };

      重要结构体之input_handler：

1. struct input_handler {
3. void * private; //私有数据
5. //操作接口
6. void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
7. bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
8. bool (*match)(struct input_handler *handler, struct input_dev *dev);
9. int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
10. void (*disconnect)(struct input_handle *handle);
11. void (*start)(struct input_handle *handle);
13. const struct file_operations *fops;
14. int minor; //次设备号
15. const char *name;
17. const struct input_device_id *id_table;
19. struct list_head h_list; //h_list是一个链表头，用来把handle挂载在这个上
20. struct list_head node; //这个node是用来连到input_handler_list上的
21. };

重要结构体之input_handle：

1. struct input_handle {
3. void * private; //私有数据
5. int open;
6. const char *name;
8. struct input_dev *dev; //指向input_dev
9. struct input_handler *handler; //指向input_handler
11. struct list_head d_node; //连到input_dev的h_list
12. struct list_head h_node; //连到input_handler的h_list
13. };

重要结构体之evdev_client：

1. /*在进程打开event设备的时候调用evdev的open方法，在open中创建和初始化*/
2. struct evdev_client {
3. unsigned int head; //针对buffer数组的索引
4. unsigned int tail; //针对buffer数组的索引，当head和tail相等的时候，说明没事件
5. unsigned int packet_head; /* [future] position of the first element of next packet */
6. spinlock_t buffer_lock; /* protects access to buffer, head and tail */
7. struct wake_lock wake_lock;
8. bool use_wake_lock;
9. char name[ 28];
10. struct fasync_struct *fasync; //异步通知函数
11. struct evdev *evdev; //evdev设备
12. struct list_head node; //evdev_client链表项
13. int clkid;
14. unsigned int bufsize;
15. struct input_event buffer[]; //一个input_event数据结构的数组，input_event代表一个事件
16. };

重要结构体之evdev：

1. <pre name= "code" class= "cpp"> /*evdev结构体在配对成功的时候生成，由handler_connect生成*/
2. struct evdev {
3. int open; //打开引用计数
4. int minor; //次设备号
5. struct input_handle handle; //关联的input_handle
6. wait_queue_head_t wait; //等待队列
7. struct evdev_client __rcu *grab;
8. struct list_head client_list; //evdev_client链表，说明一个evdev设备可以处理多个evdev_client，可以有多个进程访问
9. spinlock_t client_lock; /* protects client_list */
10. struct mutex mutex;
11. struct device dev;
12. bool exist;
13. };

另外，input.h中还定义了可以支持哪些事件类型，这些只是大类事件，每个事件下还有具体区分：

1. /*
2. * Event types
3. */
5. #define EV_SYN 0x00 //同步时间
6. #define EV_KEY 0x01 //绝对二进制值，如键盘或者按钮
7. #define EV_REL 0x02 //绝对结果，如鼠标设备
8. #define EV_ABS 0x03 //绝对整数值，如TP，操纵杆
9. #define EV_MSC 0x04 //其他类
10. #define EV_SW 0x05 //开关事件
11. #define EV_LED 0x11 //led或其他指示设备
12. #define EV_SND 0x12 //声音输出，如蜂鸣器
13. #define EV_REP 0x14 //允许按键重复
14. #define EV_FF 0x15 //力反馈
15. #define EV_PWR 0x16 //电源管理
16. #define EV_FF_STATUS 0x17
17. #define EV_MAX 0x1f
18. #define EV_CNT (EV_MAX+1)

2.2：input输入子系统的核心层input.c

路径:kernel/drivers/input/input.c

1. //先分析入口函数:input_init(void)
2. static int __ init input_init(void)
3. {
4. int err;
5. //创建一个input_class类
6. err = class_register(&input_class);
7. if (err) {
8. pr_err( "unable to register input_dev class\n");
9. return err;
10. }
11. //在/proc下创建入口项
12. err = input_proc_init();
13. if (err)
14. goto fail1;
15. //注册主设备号为INPUT_MAJOR(13)的设备，并与input_fops关联
16. err = register_chrdev(INPUT_MAJOR, "input", &input_fops);
17. if (err) {
18. pr_err( "unable to register char major %d", INPUT_MAJOR);
19. goto fail2;
20. }
22. return 0;
24. fail2: input_proc_exit();
25. fail1: class_unregister(&input_class);
26. return err;
27. }

下面继续看input子系统的关联的input_fops：

1. static const struct file_operations input_fops = {
2. .owner = THIS_MODULE,
3. .open = input_open_file, //主要分析这个Open函数
4. .llseek = noop_llseek,
5. };

进入input_open_file函数体实现：

1. static int input_open_file(struct inode *inode, struct file *file)
2. {
3. struct input_handler *handler;
4. const struct file_operations *old_fops, *new_fops = NULL;
6. //......省略部分内容
8. //根据打开的文件次设备号来得到一个input_handler结构
9. handler = input_table[iminor(inode) >> 5];
10. //通过handler得到新的file_operations结构体
11. if (handler)
12. new_fops = fops_get(handler->fops);
14. //......省略部分内容
16. //保存文件之前的f_op
17. old_fops = file->f_op;
18. //将新的f_op赋值给当前文件的f_op
19. file->f_op = new_fops;
20. //调用open函数，当应用程序打开文件时会调用这个函数
21. err = new_fops->open(inode, file);
22. if (err) {
23. fops_put(file->f_op);
24. file->f_op = fops_get(old_fops);
25. }
26. fops_put(old_fops);
27. }

上面的input_table是如何来的呢？下面我们来继续分析：

1. static struct input_handler *input_table[8]; //定义
3. int input_register_handler(struct input_handler *handler)
4. {
5. //......省略部分内容
6. if (handler->fops != NULL) {
7. if (input_table[handler->minor >> 5]) {
8. retval = -EBUSY;
9. goto out;
10. }
11. input_table[handler->minor >> 5] = handler;
12. }
13. //......省略部分内容
14. }

    由上可知，input_table在input_register_handler（）被赋值为handler。而input_register_handler（）函数是在事件处理层中调用的，在2.3中我们会对其进行具体分析。当用户空间调用open时，实际上调用的就是handler fops中的open函数，而这个函数是在evdev.c中定义的，下面我们先看看这个open函数的实现（位于evdev.c中）：

1. static int evdev_open(struct inode *inode, struct file *file)
2. {
3. struct evdev *evdev;
4. struct evdev_client *client;
5. int i = iminor(inode) - EVDEV_MINOR_BASE;
6. unsigned int bufsize;
7. int error;
9. if (i >= EVDEV_MINORS) //判断是否超出了能处理的最大设备数
10. return -ENODEV;
12. error = mutex_lock_interruptible(&evdev_table_mutex);
13. if (error)
14. return error;
15. evdev = evdev_table[i]; //得到evdev设备结构，每次调用evdev_connect配对成功后都会把分配的evdev结构体以minor为索引保存在evdev_table中
16. if (evdev)
17. get_device(&evdev->dev); //增加device引用计数
18. mutex_unlock(&evdev_table_mutex);
20. if (!evdev)
21. return -ENODEV;
23. bufsize = evdev_compute_buffer_size(evdev->handle.dev);
25. //分配用户端结构
26. client = kzalloc( sizeof(struct evdev_client) +
27. bufsize * sizeof(struct input_event),
28. GFP_KERNEL);
29. if (!client) {
30. error = -ENOMEM;
31. goto err_put_evdev;
32. }
34. client->bufsize = bufsize;
35. spin_lock_init(&client->buffer_lock);
36. snprintf(client->name, sizeof(client->name), "%s-%d",
37. dev_name(&evdev->dev), task_tgid_vnr(current));
38. client->evdev = evdev; //使用户端与evdev设备结构关联起来
39. evdev_attach_client(evdev, client); //把client链接到evdev的client链表上
41. error = evdev_open_device(evdev); //打开设备
42. if (error)
43. goto err_free_client;
45. file->private_data = client;
46. nonseekable_open(inode, file);
48. return 0;
50. err_free_client:
51. evdev_detach_client(evdev, client);
52. kfree(client);
53. err_put_evdev:
54. put_device(&evdev->dev);
55. return error;
56. }

再分析上面的evdev_open_device函数（位于evdev.c中）：

1. static int evdev_open_device(struct evdev *evdev)
2. {
3. int retval;
5. retval = mutex_lock_interruptible(&evdev->mutex);
6. if (retval)
7. return retval;
9. if (!evdev->exist) //判断evdev结构体是否存在，在evdev_conect中初始化成员为1
10. retval = -ENODEV;
11. else if (!evdev->open++) {
12. retval = input_open_device(&evdev->handle); //打开设备
13. if (retval)
14. evdev->open--;
15. }
17. mutex_unlock(&evdev->mutex);
18. return retval;
19. }

上面的input_open_device函数（位于input.c）

1. int input_open_device(struct input_handle *handle)
2. {
3. struct input_dev *dev = handle->dev;
4. int retval;
6. retval = mutex_lock_interruptible(&dev->mutex);
7. if (retval)
8. return retval;
10. //判断设备是否在open期间被注销
11. if (dev->going_away) {
12. retval = -ENODEV;
13. goto out;
14. }
16. handle->open++; //handle的打开计数加一
18. if (!dev->users++ && dev->open) //如果输入设备没有进程引用，并定义了打开方法，就调用open方法
19. retval = dev->open(dev);
21. if (retval) { //如果没打开成功
22. dev->users--;
23. if (!--handle->open) { //说明有进程打开了这个handle
24. /*
25. * Make sure we are not delivering any more events
26. * through this handle
27. */
28. synchronize_rcu();
29. }
30. }
32. out:
33. mutex_unlock(&dev->mutex);
34. return retval;
35. }

到这里，如果input_dev有定义open方法，打开函数最终会调用到input_dev下面的open函数，否者只是简单的增加打开引用计数。

2.3：input输入子系统的事件处理层

         这里我们以触摸屏的事件处理层代码进行分析，即：evdev.c  

         代码路径：kernel/drivers/input/evdev.c

1. //先分析入口函数
2. static int __ init evdev_init(void)
3. {
4. return input_register_handler(&evdev_handler); //此处调用input_register_handler(&evdev_handler);
5. }

下面在具体看看int input_register_handler(struct input_handler *handler)函数（位于input.c中）:

1. int input_register_handler(struct input_handler *handler)
2. {
3. struct input_dev *dev;
4. int retval;
6. retval = mutex_lock_interruptible(&input_mutex);
7. if (retval)
8. return retval;
9. //初始化handler的h_list
10. INIT_LIST_HEAD(&handler->h_list);
12. //根据handler的minor将handler放到相应的input_table位置中
13. if (handler->fops != NULL) {
14. if (input_table[handler->minor >> 5]) {
15. retval = -EBUSY;
16. goto out;
17. }
18. input_table[handler->minor >> 5] = handler;
19. }
20. //将handler通过node链接到input_handler_list链表中
21. list_add_tail(&handler->node, &input_handler_list);
23. //遍历input_dev_list链表，找出与这个handler匹配的input_dev,并和它connect，
24. //匹配和connect的操作就是input_attach_handler所做的事情
25. list_for_each_entry(dev, &input_dev_list, node)
26. input_attach_handler(dev, handler);
28. //唤醒input_devices_poll_wait的等待队列
29. input_wakeup_procfs_readers();
31. out:
32. mutex_unlock(&input_mutex);
33. return retval;
34. }
35. EXPORT_SYMBOL(input_register_handler);

在具体看下上面的input_attach_handler函数(位于 input.c中)：

1. static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
2. {
3. const struct input_device_id *id;
4. int error;
6. //这个是主要的配对函数，主要比较id的各项
7. id = input_match_device(handler, dev);
8. if (!id)
9. return -ENODEV;
10. //配对成功调用handler的connect函数，这个函数在事件处理层
11. //主要生成一个input_handle结构体，并初始化，还生成一个事件处理器相关的设备结构
12. error = handler->connect(handler, dev, id);
13. if (error && error != -ENODEV)
14. pr_err( "failed to attach handler %s to device %s, error: %d\n",
15. handler->name, kobject_name(&dev->dev.kobj), error);
17. return error;
18. }

由上面的input_attach_handler可知，其主要调用了input_match_device和handler->connect两个函数，下面继续分析这两个函数：

input_match_device函数（位于input.c里面）：

1. static const struct input_device_id *input_match_device(struct input_handler *handler,
2. struct input_dev *dev)
3. {
4. const struct input_device_id *id;
5. int i;
6. //遍历handler的id_table与device进行匹配
7. for (id = handler->id_table; id->flags || id->driver_info; id++) {
8. //根据flags的标志位，按所需要匹配相应的字段
9. if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)
10. if (id->bustype != dev->id.bustype) //总线类型不匹配
11. continue;
13. if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)
14. if (id->vendor != dev->id.vendor) //生产厂商不匹配
15. continue;
17. if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)
18. if (id->product != dev->id.product) //产品不匹配
19. continue;
21. if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION) //版本不匹配
22. if (id->version != dev->id.version)
23. continue;
25. MATCH_BIT(evbit, EV_MAX); //匹配所有的事件
27. //下面匹配所有的子事件
28. MATCH_BIT(keybit, KEY_MAX);
29. MATCH_BIT(relbit, REL_MAX);
30. MATCH_BIT(absbit, ABS_MAX);
31. MATCH_BIT(mscbit, MSC_MAX);
32. MATCH_BIT(ledbit, LED_MAX);
33. MATCH_BIT(sndbit, SND_MAX);
34. MATCH_BIT(ffbit, FF_MAX);
35. MATCH_BIT(swbit, SW_MAX);
36. //如果有定义handler->match则调用它
37. //由于我们注册&evdev_handler时并没定义match函数，所以直接返回id
38.   if (!handler->match || handler->match(handler, dev))
39. return id;
40. }

下面分析 handler->connect，这个函数在前面的模块入口函数input_register_handler(&evdev_handler)中的evdev_handler指定。

evdev_handler定义（位于evdev.c中）：

1. static struct input_handler evdev_handler = {
2. .event = evdev_event,  //当有事件来的时候调用，把事件放入input_event数组，为用户空间读写事件做准备
3. .connect = evdev_connect, //在input_dev和input_handler注册过程最终都会调用这个函数，完成handle的注册
4. .disconnect = evdev_disconnect,  //在nput_dev和input_handler注销过程最终会调用这个函数，完成handle的注销
5. .fops = &evdev_fops, //对事件的操作函数
6. .minor = EVDEV_MINOR_BASE, //此设备号基数
7. .name = "evdev",
8. .id_table = evdev_ids, //匹配项
9. };

由上可知，handler->connect函数即为evdev_connect函数，下面分析之：

1. static int evdev_connect(struct input_handler *handler, struct input_dev *dev,
2. const struct input_device_id *id)
3. {
4. struct evdev *evdev;
5. int minor;
6. int error;
7. //EVDEV_MINOR为32，说明evdev这个handler可以同时有32个输入设备
8. //和它配对，evdev_table中以minor存放evdev结构体
9. for (minor = 0; minor < EVDEV_MINORS; minor++)
10. if (!evdev_table[minor])
11. break;
12. //判断32个位置是否被全部占用
13. if (minor == EVDEV_MINORS) {
14. pr_err( "no more free evdev devices\n");
15. return -ENFILE;
16. }
17. //分配一个evdev结构体，这个结构体是evdev事件处理器持有的
18. evdev = kzalloc( sizeof(struct evdev), GFP_KERNEL);
19. if (!evdev)
20. return -ENOMEM;
22. INIT_LIST_HEAD(&evdev->client_list);
23. spin_lock_init(&evdev->client_lock);
24. mutex_init(&evdev->mutex);
25. init_waitqueue_head(&evdev->wait);
27. //设置evdev中device的名字
28. dev_set_name(&evdev->dev, "event%d", minor);
29. evdev->exist = true;
30. evdev->minor = minor;
31. //初始化evdev中的handle，这样就连接了input_handler and input_dev
32. evdev->handle.dev = input_get_device(dev);
33. evdev->handle.name = dev_name(&evdev->dev);
34. evdev->handle.handler = handler;
35. evdev->handle. private = evdev;
37. evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);
38. evdev->dev.class = &input_class;
39. //配对生成的device，父设备是与他相关联的 input_dev
40. evdev->dev.parent = &dev->dev;
41. evdev->dev.release = evdev_free;
42. device_initialize(&evdev->dev);
43. //注册handle结构体
44. error = input_register_handle(&evdev->handle);
45. if (error)
46. goto err_free_evdev;
47. //把evdev结构体保存在evdev_table中
48. error = evdev_install_chrdev(evdev);
49. if (error)
50. goto err_unregister_handle;
51. //注册到linux设备模型
52. error = device_add(&evdev->dev);
53. if (error)
54. goto err_cleanup_evdev;
56. return 0;
58. err_cleanup_evdev:
59. evdev_cleanup(evdev);
60. err_unregister_handle:
61. input_unregister_handle(&evdev->handle);
62. err_free_evdev:
63. put_device(&evdev->dev);
64. return error;
65. }

在分析其中的 input_register_handle(&evdev->handle)函数：

1. int input_register_handle(struct input_handle *handle)
2. {
3. struct input_handler *handler = handle->handler;
4. struct input_dev *dev = handle->dev;
5. int error;
7. /*
8. * We take dev->mutex here to prevent race with
9. * input_release_device().
10. */
11. error = mutex_lock_interruptible(&dev->mutex);
12. if (error)
13. return error;
15. /*
16. * Filters go to the head of the list, normal handlers
17. * to the tail.
18. */
19. //将handle的d_node链接到其相关的input_dev的h_list链表中
20. if (handler->filter)
21. list_add_rcu(&handle->d_node, &dev->h_list);
22. else
23. list_add_tail_rcu(&handle->d_node, &dev->h_list);
25. mutex_unlock(&dev->mutex);
27. /*
28. * Since we are supposed to be called from ->connect()
29. * which is mutually exclusive with ->disconnect()
30. * we can't be racing with input_unregister_handle()
31. * and so separate lock is not needed here.
32. */
33. //将handle的h_node链接到其相关的input_handler的h_list链表中
34. list_add_tail_rcu(&handle->h_node, &handler->h_list);
36. if (handler->start)
37. handler->start(handle);
39. return 0;
40. }

  这个函数基本没做什么事情，就是把一个handle结构体通过d_node链表项或h_node链表项，分别链接到input_dev的h_list,input_handler的h_list上。以后通过这个h_list就可以遍历相关的input_handle了。具体可参考下图：

2.4：input输入子系统的设备驱动层

          其实上面两层基本都是系统做好了，我们要用linux的输入子系统的话，其实只要编写符合输入子系统框架的驱动程序即可。那么何为符合输入子系统框架呢？简单的可以概括如下：

        ①分配一个input_dev结构体；

        ②设置能够支持哪类事件及类下具体的事件类型

        ③注册input_dev结构体

       ④硬件相关的代码：如在中断中上报事件

     在MTK 6589平台中，上面的前三步都是在mtk_tpd.c中完成，而第四步在中断中上报事件则是在具体的Touch Panel驱动中完成。下面先看mtk_tpd.c:

    代码路径：alps/mediatek/custom/common/kernel/touchpanel/src/mtk_tpd.c   

1. /* called when loaded into kernel */
2. //入口函数
3. static int __ init tpd_device_init(void) {
4. printk( "MediaTek touch panel driver init\n");
5. //注册到platform总线上，匹配成功调用探测函数
6. if(platform_driver_register(&tpd_driver)!= 0) {
7. TPD_DMESG( "unable to register touch panel driver.\n");
8. return -1;
9. }
10. return 0;
11. }

继续看tpd_driver结构体：

1. static struct platform_driver tpd_driver = {
2. .remove = tpd_remove,
3. .shutdown = NULL,
4. .probe = tpd_probe, //探测函数
5. #ifndef CONFIG_HAS_EARLYSUSPEND
6. .suspend = NULL,
7. .resume = NULL,
8. #endif
9. .driver = {
10. .name = TPD_DEVICE,
11. },
12. };

上面的核心函数为tpd_probe()，在它里面完成了输入子系统前面的3个步骤。

1. static int tpd_probe(struct platform_device *pdev)
2. {
3. //......省略部分内容
4. //这里注册了一个misc设备
5. if (misc_register(&tpd_misc_device))
6. {
7. printk( "mtk_tpd: tpd_misc_device register failed\n");
8. }
9. //为tpd_device分配空间，是一个自定义的结构体，里面包括
10. //input_dev结构体
11. if((tpd=(struct tpd_device*)kmalloc( sizeof(struct tpd_device), GFP_KERNEL))== NULL) return -ENOMEM;
12. memset(tpd, 0, sizeof(struct tpd_device));
14. /* allocate input device */
15. //这里即是上面的第一步，分配了一个input_dev结构体
16. if((tpd->dev=input_allocate_device())== NULL) { kfree(tpd); return -ENOMEM; }
17. //......省略部分内容
18. /* struct input_dev dev initialization and registration */
19. //这里完成上面的第二步，设置支持哪些类事件及类下具体的事件类型
20. tpd->dev->name = TPD_DEVICE;
21. set_bit(EV_ABS, tpd->dev->evbit);
22. set_bit(EV_KEY, tpd->dev->evbit);
23. set_bit(ABS_X, tpd->dev->absbit);
24. set_bit(ABS_Y, tpd->dev->absbit);
25. set_bit(ABS_PRESSURE, tpd->dev->absbit);
26. set_bit(BTN_TOUCH, tpd->dev->keybit);
27. set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit);
28. //电容屏多点触控的一些设置
29. set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit);
30. set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit);
31. set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit);
32. set_bit(ABS_MT_POSITION_X, tpd->dev->absbit);
33. set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit);
34. //电容屏参数的一些设置
35. input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0);
36. input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0);
37. input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X);
38. input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y);
39. input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0);
40. //注册input_dev结构体
41. if(input_register_device(tpd->dev))
42. TPD_DMESG( "input_register_device failed.(tpd)\n");
44. }

接下来第四步的上报事件在驱动文件文件ft5316_driver.c中进行：

代码路径：alps/mediatek/custom/common/kernel/touchpanel/ft5316/ft5316_driver.c

1. /* called when loaded into kernel */
2. //驱动入口函数
3. static int __ init tpd_driver_init(void) {
4. //printk("MediaTek ft5316 touch panel driver init\n");
5. //i2c_register_board_info用于注册一个i2c client
6. i2c_register_board_info( 0, &ft5316_i2c_tpd, 1);
8. //tpd_driver_add函数在mtk_tpd.c中实现
9. if(tpd_driver_add(&tpd_device_driver) < 0)
10. TPD_DMESG( "add ft5316 driver failed\n");
11. return 0;
12. }

下面我们回到mtk_tpd.c函数中来分析tpd_driver_add函数：

1. /* Add driver: if find TPD_TYPE_CAPACITIVE driver sucessfully, loading it */
2. int tpd_driver_add(struct tpd_driver_t *tpd_drv)
3. {
4. //省略部分内容
5. for(i = 1; i < TP_DRV_MAX_COUNT; i++)
6. {
7. /* add tpd driver into list */
8. //将我们注册的TP驱动添加到tpd_driver_list链表中
9. if(tpd_driver_list[i].tpd_device_name == NULL)
10. {
11. tpd_driver_list[i].tpd_device_name = tpd_drv->tpd_device_name;
12. tpd_driver_list[i].tpd_local_init = tpd_drv->tpd_local_init;
13. tpd_driver_list[i].suspend = tpd_drv->suspend;
14. tpd_driver_list[i].resume = tpd_drv->resume;
15. tpd_driver_list[i].tpd_have_button = tpd_drv->tpd_have_button;
16. #if 0
17. if(tpd_drv->tpd_local_init()== 0)
18. {
19. TPD_DMESG( "load %s sucessfully\n", tpd_driver_list[i].tpd_device_name);
20. g_tpd_drv = &tpd_driver_list[i];
21. }
22. #endif
23. break;
24. }
25. if( strcmp(tpd_driver_list[i].tpd_device_name, tpd_drv->tpd_device_name) == 0)
26. {
27. return 1; // driver exist
28. }
29. }
31. return 0;
32. }

当touchpanel驱动中填充了这个链表后，在mtk_tpd.c中的tpd_probe()函数中会通过这个链表调用到驱动中注册的函数：

1. for(i = 1; i < TP_DRV_MAX_COUNT; i++)
2. {
3. /* add tpd driver into list */
4. if(tpd_driver_list[i].tpd_device_name != NULL)
5. {
6. //此处调用我们注册的tpd_local_init函数
7. tpd_driver_list[i].tpd_local_init();
8. //msleep(1);
9. if(tpd_load_status == 1) {
10. TPD_DMESG( "[mtk-tpd]tpd_probe, tpd_driver_name=%s\n", tpd_driver_list[i].tpd_device_name);
11. g_tpd_drv = &tpd_driver_list[i];
12. break;
13. }
14. }
15. }

接下来我们回到tp驱动，注册的结构体，其中包括了local_init（）函数：

1. static struct tpd_driver_t tpd_device_driver = {
2. .tpd_device_name = "ft5316",
3. .tpd_local_init = tpd_local_init,
4. .suspend = tpd_suspend,
5. .resume = tpd_resume,
6. #ifdef TPD_HAVE_BUTTON
7. .tpd_have_button = 1,
8. # else
9. .tpd_have_button = 0,
10. #endif
11. };

local_init（）函数：

1. static int tpd_local_init(void)
2. {
3. TPD_DMESG( "Focaltech ft5316 I2C Touchscreen Driver (Built %s @ %s)\n", __DATE__, __TIME__);
4. //注册i2c driver 这里会和i2c client匹配，然后进入i2c的probe函数
5. if(i2c_add_driver(&tpd_i2c_driver)!= 0)
6. {
7. TPD_DMESG( "ft5316 unable to add i2c driver.\n");
8. return -1;
9. }
10. if(tpd_load_status == 0)
11. {
12. TPD_DMESG( "ft5316 add error touch panel driver.\n");
13. i2c_del_driver(&tpd_i2c_driver);
14. return -1;
15. }
16. #ifdef TPD_HAVE_BUTTON    //虚拟按键的一些设置  
17.     tpd_button_setting(TPD_KEY_COUNT, tpd_keys_local, tpd_keys_dim_local); // initialize tpd button data
18. #endif  
20.   //表示电容TP
21. tpd_type_cap = 1;
22. return 0;
23. }
24. <span style= "font-family:Microsoft YaHei;font-size:12px;">接下来看tp的i2c_probe()函数：</span>
25. <pre name= "code" class= "cpp"> static struct i2c_driver tpd_i2c_driver = {
26. .driver = {
27. .name = "ft5316", //.name = TPD_DEVICE,
28. // .owner = THIS_MODULE,
29. },
30. .probe = tpd_probe,
31. .remove = __devexit_p(tpd_remove),
32. .id_table = ft5316_tpd_id,
33. .detect = tpd_detect,
34. // .address_data = &addr_data,
35. };

tpd_probe()函数：

1. static int __ devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id)
2. {
3. //......省略部分内容
4. //reset管脚的配置
5. mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);
6. mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);
7. mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);
8. msleep( 10);
9. hwPowerOn(TPD_POWER_SOURCE,VOL_2800, "TP"); //TP在此处上电，TPD_POWER_SOURCE为电源脚
10. msleep( 100);
12. //中断脚的配置
13. mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);
14. mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);
15. mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);
16. mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);
18. //中断及处理函数的注册
19. mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);
20. mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);
21. mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler, 0);
22. mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
24. //创建一个内核线程，这是TP工作的核心
25. thread = kthread_run(touch_event_handler, 0, TPD_DEVICE);
26. if (IS_ERR(thread))
27. {
28. retval = PTR_ERR(thread);
29. TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", retval);
30. }
31. //自动创建字符设备节点，用于调试
32. #ifdef FTS_CTL_IIC
33. if (ft_rw_iic_drv_init(client) < 0)
34. dev_err(&client->dev, "%s:[FTS] create fts control iic driver failed\n",
35. __func__);
36. #endif
37. }

下面我们就来分析这个非常重要的线程：

1. static int touch_event_handler(void *unused)
2. {
3. //......省略部分内容
4. do
5. {
6. mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);
7. set_current_state(TASK_INTERRUPTIBLE);
8. //当TP无触摸动作时，线程在此处阻塞
9. //当TP有触摸动作时，线程往下运行，标志位实在前面probe的中断函数中改变和唤醒的，
10. //中断函数只进行标志位的改变和唤醒线程，比较简单，不在分析
11. wait_event_interruptible(waiter,tpd_flag!= 0);
12. //标志位清零
13. tpd_flag = 0;
15. set_current_state(TASK_RUNNING);
16. //tpd_touchinfo函数用于获取触摸信息，此处不在祥解
17. if (tpd_touchinfo(&cinfo, &pinfo))
18. {
19. //printk("point_num = %d\n",point_num);
20. TPD_DEBUG_SET_TIME;
21. //根据获取的触摸信息，进行相应的上报工作
22. if(point_num > 0)
23. {
24. //printk("TPD Down!!!!!!!!!!!!!!!!!!\n");
25. tpd_down(cinfo.x[ 0], cinfo.y[ 0], cinfo.p[ 0]);
26. if(point_num> 1)
27. {
28. tpd_down(cinfo.x[ 1], cinfo.y[ 1], cinfo.p[ 1]);
29. if(point_num > 2)
30. {
31. tpd_down(cinfo.x[ 2], cinfo.y[ 2], cinfo.p[ 2]);
32. if(point_num > 3)
33. {
34. tpd_down(cinfo.x[ 3], cinfo.y[ 3], cinfo.p[ 3]);
35. if(point_num > 4)
36. {
37. tpd_down(cinfo.x[ 4], cinfo.y[ 4], cinfo.p[ 4]);
38. }
39. }
40. }
42. }
43. input_sync(tpd->dev); //上报完所有点后，再上报一个sync事件用于表示上报完
44. //printk("press --->\n");
46. }
47. //当现在无触摸动作而上次有触摸，抬起上次触摸的所有点
48. else if(p_point_num> 0)
49. {
50. int i;
51. for(i= 0;i<p_point_num;i++)
52. {
53. tpd_up(pinfo.x[i], pinfo.y[i], 0);
54. }
55. input_sync(tpd->dev);
56. }
57. /* else
58. {
60. tpd_up(cinfo.x[0], cinfo.y[0], 0);
61. //printk("Ghong_zguoqing_marked tpd point release --->\n");
62. //input_mt_sync(tpd->dev);
63. input_sync(tpd->dev);
64. }*/ //Ghong_zguoqing
65. }
67. } while(!kthread_should_stop());
68. }

下面重点看下上报函数，就拿tpd_down()函数分析：

1. static void tpd_down(int x, int y, int p)
2. {
3. input_report_key(tpd->dev, BTN_TOUCH, 1);
4. input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 1);
5. //分别上报x，y轴坐标
6.  input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);
7. input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);
9. input_mt_sync(tpd->dev);
10. }

 分析input_report_abs()函数，其调用了input_event()函数：

1. static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
2. {
3. input_event(dev, EV_ABS, code, value);
4. }
5. input_event()函数:
6. <pre name= "code" class= "cpp"> void input_event(struct input_dev *dev,
7. unsigned int type, unsigned int code, int value)
8. {
9. unsigned long flags;
11. //判断是否支持这种类型的事件
12. if (is_event_supported(type, dev->evbit, EV_MAX)) {
14. spin_lock_irqsave(&dev->event_lock, flags);
15. add_input_randomness(type, code, value);
16. //对上报的事件进行处理
17. input_handle_event(dev, type, code, value);
18. spin_unlock_irqrestore(&dev->event_lock, flags);
19. }
20. }

然后调用input_handle_event()函数：

1. static void input_handle_event(struct input_dev *dev,
2. unsigned int type, unsigned int code, int value)
3. {
4. //......省略部分内容
5. switch (type)
6. {
7. //......省略部分内容
8. case EV_KEY:
9. if (is_event_supported(code, dev->keybit, KEY_MAX) &&
10. !!test_bit(code, dev->key) != value) {
12. if (value != 2) {
13. __change_bit(code, dev->key);
14. if (value)
15. input_start_autorepeat(dev, code);
16. else
17. input_stop_autorepeat(dev);
18. }
20. disposition = INPUT_PASS_TO_HANDLERS;
21. }
22. break;
24. case EV_SW:
25. if (is_event_supported(code, dev->swbit, SW_MAX) &&
26. !!test_bit(code, dev->sw) != value) {
28. __change_bit(code, dev->sw);
29. disposition = INPUT_PASS_TO_HANDLERS;
30. }
31. break;
32. //......省略部分内容
33. if (disposition & INPUT_PASS_TO_HANDLERS)
34. input_pass_event(dev, type, code, value);
35. }
37. }

然后调用input_pass_event()函数：

1. static void input_pass_event(struct input_dev *dev,
2. unsigned int type, unsigned int code, int value)
3. {
4. struct input_handler *handler;
5. struct input_handle *handle;
7. rcu_read_lock();
8. //判断是否是绑定的handle
9. handle = rcu_dereference(dev->grab);
10. if (handle)
11. handle->handler->event(handle, type, code, value);
12. else {
13. //没有则遍历dev_list列表寻找handle
14. bool filtered = false;
16. list_for_each_entry_rcu(handle, &dev->h_list, d_node) {
17. //如果打开则将消息传递到input子系统去
18. if (!handle->open)
19. continue;
21. handler = handle->handler;
22. if (!handler->filter) {
23. if (filtered)
24. break;
26. handler->event(handle, type, code, value);
28. } else if (handler->filter(handle, type, code, value))
29. filtered = true;
30. }
31. }
33. rcu_read_unlock();
34. }

这个函数里面会将产生的数据传递给之前初始化的evdev_handler中的evdev_event函数进行进一步处理：

1. static void evdev_pass_event(struct evdev_client *client,
2. struct input_event *event,
3. ktime_t mono, ktime_t real)
4. {
5. event->time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?
6. mono : real);
8. /* Interrupts are disabled, just acquire the lock. */
9. spin_lock(&client->buffer_lock);
11. //传递消息
12. client->buffer[client->head++] = *event;
13. client->head &= client->bufsize - 1;
15. if (unlikely(client->head == client->tail)) {
16. /*
17. * This effectively "drops" all unconsumed events, leaving
18. * EV_SYN/SYN_DROPPED plus the newest event in the queue.
19. */
20. client->tail = (client->head - 2) & (client->bufsize - 1);
22. client->buffer[client->tail].time = event->time;
23. client->buffer[client->tail].type = EV_SYN;
24. client->buffer[client->tail].code = SYN_DROPPED;
25. client->buffer[client->tail].value = 0;
27. client->packet_head = client->tail;
28. if (client->use_wake_lock)
29. wake_unlock(&client->wake_lock);
30. }
32. if (event->type == EV_SYN && event->code == SYN_REPORT) {
33. client->packet_head = client->head;
34. if (client->use_wake_lock)
35. wake_lock(&client->wake_lock);
36. kill_fasync(&client->fasync, SIGIO, POLL_IN);
37. }
39. spin_unlock(&client->buffer_lock);
40. }

evdev_pass_event函数最终将时间传递给了用户端的evdev_client结构中的input_event数组，之后将这个数组传递给用户空间。
至此，linux的输入子系统就先分析道此处.