基于MTK架构的input子系统分析

参考文章：

http://blog.chinaunix.net/uid-21712186-id-3237358.html 

http://blog.csdn.net/lmm670/article/details/6087081 

http://blog.csdn.net/hongtao_liu/article/details/5679171 

INPUT子系统简介：

   对于众多的输入设备的驱动问题，linux提供了一套非常灵活的机制--input子系统。通过它我们只需要调用一些简单的函数，就可以将一个输入设备的功能呈现给应用程序。input输入子系统由输入子系统核心层(Input Core)，驱动层和事件处理层(Event Handler)三部份组成 ，下面为input子系统框架简图：

 

   驱动层负责和具体的硬件设备交互，得到硬件采集到的数据；input core则是起到一个中间层的作用，将数据上报；而事件驱动层则将上报的数据通过文件节点提供给上层使用。                                                                                                  

设备驱动：

   由于input子系统为我们完成了大部分的工作，因此在设备驱动层完成的工作很少。主要就是根据不同的设备功能来填充struct input_dev结构体，由于linux内核开发人员把所有可能的input设备功能都考虑进去了，因此该结构体就比较庞大。下面是MTK代码中为电容TP填充的input_dev结构体部分代码：

1 tpd->dev->name = TPD_DEVICE;

2 set_bit(EV_ABS, tpd->dev->evbit);

3 set_bit(EV_KEY, tpd->dev->evbit);

4 set_bit(ABS_X, tpd->dev->absbit);

5 set_bit(ABS_Y, tpd->dev->absbit);

6 set_bit(ABS_PRESSURE, tpd->dev->absbit);

7 set_bit(BTN_TOUCH, tpd->dev->keybit);

8 set_bit(ABS_MT_POSITION_X, tpd->dev->absbit);

9 set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit);

10 set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit);

11 set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit);

12 tpd->dev->absmax[ABS_MT_POSITION_X] = TPD_RES_X;

13 tpd->dev->absmin[ABS_MT_POSITION_X] = 0;

14 tpd->dev->absmax[ABS_MT_POSITION_Y] = TPD_RES_Y;

15 tpd->dev->absmin[ABS_MT_POSITION_Y] = 0;

 (本文贴出的代码，都是函数中的截取)

……

……

   2-3行表示TP支持的输入事件，按键事件和绝对坐标事件；4-6行又对绝对坐标事件进行了详细设置：坐标体系，支持压力范围；7行表示按键支持点击事件；8-11行用来描述手指等直接触摸TP表面，关于这方面的知识，请参阅linux多点触控协议；剩下的内容就是设置具体的值了。

  完成这些任务后，就可以调用内核提供的注册接口input_register_device来完成设备注册了，然后当底层产生数据时调用input_report_xx函数来将数据上报，剩下的任务就是input核心的工作了。

   关于input_report_xx函数，这里做一些说明：该函数实际上接收的参数是为了填充标准的事件结构体struct input_event，最后交由相应的事件驱动函数来处理(后面将介绍)。

input核心：

   input核心代码位于input.c当中。首先在input_init()中，input子系统调用register_chrdev()为自己注册了主设备号为13的256个字符设备节点（这也代表着系统中最多可以存在256个输入设备）。

   这256个设备会被分为8类，分别对应于数组 input_table[8]中存放的8个handler。这里举一个MTK中用到的evdev_handler的例子：关于evdev事件驱动位于evdev.c中，其input_handler结构体中minor赋值为64；当调用input_register_handler注册事件驱动时，可以看到下面一句话：

input_table[handler->minor >> 5] = handler；

那么就是input_table的第三个位置放的是evdev_handler。意思就是说，次设备号为64-95的输入设备，使用的是evdev_handler，而具体每个设备的此设备号的分配是顺序分配的(关于input_handler的涉及，将在后面叙述)。

   其次，input核心对设备驱动提供设备注册、卸载等等操作的接口；它将所有注册的设备都记录在名为input_dev_list的链表上；另外，input核心也提供handler注册、卸载等操作的接口；它将所有注册的handler都记录在名为input_handler_list的链表上。当handler或者input_dev注册时，input核心就会根据匹配条件在两条链表上进行handler和设备的匹配工作。

事件驱动：

   一个input_handler代表一个事件驱动，即相当于对一类输入设备的一种处理方式。首先，先简单介绍设备和事件驱动的匹配过程：我们可以在源码中看到，在设备/事件注册的函数中都会调用input_attach_handler，这个函数就是用来绑定设备和事件驱动的。它会遍历先前说过的两条链表，匹配规则为input_match_device，实际上就是对input_handler中设置的标志、变量和input_dev作一一对比。一旦匹配上之后(对于evdev_handler任意设备可以匹配)，就会去调用相应handler的connect函数，这里以evdev_handler为例说明，即其实现的evdev_connect函数，跟踪进去可以看到下面的一些语句：

1 for (minor = 0; minor < EVDEV_MINORS; minor++)

2  if (!evdev_table[minor])

3  break;

4 dev_set_name(&evdev->dev, "event%d", minor);

5 evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);

6 error = input_register_handle(&evdev->handle);

7 error = evdev_install_chrdev(evdev);

8 error = device_add(&evdev->dev);

1-3行说明了几个问题，由for语句可以验证之前提到的设备的次设备号是顺序分配的；然后这里有个evdev_table，是用来存放struct evdev的，这个结构体实际上是对匹配后的device、handle、mutex等变量的进一步封装；4行设置了device的名字，上层打开这个名字的设备，然后数据洪流就开始泛滥了；5行设置device的设备号，主设备号为input_init中设置的INPUT_MAJOR，次设备号为64-95(64+minor)；6行注册input_handle结构，该结构把input_dev和input_handler封装在一起；7行把填充好的struct evdev结构体放到数组evdev_table的空位置中；8行是关于linux设备模型的东东，调用后将会生成设备节点。

   然后，简单介绍下上层open设备后将发生什么(此时，设备节点已经创建)：当上层打开设备，linux的内核会根据主设备号找到驱动程序(即input_init中注册的input_fops)；然后调用fops中实现的input_open_file函数，在这里我们就可以通过次设备号找到具体设备的操作集了：

1 handler = input_table[iminor(inode) >> 5];

2 if (handler)

3 new_fops = fops_get(handler->fops);

4 old_fops = file->f_op;

5 file->f_op = new_fops;

6 err = new_fops->open(inode, file);

从上面的几句话我们就可以窥探一二，1-3行正是我们次设备号发挥作用的地方，1行确保次设备号为64-95之间的设备节点可以找到evdev_handler(input_table中存放8个handler)，2-3行就找到真正的fops诺，就是handler中注册的fops；4-5行把fops偷梁换柱，造成的效果就是你open后，然后read,write，表面上看非常正常，实际上，早就物似人非了……

6行就是调用我们应该调用的evdev_open了，只是饶了一个大弯。

   这里evdev_open的面纱我们也有必要揭一揭：

   1 struct evdev_client *client;

2 evdev = evdev_table[i];

3 client->evdev = evdev;

4 error = evdev_open_device(evdev);

5 file->private_data = client;

首先，1行有一个新的结构体struct evdev_client，里面最重要的就是一个struct input_event的数组，而input_event结构体是输入事件的一个通用包，就是底层填充这个包中的数据就可以上报了，那么对应设备所有上报的数据都放在evdev_client的数组里；2-3行将存放的相应struct evdev结构体取出来，放到client中去；4行又调用了一个函数，待会解释；5行将填充的client结构放到struct file中的private_data中去，不然你想在哪里找到它呢……

   上面提到的evdev_open_device函数，如果跟踪进去的话就几行代码，其中几行代码为：

else if (!evdev->open++) 

{

retval = input_open_device(&evdev->handle);

if (retval)

evdev->open--;

}

通过判断evdev.open变量，如果设备没有被打开的话，就会调用input_open_device函数，这个函数说白了就是给handle.open变量加1，大家可以自己跟进去看，这个open变量是否为0就关乎到数据是不是可以上报诺……

   在经过漫长的open后，上层就可以通过read、write、poll读写数据了，我们简单看下read实现：

1 struct evdev_client *client = file->private_data;

2 struct evdev *evdev = client->evdev;

3 while (retval + input_event_size() <= count &&

4        evdev_fetch_next_event(client, &event)) 

5 {

6 if (input_event_to_user(buffer + retval, &event))

7 return -EFAULT;

8 retval += input_event_size();

9 }

1-2行我们得到了存放在struct file中的evdev_client结构体和client中的struct evdev结构体(内核中为了保证接口的通用性和扩展性，都是采用给你留一片天地的方法)；3-9行就是从先前说的struct evdev_client中的input_event数组中读数据了，可以自己跟踪代码查看，其中的6-7行是保证内核层到用户层数据传送安全的内核函数。

   上层把设备文件打开了，一切数据结构都准备好了，等的就是从下往上报数据了。最后，我们来跟一下数据上报的流程，如果我们上报绝对值坐标事件，大致的上报流程如下简图。

input_report_xx只是input_event的简单封装，提高函数的重用性，不同的input_report_xx函数会给input_event传入不同的type参数(EV_KEY、EV_REL、EV_ABS...) ；然后input_event的实现也就是加锁然后直接调用input_handle_event函数；input_handle_event是一个switch语句，其中对于EV_ABS的流程如下：           

1 case EV_ABS:

2 if (is_event_supported(code, dev->absbit, ABS_MAX)) {

3 if (test_bit(code, input_abs_bypass)) {

4 disposition = INPUT_PASS_TO_HANDLERS;

5 break;

6 }

7 value = input_defuzz_abs_event(value,

8 dev->abs[code], dev->absfuzz[code]);

9 if (dev->abs[code] != value) {

10 dev->abs[code] = value;

11 disposition = INPUT_PASS_TO_HANDLERS;

12 }

13 }

1-2行首先判断input_dev是否支持code(事件代码)；3-6行判断code是否为input_abs_bypass中的一员，input_abs_bypass中记录的事件代码都是无缓存的，即不记录上一次数据，因此直接给disposition赋值，然后跳出；7-8行是用作误差校准，由于我们初始input_dev时并未设置absfuzz，因此这里其实没有变化；9-13行就是相对于3-6行的判断，这些事件代码的值都会存放，只有当事件值发生变化时才上传数据。函数的最后，就会调用input_pass_event函数(调用会根据disposition而变化)。

                         

                                                              数据report大致流程图

 

   下面流程到了input_pass_event函数了，这里也简单说几句：

1 bool filtered = false;

2 list_for_each_entry_rcu(handle, &dev->h_list, d_node) {

3 if (!handle->open)

4 continue;

5 handler = handle->handler;

6 if (!handler->filter) {

7 if (filtered)

8 break;

9 handler->event(handle, type, code, value);

这几句话这是核心部分，2-4行是遍历input_dev上的handle，如果handler中的open不为零(前面提到这个open关乎数据上报)就可以得到handle中的handler，然后调用时间驱动中实现的event函数。在evdev_handler中这个函数就是evdev_event了，不得已又要贴函数：

1 struct evdev *evdev = handle->private;

2 rcu_read_lock();

3 client = rcu_dereference(evdev->grab);

4 if (client)

5  evdev_pass_event(client, &event);

6 else

7  list_for_each_entry_rcu(client, &evdev->client_list, node)

8  evdev_pass_event(client, &event);

9 rcu_read_unlock();

可以看到1行我们拿到了先前说过的对一些数据进行封装的结构体struct evdev；2,9行是加锁、解锁的东东；3行我们没有设置(由上层调用相应ioctl设置)；6-8行我们用蠢方法来得到client结构体(为什么需要得到呢？)，然后把填充好的通用数据包input_event传给下一个函数evdev_pass_event。最后一个函数不贴了，自己进去看看，要是不知道干嘛，反省吧……

目录及原型：

mediatek/platform/mt6575/kernel/drivers/keypad/kpd.c

mediatek/custom/common/kernel/touchpanel/src/mtk_tpd.c

/drivers/input/evdev.c

/drivers/input/input.c

struct input_event {
 struct timeval time;//时间戳
 __u16 type;//事件类型
 __u16 code;//事件代码
 __s32 value;//事件值，如坐标的偏移值
}; 

struct evdev {

int exist;

int open;

int minor;

struct input_handle handle;

wait_queue_head_t wait;

struct evdev_client *grab;

struct list_head client_list;

spinlock_t client_lock; /* protects client_list */

struct mutex mutex;

struct device dev;

};

struct evdev_client {

struct input_event buffer[EVDEV_BUFFER_SIZE]; //message package of  input device

int head;

int tail;

spinlock_t buffer_lock; /* protects access to buffer, head and tail */

struct fasync_struct *fasync;

struct evdev *evdev;

struct list_head node;

struct wake_lock wake_lock;

char name[28];

};

struct input_handle {

void *private;

int open;

const char *name;

struct input_dev *dev;

struct input_handler *handler;

struct list_head d_node;

struct list_head h_node;

};

struct input_handler {

void *private;

void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);

bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);

bool (*match)(struct input_handler *handler, struct input_dev *dev);

int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);

void (*disconnect)(struct input_handle *handle);

void (*start)(struct input_handle *handle);

const struct file_operations *fops;

int minor;

const char *name;

const struct input_device_id *id_table;

struct list_head h_list;

struct list_head node;

};

struct input_dev {

 const char *name;

       const char *phys;

       const char *uniq;

       struct input_id id;

       unsigned long evbit[BITS_TO_LONGS(EV_CNT)]; ;//记录支持的事件类型的位图 

       unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];//记录支持的按键值的位图 

       unsigned long relbit[BITS_TO_LONGS(REL_CNT)];//记录支持的相对坐标的位图 

       unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];//记录支持的绝对坐标的位图 

       unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];

       unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];

       unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];

       unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];

       unsigned long swbit[BITS_TO_LONGS(SW_CNT)];

       unsigned int keycodemax;//支持的按键值的个数 

       unsigned int keycodesize;//每个键值的字节数 

       void *keycode;//存储按键值的数组首地址 

       int (*setkeycode)(struct input_dev *dev, int scancode, int keycode);

       int (*getkeycode)(struct input_dev *dev, int scancode, int *keycode);

       struct ff_device *ff;

       unsigned int repeat_key;//最近一次按键值，用于连击 

       struct timer_list timer;

       int sync;

       int abs[ABS_MAX + 1];//当前各个坐标的值 

       int rep[REP_MAX + 1];

       unsigned long key[BITS_TO_LONGS(KEY_CNT)];;//反映当前按键状态的位图 

       unsigned long led[BITS_TO_LONGS(LED_CNT)];//反映当前led状态的位图 

       unsigned long snd[BITS_TO_LONGS(SND_CNT)];//反映当前beep状态的位图 

       unsigned long sw[BITS_TO_LONGS(SW_CNT)];

 

       int absmax[ABS_MAX + 1];//记录各个坐标的最大值 

       int absmin[ABS_MAX + 1];;//记录各个坐标的最小值 

       int absfuzz[ABS_MAX + 1];//记录各个坐标的分辨率 

       int absflat[ABS_MAX + 1];//记录各个坐标的基准值 

 

       int (*open)(struct input_dev *dev);

       void (*close)(struct input_dev *dev);

       int (*flush)(struct input_dev *dev, struct file *file);

       int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

       struct input_handle *grab;

       spinlock_t event_lock;

       struct mutex mutex;

       unsigned int users;

       int going_away;

       struct device dev;

       struct list_head  h_list;

       struct list_head  node;

};