Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 1 | /* |
| 2 | * Philips UCB1400 touchscreen driver |
| 3 | * |
| 4 | * Author: Nicolas Pitre |
| 5 | * Created: September 25, 2006 |
| 6 | * Copyright: MontaVista Software, Inc. |
| 7 | * |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 8 | * Spliting done by: Marek Vasut <marek.vasut@gmail.com> |
Lucas De Marchi | 25985ed | 2011-03-30 22:57:33 -0300 | [diff] [blame] | 9 | * If something doesn't work and it worked before spliting, e-mail me, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 10 | * dont bother Nicolas please ;-) |
| 11 | * |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 12 | * This program is free software; you can redistribute it and/or modify |
| 13 | * it under the terms of the GNU General Public License version 2 as |
| 14 | * published by the Free Software Foundation. |
| 15 | * |
| 16 | * This code is heavily based on ucb1x00-*.c copyrighted by Russell King |
| 17 | * covering the UCB1100, UCB1200 and UCB1300.. Support for the UCB1400 has |
| 18 | * been made separate from ucb1x00-core/ucb1x00-ts on Russell's request. |
| 19 | */ |
| 20 | |
| 21 | #include <linux/module.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 22 | #include <linux/init.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 23 | #include <linux/completion.h> |
| 24 | #include <linux/delay.h> |
| 25 | #include <linux/input.h> |
| 26 | #include <linux/device.h> |
| 27 | #include <linux/interrupt.h> |
| 28 | #include <linux/suspend.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 29 | #include <linux/kthread.h> |
Dmitry Torokhov | bff19b1 | 2006-12-08 01:37:03 -0500 | [diff] [blame] | 30 | #include <linux/freezer.h> |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 31 | #include <linux/ucb1400.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 32 | |
| 33 | static int adcsync; |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 34 | static int ts_delay = 55; /* us */ |
| 35 | static int ts_delay_pressure; /* us */ |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 36 | |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 37 | /* Switch to interrupt mode. */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 38 | static inline void ucb1400_ts_mode_int(struct snd_ac97 *ac97) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 39 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 40 | ucb1400_reg_write(ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 41 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 42 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 43 | UCB_TS_CR_MODE_INT); |
| 44 | } |
| 45 | |
| 46 | /* |
| 47 | * Switch to pressure mode, and read pressure. We don't need to wait |
| 48 | * here, since both plates are being driven. |
| 49 | */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 50 | static inline unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 51 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 52 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 53 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 54 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 55 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 56 | udelay(ts_delay_pressure); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 57 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 58 | } |
| 59 | |
| 60 | /* |
| 61 | * Switch to X position mode and measure Y plate. We switch the plate |
| 62 | * configuration in pressure mode, then switch to position mode. This |
| 63 | * gives a faster response time. Even so, we need to wait about 55us |
| 64 | * for things to stabilise. |
| 65 | */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 66 | static inline unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 67 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 68 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 69 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 70 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 71 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 72 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 73 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 74 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 75 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 76 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 77 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 78 | udelay(ts_delay); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 79 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 80 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 81 | } |
| 82 | |
| 83 | /* |
| 84 | * Switch to Y position mode and measure X plate. We switch the plate |
| 85 | * configuration in pressure mode, then switch to position mode. This |
| 86 | * gives a faster response time. Even so, we need to wait about 55us |
| 87 | * for things to stabilise. |
| 88 | */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 89 | static inline unsigned int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 90 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 91 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 92 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 93 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 94 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 95 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 96 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 97 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 98 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 99 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 100 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 101 | udelay(ts_delay); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 102 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 103 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPX, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 104 | } |
| 105 | |
| 106 | /* |
| 107 | * Switch to X plate resistance mode. Set MX to ground, PX to |
| 108 | * supply. Measure current. |
| 109 | */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 110 | static inline unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 111 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 112 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 113 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 114 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 115 | return ucb1400_adc_read(ucb->ac97, 0, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 116 | } |
| 117 | |
| 118 | /* |
| 119 | * Switch to Y plate resistance mode. Set MY to ground, PY to |
| 120 | * supply. Measure current. |
| 121 | */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 122 | static inline unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 123 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 124 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 125 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 126 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 127 | return ucb1400_adc_read(ucb->ac97, 0, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 128 | } |
| 129 | |
Hans J. Koch | f9c2273 | 2009-07-12 20:51:25 -0700 | [diff] [blame] | 130 | static inline int ucb1400_ts_pen_up(struct snd_ac97 *ac97) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 131 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 132 | unsigned short val = ucb1400_reg_read(ac97, UCB_TS_CR); |
Hans J. Koch | f9c2273 | 2009-07-12 20:51:25 -0700 | [diff] [blame] | 133 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 134 | return val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 135 | } |
| 136 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 137 | static inline void ucb1400_ts_irq_enable(struct snd_ac97 *ac97) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 138 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 139 | ucb1400_reg_write(ac97, UCB_IE_CLEAR, UCB_IE_TSPX); |
| 140 | ucb1400_reg_write(ac97, UCB_IE_CLEAR, 0); |
| 141 | ucb1400_reg_write(ac97, UCB_IE_FAL, UCB_IE_TSPX); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 142 | } |
| 143 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 144 | static inline void ucb1400_ts_irq_disable(struct snd_ac97 *ac97) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 145 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 146 | ucb1400_reg_write(ac97, UCB_IE_FAL, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 147 | } |
| 148 | |
| 149 | static void ucb1400_ts_evt_add(struct input_dev *idev, u16 pressure, u16 x, u16 y) |
| 150 | { |
| 151 | input_report_abs(idev, ABS_X, x); |
| 152 | input_report_abs(idev, ABS_Y, y); |
| 153 | input_report_abs(idev, ABS_PRESSURE, pressure); |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 154 | input_report_key(idev, BTN_TOUCH, 1); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 155 | input_sync(idev); |
| 156 | } |
| 157 | |
| 158 | static void ucb1400_ts_event_release(struct input_dev *idev) |
| 159 | { |
| 160 | input_report_abs(idev, ABS_PRESSURE, 0); |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 161 | input_report_key(idev, BTN_TOUCH, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 162 | input_sync(idev); |
| 163 | } |
| 164 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 165 | static void ucb1400_handle_pending_irq(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 166 | { |
| 167 | unsigned int isr; |
| 168 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 169 | isr = ucb1400_reg_read(ucb->ac97, UCB_IE_STATUS); |
| 170 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, isr); |
| 171 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 172 | |
Pavel Revak | 9b2fb2d | 2009-08-20 22:30:54 -0700 | [diff] [blame] | 173 | if (isr & UCB_IE_TSPX) |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 174 | ucb1400_ts_irq_disable(ucb->ac97); |
Pavel Revak | 9b2fb2d | 2009-08-20 22:30:54 -0700 | [diff] [blame] | 175 | else |
| 176 | dev_dbg(&ucb->ts_idev->dev, "ucb1400: unexpected IE_STATUS = %#x\n", isr); |
| 177 | enable_irq(ucb->irq); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 178 | } |
| 179 | |
| 180 | static int ucb1400_ts_thread(void *_ucb) |
| 181 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 182 | struct ucb1400_ts *ucb = _ucb; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 183 | struct task_struct *tsk = current; |
| 184 | int valid = 0; |
Satoru Takeuchi | c130bdb | 2007-05-14 23:52:07 -0400 | [diff] [blame] | 185 | struct sched_param param = { .sched_priority = 1 }; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 186 | |
Satoru Takeuchi | c130bdb | 2007-05-14 23:52:07 -0400 | [diff] [blame] | 187 | sched_setscheduler(tsk, SCHED_FIFO, ¶m); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 188 | |
Rafael J. Wysocki | 8314418 | 2007-07-17 04:03:35 -0700 | [diff] [blame] | 189 | set_freezable(); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 190 | while (!kthread_should_stop()) { |
| 191 | unsigned int x, y, p; |
| 192 | long timeout; |
| 193 | |
| 194 | ucb->ts_restart = 0; |
| 195 | |
| 196 | if (ucb->irq_pending) { |
| 197 | ucb->irq_pending = 0; |
| 198 | ucb1400_handle_pending_irq(ucb); |
| 199 | } |
| 200 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 201 | ucb1400_adc_enable(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 202 | x = ucb1400_ts_read_xpos(ucb); |
| 203 | y = ucb1400_ts_read_ypos(ucb); |
| 204 | p = ucb1400_ts_read_pressure(ucb); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 205 | ucb1400_adc_disable(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 206 | |
| 207 | /* Switch back to interrupt mode. */ |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 208 | ucb1400_ts_mode_int(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 209 | |
| 210 | msleep(10); |
| 211 | |
Hans J. Koch | f9c2273 | 2009-07-12 20:51:25 -0700 | [diff] [blame] | 212 | if (ucb1400_ts_pen_up(ucb->ac97)) { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 213 | ucb1400_ts_irq_enable(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 214 | |
| 215 | /* |
| 216 | * If we spat out a valid sample set last time, |
| 217 | * spit out a "pen off" sample here. |
| 218 | */ |
| 219 | if (valid) { |
| 220 | ucb1400_ts_event_release(ucb->ts_idev); |
| 221 | valid = 0; |
| 222 | } |
| 223 | |
| 224 | timeout = MAX_SCHEDULE_TIMEOUT; |
| 225 | } else { |
| 226 | valid = 1; |
| 227 | ucb1400_ts_evt_add(ucb->ts_idev, p, x, y); |
| 228 | timeout = msecs_to_jiffies(10); |
| 229 | } |
| 230 | |
Rafael J. Wysocki | e42837b | 2007-10-18 03:04:45 -0700 | [diff] [blame] | 231 | wait_event_freezable_timeout(ucb->ts_wait, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 232 | ucb->irq_pending || ucb->ts_restart || |
| 233 | kthread_should_stop(), timeout); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | /* Send the "pen off" if we are stopping with the pen still active */ |
| 237 | if (valid) |
| 238 | ucb1400_ts_event_release(ucb->ts_idev); |
| 239 | |
| 240 | ucb->ts_task = NULL; |
| 241 | return 0; |
| 242 | } |
| 243 | |
| 244 | /* |
| 245 | * A restriction with interrupts exists when using the ucb1400, as |
| 246 | * the codec read/write routines may sleep while waiting for codec |
| 247 | * access completion and uses semaphores for access control to the |
| 248 | * AC97 bus. A complete codec read cycle could take anywhere from |
| 249 | * 60 to 100uSec so we *definitely* don't want to spin inside the |
| 250 | * interrupt handler waiting for codec access. So, we handle the |
| 251 | * interrupt by scheduling a RT kernel thread to run in process |
| 252 | * context instead of interrupt context. |
| 253 | */ |
| 254 | static irqreturn_t ucb1400_hard_irq(int irqnr, void *devid) |
| 255 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 256 | struct ucb1400_ts *ucb = devid; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 257 | |
| 258 | if (irqnr == ucb->irq) { |
Ben Nizette | 3deb649 | 2009-04-17 20:35:58 -0700 | [diff] [blame] | 259 | disable_irq_nosync(ucb->irq); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 260 | ucb->irq_pending = 1; |
| 261 | wake_up(&ucb->ts_wait); |
| 262 | return IRQ_HANDLED; |
| 263 | } |
| 264 | return IRQ_NONE; |
| 265 | } |
| 266 | |
| 267 | static int ucb1400_ts_open(struct input_dev *idev) |
| 268 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 269 | struct ucb1400_ts *ucb = input_get_drvdata(idev); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 270 | int ret = 0; |
| 271 | |
| 272 | BUG_ON(ucb->ts_task); |
| 273 | |
| 274 | ucb->ts_task = kthread_run(ucb1400_ts_thread, ucb, "UCB1400_ts"); |
| 275 | if (IS_ERR(ucb->ts_task)) { |
| 276 | ret = PTR_ERR(ucb->ts_task); |
| 277 | ucb->ts_task = NULL; |
| 278 | } |
| 279 | |
| 280 | return ret; |
| 281 | } |
| 282 | |
| 283 | static void ucb1400_ts_close(struct input_dev *idev) |
| 284 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 285 | struct ucb1400_ts *ucb = input_get_drvdata(idev); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 286 | |
| 287 | if (ucb->ts_task) |
| 288 | kthread_stop(ucb->ts_task); |
| 289 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 290 | ucb1400_ts_irq_disable(ucb->ac97); |
| 291 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 0); |
| 292 | } |
| 293 | |
| 294 | #ifndef NO_IRQ |
| 295 | #define NO_IRQ 0 |
| 296 | #endif |
| 297 | |
| 298 | /* |
| 299 | * Try to probe our interrupt, rather than relying on lots of |
| 300 | * hard-coded machine dependencies. |
| 301 | */ |
| 302 | static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb) |
| 303 | { |
| 304 | unsigned long mask, timeout; |
| 305 | |
| 306 | mask = probe_irq_on(); |
| 307 | |
| 308 | /* Enable the ADC interrupt. */ |
| 309 | ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, UCB_IE_ADC); |
| 310 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_ADC); |
| 311 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); |
| 312 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
| 313 | |
| 314 | /* Cause an ADC interrupt. */ |
| 315 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA); |
| 316 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA | UCB_ADC_START); |
| 317 | |
| 318 | /* Wait for the conversion to complete. */ |
| 319 | timeout = jiffies + HZ/2; |
| 320 | while (!(ucb1400_reg_read(ucb->ac97, UCB_ADC_DATA) & |
| 321 | UCB_ADC_DAT_VALID)) { |
| 322 | cpu_relax(); |
| 323 | if (time_after(jiffies, timeout)) { |
| 324 | printk(KERN_ERR "ucb1400: timed out in IRQ probe\n"); |
| 325 | probe_irq_off(mask); |
| 326 | return -ENODEV; |
| 327 | } |
| 328 | } |
| 329 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, 0); |
| 330 | |
| 331 | /* Disable and clear interrupt. */ |
| 332 | ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, 0); |
| 333 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0); |
| 334 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); |
| 335 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
| 336 | |
| 337 | /* Read triggered interrupt. */ |
| 338 | ucb->irq = probe_irq_off(mask); |
| 339 | if (ucb->irq < 0 || ucb->irq == NO_IRQ) |
| 340 | return -ENODEV; |
| 341 | |
| 342 | return 0; |
| 343 | } |
| 344 | |
| 345 | static int ucb1400_ts_probe(struct platform_device *dev) |
| 346 | { |
| 347 | int error, x_res, y_res; |
Marek Vasut | 1700f5f | 2009-08-20 22:05:53 -0700 | [diff] [blame] | 348 | u16 fcsr; |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 349 | struct ucb1400_ts *ucb = dev->dev.platform_data; |
| 350 | |
| 351 | ucb->ts_idev = input_allocate_device(); |
| 352 | if (!ucb->ts_idev) { |
| 353 | error = -ENOMEM; |
| 354 | goto err; |
| 355 | } |
| 356 | |
Marek Vasut | fb14159 | 2009-11-08 19:45:54 -0800 | [diff] [blame] | 357 | /* Only in case the IRQ line wasn't supplied, try detecting it */ |
| 358 | if (ucb->irq < 0) { |
| 359 | error = ucb1400_ts_detect_irq(ucb); |
| 360 | if (error) { |
| 361 | printk(KERN_ERR "UCB1400: IRQ probe failed\n"); |
| 362 | goto err_free_devs; |
| 363 | } |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 364 | } |
| 365 | |
| 366 | init_waitqueue_head(&ucb->ts_wait); |
| 367 | |
| 368 | error = request_irq(ucb->irq, ucb1400_hard_irq, IRQF_TRIGGER_RISING, |
| 369 | "UCB1400", ucb); |
| 370 | if (error) { |
| 371 | printk(KERN_ERR "ucb1400: unable to grab irq%d: %d\n", |
| 372 | ucb->irq, error); |
| 373 | goto err_free_devs; |
| 374 | } |
| 375 | printk(KERN_DEBUG "UCB1400: found IRQ %d\n", ucb->irq); |
| 376 | |
| 377 | input_set_drvdata(ucb->ts_idev, ucb); |
| 378 | |
| 379 | ucb->ts_idev->dev.parent = &dev->dev; |
| 380 | ucb->ts_idev->name = "UCB1400 touchscreen interface"; |
| 381 | ucb->ts_idev->id.vendor = ucb1400_reg_read(ucb->ac97, |
| 382 | AC97_VENDOR_ID1); |
| 383 | ucb->ts_idev->id.product = ucb->id; |
| 384 | ucb->ts_idev->open = ucb1400_ts_open; |
| 385 | ucb->ts_idev->close = ucb1400_ts_close; |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 386 | ucb->ts_idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY); |
| 387 | ucb->ts_idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 388 | |
Marek Vasut | 1700f5f | 2009-08-20 22:05:53 -0700 | [diff] [blame] | 389 | /* |
| 390 | * Enable ADC filter to prevent horrible jitter on Colibri. |
| 391 | * This also further reduces jitter on boards where ADCSYNC |
| 392 | * pin is connected. |
| 393 | */ |
| 394 | fcsr = ucb1400_reg_read(ucb->ac97, UCB_FCSR); |
| 395 | ucb1400_reg_write(ucb->ac97, UCB_FCSR, fcsr | UCB_FCSR_AVE); |
| 396 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 397 | ucb1400_adc_enable(ucb->ac97); |
| 398 | x_res = ucb1400_ts_read_xres(ucb); |
| 399 | y_res = ucb1400_ts_read_yres(ucb); |
| 400 | ucb1400_adc_disable(ucb->ac97); |
| 401 | printk(KERN_DEBUG "UCB1400: x/y = %d/%d\n", x_res, y_res); |
| 402 | |
| 403 | input_set_abs_params(ucb->ts_idev, ABS_X, 0, x_res, 0, 0); |
| 404 | input_set_abs_params(ucb->ts_idev, ABS_Y, 0, y_res, 0, 0); |
| 405 | input_set_abs_params(ucb->ts_idev, ABS_PRESSURE, 0, 0, 0, 0); |
| 406 | |
| 407 | error = input_register_device(ucb->ts_idev); |
| 408 | if (error) |
| 409 | goto err_free_irq; |
| 410 | |
| 411 | return 0; |
| 412 | |
| 413 | err_free_irq: |
| 414 | free_irq(ucb->irq, ucb); |
| 415 | err_free_devs: |
| 416 | input_free_device(ucb->ts_idev); |
| 417 | err: |
| 418 | return error; |
| 419 | |
| 420 | } |
| 421 | |
| 422 | static int ucb1400_ts_remove(struct platform_device *dev) |
| 423 | { |
| 424 | struct ucb1400_ts *ucb = dev->dev.platform_data; |
| 425 | |
| 426 | free_irq(ucb->irq, ucb); |
| 427 | input_unregister_device(ucb->ts_idev); |
| 428 | return 0; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 429 | } |
| 430 | |
| 431 | #ifdef CONFIG_PM |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 432 | static int ucb1400_ts_resume(struct platform_device *dev) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 433 | { |
Manuel Traut | 346a850 | 2009-05-27 06:20:05 -0700 | [diff] [blame] | 434 | struct ucb1400_ts *ucb = dev->dev.platform_data; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 435 | |
| 436 | if (ucb->ts_task) { |
| 437 | /* |
| 438 | * Restart the TS thread to ensure the |
| 439 | * TS interrupt mode is set up again |
| 440 | * after sleep. |
| 441 | */ |
| 442 | ucb->ts_restart = 1; |
| 443 | wake_up(&ucb->ts_wait); |
| 444 | } |
| 445 | return 0; |
| 446 | } |
| 447 | #else |
| 448 | #define ucb1400_ts_resume NULL |
| 449 | #endif |
| 450 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 451 | static struct platform_driver ucb1400_ts_driver = { |
| 452 | .probe = ucb1400_ts_probe, |
| 453 | .remove = ucb1400_ts_remove, |
| 454 | .resume = ucb1400_ts_resume, |
| 455 | .driver = { |
| 456 | .name = "ucb1400_ts", |
| 457 | }, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 458 | }; |
| 459 | |
| 460 | static int __init ucb1400_ts_init(void) |
| 461 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 462 | return platform_driver_register(&ucb1400_ts_driver); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 463 | } |
| 464 | |
| 465 | static void __exit ucb1400_ts_exit(void) |
| 466 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 467 | platform_driver_unregister(&ucb1400_ts_driver); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 468 | } |
| 469 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 470 | module_param(adcsync, bool, 0444); |
| 471 | MODULE_PARM_DESC(adcsync, "Synchronize touch readings with ADCSYNC pin."); |
| 472 | |
| 473 | module_param(ts_delay, int, 0444); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 474 | MODULE_PARM_DESC(ts_delay, "Delay between panel setup and" |
| 475 | " position read. Default = 55us."); |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 476 | |
| 477 | module_param(ts_delay_pressure, int, 0444); |
| 478 | MODULE_PARM_DESC(ts_delay_pressure, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 479 | "delay between panel setup and pressure read." |
| 480 | " Default = 0us."); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 481 | |
| 482 | module_init(ucb1400_ts_init); |
| 483 | module_exit(ucb1400_ts_exit); |
| 484 | |
| 485 | MODULE_DESCRIPTION("Philips UCB1400 touchscreen driver"); |
| 486 | MODULE_LICENSE("GPL"); |