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