Commit | Line | Data |
---|---|---|
ffa458c1 DB |
1 | /* |
2 | * ADS7846 based touchscreen and sensor driver | |
3 | * | |
4 | * Copyright (c) 2005 David Brownell | |
7de90a8c ID |
5 | * Copyright (c) 2006 Nokia Corporation |
6 | * Various changes: Imre Deak <imre.deak@nokia.com> | |
ffa458c1 DB |
7 | * |
8 | * Using code from: | |
9 | * - corgi_ts.c | |
10 | * Copyright (C) 2004-2005 Richard Purdie | |
11 | * - omap_ts.[hc], ads7846.h, ts_osk.c | |
12 | * Copyright (C) 2002 MontaVista Software | |
13 | * Copyright (C) 2004 Texas Instruments | |
14 | * Copyright (C) 2005 Dirk Behme | |
15 | * | |
16 | * This program is free software; you can redistribute it and/or modify | |
17 | * it under the terms of the GNU General Public License version 2 as | |
18 | * published by the Free Software Foundation. | |
19 | */ | |
2991a1ca | 20 | #include <linux/types.h> |
2c8dc071 | 21 | #include <linux/hwmon.h> |
ffa458c1 | 22 | #include <linux/init.h> |
2c8dc071 | 23 | #include <linux/err.h> |
2991a1ca | 24 | #include <linux/sched.h> |
ffa458c1 DB |
25 | #include <linux/delay.h> |
26 | #include <linux/input.h> | |
27 | #include <linux/interrupt.h> | |
28 | #include <linux/slab.h> | |
4d5975e5 | 29 | #include <linux/gpio.h> |
ffa458c1 DB |
30 | #include <linux/spi/spi.h> |
31 | #include <linux/spi/ads7846.h> | |
91143379 | 32 | #include <linux/regulator/consumer.h> |
3ac8bf07 | 33 | #include <asm/irq.h> |
ffa458c1 | 34 | |
ffa458c1 | 35 | /* |
9084533e | 36 | * This code has been heavily tested on a Nokia 770, and lightly |
52ce4eaa | 37 | * tested on other ads7846 devices (OSK/Mistral, Lubbock, Spitz). |
bff0de5f | 38 | * TSC2046 is just newer ads7846 silicon. |
969111e9 NF |
39 | * Support for ads7843 tested on Atmel at91sam926x-EK. |
40 | * Support for ads7845 has only been stubbed in. | |
06a09124 | 41 | * Support for Analog Devices AD7873 and AD7843 tested. |
ffa458c1 | 42 | * |
7de90a8c ID |
43 | * IRQ handling needs a workaround because of a shortcoming in handling |
44 | * edge triggered IRQs on some platforms like the OMAP1/2. These | |
45 | * platforms don't handle the ARM lazy IRQ disabling properly, thus we | |
46 | * have to maintain our own SW IRQ disabled status. This should be | |
47 | * removed as soon as the affected platform's IRQ handling is fixed. | |
48 | * | |
52ce4eaa | 49 | * App note sbaa036 talks in more detail about accurate sampling... |
ffa458c1 DB |
50 | * that ought to help in situations like LCDs inducing noise (which |
51 | * can also be helped by using synch signals) and more generally. | |
7de90a8c ID |
52 | * This driver tries to utilize the measures described in the app |
53 | * note. The strength of filtering can be set in the board-* specific | |
54 | * files. | |
ffa458c1 DB |
55 | */ |
56 | ||
2991a1ca JW |
57 | #define TS_POLL_DELAY 1 /* ms delay before the first sample */ |
58 | #define TS_POLL_PERIOD 5 /* ms delay between samples */ | |
ffa458c1 | 59 | |
d93f70b2 DB |
60 | /* this driver doesn't aim at the peak continuous sample rate */ |
61 | #define SAMPLE_BITS (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */) | |
62 | ||
ffa458c1 | 63 | struct ts_event { |
2991a1ca JW |
64 | /* |
65 | * For portability, we can't read 12 bit values using SPI (which | |
66 | * would make the controller deliver them as native byte order u16 | |
d93f70b2 | 67 | * with msbs zeroed). Instead, we read them as two 8-bit values, |
da970e69 | 68 | * *** WHICH NEED BYTESWAPPING *** and range adjustment. |
ffa458c1 | 69 | */ |
da970e69 ID |
70 | u16 x; |
71 | u16 y; | |
72 | u16 z1, z2; | |
2991a1ca | 73 | bool ignore; |
3eac5c7e AG |
74 | u8 x_buf[3]; |
75 | u8 y_buf[3]; | |
ffa458c1 DB |
76 | }; |
77 | ||
e8f462d2 DT |
78 | /* |
79 | * We allocate this separately to avoid cache line sharing issues when | |
80 | * driver is used with DMA-based SPI controllers (like atmel_spi) on | |
81 | * systems where main memory is not DMA-coherent (most non-x86 boards). | |
82 | */ | |
83 | struct ads7846_packet { | |
84 | u8 read_x, read_y, read_z1, read_z2, pwrdown; | |
85 | u16 dummy; /* for the pwrdown read */ | |
86 | struct ts_event tc; | |
3eac5c7e AG |
87 | /* for ads7845 with mpc5121 psc spi we use 3-byte buffers */ |
88 | u8 read_x_cmd[3], read_y_cmd[3], pwrdown_cmd[3]; | |
e8f462d2 DT |
89 | }; |
90 | ||
ffa458c1 | 91 | struct ads7846 { |
a90f7e98 | 92 | struct input_dev *input; |
ffa458c1 | 93 | char phys[32]; |
b58895f8 | 94 | char name[32]; |
ffa458c1 DB |
95 | |
96 | struct spi_device *spi; | |
91143379 | 97 | struct regulator *reg; |
2c8dc071 DB |
98 | |
99 | #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE) | |
8dd51650 | 100 | struct attribute_group *attr_group; |
1beeffe4 | 101 | struct device *hwmon; |
2c8dc071 DB |
102 | #endif |
103 | ||
ffa458c1 | 104 | u16 model; |
7c6d0ee1 | 105 | u16 vref_mv; |
ffa458c1 DB |
106 | u16 vref_delay_usecs; |
107 | u16 x_plate_ohms; | |
d5b415c9 | 108 | u16 pressure_max; |
ffa458c1 | 109 | |
86579a4c MR |
110 | bool swap_xy; |
111 | ||
e8f462d2 | 112 | struct ads7846_packet *packet; |
ffa458c1 | 113 | |
e4f48861 | 114 | struct spi_transfer xfer[18]; |
0b7018aa | 115 | struct spi_message msg[5]; |
2991a1ca JW |
116 | int msg_count; |
117 | wait_queue_head_t wait; | |
118 | ||
119 | bool pendown; | |
120 | ||
0b7018aa | 121 | int read_cnt; |
d5b415c9 | 122 | int read_rep; |
0b7018aa ID |
123 | int last_read; |
124 | ||
125 | u16 debounce_max; | |
126 | u16 debounce_tol; | |
d5b415c9 | 127 | u16 debounce_rep; |
ffa458c1 | 128 | |
1d25891f SH |
129 | u16 penirq_recheck_delay_usecs; |
130 | ||
2991a1ca JW |
131 | struct mutex lock; |
132 | bool stopped; /* P: lock */ | |
133 | bool disabled; /* P: lock */ | |
134 | bool suspended; /* P: lock */ | |
c9e617a5 | 135 | |
da970e69 ID |
136 | int (*filter)(void *data, int data_idx, int *val); |
137 | void *filter_data; | |
138 | void (*filter_cleanup)(void *data); | |
c9e617a5 | 139 | int (*get_pendown_state)(void); |
4d5975e5 | 140 | int gpio_pendown; |
fd746d54 EM |
141 | |
142 | void (*wait_for_sync)(void); | |
ffa458c1 DB |
143 | }; |
144 | ||
145 | /* leave chip selected when we're done, for quicker re-select? */ | |
146 | #if 0 | |
147 | #define CS_CHANGE(xfer) ((xfer).cs_change = 1) | |
148 | #else | |
149 | #define CS_CHANGE(xfer) ((xfer).cs_change = 0) | |
150 | #endif | |
151 | ||
152 | /*--------------------------------------------------------------------------*/ | |
153 | ||
154 | /* The ADS7846 has touchscreen and other sensors. | |
155 | * Earlier ads784x chips are somewhat compatible. | |
156 | */ | |
157 | #define ADS_START (1 << 7) | |
158 | #define ADS_A2A1A0_d_y (1 << 4) /* differential */ | |
159 | #define ADS_A2A1A0_d_z1 (3 << 4) /* differential */ | |
160 | #define ADS_A2A1A0_d_z2 (4 << 4) /* differential */ | |
161 | #define ADS_A2A1A0_d_x (5 << 4) /* differential */ | |
162 | #define ADS_A2A1A0_temp0 (0 << 4) /* non-differential */ | |
163 | #define ADS_A2A1A0_vbatt (2 << 4) /* non-differential */ | |
164 | #define ADS_A2A1A0_vaux (6 << 4) /* non-differential */ | |
165 | #define ADS_A2A1A0_temp1 (7 << 4) /* non-differential */ | |
166 | #define ADS_8_BIT (1 << 3) | |
167 | #define ADS_12_BIT (0 << 3) | |
168 | #define ADS_SER (1 << 2) /* non-differential */ | |
169 | #define ADS_DFR (0 << 2) /* differential */ | |
2991a1ca | 170 | #define ADS_PD10_PDOWN (0 << 0) /* low power mode + penirq */ |
ffa458c1 DB |
171 | #define ADS_PD10_ADC_ON (1 << 0) /* ADC on */ |
172 | #define ADS_PD10_REF_ON (2 << 0) /* vREF on + penirq */ | |
173 | #define ADS_PD10_ALL_ON (3 << 0) /* ADC + vREF on */ | |
174 | ||
175 | #define MAX_12BIT ((1<<12)-1) | |
176 | ||
177 | /* leave ADC powered up (disables penirq) between differential samples */ | |
de2defd9 ID |
178 | #define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \ |
179 | | ADS_12_BIT | ADS_DFR | \ | |
180 | (adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0)) | |
ffa458c1 | 181 | |
de2defd9 ID |
182 | #define READ_Y(vref) (READ_12BIT_DFR(y, 1, vref)) |
183 | #define READ_Z1(vref) (READ_12BIT_DFR(z1, 1, vref)) | |
184 | #define READ_Z2(vref) (READ_12BIT_DFR(z2, 1, vref)) | |
53a0ef89 | 185 | |
de2defd9 ID |
186 | #define READ_X(vref) (READ_12BIT_DFR(x, 1, vref)) |
187 | #define PWRDOWN (READ_12BIT_DFR(y, 0, 0)) /* LAST */ | |
ffa458c1 DB |
188 | |
189 | /* single-ended samples need to first power up reference voltage; | |
190 | * we leave both ADC and VREF powered | |
191 | */ | |
192 | #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \ | |
193 | | ADS_12_BIT | ADS_SER) | |
194 | ||
de2defd9 ID |
195 | #define REF_ON (READ_12BIT_DFR(x, 1, 1)) |
196 | #define REF_OFF (READ_12BIT_DFR(y, 0, 0)) | |
ffa458c1 | 197 | |
2991a1ca JW |
198 | /* Must be called with ts->lock held */ |
199 | static void ads7846_stop(struct ads7846 *ts) | |
200 | { | |
201 | if (!ts->disabled && !ts->suspended) { | |
202 | /* Signal IRQ thread to stop polling and disable the handler. */ | |
203 | ts->stopped = true; | |
204 | mb(); | |
205 | wake_up(&ts->wait); | |
206 | disable_irq(ts->spi->irq); | |
207 | } | |
208 | } | |
209 | ||
210 | /* Must be called with ts->lock held */ | |
211 | static void ads7846_restart(struct ads7846 *ts) | |
212 | { | |
213 | if (!ts->disabled && !ts->suspended) { | |
214 | /* Tell IRQ thread that it may poll the device. */ | |
215 | ts->stopped = false; | |
216 | mb(); | |
217 | enable_irq(ts->spi->irq); | |
218 | } | |
219 | } | |
220 | ||
221 | /* Must be called with ts->lock held */ | |
222 | static void __ads7846_disable(struct ads7846 *ts) | |
223 | { | |
224 | ads7846_stop(ts); | |
225 | regulator_disable(ts->reg); | |
226 | ||
227 | /* | |
228 | * We know the chip's in low power mode since we always | |
229 | * leave it that way after every request | |
230 | */ | |
231 | } | |
232 | ||
233 | /* Must be called with ts->lock held */ | |
234 | static void __ads7846_enable(struct ads7846 *ts) | |
235 | { | |
236 | regulator_enable(ts->reg); | |
237 | ads7846_restart(ts); | |
238 | } | |
239 | ||
240 | static void ads7846_disable(struct ads7846 *ts) | |
241 | { | |
242 | mutex_lock(&ts->lock); | |
243 | ||
244 | if (!ts->disabled) { | |
245 | ||
246 | if (!ts->suspended) | |
247 | __ads7846_disable(ts); | |
248 | ||
249 | ts->disabled = true; | |
250 | } | |
251 | ||
252 | mutex_unlock(&ts->lock); | |
253 | } | |
254 | ||
255 | static void ads7846_enable(struct ads7846 *ts) | |
256 | { | |
257 | mutex_lock(&ts->lock); | |
258 | ||
259 | if (ts->disabled) { | |
260 | ||
261 | ts->disabled = false; | |
262 | ||
263 | if (!ts->suspended) | |
264 | __ads7846_enable(ts); | |
265 | } | |
266 | ||
267 | mutex_unlock(&ts->lock); | |
268 | } | |
269 | ||
ffa458c1 DB |
270 | /*--------------------------------------------------------------------------*/ |
271 | ||
272 | /* | |
273 | * Non-touchscreen sensors only use single-ended conversions. | |
2c8dc071 DB |
274 | * The range is GND..vREF. The ads7843 and ads7835 must use external vREF; |
275 | * ads7846 lets that pin be unconnected, to use internal vREF. | |
ffa458c1 DB |
276 | */ |
277 | ||
278 | struct ser_req { | |
d93f70b2 | 279 | u8 ref_on; |
ffa458c1 | 280 | u8 command; |
d93f70b2 | 281 | u8 ref_off; |
ffa458c1 DB |
282 | u16 scratch; |
283 | __be16 sample; | |
284 | struct spi_message msg; | |
285 | struct spi_transfer xfer[6]; | |
286 | }; | |
287 | ||
3eac5c7e AG |
288 | struct ads7845_ser_req { |
289 | u8 command[3]; | |
290 | u8 pwrdown[3]; | |
291 | u8 sample[3]; | |
292 | struct spi_message msg; | |
293 | struct spi_transfer xfer[2]; | |
294 | }; | |
295 | ||
ffa458c1 DB |
296 | static int ads7846_read12_ser(struct device *dev, unsigned command) |
297 | { | |
2991a1ca JW |
298 | struct spi_device *spi = to_spi_device(dev); |
299 | struct ads7846 *ts = dev_get_drvdata(dev); | |
300 | struct ser_req *req; | |
301 | int status; | |
302 | int use_internal; | |
ffa458c1 | 303 | |
2991a1ca | 304 | req = kzalloc(sizeof *req, GFP_KERNEL); |
ffa458c1 DB |
305 | if (!req) |
306 | return -ENOMEM; | |
307 | ||
0b7018aa | 308 | spi_message_init(&req->msg); |
8275c642 | 309 | |
2c8dc071 DB |
310 | /* FIXME boards with ads7846 might use external vref instead ... */ |
311 | use_internal = (ts->model == 7846); | |
312 | ||
313 | /* maybe turn on internal vREF, and let it settle */ | |
314 | if (use_internal) { | |
315 | req->ref_on = REF_ON; | |
316 | req->xfer[0].tx_buf = &req->ref_on; | |
317 | req->xfer[0].len = 1; | |
318 | spi_message_add_tail(&req->xfer[0], &req->msg); | |
319 | ||
320 | req->xfer[1].rx_buf = &req->scratch; | |
321 | req->xfer[1].len = 2; | |
322 | ||
323 | /* for 1uF, settle for 800 usec; no cap, 100 usec. */ | |
324 | req->xfer[1].delay_usecs = ts->vref_delay_usecs; | |
325 | spi_message_add_tail(&req->xfer[1], &req->msg); | |
326 | } | |
ffa458c1 DB |
327 | |
328 | /* take sample */ | |
329 | req->command = (u8) command; | |
330 | req->xfer[2].tx_buf = &req->command; | |
331 | req->xfer[2].len = 1; | |
2c8dc071 DB |
332 | spi_message_add_tail(&req->xfer[2], &req->msg); |
333 | ||
ffa458c1 DB |
334 | req->xfer[3].rx_buf = &req->sample; |
335 | req->xfer[3].len = 2; | |
2c8dc071 | 336 | spi_message_add_tail(&req->xfer[3], &req->msg); |
ffa458c1 DB |
337 | |
338 | /* REVISIT: take a few more samples, and compare ... */ | |
339 | ||
969111e9 NF |
340 | /* converter in low power mode & enable PENIRQ */ |
341 | req->ref_off = PWRDOWN; | |
342 | req->xfer[4].tx_buf = &req->ref_off; | |
343 | req->xfer[4].len = 1; | |
344 | spi_message_add_tail(&req->xfer[4], &req->msg); | |
345 | ||
346 | req->xfer[5].rx_buf = &req->scratch; | |
347 | req->xfer[5].len = 2; | |
348 | CS_CHANGE(req->xfer[5]); | |
349 | spi_message_add_tail(&req->xfer[5], &req->msg); | |
ffa458c1 | 350 | |
2991a1ca JW |
351 | mutex_lock(&ts->lock); |
352 | ads7846_stop(ts); | |
ffa458c1 | 353 | status = spi_sync(spi, &req->msg); |
2991a1ca JW |
354 | ads7846_restart(ts); |
355 | mutex_unlock(&ts->lock); | |
ffa458c1 | 356 | |
c24b2602 MP |
357 | if (status == 0) { |
358 | /* on-wire is a must-ignore bit, a BE12 value, then padding */ | |
7c6d0ee1 DB |
359 | status = be16_to_cpu(req->sample); |
360 | status = status >> 3; | |
361 | status &= 0x0fff; | |
c24b2602 | 362 | } |
ffa458c1 | 363 | |
9084533e | 364 | kfree(req); |
7c6d0ee1 | 365 | return status; |
ffa458c1 DB |
366 | } |
367 | ||
3eac5c7e AG |
368 | static int ads7845_read12_ser(struct device *dev, unsigned command) |
369 | { | |
2991a1ca JW |
370 | struct spi_device *spi = to_spi_device(dev); |
371 | struct ads7846 *ts = dev_get_drvdata(dev); | |
372 | struct ads7845_ser_req *req; | |
373 | int status; | |
3eac5c7e | 374 | |
2991a1ca | 375 | req = kzalloc(sizeof *req, GFP_KERNEL); |
3eac5c7e AG |
376 | if (!req) |
377 | return -ENOMEM; | |
378 | ||
379 | spi_message_init(&req->msg); | |
380 | ||
381 | req->command[0] = (u8) command; | |
382 | req->xfer[0].tx_buf = req->command; | |
383 | req->xfer[0].rx_buf = req->sample; | |
384 | req->xfer[0].len = 3; | |
385 | spi_message_add_tail(&req->xfer[0], &req->msg); | |
386 | ||
2991a1ca JW |
387 | mutex_lock(&ts->lock); |
388 | ads7846_stop(ts); | |
3eac5c7e | 389 | status = spi_sync(spi, &req->msg); |
2991a1ca JW |
390 | ads7846_restart(ts); |
391 | mutex_unlock(&ts->lock); | |
3eac5c7e AG |
392 | |
393 | if (status == 0) { | |
394 | /* BE12 value, then padding */ | |
395 | status = be16_to_cpu(*((u16 *)&req->sample[1])); | |
396 | status = status >> 3; | |
397 | status &= 0x0fff; | |
398 | } | |
399 | ||
400 | kfree(req); | |
401 | return status; | |
402 | } | |
403 | ||
2c8dc071 DB |
404 | #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE) |
405 | ||
406 | #define SHOW(name, var, adjust) static ssize_t \ | |
ffa458c1 DB |
407 | name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \ |
408 | { \ | |
2c8dc071 | 409 | struct ads7846 *ts = dev_get_drvdata(dev); \ |
ffa458c1 | 410 | ssize_t v = ads7846_read12_ser(dev, \ |
2c8dc071 | 411 | READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \ |
ffa458c1 DB |
412 | if (v < 0) \ |
413 | return v; \ | |
2c8dc071 | 414 | return sprintf(buf, "%u\n", adjust(ts, v)); \ |
ffa458c1 DB |
415 | } \ |
416 | static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL); | |
417 | ||
2c8dc071 | 418 | |
b731d7b6 | 419 | /* Sysfs conventions report temperatures in millidegrees Celsius. |
2c8dc071 DB |
420 | * ADS7846 could use the low-accuracy two-sample scheme, but can't do the high |
421 | * accuracy scheme without calibration data. For now we won't try either; | |
422 | * userspace sees raw sensor values, and must scale/calibrate appropriately. | |
423 | */ | |
424 | static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v) | |
425 | { | |
426 | return v; | |
427 | } | |
428 | ||
429 | SHOW(temp0, temp0, null_adjust) /* temp1_input */ | |
430 | SHOW(temp1, temp1, null_adjust) /* temp2_input */ | |
431 | ||
432 | ||
433 | /* sysfs conventions report voltages in millivolts. We can convert voltages | |
434 | * if we know vREF. userspace may need to scale vAUX to match the board's | |
435 | * external resistors; we assume that vBATT only uses the internal ones. | |
436 | */ | |
437 | static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v) | |
438 | { | |
439 | unsigned retval = v; | |
440 | ||
441 | /* external resistors may scale vAUX into 0..vREF */ | |
7c6d0ee1 | 442 | retval *= ts->vref_mv; |
2c8dc071 | 443 | retval = retval >> 12; |
2991a1ca | 444 | |
2c8dc071 DB |
445 | return retval; |
446 | } | |
447 | ||
448 | static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v) | |
449 | { | |
450 | unsigned retval = vaux_adjust(ts, v); | |
451 | ||
452 | /* ads7846 has a resistor ladder to scale this signal down */ | |
453 | if (ts->model == 7846) | |
454 | retval *= 4; | |
2991a1ca | 455 | |
2c8dc071 DB |
456 | return retval; |
457 | } | |
458 | ||
459 | SHOW(in0_input, vaux, vaux_adjust) | |
460 | SHOW(in1_input, vbatt, vbatt_adjust) | |
461 | ||
2c8dc071 DB |
462 | static struct attribute *ads7846_attributes[] = { |
463 | &dev_attr_temp0.attr, | |
464 | &dev_attr_temp1.attr, | |
465 | &dev_attr_in0_input.attr, | |
466 | &dev_attr_in1_input.attr, | |
467 | NULL, | |
468 | }; | |
469 | ||
470 | static struct attribute_group ads7846_attr_group = { | |
471 | .attrs = ads7846_attributes, | |
472 | }; | |
473 | ||
474 | static struct attribute *ads7843_attributes[] = { | |
475 | &dev_attr_in0_input.attr, | |
476 | &dev_attr_in1_input.attr, | |
477 | NULL, | |
478 | }; | |
479 | ||
480 | static struct attribute_group ads7843_attr_group = { | |
481 | .attrs = ads7843_attributes, | |
482 | }; | |
483 | ||
484 | static struct attribute *ads7845_attributes[] = { | |
485 | &dev_attr_in0_input.attr, | |
486 | NULL, | |
487 | }; | |
488 | ||
489 | static struct attribute_group ads7845_attr_group = { | |
490 | .attrs = ads7845_attributes, | |
491 | }; | |
492 | ||
493 | static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts) | |
494 | { | |
1beeffe4 | 495 | struct device *hwmon; |
2c8dc071 DB |
496 | int err; |
497 | ||
498 | /* hwmon sensors need a reference voltage */ | |
499 | switch (ts->model) { | |
500 | case 7846: | |
7c6d0ee1 | 501 | if (!ts->vref_mv) { |
2c8dc071 | 502 | dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n"); |
7c6d0ee1 | 503 | ts->vref_mv = 2500; |
2c8dc071 DB |
504 | } |
505 | break; | |
506 | case 7845: | |
507 | case 7843: | |
7c6d0ee1 | 508 | if (!ts->vref_mv) { |
2c8dc071 DB |
509 | dev_warn(&spi->dev, |
510 | "external vREF for ADS%d not specified\n", | |
511 | ts->model); | |
512 | return 0; | |
513 | } | |
514 | break; | |
515 | } | |
516 | ||
517 | /* different chips have different sensor groups */ | |
518 | switch (ts->model) { | |
519 | case 7846: | |
520 | ts->attr_group = &ads7846_attr_group; | |
521 | break; | |
522 | case 7845: | |
523 | ts->attr_group = &ads7845_attr_group; | |
524 | break; | |
525 | case 7843: | |
526 | ts->attr_group = &ads7843_attr_group; | |
527 | break; | |
528 | default: | |
529 | dev_dbg(&spi->dev, "ADS%d not recognized\n", ts->model); | |
530 | return 0; | |
531 | } | |
532 | ||
533 | err = sysfs_create_group(&spi->dev.kobj, ts->attr_group); | |
534 | if (err) | |
535 | return err; | |
536 | ||
537 | hwmon = hwmon_device_register(&spi->dev); | |
538 | if (IS_ERR(hwmon)) { | |
539 | sysfs_remove_group(&spi->dev.kobj, ts->attr_group); | |
540 | return PTR_ERR(hwmon); | |
541 | } | |
542 | ||
543 | ts->hwmon = hwmon; | |
544 | return 0; | |
545 | } | |
546 | ||
547 | static void ads784x_hwmon_unregister(struct spi_device *spi, | |
548 | struct ads7846 *ts) | |
549 | { | |
550 | if (ts->hwmon) { | |
551 | sysfs_remove_group(&spi->dev.kobj, ts->attr_group); | |
552 | hwmon_device_unregister(ts->hwmon); | |
553 | } | |
554 | } | |
555 | ||
556 | #else | |
557 | static inline int ads784x_hwmon_register(struct spi_device *spi, | |
558 | struct ads7846 *ts) | |
559 | { | |
560 | return 0; | |
561 | } | |
562 | ||
563 | static inline void ads784x_hwmon_unregister(struct spi_device *spi, | |
564 | struct ads7846 *ts) | |
565 | { | |
566 | } | |
567 | #endif | |
ffa458c1 | 568 | |
438f2a74 ID |
569 | static ssize_t ads7846_pen_down_show(struct device *dev, |
570 | struct device_attribute *attr, char *buf) | |
571 | { | |
2991a1ca JW |
572 | struct ads7846 *ts = dev_get_drvdata(dev); |
573 | ||
574 | return sprintf(buf, "%u\n", ts->pendown); | |
438f2a74 ID |
575 | } |
576 | ||
577 | static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL); | |
578 | ||
7de90a8c ID |
579 | static ssize_t ads7846_disable_show(struct device *dev, |
580 | struct device_attribute *attr, char *buf) | |
581 | { | |
2991a1ca | 582 | struct ads7846 *ts = dev_get_drvdata(dev); |
7de90a8c ID |
583 | |
584 | return sprintf(buf, "%u\n", ts->disabled); | |
585 | } | |
586 | ||
587 | static ssize_t ads7846_disable_store(struct device *dev, | |
588 | struct device_attribute *attr, | |
589 | const char *buf, size_t count) | |
590 | { | |
591 | struct ads7846 *ts = dev_get_drvdata(dev); | |
3a0c58dd | 592 | unsigned long i; |
160f1fef JR |
593 | |
594 | if (strict_strtoul(buf, 10, &i)) | |
595 | return -EINVAL; | |
7de90a8c | 596 | |
7de90a8c ID |
597 | if (i) |
598 | ads7846_disable(ts); | |
599 | else | |
600 | ads7846_enable(ts); | |
601 | ||
7de90a8c ID |
602 | return count; |
603 | } | |
604 | ||
605 | static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store); | |
606 | ||
2c8dc071 | 607 | static struct attribute *ads784x_attributes[] = { |
8dd51650 DT |
608 | &dev_attr_pen_down.attr, |
609 | &dev_attr_disable.attr, | |
610 | NULL, | |
611 | }; | |
612 | ||
2c8dc071 DB |
613 | static struct attribute_group ads784x_attr_group = { |
614 | .attrs = ads784x_attributes, | |
8dd51650 DT |
615 | }; |
616 | ||
ffa458c1 DB |
617 | /*--------------------------------------------------------------------------*/ |
618 | ||
4d5975e5 EM |
619 | static int get_pendown_state(struct ads7846 *ts) |
620 | { | |
621 | if (ts->get_pendown_state) | |
622 | return ts->get_pendown_state(); | |
623 | ||
624 | return !gpio_get_value(ts->gpio_pendown); | |
625 | } | |
626 | ||
fd746d54 EM |
627 | static void null_wait_for_sync(void) |
628 | { | |
629 | } | |
630 | ||
2991a1ca JW |
631 | static int ads7846_debounce_filter(void *ads, int data_idx, int *val) |
632 | { | |
633 | struct ads7846 *ts = ads; | |
634 | ||
635 | if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) { | |
636 | /* Start over collecting consistent readings. */ | |
637 | ts->read_rep = 0; | |
638 | /* | |
639 | * Repeat it, if this was the first read or the read | |
640 | * wasn't consistent enough. | |
641 | */ | |
642 | if (ts->read_cnt < ts->debounce_max) { | |
643 | ts->last_read = *val; | |
644 | ts->read_cnt++; | |
645 | return ADS7846_FILTER_REPEAT; | |
646 | } else { | |
647 | /* | |
648 | * Maximum number of debouncing reached and still | |
649 | * not enough number of consistent readings. Abort | |
650 | * the whole sample, repeat it in the next sampling | |
651 | * period. | |
652 | */ | |
653 | ts->read_cnt = 0; | |
654 | return ADS7846_FILTER_IGNORE; | |
655 | } | |
656 | } else { | |
657 | if (++ts->read_rep > ts->debounce_rep) { | |
658 | /* | |
659 | * Got a good reading for this coordinate, | |
660 | * go for the next one. | |
661 | */ | |
662 | ts->read_cnt = 0; | |
663 | ts->read_rep = 0; | |
664 | return ADS7846_FILTER_OK; | |
665 | } else { | |
666 | /* Read more values that are consistent. */ | |
667 | ts->read_cnt++; | |
668 | return ADS7846_FILTER_REPEAT; | |
669 | } | |
670 | } | |
671 | } | |
672 | ||
673 | static int ads7846_no_filter(void *ads, int data_idx, int *val) | |
674 | { | |
675 | return ADS7846_FILTER_OK; | |
676 | } | |
677 | ||
678 | static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m) | |
679 | { | |
680 | struct spi_transfer *t = | |
681 | list_entry(m->transfers.prev, struct spi_transfer, transfer_list); | |
682 | ||
683 | if (ts->model == 7845) { | |
684 | return be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3; | |
685 | } else { | |
686 | /* | |
687 | * adjust: on-wire is a must-ignore bit, a BE12 value, then | |
688 | * padding; built from two 8 bit values written msb-first. | |
689 | */ | |
690 | return be16_to_cpup((__be16 *)t->rx_buf) >> 3; | |
691 | } | |
692 | } | |
693 | ||
694 | static void ads7846_update_value(struct spi_message *m, int val) | |
695 | { | |
696 | struct spi_transfer *t = | |
697 | list_entry(m->transfers.prev, struct spi_transfer, transfer_list); | |
698 | ||
699 | *(u16 *)t->rx_buf = val; | |
700 | } | |
701 | ||
702 | static void ads7846_read_state(struct ads7846 *ts) | |
703 | { | |
704 | struct ads7846_packet *packet = ts->packet; | |
705 | struct spi_message *m; | |
706 | int msg_idx = 0; | |
707 | int val; | |
708 | int action; | |
709 | int error; | |
710 | ||
711 | while (msg_idx < ts->msg_count) { | |
712 | ||
713 | ts->wait_for_sync(); | |
714 | ||
715 | m = &ts->msg[msg_idx]; | |
716 | error = spi_sync(ts->spi, m); | |
717 | if (error) { | |
718 | dev_err(&ts->spi->dev, "spi_async --> %d\n", error); | |
719 | packet->tc.ignore = true; | |
720 | return; | |
721 | } | |
722 | ||
723 | /* | |
724 | * Last message is power down request, no need to convert | |
725 | * or filter the value. | |
726 | */ | |
727 | if (msg_idx < ts->msg_count - 1) { | |
ffa458c1 | 728 | |
2991a1ca JW |
729 | val = ads7846_get_value(ts, m); |
730 | ||
731 | action = ts->filter(ts->filter_data, msg_idx, &val); | |
732 | switch (action) { | |
733 | case ADS7846_FILTER_REPEAT: | |
734 | continue; | |
735 | ||
736 | case ADS7846_FILTER_IGNORE: | |
737 | packet->tc.ignore = true; | |
738 | msg_idx = ts->msg_count - 1; | |
739 | continue; | |
740 | ||
741 | case ADS7846_FILTER_OK: | |
742 | ads7846_update_value(m, val); | |
743 | packet->tc.ignore = false; | |
744 | msg_idx++; | |
745 | break; | |
746 | ||
747 | default: | |
748 | BUG(); | |
749 | } | |
750 | } else { | |
751 | msg_idx++; | |
752 | } | |
753 | } | |
754 | } | |
755 | ||
756 | static void ads7846_report_state(struct ads7846 *ts) | |
ffa458c1 | 757 | { |
2991a1ca JW |
758 | struct ads7846_packet *packet = ts->packet; |
759 | unsigned int Rt; | |
760 | u16 x, y, z1, z2; | |
ffa458c1 | 761 | |
2991a1ca JW |
762 | /* |
763 | * ads7846_get_value() does in-place conversion (including byte swap) | |
764 | * from on-the-wire format as part of debouncing to get stable | |
765 | * readings. | |
ffa458c1 | 766 | */ |
3eac5c7e AG |
767 | if (ts->model == 7845) { |
768 | x = *(u16 *)packet->tc.x_buf; | |
769 | y = *(u16 *)packet->tc.y_buf; | |
770 | z1 = 0; | |
771 | z2 = 0; | |
772 | } else { | |
773 | x = packet->tc.x; | |
774 | y = packet->tc.y; | |
775 | z1 = packet->tc.z1; | |
776 | z2 = packet->tc.z2; | |
777 | } | |
ffa458c1 DB |
778 | |
779 | /* range filtering */ | |
780 | if (x == MAX_12BIT) | |
781 | x = 0; | |
782 | ||
9460b652 HCE |
783 | if (ts->model == 7843) { |
784 | Rt = ts->pressure_max / 2; | |
3eac5c7e AG |
785 | } else if (ts->model == 7845) { |
786 | if (get_pendown_state(ts)) | |
787 | Rt = ts->pressure_max / 2; | |
788 | else | |
789 | Rt = 0; | |
790 | dev_vdbg(&ts->spi->dev, "x/y: %d/%d, PD %d\n", x, y, Rt); | |
9460b652 | 791 | } else if (likely(x && z1)) { |
ffa458c1 DB |
792 | /* compute touch pressure resistance using equation #2 */ |
793 | Rt = z2; | |
794 | Rt -= z1; | |
795 | Rt *= x; | |
796 | Rt *= ts->x_plate_ohms; | |
797 | Rt /= z1; | |
798 | Rt = (Rt + 2047) >> 12; | |
9460b652 | 799 | } else { |
ffa458c1 | 800 | Rt = 0; |
9460b652 | 801 | } |
969111e9 | 802 | |
2991a1ca JW |
803 | /* |
804 | * Sample found inconsistent by debouncing or pressure is beyond | |
1936d590 ID |
805 | * the maximum. Don't report it to user space, repeat at least |
806 | * once more the measurement | |
807 | */ | |
e8f462d2 | 808 | if (packet->tc.ignore || Rt > ts->pressure_max) { |
52ce4eaa PM |
809 | dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n", |
810 | packet->tc.ignore, Rt); | |
d5b415c9 ID |
811 | return; |
812 | } | |
813 | ||
2991a1ca JW |
814 | /* |
815 | * Maybe check the pendown state before reporting. This discards | |
1d25891f SH |
816 | * false readings when the pen is lifted. |
817 | */ | |
818 | if (ts->penirq_recheck_delay_usecs) { | |
819 | udelay(ts->penirq_recheck_delay_usecs); | |
4d5975e5 | 820 | if (!get_pendown_state(ts)) |
1d25891f SH |
821 | Rt = 0; |
822 | } | |
823 | ||
2991a1ca JW |
824 | /* |
825 | * NOTE: We can't rely on the pressure to determine the pen down | |
826 | * state, even this controller has a pressure sensor. The pressure | |
15e3589e ID |
827 | * value can fluctuate for quite a while after lifting the pen and |
828 | * in some cases may not even settle at the expected value. | |
ffa458c1 | 829 | * |
15e3589e ID |
830 | * The only safe way to check for the pen up condition is in the |
831 | * timer by reading the pen signal state (it's a GPIO _and_ IRQ). | |
ffa458c1 | 832 | */ |
ffa458c1 | 833 | if (Rt) { |
15e3589e | 834 | struct input_dev *input = ts->input; |
ae82d5ab | 835 | |
2991a1ca JW |
836 | if (ts->swap_xy) |
837 | swap(x, y); | |
838 | ||
15e3589e ID |
839 | if (!ts->pendown) { |
840 | input_report_key(input, BTN_TOUCH, 1); | |
2991a1ca | 841 | ts->pendown = true; |
52ce4eaa | 842 | dev_vdbg(&ts->spi->dev, "DOWN\n"); |
15e3589e | 843 | } |
86579a4c | 844 | |
15e3589e ID |
845 | input_report_abs(input, ABS_X, x); |
846 | input_report_abs(input, ABS_Y, y); | |
30ad7ba0 | 847 | input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt); |
ffa458c1 | 848 | |
15e3589e | 849 | input_sync(input); |
52ce4eaa | 850 | dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt); |
15e3589e | 851 | } |
da970e69 ID |
852 | } |
853 | ||
2991a1ca | 854 | static irqreturn_t ads7846_hard_irq(int irq, void *handle) |
da970e69 | 855 | { |
2991a1ca | 856 | struct ads7846 *ts = handle; |
da970e69 | 857 | |
2991a1ca | 858 | return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED; |
0b7018aa ID |
859 | } |
860 | ||
0b7018aa | 861 | |
7d12e780 | 862 | static irqreturn_t ads7846_irq(int irq, void *handle) |
0b7018aa ID |
863 | { |
864 | struct ads7846 *ts = handle; | |
7de90a8c | 865 | |
2991a1ca JW |
866 | /* Start with a small delay before checking pendown state */ |
867 | msleep(TS_POLL_DELAY); | |
ffa458c1 | 868 | |
2991a1ca | 869 | while (!ts->stopped && get_pendown_state(ts)) { |
ffa458c1 | 870 | |
2991a1ca JW |
871 | /* pen is down, continue with the measurement */ |
872 | ads7846_read_state(ts); | |
ffa458c1 | 873 | |
2991a1ca JW |
874 | if (!ts->stopped) |
875 | ads7846_report_state(ts); | |
c9e617a5 | 876 | |
2991a1ca JW |
877 | wait_event_timeout(ts->wait, ts->stopped, |
878 | msecs_to_jiffies(TS_POLL_PERIOD)); | |
ffa458c1 DB |
879 | } |
880 | ||
2991a1ca JW |
881 | if (ts->pendown) { |
882 | struct input_dev *input = ts->input; | |
7de90a8c | 883 | |
2991a1ca JW |
884 | input_report_key(input, BTN_TOUCH, 0); |
885 | input_report_abs(input, ABS_PRESSURE, 0); | |
886 | input_sync(input); | |
7de90a8c | 887 | |
2991a1ca JW |
888 | ts->pendown = false; |
889 | dev_vdbg(&ts->spi->dev, "UP\n"); | |
890 | } | |
91143379 | 891 | |
2991a1ca | 892 | return IRQ_HANDLED; |
7de90a8c ID |
893 | } |
894 | ||
895 | static int ads7846_suspend(struct spi_device *spi, pm_message_t message) | |
896 | { | |
897 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); | |
898 | ||
2991a1ca | 899 | mutex_lock(&ts->lock); |
7de90a8c | 900 | |
2991a1ca | 901 | if (!ts->suspended) { |
7de90a8c | 902 | |
2991a1ca JW |
903 | if (!ts->disabled) |
904 | __ads7846_disable(ts); | |
7de90a8c | 905 | |
2991a1ca JW |
906 | if (device_may_wakeup(&ts->spi->dev)) |
907 | enable_irq_wake(ts->spi->irq); | |
fdba2bb1 | 908 | |
2991a1ca JW |
909 | ts->suspended = true; |
910 | } | |
911 | ||
912 | mutex_unlock(&ts->lock); | |
7de90a8c | 913 | |
2991a1ca | 914 | return 0; |
ffa458c1 DB |
915 | } |
916 | ||
2e5a7bd9 | 917 | static int ads7846_resume(struct spi_device *spi) |
ffa458c1 | 918 | { |
2e5a7bd9 | 919 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); |
ffa458c1 | 920 | |
2991a1ca JW |
921 | mutex_lock(&ts->lock); |
922 | ||
923 | if (ts->suspended) { | |
fdba2bb1 | 924 | |
2991a1ca | 925 | ts->suspended = false; |
7de90a8c | 926 | |
2991a1ca JW |
927 | if (device_may_wakeup(&ts->spi->dev)) |
928 | disable_irq_wake(ts->spi->irq); | |
7de90a8c | 929 | |
2991a1ca JW |
930 | if (!ts->disabled) |
931 | __ads7846_enable(ts); | |
932 | } | |
933 | ||
934 | mutex_unlock(&ts->lock); | |
7de90a8c | 935 | |
ffa458c1 DB |
936 | return 0; |
937 | } | |
938 | ||
2991a1ca | 939 | static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads7846 *ts) |
4d5975e5 EM |
940 | { |
941 | struct ads7846_platform_data *pdata = spi->dev.platform_data; | |
942 | int err; | |
943 | ||
0fbc9fdb DT |
944 | /* |
945 | * REVISIT when the irq can be triggered active-low, or if for some | |
4d5975e5 EM |
946 | * reason the touchscreen isn't hooked up, we don't need to access |
947 | * the pendown state. | |
948 | */ | |
4d5975e5 EM |
949 | |
950 | if (pdata->get_pendown_state) { | |
951 | ts->get_pendown_state = pdata->get_pendown_state; | |
0fbc9fdb | 952 | } else if (gpio_is_valid(pdata->gpio_pendown)) { |
4d5975e5 | 953 | |
0fbc9fdb DT |
954 | err = gpio_request(pdata->gpio_pendown, "ads7846_pendown"); |
955 | if (err) { | |
956 | dev_err(&spi->dev, "failed to request pendown GPIO%d\n", | |
957 | pdata->gpio_pendown); | |
958 | return err; | |
959 | } | |
4d5975e5 | 960 | |
0fbc9fdb DT |
961 | ts->gpio_pendown = pdata->gpio_pendown; |
962 | ||
963 | } else { | |
964 | dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n"); | |
965 | return -EINVAL; | |
966 | } | |
2991a1ca | 967 | |
4d5975e5 EM |
968 | return 0; |
969 | } | |
970 | ||
2991a1ca JW |
971 | /* |
972 | * Set up the transfers to read touchscreen state; this assumes we | |
973 | * use formula #2 for pressure, not #3. | |
974 | */ | |
975 | static void __devinit ads7846_setup_spi_msg(struct ads7846 *ts, | |
976 | const struct ads7846_platform_data *pdata) | |
ffa458c1 | 977 | { |
2991a1ca JW |
978 | struct spi_message *m = &ts->msg[0]; |
979 | struct spi_transfer *x = ts->xfer; | |
980 | struct ads7846_packet *packet = ts->packet; | |
981 | int vref = pdata->keep_vref_on; | |
de2defd9 | 982 | |
06a09124 | 983 | if (ts->model == 7873) { |
2991a1ca JW |
984 | /* |
985 | * The AD7873 is almost identical to the ADS7846 | |
06a09124 | 986 | * keep VREF off during differential/ratiometric |
2991a1ca | 987 | * conversion modes. |
06a09124 MH |
988 | */ |
989 | ts->model = 7846; | |
990 | vref = 0; | |
991 | } | |
992 | ||
2991a1ca | 993 | ts->msg_count = 1; |
0b7018aa | 994 | spi_message_init(m); |
2991a1ca | 995 | m->context = ts; |
0b7018aa | 996 | |
3eac5c7e AG |
997 | if (ts->model == 7845) { |
998 | packet->read_y_cmd[0] = READ_Y(vref); | |
999 | packet->read_y_cmd[1] = 0; | |
1000 | packet->read_y_cmd[2] = 0; | |
1001 | x->tx_buf = &packet->read_y_cmd[0]; | |
1002 | x->rx_buf = &packet->tc.y_buf[0]; | |
1003 | x->len = 3; | |
1004 | spi_message_add_tail(x, m); | |
1005 | } else { | |
1006 | /* y- still on; turn on only y+ (and ADC) */ | |
1007 | packet->read_y = READ_Y(vref); | |
1008 | x->tx_buf = &packet->read_y; | |
1009 | x->len = 1; | |
1010 | spi_message_add_tail(x, m); | |
d93f70b2 | 1011 | |
3eac5c7e AG |
1012 | x++; |
1013 | x->rx_buf = &packet->tc.y; | |
1014 | x->len = 2; | |
1015 | spi_message_add_tail(x, m); | |
1016 | } | |
0b7018aa | 1017 | |
2991a1ca JW |
1018 | /* |
1019 | * The first sample after switching drivers can be low quality; | |
e4f48861 SH |
1020 | * optionally discard it, using a second one after the signals |
1021 | * have had enough time to stabilize. | |
1022 | */ | |
1023 | if (pdata->settle_delay_usecs) { | |
1024 | x->delay_usecs = pdata->settle_delay_usecs; | |
1025 | ||
1026 | x++; | |
e8f462d2 | 1027 | x->tx_buf = &packet->read_y; |
e4f48861 SH |
1028 | x->len = 1; |
1029 | spi_message_add_tail(x, m); | |
1030 | ||
1031 | x++; | |
e8f462d2 | 1032 | x->rx_buf = &packet->tc.y; |
e4f48861 SH |
1033 | x->len = 2; |
1034 | spi_message_add_tail(x, m); | |
1035 | } | |
1036 | ||
2991a1ca | 1037 | ts->msg_count++; |
0b7018aa ID |
1038 | m++; |
1039 | spi_message_init(m); | |
2991a1ca | 1040 | m->context = ts; |
0b7018aa | 1041 | |
3eac5c7e AG |
1042 | if (ts->model == 7845) { |
1043 | x++; | |
1044 | packet->read_x_cmd[0] = READ_X(vref); | |
1045 | packet->read_x_cmd[1] = 0; | |
1046 | packet->read_x_cmd[2] = 0; | |
1047 | x->tx_buf = &packet->read_x_cmd[0]; | |
1048 | x->rx_buf = &packet->tc.x_buf[0]; | |
1049 | x->len = 3; | |
1050 | spi_message_add_tail(x, m); | |
1051 | } else { | |
1052 | /* turn y- off, x+ on, then leave in lowpower */ | |
1053 | x++; | |
1054 | packet->read_x = READ_X(vref); | |
1055 | x->tx_buf = &packet->read_x; | |
1056 | x->len = 1; | |
1057 | spi_message_add_tail(x, m); | |
0b7018aa | 1058 | |
3eac5c7e AG |
1059 | x++; |
1060 | x->rx_buf = &packet->tc.x; | |
1061 | x->len = 2; | |
1062 | spi_message_add_tail(x, m); | |
1063 | } | |
0b7018aa | 1064 | |
e4f48861 SH |
1065 | /* ... maybe discard first sample ... */ |
1066 | if (pdata->settle_delay_usecs) { | |
1067 | x->delay_usecs = pdata->settle_delay_usecs; | |
1068 | ||
1069 | x++; | |
e8f462d2 | 1070 | x->tx_buf = &packet->read_x; |
e4f48861 SH |
1071 | x->len = 1; |
1072 | spi_message_add_tail(x, m); | |
1073 | ||
1074 | x++; | |
e8f462d2 | 1075 | x->rx_buf = &packet->tc.x; |
e4f48861 SH |
1076 | x->len = 2; |
1077 | spi_message_add_tail(x, m); | |
1078 | } | |
1079 | ||
ffa458c1 DB |
1080 | /* turn y+ off, x- on; we'll use formula #2 */ |
1081 | if (ts->model == 7846) { | |
2991a1ca | 1082 | ts->msg_count++; |
0b7018aa ID |
1083 | m++; |
1084 | spi_message_init(m); | |
2991a1ca | 1085 | m->context = ts; |
0b7018aa | 1086 | |
d93f70b2 | 1087 | x++; |
e8f462d2 DT |
1088 | packet->read_z1 = READ_Z1(vref); |
1089 | x->tx_buf = &packet->read_z1; | |
ffa458c1 | 1090 | x->len = 1; |
0b7018aa | 1091 | spi_message_add_tail(x, m); |
d93f70b2 | 1092 | |
ffa458c1 | 1093 | x++; |
e8f462d2 | 1094 | x->rx_buf = &packet->tc.z1; |
ffa458c1 | 1095 | x->len = 2; |
0b7018aa ID |
1096 | spi_message_add_tail(x, m); |
1097 | ||
e4f48861 SH |
1098 | /* ... maybe discard first sample ... */ |
1099 | if (pdata->settle_delay_usecs) { | |
1100 | x->delay_usecs = pdata->settle_delay_usecs; | |
1101 | ||
1102 | x++; | |
e8f462d2 | 1103 | x->tx_buf = &packet->read_z1; |
e4f48861 SH |
1104 | x->len = 1; |
1105 | spi_message_add_tail(x, m); | |
1106 | ||
1107 | x++; | |
e8f462d2 | 1108 | x->rx_buf = &packet->tc.z1; |
e4f48861 SH |
1109 | x->len = 2; |
1110 | spi_message_add_tail(x, m); | |
1111 | } | |
1112 | ||
2991a1ca | 1113 | ts->msg_count++; |
0b7018aa ID |
1114 | m++; |
1115 | spi_message_init(m); | |
2991a1ca | 1116 | m->context = ts; |
ffa458c1 | 1117 | |
d93f70b2 | 1118 | x++; |
e8f462d2 DT |
1119 | packet->read_z2 = READ_Z2(vref); |
1120 | x->tx_buf = &packet->read_z2; | |
ffa458c1 | 1121 | x->len = 1; |
0b7018aa | 1122 | spi_message_add_tail(x, m); |
d93f70b2 | 1123 | |
ffa458c1 | 1124 | x++; |
e8f462d2 | 1125 | x->rx_buf = &packet->tc.z2; |
ffa458c1 | 1126 | x->len = 2; |
0b7018aa | 1127 | spi_message_add_tail(x, m); |
ffa458c1 | 1128 | |
e4f48861 SH |
1129 | /* ... maybe discard first sample ... */ |
1130 | if (pdata->settle_delay_usecs) { | |
1131 | x->delay_usecs = pdata->settle_delay_usecs; | |
1132 | ||
1133 | x++; | |
e8f462d2 | 1134 | x->tx_buf = &packet->read_z2; |
e4f48861 SH |
1135 | x->len = 1; |
1136 | spi_message_add_tail(x, m); | |
1137 | ||
1138 | x++; | |
e8f462d2 | 1139 | x->rx_buf = &packet->tc.z2; |
e4f48861 SH |
1140 | x->len = 2; |
1141 | spi_message_add_tail(x, m); | |
1142 | } | |
0b7018aa | 1143 | } |
53a0ef89 ID |
1144 | |
1145 | /* power down */ | |
2991a1ca | 1146 | ts->msg_count++; |
0b7018aa ID |
1147 | m++; |
1148 | spi_message_init(m); | |
2991a1ca | 1149 | m->context = ts; |
0b7018aa | 1150 | |
3eac5c7e AG |
1151 | if (ts->model == 7845) { |
1152 | x++; | |
1153 | packet->pwrdown_cmd[0] = PWRDOWN; | |
1154 | packet->pwrdown_cmd[1] = 0; | |
1155 | packet->pwrdown_cmd[2] = 0; | |
1156 | x->tx_buf = &packet->pwrdown_cmd[0]; | |
1157 | x->len = 3; | |
1158 | } else { | |
1159 | x++; | |
1160 | packet->pwrdown = PWRDOWN; | |
1161 | x->tx_buf = &packet->pwrdown; | |
1162 | x->len = 1; | |
1163 | spi_message_add_tail(x, m); | |
1164 | ||
1165 | x++; | |
1166 | x->rx_buf = &packet->dummy; | |
1167 | x->len = 2; | |
1168 | } | |
53a0ef89 | 1169 | |
d93f70b2 | 1170 | CS_CHANGE(*x); |
0b7018aa | 1171 | spi_message_add_tail(x, m); |
2991a1ca | 1172 | } |
ffa458c1 | 1173 | |
2991a1ca JW |
1174 | static int __devinit ads7846_probe(struct spi_device *spi) |
1175 | { | |
1176 | struct ads7846 *ts; | |
1177 | struct ads7846_packet *packet; | |
1178 | struct input_dev *input_dev; | |
1179 | struct ads7846_platform_data *pdata = spi->dev.platform_data; | |
1180 | unsigned long irq_flags; | |
1181 | int err; | |
1182 | ||
1183 | if (!spi->irq) { | |
1184 | dev_dbg(&spi->dev, "no IRQ?\n"); | |
1185 | return -ENODEV; | |
1186 | } | |
1187 | ||
1188 | if (!pdata) { | |
1189 | dev_dbg(&spi->dev, "no platform data?\n"); | |
1190 | return -ENODEV; | |
1191 | } | |
1192 | ||
1193 | /* don't exceed max specified sample rate */ | |
1194 | if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) { | |
1195 | dev_dbg(&spi->dev, "f(sample) %d KHz?\n", | |
1196 | (spi->max_speed_hz/SAMPLE_BITS)/1000); | |
1197 | return -EINVAL; | |
1198 | } | |
1199 | ||
1200 | /* We'd set TX word size 8 bits and RX word size to 13 bits ... except | |
1201 | * that even if the hardware can do that, the SPI controller driver | |
1202 | * may not. So we stick to very-portable 8 bit words, both RX and TX. | |
1203 | */ | |
1204 | spi->bits_per_word = 8; | |
1205 | spi->mode = SPI_MODE_0; | |
1206 | err = spi_setup(spi); | |
1207 | if (err < 0) | |
1208 | return err; | |
ffa458c1 | 1209 | |
2991a1ca JW |
1210 | ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL); |
1211 | packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL); | |
1212 | input_dev = input_allocate_device(); | |
1213 | if (!ts || !packet || !input_dev) { | |
1214 | err = -ENOMEM; | |
1215 | goto err_free_mem; | |
1216 | } | |
1217 | ||
1218 | dev_set_drvdata(&spi->dev, ts); | |
1219 | ||
1220 | ts->packet = packet; | |
1221 | ts->spi = spi; | |
1222 | ts->input = input_dev; | |
1223 | ts->vref_mv = pdata->vref_mv; | |
1224 | ts->swap_xy = pdata->swap_xy; | |
1225 | ||
1226 | mutex_init(&ts->lock); | |
1227 | init_waitqueue_head(&ts->wait); | |
1228 | ||
1229 | ts->model = pdata->model ? : 7846; | |
1230 | ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100; | |
1231 | ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; | |
1232 | ts->pressure_max = pdata->pressure_max ? : ~0; | |
1233 | ||
1234 | if (pdata->filter != NULL) { | |
1235 | if (pdata->filter_init != NULL) { | |
1236 | err = pdata->filter_init(pdata, &ts->filter_data); | |
1237 | if (err < 0) | |
1238 | goto err_free_mem; | |
1239 | } | |
1240 | ts->filter = pdata->filter; | |
1241 | ts->filter_cleanup = pdata->filter_cleanup; | |
1242 | } else if (pdata->debounce_max) { | |
1243 | ts->debounce_max = pdata->debounce_max; | |
1244 | if (ts->debounce_max < 2) | |
1245 | ts->debounce_max = 2; | |
1246 | ts->debounce_tol = pdata->debounce_tol; | |
1247 | ts->debounce_rep = pdata->debounce_rep; | |
1248 | ts->filter = ads7846_debounce_filter; | |
1249 | ts->filter_data = ts; | |
1250 | } else { | |
1251 | ts->filter = ads7846_no_filter; | |
1252 | } | |
1253 | ||
1254 | err = ads7846_setup_pendown(spi, ts); | |
1255 | if (err) | |
1256 | goto err_cleanup_filter; | |
1257 | ||
1258 | if (pdata->penirq_recheck_delay_usecs) | |
1259 | ts->penirq_recheck_delay_usecs = | |
1260 | pdata->penirq_recheck_delay_usecs; | |
1261 | ||
1262 | ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync; | |
1263 | ||
1264 | snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev)); | |
1265 | snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model); | |
1266 | ||
1267 | input_dev->name = ts->name; | |
1268 | input_dev->phys = ts->phys; | |
1269 | input_dev->dev.parent = &spi->dev; | |
1270 | ||
1271 | input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); | |
1272 | input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); | |
1273 | input_set_abs_params(input_dev, ABS_X, | |
1274 | pdata->x_min ? : 0, | |
1275 | pdata->x_max ? : MAX_12BIT, | |
1276 | 0, 0); | |
1277 | input_set_abs_params(input_dev, ABS_Y, | |
1278 | pdata->y_min ? : 0, | |
1279 | pdata->y_max ? : MAX_12BIT, | |
1280 | 0, 0); | |
1281 | input_set_abs_params(input_dev, ABS_PRESSURE, | |
1282 | pdata->pressure_min, pdata->pressure_max, 0, 0); | |
1283 | ||
1284 | ads7846_setup_spi_msg(ts, pdata); | |
d5b415c9 | 1285 | |
91143379 GI |
1286 | ts->reg = regulator_get(&spi->dev, "vcc"); |
1287 | if (IS_ERR(ts->reg)) { | |
067fb2f6 | 1288 | err = PTR_ERR(ts->reg); |
56960b36 | 1289 | dev_err(&spi->dev, "unable to get regulator: %d\n", err); |
91143379 GI |
1290 | goto err_free_gpio; |
1291 | } | |
1292 | ||
1293 | err = regulator_enable(ts->reg); | |
1294 | if (err) { | |
1295 | dev_err(&spi->dev, "unable to enable regulator: %d\n", err); | |
1296 | goto err_put_regulator; | |
1297 | } | |
1298 | ||
0f622bf4 | 1299 | irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING; |
2991a1ca | 1300 | irq_flags |= IRQF_ONESHOT; |
7804302b | 1301 | |
2991a1ca JW |
1302 | err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq, |
1303 | irq_flags, spi->dev.driver->name, ts); | |
0f622bf4 | 1304 | if (err && !pdata->irq_flags) { |
c57c0a2a MR |
1305 | dev_info(&spi->dev, |
1306 | "trying pin change workaround on irq %d\n", spi->irq); | |
2991a1ca JW |
1307 | irq_flags |= IRQF_TRIGGER_RISING; |
1308 | err = request_threaded_irq(spi->irq, | |
1309 | ads7846_hard_irq, ads7846_irq, | |
1310 | irq_flags, spi->dev.driver->name, ts); | |
0f622bf4 DT |
1311 | } |
1312 | ||
1313 | if (err) { | |
1314 | dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq); | |
1315 | goto err_disable_regulator; | |
ffa458c1 | 1316 | } |
ffa458c1 | 1317 | |
2c8dc071 DB |
1318 | err = ads784x_hwmon_register(spi, ts); |
1319 | if (err) | |
1320 | goto err_free_irq; | |
1321 | ||
2e5a7bd9 | 1322 | dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq); |
ffa458c1 | 1323 | |
2991a1ca JW |
1324 | /* |
1325 | * Take a first sample, leaving nPENIRQ active and vREF off; avoid | |
ffa458c1 DB |
1326 | * the touchscreen, in case it's not connected. |
1327 | */ | |
3eac5c7e AG |
1328 | if (ts->model == 7845) |
1329 | ads7845_read12_ser(&spi->dev, PWRDOWN); | |
1330 | else | |
1331 | (void) ads7846_read12_ser(&spi->dev, | |
1332 | READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON); | |
ffa458c1 | 1333 | |
2c8dc071 | 1334 | err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group); |
8dd51650 | 1335 | if (err) |
2c8dc071 | 1336 | goto err_remove_hwmon; |
7de90a8c | 1337 | |
a90f7e98 DT |
1338 | err = input_register_device(input_dev); |
1339 | if (err) | |
8dd51650 | 1340 | goto err_remove_attr_group; |
a90f7e98 | 1341 | |
fdba2bb1 RL |
1342 | device_init_wakeup(&spi->dev, pdata->wakeup); |
1343 | ||
ffa458c1 | 1344 | return 0; |
a90f7e98 | 1345 | |
8dd51650 | 1346 | err_remove_attr_group: |
2c8dc071 DB |
1347 | sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); |
1348 | err_remove_hwmon: | |
1349 | ads784x_hwmon_unregister(spi, ts); | |
8dd51650 | 1350 | err_free_irq: |
a90f7e98 | 1351 | free_irq(spi->irq, ts); |
91143379 GI |
1352 | err_disable_regulator: |
1353 | regulator_disable(ts->reg); | |
1354 | err_put_regulator: | |
1355 | regulator_put(ts->reg); | |
4d5975e5 | 1356 | err_free_gpio: |
0fbc9fdb | 1357 | if (!ts->get_pendown_state) |
4d5975e5 | 1358 | gpio_free(ts->gpio_pendown); |
da970e69 ID |
1359 | err_cleanup_filter: |
1360 | if (ts->filter_cleanup) | |
1361 | ts->filter_cleanup(ts->filter_data); | |
a90f7e98 DT |
1362 | err_free_mem: |
1363 | input_free_device(input_dev); | |
e8f462d2 | 1364 | kfree(packet); |
a90f7e98 DT |
1365 | kfree(ts); |
1366 | return err; | |
ffa458c1 DB |
1367 | } |
1368 | ||
2e5a7bd9 | 1369 | static int __devexit ads7846_remove(struct spi_device *spi) |
ffa458c1 | 1370 | { |
2991a1ca | 1371 | struct ads7846 *ts = dev_get_drvdata(&spi->dev); |
ffa458c1 | 1372 | |
fdba2bb1 RL |
1373 | device_init_wakeup(&spi->dev, false); |
1374 | ||
2c8dc071 | 1375 | sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); |
ffa458c1 | 1376 | |
2991a1ca | 1377 | ads7846_disable(ts); |
7de90a8c | 1378 | free_irq(ts->spi->irq, ts); |
2991a1ca JW |
1379 | |
1380 | input_unregister_device(ts->input); | |
1381 | ||
1382 | ads784x_hwmon_unregister(spi, ts); | |
7de90a8c | 1383 | |
91143379 GI |
1384 | regulator_disable(ts->reg); |
1385 | regulator_put(ts->reg); | |
1386 | ||
0fbc9fdb DT |
1387 | if (!ts->get_pendown_state) { |
1388 | /* | |
1389 | * If we are not using specialized pendown method we must | |
1390 | * have been relying on gpio we set up ourselves. | |
1391 | */ | |
4d5975e5 | 1392 | gpio_free(ts->gpio_pendown); |
0fbc9fdb | 1393 | } |
4d5975e5 | 1394 | |
da970e69 ID |
1395 | if (ts->filter_cleanup) |
1396 | ts->filter_cleanup(ts->filter_data); | |
1397 | ||
e8f462d2 | 1398 | kfree(ts->packet); |
ffa458c1 DB |
1399 | kfree(ts); |
1400 | ||
2e5a7bd9 | 1401 | dev_dbg(&spi->dev, "unregistered touchscreen\n"); |
2991a1ca | 1402 | |
ffa458c1 DB |
1403 | return 0; |
1404 | } | |
1405 | ||
2e5a7bd9 DB |
1406 | static struct spi_driver ads7846_driver = { |
1407 | .driver = { | |
1408 | .name = "ads7846", | |
1409 | .bus = &spi_bus_type, | |
1410 | .owner = THIS_MODULE, | |
1411 | }, | |
ffa458c1 | 1412 | .probe = ads7846_probe, |
2e5a7bd9 | 1413 | .remove = __devexit_p(ads7846_remove), |
ffa458c1 DB |
1414 | .suspend = ads7846_suspend, |
1415 | .resume = ads7846_resume, | |
1416 | }; | |
1417 | ||
1418 | static int __init ads7846_init(void) | |
1419 | { | |
2e5a7bd9 | 1420 | return spi_register_driver(&ads7846_driver); |
ffa458c1 DB |
1421 | } |
1422 | module_init(ads7846_init); | |
1423 | ||
1424 | static void __exit ads7846_exit(void) | |
1425 | { | |
2e5a7bd9 | 1426 | spi_unregister_driver(&ads7846_driver); |
ffa458c1 DB |
1427 | } |
1428 | module_exit(ads7846_exit); | |
1429 | ||
1430 | MODULE_DESCRIPTION("ADS7846 TouchScreen Driver"); | |
1431 | MODULE_LICENSE("GPL"); | |
e0626e38 | 1432 | MODULE_ALIAS("spi:ads7846"); |