1acb45439SRussell King /* 2acb45439SRussell King * linux/drivers/mfd/ucb1x00-ts.c 3acb45439SRussell King * 4acb45439SRussell King * Copyright (C) 2001 Russell King, All Rights Reserved. 5acb45439SRussell King * 6acb45439SRussell King * This program is free software; you can redistribute it and/or modify 7acb45439SRussell King * it under the terms of the GNU General Public License version 2 as 8acb45439SRussell King * published by the Free Software Foundation. 9acb45439SRussell King * 10acb45439SRussell King * 21-Jan-2002 <jco@ict.es> : 11acb45439SRussell King * 12acb45439SRussell King * Added support for synchronous A/D mode. This mode is useful to 13acb45439SRussell King * avoid noise induced in the touchpanel by the LCD, provided that 14acb45439SRussell King * the UCB1x00 has a valid LCD sync signal routed to its ADCSYNC pin. 15acb45439SRussell King * It is important to note that the signal connected to the ADCSYNC 16acb45439SRussell King * pin should provide pulses even when the LCD is blanked, otherwise 17acb45439SRussell King * a pen touch needed to unblank the LCD will never be read. 18acb45439SRussell King */ 19acb45439SRussell King #include <linux/config.h> 20acb45439SRussell King #include <linux/module.h> 21acb45439SRussell King #include <linux/moduleparam.h> 22acb45439SRussell King #include <linux/init.h> 23acb45439SRussell King #include <linux/smp.h> 24acb45439SRussell King #include <linux/smp_lock.h> 25acb45439SRussell King #include <linux/sched.h> 26acb45439SRussell King #include <linux/completion.h> 27acb45439SRussell King #include <linux/delay.h> 28acb45439SRussell King #include <linux/string.h> 29acb45439SRussell King #include <linux/input.h> 30acb45439SRussell King #include <linux/device.h> 31acb45439SRussell King #include <linux/suspend.h> 32acb45439SRussell King #include <linux/slab.h> 33acb45439SRussell King 34acb45439SRussell King #include <asm/dma.h> 35acb45439SRussell King #include <asm/semaphore.h> 36acb45439SRussell King 37acb45439SRussell King #include "ucb1x00.h" 38acb45439SRussell King 39acb45439SRussell King 40acb45439SRussell King struct ucb1x00_ts { 41acb45439SRussell King struct input_dev idev; 42acb45439SRussell King struct ucb1x00 *ucb; 43acb45439SRussell King 44acb45439SRussell King wait_queue_head_t irq_wait; 45acb45439SRussell King struct semaphore sem; 46acb45439SRussell King struct completion init_exit; 47acb45439SRussell King struct task_struct *rtask; 48acb45439SRussell King int use_count; 49acb45439SRussell King u16 x_res; 50acb45439SRussell King u16 y_res; 51acb45439SRussell King 52acb45439SRussell King int restart:1; 53acb45439SRussell King int adcsync:1; 54acb45439SRussell King }; 55acb45439SRussell King 56acb45439SRussell King static int adcsync; 57acb45439SRussell King 58acb45439SRussell King static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) 59acb45439SRussell King { 60acb45439SRussell King input_report_abs(&ts->idev, ABS_X, x); 61acb45439SRussell King input_report_abs(&ts->idev, ABS_Y, y); 62acb45439SRussell King input_report_abs(&ts->idev, ABS_PRESSURE, pressure); 63acb45439SRussell King input_sync(&ts->idev); 64acb45439SRussell King } 65acb45439SRussell King 66acb45439SRussell King static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) 67acb45439SRussell King { 68acb45439SRussell King input_report_abs(&ts->idev, ABS_PRESSURE, 0); 69acb45439SRussell King input_sync(&ts->idev); 70acb45439SRussell King } 71acb45439SRussell King 72acb45439SRussell King /* 73acb45439SRussell King * Switch to interrupt mode. 74acb45439SRussell King */ 75acb45439SRussell King static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts) 76acb45439SRussell King { 77acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 78acb45439SRussell King UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | 79acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | 80acb45439SRussell King UCB_TS_CR_MODE_INT); 81acb45439SRussell King } 82acb45439SRussell King 83acb45439SRussell King /* 84acb45439SRussell King * Switch to pressure mode, and read pressure. We don't need to wait 85acb45439SRussell King * here, since both plates are being driven. 86acb45439SRussell King */ 87acb45439SRussell King static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts) 88acb45439SRussell King { 89acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 90acb45439SRussell King UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | 91acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | 92acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 93acb45439SRussell King 94acb45439SRussell King return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); 95acb45439SRussell King } 96acb45439SRussell King 97acb45439SRussell King /* 98acb45439SRussell King * Switch to X position mode and measure Y plate. We switch the plate 99acb45439SRussell King * configuration in pressure mode, then switch to position mode. This 100acb45439SRussell King * gives a faster response time. Even so, we need to wait about 55us 101acb45439SRussell King * for things to stabilise. 102acb45439SRussell King */ 103acb45439SRussell King static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts) 104acb45439SRussell King { 105acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 106acb45439SRussell King UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 107acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 108acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 109acb45439SRussell King UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 110acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 111acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 112acb45439SRussell King UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 113acb45439SRussell King UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); 114acb45439SRussell King 115acb45439SRussell King udelay(55); 116acb45439SRussell King 117acb45439SRussell King return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); 118acb45439SRussell King } 119acb45439SRussell King 120acb45439SRussell King /* 121acb45439SRussell King * Switch to Y position mode and measure X plate. We switch the plate 122acb45439SRussell King * configuration in pressure mode, then switch to position mode. This 123acb45439SRussell King * gives a faster response time. Even so, we need to wait about 55us 124acb45439SRussell King * for things to stabilise. 125acb45439SRussell King */ 126acb45439SRussell King static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts) 127acb45439SRussell King { 128acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 129acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 130acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 131acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 132acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 133acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 134acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 135acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 136acb45439SRussell King UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); 137acb45439SRussell King 138acb45439SRussell King udelay(55); 139acb45439SRussell King 140acb45439SRussell King return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync); 141acb45439SRussell King } 142acb45439SRussell King 143acb45439SRussell King /* 144acb45439SRussell King * Switch to X plate resistance mode. Set MX to ground, PX to 145acb45439SRussell King * supply. Measure current. 146acb45439SRussell King */ 147acb45439SRussell King static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts) 148acb45439SRussell King { 149acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 150acb45439SRussell King UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 151acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 152acb45439SRussell King return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); 153acb45439SRussell King } 154acb45439SRussell King 155acb45439SRussell King /* 156acb45439SRussell King * Switch to Y plate resistance mode. Set MY to ground, PY to 157acb45439SRussell King * supply. Measure current. 158acb45439SRussell King */ 159acb45439SRussell King static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts) 160acb45439SRussell King { 161acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 162acb45439SRussell King UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 163acb45439SRussell King UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 164acb45439SRussell King return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); 165acb45439SRussell King } 166acb45439SRussell King 167acb45439SRussell King /* 168acb45439SRussell King * This is a RT kernel thread that handles the ADC accesses 169acb45439SRussell King * (mainly so we can use semaphores in the UCB1200 core code 170acb45439SRussell King * to serialise accesses to the ADC). 171acb45439SRussell King */ 172acb45439SRussell King static int ucb1x00_thread(void *_ts) 173acb45439SRussell King { 174acb45439SRussell King struct ucb1x00_ts *ts = _ts; 175acb45439SRussell King struct task_struct *tsk = current; 176acb45439SRussell King DECLARE_WAITQUEUE(wait, tsk); 177acb45439SRussell King int valid; 178acb45439SRussell King 179acb45439SRussell King ts->rtask = tsk; 180acb45439SRussell King 181acb45439SRussell King daemonize("ktsd"); 182acb45439SRussell King /* only want to receive SIGKILL */ 183acb45439SRussell King allow_signal(SIGKILL); 184acb45439SRussell King 185acb45439SRussell King /* 186acb45439SRussell King * We could run as a real-time thread. However, thus far 187acb45439SRussell King * this doesn't seem to be necessary. 188acb45439SRussell King */ 189acb45439SRussell King // tsk->policy = SCHED_FIFO; 190acb45439SRussell King // tsk->rt_priority = 1; 191acb45439SRussell King 192acb45439SRussell King complete(&ts->init_exit); 193acb45439SRussell King 194acb45439SRussell King valid = 0; 195acb45439SRussell King 196acb45439SRussell King add_wait_queue(&ts->irq_wait, &wait); 197acb45439SRussell King for (;;) { 198acb45439SRussell King unsigned int x, y, p, val; 199acb45439SRussell King signed long timeout; 200acb45439SRussell King 201acb45439SRussell King ts->restart = 0; 202acb45439SRussell King 203acb45439SRussell King ucb1x00_adc_enable(ts->ucb); 204acb45439SRussell King 205acb45439SRussell King x = ucb1x00_ts_read_xpos(ts); 206acb45439SRussell King y = ucb1x00_ts_read_ypos(ts); 207acb45439SRussell King p = ucb1x00_ts_read_pressure(ts); 208acb45439SRussell King 209acb45439SRussell King /* 210acb45439SRussell King * Switch back to interrupt mode. 211acb45439SRussell King */ 212acb45439SRussell King ucb1x00_ts_mode_int(ts); 213acb45439SRussell King ucb1x00_adc_disable(ts->ucb); 214acb45439SRussell King 215acb45439SRussell King set_task_state(tsk, TASK_UNINTERRUPTIBLE); 216acb45439SRussell King schedule_timeout(HZ / 100); 217acb45439SRussell King if (signal_pending(tsk)) 218acb45439SRussell King break; 219acb45439SRussell King 220acb45439SRussell King ucb1x00_enable(ts->ucb); 221acb45439SRussell King val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); 222acb45439SRussell King 223acb45439SRussell King if (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW)) { 224acb45439SRussell King set_task_state(tsk, TASK_INTERRUPTIBLE); 225acb45439SRussell King 226acb45439SRussell King ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); 227acb45439SRussell King ucb1x00_disable(ts->ucb); 228acb45439SRussell King 229acb45439SRussell King /* 230acb45439SRussell King * If we spat out a valid sample set last time, 231acb45439SRussell King * spit out a "pen off" sample here. 232acb45439SRussell King */ 233acb45439SRussell King if (valid) { 234acb45439SRussell King ucb1x00_ts_event_release(ts); 235acb45439SRussell King valid = 0; 236acb45439SRussell King } 237acb45439SRussell King 238acb45439SRussell King timeout = MAX_SCHEDULE_TIMEOUT; 239acb45439SRussell King } else { 240acb45439SRussell King ucb1x00_disable(ts->ucb); 241acb45439SRussell King 242acb45439SRussell King /* 243acb45439SRussell King * Filtering is policy. Policy belongs in user 244acb45439SRussell King * space. We therefore leave it to user space 245acb45439SRussell King * to do any filtering they please. 246acb45439SRussell King */ 247acb45439SRussell King if (!ts->restart) { 248acb45439SRussell King ucb1x00_ts_evt_add(ts, p, x, y); 249acb45439SRussell King valid = 1; 250acb45439SRussell King } 251acb45439SRussell King 252acb45439SRussell King set_task_state(tsk, TASK_INTERRUPTIBLE); 253acb45439SRussell King timeout = HZ / 100; 254acb45439SRussell King } 255acb45439SRussell King 256acb45439SRussell King try_to_freeze(); 257acb45439SRussell King 258acb45439SRussell King schedule_timeout(timeout); 259acb45439SRussell King if (signal_pending(tsk)) 260acb45439SRussell King break; 261acb45439SRussell King } 262acb45439SRussell King 263acb45439SRussell King remove_wait_queue(&ts->irq_wait, &wait); 264acb45439SRussell King 265acb45439SRussell King ts->rtask = NULL; 266acb45439SRussell King complete_and_exit(&ts->init_exit, 0); 267acb45439SRussell King } 268acb45439SRussell King 269acb45439SRussell King /* 270acb45439SRussell King * We only detect touch screen _touches_ with this interrupt 271acb45439SRussell King * handler, and even then we just schedule our task. 272acb45439SRussell King */ 273acb45439SRussell King static void ucb1x00_ts_irq(int idx, void *id) 274acb45439SRussell King { 275acb45439SRussell King struct ucb1x00_ts *ts = id; 276acb45439SRussell King ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); 277acb45439SRussell King wake_up(&ts->irq_wait); 278acb45439SRussell King } 279acb45439SRussell King 280acb45439SRussell King static int ucb1x00_ts_open(struct input_dev *idev) 281acb45439SRussell King { 282acb45439SRussell King struct ucb1x00_ts *ts = (struct ucb1x00_ts *)idev; 283acb45439SRussell King int ret = 0; 284acb45439SRussell King 285acb45439SRussell King if (down_interruptible(&ts->sem)) 286acb45439SRussell King return -EINTR; 287acb45439SRussell King 288acb45439SRussell King if (ts->use_count++ != 0) 289acb45439SRussell King goto out; 290acb45439SRussell King 291acb45439SRussell King if (ts->rtask) 292acb45439SRussell King panic("ucb1x00: rtask running?"); 293acb45439SRussell King 294acb45439SRussell King init_waitqueue_head(&ts->irq_wait); 295acb45439SRussell King ret = ucb1x00_hook_irq(ts->ucb, UCB_IRQ_TSPX, ucb1x00_ts_irq, ts); 296acb45439SRussell King if (ret < 0) 297acb45439SRussell King goto out; 298acb45439SRussell King 299acb45439SRussell King /* 300acb45439SRussell King * If we do this at all, we should allow the user to 301acb45439SRussell King * measure and read the X and Y resistance at any time. 302acb45439SRussell King */ 303acb45439SRussell King ucb1x00_adc_enable(ts->ucb); 304acb45439SRussell King ts->x_res = ucb1x00_ts_read_xres(ts); 305acb45439SRussell King ts->y_res = ucb1x00_ts_read_yres(ts); 306acb45439SRussell King ucb1x00_adc_disable(ts->ucb); 307acb45439SRussell King 308acb45439SRussell King init_completion(&ts->init_exit); 309acb45439SRussell King ret = kernel_thread(ucb1x00_thread, ts, CLONE_KERNEL); 310acb45439SRussell King if (ret >= 0) { 311acb45439SRussell King wait_for_completion(&ts->init_exit); 312acb45439SRussell King ret = 0; 313acb45439SRussell King } else { 314acb45439SRussell King ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 315acb45439SRussell King } 316acb45439SRussell King 317acb45439SRussell King out: 318acb45439SRussell King if (ret) 319acb45439SRussell King ts->use_count--; 320acb45439SRussell King up(&ts->sem); 321acb45439SRussell King return ret; 322acb45439SRussell King } 323acb45439SRussell King 324acb45439SRussell King /* 325acb45439SRussell King * Release touchscreen resources. Disable IRQs. 326acb45439SRussell King */ 327acb45439SRussell King static void ucb1x00_ts_close(struct input_dev *idev) 328acb45439SRussell King { 329acb45439SRussell King struct ucb1x00_ts *ts = (struct ucb1x00_ts *)idev; 330acb45439SRussell King 331acb45439SRussell King down(&ts->sem); 332acb45439SRussell King if (--ts->use_count == 0) { 333acb45439SRussell King if (ts->rtask) { 334acb45439SRussell King send_sig(SIGKILL, ts->rtask, 1); 335acb45439SRussell King wait_for_completion(&ts->init_exit); 336acb45439SRussell King } 337acb45439SRussell King 338acb45439SRussell King ucb1x00_enable(ts->ucb); 339acb45439SRussell King ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 340acb45439SRussell King ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0); 341acb45439SRussell King ucb1x00_disable(ts->ucb); 342acb45439SRussell King } 343acb45439SRussell King up(&ts->sem); 344acb45439SRussell King } 345acb45439SRussell King 346acb45439SRussell King #ifdef CONFIG_PM 347acb45439SRussell King static int ucb1x00_ts_resume(struct ucb1x00_dev *dev) 348acb45439SRussell King { 349acb45439SRussell King struct ucb1x00_ts *ts = dev->priv; 350acb45439SRussell King 351acb45439SRussell King if (ts->rtask != NULL) { 352acb45439SRussell King /* 353acb45439SRussell King * Restart the TS thread to ensure the 354acb45439SRussell King * TS interrupt mode is set up again 355acb45439SRussell King * after sleep. 356acb45439SRussell King */ 357acb45439SRussell King ts->restart = 1; 358acb45439SRussell King wake_up(&ts->irq_wait); 359acb45439SRussell King } 360acb45439SRussell King return 0; 361acb45439SRussell King } 362acb45439SRussell King #else 363acb45439SRussell King #define ucb1x00_ts_resume NULL 364acb45439SRussell King #endif 365acb45439SRussell King 366acb45439SRussell King 367acb45439SRussell King /* 368acb45439SRussell King * Initialisation. 369acb45439SRussell King */ 370acb45439SRussell King static int ucb1x00_ts_add(struct ucb1x00_dev *dev) 371acb45439SRussell King { 372acb45439SRussell King struct ucb1x00_ts *ts; 373acb45439SRussell King 374acb45439SRussell King ts = kmalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); 375acb45439SRussell King if (!ts) 376acb45439SRussell King return -ENOMEM; 377acb45439SRussell King 378acb45439SRussell King memset(ts, 0, sizeof(struct ucb1x00_ts)); 379acb45439SRussell King 380acb45439SRussell King ts->ucb = dev->ucb; 381acb45439SRussell King ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC; 382acb45439SRussell King init_MUTEX(&ts->sem); 383acb45439SRussell King 384acb45439SRussell King ts->idev.name = "Touchscreen panel"; 385acb45439SRussell King ts->idev.id.product = ts->ucb->id; 386acb45439SRussell King ts->idev.open = ucb1x00_ts_open; 387acb45439SRussell King ts->idev.close = ucb1x00_ts_close; 388acb45439SRussell King 389acb45439SRussell King __set_bit(EV_ABS, ts->idev.evbit); 390acb45439SRussell King __set_bit(ABS_X, ts->idev.absbit); 391acb45439SRussell King __set_bit(ABS_Y, ts->idev.absbit); 392acb45439SRussell King __set_bit(ABS_PRESSURE, ts->idev.absbit); 393acb45439SRussell King 394acb45439SRussell King input_register_device(&ts->idev); 395acb45439SRussell King 396acb45439SRussell King dev->priv = ts; 397acb45439SRussell King 398acb45439SRussell King return 0; 399acb45439SRussell King } 400acb45439SRussell King 401acb45439SRussell King static void ucb1x00_ts_remove(struct ucb1x00_dev *dev) 402acb45439SRussell King { 403acb45439SRussell King struct ucb1x00_ts *ts = dev->priv; 404acb45439SRussell King input_unregister_device(&ts->idev); 405acb45439SRussell King kfree(ts); 406acb45439SRussell King } 407acb45439SRussell King 408acb45439SRussell King static struct ucb1x00_driver ucb1x00_ts_driver = { 409acb45439SRussell King .add = ucb1x00_ts_add, 410acb45439SRussell King .remove = ucb1x00_ts_remove, 411acb45439SRussell King .resume = ucb1x00_ts_resume, 412acb45439SRussell King }; 413acb45439SRussell King 414acb45439SRussell King static int __init ucb1x00_ts_init(void) 415acb45439SRussell King { 416acb45439SRussell King return ucb1x00_register_driver(&ucb1x00_ts_driver); 417acb45439SRussell King } 418acb45439SRussell King 419acb45439SRussell King static void __exit ucb1x00_ts_exit(void) 420acb45439SRussell King { 421acb45439SRussell King ucb1x00_unregister_driver(&ucb1x00_ts_driver); 422acb45439SRussell King } 423acb45439SRussell King 424acb45439SRussell King module_param(adcsync, int, 0444); 425acb45439SRussell King module_init(ucb1x00_ts_init); 426acb45439SRussell King module_exit(ucb1x00_ts_exit); 427acb45439SRussell King 428acb45439SRussell King MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); 429acb45439SRussell King MODULE_DESCRIPTION("UCB1x00 touchscreen driver"); 430acb45439SRussell King MODULE_LICENSE("GPL"); 431