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/delay.h> |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 23 | #include <linux/sched.h> |
| 24 | #include <linux/wait.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 25 | #include <linux/input.h> |
| 26 | #include <linux/device.h> |
| 27 | #include <linux/interrupt.h> |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 28 | #include <linux/ucb1400.h> |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 29 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 30 | #define UCB1400_TS_POLL_PERIOD 10 /* ms */ |
| 31 | |
Rusty Russell | 90ab5ee | 2012-01-13 09:32:20 +1030 | [diff] [blame] | 32 | static bool adcsync; |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 33 | static int ts_delay = 55; /* us */ |
| 34 | static int ts_delay_pressure; /* us */ |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 35 | |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 36 | /* Switch to interrupt mode. */ |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 37 | static void ucb1400_ts_mode_int(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 38 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 39 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 40 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 41 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 42 | UCB_TS_CR_MODE_INT); |
| 43 | } |
| 44 | |
| 45 | /* |
| 46 | * Switch to pressure mode, and read pressure. We don't need to wait |
| 47 | * here, since both plates are being driven. |
| 48 | */ |
Dmitry Torokhov | 7507232 | 2012-01-04 22:18:31 -0800 | [diff] [blame] | 49 | static unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 50 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 51 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 52 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 53 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 54 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 55 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 56 | udelay(ts_delay_pressure); |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 57 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 58 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 59 | } |
| 60 | |
| 61 | /* |
| 62 | * Switch to X position mode and measure Y plate. We switch the plate |
| 63 | * configuration in pressure mode, then switch to position mode. This |
| 64 | * gives a faster response time. Even so, we need to wait about 55us |
| 65 | * for things to stabilise. |
| 66 | */ |
Dmitry Torokhov | 7507232 | 2012-01-04 22:18:31 -0800 | [diff] [blame] | 67 | static unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 68 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 69 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 70 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 71 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 72 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 73 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 74 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 75 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 76 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 77 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 78 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 79 | udelay(ts_delay); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 80 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 81 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | /* |
| 85 | * Switch to Y position mode and measure X plate. We switch the plate |
| 86 | * configuration in pressure mode, then switch to position mode. This |
| 87 | * gives a faster response time. Even so, we need to wait about 55us |
| 88 | * for things to stabilise. |
| 89 | */ |
Dmitry Torokhov | 7507232 | 2012-01-04 22:18:31 -0800 | [diff] [blame] | 90 | static int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 91 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 92 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 93 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 94 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 95 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 96 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 97 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 98 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 99 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 100 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 101 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 102 | udelay(ts_delay); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 103 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 104 | return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPX, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | /* |
| 108 | * Switch to X plate resistance mode. Set MX to ground, PX to |
| 109 | * supply. Measure current. |
| 110 | */ |
Dmitry Torokhov | 7507232 | 2012-01-04 22:18:31 -0800 | [diff] [blame] | 111 | static unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 112 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 113 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 114 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 115 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 116 | return ucb1400_adc_read(ucb->ac97, 0, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | /* |
| 120 | * Switch to Y plate resistance mode. Set MY to ground, PY to |
| 121 | * supply. Measure current. |
| 122 | */ |
Dmitry Torokhov | 7507232 | 2012-01-04 22:18:31 -0800 | [diff] [blame] | 123 | static unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 124 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 125 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 126 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 127 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 128 | return ucb1400_adc_read(ucb->ac97, 0, adcsync); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 129 | } |
| 130 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 131 | static int ucb1400_ts_pen_up(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 132 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 133 | unsigned short val = ucb1400_reg_read(ucb->ac97, UCB_TS_CR); |
Hans J. Koch | f9c2273 | 2009-07-12 20:51:25 -0700 | [diff] [blame] | 134 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 135 | return val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 136 | } |
| 137 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 138 | static void ucb1400_ts_irq_enable(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 139 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 140 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, UCB_IE_TSPX); |
| 141 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
| 142 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_TSPX); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 143 | } |
| 144 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 145 | static void ucb1400_ts_irq_disable(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 146 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 147 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 148 | } |
| 149 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 150 | static void ucb1400_ts_report_event(struct input_dev *idev, u16 pressure, u16 x, u16 y) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 151 | { |
| 152 | input_report_abs(idev, ABS_X, x); |
| 153 | input_report_abs(idev, ABS_Y, y); |
| 154 | input_report_abs(idev, ABS_PRESSURE, pressure); |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 155 | input_report_key(idev, BTN_TOUCH, 1); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 156 | input_sync(idev); |
| 157 | } |
| 158 | |
| 159 | static void ucb1400_ts_event_release(struct input_dev *idev) |
| 160 | { |
| 161 | input_report_abs(idev, ABS_PRESSURE, 0); |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 162 | input_report_key(idev, BTN_TOUCH, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 163 | input_sync(idev); |
| 164 | } |
| 165 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 166 | static void ucb1400_clear_pending_irq(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 167 | { |
| 168 | unsigned int isr; |
| 169 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 170 | isr = ucb1400_reg_read(ucb->ac97, UCB_IE_STATUS); |
| 171 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, isr); |
| 172 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 173 | |
Pavel Revak | 9b2fb2d | 2009-08-20 22:30:54 -0700 | [diff] [blame] | 174 | if (isr & UCB_IE_TSPX) |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 175 | ucb1400_ts_irq_disable(ucb); |
Pavel Revak | 9b2fb2d | 2009-08-20 22:30:54 -0700 | [diff] [blame] | 176 | else |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 177 | dev_dbg(&ucb->ts_idev->dev, |
| 178 | "ucb1400: unexpected IE_STATUS = %#x\n", isr); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 179 | } |
| 180 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 181 | /* |
| 182 | * A restriction with interrupts exists when using the ucb1400, as |
| 183 | * the codec read/write routines may sleep while waiting for codec |
| 184 | * access completion and uses semaphores for access control to the |
| 185 | * AC97 bus. Therefore the driver is forced to use threaded interrupt |
| 186 | * handler. |
| 187 | */ |
| 188 | static irqreturn_t ucb1400_irq(int irqnr, void *devid) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 189 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 190 | struct ucb1400_ts *ucb = devid; |
| 191 | unsigned int x, y, p; |
| 192 | bool penup; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 193 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 194 | if (unlikely(irqnr != ucb->irq)) |
| 195 | return IRQ_NONE; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 196 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 197 | ucb1400_clear_pending_irq(ucb); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 198 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 199 | /* Start with a small delay before checking pendown state */ |
| 200 | msleep(UCB1400_TS_POLL_PERIOD); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 201 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 202 | while (!ucb->stopped && !(penup = ucb1400_ts_pen_up(ucb))) { |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 203 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 204 | ucb1400_adc_enable(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 205 | x = ucb1400_ts_read_xpos(ucb); |
| 206 | y = ucb1400_ts_read_ypos(ucb); |
| 207 | p = ucb1400_ts_read_pressure(ucb); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 208 | ucb1400_adc_disable(ucb->ac97); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 209 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 210 | ucb1400_ts_report_event(ucb->ts_idev, p, x, y); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 211 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 212 | wait_event_timeout(ucb->ts_wait, ucb->stopped, |
| 213 | msecs_to_jiffies(UCB1400_TS_POLL_PERIOD)); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 214 | } |
| 215 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 216 | ucb1400_ts_event_release(ucb->ts_idev); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 217 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 218 | if (!ucb->stopped) { |
| 219 | /* Switch back to interrupt mode. */ |
| 220 | ucb1400_ts_mode_int(ucb); |
| 221 | ucb1400_ts_irq_enable(ucb); |
| 222 | } |
| 223 | |
| 224 | return IRQ_HANDLED; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 225 | } |
| 226 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 227 | static void ucb1400_ts_stop(struct ucb1400_ts *ucb) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 228 | { |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 229 | /* Signal IRQ thread to stop polling and disable the handler. */ |
| 230 | ucb->stopped = true; |
| 231 | mb(); |
| 232 | wake_up(&ucb->ts_wait); |
| 233 | disable_irq(ucb->irq); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 234 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 235 | ucb1400_ts_irq_disable(ucb); |
| 236 | ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 0); |
| 237 | } |
| 238 | |
| 239 | /* Must be called with ts->lock held */ |
| 240 | static void ucb1400_ts_start(struct ucb1400_ts *ucb) |
| 241 | { |
| 242 | /* Tell IRQ thread that it may poll the device. */ |
| 243 | ucb->stopped = false; |
| 244 | mb(); |
| 245 | |
| 246 | ucb1400_ts_mode_int(ucb); |
| 247 | ucb1400_ts_irq_enable(ucb); |
| 248 | |
| 249 | enable_irq(ucb->irq); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 250 | } |
| 251 | |
| 252 | static int ucb1400_ts_open(struct input_dev *idev) |
| 253 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 254 | struct ucb1400_ts *ucb = input_get_drvdata(idev); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 255 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 256 | ucb1400_ts_start(ucb); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 257 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 258 | return 0; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | static void ucb1400_ts_close(struct input_dev *idev) |
| 262 | { |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 263 | struct ucb1400_ts *ucb = input_get_drvdata(idev); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 264 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 265 | ucb1400_ts_stop(ucb); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 266 | } |
| 267 | |
| 268 | #ifndef NO_IRQ |
| 269 | #define NO_IRQ 0 |
| 270 | #endif |
| 271 | |
| 272 | /* |
| 273 | * Try to probe our interrupt, rather than relying on lots of |
| 274 | * hard-coded machine dependencies. |
| 275 | */ |
Bill Pemberton | 5298cc4 | 2012-11-23 21:38:25 -0800 | [diff] [blame] | 276 | static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb, |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 277 | struct platform_device *pdev) |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 278 | { |
| 279 | unsigned long mask, timeout; |
| 280 | |
| 281 | mask = probe_irq_on(); |
| 282 | |
| 283 | /* Enable the ADC interrupt. */ |
| 284 | ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, UCB_IE_ADC); |
| 285 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_ADC); |
| 286 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); |
| 287 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
| 288 | |
| 289 | /* Cause an ADC interrupt. */ |
| 290 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA); |
| 291 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA | UCB_ADC_START); |
| 292 | |
| 293 | /* Wait for the conversion to complete. */ |
| 294 | timeout = jiffies + HZ/2; |
| 295 | while (!(ucb1400_reg_read(ucb->ac97, UCB_ADC_DATA) & |
| 296 | UCB_ADC_DAT_VALID)) { |
| 297 | cpu_relax(); |
| 298 | if (time_after(jiffies, timeout)) { |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 299 | dev_err(&pdev->dev, "timed out in IRQ probe\n"); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 300 | probe_irq_off(mask); |
| 301 | return -ENODEV; |
| 302 | } |
| 303 | } |
| 304 | ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, 0); |
| 305 | |
| 306 | /* Disable and clear interrupt. */ |
| 307 | ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, 0); |
| 308 | ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0); |
| 309 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); |
| 310 | ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); |
| 311 | |
| 312 | /* Read triggered interrupt. */ |
| 313 | ucb->irq = probe_irq_off(mask); |
| 314 | if (ucb->irq < 0 || ucb->irq == NO_IRQ) |
| 315 | return -ENODEV; |
| 316 | |
| 317 | return 0; |
| 318 | } |
| 319 | |
Bill Pemberton | 5298cc4 | 2012-11-23 21:38:25 -0800 | [diff] [blame] | 320 | static int ucb1400_ts_probe(struct platform_device *pdev) |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 321 | { |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 322 | struct ucb1400_ts *ucb = dev_get_platdata(&pdev->dev); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 323 | int error, x_res, y_res; |
Marek Vasut | 1700f5f | 2009-08-20 22:05:53 -0700 | [diff] [blame] | 324 | u16 fcsr; |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 325 | |
| 326 | ucb->ts_idev = input_allocate_device(); |
| 327 | if (!ucb->ts_idev) { |
| 328 | error = -ENOMEM; |
| 329 | goto err; |
| 330 | } |
| 331 | |
Marek Vasut | fb14159 | 2009-11-08 19:45:54 -0800 | [diff] [blame] | 332 | /* Only in case the IRQ line wasn't supplied, try detecting it */ |
| 333 | if (ucb->irq < 0) { |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 334 | error = ucb1400_ts_detect_irq(ucb, pdev); |
Marek Vasut | fb14159 | 2009-11-08 19:45:54 -0800 | [diff] [blame] | 335 | if (error) { |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 336 | dev_err(&pdev->dev, "IRQ probe failed\n"); |
Marek Vasut | fb14159 | 2009-11-08 19:45:54 -0800 | [diff] [blame] | 337 | goto err_free_devs; |
| 338 | } |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 339 | } |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 340 | dev_dbg(&pdev->dev, "found IRQ %d\n", ucb->irq); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 341 | |
| 342 | init_waitqueue_head(&ucb->ts_wait); |
| 343 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 344 | input_set_drvdata(ucb->ts_idev, ucb); |
| 345 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 346 | ucb->ts_idev->dev.parent = &pdev->dev; |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 347 | ucb->ts_idev->name = "UCB1400 touchscreen interface"; |
| 348 | ucb->ts_idev->id.vendor = ucb1400_reg_read(ucb->ac97, |
| 349 | AC97_VENDOR_ID1); |
| 350 | ucb->ts_idev->id.product = ucb->id; |
| 351 | ucb->ts_idev->open = ucb1400_ts_open; |
| 352 | ucb->ts_idev->close = ucb1400_ts_close; |
Mike Rapoport | cd2d64b | 2009-03-04 01:12:49 -0800 | [diff] [blame] | 353 | ucb->ts_idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY); |
| 354 | 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] | 355 | |
Marek Vasut | 1700f5f | 2009-08-20 22:05:53 -0700 | [diff] [blame] | 356 | /* |
| 357 | * Enable ADC filter to prevent horrible jitter on Colibri. |
| 358 | * This also further reduces jitter on boards where ADCSYNC |
| 359 | * pin is connected. |
| 360 | */ |
| 361 | fcsr = ucb1400_reg_read(ucb->ac97, UCB_FCSR); |
| 362 | ucb1400_reg_write(ucb->ac97, UCB_FCSR, fcsr | UCB_FCSR_AVE); |
| 363 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 364 | ucb1400_adc_enable(ucb->ac97); |
| 365 | x_res = ucb1400_ts_read_xres(ucb); |
| 366 | y_res = ucb1400_ts_read_yres(ucb); |
| 367 | ucb1400_adc_disable(ucb->ac97); |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 368 | dev_dbg(&pdev->dev, "x/y = %d/%d\n", x_res, y_res); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 369 | |
| 370 | input_set_abs_params(ucb->ts_idev, ABS_X, 0, x_res, 0, 0); |
| 371 | input_set_abs_params(ucb->ts_idev, ABS_Y, 0, y_res, 0, 0); |
| 372 | input_set_abs_params(ucb->ts_idev, ABS_PRESSURE, 0, 0, 0, 0); |
| 373 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 374 | ucb1400_ts_stop(ucb); |
| 375 | |
| 376 | error = request_threaded_irq(ucb->irq, NULL, ucb1400_irq, |
| 377 | IRQF_TRIGGER_RISING | IRQF_ONESHOT, |
| 378 | "UCB1400", ucb); |
| 379 | if (error) { |
Dmitry Torokhov | bd100e2 | 2012-01-04 22:18:51 -0800 | [diff] [blame] | 380 | dev_err(&pdev->dev, |
| 381 | "unable to grab irq%d: %d\n", ucb->irq, error); |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 382 | goto err_free_devs; |
| 383 | } |
| 384 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 385 | error = input_register_device(ucb->ts_idev); |
| 386 | if (error) |
| 387 | goto err_free_irq; |
| 388 | |
| 389 | return 0; |
| 390 | |
| 391 | err_free_irq: |
| 392 | free_irq(ucb->irq, ucb); |
| 393 | err_free_devs: |
| 394 | input_free_device(ucb->ts_idev); |
| 395 | err: |
| 396 | return error; |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 397 | } |
| 398 | |
Bill Pemberton | e2619cf | 2012-11-23 21:50:47 -0800 | [diff] [blame] | 399 | static int ucb1400_ts_remove(struct platform_device *pdev) |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 400 | { |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 401 | struct ucb1400_ts *ucb = dev_get_platdata(&pdev->dev); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 402 | |
| 403 | free_irq(ucb->irq, ucb); |
| 404 | input_unregister_device(ucb->ts_idev); |
Dmitry Torokhov | 9fea929 | 2012-01-04 22:18:22 -0800 | [diff] [blame] | 405 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 406 | return 0; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 407 | } |
| 408 | |
Jingoo Han | 02b6a58 | 2014-11-02 00:04:14 -0700 | [diff] [blame] | 409 | static int __maybe_unused ucb1400_ts_suspend(struct device *dev) |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 410 | { |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 411 | struct ucb1400_ts *ucb = dev_get_platdata(dev); |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 412 | struct input_dev *idev = ucb->ts_idev; |
| 413 | |
| 414 | mutex_lock(&idev->mutex); |
| 415 | |
| 416 | if (idev->users) |
| 417 | ucb1400_ts_start(ucb); |
| 418 | |
| 419 | mutex_unlock(&idev->mutex); |
| 420 | return 0; |
| 421 | } |
| 422 | |
Jingoo Han | 02b6a58 | 2014-11-02 00:04:14 -0700 | [diff] [blame] | 423 | static int __maybe_unused ucb1400_ts_resume(struct device *dev) |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 424 | { |
Jingoo Han | c838cb3 | 2013-12-05 19:21:10 -0800 | [diff] [blame] | 425 | struct ucb1400_ts *ucb = dev_get_platdata(dev); |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 426 | struct input_dev *idev = ucb->ts_idev; |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 427 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 428 | mutex_lock(&idev->mutex); |
| 429 | |
| 430 | if (idev->users) |
| 431 | ucb1400_ts_stop(ucb); |
| 432 | |
| 433 | mutex_unlock(&idev->mutex); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 434 | return 0; |
| 435 | } |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 436 | |
Dmitry Torokhov | c899afe | 2012-01-04 22:18:42 -0800 | [diff] [blame] | 437 | static SIMPLE_DEV_PM_OPS(ucb1400_ts_pm_ops, |
| 438 | ucb1400_ts_suspend, ucb1400_ts_resume); |
Dmitry Torokhov | 3db8a537 | 2012-01-04 22:17:57 -0800 | [diff] [blame] | 439 | |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 440 | static struct platform_driver ucb1400_ts_driver = { |
| 441 | .probe = ucb1400_ts_probe, |
Bill Pemberton | 1cb0aa8 | 2012-11-23 21:27:39 -0800 | [diff] [blame] | 442 | .remove = ucb1400_ts_remove, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 443 | .driver = { |
| 444 | .name = "ucb1400_ts", |
Dmitry Torokhov | 3db8a537 | 2012-01-04 22:17:57 -0800 | [diff] [blame] | 445 | .pm = &ucb1400_ts_pm_ops, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 446 | }, |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 447 | }; |
JJ Ding | cdcc96e | 2011-11-29 11:14:13 -0800 | [diff] [blame] | 448 | module_platform_driver(ucb1400_ts_driver); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 449 | |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 450 | module_param(adcsync, bool, 0444); |
| 451 | MODULE_PARM_DESC(adcsync, "Synchronize touch readings with ADCSYNC pin."); |
| 452 | |
| 453 | module_param(ts_delay, int, 0444); |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 454 | MODULE_PARM_DESC(ts_delay, "Delay between panel setup and" |
| 455 | " position read. Default = 55us."); |
Cliff Brake | b5b16c5 | 2007-04-12 01:35:43 -0400 | [diff] [blame] | 456 | |
| 457 | module_param(ts_delay_pressure, int, 0444); |
| 458 | MODULE_PARM_DESC(ts_delay_pressure, |
Marek Vašut | d9105c2 | 2008-08-03 21:34:08 +0100 | [diff] [blame] | 459 | "delay between panel setup and pressure read." |
| 460 | " Default = 0us."); |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 461 | |
Nicolas Pitre | f40219b | 2006-11-17 01:07:26 -0500 | [diff] [blame] | 462 | MODULE_DESCRIPTION("Philips UCB1400 touchscreen driver"); |
| 463 | MODULE_LICENSE("GPL"); |