2 * TSC2004/TSC2005 touchscreen driver core
4 * Copyright (C) 2006-2010 Nokia Corporation
5 * Copyright (C) 2015 QWERTY Embedded Design
6 * Copyright (C) 2015 EMAC Inc.
8 * Author: Lauri Leukkunen <lauri.leukkunen@nokia.com>
9 * based on TSC2301 driver by Klaus K. Pedersen <klaus.k.pedersen@nokia.com>
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/input.h>
25 #include <linux/input/touchscreen.h>
26 #include <linux/interrupt.h>
27 #include <linux/delay.h>
30 #include <linux/regulator/consumer.h>
31 #include <linux/regmap.h>
32 #include <linux/gpio/consumer.h>
33 #include "tsc200x-core.h"
36 * The touchscreen interface operates as follows:
38 * 1) Pen is pressed against the touchscreen.
39 * 2) TSC200X performs AD conversion.
40 * 3) After the conversion is done TSC200X drives DAV line down.
41 * 4) GPIO IRQ is received and tsc200x_irq_thread() is scheduled.
42 * 5) tsc200x_irq_thread() queues up a transfer to fetch the x, y, z1, z2
44 * 6) tsc200x_irq_thread() reports coordinates to input layer and sets up
45 * tsc200x_penup_timer() to be called after TSC200X_PENUP_TIME_MS (40ms).
46 * 7) When the penup timer expires, there have not been touch or DAV interrupts
47 * during the last 40ms which means the pen has been lifted.
49 * ESD recovery via a hardware reset is done if the TSC200X doesn't respond
50 * after a configurable period (in ms) of activity. If esd_timeout is 0, the
51 * watchdog is disabled.
54 static const struct regmap_range tsc200x_writable_ranges
[] = {
55 regmap_reg_range(TSC200X_REG_AUX_HIGH
, TSC200X_REG_CFR2
),
58 static const struct regmap_access_table tsc200x_writable_table
= {
59 .yes_ranges
= tsc200x_writable_ranges
,
60 .n_yes_ranges
= ARRAY_SIZE(tsc200x_writable_ranges
),
63 const struct regmap_config tsc200x_regmap_config
= {
68 .read_flag_mask
= TSC200X_REG_READ
,
69 .write_flag_mask
= TSC200X_REG_PND0
,
70 .wr_table
= &tsc200x_writable_table
,
71 .use_single_rw
= true,
73 EXPORT_SYMBOL_GPL(tsc200x_regmap_config
);
81 #define TSC200X_DATA_REGS 4
85 struct regmap
*regmap
;
88 struct input_dev
*idev
;
93 /* raw copy of previous x,y,z */
100 struct timer_list penup_timer
;
102 unsigned int esd_timeout
;
103 struct delayed_work esd_work
;
104 unsigned long last_valid_interrupt
;
106 unsigned int x_plate_ohm
;
113 struct regulator
*vio
;
115 struct gpio_desc
*reset_gpio
;
116 int (*tsc200x_cmd
)(struct device
*dev
, u8 cmd
);
120 static void tsc200x_update_pen_state(struct tsc200x
*ts
,
121 int x
, int y
, int pressure
)
124 input_report_abs(ts
->idev
, ABS_X
, x
);
125 input_report_abs(ts
->idev
, ABS_Y
, y
);
126 input_report_abs(ts
->idev
, ABS_PRESSURE
, pressure
);
128 input_report_key(ts
->idev
, BTN_TOUCH
, !!pressure
);
132 input_report_abs(ts
->idev
, ABS_PRESSURE
, 0);
134 input_report_key(ts
->idev
, BTN_TOUCH
, 0);
135 ts
->pen_down
= false;
138 input_sync(ts
->idev
);
139 dev_dbg(ts
->dev
, "point(%4d,%4d), pressure (%4d)\n", x
, y
,
143 static irqreturn_t
tsc200x_irq_thread(int irq
, void *_ts
)
145 struct tsc200x
*ts
= _ts
;
147 unsigned int pressure
;
148 struct tsc200x_data tsdata
;
151 /* read the coordinates */
152 error
= regmap_bulk_read(ts
->regmap
, TSC200X_REG_X
, &tsdata
,
157 /* validate position */
158 if (unlikely(tsdata
.x
> MAX_12BIT
|| tsdata
.y
> MAX_12BIT
))
161 /* Skip reading if the pressure components are out of range */
162 if (unlikely(tsdata
.z1
== 0 || tsdata
.z2
> MAX_12BIT
))
164 if (unlikely(tsdata
.z1
>= tsdata
.z2
))
168 * Skip point if this is a pen down with the exact same values as
169 * the value before pen-up - that implies SPI fed us stale data
172 ts
->in_x
== tsdata
.x
&& ts
->in_y
== tsdata
.y
&&
173 ts
->in_z1
== tsdata
.z1
&& ts
->in_z2
== tsdata
.z2
) {
178 * At this point we are happy we have a valid and useful reading.
179 * Remember it for later comparisons. We may now begin downsampling.
183 ts
->in_z1
= tsdata
.z1
;
184 ts
->in_z2
= tsdata
.z2
;
186 /* Compute touch pressure resistance using equation #1 */
187 pressure
= tsdata
.x
* (tsdata
.z2
- tsdata
.z1
) / tsdata
.z1
;
188 pressure
= pressure
* ts
->x_plate_ohm
/ 4096;
189 if (unlikely(pressure
> MAX_12BIT
))
192 spin_lock_irqsave(&ts
->lock
, flags
);
194 tsc200x_update_pen_state(ts
, tsdata
.x
, tsdata
.y
, pressure
);
195 mod_timer(&ts
->penup_timer
,
196 jiffies
+ msecs_to_jiffies(TSC200X_PENUP_TIME_MS
));
198 spin_unlock_irqrestore(&ts
->lock
, flags
);
200 ts
->last_valid_interrupt
= jiffies
;
205 static void tsc200x_penup_timer(struct timer_list
*t
)
207 struct tsc200x
*ts
= from_timer(ts
, t
, penup_timer
);
210 spin_lock_irqsave(&ts
->lock
, flags
);
211 tsc200x_update_pen_state(ts
, 0, 0, 0);
212 spin_unlock_irqrestore(&ts
->lock
, flags
);
215 static void tsc200x_start_scan(struct tsc200x
*ts
)
217 regmap_write(ts
->regmap
, TSC200X_REG_CFR0
, TSC200X_CFR0_INITVALUE
);
218 regmap_write(ts
->regmap
, TSC200X_REG_CFR1
, TSC200X_CFR1_INITVALUE
);
219 regmap_write(ts
->regmap
, TSC200X_REG_CFR2
, TSC200X_CFR2_INITVALUE
);
220 ts
->tsc200x_cmd(ts
->dev
, TSC200X_CMD_NORMAL
);
223 static void tsc200x_stop_scan(struct tsc200x
*ts
)
225 ts
->tsc200x_cmd(ts
->dev
, TSC200X_CMD_STOP
);
228 static void tsc200x_reset(struct tsc200x
*ts
)
230 if (ts
->reset_gpio
) {
231 gpiod_set_value_cansleep(ts
->reset_gpio
, 1);
232 usleep_range(100, 500); /* only 10us required */
233 gpiod_set_value_cansleep(ts
->reset_gpio
, 0);
237 /* must be called with ts->mutex held */
238 static void __tsc200x_disable(struct tsc200x
*ts
)
240 tsc200x_stop_scan(ts
);
242 disable_irq(ts
->irq
);
243 del_timer_sync(&ts
->penup_timer
);
245 cancel_delayed_work_sync(&ts
->esd_work
);
250 /* must be called with ts->mutex held */
251 static void __tsc200x_enable(struct tsc200x
*ts
)
253 tsc200x_start_scan(ts
);
255 if (ts
->esd_timeout
&& ts
->reset_gpio
) {
256 ts
->last_valid_interrupt
= jiffies
;
257 schedule_delayed_work(&ts
->esd_work
,
258 round_jiffies_relative(
259 msecs_to_jiffies(ts
->esd_timeout
)));
263 static ssize_t
tsc200x_selftest_show(struct device
*dev
,
264 struct device_attribute
*attr
,
267 struct tsc200x
*ts
= dev_get_drvdata(dev
);
268 unsigned int temp_high
;
269 unsigned int temp_high_orig
;
270 unsigned int temp_high_test
;
274 mutex_lock(&ts
->mutex
);
277 * Test TSC200X communications via temp high register.
279 __tsc200x_disable(ts
);
281 error
= regmap_read(ts
->regmap
, TSC200X_REG_TEMP_HIGH
, &temp_high_orig
);
283 dev_warn(dev
, "selftest failed: read error %d\n", error
);
288 temp_high_test
= (temp_high_orig
- 1) & MAX_12BIT
;
290 error
= regmap_write(ts
->regmap
, TSC200X_REG_TEMP_HIGH
, temp_high_test
);
292 dev_warn(dev
, "selftest failed: write error %d\n", error
);
297 error
= regmap_read(ts
->regmap
, TSC200X_REG_TEMP_HIGH
, &temp_high
);
299 dev_warn(dev
, "selftest failed: read error %d after write\n",
305 if (temp_high
!= temp_high_test
) {
306 dev_warn(dev
, "selftest failed: %d != %d\n",
307 temp_high
, temp_high_test
);
317 /* test that the reset really happened */
318 error
= regmap_read(ts
->regmap
, TSC200X_REG_TEMP_HIGH
, &temp_high
);
320 dev_warn(dev
, "selftest failed: read error %d after reset\n",
326 if (temp_high
!= temp_high_orig
) {
327 dev_warn(dev
, "selftest failed after reset: %d != %d\n",
328 temp_high
, temp_high_orig
);
333 __tsc200x_enable(ts
);
334 mutex_unlock(&ts
->mutex
);
336 return sprintf(buf
, "%d\n", success
);
339 static DEVICE_ATTR(selftest
, S_IRUGO
, tsc200x_selftest_show
, NULL
);
341 static struct attribute
*tsc200x_attrs
[] = {
342 &dev_attr_selftest
.attr
,
346 static umode_t
tsc200x_attr_is_visible(struct kobject
*kobj
,
347 struct attribute
*attr
, int n
)
349 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
350 struct tsc200x
*ts
= dev_get_drvdata(dev
);
351 umode_t mode
= attr
->mode
;
353 if (attr
== &dev_attr_selftest
.attr
) {
361 static const struct attribute_group tsc200x_attr_group
= {
362 .is_visible
= tsc200x_attr_is_visible
,
363 .attrs
= tsc200x_attrs
,
366 static void tsc200x_esd_work(struct work_struct
*work
)
368 struct tsc200x
*ts
= container_of(work
, struct tsc200x
, esd_work
.work
);
372 if (!mutex_trylock(&ts
->mutex
)) {
374 * If the mutex is taken, it means that disable or enable is in
375 * progress. In that case just reschedule the work. If the work
376 * is not needed, it will be canceled by disable.
381 if (time_is_after_jiffies(ts
->last_valid_interrupt
+
382 msecs_to_jiffies(ts
->esd_timeout
)))
385 /* We should be able to read register without disabling interrupts. */
386 error
= regmap_read(ts
->regmap
, TSC200X_REG_CFR0
, &r
);
388 !((r
^ TSC200X_CFR0_INITVALUE
) & TSC200X_CFR0_RW_MASK
)) {
393 * If we could not read our known value from configuration register 0
394 * then we should reset the controller as if from power-up and start
397 dev_info(ts
->dev
, "TSC200X not responding - resetting\n");
399 disable_irq(ts
->irq
);
400 del_timer_sync(&ts
->penup_timer
);
402 tsc200x_update_pen_state(ts
, 0, 0, 0);
407 tsc200x_start_scan(ts
);
410 mutex_unlock(&ts
->mutex
);
412 /* re-arm the watchdog */
413 schedule_delayed_work(&ts
->esd_work
,
414 round_jiffies_relative(
415 msecs_to_jiffies(ts
->esd_timeout
)));
418 static int tsc200x_open(struct input_dev
*input
)
420 struct tsc200x
*ts
= input_get_drvdata(input
);
422 mutex_lock(&ts
->mutex
);
425 __tsc200x_enable(ts
);
429 mutex_unlock(&ts
->mutex
);
434 static void tsc200x_close(struct input_dev
*input
)
436 struct tsc200x
*ts
= input_get_drvdata(input
);
438 mutex_lock(&ts
->mutex
);
441 __tsc200x_disable(ts
);
445 mutex_unlock(&ts
->mutex
);
448 int tsc200x_probe(struct device
*dev
, int irq
, const struct input_id
*tsc_id
,
449 struct regmap
*regmap
,
450 int (*tsc200x_cmd
)(struct device
*dev
, u8 cmd
))
453 struct input_dev
*input_dev
;
459 dev_err(dev
, "no irq\n");
464 return PTR_ERR(regmap
);
467 dev_err(dev
, "no cmd function\n");
471 ts
= devm_kzalloc(dev
, sizeof(*ts
), GFP_KERNEL
);
475 input_dev
= devm_input_allocate_device(dev
);
481 ts
->idev
= input_dev
;
483 ts
->tsc200x_cmd
= tsc200x_cmd
;
485 error
= device_property_read_u32(dev
, "ti,x-plate-ohms", &x_plate_ohm
);
486 ts
->x_plate_ohm
= error
? TSC200X_DEF_RESISTOR
: x_plate_ohm
;
488 error
= device_property_read_u32(dev
, "ti,esd-recovery-timeout-ms",
490 ts
->esd_timeout
= error
? 0 : esd_timeout
;
492 ts
->reset_gpio
= devm_gpiod_get_optional(dev
, "reset", GPIOD_OUT_HIGH
);
493 if (IS_ERR(ts
->reset_gpio
)) {
494 error
= PTR_ERR(ts
->reset_gpio
);
495 dev_err(dev
, "error acquiring reset gpio: %d\n", error
);
499 ts
->vio
= devm_regulator_get(dev
, "vio");
500 if (IS_ERR(ts
->vio
)) {
501 error
= PTR_ERR(ts
->vio
);
502 dev_err(dev
, "error acquiring vio regulator: %d", error
);
506 mutex_init(&ts
->mutex
);
508 spin_lock_init(&ts
->lock
);
509 timer_setup(&ts
->penup_timer
, tsc200x_penup_timer
, 0);
511 INIT_DELAYED_WORK(&ts
->esd_work
, tsc200x_esd_work
);
513 snprintf(ts
->phys
, sizeof(ts
->phys
),
514 "%s/input-ts", dev_name(dev
));
516 if (tsc_id
->product
== 2004) {
517 input_dev
->name
= "TSC200X touchscreen";
519 input_dev
->name
= devm_kasprintf(dev
, GFP_KERNEL
,
520 "TSC%04d touchscreen",
522 if (!input_dev
->name
)
526 input_dev
->phys
= ts
->phys
;
527 input_dev
->id
= *tsc_id
;
529 input_dev
->open
= tsc200x_open
;
530 input_dev
->close
= tsc200x_close
;
532 input_set_drvdata(input_dev
, ts
);
534 __set_bit(INPUT_PROP_DIRECT
, input_dev
->propbit
);
535 input_set_capability(input_dev
, EV_KEY
, BTN_TOUCH
);
537 input_set_abs_params(input_dev
, ABS_X
,
538 0, MAX_12BIT
, TSC200X_DEF_X_FUZZ
, 0);
539 input_set_abs_params(input_dev
, ABS_Y
,
540 0, MAX_12BIT
, TSC200X_DEF_Y_FUZZ
, 0);
541 input_set_abs_params(input_dev
, ABS_PRESSURE
,
542 0, MAX_12BIT
, TSC200X_DEF_P_FUZZ
, 0);
544 touchscreen_parse_properties(input_dev
, false, NULL
);
546 /* Ensure the touchscreen is off */
547 tsc200x_stop_scan(ts
);
549 error
= devm_request_threaded_irq(dev
, irq
, NULL
,
551 IRQF_TRIGGER_RISING
| IRQF_ONESHOT
,
554 dev_err(dev
, "Failed to request irq, err: %d\n", error
);
558 error
= regulator_enable(ts
->vio
);
562 dev_set_drvdata(dev
, ts
);
563 error
= sysfs_create_group(&dev
->kobj
, &tsc200x_attr_group
);
566 "Failed to create sysfs attributes, err: %d\n", error
);
567 goto disable_regulator
;
570 error
= input_register_device(ts
->idev
);
573 "Failed to register input device, err: %d\n", error
);
574 goto err_remove_sysfs
;
577 irq_set_irq_wake(irq
, 1);
581 sysfs_remove_group(&dev
->kobj
, &tsc200x_attr_group
);
583 regulator_disable(ts
->vio
);
586 EXPORT_SYMBOL_GPL(tsc200x_probe
);
588 int tsc200x_remove(struct device
*dev
)
590 struct tsc200x
*ts
= dev_get_drvdata(dev
);
592 sysfs_remove_group(&dev
->kobj
, &tsc200x_attr_group
);
594 regulator_disable(ts
->vio
);
598 EXPORT_SYMBOL_GPL(tsc200x_remove
);
600 static int __maybe_unused
tsc200x_suspend(struct device
*dev
)
602 struct tsc200x
*ts
= dev_get_drvdata(dev
);
604 mutex_lock(&ts
->mutex
);
606 if (!ts
->suspended
&& ts
->opened
)
607 __tsc200x_disable(ts
);
609 ts
->suspended
= true;
611 mutex_unlock(&ts
->mutex
);
616 static int __maybe_unused
tsc200x_resume(struct device
*dev
)
618 struct tsc200x
*ts
= dev_get_drvdata(dev
);
620 mutex_lock(&ts
->mutex
);
622 if (ts
->suspended
&& ts
->opened
)
623 __tsc200x_enable(ts
);
625 ts
->suspended
= false;
627 mutex_unlock(&ts
->mutex
);
632 SIMPLE_DEV_PM_OPS(tsc200x_pm_ops
, tsc200x_suspend
, tsc200x_resume
);
633 EXPORT_SYMBOL_GPL(tsc200x_pm_ops
);
635 MODULE_AUTHOR("Lauri Leukkunen <lauri.leukkunen@nokia.com>");
636 MODULE_DESCRIPTION("TSC200x Touchscreen Driver Core");
637 MODULE_LICENSE("GPL");