1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for I2C connected EETI EXC3000 multiple touch controller 4 * 5 * Copyright (C) 2017 Ahmet Inan <inan@distec.de> 6 * 7 * minimal implementation based on egalax_ts.c and egalax_i2c.c 8 */ 9 10 #include <linux/bitops.h> 11 #include <linux/delay.h> 12 #include <linux/device.h> 13 #include <linux/gpio/consumer.h> 14 #include <linux/i2c.h> 15 #include <linux/input.h> 16 #include <linux/input/mt.h> 17 #include <linux/input/touchscreen.h> 18 #include <linux/interrupt.h> 19 #include <linux/module.h> 20 #include <linux/of.h> 21 #include <linux/sizes.h> 22 #include <linux/timer.h> 23 #include <asm/unaligned.h> 24 25 #define EXC3000_NUM_SLOTS 10 26 #define EXC3000_SLOTS_PER_FRAME 5 27 #define EXC3000_LEN_FRAME 66 28 #define EXC3000_LEN_VENDOR_REQUEST 68 29 #define EXC3000_LEN_POINT 10 30 31 #define EXC3000_LEN_MODEL_NAME 16 32 #define EXC3000_LEN_FW_VERSION 16 33 34 #define EXC3000_VENDOR_EVENT 0x03 35 #define EXC3000_MT1_EVENT 0x06 36 #define EXC3000_MT2_EVENT 0x18 37 38 #define EXC3000_TIMEOUT_MS 100 39 40 #define EXC3000_RESET_MS 10 41 #define EXC3000_READY_MS 100 42 43 static const struct i2c_device_id exc3000_id[]; 44 45 struct eeti_dev_info { 46 const char *name; 47 int max_xy; 48 }; 49 50 enum eeti_dev_id { 51 EETI_EXC3000, 52 EETI_EXC80H60, 53 EETI_EXC80H84, 54 }; 55 56 static struct eeti_dev_info exc3000_info[] = { 57 [EETI_EXC3000] = { 58 .name = "EETI EXC3000 Touch Screen", 59 .max_xy = SZ_4K - 1, 60 }, 61 [EETI_EXC80H60] = { 62 .name = "EETI EXC80H60 Touch Screen", 63 .max_xy = SZ_16K - 1, 64 }, 65 [EETI_EXC80H84] = { 66 .name = "EETI EXC80H84 Touch Screen", 67 .max_xy = SZ_16K - 1, 68 }, 69 }; 70 71 struct exc3000_data { 72 struct i2c_client *client; 73 const struct eeti_dev_info *info; 74 struct input_dev *input; 75 struct touchscreen_properties prop; 76 struct gpio_desc *reset; 77 struct timer_list timer; 78 u8 buf[2 * EXC3000_LEN_FRAME]; 79 struct completion wait_event; 80 struct mutex query_lock; 81 }; 82 83 static void exc3000_report_slots(struct input_dev *input, 84 struct touchscreen_properties *prop, 85 const u8 *buf, int num) 86 { 87 for (; num--; buf += EXC3000_LEN_POINT) { 88 if (buf[0] & BIT(0)) { 89 input_mt_slot(input, buf[1]); 90 input_mt_report_slot_state(input, MT_TOOL_FINGER, true); 91 touchscreen_report_pos(input, prop, 92 get_unaligned_le16(buf + 2), 93 get_unaligned_le16(buf + 4), 94 true); 95 } 96 } 97 } 98 99 static void exc3000_timer(struct timer_list *t) 100 { 101 struct exc3000_data *data = from_timer(data, t, timer); 102 103 input_mt_sync_frame(data->input); 104 input_sync(data->input); 105 } 106 107 static inline void exc3000_schedule_timer(struct exc3000_data *data) 108 { 109 mod_timer(&data->timer, jiffies + msecs_to_jiffies(EXC3000_TIMEOUT_MS)); 110 } 111 112 static int exc3000_read_frame(struct exc3000_data *data, u8 *buf) 113 { 114 struct i2c_client *client = data->client; 115 int ret; 116 117 ret = i2c_master_send(client, "'", 2); 118 if (ret < 0) 119 return ret; 120 121 if (ret != 2) 122 return -EIO; 123 124 ret = i2c_master_recv(client, buf, EXC3000_LEN_FRAME); 125 if (ret < 0) 126 return ret; 127 128 if (ret != EXC3000_LEN_FRAME) 129 return -EIO; 130 131 if (get_unaligned_le16(buf) != EXC3000_LEN_FRAME) 132 return -EINVAL; 133 134 return 0; 135 } 136 137 static int exc3000_handle_mt_event(struct exc3000_data *data) 138 { 139 struct input_dev *input = data->input; 140 int ret, total_slots; 141 u8 *buf = data->buf; 142 143 total_slots = buf[3]; 144 if (!total_slots || total_slots > EXC3000_NUM_SLOTS) { 145 ret = -EINVAL; 146 goto out_fail; 147 } 148 149 if (total_slots > EXC3000_SLOTS_PER_FRAME) { 150 /* Read 2nd frame to get the rest of the contacts. */ 151 ret = exc3000_read_frame(data, buf + EXC3000_LEN_FRAME); 152 if (ret) 153 goto out_fail; 154 155 /* 2nd chunk must have number of contacts set to 0. */ 156 if (buf[EXC3000_LEN_FRAME + 3] != 0) { 157 ret = -EINVAL; 158 goto out_fail; 159 } 160 } 161 162 /* 163 * We read full state successfully, no contacts will be "stuck". 164 */ 165 del_timer_sync(&data->timer); 166 167 while (total_slots > 0) { 168 int slots = min(total_slots, EXC3000_SLOTS_PER_FRAME); 169 170 exc3000_report_slots(input, &data->prop, buf + 4, slots); 171 total_slots -= slots; 172 buf += EXC3000_LEN_FRAME; 173 } 174 175 input_mt_sync_frame(input); 176 input_sync(input); 177 178 return 0; 179 180 out_fail: 181 /* Schedule a timer to release "stuck" contacts */ 182 exc3000_schedule_timer(data); 183 184 return ret; 185 } 186 187 static irqreturn_t exc3000_interrupt(int irq, void *dev_id) 188 { 189 struct exc3000_data *data = dev_id; 190 u8 *buf = data->buf; 191 int ret; 192 193 ret = exc3000_read_frame(data, buf); 194 if (ret) { 195 /* Schedule a timer to release "stuck" contacts */ 196 exc3000_schedule_timer(data); 197 goto out; 198 } 199 200 switch (buf[2]) { 201 case EXC3000_VENDOR_EVENT: 202 complete(&data->wait_event); 203 break; 204 205 case EXC3000_MT1_EVENT: 206 case EXC3000_MT2_EVENT: 207 exc3000_handle_mt_event(data); 208 break; 209 210 default: 211 break; 212 } 213 214 out: 215 return IRQ_HANDLED; 216 } 217 218 static int exc3000_vendor_data_request(struct exc3000_data *data, u8 *request, 219 u8 request_len, u8 *response, int timeout) 220 { 221 u8 buf[EXC3000_LEN_VENDOR_REQUEST] = { 0x67, 0x00, 0x42, 0x00, 0x03 }; 222 int ret; 223 unsigned long time_left; 224 225 mutex_lock(&data->query_lock); 226 227 reinit_completion(&data->wait_event); 228 229 buf[5] = request_len; 230 memcpy(&buf[6], request, request_len); 231 232 ret = i2c_master_send(data->client, buf, EXC3000_LEN_VENDOR_REQUEST); 233 if (ret < 0) 234 goto out_unlock; 235 236 if (response) { 237 time_left = wait_for_completion_timeout(&data->wait_event, 238 timeout * HZ); 239 if (time_left == 0) { 240 ret = -ETIMEDOUT; 241 goto out_unlock; 242 } 243 244 if (data->buf[3] >= EXC3000_LEN_FRAME) { 245 ret = -ENOSPC; 246 goto out_unlock; 247 } 248 249 memcpy(response, &data->buf[4], data->buf[3]); 250 ret = data->buf[3]; 251 } 252 253 out_unlock: 254 mutex_unlock(&data->query_lock); 255 256 return ret; 257 } 258 259 static ssize_t fw_version_show(struct device *dev, 260 struct device_attribute *attr, char *buf) 261 { 262 struct i2c_client *client = to_i2c_client(dev); 263 struct exc3000_data *data = i2c_get_clientdata(client); 264 u8 response[EXC3000_LEN_FRAME]; 265 int ret; 266 267 /* query bootloader info */ 268 ret = exc3000_vendor_data_request(data, 269 (u8[]){0x39, 0x02}, 2, response, 1); 270 if (ret < 0) 271 return ret; 272 273 /* 274 * If the bootloader version is non-zero then the device is in 275 * bootloader mode and won't answer a query for the application FW 276 * version, so we just use the bootloader version info. 277 */ 278 if (response[2] || response[3]) 279 return sprintf(buf, "%d.%d\n", response[2], response[3]); 280 281 ret = exc3000_vendor_data_request(data, (u8[]){'D'}, 1, response, 1); 282 if (ret < 0) 283 return ret; 284 285 return sprintf(buf, "%s\n", &response[1]); 286 } 287 static DEVICE_ATTR_RO(fw_version); 288 289 static ssize_t model_show(struct device *dev, 290 struct device_attribute *attr, char *buf) 291 { 292 struct i2c_client *client = to_i2c_client(dev); 293 struct exc3000_data *data = i2c_get_clientdata(client); 294 u8 response[EXC3000_LEN_FRAME]; 295 int ret; 296 297 ret = exc3000_vendor_data_request(data, (u8[]){'E'}, 1, response, 1); 298 if (ret < 0) 299 return ret; 300 301 return sprintf(buf, "%s\n", &response[1]); 302 } 303 static DEVICE_ATTR_RO(model); 304 305 static ssize_t type_show(struct device *dev, 306 struct device_attribute *attr, char *buf) 307 { 308 struct i2c_client *client = to_i2c_client(dev); 309 struct exc3000_data *data = i2c_get_clientdata(client); 310 u8 response[EXC3000_LEN_FRAME]; 311 int ret; 312 313 ret = exc3000_vendor_data_request(data, (u8[]){'F'}, 1, response, 1); 314 if (ret < 0) 315 return ret; 316 317 return sprintf(buf, "%s\n", &response[1]); 318 } 319 static DEVICE_ATTR_RO(type); 320 321 static struct attribute *sysfs_attrs[] = { 322 &dev_attr_fw_version.attr, 323 &dev_attr_model.attr, 324 &dev_attr_type.attr, 325 NULL 326 }; 327 328 static struct attribute_group exc3000_attribute_group = { 329 .attrs = sysfs_attrs 330 }; 331 332 static int exc3000_probe(struct i2c_client *client) 333 { 334 struct exc3000_data *data; 335 struct input_dev *input; 336 int error, max_xy, retry; 337 338 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL); 339 if (!data) 340 return -ENOMEM; 341 342 data->client = client; 343 data->info = device_get_match_data(&client->dev); 344 if (!data->info) { 345 enum eeti_dev_id eeti_dev_id = 346 i2c_match_id(exc3000_id, client)->driver_data; 347 data->info = &exc3000_info[eeti_dev_id]; 348 } 349 timer_setup(&data->timer, exc3000_timer, 0); 350 init_completion(&data->wait_event); 351 mutex_init(&data->query_lock); 352 353 data->reset = devm_gpiod_get_optional(&client->dev, "reset", 354 GPIOD_OUT_HIGH); 355 if (IS_ERR(data->reset)) 356 return PTR_ERR(data->reset); 357 358 if (data->reset) { 359 msleep(EXC3000_RESET_MS); 360 gpiod_set_value_cansleep(data->reset, 0); 361 msleep(EXC3000_READY_MS); 362 } 363 364 input = devm_input_allocate_device(&client->dev); 365 if (!input) 366 return -ENOMEM; 367 368 data->input = input; 369 input_set_drvdata(input, data); 370 371 input->name = data->info->name; 372 input->id.bustype = BUS_I2C; 373 374 max_xy = data->info->max_xy; 375 input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_xy, 0, 0); 376 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_xy, 0, 0); 377 378 touchscreen_parse_properties(input, true, &data->prop); 379 380 error = input_mt_init_slots(input, EXC3000_NUM_SLOTS, 381 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 382 if (error) 383 return error; 384 385 error = input_register_device(input); 386 if (error) 387 return error; 388 389 error = devm_request_threaded_irq(&client->dev, client->irq, 390 NULL, exc3000_interrupt, IRQF_ONESHOT, 391 client->name, data); 392 if (error) 393 return error; 394 395 /* 396 * I²C does not have built-in recovery, so retry on failure. This 397 * ensures, that the device probe will not fail for temporary issues 398 * on the bus. This is not needed for the sysfs calls (userspace 399 * will receive the error code and can start another query) and 400 * cannot be done for touch events (but that only means loosing one 401 * or two touch events anyways). 402 */ 403 for (retry = 0; retry < 3; retry++) { 404 u8 response[EXC3000_LEN_FRAME]; 405 406 error = exc3000_vendor_data_request(data, (u8[]){'E'}, 1, 407 response, 1); 408 if (error > 0) { 409 dev_dbg(&client->dev, "TS Model: %s", &response[1]); 410 error = 0; 411 break; 412 } 413 dev_warn(&client->dev, "Retry %d get EETI EXC3000 model: %d\n", 414 retry + 1, error); 415 } 416 417 if (error) 418 return error; 419 420 i2c_set_clientdata(client, data); 421 422 error = devm_device_add_group(&client->dev, &exc3000_attribute_group); 423 if (error) 424 return error; 425 426 return 0; 427 } 428 429 static const struct i2c_device_id exc3000_id[] = { 430 { "exc3000", EETI_EXC3000 }, 431 { "exc80h60", EETI_EXC80H60 }, 432 { "exc80h84", EETI_EXC80H84 }, 433 { } 434 }; 435 MODULE_DEVICE_TABLE(i2c, exc3000_id); 436 437 #ifdef CONFIG_OF 438 static const struct of_device_id exc3000_of_match[] = { 439 { .compatible = "eeti,exc3000", .data = &exc3000_info[EETI_EXC3000] }, 440 { .compatible = "eeti,exc80h60", .data = &exc3000_info[EETI_EXC80H60] }, 441 { .compatible = "eeti,exc80h84", .data = &exc3000_info[EETI_EXC80H84] }, 442 { } 443 }; 444 MODULE_DEVICE_TABLE(of, exc3000_of_match); 445 #endif 446 447 static struct i2c_driver exc3000_driver = { 448 .driver = { 449 .name = "exc3000", 450 .of_match_table = of_match_ptr(exc3000_of_match), 451 }, 452 .id_table = exc3000_id, 453 .probe_new = exc3000_probe, 454 }; 455 456 module_i2c_driver(exc3000_driver); 457 458 MODULE_AUTHOR("Ahmet Inan <inan@distec.de>"); 459 MODULE_DESCRIPTION("I2C connected EETI EXC3000 multiple touch controller driver"); 460 MODULE_LICENSE("GPL v2"); 461