Chinaunix首页 | 论坛 | 博客
  • 博客访问: 900887
  • 博文数量: 453
  • 博客积分: 7865
  • 博客等级: 少将
  • 技术积分: 5673
  • 用 户 组: 普通用户
  • 注册时间: 2011-06-29 16:21
个人简介

时光荏苒..

文章分类
文章存档

2015年(46)

2014年(22)

2013年(68)

2012年(218)

2011年(99)

分类: LINUX

2012-01-16 22:35:19

硬件平台:FL2440

内核版本:2.6.28

主机平台:Ubuntu 11.04

内核版本:2.6.39

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

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

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

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

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

(1) 正常转换模式

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

(2) 分离XY坐标模式

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

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

相应的引脚连接:

(3) 自动XY坐标模式

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

相应的引脚连接:

(4) 等待中断模式

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

引脚定义如下:

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

  1. //#define CONFIG_TOUCHSCREEN_S3C2410_DEBUG   
  2.   
  3. #include    
  4. #include    
  5. #include    
  6. #include    
  7. #include    
  8. #include    
  9. #include    
  10. #include    
  11. #include    
  12. #include    
  13. #include    
  14. #include    
  15.   
  16. #include    
  17. #include    
  18.   
  19. #include    
  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<
  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.     dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); 
  304.     if (dev) { 
  305.         dev->dev.type = &input_dev_type; 
  306.         dev->dev.class = &input_class; 
  307.         device_initialize(&dev->dev); 
  308.         mutex_init(&dev->mutex); 
  309.         spin_lock_init(&dev->event_lock); 
  310.         INIT_LIST_HEAD(&dev->h_list); 
  311.         INIT_LIST_HEAD(&dev->node); 
  312.         __module_get(THIS_MODULE); 
  313.     } 
  314.     return dev; 
  315.     } 
  316.     */  
  317.     input_dev = input_allocate_device();  
  318.   
  319.     if (!input_dev) {  
  320.         printk(KERN_ERR "Unable to allocate the input device !!\n");  
  321.         return -ENOMEM;  
  322.     }  
  323.     //下面初始化输入设备信息   
  324.     ts.dev = input_dev;  
  325.     ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) |  
  326.                BIT_MASK(EV_ABS);  
  327.     ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);  
  328.     input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0);  
  329.     input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0);  
  330.     input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0);  
  331.   
  332.     //ts.dev->private = &ts;   
  333.     ts.dev->name = s3c2440ts_name;  
  334.     ts.dev->id.bustype = BUS_RS232;  
  335.     ts.dev->id.vendor = 0xDEAD;  
  336.     ts.dev->id.product = 0xBEEF;  
  337.     ts.dev->id.version = S3C2410TSVERSION;  
  338.   
  339.     ts.shift = info->oversampling_shift;  
  340.     //printk("shift: %d\n",ts.shift);   
  341.       
  342.     /* Get irqs */  
  343.     //申请ADC中断,注意,中断类型为IRQF_SAMPLE_RANDOM | IRQF_SHARED,这样在使用触摸屏的时候   
  344.     //可以调试自己的ADC转换驱动,中断处理函数为adc_irq   
  345.     if (request_irq(IRQ_ADC, adc_irq, IRQF_SAMPLE_RANDOM | IRQF_SHARED,  
  346.         "s3c2440_action", ts.dev)) {  
  347.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_ADC !\n");  
  348.         iounmap(base_addr);  
  349.         return -EIO;  
  350.     }  
  351.     //申请TC中断,中断处理函数为tc_irq   
  352.     if (request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM,  
  353.             "s3c2440_action", ts.dev)) {  
  354.         printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_TC !\n");  
  355.         free_irq(IRQ_ADC, ts.dev);  
  356.         iounmap(base_addr);  
  357.         return -EIO;  
  358.     }  
  359.   
  360.     printk(KERN_INFO "%s successfully loaded\n", s3c2440ts_name);  
  361.   
  362.     /* All went ok, so register to the input system */  
  363.     /*这里注册设备 
  364.     函数功能: 
  365.      * This function registers device with input core. The device must be 
  366.      * allocated with input_allocate_device() and all it's capabilities 
  367.      * set up before registering. 
  368.      * If function fails the device must be freed with input_free_device(). 
  369.      * Once device has been successfully registered it can be unregistered 
  370.      * with input_unregister_device(); input_free_device() should not be 
  371.      * called in this case. 
  372.     函数原型如下: 
  373.     int input_register_device(struct input_dev *dev) 
  374.     { 
  375.         static atomic_t input_no = ATOMIC_INIT(0); 
  376.         struct input_handler *handler; 
  377.         const char *path; 
  378.         int error; 
  379.         __set_bit(EV_SYN, dev->evbit); 
  380.         init_timer(&dev->timer); 
  381.         if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { 
  382.             dev->timer.data = (long) dev; 
  383.             dev->timer.function = input_repeat_key; 
  384.             dev->rep[REP_DELAY] = 250; 
  385.             dev->rep[REP_PERIOD] = 33; 
  386.         } 
  387.         if (!dev->getkeycode) 
  388.             dev->getkeycode = input_default_getkeycode; 
  389.         if (!dev->setkeycode) 
  390.             dev->setkeycode = input_default_setkeycode; 
  391.         snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), 
  392.              "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); 
  393.         error = device_add(&dev->dev); 
  394.         if (error) 
  395.             return error; 
  396.         path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); 
  397.         printk(KERN_INFO "input: %s as %s\n", 
  398.             dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); 
  399.         kfree(path); 
  400.         error = mutex_lock_interruptible(&input_mutex); 
  401.         if (error) { 
  402.             device_del(&dev->dev); 
  403.             return error; 
  404.         } 
  405.         list_add_tail(&dev->node, &input_dev_list); 
  406.         list_for_each_entry(handler, &input_handler_list, node) 
  407.             input_attach_handler(dev, handler); 
  408.         input_wakeup_procfs_readers(); 
  409.         mutex_unlock(&input_mutex); 
  410.         return 0; 
  411.     } 
  412.     */  
  413.       
  414.     rc = input_register_device(ts.dev);  
  415.     if (rc) {  
  416.         free_irq(IRQ_TC, ts.dev);  
  417.         free_irq(IRQ_ADC, ts.dev);  
  418.         clk_disable(adc_clock);  
  419.         iounmap(base_addr);  
  420.         return -EIO;  
  421.     }  
  422.   
  423.     return 0;  
  424. }  
  425.   
  426. static int s3c2440ts_remove(struct platform_device *pdev)  
  427. {  
  428.     disable_irq(IRQ_ADC);  
  429.     disable_irq(IRQ_TC);  
  430.     free_irq(IRQ_TC,ts.dev);  
  431.     free_irq(IRQ_ADC,ts.dev);  
  432.   
  433.     if (adc_clock) {  
  434.         clk_disable(adc_clock);  
  435.         clk_put(adc_clock);  
  436.         adc_clock = NULL;  
  437.     }  
  438.   
  439.     input_unregister_device(ts.dev);  
  440.     iounmap(base_addr);  
  441.   
  442.     return 0;  
  443. }  
  444.   
  445. #ifdef CONFIG_PM   
  446. static int s3c2440ts_suspend(struct platform_device *pdev, pm_message_t state)  
  447. {  
  448.     writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC);  
  449.     writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM,  
  450.            base_addr+S3C2410_ADCCON);  
  451.   
  452.     disable_irq(IRQ_ADC);  
  453.     disable_irq(IRQ_TC);  
  454.   
  455.     clk_disable(adc_clock);  
  456.   
  457.     return 0;  
  458. }  
  459.   
  460. static int s3c2440ts_resume(struct platform_device *pdev)  
  461. {  
  462.     struct s3c2440_ts_mach_info *info =  
  463.         ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data;  
  464.   
  465.     clk_enable(adc_clock);  
  466.     msleep(1);  
  467.   
  468.     enable_irq(IRQ_ADC);  
  469.     enable_irq(IRQ_TC);  
  470.   
  471.     if ((info->presc&0xff) > 0)  
  472.         writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\  
  473.                  base_addr+S3C2410_ADCCON);  
  474.     else  
  475.         writel(0,base_addr+S3C2410_ADCCON);  
  476.   
  477.     /* Initialise registers */  
  478.     if ((info->delay&0xffff) > 0)  
  479.         writel(info->delay & 0xffff,  base_addr+S3C2410_ADCDLY);  
  480.   
  481.     writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC);  
  482.   
  483.     return 0;  
  484. }  
  485.   
  486. #else   
  487. #define s3c2440ts_suspend NULL   
  488. #define s3c2440ts_resume  NULL   
  489. #endif   
  490. /* 
  491. 下面是/linux/platform_device.h定义的platform_driver结构体 
  492. struct platform_driver { 
  493.     int (*probe)(struct platform_device *);//设备的检测,所以需要先前的设备注册 
  494.     int (*remove)(struct platform_device *);//删除该设备 
  495.     void (*shutdown)(struct platform_device *); //关闭该设备 
  496.     int (*suspend)(struct platform_device *, pm_message_t state); 
  497.     int (*suspend_late)(struct platform_device *, pm_message_t state); 
  498.     int (*resume_early)(struct platform_device *); 
  499.     int (*resume)(struct platform_device *); 
  500.     struct pm_ext_ops *pm; 
  501.     struct device_driver driver;//设备驱动,定义在include/linux/device.h中 
  502. }; 
  503. 内核提供的platform_driver结构体的注册函数为platform_driver_register(),该函数定义在driver/base/platform.c中 
  504. */  
  505. static struct platform_driver s3c2440ts_driver = {  
  506.        .driver         = {  
  507.            .name   = "s3c2440-ts",  
  508.            .owner  = THIS_MODULE,  
  509.        },  
  510.        .probe          = s3c2440ts_probe,  
  511.        .remove         = s3c2440ts_remove,  
  512.        .suspend        = s3c2440ts_suspend,  
  513.        .resume         = s3c2440ts_resume,  
  514.   
  515. };  
  516.   
  517. static int __init s3c2440ts_init(void)  
  518. {  
  519.     int rc;  
  520.     rc = platform_driver_register(&s3c2440ts_driver);  
  521.     if (rc < 0)  
  522.         printk(KERN_ERR "platform_driver_register error!\n");  
  523.     return rc;  
  524. }  
  525.   
  526. static void __exit s3c2440ts_exit(void)  
  527. {  
  528.     platform_driver_unregister(&s3c2440ts_driver);  
  529. }  
  530.   
  531. module_init(s3c2440ts_init);  
  532. module_exit(s3c2440ts_exit);  
  533.   
  534. MODULE_AUTHOR("YANMING");  
  535. MODULE_DESCRIPTION("My s3c2440 touchscreen driver");  
  536. MODULE_LICENSE("GPL");  

//#define CONFIG_TOUCHSCREEN_S3C2410_DEBUG #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define TRUE 1 //CoAsia added #define FALSE 0 //CoAsia added #define FILTER_LIMIT 25 //CoAsia added /* For ts.dev.id.version */ #define S3C2410TSVERSION 0x0101 #define TSC_SLEEP (S3C2410_ADCTSC_PULL_UP_DISABLE | S3C2410_ADCTSC_XY_PST(0)) #define WAIT4INT(x) (((x)<<8) | \ S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \ S3C2410_ADCTSC_XY_PST(3)) #define AUTOPST (S3C2410_ADCTSC_YM_SEN | S3C2410_ADCTSC_YP_SEN | S3C2410_ADCTSC_XP_SEN | \ S3C2410_ADCTSC_AUTO_PST | S3C2410_ADCTSC_XY_PST(0)) #define DEBUG_LVL "<3>" //KERN_DEBUG static char *s3c2440ts_name = "s3c2440 TouchScreen"; /* * Per-touchscreen data. */ //定义s3c2440触摸屏使用的数据结构体 struct s3c2440ts { struct input_dev *dev; long xp; long yp; int count; int shift; }; static struct s3c2440ts ts; static struct clk *adc_clock; //__iomem声明地址空间是设备地址映射空间 static void __iomem *base_addr; //函数声明 static void touch_timer_fire(unsigned long data); static irqreturn_t tc_irq(int irq, void *dev_id); static irqreturn_t adc_irq(int irq, void *dev_id); static int __init s3c2440ts_probe(struct platform_device *pdev); static int s3c2440ts_remove(struct platform_device *pdev); static int s3c2440ts_resume(struct platform_device *pdev); //定义定时器 static struct timer_list touch_timer = TIMER_INITIALIZER(touch_timer_fire, 0, 0); //IRQ_TC中断处理函数 static irqreturn_t tc_irq(int irq, void *dev_id) { //data0,data1用于存放读取的ADCDAT数据寄存器的值 unsigned long data0; unsigned long data1; int updown;//用于存放光标的按下或提起的状态 //读取ADCDAT0、ADCDAT1数据寄存器的值 data0 = readl(base_addr+S3C2410_ADCDAT0); data1 = readl(base_addr+S3C2410_ADCDAT1); //查看数据寄存器的第15位的值 updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN)); /* TODO we should never get an interrupt with updown set while * the timer is running, but maybe we ought to verify that the * timer isn't running anyways. */ //如果data0和data1的第15位都是0,则updown为1,则通过函数touch_timer_fire()函数来启动ADC转换 if (updown) touch_timer_fire(0); return IRQ_HANDLED; } static void touch_timer_fire(unsigned long data) { //用于存储数据寄存器ADCDAT0、ADCDAT1的值 unsigned long data0; unsigned long data1; //用于存放光标是否被按下 int updown; data0 = readl(base_addr+S3C2410_ADCDAT0); data1 = readl(base_addr+S3C2410_ADCDAT1); updown = (!(data0 & S3C2410_ADCDAT0_UPDOWN)) && (!(data1 & S3C2410_ADCDAT0_UPDOWN)); //printk("The number of 'updown' is %d\n ",updown); //如果光标被按下,执行 if (updown) { //ts.count!=0表示ADC已经转换过,下面就报告事件和光标位置数据 if (ts.count != 0) { ts.xp >>= ts.shift;//这里shift为2,这里实际上是求均值,四次的和/4,这样定位更加准确 ts.yp >>= ts.shift; #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG { struct timeval tv; do_gettimeofday(&tv); printk(DEBUG_LVL "T: %06d, X: %03ld, Y: %03ld\n", (int)tv.tv_usec, ts.xp, ts.yp); } #endif /* 下面的函数位于/include/linux/input.h,作用是报告事件 static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value) { input_event(dev, EV_ABS, code, value); } */ //报告X,Y的绝对坐标 input_report_abs(ts.dev, ABS_X, ts.xp); input_report_abs(ts.dev, ABS_Y, ts.yp); //报告事件,1代表光标被按下 input_report_key(ts.dev, BTN_TOUCH, 1); //报告触摸屏状态,1代表触摸屏被按下 input_report_abs(ts.dev, ABS_PRESSURE, 1); //等待接收方的确认,用于事件的同步 input_sync(ts.dev); } //现在光标被按下,并且ADC转换没有启动 ts.xp = 0; ts.yp = 0; ts.count = 0; //设置触摸屏控制寄存器的值为 0xdc B:1101 1100,设置控制寄存器上拉无效,自动转换X,Y坐标 //printk("S3C2410_ADCTSC: 0x%x\n",S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST); writel(S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST, base_addr+S3C2410_ADCTSC); //启动ADC转换 writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_ENABLE_START, base_addr+S3C2410_ADCCON); } else//光标没有被按下 { ts.count = 0; //报告事件及光标的位置状态 input_report_key(ts.dev, BTN_TOUCH, 0); input_report_abs(ts.dev, ABS_PRESSURE, 0); //等待接收方的应答,用于同步 input_sync(ts.dev); //设置触摸屏控制寄存器为等待中断模式 writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC); } } static irqreturn_t adc_irq(int irq, void *dev_id) { //用于存放数据寄存器的数据 unsigned long data0; unsigned long data1; //读取数据,这次主要读取的是位置数据 data0 = readl(base_addr+S3C2410_ADCDAT0); data1 = readl(base_addr+S3C2410_ADCDAT1); ts.xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;//累加四次准换结果的X坐标和 ts.yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;//累加四次准换结果的Y坐标和 ts.count++;//转换次数加一 //如果转换次数小于4 if (ts.count < (1<dev.platform_data; if (!info) { printk(KERN_ERR "Hm... too bad : no platform data for ts\n"); return -EINVAL; } #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG printk(DEBUG_LVL "Entering s3c2440ts_init\n"); #endif //由于ADC转换需要时钟,这里获取时钟 adc_clock = clk_get(NULL, "adc"); if (!adc_clock) { printk(KERN_ERR "failed to get adc clock source\n"); return -ENOENT; } clk_enable(adc_clock);//使能时钟 #ifdef CONFIG_TOUCHSCREEN_S3C2410_DEBUG printk(DEBUG_LVL "got and enabled clock\n"); #endif //通过ioremap实现物理地址到虚拟地址的转换 base_addr = ioremap(S3C2410_PA_ADC,0x20); if (base_addr == NULL) { printk(KERN_ERR "Failed to remap register block\n"); return -ENOMEM; } //设置ADCCON控制寄存器为0x4c40,设置预分频有效,预分频值为B:110001 D:49 //printk("ADCCON is 0x%x\n",S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF)); if ((info->presc&0xff) > 0) writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\ base_addr+S3C2410_ADCCON); else writel(0,base_addr+S3C2410_ADCCON); /* Initialise registers */ /* 设置ADC开始延时寄存器ADCDLY: 0x4e20 */ //printk("ADCDLY: 0x%x\n",info->delay & 0xffff); if ((info->delay&0xffff) > 0) writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY); /* 设置ADC触摸屏控制寄存器ADC_TSC: 0xd3 B:1101 0011 [8]检测光标按下中断信号 [7]YM输出驱动有效(GND) [6]YP输出驱动无效(AIN5) [5]XM输出驱动无效(Hi-z) [4]XP输出驱动无效(AIN7) [3]XP上拉有效 [2]普通ADC转换 [0:1]等待中断模式 测量X和Y的坐标 */ //printk("ADC_TSC: 0x%x\n",WAIT4INT(0)); writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC); /* Initialise input stuff */ memset(&ts, 0, sizeof(struct s3c2440ts)); /* 下面的函数 为新的输入设备分配内存。 使用free_device()释放没有被注册的函数,使用input_unregister_device()解除已经注册的设备 定义在/drivers/input/input.c struct input_dev *input_allocate_device(void) { struct input_dev *dev; dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL); if (dev) { dev->dev.type = &input_dev_type; dev->dev.class = &input_class; device_initialize(&dev->dev); mutex_init(&dev->mutex); spin_lock_init(&dev->event_lock); INIT_LIST_HEAD(&dev->h_list); INIT_LIST_HEAD(&dev->node); __module_get(THIS_MODULE); } return dev; } */ input_dev = input_allocate_device(); if (!input_dev) { printk(KERN_ERR "Unable to allocate the input device !!\n"); return -ENOMEM; } //下面初始化输入设备信息 ts.dev = input_dev; ts.dev->evbit[0] = BIT_MASK(EV_SYN) | BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); ts.dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); input_set_abs_params(ts.dev, ABS_X, 0, 0x3FF, 0, 0); input_set_abs_params(ts.dev, ABS_Y, 0, 0x3FF, 0, 0); input_set_abs_params(ts.dev, ABS_PRESSURE, 0, 1, 0, 0); //ts.dev->private = &ts; ts.dev->name = s3c2440ts_name; ts.dev->id.bustype = BUS_RS232; ts.dev->id.vendor = 0xDEAD; ts.dev->id.product = 0xBEEF; ts.dev->id.version = S3C2410TSVERSION; ts.shift = info->oversampling_shift; //printk("shift: %d\n",ts.shift); /* Get irqs */ //申请ADC中断,注意,中断类型为IRQF_SAMPLE_RANDOM | IRQF_SHARED,这样在使用触摸屏的时候 //可以调试自己的ADC转换驱动,中断处理函数为adc_irq if (request_irq(IRQ_ADC, adc_irq, IRQF_SAMPLE_RANDOM | IRQF_SHARED, "s3c2440_action", ts.dev)) { printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_ADC !\n"); iounmap(base_addr); return -EIO; } //申请TC中断,中断处理函数为tc_irq if (request_irq(IRQ_TC, tc_irq, IRQF_SAMPLE_RANDOM, "s3c2440_action", ts.dev)) { printk(KERN_ERR "s3c2440_ts.c: Could not allocate ts IRQ_TC !\n"); free_irq(IRQ_ADC, ts.dev); iounmap(base_addr); return -EIO; } printk(KERN_INFO "%s successfully loaded\n", s3c2440ts_name); /* All went ok, so register to the input system */ /*这里注册设备 函数功能: * This function registers device with input core. The device must be * allocated with input_allocate_device() and all it's capabilities * set up before registering. * If function fails the device must be freed with input_free_device(). * Once device has been successfully registered it can be unregistered * with input_unregister_device(); input_free_device() should not be * called in this case. 函数原型如下: int input_register_device(struct input_dev *dev) { static atomic_t input_no = ATOMIC_INIT(0); struct input_handler *handler; const char *path; int error; __set_bit(EV_SYN, dev->evbit); init_timer(&dev->timer); if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) { dev->timer.data = (long) dev; dev->timer.function = input_repeat_key; dev->rep[REP_DELAY] = 250; dev->rep[REP_PERIOD] = 33; } if (!dev->getkeycode) dev->getkeycode = input_default_getkeycode; if (!dev->setkeycode) dev->setkeycode = input_default_setkeycode; snprintf(dev->dev.bus_id, sizeof(dev->dev.bus_id), "input%ld", (unsigned long) atomic_inc_return(&input_no) - 1); error = device_add(&dev->dev); if (error) return error; path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL); printk(KERN_INFO "input: %s as %s\n", dev->name ? dev->name : "Unspecified device", path ? path : "N/A"); kfree(path); error = mutex_lock_interruptible(&input_mutex); if (error) { device_del(&dev->dev); return error; } list_add_tail(&dev->node, &input_dev_list); list_for_each_entry(handler, &input_handler_list, node) input_attach_handler(dev, handler); input_wakeup_procfs_readers(); mutex_unlock(&input_mutex); return 0; } */ rc = input_register_device(ts.dev); if (rc) { free_irq(IRQ_TC, ts.dev); free_irq(IRQ_ADC, ts.dev); clk_disable(adc_clock); iounmap(base_addr); return -EIO; } return 0; } static int s3c2440ts_remove(struct platform_device *pdev) { disable_irq(IRQ_ADC); disable_irq(IRQ_TC); free_irq(IRQ_TC,ts.dev); free_irq(IRQ_ADC,ts.dev); if (adc_clock) { clk_disable(adc_clock); clk_put(adc_clock); adc_clock = NULL; } input_unregister_device(ts.dev); iounmap(base_addr); return 0; } #ifdef CONFIG_PM static int s3c2440ts_suspend(struct platform_device *pdev, pm_message_t state) { writel(TSC_SLEEP, base_addr+S3C2410_ADCTSC); writel(readl(base_addr+S3C2410_ADCCON) | S3C2410_ADCCON_STDBM, base_addr+S3C2410_ADCCON); disable_irq(IRQ_ADC); disable_irq(IRQ_TC); clk_disable(adc_clock); return 0; } static int s3c2440ts_resume(struct platform_device *pdev) { struct s3c2440_ts_mach_info *info = ( struct s3c2440_ts_mach_info *)pdev->dev.platform_data; clk_enable(adc_clock); msleep(1); enable_irq(IRQ_ADC); enable_irq(IRQ_TC); if ((info->presc&0xff) > 0) writel(S3C2410_ADCCON_PRSCEN | S3C2410_ADCCON_PRSCVL(info->presc&0xFF),\ base_addr+S3C2410_ADCCON); else writel(0,base_addr+S3C2410_ADCCON); /* Initialise registers */ if ((info->delay&0xffff) > 0) writel(info->delay & 0xffff, base_addr+S3C2410_ADCDLY); writel(WAIT4INT(0), base_addr+S3C2410_ADCTSC); return 0; } #else #define s3c2440ts_suspend NULL #define s3c2440ts_resume NULL #endif /* 下面是/linux/platform_device.h定义的platform_driver结构体 struct platform_driver { int (*probe)(struct platform_device *);//设备的检测,所以需要先前的设备注册 int (*remove)(struct platform_device *);//删除该设备 void (*shutdown)(struct platform_device *); //关闭该设备 int (*suspend)(struct platform_device *, pm_message_t state); int (*suspend_late)(struct platform_device *, pm_message_t state); int (*resume_early)(struct platform_device *); int (*resume)(struct platform_device *); struct pm_ext_ops *pm; struct device_driver driver;//设备驱动,定义在include/linux/device.h中 }; 内核提供的platform_driver结构体的注册函数为platform_driver_register(),该函数定义在driver/base/platform.c中 */ static struct platform_driver s3c2440ts_driver = { .driver = { .name = "s3c2440-ts", .owner = THIS_MODULE, }, .probe = s3c2440ts_probe, .remove = s3c2440ts_remove, .suspend = s3c2440ts_suspend, .resume = s3c2440ts_resume, }; static int __init s3c2440ts_init(void) { int rc; rc = platform_driver_register(&s3c2440ts_driver); if (rc < 0) printk(KERN_ERR "platform_driver_register error!\n"); return rc; } static void __exit s3c2440ts_exit(void) { platform_driver_unregister(&s3c2440ts_driver); } module_init(s3c2440ts_init); module_exit(s3c2440ts_exit); MODULE_AUTHOR("YANMING"); MODULE_DESCRIPTION("My s3c2440 touchscreen driver"); 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);如果没有被按下,上报时间和坐标数据,将触摸屏控制寄存器设置为中断等待状态
可见,触摸屏驱动的服务是一个封闭的循环过程。

阅读(1683) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~