Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 1 | /* |
| 2 | * drivers/input/touchscreen/tsc2007.c |
| 3 | * |
| 4 | * Copyright (c) 2008 MtekVision Co., Ltd. |
| 5 | * Kwangwoo Lee <kwlee@mtekvision.com> |
| 6 | * |
| 7 | * Using code from: |
| 8 | * - ads7846.c |
| 9 | * Copyright (c) 2005 David Brownell |
| 10 | * Copyright (c) 2006 Nokia Corporation |
| 11 | * - corgi_ts.c |
| 12 | * Copyright (C) 2004-2005 Richard Purdie |
| 13 | * - omap_ts.[hc], ads7846.h, ts_osk.c |
| 14 | * Copyright (C) 2002 MontaVista Software |
| 15 | * Copyright (C) 2004 Texas Instruments |
| 16 | * Copyright (C) 2005 Dirk Behme |
| 17 | * |
| 18 | * This program is free software; you can redistribute it and/or modify |
| 19 | * it under the terms of the GNU General Public License version 2 as |
| 20 | * published by the Free Software Foundation. |
| 21 | */ |
| 22 | |
| 23 | #include <linux/module.h> |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 24 | #include <linux/slab.h> |
| 25 | #include <linux/input.h> |
| 26 | #include <linux/interrupt.h> |
| 27 | #include <linux/i2c.h> |
| 28 | #include <linux/i2c/tsc2007.h> |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 29 | #include <linux/of_device.h> |
| 30 | #include <linux/of.h> |
| 31 | #include <linux/of_gpio.h> |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 32 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 33 | #define TSC2007_MEASURE_TEMP0 (0x0 << 4) |
| 34 | #define TSC2007_MEASURE_AUX (0x2 << 4) |
| 35 | #define TSC2007_MEASURE_TEMP1 (0x4 << 4) |
| 36 | #define TSC2007_ACTIVATE_XN (0x8 << 4) |
| 37 | #define TSC2007_ACTIVATE_YN (0x9 << 4) |
| 38 | #define TSC2007_ACTIVATE_YP_XN (0xa << 4) |
| 39 | #define TSC2007_SETUP (0xb << 4) |
| 40 | #define TSC2007_MEASURE_X (0xc << 4) |
| 41 | #define TSC2007_MEASURE_Y (0xd << 4) |
| 42 | #define TSC2007_MEASURE_Z1 (0xe << 4) |
| 43 | #define TSC2007_MEASURE_Z2 (0xf << 4) |
| 44 | |
| 45 | #define TSC2007_POWER_OFF_IRQ_EN (0x0 << 2) |
| 46 | #define TSC2007_ADC_ON_IRQ_DIS0 (0x1 << 2) |
| 47 | #define TSC2007_ADC_OFF_IRQ_EN (0x2 << 2) |
| 48 | #define TSC2007_ADC_ON_IRQ_DIS1 (0x3 << 2) |
| 49 | |
| 50 | #define TSC2007_12BIT (0x0 << 1) |
| 51 | #define TSC2007_8BIT (0x1 << 1) |
| 52 | |
| 53 | #define MAX_12BIT ((1 << 12) - 1) |
| 54 | |
| 55 | #define ADC_ON_12BIT (TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0) |
| 56 | |
| 57 | #define READ_Y (ADC_ON_12BIT | TSC2007_MEASURE_Y) |
| 58 | #define READ_Z1 (ADC_ON_12BIT | TSC2007_MEASURE_Z1) |
| 59 | #define READ_Z2 (ADC_ON_12BIT | TSC2007_MEASURE_Z2) |
| 60 | #define READ_X (ADC_ON_12BIT | TSC2007_MEASURE_X) |
| 61 | #define PWRDOWN (TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN) |
| 62 | |
| 63 | struct ts_event { |
| 64 | u16 x; |
| 65 | u16 y; |
| 66 | u16 z1, z2; |
| 67 | }; |
| 68 | |
| 69 | struct tsc2007 { |
| 70 | struct input_dev *input; |
| 71 | char phys[32]; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 72 | |
| 73 | struct i2c_client *client; |
| 74 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 75 | u16 model; |
| 76 | u16 x_plate_ohms; |
Thierry Reding | 84005eb | 2011-05-17 09:31:01 -0700 | [diff] [blame] | 77 | u16 max_rt; |
Aaron Sierra | bbdb38a | 2015-03-31 14:35:36 -0700 | [diff] [blame] | 78 | unsigned long poll_period; /* in jiffies */ |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 79 | int fuzzx; |
| 80 | int fuzzy; |
| 81 | int fuzzz; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 82 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 83 | unsigned gpio; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 84 | int irq; |
| 85 | |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 86 | wait_queue_head_t wait; |
| 87 | bool stopped; |
| 88 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 89 | int (*get_pendown_state)(struct device *); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 90 | void (*clear_penirq)(void); |
| 91 | }; |
| 92 | |
| 93 | static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd) |
| 94 | { |
| 95 | s32 data; |
| 96 | u16 val; |
| 97 | |
| 98 | data = i2c_smbus_read_word_data(tsc->client, cmd); |
| 99 | if (data < 0) { |
| 100 | dev_err(&tsc->client->dev, "i2c io error: %d\n", data); |
| 101 | return data; |
| 102 | } |
| 103 | |
| 104 | /* The protocol and raw data format from i2c interface: |
| 105 | * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P |
| 106 | * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit]. |
| 107 | */ |
| 108 | val = swab16(data) >> 4; |
| 109 | |
| 110 | dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val); |
| 111 | |
| 112 | return val; |
| 113 | } |
| 114 | |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 115 | static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc) |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 116 | { |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 117 | /* y- still on; turn on only y+ (and ADC) */ |
| 118 | tc->y = tsc2007_xfer(tsc, READ_Y); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 119 | |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 120 | /* turn y- off, x+ on, then leave in lowpower */ |
| 121 | tc->x = tsc2007_xfer(tsc, READ_X); |
| 122 | |
| 123 | /* turn y+ off, x- on; we'll use formula #1 */ |
| 124 | tc->z1 = tsc2007_xfer(tsc, READ_Z1); |
| 125 | tc->z2 = tsc2007_xfer(tsc, READ_Z2); |
| 126 | |
| 127 | /* Prepare for next touch reading - power down ADC, enable PENIRQ */ |
| 128 | tsc2007_xfer(tsc, PWRDOWN); |
| 129 | } |
| 130 | |
| 131 | static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc) |
| 132 | { |
| 133 | u32 rt = 0; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 134 | |
| 135 | /* range filtering */ |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 136 | if (tc->x == MAX_12BIT) |
| 137 | tc->x = 0; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 138 | |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 139 | if (likely(tc->x && tc->z1)) { |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 140 | /* compute touch pressure resistance using equation #1 */ |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 141 | rt = tc->z2 - tc->z1; |
| 142 | rt *= tc->x; |
| 143 | rt *= tsc->x_plate_ohms; |
| 144 | rt /= tc->z1; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 145 | rt = (rt + 2047) >> 12; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 146 | } |
| 147 | |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 148 | return rt; |
| 149 | } |
| 150 | |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 151 | static bool tsc2007_is_pen_down(struct tsc2007 *ts) |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 152 | { |
Dmitry Torokhov | 141586bc | 2009-07-24 23:14:16 -0700 | [diff] [blame] | 153 | /* |
| 154 | * NOTE: We can't rely on the pressure to determine the pen down |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 155 | * state, even though this controller has a pressure sensor. |
| 156 | * The pressure value can fluctuate for quite a while after |
| 157 | * lifting the pen and in some cases may not even settle at the |
| 158 | * expected value. |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 159 | * |
| 160 | * The only safe way to check for the pen up condition is in the |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 161 | * work function by reading the pen signal state (it's a GPIO |
| 162 | * and IRQ). Unfortunately such callback is not always available, |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 163 | * in that case we assume that the pen is down and expect caller |
| 164 | * to fall back on the pressure reading. |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 165 | */ |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 166 | |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 167 | if (!ts->get_pendown_state) |
| 168 | return true; |
Dmitry Torokhov | d570e9e | 2009-08-04 22:07:26 -0700 | [diff] [blame] | 169 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 170 | return ts->get_pendown_state(&ts->client->dev); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 171 | } |
| 172 | |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 173 | static irqreturn_t tsc2007_soft_irq(int irq, void *handle) |
| 174 | { |
| 175 | struct tsc2007 *ts = handle; |
| 176 | struct input_dev *input = ts->input; |
| 177 | struct ts_event tc; |
| 178 | u32 rt; |
| 179 | |
| 180 | while (!ts->stopped && tsc2007_is_pen_down(ts)) { |
| 181 | |
| 182 | /* pen is down, continue with the measurement */ |
| 183 | tsc2007_read_values(ts, &tc); |
| 184 | |
| 185 | rt = tsc2007_calculate_pressure(ts, &tc); |
| 186 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 187 | if (!rt && !ts->get_pendown_state) { |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 188 | /* |
| 189 | * If pressure reported is 0 and we don't have |
| 190 | * callback to check pendown state, we have to |
| 191 | * assume that pen was lifted up. |
| 192 | */ |
| 193 | break; |
| 194 | } |
| 195 | |
| 196 | if (rt <= ts->max_rt) { |
| 197 | dev_dbg(&ts->client->dev, |
| 198 | "DOWN point(%4d,%4d), pressure (%4u)\n", |
| 199 | tc.x, tc.y, rt); |
| 200 | |
| 201 | input_report_key(input, BTN_TOUCH, 1); |
| 202 | input_report_abs(input, ABS_X, tc.x); |
| 203 | input_report_abs(input, ABS_Y, tc.y); |
| 204 | input_report_abs(input, ABS_PRESSURE, rt); |
| 205 | |
| 206 | input_sync(input); |
| 207 | |
| 208 | } else { |
| 209 | /* |
| 210 | * Sample found inconsistent by debouncing or pressure is |
| 211 | * beyond the maximum. Don't report it to user space, |
| 212 | * repeat at least once more the measurement. |
| 213 | */ |
| 214 | dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt); |
| 215 | } |
| 216 | |
Aaron Sierra | bbdb38a | 2015-03-31 14:35:36 -0700 | [diff] [blame] | 217 | wait_event_timeout(ts->wait, ts->stopped, ts->poll_period); |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 218 | } |
| 219 | |
| 220 | dev_dbg(&ts->client->dev, "UP\n"); |
| 221 | |
| 222 | input_report_key(input, BTN_TOUCH, 0); |
| 223 | input_report_abs(input, ABS_PRESSURE, 0); |
| 224 | input_sync(input); |
| 225 | |
| 226 | if (ts->clear_penirq) |
| 227 | ts->clear_penirq(); |
| 228 | |
| 229 | return IRQ_HANDLED; |
| 230 | } |
| 231 | |
| 232 | static irqreturn_t tsc2007_hard_irq(int irq, void *handle) |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 233 | { |
| 234 | struct tsc2007 *ts = handle; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 235 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 236 | if (tsc2007_is_pen_down(ts)) |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 237 | return IRQ_WAKE_THREAD; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 238 | |
| 239 | if (ts->clear_penirq) |
| 240 | ts->clear_penirq(); |
| 241 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 242 | return IRQ_HANDLED; |
| 243 | } |
| 244 | |
Dmitry Torokhov | d3654d7 | 2011-08-25 01:05:46 -0700 | [diff] [blame] | 245 | static void tsc2007_stop(struct tsc2007 *ts) |
Dmitry Torokhov | 141586bc | 2009-07-24 23:14:16 -0700 | [diff] [blame] | 246 | { |
Dmitry Torokhov | 377dc55 | 2011-08-25 00:25:12 -0700 | [diff] [blame] | 247 | ts->stopped = true; |
| 248 | mb(); |
| 249 | wake_up(&ts->wait); |
Dmitry Torokhov | d3654d7 | 2011-08-25 01:05:46 -0700 | [diff] [blame] | 250 | |
| 251 | disable_irq(ts->irq); |
| 252 | } |
| 253 | |
| 254 | static int tsc2007_open(struct input_dev *input_dev) |
| 255 | { |
| 256 | struct tsc2007 *ts = input_get_drvdata(input_dev); |
| 257 | int err; |
| 258 | |
| 259 | ts->stopped = false; |
| 260 | mb(); |
| 261 | |
| 262 | enable_irq(ts->irq); |
| 263 | |
| 264 | /* Prepare for touch readings - power down ADC and enable PENIRQ */ |
| 265 | err = tsc2007_xfer(ts, PWRDOWN); |
| 266 | if (err < 0) { |
| 267 | tsc2007_stop(ts); |
| 268 | return err; |
| 269 | } |
| 270 | |
| 271 | return 0; |
| 272 | } |
| 273 | |
| 274 | static void tsc2007_close(struct input_dev *input_dev) |
| 275 | { |
| 276 | struct tsc2007 *ts = input_get_drvdata(input_dev); |
| 277 | |
| 278 | tsc2007_stop(ts); |
Dmitry Torokhov | 141586bc | 2009-07-24 23:14:16 -0700 | [diff] [blame] | 279 | } |
| 280 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 281 | #ifdef CONFIG_OF |
| 282 | static int tsc2007_get_pendown_state_gpio(struct device *dev) |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 283 | { |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 284 | struct i2c_client *client = to_i2c_client(dev); |
| 285 | struct tsc2007 *ts = i2c_get_clientdata(client); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 286 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 287 | return !gpio_get_value(ts->gpio); |
| 288 | } |
| 289 | |
| 290 | static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts) |
| 291 | { |
| 292 | struct device_node *np = client->dev.of_node; |
| 293 | u32 val32; |
| 294 | u64 val64; |
| 295 | |
| 296 | if (!np) { |
| 297 | dev_err(&client->dev, "missing device tree data\n"); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 298 | return -EINVAL; |
| 299 | } |
| 300 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 301 | if (!of_property_read_u32(np, "ti,max-rt", &val32)) |
| 302 | ts->max_rt = val32; |
| 303 | else |
| 304 | ts->max_rt = MAX_12BIT; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 305 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 306 | if (!of_property_read_u32(np, "ti,fuzzx", &val32)) |
| 307 | ts->fuzzx = val32; |
| 308 | |
| 309 | if (!of_property_read_u32(np, "ti,fuzzy", &val32)) |
| 310 | ts->fuzzy = val32; |
| 311 | |
| 312 | if (!of_property_read_u32(np, "ti,fuzzz", &val32)) |
| 313 | ts->fuzzz = val32; |
| 314 | |
| 315 | if (!of_property_read_u64(np, "ti,poll-period", &val64)) |
Aaron Sierra | bbdb38a | 2015-03-31 14:35:36 -0700 | [diff] [blame] | 316 | ts->poll_period = msecs_to_jiffies(val64); |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 317 | else |
Aaron Sierra | bbdb38a | 2015-03-31 14:35:36 -0700 | [diff] [blame] | 318 | ts->poll_period = msecs_to_jiffies(1); |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 319 | |
| 320 | if (!of_property_read_u32(np, "ti,x-plate-ohms", &val32)) { |
| 321 | ts->x_plate_ohms = val32; |
| 322 | } else { |
| 323 | dev_err(&client->dev, "missing ti,x-plate-ohms devicetree property."); |
| 324 | return -EINVAL; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 325 | } |
| 326 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 327 | ts->gpio = of_get_gpio(np, 0); |
| 328 | if (gpio_is_valid(ts->gpio)) |
| 329 | ts->get_pendown_state = tsc2007_get_pendown_state_gpio; |
| 330 | else |
| 331 | dev_warn(&client->dev, |
| 332 | "GPIO not specified in DT (of_get_gpio returned %d)\n", |
| 333 | ts->gpio); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 334 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 335 | return 0; |
| 336 | } |
| 337 | #else |
| 338 | static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts) |
| 339 | { |
| 340 | dev_err(&client->dev, "platform data is required!\n"); |
| 341 | return -EINVAL; |
| 342 | } |
| 343 | #endif |
| 344 | |
| 345 | static int tsc2007_probe_pdev(struct i2c_client *client, struct tsc2007 *ts, |
| 346 | const struct tsc2007_platform_data *pdata, |
| 347 | const struct i2c_device_id *id) |
| 348 | { |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 349 | ts->model = pdata->model; |
| 350 | ts->x_plate_ohms = pdata->x_plate_ohms; |
Thierry Reding | 84005eb | 2011-05-17 09:31:01 -0700 | [diff] [blame] | 351 | ts->max_rt = pdata->max_rt ? : MAX_12BIT; |
Aaron Sierra | bbdb38a | 2015-03-31 14:35:36 -0700 | [diff] [blame] | 352 | ts->poll_period = msecs_to_jiffies(pdata->poll_period ? : 1); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 353 | ts->get_pendown_state = pdata->get_pendown_state; |
| 354 | ts->clear_penirq = pdata->clear_penirq; |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 355 | ts->fuzzx = pdata->fuzzx; |
| 356 | ts->fuzzy = pdata->fuzzy; |
| 357 | ts->fuzzz = pdata->fuzzz; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 358 | |
Philip Rakity | 341deef | 2011-10-11 20:54:55 -0700 | [diff] [blame] | 359 | if (pdata->x_plate_ohms == 0) { |
| 360 | dev_err(&client->dev, "x_plate_ohms is not set up in platform data"); |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 361 | return -EINVAL; |
Philip Rakity | 341deef | 2011-10-11 20:54:55 -0700 | [diff] [blame] | 362 | } |
| 363 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 364 | return 0; |
| 365 | } |
| 366 | |
Dmitry Torokhov | fd91a5f | 2013-11-19 12:52:29 -0800 | [diff] [blame] | 367 | static void tsc2007_call_exit_platform_hw(void *data) |
| 368 | { |
| 369 | struct device *dev = data; |
| 370 | const struct tsc2007_platform_data *pdata = dev_get_platdata(dev); |
| 371 | |
| 372 | pdata->exit_platform_hw(); |
| 373 | } |
| 374 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 375 | static int tsc2007_probe(struct i2c_client *client, |
| 376 | const struct i2c_device_id *id) |
| 377 | { |
| 378 | const struct tsc2007_platform_data *pdata = dev_get_platdata(&client->dev); |
| 379 | struct tsc2007 *ts; |
| 380 | struct input_dev *input_dev; |
| 381 | int err; |
| 382 | |
| 383 | if (!i2c_check_functionality(client->adapter, |
| 384 | I2C_FUNC_SMBUS_READ_WORD_DATA)) |
| 385 | return -EIO; |
| 386 | |
| 387 | ts = devm_kzalloc(&client->dev, sizeof(struct tsc2007), GFP_KERNEL); |
| 388 | if (!ts) |
| 389 | return -ENOMEM; |
| 390 | |
| 391 | if (pdata) |
| 392 | err = tsc2007_probe_pdev(client, ts, pdata, id); |
| 393 | else |
| 394 | err = tsc2007_probe_dt(client, ts); |
| 395 | if (err) |
| 396 | return err; |
| 397 | |
Dmitry Torokhov | fd91a5f | 2013-11-19 12:52:29 -0800 | [diff] [blame] | 398 | input_dev = devm_input_allocate_device(&client->dev); |
| 399 | if (!input_dev) |
| 400 | return -ENOMEM; |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 401 | |
| 402 | i2c_set_clientdata(client, ts); |
| 403 | |
| 404 | ts->client = client; |
| 405 | ts->irq = client->irq; |
| 406 | ts->input = input_dev; |
| 407 | init_waitqueue_head(&ts->wait); |
| 408 | |
Kay Sievers | 4e8718a | 2009-01-29 22:56:08 -0800 | [diff] [blame] | 409 | snprintf(ts->phys, sizeof(ts->phys), |
| 410 | "%s/input0", dev_name(&client->dev)); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 411 | |
| 412 | input_dev->name = "TSC2007 Touchscreen"; |
| 413 | input_dev->phys = ts->phys; |
| 414 | input_dev->id.bustype = BUS_I2C; |
| 415 | |
Dmitry Torokhov | d3654d7 | 2011-08-25 01:05:46 -0700 | [diff] [blame] | 416 | input_dev->open = tsc2007_open; |
| 417 | input_dev->close = tsc2007_close; |
| 418 | |
| 419 | input_set_drvdata(input_dev, ts); |
| 420 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 421 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
| 422 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); |
| 423 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 424 | input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, ts->fuzzx, 0); |
| 425 | input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, ts->fuzzy, 0); |
Thierry Reding | 891e376 | 2011-05-17 09:32:29 -0700 | [diff] [blame] | 426 | input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 427 | ts->fuzzz, 0); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 428 | |
Dmitry Torokhov | fd91a5f | 2013-11-19 12:52:29 -0800 | [diff] [blame] | 429 | if (pdata) { |
| 430 | if (pdata->exit_platform_hw) { |
| 431 | err = devm_add_action(&client->dev, |
| 432 | tsc2007_call_exit_platform_hw, |
| 433 | &client->dev); |
| 434 | if (err) { |
| 435 | dev_err(&client->dev, |
| 436 | "Failed to register exit_platform_hw action, %d\n", |
| 437 | err); |
| 438 | return err; |
| 439 | } |
| 440 | } |
Richard Röjfors | 75fba3b | 2009-07-24 22:01:39 -0700 | [diff] [blame] | 441 | |
Dmitry Torokhov | fd91a5f | 2013-11-19 12:52:29 -0800 | [diff] [blame] | 442 | if (pdata->init_platform_hw) |
| 443 | pdata->init_platform_hw(); |
| 444 | } |
| 445 | |
| 446 | err = devm_request_threaded_irq(&client->dev, ts->irq, |
| 447 | tsc2007_hard_irq, tsc2007_soft_irq, |
| 448 | IRQF_ONESHOT, |
| 449 | client->dev.driver->name, ts); |
| 450 | if (err) { |
| 451 | dev_err(&client->dev, "Failed to request irq %d: %d\n", |
| 452 | ts->irq, err); |
| 453 | return err; |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 454 | } |
| 455 | |
Dmitry Torokhov | d3654d7 | 2011-08-25 01:05:46 -0700 | [diff] [blame] | 456 | tsc2007_stop(ts); |
Richard Röjfors | cf5f439 | 2009-08-04 22:34:10 -0700 | [diff] [blame] | 457 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 458 | err = input_register_device(input_dev); |
Dmitry Torokhov | fd91a5f | 2013-11-19 12:52:29 -0800 | [diff] [blame] | 459 | if (err) { |
| 460 | dev_err(&client->dev, |
| 461 | "Failed to register input device: %d\n", err); |
| 462 | return err; |
| 463 | } |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 464 | |
| 465 | return 0; |
| 466 | } |
| 467 | |
Márton Németh | ce7b39a | 2010-01-09 23:23:02 -0800 | [diff] [blame] | 468 | static const struct i2c_device_id tsc2007_idtable[] = { |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 469 | { "tsc2007", 0 }, |
| 470 | { } |
| 471 | }; |
| 472 | |
| 473 | MODULE_DEVICE_TABLE(i2c, tsc2007_idtable); |
| 474 | |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 475 | #ifdef CONFIG_OF |
| 476 | static const struct of_device_id tsc2007_of_match[] = { |
| 477 | { .compatible = "ti,tsc2007" }, |
| 478 | { /* sentinel */ } |
| 479 | }; |
| 480 | MODULE_DEVICE_TABLE(of, tsc2007_of_match); |
| 481 | #endif |
| 482 | |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 483 | static struct i2c_driver tsc2007_driver = { |
| 484 | .driver = { |
Denis Carikli | 07f9e5c | 2013-11-19 11:56:04 -0800 | [diff] [blame] | 485 | .name = "tsc2007", |
| 486 | .of_match_table = of_match_ptr(tsc2007_of_match), |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 487 | }, |
| 488 | .id_table = tsc2007_idtable, |
| 489 | .probe = tsc2007_probe, |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 490 | }; |
| 491 | |
Axel Lin | 1b92c1c | 2012-03-16 23:05:41 -0700 | [diff] [blame] | 492 | module_i2c_driver(tsc2007_driver); |
Kwangwoo Lee | 50b6f1f | 2008-12-20 04:26:01 -0500 | [diff] [blame] | 493 | |
| 494 | MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>"); |
| 495 | MODULE_DESCRIPTION("TSC2007 TouchScreen Driver"); |
| 496 | MODULE_LICENSE("GPL"); |