Commit | Line | Data |
---|---|---|
50b6f1f4 KL |
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> | |
50b6f1f4 KL |
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> | |
29 | ||
50b6f1f4 KL |
30 | #define TSC2007_MEASURE_TEMP0 (0x0 << 4) |
31 | #define TSC2007_MEASURE_AUX (0x2 << 4) | |
32 | #define TSC2007_MEASURE_TEMP1 (0x4 << 4) | |
33 | #define TSC2007_ACTIVATE_XN (0x8 << 4) | |
34 | #define TSC2007_ACTIVATE_YN (0x9 << 4) | |
35 | #define TSC2007_ACTIVATE_YP_XN (0xa << 4) | |
36 | #define TSC2007_SETUP (0xb << 4) | |
37 | #define TSC2007_MEASURE_X (0xc << 4) | |
38 | #define TSC2007_MEASURE_Y (0xd << 4) | |
39 | #define TSC2007_MEASURE_Z1 (0xe << 4) | |
40 | #define TSC2007_MEASURE_Z2 (0xf << 4) | |
41 | ||
42 | #define TSC2007_POWER_OFF_IRQ_EN (0x0 << 2) | |
43 | #define TSC2007_ADC_ON_IRQ_DIS0 (0x1 << 2) | |
44 | #define TSC2007_ADC_OFF_IRQ_EN (0x2 << 2) | |
45 | #define TSC2007_ADC_ON_IRQ_DIS1 (0x3 << 2) | |
46 | ||
47 | #define TSC2007_12BIT (0x0 << 1) | |
48 | #define TSC2007_8BIT (0x1 << 1) | |
49 | ||
50 | #define MAX_12BIT ((1 << 12) - 1) | |
51 | ||
52 | #define ADC_ON_12BIT (TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0) | |
53 | ||
54 | #define READ_Y (ADC_ON_12BIT | TSC2007_MEASURE_Y) | |
55 | #define READ_Z1 (ADC_ON_12BIT | TSC2007_MEASURE_Z1) | |
56 | #define READ_Z2 (ADC_ON_12BIT | TSC2007_MEASURE_Z2) | |
57 | #define READ_X (ADC_ON_12BIT | TSC2007_MEASURE_X) | |
58 | #define PWRDOWN (TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN) | |
59 | ||
60 | struct ts_event { | |
61 | u16 x; | |
62 | u16 y; | |
63 | u16 z1, z2; | |
64 | }; | |
65 | ||
66 | struct tsc2007 { | |
67 | struct input_dev *input; | |
68 | char phys[32]; | |
50b6f1f4 KL |
69 | |
70 | struct i2c_client *client; | |
71 | ||
50b6f1f4 KL |
72 | u16 model; |
73 | u16 x_plate_ohms; | |
84005eb5 | 74 | u16 max_rt; |
2d137c7e | 75 | unsigned long poll_delay; |
1af38eac | 76 | unsigned long poll_period; |
50b6f1f4 | 77 | |
50b6f1f4 KL |
78 | int irq; |
79 | ||
377dc553 DT |
80 | wait_queue_head_t wait; |
81 | bool stopped; | |
82 | ||
50b6f1f4 KL |
83 | int (*get_pendown_state)(void); |
84 | void (*clear_penirq)(void); | |
85 | }; | |
86 | ||
87 | static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd) | |
88 | { | |
89 | s32 data; | |
90 | u16 val; | |
91 | ||
92 | data = i2c_smbus_read_word_data(tsc->client, cmd); | |
93 | if (data < 0) { | |
94 | dev_err(&tsc->client->dev, "i2c io error: %d\n", data); | |
95 | return data; | |
96 | } | |
97 | ||
98 | /* The protocol and raw data format from i2c interface: | |
99 | * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P | |
100 | * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit]. | |
101 | */ | |
102 | val = swab16(data) >> 4; | |
103 | ||
104 | dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val); | |
105 | ||
106 | return val; | |
107 | } | |
108 | ||
d570e9ef | 109 | static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc) |
50b6f1f4 | 110 | { |
d570e9ef DT |
111 | /* y- still on; turn on only y+ (and ADC) */ |
112 | tc->y = tsc2007_xfer(tsc, READ_Y); | |
113 | ||
114 | /* turn y- off, x+ on, then leave in lowpower */ | |
115 | tc->x = tsc2007_xfer(tsc, READ_X); | |
116 | ||
117 | /* turn y+ off, x- on; we'll use formula #1 */ | |
118 | tc->z1 = tsc2007_xfer(tsc, READ_Z1); | |
119 | tc->z2 = tsc2007_xfer(tsc, READ_Z2); | |
120 | ||
121 | /* Prepare for next touch reading - power down ADC, enable PENIRQ */ | |
122 | tsc2007_xfer(tsc, PWRDOWN); | |
123 | } | |
50b6f1f4 | 124 | |
d570e9ef DT |
125 | static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc) |
126 | { | |
127 | u32 rt = 0; | |
50b6f1f4 KL |
128 | |
129 | /* range filtering */ | |
d570e9ef DT |
130 | if (tc->x == MAX_12BIT) |
131 | tc->x = 0; | |
50b6f1f4 | 132 | |
d570e9ef | 133 | if (likely(tc->x && tc->z1)) { |
50b6f1f4 | 134 | /* compute touch pressure resistance using equation #1 */ |
d570e9ef DT |
135 | rt = tc->z2 - tc->z1; |
136 | rt *= tc->x; | |
137 | rt *= tsc->x_plate_ohms; | |
138 | rt /= tc->z1; | |
50b6f1f4 | 139 | rt = (rt + 2047) >> 12; |
50b6f1f4 KL |
140 | } |
141 | ||
d570e9ef DT |
142 | return rt; |
143 | } | |
144 | ||
377dc553 | 145 | static bool tsc2007_is_pen_down(struct tsc2007 *ts) |
d570e9ef | 146 | { |
141586bc DT |
147 | /* |
148 | * NOTE: We can't rely on the pressure to determine the pen down | |
d570e9ef DT |
149 | * state, even though this controller has a pressure sensor. |
150 | * The pressure value can fluctuate for quite a while after | |
151 | * lifting the pen and in some cases may not even settle at the | |
152 | * expected value. | |
50b6f1f4 KL |
153 | * |
154 | * The only safe way to check for the pen up condition is in the | |
d570e9ef DT |
155 | * work function by reading the pen signal state (it's a GPIO |
156 | * and IRQ). Unfortunately such callback is not always available, | |
377dc553 DT |
157 | * in that case we assume that the pen is down and expect caller |
158 | * to fall back on the pressure reading. | |
50b6f1f4 | 159 | */ |
d570e9ef | 160 | |
377dc553 DT |
161 | if (!ts->get_pendown_state) |
162 | return true; | |
d570e9ef | 163 | |
377dc553 DT |
164 | return ts->get_pendown_state(); |
165 | } | |
d570e9ef | 166 | |
377dc553 DT |
167 | static irqreturn_t tsc2007_soft_irq(int irq, void *handle) |
168 | { | |
169 | struct tsc2007 *ts = handle; | |
170 | struct input_dev *input = ts->input; | |
171 | struct ts_event tc; | |
172 | u32 rt; | |
d570e9ef | 173 | |
377dc553 DT |
174 | while (!ts->stopped && tsc2007_is_pen_down(ts)) { |
175 | ||
176 | /* pen is down, continue with the measurement */ | |
177 | tsc2007_read_values(ts, &tc); | |
d570e9ef | 178 | |
377dc553 | 179 | rt = tsc2007_calculate_pressure(ts, &tc); |
50b6f1f4 | 180 | |
377dc553 DT |
181 | if (rt == 0 && !ts->get_pendown_state) { |
182 | /* | |
183 | * If pressure reported is 0 and we don't have | |
184 | * callback to check pendown state, we have to | |
185 | * assume that pen was lifted up. | |
186 | */ | |
187 | break; | |
188 | } | |
189 | ||
190 | if (rt <= ts->max_rt) { | |
191 | dev_dbg(&ts->client->dev, | |
192 | "DOWN point(%4d,%4d), pressure (%4u)\n", | |
193 | tc.x, tc.y, rt); | |
50b6f1f4 KL |
194 | |
195 | input_report_key(input, BTN_TOUCH, 1); | |
377dc553 DT |
196 | input_report_abs(input, ABS_X, tc.x); |
197 | input_report_abs(input, ABS_Y, tc.y); | |
198 | input_report_abs(input, ABS_PRESSURE, rt); | |
199 | ||
200 | input_sync(input); | |
201 | ||
202 | } else { | |
203 | /* | |
204 | * Sample found inconsistent by debouncing or pressure is | |
205 | * beyond the maximum. Don't report it to user space, | |
206 | * repeat at least once more the measurement. | |
207 | */ | |
208 | dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt); | |
50b6f1f4 KL |
209 | } |
210 | ||
377dc553 DT |
211 | wait_event_timeout(ts->wait, ts->stopped, |
212 | msecs_to_jiffies(ts->poll_period)); | |
213 | } | |
50b6f1f4 | 214 | |
377dc553 | 215 | dev_dbg(&ts->client->dev, "UP\n"); |
50b6f1f4 | 216 | |
377dc553 DT |
217 | input_report_key(input, BTN_TOUCH, 0); |
218 | input_report_abs(input, ABS_PRESSURE, 0); | |
219 | input_sync(input); | |
50b6f1f4 | 220 | |
377dc553 DT |
221 | if (ts->clear_penirq) |
222 | ts->clear_penirq(); | |
141586bc | 223 | |
377dc553 | 224 | return IRQ_HANDLED; |
50b6f1f4 KL |
225 | } |
226 | ||
377dc553 | 227 | static irqreturn_t tsc2007_hard_irq(int irq, void *handle) |
50b6f1f4 KL |
228 | { |
229 | struct tsc2007 *ts = handle; | |
50b6f1f4 | 230 | |
377dc553 DT |
231 | if (!ts->get_pendown_state || likely(ts->get_pendown_state())) |
232 | return IRQ_WAKE_THREAD; | |
50b6f1f4 KL |
233 | |
234 | if (ts->clear_penirq) | |
235 | ts->clear_penirq(); | |
236 | ||
50b6f1f4 KL |
237 | return IRQ_HANDLED; |
238 | } | |
239 | ||
d3654d7e | 240 | static void tsc2007_stop(struct tsc2007 *ts) |
141586bc | 241 | { |
377dc553 DT |
242 | ts->stopped = true; |
243 | mb(); | |
244 | wake_up(&ts->wait); | |
d3654d7e DT |
245 | |
246 | disable_irq(ts->irq); | |
247 | } | |
248 | ||
249 | static int tsc2007_open(struct input_dev *input_dev) | |
250 | { | |
251 | struct tsc2007 *ts = input_get_drvdata(input_dev); | |
252 | int err; | |
253 | ||
254 | ts->stopped = false; | |
255 | mb(); | |
256 | ||
257 | enable_irq(ts->irq); | |
258 | ||
259 | /* Prepare for touch readings - power down ADC and enable PENIRQ */ | |
260 | err = tsc2007_xfer(ts, PWRDOWN); | |
261 | if (err < 0) { | |
262 | tsc2007_stop(ts); | |
263 | return err; | |
264 | } | |
265 | ||
266 | return 0; | |
267 | } | |
268 | ||
269 | static void tsc2007_close(struct input_dev *input_dev) | |
270 | { | |
271 | struct tsc2007 *ts = input_get_drvdata(input_dev); | |
272 | ||
273 | tsc2007_stop(ts); | |
141586bc DT |
274 | } |
275 | ||
276 | static int __devinit tsc2007_probe(struct i2c_client *client, | |
277 | const struct i2c_device_id *id) | |
50b6f1f4 KL |
278 | { |
279 | struct tsc2007 *ts; | |
b496acb7 | 280 | struct tsc2007_platform_data *pdata = client->dev.platform_data; |
50b6f1f4 KL |
281 | struct input_dev *input_dev; |
282 | int err; | |
283 | ||
d570e9ef | 284 | if (!pdata) { |
50b6f1f4 KL |
285 | dev_err(&client->dev, "platform data is required!\n"); |
286 | return -EINVAL; | |
287 | } | |
288 | ||
289 | if (!i2c_check_functionality(client->adapter, | |
290 | I2C_FUNC_SMBUS_READ_WORD_DATA)) | |
291 | return -EIO; | |
292 | ||
293 | ts = kzalloc(sizeof(struct tsc2007), GFP_KERNEL); | |
294 | input_dev = input_allocate_device(); | |
295 | if (!ts || !input_dev) { | |
296 | err = -ENOMEM; | |
297 | goto err_free_mem; | |
298 | } | |
299 | ||
300 | ts->client = client; | |
141586bc | 301 | ts->irq = client->irq; |
50b6f1f4 | 302 | ts->input = input_dev; |
377dc553 | 303 | init_waitqueue_head(&ts->wait); |
50b6f1f4 | 304 | |
50b6f1f4 KL |
305 | ts->model = pdata->model; |
306 | ts->x_plate_ohms = pdata->x_plate_ohms; | |
84005eb5 | 307 | ts->max_rt = pdata->max_rt ? : MAX_12BIT; |
2d137c7e | 308 | ts->poll_delay = pdata->poll_delay ? : 1; |
1af38eac | 309 | ts->poll_period = pdata->poll_period ? : 1; |
50b6f1f4 KL |
310 | ts->get_pendown_state = pdata->get_pendown_state; |
311 | ts->clear_penirq = pdata->clear_penirq; | |
312 | ||
341deefe PR |
313 | if (pdata->x_plate_ohms == 0) { |
314 | dev_err(&client->dev, "x_plate_ohms is not set up in platform data"); | |
315 | err = -EINVAL; | |
316 | goto err_free_mem; | |
317 | } | |
318 | ||
4e8718a1 KS |
319 | snprintf(ts->phys, sizeof(ts->phys), |
320 | "%s/input0", dev_name(&client->dev)); | |
50b6f1f4 KL |
321 | |
322 | input_dev->name = "TSC2007 Touchscreen"; | |
323 | input_dev->phys = ts->phys; | |
324 | input_dev->id.bustype = BUS_I2C; | |
325 | ||
d3654d7e DT |
326 | input_dev->open = tsc2007_open; |
327 | input_dev->close = tsc2007_close; | |
328 | ||
329 | input_set_drvdata(input_dev, ts); | |
330 | ||
50b6f1f4 KL |
331 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); |
332 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
333 | ||
891e376b TR |
334 | input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, pdata->fuzzx, 0); |
335 | input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, pdata->fuzzy, 0); | |
336 | input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, | |
337 | pdata->fuzzz, 0); | |
50b6f1f4 | 338 | |
cad065fd RR |
339 | if (pdata->init_platform_hw) |
340 | pdata->init_platform_hw(); | |
75fba3b0 | 341 | |
377dc553 DT |
342 | err = request_threaded_irq(ts->irq, tsc2007_hard_irq, tsc2007_soft_irq, |
343 | IRQF_ONESHOT, client->dev.driver->name, ts); | |
50b6f1f4 KL |
344 | if (err < 0) { |
345 | dev_err(&client->dev, "irq %d busy?\n", ts->irq); | |
346 | goto err_free_mem; | |
347 | } | |
348 | ||
d3654d7e | 349 | tsc2007_stop(ts); |
cf5f439b | 350 | |
50b6f1f4 KL |
351 | err = input_register_device(input_dev); |
352 | if (err) | |
353 | goto err_free_irq; | |
354 | ||
141586bc DT |
355 | i2c_set_clientdata(client, ts); |
356 | ||
50b6f1f4 KL |
357 | return 0; |
358 | ||
359 | err_free_irq: | |
d3654d7e | 360 | free_irq(ts->irq, ts); |
cad065fd RR |
361 | if (pdata->exit_platform_hw) |
362 | pdata->exit_platform_hw(); | |
50b6f1f4 KL |
363 | err_free_mem: |
364 | input_free_device(input_dev); | |
365 | kfree(ts); | |
366 | return err; | |
367 | } | |
368 | ||
141586bc | 369 | static int __devexit tsc2007_remove(struct i2c_client *client) |
50b6f1f4 KL |
370 | { |
371 | struct tsc2007 *ts = i2c_get_clientdata(client); | |
141586bc | 372 | struct tsc2007_platform_data *pdata = client->dev.platform_data; |
50b6f1f4 | 373 | |
d3654d7e | 374 | free_irq(ts->irq, ts); |
75fba3b0 | 375 | |
cad065fd RR |
376 | if (pdata->exit_platform_hw) |
377 | pdata->exit_platform_hw(); | |
50b6f1f4 | 378 | |
50b6f1f4 KL |
379 | input_unregister_device(ts->input); |
380 | kfree(ts); | |
381 | ||
382 | return 0; | |
383 | } | |
384 | ||
ce7b39a1 | 385 | static const struct i2c_device_id tsc2007_idtable[] = { |
50b6f1f4 KL |
386 | { "tsc2007", 0 }, |
387 | { } | |
388 | }; | |
389 | ||
390 | MODULE_DEVICE_TABLE(i2c, tsc2007_idtable); | |
391 | ||
392 | static struct i2c_driver tsc2007_driver = { | |
393 | .driver = { | |
394 | .owner = THIS_MODULE, | |
395 | .name = "tsc2007" | |
396 | }, | |
397 | .id_table = tsc2007_idtable, | |
398 | .probe = tsc2007_probe, | |
1cb0aa88 | 399 | .remove = tsc2007_remove, |
50b6f1f4 KL |
400 | }; |
401 | ||
1b92c1cf | 402 | module_i2c_driver(tsc2007_driver); |
50b6f1f4 KL |
403 | |
404 | MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>"); | |
405 | MODULE_DESCRIPTION("TSC2007 TouchScreen Driver"); | |
406 | MODULE_LICENSE("GPL"); |