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：

struct input_dev {const char *name;    //设备名称const char *phys;       //设备在系统的物理路径const char *uniq;      //设备唯一识别符struct input_id id;     //设备ID，包含总线ID(PCI,USB)、厂商ID，与input_handler匹配时用到unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];     //bitmap of device properties and quirksunsigned 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)];         //支持的led灯事件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 hint_events_per_packet;                                     unsigned int keycodemax;   //keycode表的大小unsigned int keycodesize;  //keycode表中的元素个数void *keycode;//设备的键盘表//配置keycode表int (*setkeycode)(struct input_dev *dev,  const struct input_keymap_entry *ke,  unsigned int *old_keycode);//获取keycode表int (*getkeycode)(struct input_dev *dev,  struct input_keymap_entry *ke);struct ff_device *ff;unsigned int repeat_key;  //保存上一个键值struct timer_list timer;//定时器int rep[REP_CNT];struct input_mt_slot *mt;int mtsize;int slot;int trkid;struct input_absinfo *absinfo;unsigned long key[BITS_TO_LONGS(KEY_CNT)];unsigned long led[BITS_TO_LONGS(LED_CNT)];unsigned long snd[BITS_TO_LONGS(SND_CNT)];unsigned long sw[BITS_TO_LONGS(SW_CNT)];//操作接口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 __rcu *grab;  //当前使用的handlespinlock_t event_lock;struct mutex mutex;unsigned int users;bool going_away;bool sync;struct device dev;struct list_headh_list; //h_list是一个链表头，用来把handle挂载在这个上struct list_headnode; //这个node是用来连到input_dev_list上的};

     重要结构体之input_handler：

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_headh_list;    //h_list是一个链表头，用来把handle挂载在这个上struct list_headnode;    //这个node是用来连到input_handler_list上的 };

重要结构体之input_handle：

struct input_handle {        void *private;    //私有数据        int open;      const char *name;        struct input_dev *dev;  //指向input_dev      struct input_handler *handler;  //指向input_handler        struct list_head    d_node;  //连到input_dev的h_list      struct list_head    h_node; //连到input_handler的h_list  };  

重要结构体之evdev_client：

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

重要结构体之evdev：

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

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

/* * Event types */#define EV_SYN0x00               //同步时间#define EV_KEY0x01              //绝对二进制值，如键盘或者按钮  #define EV_REL0x02             //绝对结果，如鼠标设备#define EV_ABS0x03            //绝对整数值，如TP，操纵杆#define EV_MSC0x04             //其他类#define EV_SW0x05            //开关事件#define EV_LED0x11          //led或其他指示设备#define EV_SND0x12           //声音输出，如蜂鸣器#define EV_REP0x14          //允许按键重复#define EV_FF0x15           //力反馈#define EV_PWR0x16          //电源管理#define EV_FF_STATUS0x17       #define EV_MAX0x1f#define EV_CNT(EV_MAX+1)

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

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

//先分析入口函数:input_init(void)static int __init input_init(void){int err;        //创建一个input_class类err = class_register(&input_class);if (err) {pr_err("unable to register input_dev class\n");return err;}       //在/proc下创建入口项err = input_proc_init();if (err)goto fail1;      //注册主设备号为INPUT_MAJOR(13)的设备，并与input_fops关联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;}

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

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

进入input_open_file函数体实现：

static int input_open_file(struct inode *inode, struct file *file){struct input_handler *handler;const struct file_operations *old_fops, *new_fops = NULL;      //......省略部分内容      //根据打开的文件次设备号来得到一个input_handler结构handler = input_table[iminor(inode) >> 5];//通过handler得到新的file_operations结构体if (handler)new_fops = fops_get(handler->fops);            //......省略部分内容           //保存文件之前的f_opold_fops = file->f_op;//将新的f_op赋值给当前文件的f_opfile->f_op = new_fops;      //调用open函数，当应用程序打开文件时会调用这个函数err = new_fops->open(inode, file);if (err) {fops_put(file->f_op);file->f_op = fops_get(old_fops);}fops_put(old_fops);}

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

static struct input_handler *input_table[8];  //定义int input_register_handler(struct input_handler *handler){//......省略部分内容if (handler->fops != NULL) {if (input_table[handler->minor >> 5]) {retval = -EBUSY;goto out;}input_table[handler->minor >> 5] = handler;}    //......省略部分内容}

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

static int evdev_open(struct inode *inode, struct file *file){struct evdev *evdev;struct evdev_client *client;int i = iminor(inode) - EVDEV_MINOR_BASE;unsigned int bufsize;int error;if (i >= EVDEV_MINORS)  //判断是否超出了能处理的最大设备数return -ENODEV;error = mutex_lock_interruptible(&evdev_table_mutex);if (error)return error;evdev = evdev_table[i]; //得到evdev设备结构，每次调用evdev_connect配对成功后都会把分配的evdev结构体以minor为索引保存在evdev_table中if (evdev)get_device(&evdev->dev);  //增加device引用计数mutex_unlock(&evdev_table_mutex);if (!evdev)return -ENODEV;bufsize = evdev_compute_buffer_size(evdev->handle.dev);      //分配用户端结构client = kzalloc(sizeof(struct evdev_client) +bufsize * sizeof(struct input_event), GFP_KERNEL);if (!client) {error = -ENOMEM;goto err_put_evdev;}client->bufsize = bufsize;spin_lock_init(&client->buffer_lock);snprintf(client->name, sizeof(client->name), "%s-%d",dev_name(&evdev->dev), task_tgid_vnr(current));client->evdev = evdev;  //使用户端与evdev设备结构关联起来evdev_attach_client(evdev, client);  //把client链接到evdev的client链表上error = evdev_open_device(evdev);  //打开设备if (error)goto err_free_client;file->private_data = client;nonseekable_open(inode, file);return 0; err_free_client:evdev_detach_client(evdev, client);kfree(client); err_put_evdev:put_device(&evdev->dev);return error;}

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

static int evdev_open_device(struct evdev *evdev){int retval;retval = mutex_lock_interruptible(&evdev->mutex);if (retval)return retval;if (!evdev->exist)   //判断evdev结构体是否存在，在evdev_conect中初始化成员为1retval = -ENODEV;else if (!evdev->open++) {retval = input_open_device(&evdev->handle);  //打开设备if (retval)evdev->open--;}mutex_unlock(&evdev->mutex);return retval;}

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

int input_open_device(struct input_handle *handle){struct input_dev *dev = handle->dev;int retval;retval = mutex_lock_interruptible(&dev->mutex);if (retval)return retval;     //判断设备是否在open期间被注销if (dev->going_away) {retval = -ENODEV;goto out;}handle->open++;  //handle的打开计数加一if (!dev->users++ && dev->open)  //如果输入设备没有进程引用，并定义了打开方法，就调用open方法retval = dev->open(dev);if (retval) {    //如果没打开成功dev->users--;if (!--handle->open) {  //说明有进程打开了这个handle/* * Make sure we are not delivering any more events * through this handle */synchronize_rcu();}} out:mutex_unlock(&dev->mutex);return retval;}

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

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

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

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

//先分析入口函数static int __init evdev_init(void){return input_register_handler(&evdev_handler);//此处调用input_register_handler(&evdev_handler);}

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

int input_register_handler(struct input_handler *handler){struct input_dev *dev;int retval;retval = mutex_lock_interruptible(&input_mutex);if (retval)return retval;       //初始化handler的h_listINIT_LIST_HEAD(&handler->h_list);  //根据handler的minor将handler放到相应的input_table位置中if (handler->fops != NULL) {if (input_table[handler->minor >> 5]) {retval = -EBUSY;goto out;}input_table[handler->minor >> 5] = handler;}       //将handler通过node链接到input_handler_list链表中list_add_tail(&handler->node, &input_handler_list);       //遍历input_dev_list链表，找出与这个handler匹配的input_dev,并和它connect，       //匹配和connect的操作就是input_attach_handler所做的事情list_for_each_entry(dev, &input_dev_list, node)input_attach_handler(dev, handler);  //唤醒input_devices_poll_wait的等待队列input_wakeup_procfs_readers(); out:mutex_unlock(&input_mutex);return retval;}EXPORT_SYMBOL(input_register_handler);

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

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

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

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

static const struct input_device_id *input_match_device(struct input_handler *handler,struct input_dev *dev){const struct input_device_id *id;int i;       //遍历handler的id_table与device进行匹配for (id = handler->id_table; id->flags || id->driver_info; id++) {           //根据flags的标志位，按所需要匹配相应的字段if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)if (id->bustype != dev->id.bustype)        //总线类型不匹配continue;if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR)if (id->vendor != dev->id.vendor)           //生产厂商不匹配continue;if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)if (id->product != dev->id.product)        //产品不匹配continue;if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)    //版本不匹配if (id->version != dev->id.version)continue;MATCH_BIT(evbit,  EV_MAX);     //匹配所有的事件 //下面匹配所有的子事件MATCH_BIT(keybit, KEY_MAX);MATCH_BIT(relbit, REL_MAX);MATCH_BIT(absbit, ABS_MAX);MATCH_BIT(mscbit, MSC_MAX);MATCH_BIT(ledbit, LED_MAX);MATCH_BIT(sndbit, SND_MAX);MATCH_BIT(ffbit,  FF_MAX);MATCH_BIT(swbit,  SW_MAX);             //如果有定义handler->match则调用它             //由于我们注册&evdev_handler时并没定义match函数，所以直接返回id              if (!handler->match || handler->match(handler, dev))return id;}

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

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

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

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

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;       //EVDEV_MINOR为32，说明evdev这个handler可以同时有32个输入设备       //和它配对，evdev_table中以minor存放evdev结构体for (minor = 0; minor < EVDEV_MINORS; minor++)if (!evdev_table[minor])break;      //判断32个位置是否被全部占用if (minor == EVDEV_MINORS) {pr_err("no more free evdev devices\n");return -ENFILE;}      //分配一个evdev结构体，这个结构体是evdev事件处理器持有的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);//设置evdev中device的名字dev_set_name(&evdev->dev, "event%d", minor);evdev->exist = true;evdev->minor = minor;       //初始化evdev中的handle，这样就连接了input_handler and input_devevdev->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;//配对生成的device，父设备是与他相关联的 input_devevdev->dev.parent = &dev->dev;evdev->dev.release = evdev_free;device_initialize(&evdev->dev);       //注册handle结构体error = input_register_handle(&evdev->handle);if (error)goto err_free_evdev;      //把evdev结构体保存在evdev_table中error = evdev_install_chrdev(evdev);if (error)goto err_unregister_handle;      //注册到linux设备模型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;}

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

int input_register_handle(struct input_handle *handle){struct input_handler *handler = handle->handler;struct input_dev *dev = handle->dev;int error;/* * We take dev->mutex here to prevent race with * input_release_device(). */error = mutex_lock_interruptible(&dev->mutex);if (error)return error;/* * Filters go to the head of the list, normal handlers * to the tail. */ //将handle的d_node链接到其相关的input_dev的h_list链表中if (handler->filter)list_add_rcu(&handle->d_node, &dev->h_list);elselist_add_tail_rcu(&handle->d_node, &dev->h_list);mutex_unlock(&dev->mutex);/* * Since we are supposed to be called from ->connect() * which is mutually exclusive with ->disconnect() * we can't be racing with input_unregister_handle() * and so separate lock is not needed here. */ //将handle的h_node链接到其相关的input_handler的h_list链表中list_add_tail_rcu(&handle->h_node, &handler->h_list);if (handler->start)handler->start(handle);return 0;}

  这个函数基本没做什么事情，就是把一个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   

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

继续看tpd_driver结构体：

static struct platform_driver tpd_driver = {    .remove     = tpd_remove,    .shutdown   = NULL,    .probe      = tpd_probe,         //探测函数    #ifndef CONFIG_HAS_EARLYSUSPEND    .suspend    = NULL,    .resume     = NULL,    #endif    .driver     = {        .name = TPD_DEVICE,    },};

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

static int tpd_probe(struct platform_device *pdev) {    //......省略部分内容     //这里注册了一个misc设备    if (misc_register(&tpd_misc_device))    {printk("mtk_tpd: tpd_misc_device register failed\n");    }    //为tpd_device分配空间，是一个自定义的结构体，里面包括    //input_dev结构体    if((tpd=(struct tpd_device*)kmalloc(sizeof(struct tpd_device), GFP_KERNEL))==NULL) return -ENOMEM;    memset(tpd, 0, sizeof(struct tpd_device));    /* allocate input device */   //这里即是上面的第一步，分配了一个input_dev结构体    if((tpd->dev=input_allocate_device())==NULL) { kfree(tpd); return -ENOMEM; }    //......省略部分内容    /* struct input_dev dev initialization and registration */   //这里完成上面的第二步，设置支持哪些类事件及类下具体的事件类型     tpd->dev->name = TPD_DEVICE;    set_bit(EV_ABS, tpd->dev->evbit);    set_bit(EV_KEY, tpd->dev->evbit);    set_bit(ABS_X, tpd->dev->absbit);    set_bit(ABS_Y, tpd->dev->absbit);    set_bit(ABS_PRESSURE, tpd->dev->absbit);    set_bit(BTN_TOUCH, tpd->dev->keybit);    set_bit(INPUT_PROP_DIRECT, tpd->dev->propbit);    //电容屏多点触控的一些设置      set_bit(ABS_MT_TRACKING_ID, tpd->dev->absbit);    set_bit(ABS_MT_TOUCH_MAJOR, tpd->dev->absbit);    set_bit(ABS_MT_TOUCH_MINOR, tpd->dev->absbit);    set_bit(ABS_MT_POSITION_X, tpd->dev->absbit);    set_bit(ABS_MT_POSITION_Y, tpd->dev->absbit);    //电容屏参数的一些设置      input_set_abs_params(tpd->dev, ABS_X, 0, TPD_RES_X, 0, 0);      input_set_abs_params(tpd->dev, ABS_Y, 0, TPD_RES_Y, 0, 0);      input_abs_set_res(tpd->dev, ABS_X, TPD_RES_X);input_abs_set_res(tpd->dev, ABS_Y, TPD_RES_Y);input_set_abs_params(tpd->dev, ABS_PRESSURE, 0, 255, 0, 0);    //注册input_dev结构体     if(input_register_device(tpd->dev))        TPD_DMESG("input_register_device failed.(tpd)\n");}

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

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

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

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

/* Add driver: if find TPD_TYPE_CAPACITIVE driver sucessfully, loading it */int tpd_driver_add(struct tpd_driver_t *tpd_drv){     //省略部分内容for(i = 1; i < TP_DRV_MAX_COUNT; i++){/* add tpd driver into list *///将我们注册的TP驱动添加到tpd_driver_list链表中if(tpd_driver_list[i].tpd_device_name == NULL){tpd_driver_list[i].tpd_device_name = tpd_drv->tpd_device_name;tpd_driver_list[i].tpd_local_init = tpd_drv->tpd_local_init;tpd_driver_list[i].suspend = tpd_drv->suspend;tpd_driver_list[i].resume = tpd_drv->resume;tpd_driver_list[i].tpd_have_button = tpd_drv->tpd_have_button;#if 0if(tpd_drv->tpd_local_init()==0){TPD_DMESG("load %s sucessfully\n", tpd_driver_list[i].tpd_device_name);g_tpd_drv = &tpd_driver_list[i];}#endifbreak;}if(strcmp(tpd_driver_list[i].tpd_device_name, tpd_drv->tpd_device_name) == 0){return 1; // driver exist}}return 0;}

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

 for(i = 1; i < TP_DRV_MAX_COUNT; i++){    /* add tpd driver into list */if(tpd_driver_list[i].tpd_device_name != NULL){      //此处调用我们注册的tpd_local_init函数tpd_driver_list[i].tpd_local_init();//msleep(1);if(tpd_load_status ==1) {TPD_DMESG("[mtk-tpd]tpd_probe, tpd_driver_name=%s\n", tpd_driver_list[i].tpd_device_name);g_tpd_drv = &tpd_driver_list[i];break;}}      }

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

 static struct tpd_driver_t tpd_device_driver = { .tpd_device_name = "ft5316", .tpd_local_init = tpd_local_init, .suspend = tpd_suspend, .resume = tpd_resume,#ifdef TPD_HAVE_BUTTON .tpd_have_button = 1,#else .tpd_have_button = 0,#endif };

local_init（）函数：

static int tpd_local_init(void) {   TPD_DMESG("Focaltech ft5316 I2C Touchscreen Driver (Built %s @ %s)\n", __DATE__, __TIME__);   //注册i2c driver 这里会和i2c client匹配，然后进入i2c的probe函数   if(i2c_add_driver(&tpd_i2c_driver)!=0)   {  TPD_DMESG("ft5316 unable to add i2c driver.\n");      return -1;    }    if(tpd_load_status == 0)     {    TPD_DMESG("ft5316 add error touch panel driver.\n");    i2c_del_driver(&tpd_i2c_driver);    return -1;    }    #ifdef TPD_HAVE_BUTTON      //虚拟按键的一些设置      tpd_button_setting(TPD_KEY_COUNT, tpd_keys_local, tpd_keys_dim_local);// initialize tpd button data    #endif           //表示电容TPtpd_type_cap = 1;    return 0;  }<span style="font-family:Microsoft YaHei;font-size:12px;">接下来看tp的i2c_probe()函数：</span><pre name="code" class="cpp"> static struct i2c_driver tpd_i2c_driver = {  .driver = { .name = "ft5316",//.name = TPD_DEVICE,// .owner = THIS_MODULE,  },  .probe = tpd_probe,  .remove = __devexit_p(tpd_remove),  .id_table = ft5316_tpd_id,  .detect = tpd_detect,//  .address_data = &addr_data, };

tpd_probe()函数：

static int __devinit tpd_probe(struct i2c_client *client, const struct i2c_device_id *id){   //......省略部分内容  //reset管脚的配置   mt_set_gpio_mode(GPIO_CTP_RST_PIN, GPIO_CTP_RST_PIN_M_GPIO);                mt_set_gpio_dir(GPIO_CTP_RST_PIN, GPIO_DIR_OUT);   mt_set_gpio_out(GPIO_CTP_RST_PIN, GPIO_OUT_ONE);   msleep(10);   hwPowerOn(TPD_POWER_SOURCE,VOL_2800,"TP");  //TP在此处上电，TPD_POWER_SOURCE为电源脚   msleep(100);   //中断脚的配置   mt_set_gpio_mode(GPIO_CTP_EINT_PIN, GPIO_CTP_EINT_PIN_M_EINT);   mt_set_gpio_dir(GPIO_CTP_EINT_PIN, GPIO_DIR_IN);   mt_set_gpio_pull_enable(GPIO_CTP_EINT_PIN, GPIO_PULL_ENABLE);   mt_set_gpio_pull_select(GPIO_CTP_EINT_PIN, GPIO_PULL_UP);      //中断及处理函数的注册   mt65xx_eint_set_sens(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_SENSITIVE);   mt65xx_eint_set_hw_debounce(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_CN);   mt65xx_eint_registration(CUST_EINT_TOUCH_PANEL_NUM, CUST_EINT_TOUCH_PANEL_DEBOUNCE_EN, CUST_EINT_TOUCH_PANEL_POLARITY, tpd_eint_interrupt_handler,0);    mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);      //创建一个内核线程，这是TP工作的核心   thread = kthread_run(touch_event_handler, 0, TPD_DEVICE); if (IS_ERR(thread)) {   retval = PTR_ERR(thread);  TPD_DMESG(TPD_DEVICE " failed to create kernel thread: %d\n", retval);}  //自动创建字符设备节点，用于调试   #ifdef FTS_CTL_IICif (ft_rw_iic_drv_init(client) < 0)dev_err(&client->dev, "%s:[FTS] create fts control iic driver failed\n",__func__);   #endif}

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

 static int touch_event_handler(void *unused){   //......省略部分内容   do {  mt65xx_eint_unmask(CUST_EINT_TOUCH_PANEL_NUM);  set_current_state(TASK_INTERRUPTIBLE);                  //当TP无触摸动作时，线程在此处阻塞                 //当TP有触摸动作时，线程往下运行，标志位实在前面probe的中断函数中改变和唤醒的，                 //中断函数只进行标志位的改变和唤醒线程，比较简单，不在分析  wait_event_interruptible(waiter,tpd_flag!=0);//标志位清零  tpd_flag = 0;  set_current_state(TASK_RUNNING); //tpd_touchinfo函数用于获取触摸信息，此处不在祥解  if (tpd_touchinfo(&cinfo, &pinfo))   {    //printk("point_num = %d\n",point_num);TPD_DEBUG_SET_TIME;   //根据获取的触摸信息，进行相应的上报工作              if(point_num >0)     {//printk("TPD Down!!!!!!!!!!!!!!!!!!\n");                tpd_down(cinfo.x[0], cinfo.y[0], cinfo.p[0]);                if(point_num>1)             { tpd_down(cinfo.x[1], cinfo.y[1], cinfo.p[1]);if(point_num >2){tpd_down(cinfo.x[2], cinfo.y[2], cinfo.p[2]);if(point_num >3){tpd_down(cinfo.x[3], cinfo.y[3], cinfo.p[3]);if(point_num >4){tpd_down(cinfo.x[4], cinfo.y[4], cinfo.p[4]);}}}                }                input_sync(tpd->dev); //上报完所有点后，再上报一个sync事件用于表示上报完//printk("press --->\n");            }               //当现在无触摸动作而上次有触摸，抬起上次触摸的所有点else if(p_point_num>0) { int i;for(i=0;i<p_point_num;i++) { tpd_up(pinfo.x[i], pinfo.y[i], 0); } input_sync(tpd->dev); } /*else  { tpd_up(cinfo.x[0], cinfo.y[0], 0);//printk("Ghong_zguoqing_marked tpd point release --->\n");                 //input_mt_sync(tpd->dev);                input_sync(tpd->dev);}*/ //Ghong_zguoqing        } }while(!kthread_should_stop()); }

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

static  void tpd_down(int x, int y, int p) {   input_report_key(tpd->dev, BTN_TOUCH, 1);   input_report_abs(tpd->dev, ABS_MT_TOUCH_MAJOR, 1);   //分别上报x，y轴坐标   input_report_abs(tpd->dev, ABS_MT_POSITION_X, x);   input_report_abs(tpd->dev, ABS_MT_POSITION_Y, y);    input_mt_sync(tpd->dev);}

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

static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value){input_event(dev, EV_ABS, code, value);}input_event()函数:<pre name="code" class="cpp">void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value){unsigned long flags;      //判断是否支持这种类型的事件if (is_event_supported(type, dev->evbit, EV_MAX)) {spin_lock_irqsave(&dev->event_lock, flags);add_input_randomness(type, code, value);//对上报的事件进行处理input_handle_event(dev, type, code, value);spin_unlock_irqrestore(&dev->event_lock, flags);}}

然后调用input_handle_event()函数：

static void input_handle_event(struct input_dev *dev,       unsigned int type, unsigned int code, int value){    //......省略部分内容   switch (type)    {       //......省略部分内容case EV_KEY:if (is_event_supported(code, dev->keybit, KEY_MAX) &&    !!test_bit(code, dev->key) != value) {if (value != 2) {__change_bit(code, dev->key);if (value)input_start_autorepeat(dev, code);elseinput_stop_autorepeat(dev);}disposition = INPUT_PASS_TO_HANDLERS;}break;case EV_SW:if (is_event_supported(code, dev->swbit, SW_MAX) &&    !!test_bit(code, dev->sw) != value) {__change_bit(code, dev->sw);disposition = INPUT_PASS_TO_HANDLERS;}break;        //......省略部分内容        if (disposition & INPUT_PASS_TO_HANDLERS)input_pass_event(dev, type, code, value);    }    }

然后调用input_pass_event()函数：

static void input_pass_event(struct input_dev *dev,     unsigned int type, unsigned int code, int value){struct input_handler *handler;struct input_handle *handle;rcu_read_lock();      //判断是否是绑定的handlehandle = rcu_dereference(dev->grab);if (handle)handle->handler->event(handle, type, code, value);else {//没有则遍历dev_list列表寻找handlebool filtered = false;list_for_each_entry_rcu(handle, &dev->h_list, d_node) {//如果打开则将消息传递到input子系统去if (!handle->open)continue;handler = handle->handler;if (!handler->filter) {if (filtered)break;handler->event(handle, type, code, value);} else if (handler->filter(handle, type, code, value))filtered = true;}}rcu_read_unlock();}

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

static void evdev_pass_event(struct evdev_client *client,     struct input_event *event,     ktime_t mono, ktime_t real){event->time = ktime_to_timeval(client->clkid == CLOCK_MONOTONIC ?mono : real);/* Interrupts are disabled, just acquire the lock. */spin_lock(&client->buffer_lock);      //传递消息client->buffer[client->head++] = *event;client->head &= client->bufsize - 1;if (unlikely(client->head == client->tail)) {/* * This effectively "drops" all unconsumed events, leaving * EV_SYN/SYN_DROPPED plus the newest event in the queue. */client->tail = (client->head - 2) & (client->bufsize - 1);client->buffer[client->tail].time = event->time;client->buffer[client->tail].type = EV_SYN;client->buffer[client->tail].code = SYN_DROPPED;client->buffer[client->tail].value = 0;client->packet_head = client->tail;if (client->use_wake_lock)wake_unlock(&client->wake_lock);}if (event->type == EV_SYN && event->code == SYN_REPORT) {client->packet_head = client->head;if (client->use_wake_lock)wake_lock(&client->wake_lock);kill_fasync(&client->fasync, SIGIO, POLL_IN);}spin_unlock(&client->buffer_lock);}

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