6410触摸屏驱动分析（s3c-ts.c）（Linux）（分析）
转自：http://www.cnblogs.com/liu_xf/archive/2011/06/22/2086750.html
摘要：
分析内核s3c-ts.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 <[email protected]>
- 023 ** iPAQ H1940 touchscreen support
- 024 **
- 025 ** ChangeLog
- 026 **
- 027 ** 2004-09-05: Herbert Potzl <[email protected]>
- 028 ** - added clock (de-)allocation code
- 029 **
- 030 ** 2005-03-06: Arnaud Patard <[email protected]>
- 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 <[email protected]>
- 040 ** - Make use of some undocumented features of the touchscreen
- 041 ** controller
- 042 **
- 043 ** 2006-09-05: Ryu Euiyoul <[email protected]>
- 044 ** - added power management suspend and resume code
- 045 *
- 046 */
- 047
- 048 #include <linux/errno.h>
- 049 #include <linux/kernel.h>
- 050 #include <linux/module.h>
- 051 #include <linux/slab.h>
- 052 #include <linux/input.h>
- 053 #include <linux/init.h>
- 054 #include <linux/serio.h>
- 055 #include <linux/delay.h>
- 056 #include <linux/platform_device.h>
- 057 #include <linux/clk.h>
- 058 #include <linux/fs.h>
- 059 #include <linux/poll.h>
- 060 #include <linux/irq.h>
- 061 #include <linux/interrupt.h>
- 062 #include <linux/cdev.h>
- 063 #include <linux/miscdevice.h>
- 064
- 065 #include <asm/uaccess.h>
- 066 #include <asm/io.h>
- 067 #include <asm/irq.h>
- 068 #include <mach/hardware.h>
- 069
- 070 #include <plat/regs-adc.h>
- 071 #include <mach/irqs.h>
- 072 #include <mach/map.h>
- 073 #include <mach/regs-clock.h>
- 074 #include <mach/regs-gpio.h>
- 075 #include <mach/gpio-bank-a.h>
- 076 #include <mach/ts.h>
- 077
- 078 #define CONFIG_TOUCHSCREEN_S3C_DEBUG
- 079 #undef CONFIG_TOUCHSCREEN_S3C_DEBUG
- 080 #define DEBUG_LVL KERN_DEBUG
- 081
- 082
- 083 #ifdef CONFIG_MINI6410_ADC
- 084 DEFINE_SEMAPHORE(ADC_LOCK); //定义并初始化了一个信号量
- 085 //37内核就没有DECLARE_MUTEX了吧，功能应该是一样的
- 086
- 087
- 088 /* Indicate who is using the ADC controller */
- 089 //ADC的状态，防止触摸屏转换时，ADC正在被使用
- 090 #define LOCK_FREE 0
- 091 #define LOCK_TS 1
- 092 #define LOCK_ADC 2
- 093 static int adc_lock_id = LOCK_FREE;
- 094
- 095 #define ADC_free() (adc_lock_id == LOCK_FREE)
- 096 #define ADC_locked4TS() (adc_lock_id == LOCK_TS)
- 097
- 098 //==
- 099 static inline int s3c_ts_adc_lock(int id) {
- 100 int ret;
- 101
- 102 ret = down_trylock(&ADC_LOCK); //获取自旋锁
- 103 if (!ret) {
- 104 adc_lock_id = id;
- 105 }
- 106
- 107 return ret; //返回状态 1:失败 0：成功
- 108 }
- 109 //--
- 110
- 111 static inline void s3c_ts_adc_unlock(void) {
- 112 adc_lock_id = 0;
- 113 up(&ADC_LOCK); //释放自旋锁
- 114 }
- 115 #endif
- 116
- 117
- 118 /* Touchscreen default configuration */
- 119 struct s3c_ts_mach_info s3c_ts_default_cfg __initdata = {
- 120 .delay = 10000, //转换延时
- 121 .presc = 49, //转换时钟分频
- 122 .oversampling_shift = 2, //转换次数 4次
- 123 .resol_bit = 12, //转换精度
- 124 .s3c_adc_con = ADC_TYPE_2 //6410是type2
- 125 };
- 126 /*
- 127 struct s3c_ts_mach_info s3c_ts_default_cfg __initdata = {
- 128 .delay = 10000,
- 129 .presc = 49,
- 130 .oversampling_shift = 2,
- 131 .resol_bit = 10
- 132 };
- 133 */
- 134 /*
- 135 * Definitions & global arrays.
- 136 */
- 137 #define DEVICE_NAME "touchscreen"
- 138 static DECLARE_WAIT_QUEUE_HEAD(ts_waitq); //定义并初始化一个等待队列
- 139
- 140 typedef unsigned TS_EVENT;
- 141 #define NR_EVENTS 64 //触摸屏fifo大小
- 142
- 143 static TS_EVENT events[NR_EVENTS];
- 144 static int evt_head, evt_tail; //fifo的头的尾
- 145 //驱动写fifo时evt_head++，应用读fifo时 evt_tail++
- 146
- 147 #define ts_evt_pending() ((volatile u8)(evt_head != evt_tail)) //相等就表示满了
- 148 #define ts_evt_get() (events + evt_tail)
- 149 #define ts_evt_pull() (evt_tail = (evt_tail + 1) & (NR_EVENTS - 1))
- 150 #define ts_evt_clear() (evt_head = evt_tail = 0)
- 151
- 152 //将AD转换的值放入FIFO
- 153 //这里是一个先进先出的fifo
- 154 //只要有数据被添加进来，就会唤醒ts_waitq进程
- 155 static void ts_evt_add(unsigned x, unsigned y, unsigned down) {
- 156 unsigned ts_event;
- 157 int next_head;
- 158
- 159 ts_event = ((x << 16) | (y)) | (down << 31);
- 160 next_head = (evt_head + 1) & (NR_EVENTS - 1);
- 161 //没满就装入
- 162 if (next_head != evt_tail) {
- 163 events[evt_head] = ts_event;
- 164 evt_head = next_head;
- 165 //printk("====>Add ... [ %4d, %4d ]%s\n", x, y, down ? "":" ~~~");
- 166
- 167 /* wake up any read call */
- 168 if (waitqueue_active(&ts_waitq)) { //判斷等待隊列是否有進程睡眠
- 169 wake_up_interruptible(&ts_waitq); //唤醒ts_waitq等待队列中所有interruptible类型的进程
- 170 }
- 171 } else {
- 172 /* drop the event and try to wakeup readers */
- 173 printk(KERN_WARNING "mini6410-ts: touch event buffer full");
- 174 wake_up_interruptible(&ts_waitq);
- 175 }
- 176 }
- 177
- 178 static unsigned int s3c_ts_poll( struct file *file, struct poll_table_struct *wait)
- 179 {
- 180 unsigned int mask = 0;
- 181
- 182 //将ts_waitq等待队列添加到poll_table里去
- 183 poll_wait(file, &ts_waitq, wait);
- 184 //返回掩码
- 185 if (ts_evt_pending())
- 186 mask |= POLLIN | POLLRDNORM; //返回设备可读
- 187
- 188 return mask;
- 189 }
- 190
- 191 //读 系统调用==
- 192 static int s3c_ts_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)
- 193 {
- 194 DECLARE_WAITQUEUE(wait, current); //把当前进程加到定义的等待队列头wait中
- 195 char *ptr = buff;
- 196 int err = 0;
- 197
- 198 add_wait_queue(&ts_waitq, &wait); //把wait入到等待队列头中。该队列会在进程等待的条件满足时唤醒它。
- 199 //我们必须在其他地方写相关代码，在事件发生时，对等的队列执行wake_up()操作。
- 200 //这里是在ts_evt_add里wake_up
- 201 while (count >= sizeof(TS_EVENT)) {
- 202 err = -ERESTARTSYS;
- 203 if (signal_pending(current)) //如果是信号唤醒 参考http://www.360doc.com/content/10/1009/17/1317564_59632874.shtml
- 204 break;
- 205
- 206 if (ts_evt_pending()) {
- 207 TS_EVENT *evt = ts_evt_get();
- 208
- 209 err = copy_to_user(ptr, evt, sizeof(TS_EVENT));
- 210 ts_evt_pull();
- 211
- 212 if (err)
- 213 break;
- 214
- 215 ptr += sizeof(TS_EVENT);
- 216 count -= sizeof(TS_EVENT);
- 217 continue;
- 218 }
- 219
- 220 set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为可中断的睡眠
- 221 err = -EAGAIN;
- 222 if (filp->f_flags & O_NONBLOCK) //如果上层调用是非阻塞方式，则不阻塞该进程，直接返回EAGAIN
- 223 break;
- 224 schedule(); //本进程在此处交出CPU控制权，等待被唤醒
- 225 //进程调度的意思侧重于把当前任务从CPU拿掉，再从就绪队列中按照调度算法取一就绪进程占用CPU
- 226 }
- 227 current->state = TASK_RUNNING;
- 228 remove_wait_queue(&ts_waitq, &wait);
- 229
- 230 return ptr == buff ? err : ptr - buff;
- 231 }
- 232 //--
- 233
- 234 static int s3c_ts_open(struct inode *inode, struct file *filp) {
- 235 /* flush event queue */
- 236 ts_evt_clear();
- 237
- 238 return 0;
- 239 }
- 240
- 241 //当应用程序操作设备文件时调用的open read等函数，最终会调用这个结构体中对应的函数
- 242 static struct file_operations dev_fops = {
- 243 .owner = THIS_MODULE,
- 244 .read = s3c_ts_read,
- 245 .poll = s3c_ts_poll, //select系统调用
- 246 .open = s3c_ts_open,
- 247 };
- 248
- 249 //设备号，设备名，注册的时候用到这个数组
- 250 //混杂设备主设备号为10
- 251 static struct miscdevice misc = {
- 252 .minor = MISC_DYNAMIC_MINOR, //自动分配次设置号
- 253 //.minor = 180,
- 254 .name = DEVICE_NAME,
- 255 .fops = &dev_fops,
- 256 };
- 257
- 258 //x为0时为等待按下中断，x为1是为等待抬起中断
- 259 #define WAIT4INT(x) (((x) << 8) | \
- 260 S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
- 261 S3C_ADCTSC_XY_PST(3))
- 262
- 263 //自动连续测量X坐标和Y坐标
- 264 #define AUTOPST (S3C_ADCTSC_YM_SEN | S3C_ADCTSC_YP_SEN | S3C_ADCTSC_XP_SEN | \
- 265 S3C_ADCTSC_AUTO_PST | S3C_ADCTSC_XY_PST(0))
- 266
- 267 static void __iomem *ts_base;
- 268 static struct resource *ts_mem;
- 269 static struct resource *ts_irq;
- 270 static struct clk *ts_clock;
- 271 static struct s3c_ts_info *ts;
- 272
- 273 /**
- 274 * get_down - return the down state of the pen
- 275 * @data0: The data read from ADCDAT0 register.
- 276 * @data1: The data read from ADCDAT1 register.
- 277 *
- 278 * Return non-zero if both readings show that the pen is down.
- 279 */
- 280 static inline bool get_down(unsigned long data0, unsigned long data1)
- 281 {
- 282 /* returns true if both data values show stylus down */
- 283 return (!(data0 & S3C_ADCDAT0_UPDOWN) && !(data1 & S3C_ADCDAT1_UPDOWN)); //判断data0,data1最高位是否仍为"0"，为“0”表示触摸笔状态保持为down
- 284 }
- 285
- 286
- 287 /*===========================================================================================
- 288 touch_timer_fire这个函数主要实现以下功能：
- 289
- 290 1、 触摸笔开始点击的时候， 在中断函数stylus_updown里面被调用，
- 291 此时缓存区没有数据，ts.count为0, 并且开启AD转换,而后进入 AD 中断
- 292
- 293 2、 ADC中断函数stylus_action把缓冲区填满的时候，作为中断后半段函数稍后被调用（由内核定时器触发中断），
- 294 此时ts.count为4，算出其平均值后，交给事件处理层(Event Handler)处理，
- 295 主要是填写缓冲，然后唤醒等待输入数据的进程。
- 296
- 297 3、 stylus抬起，等到缓冲区填满后(可能会包含一些无用的数据)被调用，
- 298 这时候判断出stylus up，报告stylus up事件，重新等待stylus down。
- 299 ============================================================================================*/
- 300
- 301 static void touch_timer_fire(unsigned long data) {
- 302 unsigned long data0;
- 303 unsigned long data1;
- 304 int pendown;
- 305
- 306 #ifdef CONFIG_MINI6410_ADC
- 307 if (!ADC_locked4TS()) {
- 308 /* Note: pen UP interrupt detected and handled, the lock is released,
- 309 * so do nothing in the timer which started by ADC ISR. */
- 310 return;
- 311 }
- 312 #endif
- 313
- 314 data0 = readl(ts_base + S3C_ADCDAT0);
- 315 data1 = readl(ts_base + S3C_ADCDAT1);//读取AD转换数据的值
- 316
- 317 pendown = get_down(data0, data1);
- 318
- 319 if (pendown) {
- 320 if (ts->count == (1 << ts->shift)) { //定时器触发touch_timer_fire中断时执行这个括号里
- 321 #ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
- 322 {
- 323 struct timeval tv;
- 324 do_gettimeofday(&tv);
- 325 printk(KERN_INFO "T: %06d, X: %03ld, Y: %03ld\n",
- 326 (int)tv.tv_usec, ts->xp, ts->yp);
- 327 }
- 328 #endif
- 329
- 330 ts_evt_add((ts->xp >> ts->shift), (ts->yp >> ts->shift), 1);//求平均，并写入fifo
- 331
- 332 ts->xp = 0;
- 333 ts->yp = 0;
- 334 ts->count = 0;
- 335 }
- 336
- 337 /* start automatic sequencing A/D conversion */
- 338 //每次按下有四次AD转换，以下为在按下中断中触发的第一次AD转换，其余三次在AD转换中断处理函数中触发
- 339 //AUTOPST表示自动连续测量 以得到X位置，Y位置
- 340 writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base + S3C_ADCTSC);
- 341 // 启动D转换，转换后会产生中断IRQ_ADC
- 342 writel(readl(ts_base + S3C_ADCCON) | S3C_ADCCON_ENABLE_START,
- 343 ts_base + S3C_ADCCON);
- 344
- 345 } else { //如果是松开，报告其触摸笔状态
- 346 ts->xp = 0;
- 347 ts->yp = 0;
- 348 ts->count = 0;
- 349
- 350 ts_evt_add(0, 0, 0);
- 351
- 352 /* PEN is UP, Let's wait the PEN DOWN interrupt */
- 353 writel(WAIT4INT(0), ts_base + S3C_ADCTSC); // 设置INT 位，等待 DOWN 中断
- 354
- 355 #ifdef CONFIG_MINI6410_ADC
- 356 if (ADC_locked4TS()) {
- 357 s3c_ts_adc_unlock();
- 358 }
- 359 #endif
- 360 }
- 361 }
- 362
- 363 static DEFINE_TIMER(touch_timer, touch_timer_fire, 0, 0);
- 364
- 365 //触摸屏按下松开中断服务==
- 366 static irqreturn_t stylus_updown(int irqno, void *param)
- 367 {
- 368 #ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
- 369 unsigned long data0;
- 370 unsigned long data1;
- 371 int is_waiting_up;
- 372 int pendown;
- 373 #endif
- 374
- 375 #ifdef CONFIG_MINI6410_ADC
- 376 if (!ADC_locked4TS()) {
- 377 if (s3c_ts_adc_lock(LOCK_TS)) {
- 378 /* Locking ADC controller failed */
- 379 printk("Lock ADC failed, %d\n", adc_lock_id);
- 380 return IRQ_HANDLED;
- 381 }
- 382 }
- 383 #endif
- 384
- 385 #ifdef CONFIG_TOUCHSCREEN_S3C_DEBUG
- 386 data0 = readl(ts_base + S3C_ADCDAT0);
- 387 data1 = readl(ts_base + S3C_ADCDAT1);
- 388
- 389 is_waiting_up = readl(ts_base + S3C_ADCTSC) & (1 << 8);
- 390 pendown = get_down(data0, data1);
- 391
- 392 printk("P: %d <--> %c\n", pendown, is_waiting_up ? 'u':'d');
- 393 #endif
- 394 //执行如下语句否则不断产生中断从而把系统卡死
- 395 if (ts->s3c_adc_con == ADC_TYPE_2) {
- 396 /* Clear ADC and PEN Down/UP interrupt */
- 397 __raw_writel(0x0, ts_base + S3C_ADCCLRWK);
- 398 __raw_writel(0x0, ts_base + S3C_ADCCLRINT);
- 399 }
- 400
- 401 /* TODO we should never get an interrupt with pendown set while
- 402 * the timer is running, but maybe we ought to verify that the
- 403 * timer isn't running anyways. */
- 404
- 405 touch_timer_fire(1);
- 406
- 407 return IRQ_HANDLED;
- 408 }
- 409
- 410 //ad转换结束中断服务程序==
- 411 static irqreturn_t stylus_action(int irqno, void *param)
- 412 {
- 413 unsigned long data0;
- 414 unsigned long data1;
- 415
- 416 #ifdef CONFIG_MINI6410_ADC
- 417 if (!ADC_locked4TS()) {
- 418 if (ADC_free()) {
- 419 printk("Unexpected\n");
- 420
- 421 /* Clear ADC interrupt */
- 422 __raw_writel(0x0, ts_base + S3C_ADCCLRINT);
- 423 }
- 424
- 425 return IRQ_HANDLED;
- 426 }
- 427 #endif
- 428
- 429 data0 = readl(ts_base + S3C_ADCDAT0);
- 430 data1 = readl(ts_base + S3C_ADCDAT1);
- 431
- 432 if (ts->resol_bit == 12) {
- 433 #if defined(CONFIG_TOUCHSCREEN_NEW)
- 434 ts->yp += S3C_ADCDAT0_XPDATA_MASK_12BIT - (data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT);
- 435 ts->xp += S3C_ADCDAT1_YPDATA_MASK_12BIT - (data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT);
- 436 #else
- 437 ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK_12BIT;
- 438 ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK_12BIT;
- 439 #endif
- 440 } else {
- 441 #if defined(CONFIG_TOUCHSCREEN_NEW)
- 442 ts->yp += S3C_ADCDAT0_XPDATA_MASK - (data0 & S3C_ADCDAT0_XPDATA_MASK);
- 443 ts->xp += S3C_ADCDAT1_YPDATA_MASK - (data1 & S3C_ADCDAT1_YPDATA_MASK);
- 444 #else
- 445 ts->xp += data0 & S3C_ADCDAT0_XPDATA_MASK;
- 446 ts->yp += data1 & S3C_ADCDAT1_YPDATA_MASK;
- 447 #endif
- 448 } // 转换结果累加
- 449
- 450 ts->count++;
- 451
- 452 if (ts->count < (1 << ts->shift)) { // 采样未完成，继续下一次采样 ，通过 ENABLE_START 启动 AD 转换，一次一个数据
- 453 writel(S3C_ADCTSC_PULL_UP_DISABLE | AUTOPST, ts_base + S3C_ADCTSC);
- 454 writel(readl(ts_base + S3C_ADCCON) | S3C_ADCCON_ENABLE_START, ts_base + S3C_ADCCON);
- 455 } else { // 采样完毕，激活下半部处理程序touch_timer_fire，处理接收数据
- 456 mod_timer(&touch_timer, jiffies + 1); //设置定时器超时的时间，目的是为了延时触发 touch_timer_fire 中断，如果在这段时间有抬起中断发生，则表示是抖动
- 457 //jiffies变量记录了系统启动以来，系统定时器已经触发的次数。内核每秒钟将jiffies变量增加HZ次。
- 458 //因此，对于HZ值为100的系统，1个jiffy等于10ms，而对于HZ为1000的系统，1个jiffy仅为1ms
- 459
- 460 writel(WAIT4INT(1), ts_base + S3C_ADCTSC); //设置为等待抬起中断
- 461 }
- 462
- 463 if (ts->s3c_adc_con == ADC_TYPE_2) {
- 464 /* Clear ADC and PEN Down/UP interrupt */
- 465 __raw_writel(0x0, ts_base + S3C_ADCCLRWK);
- 466 __raw_writel(0x0, ts_base + S3C_ADCCLRINT);
- 467 }
- 468
- 469 return IRQ_HANDLED;
- 470 }
- 471
- 472
- 473 #ifdef CONFIG_MINI6410_ADC
- 474 static unsigned int _adccon, _adctsc, _adcdly;
- 475
- 476 //其它模块要用ADC时，需要调用这个函数，来确定ADC是否可用，如果可用，则将它锁住，不让别的驱动用
- 477 int mini6410_adc_acquire_io(void) {
- 478 int ret;
- 479
- 480 ret = s3c_ts_adc_lock(LOCK_ADC); //锁住ADC，不让其它模块使用
- 481 if (!ret) { //如果ADC没有被使用，则保存ADC寄存器的值
- 482 _adccon = readl(ts_base + S3C_ADCCON);
- 483 _adctsc = readl(ts_base + S3C_ADCTSC);
- 484 _adcdly = readl(ts_base + S3C_ADCDLY);
- 485 }
- 486
- 487 return ret;// 0:操作成功 1：操作失败
- 488 }
- 489 EXPORT_SYMBOL(mini6410_adc_acquire_io); //声明为外部可用
- 490
- 491 //其它模块不要用ADC了，需要调用这个函数，来解锁ADC让别的驱动用
- 492 void mini6410_adc_release_io(void) {
- 493 //还原ADC寄存器的设置
- 494 writel(_adccon, ts_base + S3C_ADCCON);
- 495 writel(_adctsc, ts_base + S3C_ADCTSC);
- 496 writel(_adcdly, ts_base + S3C_ADCDLY);
- 497 writel(WAIT4INT(0), ts_base + S3C_ADCTSC);
- 498
- 499 s3c_ts_adc_unlock(); //释放ADC，其它模块可以使用
- 500 }
- 501
- 502 EXPORT_SYMBOL(mini6410_adc_release_io);
- 503 #endif
- 504
- 505 //获得触摸屏的配置信息==
- 506 static struct s3c_ts_mach_info *s3c_ts_get_platdata(struct device *dev)
- 507 {
- 508 if (dev->platform_data != NULL)
- 509 return (struct s3c_ts_mach_info *)dev->platform_data; //优先使用 arch/arm/mach-s3c64xx中的定义
- 510
- 511 return &s3c_ts_default_cfg; //如果前面没定义，则使用本函数的default定义
- 512 }
- 513 //--
- 514
- 515 /*
- 516 * The functions for inserting/removing us as a module.
- 517 */
- 518 static int __init s3c_ts_probe(struct platform_device *pdev)
- 519 {
- 520 struct resource *res;
- 521 struct device *dev;
- 522 struct s3c_ts_mach_info * s3c_ts_cfg;
- 523 int ret, size;
- 524
- 525 dev = &pdev->dev;
- 526
- 527 res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
- 528 if (res == NULL) {
- 529 dev_err(dev,"no memory resource specified\n");
- 530 return -ENOENT;
- 531 }
- 532
- 533 size = (res->end - res->start) + 1;
- 534 ts_mem = request_mem_region(res->start, size, pdev->name);
- 535 if (ts_mem == NULL) {
- 536 dev_err(dev, "failed to get memory region\n");
- 537 ret = -ENOENT;
- 538 goto err_req;
- 539 }
- 540
- 541 ts_base = ioremap(res->start, size);
- 542 if (ts_base == NULL) {
- 543 dev_err(dev, "failed to ioremap() region\n");
- 544 ret = -EINVAL;
- 545 goto err_map;
- 546 }
- 547
- 548 ts_clock = clk_get(&pdev->dev, "adc");
- 549 if (IS_ERR(ts_clock)) {
- 550 dev_err(dev, "failed to find watchdog clock source\n");
- 551 ret = PTR_ERR(ts_clock);
- 552 goto err_clk;
- 553 }
- 554
- 555 clk_enable(ts_clock);
- 556
- 557 s3c_ts_cfg = s3c_ts_get_platdata(&pdev->dev); //获取配置参数
- 558
- 559 //设置ADC分频
- 560 if ((s3c_ts_cfg->presc & 0xff) > 0)
- 561 writel(S3C_ADCCON_PRSCEN | S3C_ADCCON_PRSCVL(s3c_ts_cfg->presc & 0xff),
- 562 ts_base + S3C_ADCCON);
- 563 else
- 564 writel(0, ts_base + S3C_ADCCON);
- 565
- 566 /* Initialise registers */
- 567 //设置转换延时
- 568 if ((s3c_ts_cfg->delay & 0xffff) > 0)
- 569 writel(s3c_ts_cfg->delay & 0xffff, ts_base + S3C_ADCDLY);
- 570
- 571 if (s3c_ts_cfg->resol_bit == 12) {
- 572 switch(s3c_ts_cfg->s3c_adc_con) {
- 573 case ADC_TYPE_2:
- 574 writel(readl(ts_base + S3C_ADCCON) | S3C_ADCCON_RESSEL_12BIT,
- 575 ts_base + S3C_ADCCON);
- 576 break;
- 577
- 578 case ADC_TYPE_1:
- 579 writel(readl(ts_base + S3C_ADCCON) | S3C_ADCCON_RESSEL_12BIT_1,
- 580 ts_base + S3C_ADCCON);
- 581 break;
- 582
- 583 default:
- 584 dev_err(dev, "Touchscreen over this type of AP isn't supported !\n");
- 585 break;
- 586 }
- 587 }
- 588
- 589 writel(WAIT4INT(0), ts_base + S3C_ADCTSC);
- 590
- 591 ts = kzalloc(sizeof(struct s3c_ts_info), GFP_KERNEL);
- 592
- 593 ts->shift = s3c_ts_cfg->oversampling_shift;
- 594 ts->resol_bit = s3c_ts_cfg->resol_bit;
- 595 ts->s3c_adc_con = s3c_ts_cfg->s3c_adc_con;
- 596
- 597 /* For IRQ_PENDUP */
- 598 ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
- 599 if (ts_irq == NULL) {
- 600 dev_err(dev, "no irq resource specified\n");
- 601 ret = -ENOENT;
- 602 goto err_irq;
- 603 }
- 604
- 605 ret = request_irq(ts_irq->start, stylus_updown, IRQF_SAMPLE_RANDOM, "s3c_updown", ts);
- 606 if (ret != 0) {
- 607 dev_err(dev,"s3c_ts.c: Could not allocate ts IRQ_PENDN !\n");
- 608 ret = -EIO;
- 609 goto err_irq;
- 610 }
- 611
- 612 /* For IRQ_ADC */
- 613 ts_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
- 614 if (ts_irq == NULL) {
- 615 dev_err(dev, "no irq resource specified\n");
- 616 ret = -ENOENT;
- 617 goto err_irq;
- 618 }
- 619
- 620 ret = request_irq(ts_irq->start, stylus_action, IRQF_SAMPLE_RANDOM | IRQF_SHARED,
- 621 "s3c_action", ts);
- 622 if (ret != 0) {
- 623 dev_err(dev, "s3c_ts.c: Could not allocate ts IRQ_ADC !\n");
- 624 ret = -EIO;
- 625 goto err_irq;
- 626 }
- 627
- 628 printk(KERN_INFO "%s got loaded successfully : %d bits\n", DEVICE_NAME, s3c_ts_cfg->resol_bit);
- 629
- 630 ret = misc_register(&misc); //注册这混杂字符设备
- 631 if (ret) {
- 632 dev_err(dev, "s3c_ts.c: Could not register device(mini6410 touchscreen)!\n");
- 633 ret = -EIO;
- 634 goto fail;
- 635 }
- 636
- 637 return 0;
- 638
- 639 fail:
- 640 free_irq(ts_irq->start, ts->dev);
- 641 free_irq(ts_irq->end, ts->dev);
- 642
- 643 err_irq:
- 644 kfree(ts);
- 645
- 646 clk_disable(ts_clock);
- 647 clk_put(ts_clock);
- 648
- 649 err_clk:
- 650 iounmap(ts_base);
- 651
- 652 err_map:
- 653 release_resource(ts_mem);
- 654 kfree(ts_mem);
- 655
- 656 err_req:
- 657 return ret;
- 658 }
- 659
- 660 static int s3c_ts_remove(struct platform_device *dev)
- 661 {
- 662 printk(KERN_INFO "s3c_ts_remove() of TS called !\n");
- 663
- 664 disable_irq(IRQ_ADC);
- 665 disable_irq(IRQ_PENDN);
- 666
- 667 free_irq(IRQ_PENDN, ts->dev);
- 668 free_irq(IRQ_ADC, ts->dev);
- 669
- 670 if (ts_clock) {
- 671 clk_disable(ts_clock);
- 672 clk_put(ts_clock);
- 673 ts_clock = NULL;
- 674 }
- 675
- 676 misc_deregister(&misc);
- 677 iounmap(ts_base);
- 678
- 679 return 0;
- 680 }
- 681
- 682 #ifdef CONFIG_PM
- 683 static unsigned int adccon, adctsc, adcdly;
- 684
- 685 static int s3c_ts_suspend(struct platform_device *dev, pm_message_t state)
- 686 {
- 687 adccon = readl(ts_base + S3C_ADCCON);
- 688 adctsc = readl(ts_base + S3C_ADCTSC);
- 689 adcdly = readl(ts_base + S3C_ADCDLY);
- 690
- 691 disable_irq(IRQ_ADC);
- 692 disable_irq(IRQ_PENDN);
- 693
- 694 clk_disable(ts_clock);
- 695
- 696 return 0;
- 697 }
- 698
- 699 static int s3c_ts_resume(struct platform_device *pdev)
- 700 {
- 701 clk_enable(ts_clock);
- 702
- 703 writel(adccon, ts_base + S3C_ADCCON);
- 704 writel(adctsc, ts_base + S3C_ADCTSC);
- 705 writel(adcdly, ts_base + S3C_ADCDLY);
- 706 writel(WAIT4INT(0), ts_base + S3C_ADCTSC);
- 707
- 708 enable_irq(IRQ_ADC);
- 709 enable_irq(IRQ_PENDN);
- 710 return 0;
- 711 }
- 712 #else
- 713 #define s3c_ts_suspend NULL
- 714 #define s3c_ts_resume NULL
- 715 #endif
- 716
- 717 static struct platform_driver s3c_ts_driver = {
- 718 .probe = s3c_ts_probe,
- 719 .remove = s3c_ts_remove,
- 720 .suspend = s3c_ts_suspend,
- 721 .resume = s3c_ts_resume,
- 722 .driver = {
- 723 .owner = THIS_MODULE,
- 724 .name = "s3c-ts",
- 725 },
- 726 };
- 727
- 728 static char banner[] __initdata = KERN_INFO "S3C Touchscreen driver, (c) 2010 FriendlyARM,\n";
- 729
- 730 static int __init s3c_ts_init(void)
- 731 {
- 732 printk(banner);
- 733 return platform_driver_register(&s3c_ts_driver);
- 734 }
- 735
- 736 static void __exit s3c_ts_exit(void)
- 737 {
- 738 platform_driver_unregister(&s3c_ts_driver);
- 739 }
- 740
- 741 module_init(s3c_ts_init);
- 742 module_exit(s3c_ts_exit);
- 743
- 744 MODULE_AUTHOR("FriendlyARM Inc.");
- 745 MODULE_LICENSE("GPL");
- 746
- 747
- 748 /*
- 749 * 驱动分析
- 750 * 1、内核是如何加载驱动的？
- 751 * 首先要提到两个结构体：设备用Platform_device表示，驱动用Platform_driver进行注册
- 752 * Platform机制开发发底层驱动的大致流程为: 定义 platform_device 注册 platform_device 定义 platform_driver 注册 platform_driver
- 753 * 首先要确认的就是设备的资源信息platform_device，例如设备的地址，中断号等 该结构体定义在kernel\include\linux\platform_device.h
- 754 * 该结构一个重要的元素是resource，该元素存入了最为重要的设备资源信息，定义在kernel\include\linux\ioport.h中
- 755 * 下面我们以本例来进行说明：
- 756 * arch/arm/mach-s3c64xx中dev-ts-mini6410.c中定义了platform_device s3c_device_ts
- 757 * 定义好了platform_device结构体后就可以调用函数platform_add_devices向系统中添加该设备了，之后可以调用platform_driver_register()进行设备注册。
- 758 * 要注意的是，这里的platform_device设备的注册过程必须在相应设备驱动加载之前被调用，即执行platform_driver_register之前,原因是因为驱动注册时需要
- 759 * 匹配内核中所以已注册的设备名。
- 760 * platform_devicerr的注册是在arch/arm/mach-s3c64xx中mach-mini6410.c中的mini6410_machine_init函数实现的。
- 761 * mini6410_machine_init是在启动后调用，它是在module_init之前；更具体的见MACHINE_START
- 762 * MACHINE_START(MINI6410, "MINI6410")
- 763 *
- 764 * .boot_params = S3C64XX_PA_SDRAM + 0x100, //.boot_params是bootloader向内核传递的参数的位置，这要和bootloader中参数的定义要一致。
- 765 *
- 766 * .init_irq = s3c6410_init_irq, //.init_irq在start_kernel() --> init_IRQ() --> init_arch_irq()中被调用
- 767 * .map_io = mini6410_map_io, //.map_io 在 setup_arch() --> paging_init() --> devicemaps_init()中被调用
- 768 * .init_machine = mini6410_machine_init, //init_machine 在 arch/arm/kernel/setup.c 中被 customize_machine 调用，
- 769 * //放在 arch_initcall() 段里面，会自动按顺序被调用。
- 770 * .timer = &s3c24xx_timer, //.timer是定义系统时钟，定义TIMER4为系统时钟，在arch/arm/plat-s3c/time.c中体现。
- 771 * //在start_kernel() --> time_init()中被调用。
- 772 * MACHINE_END
- 773 * 再来看看platform_driver，这个定义在本文中，
- 774 * 在驱动初始化函数中调用函数platform_driver_register()注册platform_driver，需要注意的是s3c_device_ts结构中name元素和s3c_ts_driver结构中driver.name
- 775 * 必须是相同的，这样在platform_driver_register()注册时会对所有已注册的所有platform_device中的name和当前注册的platform_driver的driver.name进行比较，
- 776 * 只有找到相同的名称的platfomr_device才能注册成功，当注册成功时会调用platform_driver结构元素probe函数指针，这里就是s3c_ts_probe
- 777 * 参考资料：http://blogold.chinaunix.net/u2/60011/showart.php?id=1018502
- 778 *
- 779 * 2、timer在这里的作用
- 780 * timer是用来防抖的，我们知道，触摸屏处理分为两个时间段，一个是由按下中断触发的四次AD转换的时间A，一个是4次AD转换完成后将AD数据存入FIFO的时间B，在时间A，没有打开抬起中断，
- 781 * 也就是说如果在这段时间有抬起事件，也不会触发中断，不会影响AD的转换。在时间B，打开抬起中断，打开定时器延时触发touch_timer_fire，如果在延时这段时间，有抬起事件发生
- 782 * 则touch_timer_fire不会将前面的数据存入到FIFO中，否则写入FIFO，表示值有效。
- 783 *
- 784 *
- 785 */