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