gt9xx电容屏驱动分析

 电容屏驱动调试先了解Linux电容屏驱动中几个常用的概念：
             中断下半部-工作队列；
             input机制；
             Linux与Android 多点触摸协议。

一、中断下半部-工作队列

1、中断

      先看一下宋宝华先生的《linux设备驱动开发详解》里面对中断的描述吧。这本书个人感觉写的比较好，从开始学驱动到现在，还能从中得到不少知识。

      设备的中断会打断内核中进程的正常调度和运行，系统对更高吞吐率的追求势必要求中断服务程序尽可能地短小精悍。但是，这个良好的愿望往往与现实并不吻合。在大多数真实的系统中，当中断到来时，要完成的工作往往并不会是短小的，它可能要进行较大量的耗时处理。如下图描述了Linux内核的中断处理机制。为了在中断执行时间尽可能短和中断处理需完成大量工作之间找到一个平衡点，Linux将中断处理程序分解为两个半部：顶半部（top  half）和底半部（bottom half）。顶半部完成尽可能少的比较紧急的功能，它往往只是简单地读取寄存器中的中断状态并清除中断标志后就进行“登记中断”的工作。“登记中断”意味着将底半部处理程序挂到该设备的底半部执行队列中去。这样，顶半部执行的速度就会很快，可以服务更多的中断请求。现在，中断处理工作的重心就落在了底半部的头上，它来完成中断事件的绝大多数任务。底半部几乎做了中断处理程序所有的事情，而且可以被新的中断打断，这也是底半部和顶半部的最大不同，因为顶半部往往被设计成不可中断。底半部则相对来说并不是非常紧急的，而且相对比较耗时，不在硬件中断服务程序中执行。尽管顶半部、底半部的结合能够改善系统的响应能力，但是，僵化地认为Linux设备驱动中的中断处理一定要分两个半部则是不对的。如果中断要处理的工作本身很少，则完全可以直接在顶半部全部完成。

          其实上面这一段大致说明一个问题，那就是：中断要尽可能耗时比较短，尽快恢复系统正常调试，所以把中断触发、中断执行分开，也就是所说的“上半部分（中断触发）、底半部（中断执行）”，其实就是我们后面说的中断上下文。下半部分一般有tasklet、工作队列实现，触摸屏中中断实现以工作队列形式实现的，所以我们今天重点讲工作队列。

2、为什么还需要工作队列？

          工作队列（work queue）是另外一种将中断的部分工作推后的一种方式，它可以实现一些tasklet不能实现的工作，比如工作队列机制可以睡眠。这种差异的本质原因是，在工作队列机制中，将推后的工作交给一个称之为工作者线程（worker thread）的内核线程去完成（单核下一般会交给默认的线程events/0）。因此，在该机制中，当内核在执行中断的剩余工作时就处在进程上下文（process context）中。也就是说由工作队列所执行的中断代码会表现出进程的一些特性，最典型的就是可以重新调度甚至睡眠。

            对于tasklet机制（中断处理程序也是如此），内核在执行时处于中断上下文（interruptcontext）中。而中断上下文与进程毫无瓜葛，所以在中断上下文中就不能睡眠。因此，选择tasklet还是工作队列来完成下半部分应该不难选择。当推后的那部分中断程序需要睡眠时，工作队列毫无疑问是你的最佳选择；否则，还是用tasklet吧。

3、中断上下文

         有上面那个图可以看出上下两部分吧，就是上下文吧，这个比较好理解。

         看下别人比较专业的解释：

         在了解中断上下文时，先来回顾另一个熟悉概念：进程上下文（这个中文翻译真的不是很好理解，用“环境”比它好很多）。一般的进程运行在用户态，如果这个进程进行了系统调用，那么此时用户空间中的程序就进入了内核空间，并且称内核代表该进程运行于内核空间中。由于用户空间和内核空间具有不同的地址映射，并且用户空间的进程要传递很多变量、参数给内核，内核也要保存用户进程的一些寄存器、变量等，以便系统调用结束后回到用户空间继续执行。这样就产生了进程上下文。

          所谓的进程上下文，就是一个进程在执行的时候，CPU的所有寄存器中的值、进程的状态以及堆栈中的内容。当内核需要切换到另一个进程时（上下文切换），它需要保存当前进程的所有状态，即保存当前进程的进程上下文，以便再次执行该进程时，能够恢复切换时的状态继续执行。上述所说的工作队列所要做的工作都交给工作者线程来处理，因此它可以表现出进程的一些特性，比如说可以睡眠等。 对于中断而言，是硬件通过触发信号，导致内核调用中断处理程序，进入内核空间。这个过程中，硬件的一些变量和参数也要传递给内核，内核通过这些参数进行中断处理，中断上下文就可以理解为硬件传递过来的这些参数和内核需要保存的一些环境，主要是被中断的进程的环境。因此处于中断上下文的tasklet不会有睡眠这样的特性。

4、工作队列的使用方法

内核中通过下述结构体来表示一个具体的工作：

1.  struct work_struct  

2.      {  

3.        unsigned long pending;//这个工作是否正在等待处理  

4.        struct list_head entry;//链接所有工作的链表，形成工作队列  

5.        void (*func)(void *);//处理函数  

6.        void *data;//传递给处理函数的参数  

7.        void *wq_data;//内部使用数据  

8.        struct timer_list timer;//延迟的工作队列所用到的定时器  

9.      };  

          而这些工作（结构体）链接成的链表就是所谓的工作队列。工作者线程会在被唤醒时执行链表上的所有工作，当一个工作被执行完毕后，相应的work_struct结构体也会被删除。当这个工作链表上没有工作时，工作线程就会休眠。

（1）、通过如下宏可以创建一个要推后的完成的工作:

1.  DECLARE_WORK(name,void(*func)(void*),void*data);  

（2）、也可以通过下述宏动态创建一个工作:

1.  INIT_WORK(struct work_struct*work,void(*func)(void*),void *data);  

与tasklet类似，每个工作都有具体的工作队列处理函数，原型如下:

1.  void work_handler(void *data)  

将工作队列机制对应到具体的中断程序中，即那些被推后的工作将会在func所指向的那个工作队列处理函数中被执行。

（3）、实现了工作队列处理函数后，就需要schedule_work函数对这个工作进行调度，就像这样：

1.  schedule_work(&work);  

这样work会马上就被调度，一旦工作线程被唤醒，这个工作就会被执行（因为其所在工作队列会被执行）。

二、input子系统概述可见文章基于 mini2440 电阻式触摸屏（三）：Linux输入子系统(InputSubsystem)：

           按键、鼠标、触摸屏、电池信息等，都是通过input子系统上报。

三、Linux与Android 多点触摸协议

     为了使用功能强大的多点触控设备，就需要一种方案去上报用户层所需的详细的手指触摸数据。这个文档所描述的多点触控协议可以让内核驱动程序向用户层上报任意多指的数据信息。

1、使用说明

       单点触摸信息是以ABS承载并按一定顺序发送，如BTN_TOUCH、ABS_X、ABS_Y、SYNC。而多点触摸信息则是以ABS_MT承载并按一定顺序发送，如ABS_MT_POSITION_X、ABS_MT_POSITION_Y，然后通过调用input_mt_sync（）产生一个 SYN_MT_REPORTevent来标记一个点的结束，告诉接收方接收当前手指的信息并准备接收其它手指的触控信息。最后调用 input_sync（）函数上报触摸信息开始动作并告诉接收方开始接收下一系列多点触摸信息。

       协议定义了一系列ABS_MT事件，这些事件被分为几大类，充许只应用其中的一部份，多点触摸最小的事件集中应包括ABS_MT_TOUCH_MAJOR、ABS_MT_POSITION_X和ABS_MT_POSITION_Y，以此来实现多点触摸。如果设备支持ABS_MT_WIDTH_MAJOR这个事件，那么此事件可以提供手指触摸接触面积大小。触摸方向等信息可以由ABS_MT_TOUCH_MINOR,ABS_MT_WIDTH_MINOR and ABS_MT_ORIENTATION提供。ABS_MT_TOOL_TYPE提供触摸设备的类别，如手或是笔或是其它。最后有些设备可能会支持ABS_MT_TRACKING_ID，用来支持硬件跟踪多点信息，即该点属于哪一条线等。

1.  下面是两点触摸支持的最小事件集序列：  

2.  ABS_MT_TOUCH_MAJOR  

3.  ABS_MT_POSITION_X  

4.  ABS_MT_POSITION_Y  

5.  SYN_MT_REPORT //上报第一个点  

6.  ABS_MT_TOUCH_MAJOR  

7.  ABS_MT_POSITION_X  

8.  ABS_MT_POSITION_Y  

9.  SYN_MT_REPORT //上报第二个点  

10.            ………… //完成多点上报  

11. SYN_REPORT //开始动作  

2、Event原语

    接触”一词用来描述一个物体直接碰到另一个物体的表面。

    ABS_MT_TOUCH_MAJOR描述了主接触面的长轴，它和X，Y同一个单位，如果一个面的分辨率为X*Y，则ABS_MT_TOUCH_MAJOR的最大值为sqrt（X^2+Y^2）

1.  <span style="white-space:pre">  </span>ABS_MT_TOUCH_MINOR描述了接触面的短轴，如果接触面是圆形，它可以不用。  

2.      ABS_MT_WIDTH_MAJOR描述了接触工具的长轴  

3.      ABS_MT_WIDTH_MINOR描述了接触工具的短轴  

4.      ABS_MT_TOUCH_MAJOR := max（X, Y）  

5.      ABS_MT_TOUCH_MINOR := min（X, Y）  

6.      ABS_MT_ORIENTATION := bool（X > Y）  

               以上四个参数可以用来生成额外的触摸信息，ABS_MT_TOUCH_MAJOR/ABS_MT_WIDTH_MAJOR的比率可以用来描述压力。

               ABS_MT_ORIENTATION

               ABS_MT_POSITION_X接触面的中心点X坐标

               ABS_MT_POSITION_Y接触面的中心点Y坐标

               ABS_MT_TOOL_TYPE描述接触工具类型，很多内核驱动无法区分此参数如手指及笔，如果是这样，该参数可以不用，协议目前支持MT_TOOL_FINGER和MT_TOOL_PEN两种类型。

               ABS_MT_BLOB_ID形状集ID，集合几个点以描述一个形状，很多驱动没有形状属性，此参数可以不用。ABS_MT_TRACKING_ID描述了从接触开始到释放的整个过程的集合，如果设备不支持，此参数可是不用。

3、触摸轨迹

           仅有少数设备可以明触的标识真实的 trackingID，多数情况下 trackingID只能来标识一次触摸动作的过程。

4、手势

           多点触摸指定的应用是创建手势动作， TOUCH和 WIDTH参数经常用来区别手指的压力和手指间的距离，另外 MINOR类的参数可以用来区别设备的接触面的大小（点接触还是面接触），ORIENTATION可以产生旋转事件。

5、在Linux内核支持的基础上，Android在其2.0源码中加入多点触摸功能（android4.0中间层有所不同）

           由此触摸屏在Android的frameworks被完全分为2种实现途径：单点触摸屏的单点方式，多点触摸屏的单点和多点方式。

             在Linux的input.h中，多点触摸功能依赖于以下几个主要的软件位：

1.  ……  

2.  #define SYN_REPORT0  

3.  #define SYN_CONFIG1  

4.  #define SYN_MT_REPORT2  

5.  ……  

6.  #define ABS_MT_TOUCH_MAJOR  0x30  

7.  #define ABS_MT_TOUCH_MINOR  0x31  

8.  #define ABS_MT_WIDTH_MAJOR  0x32  

9.  #define ABS_MT_WIDTH_MINOR  0x33  

10. #define ABS_MT_ORIENTATION  0x34  

11. #define ABS_MT_POSITION_X    0x35  

12. #define ABS_MT_POSITION_Y    0x36  

13. #define ABS_MT_TOOL_TYPE      0x37  

14. #define ABS_MT_BLOB_ID        0x38  

15. ……  

在Android中对应的软件位定义在RawInputEvent.java中：……  

1.   public class RawInputEvent {  

2.   ……  

3.   public static final int CLASS_TOUCHSCREEN_MT = 0x00000010;  

4.   ……  

5.   public static final int ABS_MT_TOUCH_MAJOR = 0x30;  

6.   public static final int ABS_MT_TOUCH_MINOR = 0x31;  

7.   public static final int ABS_MT_WIDTH_MAJOR = 0x32;  

8.   public static final int ABS_MT_WIDTH_MINOR = 0x33;  

9.   public static final int ABS_MT_ORIENTATION = 0x34;  

10.  public static final int ABS_MT_POSITION_X = 0x35;  

11.  public static final int ABS_MT_POSITION_Y = 0x36;  

12.  public static final int ABS_MT_TOOL_TYPE = 0x37;  

13.  public static final int ABS_MT_BLOB_ID = 0x38;  

14.  ……  

15.  public static final int SYN_REPORT = 0;  

16.  public static final int SYN_CONFIG = 1;  

17.  public static final int SYN_MT_REPORT = 2;  

18.  ……  

   在Android中，多点触摸的实现方法在具体的代码实现中和单点是完全区分开的。在Android代码的EventHub.cpp中，单点屏和多点屏由如下代码段来判定：

1.  int EventHub::open_device（const char *deviceName）  

2.  {  

3.  ……  

4.  if （test_bit（ABS_MT_TOUCH_MAJOR, abs_bitmask）  

5.  && test_bit（ABS_MT_POSITION_X, abs_bitmask）  

6.  && test_bit（ABS_MT_POSITION_Y, abs_bitmask）） {  

7.  device->classes |= CLASS_TOUCHSCREEN | CLASS_TOUCHSCREEN_MT;  

8.  //LOGI（"It is a multi-touch screen!"）；  

9.  }  

10.   

11. //single-touch?  

12. else if （test_bit（BTN_TOUCH, key_bitmask）  

13. && test_bit（ABS_X, abs_bitmask）  

14. && test_bit（ABS_Y, abs_bitmask）） {  

15. device->classes |= CLASS_TOUCHSCREEN;  

16. //LOGI（"It is a single-touch screen!"）；  

17. }  

18. ……  

19. }  

               我们知道，在触摸屏驱动中，通常在probe函数中会调用input_set_abs_params给设备的input_dev结构体初始化，这些input_dev的参数会在Android的EventHub.cpp中被读取。如上可知，如果我们的触摸屏想被当成多点屏被处理，只需要在驱动中给input_dev额外增加以下几个参数即可：

1.   input_set_abs_params（mcs_data.input, ABS_MT_POSITION_X, pdata->abs_x_min, pdata->abs_x_max, 0, 0）；  

2.   input_set_abs_params（mcs_data.input, ABS_MT_POSITION_Y, pdata->abs_y_min, pdata->abs_y_max, 0, 0）；  

3.   input_set_abs_params（mcs_data.input, ABS_MT_TOUCH_MAJOR, 0, 15, 0, 0）；//相当于单点屏的ABX_PRESSURE  

4.   input_set_abs_params（mcs_data.input, ABS_MT_WIDTH_MAJOR, 0, 15, 0, 0）；//相当于单点屏的ABS_TOOL_WIDTH  

   由于多点触摸技术需要采集到多个点，然后再一起处理这些点，所以在软件实现中需要保证每一波点的准确性和完整性。因此，Linux内核提供了input_mt_sync（struct input_dev* input）函数。在每波的每个点上报后需要紧跟一句input_mt_sync（），当这波所有点上报后再使用input_sync（）进行同步。

1.  例如一波要上报3个点：  

2.     ……  

3.    input_mt_sync（input）；  

4.    ……  

5.    input_mt_sync（input）；  

6.    ……  

7.    input_mt_sync（input）；  

8.    input_sync（input）；  

9.   注：即使是仅上报一个点的单点事件，也需要一次input_mt_sync。<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">  

10. </span></span>  

以goodix的gt8105为例

一、总体架构

硬件部分：先看一个总体的图吧，其实触摸屏原理也比较简单，触摸屏和主控芯片间的联系，如下主要有三部分：

1、IIC部分，初始化gt8105的数据和传回主控制的坐标位置信息就是通过IIC这条线传输的；

2、INT，当gt8105初触摸时，会发出中断通知主控接收信息（坐标数据）；

3、gt8105电源、复位这一部分，不同芯片有所不同，可以根据触摸屏芯片来配置。

 软件部分：

 二、电容触摸屏的主要参数（这部分面试的时候也许有人会问的）

     记得刚出来找工作时有人问我一些问题，我答不上来，现在感觉很清晰（那时候刚毕业IIC我都说不全）

1、IIC
（1）、clk370KHz~400KHz；
（2）、触摸屏工作在从模式，这个比较简单；
2、电容检测频率，也就是每秒检测的次数:（大概）
（1）、单指≥100Hz；
（2）、五指≥80Hz；
（3）、十指≥60Hz。
3、手指按下，没抬起时触发多少中断？
           中断个数也就是检测频率，按下没提起一直有中断。这样我们就可有判断单点、划线之类的操作；
4、校准功能、自动校准（有个别电容屏没有的，用软件校准）
（1）、初始化校准
            不同的温度、湿度及物理空间结构均会影响到电容传感器在闲置状态的基准值。一般电容触摸屏会在初始化的 200ms内根据环境情况自动获得新的检测基准。完成触摸屏检测的初始化。
（2）、自动温漂补偿
             温度、湿度或灰尘等环境因素的缓慢变化,也会影响到电容传感器在闲置状态的基准值。实时检测各点数据的变化,对历史数据进行统计分析,由此来修正检测基准。从而降低环境变化对触摸屏检测的影响。    
5、推荐工作条件(环境温度为 25°C,VDD=2.8V)

参数	最小值	典型值	最大值	单位
模拟AVDD(参考AGND)	2.5	2.8	3.6	V
数字DVDD(参考DGND)	2.5	2.8	3.6	V
电源纹波		50(注意电池、充电器的影响)		mV
工作温度	-20	+25	+85	度
工作湿度	-	-	95	%

三、硬件接口电路：

如下图：

SDA	IIC数据 要上拉电阻，为1K；
SCL	IIC 时钟（400KHz）
TP_EN	使能脚（gt8105为高电平）
INT	中断（一直点到触摸屏时中断是一直发出的）
VCC	3.3V 这个电压一直有
GND	地

三、IIC配置

               设备到芯片的数据、初始化值都是从这条总线上传输的，首先我们要配置这个条总线，

/linux/arch/arm/mach-exynos/mach-smdkv310.c,这个因平台而已，地址右移也跟情况而定，如果本来就是7bit的地址就不用移位。

1.  static struct i2c_board_info i2c_devs5[] __initdata = {  

2.  #if CONFIG_TOUCHSCREEN_GT8105  

3.            {  

4.                      I2C_BOARD_INFO("Goodix-TS", (0xaa>>1)),  

5.                      .irq = IRQ_EINT(5),  

6.            }  

7.  #endif  

8.  };  

四、电源、复位（使能脚）

1、电源

          3.3V的电源是一直有的，这个硬件上给就行了。

2、复位（时能脚），这个因触摸屏而已，gt8105工作时要高电平。

在：linux3.0/drivers/input/touchscreen/goodix_touch.h中

1.  #define          RESETPIN_CFG          s3c_gpio_cfgpin(EXYNOS4_GPB(4), S3C_GPIO_OUTPUT)  

2.  #define          RESETPIN_SET0           gpio_direction_output(EXYNOS4_GPB(4),0)  

3.  #define          RESETPIN_SET1          gpio_direction_output(EXYNOS4_GPB(4),1)  

4.  static void goodix_reset(void)  

5.  {  

6.            int err;  

7.            err = gpio_request(EXYNOS4_GPB(4), "GPX1");  

8.            if (err)  

9.            printk(KERN_ERR "#### failed to request GPB_4 ####\n");  

10.           RESETPIN_CFG; //配置管脚功能  

11.           RESETPIN_SET0;//管脚拉低  

12.           mdelay(20); //延时  

13.           RESETPIN_SET1;//管脚拉高  

14.           mdelay(60);  

15.           gpio_free(EXYNOS4_GPB(4));  

16. }  

五、中断配置

在：linux3.0/drivers/input/touchscreen/goodix_touch.h中

1.  #define INT_PORT EXYNOS4_GPX0(5)  

2.  #ifdef INT_PORT  

3.            #define TS_INT                     IRQ_EINT(5)//中断引脚，中断号            

4.            #define INT_CFG           S3C_GPIO_SFN(0x0F)                                                    

5.  #else  

6.     

7.  在：linux3.0/drivers/input/touchscreen/goodix_touch.h中 中断申请  

8.  #ifdef INT_PORT  

9.            client->irq=TS_INT;  

10.           if (client->irq)   

11.           {  

12.              ret = request_irq(client->irq, goodix_ts_irq_handler , IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING,client->name, ts);  

13. #endif  

 上面三部完成了触摸屏工作的最基本配置，保证IIC、上电、INT正常，触摸屏就可以工作。

六、驱动程序分析（完整代码见 goodix_touch.c/goodix_touch.h）

      驱动有几个比较重要的部分：probe函数分析；中断申请、工作队列调度；中断下半部函数的执行，坐标值计算、上报。

1、probe函数分析

1.  static int goodix_ts_probe(struct i2c_client *client, const struct i2c_device_id *id)  

2.  {  

3.            struct goodix_ts_data *ts;  

4.            …………  

5.            // 1,分配触摸屏结构内核空间；  

6.            ts = kzalloc(sizeof(*ts), GFP_KERNEL);   

7.            …………  

8.            // 2,初始化工作队列，这个比较重要，中断触发后，调用队列中的goodix_ts_work_func函数，计算上报坐标值；  

9.            INIT_WORK(&ts->work, goodix_ts_work_func);   

10.           …………  

11.           // 3, 触摸芯片初始化；  

12.           for(retry=0; retry<3; retry++)  

13.           {  

14.                     ret=goodix_init_panel(ts);  

15.           …………  

16.           }  

17.           //4、触摸屏复位，拉高；  

18.           goodix_reset();                       

19. #ifdef INT_PORT  

20.           // 5,中断申请，TS_INT就是我们所设定的中断脚；  

21.           client->irq=TS_INT;                                               

22.           ret = request_irq(client->irq, goodix_ts_irq_handler , IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING, client->name, ts);  

23.           ………………  

24. #endif  

25.    

26.           // 6、分配input驱动内核空间；  

27.           ts->input_dev = input_allocate_device();   

28.   // 7,input初始化参数设定，我们在前面提到Linux与Android 多点触摸协议里有对这部分说明；  

29.           ts->input_dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) ;  

30.           ts->input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);  

31.           ts->input_dev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);       // absolute coor (x,y)  

32. #ifdef HAVE_TOUCH_KEY  

33.           for(retry = 0; retry < MAX_KEY_NUM; retry++)  

34.           {  

35.          input_set_capability(ts->input_dev,EV_KEY,touch_key_array[retry]); 

36.           }  

37. #endif  

38.    

39.           input_set_abs_params(ts->input_dev, ABS_X, 0, ts->abs_x_max, 0, 0);  

40.           input_set_abs_params(ts->input_dev, ABS_Y, 0, ts->abs_y_max, 0, 0);  

41.           input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 255, 0, 0);  

42.           //8、这部分针对触摸屏参数设定；  

43. #ifdef GOODIX_MULTI_TOUCH  

44.           input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);  

45.           input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);  

46.           input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X, 0, ts->abs_x_max, 0, 0);  

47.           input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y, 0, ts->abs_y_max, 0, 0);  

48.           input_set_abs_params(ts->input_dev, ABS_MT_TRACKING_ID, 0, ts->max_touch_num, 0, 0);  

49. #endif            

50.           //9、触摸屏版本信息设定；  

51.           sprintf(ts->phys, "input/ts");  

52.           ts->input_dev->name = goodix_ts_name;  

53.           ts->input_dev->phys = ts->phys;  

54.           ts->input_dev->id.bustype = BUS_I2C;  

55.           ts->input_dev->id.vendor = 0xDEAD;  

56.           ts->input_dev->id.product = 0xBEEF;  

57.           ts->input_dev->id.version = 10427;   //screen firmware version  

58.           //10,对于input子系统来说，这个是重头戏了，只有注册了input子系统，其他的才有做用；  

59.           ret = input_register_device(ts->input_dev);   

60.           ………………  

61.           // 11,对睡眠唤醒操作；  

62. #ifdef CONFIG_HAS_EARLYSUSPEND   

63.           ts->early_suspend.level = EARLY_SUSPEND_LEVEL_BLANK_SCREEN + 1;  

64.           ts->early_suspend.suspend = goodix_ts_early_suspend;  

65.           ts->early_suspend.resume = goodix_ts_late_resume;  

66.           register_early_suspend(&ts->early_suspend);  

67. #endif  

68. ………………  

69. }  

（1）、分配触摸屏结构内核空间；

1.  struct goodix_ts_data {  

2.            uint16_t addr;  

3.            uint8_t bad_data;  

4.            struct i2c_client *client;  

5.            struct input_dev *input_dev;  

6.            int use_reset;                    //use RESET flag  

7.            int use_irq;                    //use EINT flag  

8.            int read_mode;                    //read moudle mode,20110221 by andrew  

9.            struct hrtimer timer;  

10.           struct work_struct work;  

11.           char phys[32];  

12.           int retry;  

13.           struct early_suspend early_suspend;  

14.           int (*power)(struct goodix_ts_data * ts, int on);  

15.           uint16_t abs_x_max;  

16.           uint16_t abs_y_max;  

17.           uint8_t max_touch_num;  

18.           uint8_t int_trigger_type;  

19.           uint8_t green_wake_mode;  

20. };  

（2）、初始化工作队列，这个比较重要，中断触发后，调用队列中的goodix_ts_work_func函数，计算上报坐标值；这个和中断申请一起分析；

（3）、触摸芯片初始化；

          对触摸芯片寄存器的初始化，这里面对中断方式设定等，一般芯片厂的FAE在调试的时候会修改这里面的值，这个也是因芯片而异，有的在驱动里做，可以直接改；有的直接做成固件了，那部分要FAE帮忙了。

1.  uint8_t cfg_info_group1[] =   

2.            {           

3.               0x65,0x00,0x25,0x80,0x19,0x00,0x00,0x2C,0x11,0x11,0x32,0x02,0x08,0x10,0x20,0x00,  

4.               0x00,0x88,0x88,0x88,0x03,0x13,0x32,0x64,0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,  

5.               0x08,0x09,0x0A,0x0B,0x0C,0xFF,0x0D,0x0E,0x0F,0x10,0x11,0x12,0x13,0x14,0x15,0x16,  

6.               0x17,0x18,0x19,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  

7.               0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,  

8.               0x00,0x00,0x00,0x00  

9.            };  

（4）、触摸屏复位，拉高；

          gt8015在工作时要拉高，所以我们做一个拉低—延时--拉高的操作；

（5）、中断申请，TS_INT就是我们所设定的中断脚，和（2）一起后面分析；

（6）、分配input驱动内核空间；

1.  ts->input_dev= input_allocate_device();  

（7）、input初始化参数设定，我们在前面提到Linux与Android 多点触摸协议里有对这部分说明；

（8）、这部分针对触摸屏参数设定；

（9）、触摸屏版本信息设定；

1.  cat /proc/bus/input/devices时可以看到下面信息（这个是pixcir的触摸屏）  

2.  I: Bus=0018 Vendor=0000 Product=0000 Version=0000  

3.  N: Name="pixcir-ts"  

4.  P: Phys=  

5.  S: Sysfs=/devices/platform/s3c2440-i2c.5/i2c-5/5-005c/input/input3  

6.  U: Uniq=  

7.  H: Handlers=kbd event3   

8.  B: PROP=0  

9.  B: EV=b  

10. B: KEY=400 0 0 0 0 1000 40000800 0 0 0 0  

11. B: ABS=2650000 1000000  

（10）、对于input子系统来说，这个是重头戏了，驱动注册到input子系统；

1.   input_register_device(ts->input_dev);  

（11）、触摸屏睡眠唤醒操作，这部分不做详细说明，感兴趣的可以看下……

2、中断申请、工作队列调度

（1）、中断申请

1.    ret = request_irq(client->irq, goodix_ts_irq_handler , IRQ_TYPE_EDGE_RISING|IRQ_TYPE_EDGE_FALLING,  client->name, ts);  

2.  第一个参数： 中断号，client->irq，client->irq=TS_INT;  

3.  #define TS_INT                     IRQ_EINT(5)对应到我们要申请的中断；  

4.  第二个参数：中断执行函数，goodix_ts_irq_handler ；  

5.  第三个参数：中断触发方式：上升沿触发、下降沿触发、高电平触发、低电平触发  

6.  IRQ_TYPE_EDGE_RISING,  

7.  IRQ_TYPE_EDGE_FALLING,  

8.  IRQ_TYPE_LEVEL_LOW,  

9.  IRQ_TYPE_LEVEL_HIGH  

10. 第四个参数：  

11. 第五个参数：  

（2）、中断处理函数 goodix_ts_irq_handler

1.  static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)  

2.  {  

3.            struct goodix_ts_data *ts = dev_id;  

4.            queue_work(goodix_wq, &ts->work);  

5.            return IRQ_HANDLED;  

6.  }  

看下queue_work()这个函数中的两个参数：

a、goodix_wq

1.  goodix_wq=create_singlethread_workqueue("goodix_wq");  //createa work queue and worker thread  

在函数 goodix_ts_init中，创建工作队列和工作线程,初始化时创建线程。

b、&ts->work

           在函数goodix_ts_probe（）中：

1.  INIT_WORK(&ts->work,goodix_ts_work_func);  

          在工作队列&ts->work中增加 goodix_ts_work_func任务。

          也就是当中断函数触发时，执行中断函数goodix_ts_irq_handler（），中断函数里面对队列调度，调用队列中的goodix_ts_work_func（）函数。

3、中断下半部函数的执行goodix_ts_work_func（）函数

这就是核心部分，坐标点的计算、上报、多点处理都在这个函数中执行。

1.  static void goodix_ts_work_func(struct work_struct *work)  

2.  {            

3.            int ret=-1;  

4.            int tmp = 0;  

5.            uint8_t point_data[(1-READ_COOR_ADDR)+1+2+5*MAX_FINGER_NUM+1]={ 0 }; //read address(1byte)+key index(1byte)+point mask(2bytes)+5bytes*MAX_FINGER_NUM+coor checksum(1byte)  

6.            uint8_t check_sum = 0;  

7.            uint16_t finger_current = 0;  

8.            uint16_t finger_bit = 0;  

9.            unsigned int count = 0, point_count = 0;  

10.           unsigned int position = 0;            

11.           uint8_t track_id[MAX_FINGER_NUM] = {0};  

12.           unsigned int input_x = 0;  

13.           unsigned int input_y = 0;  

14.           unsigned int input_w = 0;  

15.           unsigned char index = 0;  

16.           unsigned char touch_num = 0;  

17.              

18.           struct goodix_ts_data *ts = container_of(work, struct goodix_ts_data, work);  

          if(g_enter_isp)return;  

19.           COORDINATE_POLL:  

20.           if((ts->int_trigger_type> 1)&& (gpio_get_value(INT_PORT) != (ts->int_trigger_type&0x01)))  

21.           {  

22.                     goto NO_ACTION;  

23.           }                      

24.    

25.           if( tmp > 9) {  

26.                        

27.                     dev_info(&(ts->client->dev), "I2C transfer error,touchscreen stop working.\n");  

28.                     goto XFER_ERROR ;  

29.           }  

30.              

31.           if(ts->bad_data)            

32.                     msleep(20);  

33.              

34.           point_data[0] = READ_COOR_ADDR;                    //read coor address  

35.           //1、读取触摸屏值，手指数、坐标值等；  

36.           ret=i2c_read_bytes(ts->client, point_data, ((1-READ_COOR_ADDR)+1+2+5*ts->max_touch_num+1));  

37.           …………  

38.           //2、判断是否有手指按下；  

39.           finger_current = (point_data[3 - READ_COOR_ADDR]<<8) + point_data[2 – READ_COOR_ADDR];  

40.              

41.           if(finger_current)//3、如果有手指按下  

42.           {            

43.                     point_count = 0, finger_bit = finger_current;  

44.                     //3，循环判断有多少手指按下；  

45.                     for(count = 0; (finger_bit != 0) && (count < ts->max_touch_num); count++)//cal how many point touch currntly  

46.                     {  

47.                               if(finger_bit & 0x01)  

48.                               {  

49.                                         track_id[point_count] = count;  

50.                                         point_count++;  

51.                               }  

52.                               finger_bit >>= 1;  

53.                     }  

54.                     //4、把按下手指数赋给touch_num；  

55.                     touch_num = point_count;  

56.                     //5、计算坐标值；  

57.                     check_sum = point_data[2 - READ_COOR_ADDR] + point_data[3 - READ_COOR_ADDR];                               //cal coor checksum  

58.                     count = 4 - READ_COOR_ADDR;  

59.                     for(point_count *= 5; point_count > 0; point_count--)  

60.                               check_sum += point_data[count++];  

61.                     check_sum += point_data[count];  

62.                     if(check_sum != 0)                              //checksum verify error  

63.                     {  

64.                               printk("coor checksum error!\n");  

65.                               if(ts->int_trigger_type> 1)  

66.                                         goto COORDINATE_POLL;  

67.                               else            

68.                                         goto XFER_ERROR;  

69.                     }  

70.           }  

71.           //6、读取值坐标值上报；  

72.           if(touch_num)  

73.           {  

74.                     //7、touch_num为按下手指个数，依次循环读取；  

75.                     for(index=0; index<touch_num; index++)  

76.                     {  

77.                               position = 4 - READ_COOR_ADDR + 5*index;  

78.                               //8、读出X的值；  

79.                               input_x = (unsigned int) (point_data[position]<<8) + (unsigned int)( point_data[position+1]);  

80.                               //9、读出Y的值；  

81.                               input_y = (unsigned int)(point_data[position+2]<<8) + (unsigned int) (point_data[position+3]);  

82.                               input_w =(unsigned int) (point_data[position+4]);                      

83.                               //10、如果读出值超出范围，退出；  

84.                               if((input_x > ts->abs_x_max)||(input_y > ts->abs_y_max))  

85.                               continue;  

86.                               //11、下面的函数依次上报坐标， input_mt_sync单点同步  

87.                               input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);  

88.                               input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);                                

89.                               input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);  

90.                               input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);  

91.                               input_report_abs(ts->input_dev, ABS_MT_TRACKING_ID, track_id[index]);  

92.                               input_mt_sync(ts->input_dev);  

93.                     }  

94.           }  

95.           //12、没有触摸时，初始值为0；  

96.           else  

97.           {  

98.                     input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0);  

99.                     input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0);  

100.                     input_mt_sync(ts->input_dev);  

101.           }  

102.           //13、同步多点值；  

103.           input_sync(ts->input_dev);  

104.    

105.           if(ts->int_trigger_type> 1)  

106.           {  

107.                     msleep(POLL_TIME);  

108.                     goto COORDINATE_POLL;  

109.           }  

110.           goto END_WORK_FUNC;  

111.    

112.           NO_ACTION:            

113.           END_WORK_FUNC:  

114.           XFER_ERROR:  

115.                        

116.           return;  

117. }  

总的来数，当我们手指按下是，不管是单个手指，还是多个手指，坐标值和一些信息存储到触摸芯片的相应寄存器中，然后再通过IIC读出，送到主控中就可以了，其他事情就是android去处理了。

          如下图所示，规格书中坐标及重量：XY坐标缓存寄存器的高低位：

中断触发--中断函数--工作队列调度--功能函数执行