Root/
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> |
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 | |
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]; |
69 | |
70 | struct i2c_client *client; |
71 | |
72 | u16 model; |
73 | u16 x_plate_ohms; |
74 | u16 max_rt; |
75 | unsigned long poll_delay; |
76 | unsigned long poll_period; |
77 | |
78 | int irq; |
79 | |
80 | wait_queue_head_t wait; |
81 | bool stopped; |
82 | |
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 | |
109 | static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc) |
110 | { |
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 | } |
124 | |
125 | static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc) |
126 | { |
127 | u32 rt = 0; |
128 | |
129 | /* range filtering */ |
130 | if (tc->x == MAX_12BIT) |
131 | tc->x = 0; |
132 | |
133 | if (likely(tc->x && tc->z1)) { |
134 | /* compute touch pressure resistance using equation #1 */ |
135 | rt = tc->z2 - tc->z1; |
136 | rt *= tc->x; |
137 | rt *= tsc->x_plate_ohms; |
138 | rt /= tc->z1; |
139 | rt = (rt + 2047) >> 12; |
140 | } |
141 | |
142 | return rt; |
143 | } |
144 | |
145 | static bool tsc2007_is_pen_down(struct tsc2007 *ts) |
146 | { |
147 | /* |
148 | * NOTE: We can't rely on the pressure to determine the pen down |
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. |
153 | * |
154 | * The only safe way to check for the pen up condition is in the |
155 | * work function by reading the pen signal state (it's a GPIO |
156 | * and IRQ). Unfortunately such callback is not always available, |
157 | * in that case we assume that the pen is down and expect caller |
158 | * to fall back on the pressure reading. |
159 | */ |
160 | |
161 | if (!ts->get_pendown_state) |
162 | return true; |
163 | |
164 | return ts->get_pendown_state(); |
165 | } |
166 | |
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; |
173 | |
174 | while (!ts->stopped && tsc2007_is_pen_down(ts)) { |
175 | |
176 | /* pen is down, continue with the measurement */ |
177 | tsc2007_read_values(ts, &tc); |
178 | |
179 | rt = tsc2007_calculate_pressure(ts, &tc); |
180 | |
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); |
194 | |
195 | input_report_key(input, BTN_TOUCH, 1); |
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); |
209 | } |
210 | |
211 | wait_event_timeout(ts->wait, ts->stopped, |
212 | msecs_to_jiffies(ts->poll_period)); |
213 | } |
214 | |
215 | dev_dbg(&ts->client->dev, "UP\n"); |
216 | |
217 | input_report_key(input, BTN_TOUCH, 0); |
218 | input_report_abs(input, ABS_PRESSURE, 0); |
219 | input_sync(input); |
220 | |
221 | if (ts->clear_penirq) |
222 | ts->clear_penirq(); |
223 | |
224 | return IRQ_HANDLED; |
225 | } |
226 | |
227 | static irqreturn_t tsc2007_hard_irq(int irq, void *handle) |
228 | { |
229 | struct tsc2007 *ts = handle; |
230 | |
231 | if (!ts->get_pendown_state || likely(ts->get_pendown_state())) |
232 | return IRQ_WAKE_THREAD; |
233 | |
234 | if (ts->clear_penirq) |
235 | ts->clear_penirq(); |
236 | |
237 | return IRQ_HANDLED; |
238 | } |
239 | |
240 | static void tsc2007_stop(struct tsc2007 *ts) |
241 | { |
242 | ts->stopped = true; |
243 | mb(); |
244 | wake_up(&ts->wait); |
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); |
274 | } |
275 | |
276 | static int tsc2007_probe(struct i2c_client *client, |
277 | const struct i2c_device_id *id) |
278 | { |
279 | struct tsc2007 *ts; |
280 | struct tsc2007_platform_data *pdata = client->dev.platform_data; |
281 | struct input_dev *input_dev; |
282 | int err; |
283 | |
284 | if (!pdata) { |
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; |
301 | ts->irq = client->irq; |
302 | ts->input = input_dev; |
303 | init_waitqueue_head(&ts->wait); |
304 | |
305 | ts->model = pdata->model; |
306 | ts->x_plate_ohms = pdata->x_plate_ohms; |
307 | ts->max_rt = pdata->max_rt ? : MAX_12BIT; |
308 | ts->poll_delay = pdata->poll_delay ? : 1; |
309 | ts->poll_period = pdata->poll_period ? : 1; |
310 | ts->get_pendown_state = pdata->get_pendown_state; |
311 | ts->clear_penirq = pdata->clear_penirq; |
312 | |
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 | |
319 | snprintf(ts->phys, sizeof(ts->phys), |
320 | "%s/input0", dev_name(&client->dev)); |
321 | |
322 | input_dev->name = "TSC2007 Touchscreen"; |
323 | input_dev->phys = ts->phys; |
324 | input_dev->id.bustype = BUS_I2C; |
325 | |
326 | input_dev->open = tsc2007_open; |
327 | input_dev->close = tsc2007_close; |
328 | |
329 | input_set_drvdata(input_dev, ts); |
330 | |
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 | |
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); |
338 | |
339 | if (pdata->init_platform_hw) |
340 | pdata->init_platform_hw(); |
341 | |
342 | err = request_threaded_irq(ts->irq, tsc2007_hard_irq, tsc2007_soft_irq, |
343 | IRQF_ONESHOT, client->dev.driver->name, ts); |
344 | if (err < 0) { |
345 | dev_err(&client->dev, "irq %d busy?\n", ts->irq); |
346 | goto err_free_mem; |
347 | } |
348 | |
349 | tsc2007_stop(ts); |
350 | |
351 | err = input_register_device(input_dev); |
352 | if (err) |
353 | goto err_free_irq; |
354 | |
355 | i2c_set_clientdata(client, ts); |
356 | |
357 | return 0; |
358 | |
359 | err_free_irq: |
360 | free_irq(ts->irq, ts); |
361 | if (pdata->exit_platform_hw) |
362 | pdata->exit_platform_hw(); |
363 | err_free_mem: |
364 | input_free_device(input_dev); |
365 | kfree(ts); |
366 | return err; |
367 | } |
368 | |
369 | static int tsc2007_remove(struct i2c_client *client) |
370 | { |
371 | struct tsc2007 *ts = i2c_get_clientdata(client); |
372 | struct tsc2007_platform_data *pdata = client->dev.platform_data; |
373 | |
374 | free_irq(ts->irq, ts); |
375 | |
376 | if (pdata->exit_platform_hw) |
377 | pdata->exit_platform_hw(); |
378 | |
379 | input_unregister_device(ts->input); |
380 | kfree(ts); |
381 | |
382 | return 0; |
383 | } |
384 | |
385 | static const struct i2c_device_id tsc2007_idtable[] = { |
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, |
399 | .remove = tsc2007_remove, |
400 | }; |
401 | |
402 | module_i2c_driver(tsc2007_driver); |
403 | |
404 | MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>"); |
405 | MODULE_DESCRIPTION("TSC2007 TouchScreen Driver"); |
406 | MODULE_LICENSE("GPL"); |
407 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9