天天看点
返回

[转]S3C2440上触摸屏驱动实例开发讲解

转自：来源: blog.chinaunix.net 作者: Tekkaman Ninja

一、开发环境

  • 主  机：VMWare--Fedora 9
  • 开发板：Mini2440--64MB Nand, Kernel:2.6.30.4
  • 编译器：arm-linux-gcc-4.3.2

二、前提知识

1、Linux输入子系统(Input Subsystem)：

在Linux中，输入子系统是由输入子系统设备驱动层、输入子系统核心层(Input Core)和输入子系统事件处理层(Event Handler)组成。其中设备驱动层提供对硬件各寄存器的读写访问和将底层硬件对用户输入访问的响应转换为标准的输入事件，再通过核心层提交给事件处理 层；而核心层对下提供了设备驱动层的编程接口，对上又提供了事件处理层的编程接口；而事件处理层就为我们用户空间的应用程序提供了统一访问设备的接口和驱 动层提交来的事件处理。所以这使得我们输入设备的驱动部分不在用关心对设备文件的操作，而是要关心对各硬件寄存器的操作和提交的输入事件。下面用图形来描 述一下这三者的关系吧！

[转]S3C2440上触摸屏驱动实例开发讲解

另外，又找了另一幅图来说明Linux输入子系统的结构，可能更加形象容易理解。如下：

[转]S3C2440上触摸屏驱动实例开发讲解

2、输入子系统设备驱动层实现原理：

在Linux中，Input设备用input_dev结构体描述，定义在input.h中。设备的驱动只需按照如下步骤就可实现了。

①、在驱动模块加载函数中设置Input设备支持input子系统的哪些事件；

②、将Input设备注册到input子系统中；

③、在Input设备发生输入操作时(如：键盘被按下/抬起、触摸屏被触摸/抬起/移动、鼠标被移动/单击/抬起时等)，提交所发生的事件及对应的键值/坐标等状态。

Linux中输入设备的事件类型有(这里只列出了常用的一些，更多请看linux/input.h中)：

     
  1.  EV_SYN     0x00     同步事件        
    2.           
  2.  EV_KEY     0x01     按键事件        
    3.           
  3.  EV_REL     0x02     相对坐标(如：鼠标移动，报告的是相对最后一次位置的偏移)        
    4.           
  4.  EV_ABS     0x03     绝对坐标(如：触摸屏和操作杆，报告的是绝对的坐标位置)        
    5.           
  5.  EV_MSC     0x04     其它        
    6.           
  6.  EV_LED     0x11     LED        
    7.           
  7.  EV_SND     0x12     声音        
    8.           
  8.  EV_REP     0x14     Repeat        
    9.           
  9.  EV_FF      0x15     力反馈        
    10.

用于提交较常用的事件类型给输入子系统的函数有：

     
  1.  void      input_report_key(     struct      input_dev *dev, unsigned      int      code,      int      value);        
    2.           
  2.  //提交按键事件的函数       
    3.           
  3.  void      input_report_rel(     struct      input_dev *dev, unsigned      int      code,      int      value);        
    4.           
  4.  //提交相对坐标事件的函数       
    5.           
  5.  void      input_report_abs(     struct      input_dev *dev, unsigned      int      code,      int      value);        
    6.           
  6.  //提交绝对坐标事件的函数       
    7.

注意，在提交输入设备的事件后必须用下列方法使事件同步，让它告知input系统，设备驱动已经发出了一个完整的报告：

     
  1.  void      input_sync(     struct      input_dev *dev)        
    2.

三、触摸屏驱动的实现步骤

1、硬件原理图分析：

S3c2440芯片内部触摸屏接口与ADC接口是集成在一起的，硬件结构原理图请看：S3C2440上ADC驱动实例开发讲解 中的图，其中通道7(XP或AIN7)作为触摸屏接口的X坐标输入，通道5(YP或AIN5)作为触摸屏接口的Y坐标输入。在"S3C2440上ADC驱动实例开发讲解 " 中，AD转换的模拟信号是由开发板上的一个电位器产生并通过通道1(AIN0)输入的，而这里的模拟信号则是由点触触摸屏所产生的X坐标和Y坐标两个模拟 信号，并分别通过通道7和通道5输入。S3c2440提供的触摸屏接口有4种处理模式，分别是：正常转换模式、单独的X/Y位置转换模式、自动X/Y位置 转换模式和等待中断模式，对于在每种模式下工作的要求，请详细查看数据手册的描述。本驱动实例将采用自动X/Y位置转换模式和等待中断模式。

注意：在每步中，为了让代码逻辑更加有条理和容易理解，就没有考虑代码的顺序，比如函数要先定义后调用。如果要编译此代码，请严格按照C语言 的规范来调整代码的顺序。

2、建立触摸屏驱动程序my2440_ts.c，首先实现加载和卸载部分，在驱动加载部分，我们主要做的事情是：启用ADC所需要的时钟、映射IO口、初始化寄存器、申请中断、初始化输入设备、将输入设备注册到输入子系统。代码如下：

     
  1.  #include <linux/module.h>       
    2.           
  2.  #include <linux/kernel.h>       
    3.           
  3.  #include <linux/clk.h>       
    4.           
  4.  #include <linux/init.h>       
    5.           
  5.  #include <linux/input.h>       
    6.           
  6.  #include <linux/serio.h>       
    7.           
  7.  #include <plat/regs-adc.h>       
    8.           
  8.  #include <asm/irq.h>       
    9.           
  9.  #include <asm/io.h>       
    10.                   
  10.  /*用于保存从平台时钟列表中获取的ADC时钟*/       
    11.           
  11.  static     struct      clk *adc_clk;        
    12.           
  12.  /*定义了一个用来保存经过虚拟映射后的内存地址*/       
    13.           
  13.  static     void      __iomem *adc_base;        
    14.           
  14.  /*定义一个输入设备来表示我们的触摸屏设备*/       
    15.           
  15.  static     struct      input_dev *ts_dev;        
    16.           
  16.  /*设备名称*/       
    17.           
  17.  #define DEVICE_NAME    "my2440_TouchScreen"       
    18.           
  18.  /*定义一个WAIT4INT宏，该宏将对ADC触摸屏控制寄存器进行操作       
    19.           
  19.  S3C2410_ADCTSC_YM_SEN这些宏都定义在regs-adc.h中*/       
    20.           
  20.  #define WAIT4INT(x)    (((x)<<8) | S3C2410_ADCTSC_YM_SEN |      /       
    21.           
  21.  S3C2410_ADCTSC_YP_SEN |     S3C2410_ADCTSC_XP_SEN | S3C2410_ADCTSC_XY_PST(3))        
    22.                   
  22.  static     int      __init ts_init(     void     )        
    23.           
  23.  {        
    24.           
  24.      int      ret;        
    25.                   
  25.  /*从平台时钟队列中获取ADC的时钟，这里为什么要取得这个时钟，因为ADC的转换频率跟时钟有关。       
    26.           
  26.  系统的一些时钟定义在arch/arm/plat-s3c24xx/s3c2410-clock.c中*/       
    27.           
  27.      adc_clk = clk_get(NULL, "adc"     );        
    28.           
  28.      if     (!adc_clk)        
    29.           
  29.      {        
    30.           
  30.  /*错误处理*/       
    31.           
  31.          printk(KERN_ERR "falied to find adc clock source/n"     );        
    32.           
  32.          return      -ENOENT;        
    33.           
  33.      }        
    34.                   
  34.  /*时钟获取后要使能后才可以使用，clk_enable定义在arch/arm/plat-s3c/clock.c中*/       
    35.           
  35.      clk_enable(adc_clk);        
    36.                   
  36.  /*将ADC的IO端口占用的这段IO空间映射到内存的虚拟地址，ioremap定义在io.h中。       
    37.           
  37.  注意：IO空间要映射后才能使用，以后对虚拟地址的操作就是对IO空间的操作,       
    38.           
  38.  S3C2410_PA_ADC是ADC控制器的基地址，定义在mach-s3c2410/include/mach/map.h       
    39.           
  39.  中，0x20是虚拟地址长度大小*/       
    40.           
  40.      adc_base = ioremap(S3C2410_PA_ADC, 0x20);        
    41.           
  41.      if     (adc_base == NULL)        
    42.           
  42.      {        
    43.           
  43.  /*错误处理*/       
    44.           
  44.          printk(KERN_ERR "failed to remap register block/n"     );        
    45.           
  45.          ret = -EINVAL;        
    46.           
  46.          goto      err_noclk;        
    47.           
  47.      }        
    48.                   
  48.  /*初始化ADC控制寄存器和ADC 触摸屏控制寄存器*/       
    49.           
  49.      adc_initialize();        
    50.                   
  50.  /*申请ADC中断，AD转换完成后触发。这里使用共享中断IRQF_SHARED 是因为该中断号在ADC驱动       
    51.           
  51.  中也使用了，     最后一个参数1是随便给的一个值，因为如果不给值设为NULL的话，中断就申请不成功*/       
    52.           
  52.      ret = request_irq(IRQ_ADC, adc_irq, IRQF_SHARED | /       
    53.           
  53.  IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);        
    54.           
  54.      if     (ret)        
    55.           
  55.      {        
    56.           
  56.          printk(KERN_ERR "IRQ%d error %d/n"     , IRQ_ADC, ret);        
    57.           
  57.          ret = -EINVAL;        
    58.           
  58.          goto      err_nomap;        
    59.           
  59.      }        
    60.                   
  60.  /*申请触摸屏中断，对触摸屏按下或提笔时触发*/       
    61.           
  61.      ret = request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM, DEVICE_NAME, 1);        
    62.           
  62.      if     (ret)        
    63.           
  63.      {        
    64.           
  64.          printk(KERN_ERR "IRQ%d error %d/n"     , IRQ_TC, ret);        
    65.           
  65.          ret = -EINVAL;        
    66.           
  66.          goto      err_noirq;        
    67.           
  67.      }        
    68.                   
  68.  /*给输入设备申请空间，input_allocate_device定义在input.h中*/       
    69.           
  69.      ts_dev = input_allocate_device();        
    70.                   
  70.  /*下面初始化输入设备，即给输入设备结构体input_dev的成员设置值。       
    71.           
  71.  evbit字段用于描述支持的事件，这里支持同步事件、按键事件、绝对坐标事件，       
    72.           
  72.  BIT宏实际就是对1进行位操作，定义在linux/bitops.h中*/       
    73.           
  73.      ts_dev->evbit[0] = BIT(EV_SYN) | BIT(EV_KEY) | BIT(EV_ABS);        
    74.                   
  74.  /*keybit字段用于描述按键的类型，在input.h中定义了很多，       
    75.           
  75.  这里用BTN_TOUCH类型来表示触摸屏的点击*/       
    76.           
  76.      ts_dev->keybit[BITS_TO_LONGS(BTN_TOUCH)] = BIT(BTN_TOUCH);        
    77.                   
  77.  /*对于触摸屏来说，使用的是绝对坐标系统。这里设置该坐标系统中X和Y坐标的最小值和最大值       
    78.           
  78.  (0-1023范围)     ABS_X和ABS_Y就表示X坐标和Y坐标，ABS_PRESSURE就表示触摸屏是按下还是抬起状态*/       
    79.           
  79.      input_set_abs_params(ts_dev, ABS_X, 0, 0x3FF, 0, 0);        
    80.           
  80.      input_set_abs_params(ts_dev, ABS_Y, 0, 0x3FF, 0, 0);        
    81.           
  81.      input_set_abs_params(ts_dev, ABS_PRESSURE, 0, 1, 0, 0);        
    82.                   
  82.  /*以下是设置触摸屏输入设备的身份信息，直接在这里写死。        
    83.           
  83.      这些信息可以在驱动挂载后在/proc/bus/input/devices中查看到*/        
    84.           
  84.      ts_dev->name          = DEVICE_NAME;   /*设备名称*/       
    85.           
  85.      ts_dev->id.bustype    = BUS_RS232;     /*总线类型*/       
    86.           
  86.      ts_dev->id.vendor     = 0xDEAD;        /*经销商ID号*/       
    87.           
  87.      ts_dev->id.product    = 0xBEEF;        /*产品ID号*/       
    88.           
  88.      ts_dev->id.version    = 0x0101;        /*版本ID号*/       
    89.                   
  89.  /*好了，一些都准备就绪，现在就把 ts_dev触摸屏设备注册到输入子系统中*/       
    90.           
  90.      input_register_device(ts_dev);        
    91.                   
  91.      return      0;        
    92.                   
  92.  /*下面是错误跳转处理*/       
    93.           
  93.  err_noclk:        
    94.           
  94.      clk_disable(adc_clk);        
    95.           
  95.      clk_put(adc_clk);        
    96.                   
  96.  err_nomap:        
    97.           
  97.      iounmap(adc_base);        
    98.                   
  98.  err_noirq:        
    99.           
  99.      free_irq(IRQ_ADC, 1);        
    100.                   
  100.      return      ret;        
    101.           
  101.  }        
    102.                   
  102.  /*初始化ADC控制寄存器和ADC触摸屏控制寄存器*/       
    103.           
  103.  static     void      adc_initialize(     void     )        
    104.           
  104.  {        
    105.           
  105.  /*计算结果为(二进制)：111111111000000，再根据数据手册得知       
    106.           
  106.  此处是将AD转换预定标器值设为255、AD转换预定标器使能有效*/       
    107.           
  107.      writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(0xFF), adc_base + S3C2410_ADCCON);        
    108.                   
  108.      /*对ADC开始延时寄存器进行设置，延时值为0xffff*/       
    109.           
  109.      writel(0xffff, adc_base + S3C2410_ADCDLY);        
    110.                   
  110.      /*WAIT4INT宏计算结果为(二进制)：11010011，再根据数据手册得知       
    111.           
  111.      此处是将ADC触摸屏控制寄存器设置成等待中断模式*/       
    112.           
  112.      writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);        
    113.           
  113.  }        
    114.                   
  114.  static     void      __exit ts_exit(     void     )        
    115.           
  115.  {        
    116.           
  116.      /*屏蔽和释放中断*/       
    117.           
  117.      disable_irq(IRQ_ADC);        
    118.           
  118.      disable_irq(IRQ_TC);        
    119.           
  119.      free_irq(IRQ_ADC, 1);        
    120.           
  120.      free_irq(IRQ_TC, 1);        
    121.                   
  121.      /*释放虚拟地址映射空间*/       
    122.           
  122.      iounmap(adc_base);        
    123.                   
  123.      /*屏蔽和销毁时钟*/       
    124.           
  124.      if     (adc_clk)        
    125.           
  125.      {        
    126.           
  126.          clk_disable(adc_clk);        
    127.           
  127.          clk_put(adc_clk);        
    128.           
  128.          adc_clk = NULL;        
    129.           
  129.      }        
    130.                   
  130.      /*将触摸屏设备从输入子系统中注销*/       
    131.           
  131.      input_unregister_device(ts_dev);        
    132.           
  132.  }        
    133.                   
  133.  module_init(ts_init);        
    134.           
  134.  module_exit(ts_exit);        
    135.                   
  135.  MODULE_LICENSE("GPL"     );        
    136.           
  136.  MODULE_AUTHOR("Huang Gang"     );        
    137.           
  137.  MODULE_DESCRIPTION("My2440 Touch Screen Driver"     );        
    138.

3、接下来要做的是，在两个中断服务程序中实现触摸屏状态和坐标的转换。先看代码，如下：

     
  1.  /*定义一个外部的信号量ADC_LOCK，因为ADC_LOCK在ADC驱动程序中已申明       
    2.           
  2.  这样就能保证ADC资源在ADC驱动和触摸屏驱动中进行互斥访问*/       
    3.           
  3.  extern     struct      semaphore ADC_LOCK;        
    4.                   
  4.  /*做为一个标签，只有对触摸屏操作后才对X和Y坐标进行转换*/       
    5.           
  5.  static     int      OwnADC = 0;        
    6.                   
  6.  /*用于记录转换后的X坐标值和Y坐标值*/       
    7.           
  7.  static     long      xp;        
    8.           
  8.  static     long      yp;        
    9.                   
  9.  /*用于计数对触摸屏压下或抬起时模拟输入转换的次数*/       
    10.           
  10.  static     int      count;        
    11.                   
  11.  /*定义一个AUTOPST宏，将ADC触摸屏控制寄存器设置成自动转换模式*/       
    12.           
  12.  #define AUTOPST    (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN/       
    13.           
  13.  | S3C2410_ADCTSC_XP_SEN |     S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))        
    14.                           
  14.  /*触摸屏中断服务程序，对触摸屏按下或提笔时触发执行*/       
    15.           
  15.  static      irqreturn_t tc_irq(     int      irq,      void      *dev_id)        
    16.           
  16.  {        
    17.           
  17.      /*用于记录这一次AD转换后的值*/       
    18.           
  18.      unsigned long      data0;        
    19.           
  19.      unsigned long      data1;        
    20.                   
  20.      /*用于记录触摸屏操作状态是按下还是抬起*/       
    21.           
  21.      int      updown;        
    22.                   
  22.      /*ADC资源可以获取，即上锁*/       
    23.           
  23.      if      (down_trylock(&ADC_LOCK) == 0)        
    24.           
  24.      {        
    25.           
  25.          /*标识对触摸屏进行了操作*/       
    26.           
  26.          OwnADC = 1;        
    27.                   
  27.          /*读取这一次AD转换后的值，注意这次主要读的是状态*/       
    28.           
  28.          data0 = readl(adc_base + S3C2410_ADCDAT0);        
    29.           
  29.          data1 = readl(adc_base + S3C2410_ADCDAT1);        
    30.                   
  30.  /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，       
    31.           
  31.  所以与上 S3C2410_ADCDAT0_UPDOWN*/       
    32.           
  32.  updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));        
    33.                   
  33.          /*判断触摸屏的操作状态*/       
    34.           
  34.          if      (updown)        
    35.           
  35.          {        
    36.           
  36.  /*如果是按下状态，则调用touch_timer_fire函数来启动ADC转换，该函数定义后面再讲*/       
    37.           
  37.              touch_timer_fire(0);        
    38.           
  38.          }        
    39.           
  39.          else       
    40.           
  40.          {        
    41.           
  41.  /*如果是抬起状态，就结束了这一次的操作，所以就释放ADC资源的占有*/       
    42.           
  42.              OwnADC = 0;        
    43.           
  43.              up(&ADC_LOCK);        
    44.           
  44.          }        
    45.           
  45.      }        
    46.                   
  46.      return      IRQ_HANDLED;        
    47.           
  47.  }        
    48.                   
  48.  static     void      touch_timer_fire(unsigned      long      data)        
    49.           
  49.  {        
    50.           
  50.      /*用于记录这一次AD转换后的值*/       
    51.           
  51.        unsigned long      data0;        
    52.           
  52.        unsigned long      data1;        
    53.                   
  53.      /*用于记录触摸屏操作状态是按下还是抬起*/       
    54.           
  54.      int      updown;        
    55.                   
  55.      /*读取这一次AD转换后的值，注意这次主要读的是状态*/       
    56.           
  56.        data0 = readl(adc_base + S3C2410_ADCDAT0);        
    57.           
  57.      data1 = readl(adc_base + S3C2410_ADCDAT1);        
    58.                   
  58.  /*记录这一次对触摸屏是压下还是抬起，该状态保存在数据寄存器的第15位，       
    59.           
  59.  所以与上 S3C2410_ADCDAT0_UPDOWN*/       
    60.           
  60.  updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));        
    61.                   
  61.      /*判断触摸屏的操作状态*/       
    62.           
  62.       if      (updown)        
    63.           
  63.      {        
    64.           
  64.          /*如果状态是按下，并且ADC已经转换了就报告事件和数据*/       
    65.           
  65.           if      (count != 0)        
    66.           
  66.          {        
    67.           
  67.              long      tmp;        
    68.                   
  68.              tmp = xp;        
    69.           
  69.              xp = yp;        
    70.           
  70.              yp = tmp;        
    71.                   
  71.              xp >>= 2;        
    72.           
  72.              yp >>= 2;        
    73.                   
  73.  #ifdef CONFIG_TOUCHSCREEN_MY2440_DEBUG       
    74.           
  74.  /*触摸屏调试信息，编译内核时选上此项后，点击触摸屏会在终端上打印出坐标信息*/       
    75.           
  75.  struct      timeval tv;        
    76.           
  76.  do_gettimeofday(&tv);        
    77.           
  77.  printk(KERN_DEBUG "T: %06d, X: %03ld, Y: %03ld/n"     , (     int     )tv.tv_usec, xp, yp);        
    78.           
  78.  #endif       
    79.                   
  79.  /*报告X、Y的绝对坐标值*/       
    80.           
  80.  input_report_abs(ts_dev, ABS_X, xp);        
    81.           
  81.  input_report_abs(ts_dev, ABS_Y, yp);        
    82.                   
  82.  /*报告触摸屏的状态，1表明触摸屏被按下*/       
    83.           
  83.  input_report_abs(ts_dev, ABS_PRESSURE, 1);        
    84.                   
  84.  /*报告按键事件，键值为1(代表触摸屏对应的按键被按下)*/       
    85.           
  85.  input_report_key(ts_dev, BTN_TOUCH, 1);        
    86.                   
  86.  /*等待接收方受到数据后回复确认，用于同步*/       
    87.           
  87.  input_sync(ts_dev);        
    88.           
  88.  }        
    89.                   
  89.  /*如果状态是按下，并且ADC还没有开始转换就启动ADC进行转换*/       
    90.           
  90.  xp = 0;        
    91.           
  91.  yp = 0;        
    92.           
  92.  count = 0;        
    93.           
  93.  /*设置触摸屏的模式为自动转换模式*/       
    94.           
  94.  writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);        
    95.                   
  95.  /*启动ADC转换*/       
    96.           
  96.  writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START,       
    97.           
  97.   adc_base + S3C2410_ADCCON);        
    98.           
  98.  }        
    99.           
  99.      else       
    100.           
  100.      {        
    101.           
  101.  /*否则是抬起状态*/       
    102.           
  102.  count = 0;        
    103.           
  103.  /*报告按键事件，键值为0(代表触摸屏对应的按键被释放)*/       
    104.           
  104.  input_report_key(ts_dev, BTN_TOUCH, 0);        
    105.           
  105.  /*报告触摸屏的状态，0表明触摸屏没被按下*/       
    106.           
  106.  input_report_abs(ts_dev, ABS_PRESSURE, 0);        
    107.           
  107.  /*等待接收方受到数据后回复确认，用于同步*/       
    108.           
  108.  input_sync(ts_dev);        
    109.           
  109.  /*将触摸屏重新设置为等待中断状态*/       
    110.           
  110.  writel(WAIT4INT(0), adc_base + S3C2410_ADCTSC);        
    111.           
  111.  /*如果触摸屏抬起，就意味着这一次的操作结束，所以就释放ADC资源的占有*/       
    112.           
  112.  if      (OwnADC)        
    113.           
  113.  {        
    114.           
  114.  OwnADC = 0;        
    115.           
  115.  up(&ADC_LOCK);        
    116.           
  116.  }        
    117.           
  117.  }        
    118.           
  118.  }        
    119.                   
  119.  /*定义并初始化了一个定时器touch_timer，定时器服务程序为touch_timer_fire*/       
    120.           
  120.  static     struct      timer_list touch_timer = TIMER_INITIALIZER(touch_timer_fire, 0, 0);        
    121.                   
  121.  /*ADC中断服务程序，AD转换完成后触发执行*/       
    122.           
  122.  static      irqreturn_t adc_irq(     int      irq,      void      *dev_id)        
    123.           
  123.  {        
    124.           
  124.  /*用于记录这一次AD转换后的值*/       
    125.           
  125.  unsigned long      data0;        
    126.           
  126.  unsigned long      data1;        
    127.           
  127.  if     (OwnADC)        
    128.           
  128.  {        
    129.           
  129.  /*读取这一次AD转换后的值，注意这次主要读的是坐标*/       
    130.           
  130.  data0 = readl(adc_base + S3C2410_ADCDAT0);        
    131.           
  131.  data1 = readl(adc_base + S3C2410_ADCDAT1);        
    132.           
  132.  /*记录这一次通过AD转换后的X坐标值和Y坐标值，根据数据手册可知，X和Y坐标转换数值       
    133.           
  133.  分别保存在数据寄存器0和1的第0-9位，所以这里与上S3C2410_ADCDAT0_XPDATA_MASK就是取0-9位的值*/       
    134.           
  134.  xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;        
    135.           
  135.  yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;        
    136.           
  136.  /*计数这一次AD转换的次数*/       
    137.           
  137.  count++;        
    138.           
  138.  if      (count < (1<<2))        
    139.           
  139.  {        
    140.           
  140.  /*如果转换的次数小于4，则重新启动ADC转换*/       
    141.           
  141.  writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, adc_base + S3C2410_ADCTSC);        
    142.           
  142.  writel(readl(adc_base + S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START,       
    143.           
  143.   adc_base + S3C2410_ADCCON);        
    144.           
  144.  }        
    145.           
  145.  else       
    146.           
  146.  {        
    147.           
  147.  /*否则，启动1个时间滴答的定时器，这是就会去执行定时器服务程序上报事件和数据*/       
    148.           
  148.  mod_timer(&touch_timer, jiffies + 1);        
    149.           
  149.  writel(WAIT4INT(1), adc_base + S3C2410_ADCTSC);        
    150.           
  150.  }        
    151.           
  151.  }        
    152.                   
  152.  return      IRQ_HANDLED;        
    153.           
  153.  }        
    154.

我们从整体上描述转换这个的过程：

(1)如果触摸屏感觉到触摸，则触发触摸屏中断即进入tc_irq，获取ADC_LOCK后判断触摸屏状态为按下，则调用touch_timer_fire启动ADC转换；

(2)当ADC转换启动后，触发ADC中断即进入adc_irq，如果这一次转换的次数小于4，则重新启动ADC进行转换，如果4次完毕后，启动1个时间滴答的定时器，停止ADC转换，也就是说在这个时间滴答内，ADC转换是停止的；

(3)这里为什么要在1个时间滴答到来之前停止ADC的转换呢？这是为了防止屏幕抖动。

(4)如果1个时间滴答到来则进入定时器服务程序touch_timer_fire，判断触摸屏仍然处于按下状态则上报事件和转换的数据，并重启ADC转换，重复第(2)步；

(5)如果触摸抬起了，则上报释放事件，并将触摸屏重新设置为等待中断状态。

四、移植和测试触摸屏驱动程序

     移植和测试请看 Linux-2.6.30.4在2440上的移植之触摸屏驱动

嵌入式 linux 转载 c input timer report module Linux
上一篇: Start Developing iOS Apps (Swift) 学习笔记 (2)
下一篇: linux子系统分析及触摸屏驱动浅析

继续阅读