转：linux--6410触摸屏驱动

目前，市面上很多6410开发板都存在触摸屏抖动的问题，tiny6410也不例外，友善的解决方法是采用一线触摸，即在LCD板上，用一个单片机控制ADS7846芯片AD转换，再将数据通过单总线的方式与6410通讯。可是，我这里没有一线触摸板，于是就开始移植ADS7846驱动到tiny6410。

介绍：

可能有人会问，6410的触摸屏为什么会抖动呢，是不是滤波没做好，或者是硬件走线的原因？是不是硬件的原因，我无法验证。我尝试过通过滤波来改善，但效果一般。不说别的，我在单独测试AD的时候，发现在输入不变的情况下，AD采样的跳幅最大达到25（0～1024范围），可见，跳动还是很大的，这样的情况下，即使再滤波也只是浪费时间。

mini6410-ts.c触摸屏驱动见：

（原创）6410触摸屏驱动分析（s3c-ts.c）（Linux）（分析）

先说说我的硬件：

TS_PEN ----- GPN9 EINT9

TS_MISO ---- GPC0 MISO0

TS_MOSI ---- GPC2 MOSI0

TS_SCK ----- GPC1 SCK0

TS_CS ----- GPC3 CS0

这些端子在核心板的CON1上可以找到，我这里是用的IO模拟的SPI。

下面的开始介绍移植的过程，代码，我在下面会全部帖出来，里面注释也很详细，一般都能看明白。

1、复制/opt/FriendlyARM/mini6410/linux-2.6.38/drivers/input/touchscreen/mini6410-ts.c为mini6410-ads7846.c。

修改后，如下：

001 /* linux/drivers/input/touchscreen/s3c-ts.c
002 *
003 * This program is free software; you can redistribute it and/or modify
004 * it under the terms of the GNU General Public License as published by
005 * the Free Software Foundation; either version 2 of the License, or
006 * (at your option) any later version.
007 *
008 * This program is distributed in the hope that it will be useful,
009 * but WITHOUT ANY WARRANTY; without even the implied warranty of
010 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
011 * GNU General Public License for more details.
012 *
013 * You should have received a copy of the GNU General Public License
014 * along with this program; if not, write to the Free Software
015 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
016 *
017 * a misc driver for mini6410 touch screen
018 * by FriendlyARM 2010
019 *
020 * Based on following software:
021 *
022 ** Copyright (c) 2004 Arnaud Patard
023 ** iPAQ H1940 touchscreen support
024 **
025 ** ChangeLog
026 **
027 ** 2004-09-05: Herbert Potzl
028 ** - added clock (de-)allocation code
029 **
030 ** 2005-03-06: Arnaud Patard
031 ** - h1940_ -> s3c24xx (this driver is now also used on the n30
032 ** machines :P)
033 ** - Debug messages are now enabled with the config option
034 ** TOUCHSCREEN_S3C_DEBUG
035 ** - Changed the way the value are read
036 ** - Input subsystem should now work
037 ** - Use ioremap and readl/writel
038 **
039 ** 2005-03-23: Arnaud Patard
040 ** - Make use of some undocumented features of the touchscreen
041 ** controller
042 **
043 ** 2006-09-05: Ryu Euiyoul
044 ** - added power management suspend and resume code
045 *
046 * 2011-6-23: ADS7846触摸屏驱动程序 by liu_xf
047 * http://www.cnblogs.com/liu_xf
048 *
049 * 2011-6-29 改进滤波，并将AD连续转换8次的间隔缩小了
050 */
051
052 #include
053 #include
054 #include
055 #include
056 #include
057 #include
058 #include
059 #include
060 #include
061 #include
062 #include
063 #include
064 #include
065 #include
066 #include
067 #include
068
069 #include
070 #include
071 #include
072 #include
073
074
075 //#include
076 #include
077 #include
078 #include
079 #include
080 #include
081 #include
082
083
084 #define CONFIG_TOUCHSCREEN_ADS7846_DEBUG
085 #undef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
086 #define DEBUG_LVL KERN_DEBUG
087
088
089 /*
090 * Definitions & global arrays.
091 */
092 #define DEVICE_NAME "touchscreen"
093 static DECLARE_WAIT_QUEUE_HEAD(ts_waitq); //定义并初始化一个等待队列
094
095 typedef unsigned TS_EVENT;
096 #define NR_EVENTS 64 //触摸屏fifo大小
097
098
099 static TS_EVENT events[NR_EVENTS];
100 static int evt_head, evt_tail; //fifo的头的尾
101 //驱动写fifo时evt_head++，应用读fifo时 evt_tail++
102
103 #define ts_evt_pending() ((volatile u8)(evt_head != evt_tail)) //相等就表示满了
104 #define ts_evt_get() (events + evt_tail)
105 #define ts_evt_pull() (evt_tail = (evt_tail + 1) & (NR_EVENTS - 1))
106 #define ts_evt_clear() (evt_head = evt_tail = 0)
107
108 #define ADS7846_CNV_NBR 8 //ADC连续转换的次数
109 struct ads7846_ts_info {
110
111 struct input_dev *dev;
112
113 unsigned int xp; //x方向位置
114 unsigned int yp; //y方向位置
115 unsigned int count; //adc转换次数
116 unsigned int cnv_nbr;
117 unsigned int x_buf[ADS7846_CNV_NBR]; //ad转换buf
118 unsigned int y_buf[ADS7846_CNV_NBR];
119
120 };
121
122 static struct ads7846_ts_info *ts;
123
124
125
126
127 //ADS7846底层操作========================================================================
128 #define ADS7846_GPIO_MISO 0 //gpc0
129 #define ADS7846_GPIO_MOSI 2 //gpc2
130 #define ADS7846_GPIO_CLK 1 //gpc1
131 #define ADS7846_GPIO_CS 3 //gpc3
132
133 // ADS7846 Control Byte bit defines
134 #define ADS7846_CMD_START 0x0080
135 #define ADS7846_ADDR_BIT 4
136 #define ADS7846_ADDR_MASK (0x7<
137 #define ADS7846_MEASURE_X (0x5<
138 #define ADS7846_MEASURE_Y (0x1<
139 #define ADS7846_MEASURE_Z1 (0x3<
140 #define ADS7846_MEASURE_Z2 (0x4<
141 #define ADS7846_8BITS (1<<3)
142 #define ADS7846_12BITS 0
143 #define ADS7846_SER (1<<2)
144 #define ADS7846_DFR 0
145 #define ADS7846_PWR_BIT 0
146 #define ADS7846_PD 0
147 #define ADS7846_ADC_ON (0x1<
148 #define ADS7846_REF_ON (0x2<
149 #define ADS7846_REF_ADC_ON (0x3<
150
151 #define MEASURE_8BIT_X\
152 (unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_X | ADS7846_8BITS | ADS7846_DFR | ADS7846_PD)
153 #define MEASURE_8BIT_Y\
154 (unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_Y | ADS7846_8BITS | ADS7846_DFR | ADS7846_PD)
155
156 #define MEASURE_12BIT_X \
157 (unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_X | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)
158 #define MEASURE_12BIT_Y \
159 (unsigned short)(ADS7846_CMD_START | ADS7846_MEASURE_Y | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)
160 #define MEASURE_12BIT_Z1 \
161 (unsigned char)(ADS7846_MEASURE_Z1 | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)
162 #define MEASURE_12BIT_Z2 \
163 (unsigned char)(ADS7846_MEASURE_Z2 | ADS7846_12BITS | ADS7846_DFR | ADS7846_PD)
164
165 // Pin access
166 //
167 static inline void set_miso_as_up(void)//gpc0
168 {
169 unsigned long tmp;
170 tmp = readl(S3C64XX_GPCPUD);
171 tmp &= ~(3U <<0);
172 tmp |= (2U << 0);
173 writel(tmp, S3C64XX_GPCPUD);
174 }
175
176 static inline void set_miso_as_input(void)//gpc0
177 {
178 unsigned long tmp;
179 tmp = readl(S3C64XX_GPCCON);
180 tmp &= ~(0xf << 0);
181 writel(tmp, S3C64XX_GPCCON);
182 }
183
184 static inline void set_cs_mosi_clk_as_output(void)//gpc1 2 3
185 {
186 unsigned long tmp;
187 tmp = readl(S3C64XX_GPCCON);
188 tmp = (tmp & ~0xfff0) | (0x1110);
189 writel(tmp, S3C64XX_GPCCON);
190 }
191
192 static inline void set_cs_mosi_clk_as_up(void)//gpc1 2 3
193 {
194 unsigned long tmp;
195 tmp = readl(S3C64XX_GPCPUD);
196 tmp &= ~((3U <<2)|(3U <<4)|(3U <<6));
197 tmp |= (2U << 2) | (2U << 4) | (2U << 6);
198 writel(tmp, S3C64XX_GPCPUD);
199 }
200
201
202 static inline void set_gpcx_value(int pinx ,int v)
203 {
204 unsigned long tmp;
205 tmp = readl(S3C64XX_GPCDAT);
206 if (v) {
207 tmp |= (1 << pinx);
208 } else {
209 tmp &= ~(1<
210 }
211 writel(tmp, S3C64XX_GPCDAT);
212 }
213
214 static inline int get_gpcx_value(int pinx)
215 {
216 int v;
217 unsigned long tmp;
218 tmp = readl(S3C64XX_GPCDAT);
219 v = !!(tmp & (1<
220 return v;
221 }
222
223 //读12bit
224 static unsigned int ads7846_Read_Data(void)
225 {
226 unsigned int i,temp=0x00;
227 for(i=0;i<12;i++)
228 {
229 temp <<=1;
230 set_gpcx_value(ADS7846_GPIO_CLK, 1); udelay(10);
231 set_gpcx_value(ADS7846_GPIO_CLK, 0); udelay(10);
232 if(get_gpcx_value(ADS7846_GPIO_MISO) != 0)temp++;
233 }
234 return (temp);
235 }
236 //写8bit
237 static void ads7846_Write_Data(unsigned int n)
238 {
239 unsigned char i;
240 set_gpcx_value(ADS7846_GPIO_CLK, 0);
241 for(i=0;i<8;i++)
242 {
243 if((n&0x80)==0x80)
244 set_gpcx_value(ADS7846_GPIO_MOSI, 1);
245 else
246 set_gpcx_value(ADS7846_GPIO_MOSI, 0);
247
248 n <<= 1;
249 set_gpcx_value(ADS7846_GPIO_CLK, 1); udelay(10);
250 set_gpcx_value(ADS7846_GPIO_CLK, 0); udelay(10);
251 }
252 }
253
254
255 //ADS7846转换==
256 //保存在ts->buf 当中
257 static void ads7846_conver_start(void)
258 {
259 int i;
260 unsigned int cmd[2];
261 unsigned int data[2];
262
263 set_gpcx_value(ADS7846_GPIO_CS, 0);
264 //开读
265 cmd[0] = MEASURE_12BIT_X;
266 cmd[1] = MEASURE_12BIT_Y;
267
268 /* CS# Low */
269 set_gpcx_value(ADS7846_GPIO_CS, 0);
270
271 //连续转换
272 for(ts->count=0; ts->countcnv_nbr;)
273 {
274 //分别读出x y坐标＝＝
275 for(i=0; i<2; i++){
276 ads7846_Write_Data(cmd[i]);
277 udelay(40);
278 data[i] = ads7846_Read_Data();
279 }
280
281
282
283 //保存转换结果
284 ts->x_buf[ts->count]= data[0];
285 ts->y_buf[ts->count]= data[1];
286 ts->count++;
287 }
288 /* CS# High */
289 set_gpcx_value(ADS7846_GPIO_CS, 1);
290
291 #ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
292 //printk("ts read pos: x = %d, y = %d\n", data[0], data[1]);
293 #endif
294
295 }
296
297
298 //-----------------------------------------------------------------------------
299
300 //触摸屏数据滤波算法
301 //触摸屏AD连续转换N次后，按升序排列，再取中间几位值求平均
302 #define TS_AD_NBR_PJ 4 //取中间4位求平均值
303 #define TS_AD_NBR_MAX_CZ 10 //最大与最小的差值
304 static inline bool touch_ad_data_filter(unsigned int *buf0, unsigned int *buf1)
305 {
306 unsigned int i,j,k,temp,temp1,nbr=(ADS7846_CNV_NBR);
307 //将转换结果升序排列
308 //buf0
309 for (j= 0; j< nbr; j++)
310 for (i = 0; i < nbr; i++)
311 {
312 if(buf0[i]>buf0[i+1])//升序排列
313 {
314 temp=buf0[i+1];
315 buf0[i+1]=buf0[i];
316 buf0[i]=temp;
317 }
318 }
319
320 //buf1
321 for (j= 0; j< nbr; j++)
322 for (i = 0; i < nbr; i++)
323 {
324 if(buf1[i]>buf1[i+1])//升序排列
325 {
326 temp=buf1[i+1];
327 buf1[i+1]=buf1[i];
328 buf1[i]=temp;
329 }
330 }
331
332 //串口调试查看结果
333 //for (j= 0; j< nbr; j++)
334 // printk("buf0[%2d]=%4d, buf1[%2d]=%4d,\r\n",j,buf0[j],j,buf1[j]);
335 //取中间值求平均==
336 k=((nbr-TS_AD_NBR_PJ)>>1);
337 temp = 0;temp1 = 0;
338 //检查值是否有效==
339 if((buf0[k+TS_AD_NBR_PJ-1]-buf0[k]>TS_AD_NBR_MAX_CZ)||(buf1[k+TS_AD_NBR_PJ-1]-buf1[k]>TS_AD_NBR_MAX_CZ)) //无效值
340 {
341
342 return 0;
343 }
344 //--
345 //将中间指定位数累加
346 for(i=0;i
347 {
348 temp += buf0[k+i];
349 temp1 += buf1[k+i];
350 }
351 //求平均值,将结果保存在最低位
352 buf0[0]=temp/TS_AD_NBR_PJ;
353 buf1[0] = temp1/TS_AD_NBR_PJ;
354 //--
355 return 1;
356
357 }
358
359
360 //将AD转换的值放入FIFO
361 //这里是一个先进先出的fifo
362 //只要有数据被添加进来，就会唤醒ts_waitq进程
363 static void ts_evt_add(unsigned x, unsigned y, unsigned down) {
364 unsigned ts_event;
365 int next_head;
366
367 ts_event = ((x << 16) | (y)) | (down << 31);
368 next_head = (evt_head + 1) & (NR_EVENTS - 1);
369 //没满就装入
370 if (next_head != evt_tail) {
371 events[evt_head] = ts_event;
372 evt_head = next_head;
373 #ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
374 printk("====>Add ... [ %4d, %4d ]%s\n", x, y, down ? "":" ~~~");
375 #endif
376 /* wake up any read call */
377 if (waitqueue_active(&ts_waitq)) { //判斷等待隊列是否有進程睡眠
378 wake_up_interruptible(&ts_waitq); //唤醒ts_waitq等待队列中所有interruptible类型的进程
379 }
380 } else {
381 /* drop the event and try to wakeup readers */
382 printk(KERN_WARNING "mini6410-ads7846: touch event buffer full");
383 wake_up_interruptible(&ts_waitq);
384 }
385 }
386
387 static unsigned int ads7846_ts_poll( struct file *file, struct poll_table_struct *wait)
388 {
389 unsigned int mask = 0;
390
391 //将ts_waitq等待队列添加到poll_table里去
392 poll_wait(file, &ts_waitq, wait);
393 //返回掩码
394 if (ts_evt_pending())
395 mask |= POLLIN | POLLRDNORM; //返回设备可读
396
397 return mask;
398 }
399
400 //读 系统调用==
401 static int ads7846_ts_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
402 {
403 DECLARE_WAITQUEUE(wait, current); //把当前进程加到定义的等待队列头wait中
404 char *ptr = buff;
405 int err = 0;
406
407 add_wait_queue(&ts_waitq, &wait); //把wait入到等待队列头中。该队列会在进程等待的条件满足时唤醒它。
408 //我们必须在其他地方写相关代码，在事件发生时，对等的队列执行wake_up()操作。
409 //这里是在ts_evt_add里wake_up
410 while (count >= sizeof(TS_EVENT)) {
411 err = -ERESTARTSYS;
412 if (signal_pending(current)) //如果是信号唤醒 参考http://www.360doc.com/content/10/1009/17/1317564_59632874.shtml
413 break;
414
415 if (ts_evt_pending()) {
416 TS_EVENT *evt = ts_evt_get();
417
418 err = copy_to_user(ptr, evt, sizeof(TS_EVENT));
419 ts_evt_pull();
420
421 if (err)
422 break;
423
424 ptr += sizeof(TS_EVENT);
425 count -= sizeof(TS_EVENT);
426 continue;
427 }
428
429 set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为可中断的睡眠
430 err = -EAGAIN;
431 if (filp->f_flags & O_NONBLOCK) //如果上层调用是非阻塞方式，则不阻塞该进程，直接返回EAGAIN
432 break;
433 schedule(); //本进程在此处交出CPU控制权，等待被唤醒
434 //进程调度的意思侧重于把当前任务从CPU拿掉，再从就绪队列中按照调度算法取一就绪进程占用CPU
435 }
436 current->state = TASK_RUNNING;
437 remove_wait_queue(&ts_waitq, &wait);
438
439 return ptr == buff ? err : ptr - buff;
440 }
441 //--
442
443 static int ads7846_ts_open(struct inode *inode, struct file *filp) {
444 /* flush event queue */
445 ts_evt_clear();
446
447 return 0;
448 }
449
450 //当应用程序操作设备文件时调用的open read等函数，最终会调用这个结构体中对应的函数
451 static struct file_operations dev_fops = {
452 .owner = THIS_MODULE,
453 .read = ads7846_ts_read,
454 .poll = ads7846_ts_poll, //select系统调用
455 .open = ads7846_ts_open,
456 };
457
458 //设备号，设备名，注册的时候用到这个数组
459 //混杂设备主设备号为10
460 static struct miscdevice misc = {
461 .minor = MISC_DYNAMIC_MINOR, //自动分配次设置号
462 //.minor = 180,
463 .name = DEVICE_NAME,
464 .fops = &dev_fops,
465 };
466
467
468
469
470
471
472 /**
473 * get_down - return the down state of the pen
474 * 获取pen引脚状态，为0表示down
475 * GPN9 EINT9 TS_PEN
476 */
477 static inline bool get_down(void)
478 {
479 int tmp,down;
480 tmp = readl(S3C64XX_GPNDAT);
481 down = !(tmp & (1<<9));
482 return (down);
483 }
484
485
486 /*===========================================================================================
487 touch_timer_get_value这个函数的调用：
488
489 1、 触摸笔开始点击的时候， 在中断函数touch_down里面被调用，不是直接调用，而是设置定时器超时后调用
490 这样是为了去抖动
491
492 2、 touch_timer_get_value被调用一次后，如果pendown信号有效，则touch_timer_get_value会被持续调用
493 也是通过定时器实现的
494
495 touch_timer_get_value这个函数的功能：
496 启动7846转换，直到连续转换8次后，再滤波处理，获得有效值，并向上报告触摸屏事件
497
498 ============================================================================================*/
499 static void touch_timer_get_value(unsigned long data);
500
501 static DEFINE_TIMER(touch_timer, touch_timer_get_value, 0, 0);
502
503 static void touch_timer_get_value(unsigned long data) {
504
505 int pendown;
506
507 pendown = get_down();
508
509 #ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
510 // if(pendown)
511 // {
512 // printk("touch is down!\n");
513 // }
514 // else
515 // printk("touch is up!\n");
516 #endif
517
518 if (pendown) {
519
520 //关中断===
521 disable_irq(IRQ_EINT(9));
522 //--
523 //启动ADS7846转换==
524 ads7846_conver_start();
525 //开中断==
526 enable_irq(IRQ_EINT(9));
527 //--
528 //如果转换了8次，就写入FIFO保存
529 //if (ts->count == ( ts->cnv_nbr)) {
530 if(touch_ad_data_filter(ts->x_buf,ts->y_buf)) //滤波处理
531 {
532
533 ts->xp = ts->x_buf[0];
534 ts->yp = ts->y_buf[0];
535
536 ts_evt_add(ts->xp, ts->yp, 1); //向上报告触摸屏事件
537 }
538
539
540 ts->xp = 0;
541 ts->yp = 0;
542 ts->count = 0;
543 //}
544 //--
545
546 mod_timer(&touch_timer, jiffies + 2); //重新设置系统定时器，超时后，又会调用touch_timer_get_value
547 //jiffies变量记录了系统启动以来，系统定时器已经触发的次数。内核每秒钟将jiffies变量增加HZ次。
548 //因此，对于HZ值为100的系统，1个jiffy等于10ms，而对于HZ为1000的系统，1个jiffy仅为1ms
549 //这里系统配置提HZ是100
550
551 } else { //如果是松开，报告其触摸笔状态
552 ts->xp = 0;
553 ts->yp = 0;
554 ts->count = 0;
555
556 ts_evt_add(0, 0, 0);
557
558
559 }
560
561 }
562
563
564
565 //触摸屏按下中断服务==
566 //双边沿中断
567 static irqreturn_t touch_down(int irqno, void *param)
568 {
569
570
571 /* Clear interrupt */
572 //__raw_writel(0x0, ts_base + S3C_ADCCLRWK);
573 //__raw_writel(0x0, ts_base + S3C_ADCCLRINT);
574
575 //稍后调用touch_timer_get_value，去抖动
576 mod_timer(&touch_timer, jiffies + 2); //等ADS7846转换完成了再读
577 //同时还可以防抖动，如果定时器没有超时的这段时间里，发生了抬起和按下中断，则定时器的值会被重设，不会超时
578 //内核配置时HZ值设为100，即1个jiffy等于10ms，
579 //touch_timer_get_value(1); //直接调用会有抖动
580
581 return IRQ_RETVAL(IRQ_HANDLED);
582 }
583
584
585
586
587 //-------------------------------------------
588
589
590 /*
591 * The functions for inserting/removing us as a module.
592 */
593 static int __init ads7846_ts_probe(struct platform_device *pdev)
594 {
595 struct device *dev;
596 int ret = 0;
597
598 dev = &pdev->dev;
599 #ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
600 printk("ads7846_ts_probe start!\n");
601 #endif
602 //给ads7846_ts_info指针分配内存==
603 ts = kzalloc(sizeof(struct ads7846_ts_info), GFP_KERNEL);
604 ts->cnv_nbr = ADS7846_CNV_NBR;
605 ts->xp = 0;
606 ts->yp = 0;
607 ts->count = 0;
608
609
610 //申请中断==
611 //TS_PEN双边沿触发 EINT9 GPN9
612 ret = request_irq(IRQ_EINT(9), touch_down,IRQ_TYPE_EDGE_BOTH,
613 "ads7864_touch", ts);
614
615 if (ret != 0) {
616 dev_err(dev,"ads7846_ts.c: Could not allocate ts IRQ_EINT !\n");
617 ret = -EIO;
618 goto fail;
619 }
620
621
622
623
624 ret = misc_register(&misc); //注册这混杂字符设备
625 if (ret) {
626 dev_err(dev, "ads7846_ts.c: Could not register device(mini6410 touchscreen)!\n");
627 ret = -EIO;
628 goto fail;
629 }
630 //初始化GPIO==
631 set_miso_as_up();
632 set_miso_as_input();
633 set_cs_mosi_clk_as_up();
634 set_cs_mosi_clk_as_output();
635 set_gpcx_value(ADS7846_GPIO_MOSI ,1);
636 set_gpcx_value(ADS7846_GPIO_CS ,1);
637 set_gpcx_value(ADS7846_GPIO_CLK ,1);
638 //--
639
640 #ifdef CONFIG_TOUCHSCREEN_ADS7846_DEBUG
641 printk("ads7846_ts_probe end!\n");
642 #endif
643
644 return 0;
645
646 fail:
647 disable_irq(IRQ_EINT(9));
648 free_irq(IRQ_EINT(9), ts);
649
650 return ret;
651
652 }
653
654 static int ads7846_ts_remove(struct platform_device *dev)
655 {
656 printk(KERN_INFO "ads7846_ts_remove() of TS called !\n");
657
658 disable_irq(IRQ_EINT(9));
659 free_irq(IRQ_EINT(9), ts);
660 return 0;
661 }
662
663 #ifdef CONFIG_PM
664 static unsigned int adccon, adctsc, adcdly;
665
666 static int ads7846_ts_suspend(struct platform_device *dev, pm_message_t state)
667 {
668
669 return 0;
670 }
671
672 static int ads7846_ts_resume(struct platform_device *pdev)
673 {
674 return 0;
675 }
676 #else
677 #define ads7846_ts_suspend NULL
678 #define ads7846_ts_resume NULL
679 #endif
680
681 static struct platform_driver ads7846_ts_driver = {
682 .probe = ads7846_ts_probe,
683 .remove = ads7846_ts_remove,
684 .suspend = ads7846_ts_suspend,
685 .resume = ads7846_ts_resume,
686 .driver = {
687 .owner = THIS_MODULE,
688 .name = "ads7846-ts",
689 },
690 };
691
692 static char banner[] __initdata = KERN_INFO "mini6410 ads7846 Touchscreen driver,by liu_xf 20110622,\n";
693
694 static int __init ads7846_ts_init(void)
695 {
696 printk(banner);
697 return platform_driver_register(&ads7846_ts_driver);
698 }
699
700 static void __exit ads7846_ts_exit(void)
701 {
702 platform_driver_unregister(&ads7846_ts_driver);
703 }
704
705 module_init(ads7846_ts_init);
706 module_exit(ads7846_ts_exit);
707
708 MODULE_AUTHOR("Hunan Create Inc.");
709 MODULE_LICENSE("GPL");

2、修改当前目录下的Kconfig和makefile，让它在menuconfig里可见，并能被编译。

在 Kconfig里添加：

01 config TOUCHSCREEN_MINI6410_ADS7846
02 tristate "ADS7846 touchscreen driver for Mini6410"
03 depends on MACH_MINI6410
04 default y
05 help
06 Say Y here to enable the driver for the ADS7846 touchscreen on the
07 FriendlyARM Mini6410 development board.
08
09 If unsure, say N.
10
11 To compile this driver as a module, choose M here: the
12 module will be called mini6410-ads7846.

makefile里添加

obj-$(CONFIG_TOUCHSCREEN_MINI6410_ADS7846) += mini6410-ads7846.o

3、 ads7846_device_ts设备定义

复制 /opt/FriendlyARM/mini6410/linux-2.6.38/arch/arm/mach-s3c64xx/dev-ts-mini6410.c为dev-ads7846-mini6410.c，更改代码为

01 /* linux/arch/arm/mach-s3c64xx/dev-ts-mini6410.c
02 *
03 * Copyright (c) 2008 Simtec Electronics
04 * Ben Dooks
05 * http://armlinux.simtec.co.uk/
06 *
07 * S3C series device definition for touchscreen devices
08 *
09 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
12 */
13
14 #include
15 #include
16
17 #include
18 #include
19 #include
20 #include
21 #include
22
23 /* Touch srcreen */
24 //resource没有用，先留在这，不管它
25 static struct resource ads7846_ts_resource[] = {
26 [0] = {
27 .start = SAMSUNG_PA_ADC,
28 .end = SAMSUNG_PA_ADC + SZ_256 - 1,
29 .flags = IORESOURCE_MEM,
30 },
31 [1] = {
32 .start = IRQ_PENDN,
33 .end = IRQ_PENDN,
34 .flags = IORESOURCE_IRQ,
35 },
36 [2] = {
37 .start = IRQ_ADC,
38 .end = IRQ_ADC,
39 .flags = IORESOURCE_IRQ,
40 }
41 };
42
43 struct platform_device ads7846_device_ts = {
44 .name = "ads7846-ts",
45 .id = -1,
46 .num_resources = ARRAY_SIZE(ads7846_ts_resource),
47 .resource = ads7846_ts_resource,
48 };
49 /*
50 void __init ads7846_ts_set_platdata(struct s3c_ts_mach_info *pd)
51 {
52 printk(KERN_ERR "%s: no platform data\n", __func__);
53
54 }
55 */

4、在/opt/FriendlyARM/mini6410/linux-2.6.38/arch/arm/mach-s3c64xx/mach-mini6410.c的platform_device添加ads7846_device_ts设备（s3c_device_ts附近），注册设备时要用到它

#ifdef CONFIG_TOUCHSCREEN_MINI6410_ADS7846
&ads7846_device_ts,
#endif

5、添加设备声明

mach-mini6410里注册ads7846_device_ts设备，但在哪里mach-mini6410并不知道，需要在devs.h里声明，打开当前目录下的devs.h，添加如下代码：

extern struct platform_device ads7846_device_ts;

6、然后再make，放到SD卡里运行

make menuconfig，在device drives－> input device support -> touch screens选择ADS7846 touchscreen driver for Mini6410 ,然后再make zImage。

完成后，再放到SD卡里运行，怎么样，一点也不抖动了吧！

结语：

这个驱动是由mini6410-ts.c修改而来的，那些系统调用的函数都没有改，只是将获取触摸屏数据的方式变了，可以直接用原来的tslib。经测试，效果良好。但是在移植的过程中，有一个问题还是没搞明白，之前，我是将TS_PEN接在EINT6上在的，但一接上去，就一直中断，把系统都弄死了，要按下触摸屏才能停止中断，不知道是什么原因，可能是EINT6被其它地方设置了，还是怎么回事，后来换成EINT9就好了，正好两个端子相邻。知道的大侠还请告诉我一声