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