码迷，mamicode.com
首页 > 系统相关 > 详细

ARM-Linux驱动-触摸屏驱动分析

时间：2014-11-11 10:44:31      阅读：343      评论：0      收藏：0      [点我收藏+]

标签：des   style   blog   http   io   ar   使用   sp   for   

出处：http://blog.csdn.net/geekcome/article/details/6580981

硬件平台：FL2440

内核版本：2.6.28

主机平台：Ubuntu 11.04

内核版本：2.6.39

原创作品，转载请标明出处http://blog.csdn.net/yming0221/article/details/6580981

1、下面是ADC和触摸屏接口的模块图

bubuko.com,布布扣

当触摸屏接口使用时，XM或YM接触摸屏接口的地

当触摸屏接口不使用时，XM或YM接模拟信号，做普通ADC使用。

2、触摸屏接口的几种操作模式

（1） 正常转换模式

通过设置ADCCON（adc控制寄存器）来完成初始化，并对ADCDAT0数据寄存器进行操作。

（2） 分离XY坐标模式

X坐标模式写X坐标转换数据到ADCDAT0，触摸屏接口产生中断到中断控制寄存器。Y坐标模式写Y坐标转换数据到ADCDAT1，触摸屏接口产生中断到中断控制寄存器。两种模

式可以选择一种模式工作。

相应的引脚连接：

bubuko.com,布布扣

（3） 自动XY坐标模式

触摸屏控制器连续的转换X和Y的坐标，在X坐标转换后的值存入ADCDAT0后，自动将Y坐标转换后的值存入ADCDAT1，触摸屏接口产生中断到中断控制器。

相应的引脚连接：

bubuko.com,布布扣

（4） 等待中断模式

当光标被按下，触摸屏控制器产生中断IRQ_TC，当产生中断信号时，等待中断模式必须被清除。

引脚定义如下：

bubuko.com,布布扣

3、下面是s3c2440触摸屏驱动的分析

 

[cpp] view plaincopy
  1. //#define CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  2.   
  3. #include <linux/errno.h>  
  4. #include <linux/kernel.h>  
  5. #include <linux/module.h>  
  6. #include <linux/slab.h>  
  7. #include <linux/input.h>  
  8. #include <linux/init.h>  
  9. #include <linux/serio.h>  
  10. #include <linux/delay.h>  
  11. #include <linux/platform_device.h>  
  12. #include <linux/clk.h>  
  13. #include <asm/io.h>  
  14. #include <asm/irq.h>  
  15.   
  16. #include <mach/regs-gpio.h>  
  17. #include <mach/s3c2410_ts.h>  
  18.   
  19. #include <plat/regs-adc.h>  
  20.   
  21. #define TRUE 1    //CoAsia added  
  22. #define FALSE 0    //CoAsia added  
  23. #define FILTER_LIMIT 25    //CoAsia added  
  24.   
  25. /* For ts.dev.id.version */  
  26. #define S3C2410TSVERSION    0x0101  
  27.   
  28. #define TSC_SLEEP  (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0))  
  29.   
  30. #define WAIT4INT(x)  (((x)<<8) | \  
  31.              S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \  
  32.              S3C2410_ADCTSC_XY_PST(3))  
  33.   
  34. #define AUTOPST      (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \  
  35.              S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0))  
  36.   
  37. #define DEBUG_LVL   "<3>" //KERN_DEBUG  
  38.   
  39. static char *s3c2440ts_name = "s3c2440 TouchScreen";  
  40.   
  41. /* 
  42.  * Per-touchscreen data. 
  43.  */  
  44. //定义s3c2440触摸屏使用的数据结构体  
  45. struct s3c2440ts {  
  46.     struct input_dev *dev;  
  47.     long xp;  
  48.     long yp;  
  49.     int count;  
  50.     int shift;  
  51. };  
  52.   
  53. static struct s3c2440ts ts;  
  54. static struct clk   *adc_clock;  
  55.   
  56. //__iomem声明地址空间是设备地址映射空间  
  57. static void __iomem *base_addr;  
  58.   
  59. //函数声明  
  60. static void touch_timer_fire(unsigned long data);  
  61. static irqreturn_t tc_irq(int irq, void *dev_id);  
  62. static irqreturn_t adc_irq(int irq, void *dev_id);  
  63. static int __init s3c2440ts_probe(struct platform_device *pdev);  
  64. static int s3c2440ts_remove(struct platform_device *pdev);  
  65. static int s3c2440ts_resume(struct platform_device *pdev);  
  66.   
  67. //定义定时器  
  68. static struct timer_list touch_timer =  
  69.         TIMER_INITIALIZER(touch_timer_fire, 0, 0);  
  70.   
  71.   
  72. //IRQ_TC中断处理函数  
  73. static irqreturn_t tc_irq(int irq, void *dev_id)  
  74. {  
  75.     //data0,data1用于存放读取的ADCDAT数据寄存器的值  
  76.     unsigned long data0;  
  77.     unsigned long data1;  
  78.     int updown;//用于存放光标的按下或提起的状态  
  79.       
  80.     //读取ADCDAT0、ADCDAT1数据寄存器的值  
  81.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  82.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  83.       
  84.     //查看数据寄存器的第15位的值  
  85.     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));  
  86.   
  87.     /* TODO we should never get an interrupt with updown set while 
  88.      * the timer is running, but maybe we ought to verify that the 
  89.      * timer isn‘t running anyways. */  
  90.        
  91.     //如果data0和data1的第15位都是0，则updown为1，则通过函数touch_timer_fire()函数来启动ADC转换  
  92.     if (updown)  
  93.         touch_timer_fire(0);  
  94.   
  95.     return IRQ_HANDLED;  
  96. }  
  97.   
  98. static void touch_timer_fire(unsigned long data)  
  99. {  
  100.     //用于存储数据寄存器ADCDAT0、ADCDAT1的值  
  101.     unsigned long data0;  
  102.     unsigned long data1;  
  103.       
  104.     //用于存放光标是否被按下  
  105.     int updown;  
  106.   
  107.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  108.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  109.   
  110.     updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN));  
  111. //printk("The number of ‘updown‘ is %d\n ",updown);  
  112.     //如果光标被按下，执行  
  113.     if (updown)   
  114.     {  
  115.         //ts.count!=0表示ADC已经转换过，下面就报告事件和光标位置数据  
  116.         if (ts.count != 0)   
  117.         {  
  118.             ts.xp >>= ts.shift;//这里shift为2，这里实际上是求均值，四次的和/4，这样定位更加准确  
  119.             ts.yp >>= ts.shift;  
  120.   
  121. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  122.             {  
  123.                 struct timeval tv;  
  124.                 do_gettimeofday(&tv);  
  125.                 printk(DEBUG_LVL "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts.xp, ts.yp);  
  126.             }  
  127. #endif  
  128. /* 
  129. 下面的函数位于/include/linux/input.h，作用是报告事件 
  130. static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value) 
  131. { 
  132.     input_event(dev, EV_ABS, code, value); 
  133. } 
  134. */  
  135.             //报告X，Y的绝对坐标  
  136.             input_report_abs(ts.dev, ABS_X, ts.xp);  
  137.             input_report_abs(ts.dev, ABS_Y, ts.yp);  
  138.               
  139.             //报告事件，1代表光标被按下  
  140.             input_report_key(ts.dev, BTN_TOUCH, 1);  
  141.             //报告触摸屏状态，1代表触摸屏被按下  
  142.             input_report_abs(ts.dev, ABS_PRESSURE, 1);  
  143.             //等待接收方的确认，用于事件的同步  
  144.             input_sync(ts.dev);  
  145.         }  
  146.         //现在光标被按下，并且ADC转换没有启动  
  147.         ts.xp = 0;  
  148.         ts.yp = 0;  
  149.         ts.count = 0;  
  150.           
  151.         //设置触摸屏控制寄存器的值为 0xdc B:1101 1100，设置控制寄存器上拉无效，自动转换X，Y坐标  
  152.         //printk("S3C2410_ADCTSC: 0x%x\n",S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST);  
  153.         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);  
  154.         //启动ADC转换  
  155.         writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);  
  156.     }   
  157.     else//光标没有被按下  
  158.     {  
  159.         ts.count = 0;  
  160.         //报告事件及光标的位置状态  
  161.         input_report_key(ts.dev, BTN_TOUCH, 0);  
  162.         input_report_abs(ts.dev, ABS_PRESSURE, 0);  
  163.         //等待接收方的应答，用于同步  
  164.         input_sync(ts.dev);  
  165.         //设置触摸屏控制寄存器为等待中断模式  
  166.         writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  167.     }  
  168. }  
  169.   
  170.   
  171. static irqreturn_t adc_irq(int irq, void *dev_id)  
  172. {  
  173.     //用于存放数据寄存器的数据  
  174.     unsigned long data0;  
  175.     unsigned long data1;  
  176.     //读取数据，这次主要读取的是位置数据  
  177.     data0 = readl(base_addr+S3C2410_ADCDAT0);  
  178.     data1 = readl(base_addr+S3C2410_ADCDAT1);  
  179.       
  180.     ts.xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;//累加四次准换结果的X坐标和  
  181.     ts.yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;//累加四次准换结果的Y坐标和  
  182.   
  183.     ts.count++;//转换次数加一  
  184.       
  185.     //如果转换次数小于4  
  186.     if (ts.count < (1<<ts.shift))   
  187.     {  
  188.         //再次设置触摸屏控制寄存器上拉不使能、自动X、Y转换模式  
  189.         writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC);  
  190.         //再次启动ADC转换  
  191.         writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON);  
  192.     }  
  193.     else//这时，ADC转换四次完成，延迟一个系统滴答，执行touch_timer_fire()函数  
  194.     {  
  195.         mod_timer(&touch_timer, jiffies+1);   
  196.         writel(WAIT4INT(1), base_addr+S3C2410_ADCTSC);  
  197.     }  
  198.   
  199.     return IRQ_HANDLED;  
  200. }  
  201.   
  202.   
  203.   
  204. /* 
  205.  * The functions for inserting/removing us as a module. 
  206.  */  
  207. /* 
  208. 该结构体定义在/include/linux/platform_device.h 
  209. struct platform_device { 
  210.     const char  * name; 
  211.     int     id; 
  212.     struct device   dev; 
  213.     u32     num_resources; 
  214.     struct resource * resource; 
  215. }; 
  216. */  
  217. static int __init s3c2440ts_probe(struct platform_device *pdev)  
  218. {  
  219.     int rc;  
  220.     /* 
  221.     下面结构体定义在/include/mach/s3c2410_ts.h 
  222.     struct s3c2410_ts_mach_info { 
  223.        int             delay; 
  224.        int             presc; 
  225.        int             oversampling_shift; 
  226.     }; 
  227.     */  
  228.     struct s3c2410_ts_mach_info *info;  
  229.     struct input_dev *input_dev;  
  230.     /* 
  231.         void        *platform_data;//Platform specific data, device core doesn‘t touch it  
  232.     */  
  233.     info = ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data;  
  234.   
  235.     if (!info)  
  236.     {  
  237.         printk(KERN_ERR "Hm... too bad : no platform data for ts\n");  
  238.         return -EINVAL;  
  239.     }  
  240.   
  241. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  242.     printk(DEBUG_LVL "Entering s3c2440ts_init\n");  
  243. #endif  
  244.     //由于ADC转换需要时钟，这里获取时钟  
  245.     adc_clock = clk_get(NULL, "adc");  
  246.     if (!adc_clock) {  
  247.         printk(KERN_ERR "failed to get adc clock source\n");  
  248.         return -ENOENT;  
  249.     }  
  250.     clk_enable(adc_clock);//使能时钟  
  251.   
  252. #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG  
  253.     printk(DEBUG_LVL "got and enabled clock\n");  
  254. #endif  
  255.     //通过ioremap实现物理地址到虚拟地址的转换  
  256.     base_addr = ioremap(S3C2410_PA_ADC,0x20);  
  257.     if (base_addr == NULL) {  
  258.         printk(KERN_ERR "Failed to remap register block\n");  
  259.         return -ENOMEM;  
  260.     }  
  261.       
  262.     //设置ADCCON控制寄存器为0x4c40,设置预分频有效，预分频值为B：110001 D：49  
  263.     //printk("ADCCON is 0x%x\n",S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF));  
  264.     if ((info->presc&0xff) > 0)  
  265.         writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\  
  266.                  base_addr+S3C2410_ADCCON);  
  267.     else  
  268.         writel(0,base_addr+S3C2410_ADCCON);  
  269.   
  270.   
  271.     /* Initialise registers */  
  272.     /* 
  273.         设置ADC开始延时寄存器ADCDLY: 0x4e20 
  274.     */  
  275.     //printk("ADCDLY: 0x%x\n",info->delay & 0xffff);  
  276.     if ((info->delay&0xffff) > 0)  
  277.         writel(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  
  278.     /* 
  279.         设置ADC触摸屏控制寄存器ADC_TSC: 0xd3 B:1101 0011 
  280.         [8]检测光标按下中断信号 
  281.         [7]YM输出驱动有效（GND） 
  282.         [6]YP输出驱动无效（AIN5） 
  283.         [5]XM输出驱动无效（Hi-z） 
  284.         [4]XP输出驱动无效（AIN7） 
  285.         [3]XP上拉有效 
  286.         [2]普通ADC转换 
  287.         [0:1]等待中断模式 测量X和Y的坐标 
  288.     */  
  289.     //printk("ADC_TSC: 0x%x\n",WAIT4INT(0));  
  290.     writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  291.   
  292.     /* Initialise input stuff */  
  293.     memset(&ts, 0, sizeof(struct s3c2440ts));  
  294.   
  295.     /* 
  296.     下面的函数 
  297.     为新的输入设备分配内存。 
  298.     使用free_device()释放没有被注册的函数，使用input_unregister_device()解除已经注册的设备 
  299.     定义在/drivers/input/input.c 
  300.     struct input_dev *input_allocate_device(void) 
  301.     { 
  302.     struct input_dev *dev; 
  303.  
  304.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 
  305.     if (dev) { 
  306.         dev->dev.type = &input_dev_type; 
  307.         dev->dev.class = &input_class; 
  308.         device_initialize(&dev->dev); 
  309.         mutex_init(&dev->mutex); 
  310.         spin_lock_init(&dev->event_lock); 
  311.         INIT_LIST_HEAD(&dev->h_list); 
  312.         INIT_LIST_HEAD(&dev->node); 
  313.  
  314.         __module_get(THIS_MODULE); 
  315.     } 
  316.     return dev; 
  317.     } 
  318.     */  
  319.     input_dev = input_allocate_device();  
  320.   
  321.     if (!input_dev) {  
  322.         printk(KERN_ERR "Unable to allocate the input device !!\n");  
  323.         return -ENOMEM;  
  324.     }  
  325.     //下面初始化输入设备信息  
  326.     ts.dev = input_dev;  
  327.     ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) |  
  328.                BIT_MASK(EV_ABS);  
  329.     ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);  
  330.     input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0);  
  331.     input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0);  
  332.     input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0);  
  333.   
  334.     //ts.dev->private = &ts;  
  335.     ts.dev->name = s3c2440ts_name;  
  336.     ts.dev->id.bustype = BUS_RS232;  
  337.     ts.dev->id.vendor = 0xDEAD;  
  338.     ts.dev->id.product = 0xBEEF;  
  339.     ts.dev->id.version = S3C2410TSVERSION;  
  340.   
  341.     ts.shift = info->oversampling_shift;  
  342.     //printk("shift: %d\n",ts.shift);  
  343.       
  344.     /* Get irqs */  
  345.     //申请ADC中断，注意，中断类型为IRQF_SAMPLE_RANDOM | IRQF_SHARED，这样在使用触摸屏的时候  
  346.     //可以调试自己的ADC转换驱动，中断处理函数为adc_irq  
  347.     if (request_irq(IRQ_ADC, adc_irq, IRQF_SAMPLE_RANDOM | IRQF_SHARED,  
  348.         "s3c2440_action", ts.dev)) {  
  349.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_ADC !\n");  
  350.         iounmap(base_addr);  
  351.         return -EIO;  
  352.     }  
  353.     //申请TC中断，中断处理函数为tc_irq  
  354.     if (request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM,  
  355.             "s3c2440_action", ts.dev)) {  
  356.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_TC !\n");  
  357.         free_irq(IRQ_ADC, ts.dev);  
  358.         iounmap(base_addr);  
  359.         return -EIO;  
  360.     }  
  361.   
  362.     printk(KERN_INFO "%s successfully loaded\n", s3c2440ts_name);  
  363.   
  364.     /* All went ok, so register to the input system */  
  365.     /*这里注册设备 
  366.     函数功能： 
  367.      * This function registers device with input core. The device must be 
  368.      * allocated with input_allocate_device() and all it‘s capabilities 
  369.      * set up before registering. 
  370.      * If function fails the device must be freed with input_free_device(). 
  371.      * Once device has been successfully registered it can be unregistered 
  372.      * with input_unregister_device(); input_free_device() should not be 
  373.      * called in this case. 
  374.     函数原型如下： 
  375.     int input_register_device(struct input_dev *dev) 
  376.     { 
  377.         static atomic_t input_no = ATOMIC_INIT(0); 
  378.         struct input_handler *handler; 
  379.         const char *path; 
  380.         int error; 
  381.  
  382.         __set_bit(EV_SYN, dev->evbit); 
  383.  
  384.         init_timer(&dev->timer); 
  385.         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  386.             dev->timer.data = (long) dev; 
  387.             dev->timer.function = input_repeat_key; 
  388.             dev->rep[REP_DELAY] = 250; 
  389.             dev->rep[REP_PERIOD] = 33; 
  390.         } 
  391.  
  392.         if (!dev->getkeycode) 
  393.             dev->getkeycode = input_default_getkeycode; 
  394.  
  395.         if (!dev->setkeycode) 
  396.             dev->setkeycode = input_default_setkeycode; 
  397.  
  398.         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 
  399.              "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); 
  400.  
  401.         error = device_add(&dev->dev); 
  402.         if (error) 
  403.             return error; 
  404.  
  405.         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 
  406.         printk(KERN_INFO "input: %s as %s\n", 
  407.             dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  408.         kfree(path); 
  409.  
  410.         error = mutex_lock_interruptible(&input_mutex); 
  411.         if (error) { 
  412.             device_del(&dev->dev); 
  413.             return error; 
  414.         } 
  415.  
  416.         list_add_tail(&dev->node, &input_dev_list); 
  417.  
  418.         list_for_each_entry(handler, &input_handler_list, node) 
  419.             input_attach_handler(dev, handler); 
  420.  
  421.         input_wakeup_procfs_readers(); 
  422.  
  423.         mutex_unlock(&input_mutex); 
  424.  
  425.         return 0; 
  426.     } 
  427.     */  
  428.       
  429.     rc = input_register_device(ts.dev);  
  430.     if (rc) {  
  431.         free_irq(IRQ_TC, ts.dev);  
  432.         free_irq(IRQ_ADC, ts.dev);  
  433.         clk_disable(adc_clock);  
  434.         iounmap(base_addr);  
  435.         return -EIO;  
  436.     }  
  437.   
  438.     return 0;  
  439. }  
  440.   
  441. static int s3c2440ts_remove(struct platform_device *pdev)  
  442. {  
  443.     disable_irq(IRQ_ADC);  
  444.     disable_irq(IRQ_TC);  
  445.     free_irq(IRQ_TC,ts.dev);  
  446.     free_irq(IRQ_ADC,ts.dev);  
  447.   
  448.     if (adc_clock) {  
  449.         clk_disable(adc_clock);  
  450.         clk_put(adc_clock);  
  451.         adc_clock = NULL;  
  452.     }  
  453.   
  454.     input_unregister_device(ts.dev);  
  455.     iounmap(base_addr);  
  456.   
  457.     return 0;  
  458. }  
  459.   
  460. #ifdef CONFIG_PM  
  461. static int s3c2440ts_suspend(struct platform_device *pdev, pm_message_t state)  
  462. {  
  463.     writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC);  
  464.     writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM,  
  465.            base_addr+S3C2410_ADCCON);  
  466.   
  467.     disable_irq(IRQ_ADC);  
  468.     disable_irq(IRQ_TC);  
  469.   
  470.     clk_disable(adc_clock);  
  471.   
  472.     return 0;  
  473. }  
  474.   
  475. static int s3c2440ts_resume(struct platform_device *pdev)  
  476. {  
  477.     struct s3c2440_ts_mach_info *info =  
  478.         ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data;  
  479.   
  480.     clk_enable(adc_clock);  
  481.     msleep(1);  
  482.   
  483.     enable_irq(IRQ_ADC);  
  484.     enable_irq(IRQ_TC);  
  485.   
  486.     if ((info->presc&0xff) > 0)  
  487.         writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\  
  488.                  base_addr+S3C2410_ADCCON);  
  489.     else  
  490.         writel(0,base_addr+S3C2410_ADCCON);  
  491.   
  492.     /* Initialise registers */  
  493.     if ((info->delay&0xffff) > 0)  
  494.         writel(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  
  495.   
  496.     writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  497.   
  498.     return 0;  
  499. }  
  500.   
  501. #else  
  502. #define s3c2440ts_suspend NULL  
  503. #define s3c2440ts_resume  NULL  
  504. #endif  
  505. /* 
  506. 下面是/linux/platform_device.h定义的platform_driver结构体 
  507. struct platform_driver { 
  508.     int (*probe)(struct platform_device *);//设备的检测，所以需要先前的设备注册 
  509.     int (*remove)(struct platform_device *);//删除该设备 
  510.     void (*shutdown)(struct platform_device *); //关闭该设备 
  511.     int (*suspend)(struct platform_device *, pm_message_t state); 
  512.     int (*suspend_late)(struct platform_device *, pm_message_t state); 
  513.     int (*resume_early)(struct platform_device *); 
  514.     int (*resume)(struct platform_device *); 
  515.     struct pm_ext_ops *pm; 
  516.     struct device_driver driver;//设备驱动，定义在include/linux/device.h中 
  517. }; 
  518. 内核提供的platform_driver结构体的注册函数为platform_driver_register(),该函数定义在driver/base/platform.c中 
  519. */  
  520. static struct platform_driver s3c2440ts_driver = {  
  521.        .driver         = {  
  522.            .name   = "s3c2440-ts",  
  523.            .owner  = THIS_MODULE,  
  524.        },  
  525.        .probe          = s3c2440ts_probe,  
  526.        .remove         = s3c2440ts_remove,  
  527.        .suspend        = s3c2440ts_suspend,  
  528.        .resume         = s3c2440ts_resume,  
  529.   
  530. };  
  531.   
  532. static int __init s3c2440ts_init(void)  
  533. {  
  534.     int rc;  
  535.     rc = platform_driver_register(&s3c2440ts_driver);  
  536.     if (rc < 0)  
  537.         printk(KERN_ERR "platform_driver_register error!\n");  
  538.     return rc;  
  539. }  
  540.   
  541. static void __exit s3c2440ts_exit(void)  
  542. {  
  543.     platform_driver_unregister(&s3c2440ts_driver);  
  544. }  
  545.   
  546. module_init(s3c2440ts_init);  
  547. module_exit(s3c2440ts_exit);  
  548.   
  549. MODULE_AUTHOR("YANMING");  
  550. MODULE_DESCRIPTION("My s3c2440 touchscreen driver");  
  551. MODULE_LICENSE("GPL");  

4、分析完成后对触摸屏的工作过程就有了一个比较明确的认识

从触摸屏被按下到系统相应的过程如下：

（1） 当触摸屏感觉到触摸，触发IRQ_TC中断，然后读取触摸屏控制寄存器的值，判断是否被按下，如果被按下，启动定时器，执行touch_timer_fire()函数启动ADC转换。

（2） ADC转换完成后，会触发IRQ_ADC中断，执行相应的中断处理函数，如果ADC转换次数小于4，再次启动ADC转换；如果ADC转换次数为4，则启动一个系统滴答定时器，执行touch_timer_fire()函数

（3） 执行定时器服务程序时，如果此时触摸屏仍被按下，则上报事件和坐标数据，重复（2）；如果没有被按下，上报时间和坐标数据，将触摸屏控制寄存器设置为中断等待状态
可见，触摸屏驱动的服务是一个封闭的循环过程。

ARM-Linux驱动-触摸屏驱动分析

标签：des   style   blog   http   io   ar   使用   sp   for   

原文地址：http://www.cnblogs.com/0822vaj/p/4088698.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！