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

出处：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和触摸屏接口的模块图

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