1 // SPDX-License-Identifier: GPL-2.0-only
3 * Driver for I2C connected EETI EXC3000 multiple touch controller
5 * Copyright (C) 2017 Ahmet Inan <inan@distec.de>
7 * minimal implementation based on egalax_ts.c and egalax_i2c.c
10 #include <linux/acpi.h>
11 #include <linux/bitops.h>
12 #include <linux/delay.h>
13 #include <linux/device.h>
14 #include <linux/gpio/consumer.h>
15 #include <linux/i2c.h>
16 #include <linux/input.h>
17 #include <linux/input/mt.h>
18 #include <linux/input/touchscreen.h>
19 #include <linux/interrupt.h>
20 #include <linux/module.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/sizes.h>
24 #include <linux/timer.h>
25 #include <linux/unaligned.h>
27 #define EXC3000_NUM_SLOTS 10
28 #define EXC3000_SLOTS_PER_FRAME 5
29 #define EXC3000_LEN_FRAME 66
30 #define EXC3000_LEN_VENDOR_REQUEST 68
31 #define EXC3000_LEN_POINT 10
33 #define EXC3000_LEN_MODEL_NAME 16
34 #define EXC3000_LEN_FW_VERSION 16
36 #define EXC3000_VENDOR_EVENT 0x03
37 #define EXC3000_MT1_EVENT 0x06
38 #define EXC3000_MT2_EVENT 0x18
40 #define EXC3000_TIMEOUT_MS 100
42 #define EXC3000_RESET_MS 10
43 #define EXC3000_READY_MS 100
45 static const struct i2c_device_id exc3000_id
[];
47 struct eeti_dev_info
{
59 static struct eeti_dev_info exc3000_info
[] = {
61 .name
= "EETI EXC3000 Touch Screen",
65 .name
= "EETI EXC80H60 Touch Screen",
69 .name
= "EETI EXC80H84 Touch Screen",
73 .name
= "EETI EXC81W32 Touch Screen",
79 struct i2c_client
*client
;
80 const struct eeti_dev_info
*info
;
81 struct input_dev
*input
;
82 struct touchscreen_properties prop
;
83 struct gpio_desc
*reset
;
84 struct timer_list timer
;
85 u8 buf
[2 * EXC3000_LEN_FRAME
];
86 struct completion wait_event
;
87 struct mutex query_lock
;
90 static void exc3000_report_slots(struct input_dev
*input
,
91 struct touchscreen_properties
*prop
,
92 const u8
*buf
, int num
)
94 for (; num
--; buf
+= EXC3000_LEN_POINT
) {
95 if (buf
[0] & BIT(0)) {
96 input_mt_slot(input
, buf
[1]);
97 input_mt_report_slot_state(input
, MT_TOOL_FINGER
, true);
98 touchscreen_report_pos(input
, prop
,
99 get_unaligned_le16(buf
+ 2),
100 get_unaligned_le16(buf
+ 4),
106 static void exc3000_timer(struct timer_list
*t
)
108 struct exc3000_data
*data
= from_timer(data
, t
, timer
);
110 input_mt_sync_frame(data
->input
);
111 input_sync(data
->input
);
114 static inline void exc3000_schedule_timer(struct exc3000_data
*data
)
116 mod_timer(&data
->timer
, jiffies
+ msecs_to_jiffies(EXC3000_TIMEOUT_MS
));
119 static void exc3000_shutdown_timer(void *timer
)
121 timer_shutdown_sync(timer
);
124 static int exc3000_read_frame(struct exc3000_data
*data
, u8
*buf
)
126 struct i2c_client
*client
= data
->client
;
129 ret
= i2c_master_send(client
, "'", 2);
136 ret
= i2c_master_recv(client
, buf
, EXC3000_LEN_FRAME
);
140 if (ret
!= EXC3000_LEN_FRAME
)
143 if (get_unaligned_le16(buf
) != EXC3000_LEN_FRAME
)
149 static int exc3000_handle_mt_event(struct exc3000_data
*data
)
151 struct input_dev
*input
= data
->input
;
152 int ret
, total_slots
;
155 total_slots
= buf
[3];
156 if (!total_slots
|| total_slots
> EXC3000_NUM_SLOTS
) {
161 if (total_slots
> EXC3000_SLOTS_PER_FRAME
) {
162 /* Read 2nd frame to get the rest of the contacts. */
163 ret
= exc3000_read_frame(data
, buf
+ EXC3000_LEN_FRAME
);
167 /* 2nd chunk must have number of contacts set to 0. */
168 if (buf
[EXC3000_LEN_FRAME
+ 3] != 0) {
175 * We read full state successfully, no contacts will be "stuck".
177 del_timer_sync(&data
->timer
);
179 while (total_slots
> 0) {
180 int slots
= min(total_slots
, EXC3000_SLOTS_PER_FRAME
);
182 exc3000_report_slots(input
, &data
->prop
, buf
+ 4, slots
);
183 total_slots
-= slots
;
184 buf
+= EXC3000_LEN_FRAME
;
187 input_mt_sync_frame(input
);
193 /* Schedule a timer to release "stuck" contacts */
194 exc3000_schedule_timer(data
);
199 static irqreturn_t
exc3000_interrupt(int irq
, void *dev_id
)
201 struct exc3000_data
*data
= dev_id
;
205 ret
= exc3000_read_frame(data
, buf
);
207 /* Schedule a timer to release "stuck" contacts */
208 exc3000_schedule_timer(data
);
213 case EXC3000_VENDOR_EVENT
:
214 complete(&data
->wait_event
);
217 case EXC3000_MT1_EVENT
:
218 case EXC3000_MT2_EVENT
:
219 exc3000_handle_mt_event(data
);
230 static int exc3000_vendor_data_request(struct exc3000_data
*data
, u8
*request
,
231 u8 request_len
, u8
*response
, int timeout
)
233 u8 buf
[EXC3000_LEN_VENDOR_REQUEST
] = { 0x67, 0x00, 0x42, 0x00, 0x03 };
235 unsigned long time_left
;
237 mutex_lock(&data
->query_lock
);
239 reinit_completion(&data
->wait_event
);
241 buf
[5] = request_len
;
242 memcpy(&buf
[6], request
, request_len
);
244 ret
= i2c_master_send(data
->client
, buf
, EXC3000_LEN_VENDOR_REQUEST
);
249 time_left
= wait_for_completion_timeout(&data
->wait_event
,
251 if (time_left
== 0) {
256 if (data
->buf
[3] >= EXC3000_LEN_FRAME
) {
261 memcpy(response
, &data
->buf
[4], data
->buf
[3]);
266 mutex_unlock(&data
->query_lock
);
271 static ssize_t
fw_version_show(struct device
*dev
,
272 struct device_attribute
*attr
, char *buf
)
274 struct i2c_client
*client
= to_i2c_client(dev
);
275 struct exc3000_data
*data
= i2c_get_clientdata(client
);
276 u8 response
[EXC3000_LEN_FRAME
];
279 /* query bootloader info */
280 ret
= exc3000_vendor_data_request(data
,
281 (u8
[]){0x39, 0x02}, 2, response
, 1);
286 * If the bootloader version is non-zero then the device is in
287 * bootloader mode and won't answer a query for the application FW
288 * version, so we just use the bootloader version info.
290 if (response
[2] || response
[3])
291 return sprintf(buf
, "%d.%d\n", response
[2], response
[3]);
293 ret
= exc3000_vendor_data_request(data
, (u8
[]){'D'}, 1, response
, 1);
297 return sprintf(buf
, "%s\n", &response
[1]);
299 static DEVICE_ATTR_RO(fw_version
);
301 static ssize_t
model_show(struct device
*dev
,
302 struct device_attribute
*attr
, char *buf
)
304 struct i2c_client
*client
= to_i2c_client(dev
);
305 struct exc3000_data
*data
= i2c_get_clientdata(client
);
306 u8 response
[EXC3000_LEN_FRAME
];
309 ret
= exc3000_vendor_data_request(data
, (u8
[]){'E'}, 1, response
, 1);
313 return sprintf(buf
, "%s\n", &response
[1]);
315 static DEVICE_ATTR_RO(model
);
317 static ssize_t
type_show(struct device
*dev
,
318 struct device_attribute
*attr
, char *buf
)
320 struct i2c_client
*client
= to_i2c_client(dev
);
321 struct exc3000_data
*data
= i2c_get_clientdata(client
);
322 u8 response
[EXC3000_LEN_FRAME
];
325 ret
= exc3000_vendor_data_request(data
, (u8
[]){'F'}, 1, response
, 1);
329 return sprintf(buf
, "%s\n", &response
[1]);
331 static DEVICE_ATTR_RO(type
);
333 static struct attribute
*exc3000_attrs
[] = {
334 &dev_attr_fw_version
.attr
,
335 &dev_attr_model
.attr
,
339 ATTRIBUTE_GROUPS(exc3000
);
341 static int exc3000_probe(struct i2c_client
*client
)
343 struct exc3000_data
*data
;
344 struct input_dev
*input
;
345 int error
, max_xy
, retry
;
347 data
= devm_kzalloc(&client
->dev
, sizeof(*data
), GFP_KERNEL
);
351 data
->client
= client
;
352 data
->info
= device_get_match_data(&client
->dev
);
354 enum eeti_dev_id eeti_dev_id
=
355 i2c_match_id(exc3000_id
, client
)->driver_data
;
356 data
->info
= &exc3000_info
[eeti_dev_id
];
358 timer_setup(&data
->timer
, exc3000_timer
, 0);
359 init_completion(&data
->wait_event
);
360 mutex_init(&data
->query_lock
);
362 data
->reset
= devm_gpiod_get_optional(&client
->dev
, "reset",
364 if (IS_ERR(data
->reset
))
365 return PTR_ERR(data
->reset
);
367 /* For proper reset sequence, enable power while reset asserted */
368 error
= devm_regulator_get_enable(&client
->dev
, "vdd");
369 if (error
&& error
!= -ENODEV
)
370 return dev_err_probe(&client
->dev
, error
,
371 "failed to request vdd regulator\n");
374 msleep(EXC3000_RESET_MS
);
375 gpiod_set_value_cansleep(data
->reset
, 0);
376 msleep(EXC3000_READY_MS
);
379 input
= devm_input_allocate_device(&client
->dev
);
384 input_set_drvdata(input
, data
);
386 input
->name
= data
->info
->name
;
387 input
->id
.bustype
= BUS_I2C
;
389 max_xy
= data
->info
->max_xy
;
390 input_set_abs_params(input
, ABS_MT_POSITION_X
, 0, max_xy
, 0, 0);
391 input_set_abs_params(input
, ABS_MT_POSITION_Y
, 0, max_xy
, 0, 0);
393 touchscreen_parse_properties(input
, true, &data
->prop
);
395 error
= input_mt_init_slots(input
, EXC3000_NUM_SLOTS
,
396 INPUT_MT_DIRECT
| INPUT_MT_DROP_UNUSED
);
400 error
= input_register_device(input
);
404 error
= devm_add_action_or_reset(&client
->dev
, exc3000_shutdown_timer
,
409 error
= devm_request_threaded_irq(&client
->dev
, client
->irq
,
410 NULL
, exc3000_interrupt
, IRQF_ONESHOT
,
416 * I²C does not have built-in recovery, so retry on failure. This
417 * ensures, that the device probe will not fail for temporary issues
418 * on the bus. This is not needed for the sysfs calls (userspace
419 * will receive the error code and can start another query) and
420 * cannot be done for touch events (but that only means loosing one
421 * or two touch events anyways).
423 for (retry
= 0; retry
< 3; retry
++) {
424 u8 response
[EXC3000_LEN_FRAME
];
426 error
= exc3000_vendor_data_request(data
, (u8
[]){'E'}, 1,
429 dev_dbg(&client
->dev
, "TS Model: %s", &response
[1]);
433 dev_warn(&client
->dev
, "Retry %d get EETI EXC3000 model: %d\n",
440 i2c_set_clientdata(client
, data
);
445 static const struct i2c_device_id exc3000_id
[] = {
446 { "exc3000", EETI_EXC3000
},
447 { "exc80h60", EETI_EXC80H60
},
448 { "exc80h84", EETI_EXC80H84
},
449 { "exc81w32", EETI_EXC81W32
},
452 MODULE_DEVICE_TABLE(i2c
, exc3000_id
);
455 static const struct of_device_id exc3000_of_match
[] = {
456 { .compatible
= "eeti,exc3000", .data
= &exc3000_info
[EETI_EXC3000
] },
457 { .compatible
= "eeti,exc80h60", .data
= &exc3000_info
[EETI_EXC80H60
] },
458 { .compatible
= "eeti,exc80h84", .data
= &exc3000_info
[EETI_EXC80H84
] },
459 { .compatible
= "eeti,exc81w32", .data
= &exc3000_info
[EETI_EXC81W32
] },
462 MODULE_DEVICE_TABLE(of
, exc3000_of_match
);
466 static const struct acpi_device_id exc3000_acpi_match
[] = {
467 { "EGA00001", .driver_data
= (kernel_ulong_t
)&exc3000_info
[EETI_EXC80H60
] },
470 MODULE_DEVICE_TABLE(acpi
, exc3000_acpi_match
);
473 static struct i2c_driver exc3000_driver
= {
476 .dev_groups
= exc3000_groups
,
477 .of_match_table
= of_match_ptr(exc3000_of_match
),
478 .acpi_match_table
= ACPI_PTR(exc3000_acpi_match
),
480 .id_table
= exc3000_id
,
481 .probe
= exc3000_probe
,
484 module_i2c_driver(exc3000_driver
);
486 MODULE_AUTHOR("Ahmet Inan <inan@distec.de>");
487 MODULE_DESCRIPTION("I2C connected EETI EXC3000 multiple touch controller driver");
488 MODULE_LICENSE("GPL v2");