drivers/input/touchscreen/exc3000.c

   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 void exc3000_shutdown_timer(void *timer)
 113 {
 114         timer_shutdown_sync(timer);
 115 }
 116
 117 static int exc3000_read_frame(struct exc3000_data *data, u8 *buf)
 118 {
 119         struct i2c_client *client = data->client;
 120         int ret;
 121
 122         ret = i2c_master_send(client, "'", 2);
 123         if (ret < 0)
 124                 return ret;
 125
 126         if (ret != 2)
 127                 return -EIO;
 128
 129         ret = i2c_master_recv(client, buf, EXC3000_LEN_FRAME);
 130         if (ret < 0)
 131                 return ret;
 132
 133         if (ret != EXC3000_LEN_FRAME)
 134                 return -EIO;
 135
 136         if (get_unaligned_le16(buf) != EXC3000_LEN_FRAME)
 137                 return -EINVAL;
 138
 139         return 0;
 140 }
 141
 142 static int exc3000_handle_mt_event(struct exc3000_data *data)
 143 {
 144         struct input_dev *input = data->input;
 145         int ret, total_slots;
 146         u8 *buf = data->buf;
 147
 148         total_slots = buf[3];
 149         if (!total_slots || total_slots > EXC3000_NUM_SLOTS) {
 150                 ret = -EINVAL;
 151                 goto out_fail;
 152         }
 153
 154         if (total_slots > EXC3000_SLOTS_PER_FRAME) {
 155                 /* Read 2nd frame to get the rest of the contacts. */
 156                 ret = exc3000_read_frame(data, buf + EXC3000_LEN_FRAME);
 157                 if (ret)
 158                         goto out_fail;
 159
 160                 /* 2nd chunk must have number of contacts set to 0. */
 161                 if (buf[EXC3000_LEN_FRAME + 3] != 0) {
 162                         ret = -EINVAL;
 163                         goto out_fail;
 164                 }
 165         }
 166
 167         /*
 168          * We read full state successfully, no contacts will be "stuck".
 169          */
 170         del_timer_sync(&data->timer);
 171
 172         while (total_slots > 0) {
 173                 int slots = min(total_slots, EXC3000_SLOTS_PER_FRAME);
 174
 175                 exc3000_report_slots(input, &data->prop, buf + 4, slots);
 176                 total_slots -= slots;
 177                 buf += EXC3000_LEN_FRAME;
 178         }
 179
 180         input_mt_sync_frame(input);
 181         input_sync(input);
 182
 183         return 0;
 184
 185 out_fail:
 186         /* Schedule a timer to release "stuck" contacts */
 187         exc3000_schedule_timer(data);
 188
 189         return ret;
 190 }
 191
 192 static irqreturn_t exc3000_interrupt(int irq, void *dev_id)
 193 {
 194         struct exc3000_data *data = dev_id;
 195         u8 *buf = data->buf;
 196         int ret;
 197
 198         ret = exc3000_read_frame(data, buf);
 199         if (ret) {
 200                 /* Schedule a timer to release "stuck" contacts */
 201                 exc3000_schedule_timer(data);
 202                 goto out;
 203         }
 204
 205         switch (buf[2]) {
 206         case EXC3000_VENDOR_EVENT:
 207                 complete(&data->wait_event);
 208                 break;
 209
 210         case EXC3000_MT1_EVENT:
 211         case EXC3000_MT2_EVENT:
 212                 exc3000_handle_mt_event(data);
 213                 break;
 214
 215         default:
 216                 break;
 217         }
 218
 219 out:
 220         return IRQ_HANDLED;
 221 }
 222
 223 static int exc3000_vendor_data_request(struct exc3000_data *data, u8 *request,
 224                                        u8 request_len, u8 *response, int timeout)
 225 {
 226         u8 buf[EXC3000_LEN_VENDOR_REQUEST] = { 0x67, 0x00, 0x42, 0x00, 0x03 };
 227         int ret;
 228         unsigned long time_left;
 229
 230         mutex_lock(&data->query_lock);
 231
 232         reinit_completion(&data->wait_event);
 233
 234         buf[5] = request_len;
 235         memcpy(&buf[6], request, request_len);
 236
 237         ret = i2c_master_send(data->client, buf, EXC3000_LEN_VENDOR_REQUEST);
 238         if (ret < 0)
 239                 goto out_unlock;
 240
 241         if (response) {
 242                 time_left = wait_for_completion_timeout(&data->wait_event,
 243                                                         timeout * HZ);
 244                 if (time_left == 0) {
 245                         ret = -ETIMEDOUT;
 246                         goto out_unlock;
 247                 }
 248
 249                 if (data->buf[3] >= EXC3000_LEN_FRAME) {
 250                         ret = -ENOSPC;
 251                         goto out_unlock;
 252                 }
 253
 254                 memcpy(response, &data->buf[4], data->buf[3]);
 255                 ret = data->buf[3];
 256         }
 257
 258 out_unlock:
 259         mutex_unlock(&data->query_lock);
 260
 261         return ret;
 262 }
 263
 264 static ssize_t fw_version_show(struct device *dev,
 265                                struct device_attribute *attr, char *buf)
 266 {
 267         struct i2c_client *client = to_i2c_client(dev);
 268         struct exc3000_data *data = i2c_get_clientdata(client);
 269         u8 response[EXC3000_LEN_FRAME];
 270         int ret;
 271
 272         /* query bootloader info */
 273         ret = exc3000_vendor_data_request(data,
 274                                           (u8[]){0x39, 0x02}, 2, response, 1);
 275         if (ret < 0)
 276                 return ret;
 277
 278         /*
 279          * If the bootloader version is non-zero then the device is in
 280          * bootloader mode and won't answer a query for the application FW
 281          * version, so we just use the bootloader version info.
 282          */
 283         if (response[2] || response[3])
 284                 return sprintf(buf, "%d.%d\n", response[2], response[3]);
 285
 286         ret = exc3000_vendor_data_request(data, (u8[]){'D'}, 1, response, 1);
 287         if (ret < 0)
 288                 return ret;
 289
 290         return sprintf(buf, "%s\n", &response[1]);
 291 }
 292 static DEVICE_ATTR_RO(fw_version);
 293
 294 static ssize_t model_show(struct device *dev,
 295                           struct device_attribute *attr, char *buf)
 296 {
 297         struct i2c_client *client = to_i2c_client(dev);
 298         struct exc3000_data *data = i2c_get_clientdata(client);
 299         u8 response[EXC3000_LEN_FRAME];
 300         int ret;
 301
 302         ret = exc3000_vendor_data_request(data, (u8[]){'E'}, 1, response, 1);
 303         if (ret < 0)
 304                 return ret;
 305
 306         return sprintf(buf, "%s\n", &response[1]);
 307 }
 308 static DEVICE_ATTR_RO(model);
 309
 310 static ssize_t type_show(struct device *dev,
 311                           struct device_attribute *attr, char *buf)
 312 {
 313         struct i2c_client *client = to_i2c_client(dev);
 314         struct exc3000_data *data = i2c_get_clientdata(client);
 315         u8 response[EXC3000_LEN_FRAME];
 316         int ret;
 317
 318         ret = exc3000_vendor_data_request(data, (u8[]){'F'}, 1, response, 1);
 319         if (ret < 0)
 320                 return ret;
 321
 322         return sprintf(buf, "%s\n", &response[1]);
 323 }
 324 static DEVICE_ATTR_RO(type);
 325
 326 static struct attribute *sysfs_attrs[] = {
 327         &dev_attr_fw_version.attr,
 328         &dev_attr_model.attr,
 329         &dev_attr_type.attr,
 330         NULL
 331 };
 332
 333 static struct attribute_group exc3000_attribute_group = {
 334         .attrs = sysfs_attrs
 335 };
 336
 337 static int exc3000_probe(struct i2c_client *client)
 338 {
 339         struct exc3000_data *data;
 340         struct input_dev *input;
 341         int error, max_xy, retry;
 342
 343         data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
 344         if (!data)
 345                 return -ENOMEM;
 346
 347         data->client = client;
 348         data->info = device_get_match_data(&client->dev);
 349         if (!data->info) {
 350                 enum eeti_dev_id eeti_dev_id =
 351                         i2c_match_id(exc3000_id, client)->driver_data;
 352                 data->info = &exc3000_info[eeti_dev_id];
 353         }
 354         timer_setup(&data->timer, exc3000_timer, 0);
 355         init_completion(&data->wait_event);
 356         mutex_init(&data->query_lock);
 357
 358         data->reset = devm_gpiod_get_optional(&client->dev, "reset",
 359                                               GPIOD_OUT_HIGH);
 360         if (IS_ERR(data->reset))
 361                 return PTR_ERR(data->reset);
 362
 363         if (data->reset) {
 364                 msleep(EXC3000_RESET_MS);
 365                 gpiod_set_value_cansleep(data->reset, 0);
 366                 msleep(EXC3000_READY_MS);
 367         }
 368
 369         input = devm_input_allocate_device(&client->dev);
 370         if (!input)
 371                 return -ENOMEM;
 372
 373         data->input = input;
 374         input_set_drvdata(input, data);
 375
 376         input->name = data->info->name;
 377         input->id.bustype = BUS_I2C;
 378
 379         max_xy = data->info->max_xy;
 380         input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_xy, 0, 0);
 381         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_xy, 0, 0);
 382
 383         touchscreen_parse_properties(input, true, &data->prop);
 384
 385         error = input_mt_init_slots(input, EXC3000_NUM_SLOTS,
 386                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 387         if (error)
 388                 return error;
 389
 390         error = input_register_device(input);
 391         if (error)
 392                 return error;
 393
 394         error = devm_add_action_or_reset(&client->dev, exc3000_shutdown_timer,
 395                                          &data->timer);
 396         if (error)
 397                 return error;
 398
 399         error = devm_request_threaded_irq(&client->dev, client->irq,
 400                                           NULL, exc3000_interrupt, IRQF_ONESHOT,
 401                                           client->name, data);
 402         if (error)
 403                 return error;
 404
 405         /*
 406          * I²C does not have built-in recovery, so retry on failure. This
 407          * ensures, that the device probe will not fail for temporary issues
 408          * on the bus.  This is not needed for the sysfs calls (userspace
 409          * will receive the error code and can start another query) and
 410          * cannot be done for touch events (but that only means loosing one
 411          * or two touch events anyways).
 412          */
 413         for (retry = 0; retry < 3; retry++) {
 414                 u8 response[EXC3000_LEN_FRAME];
 415
 416                 error = exc3000_vendor_data_request(data, (u8[]){'E'}, 1,
 417                                                     response, 1);
 418                 if (error > 0) {
 419                         dev_dbg(&client->dev, "TS Model: %s", &response[1]);
 420                         error = 0;
 421                         break;
 422                 }
 423                 dev_warn(&client->dev, "Retry %d get EETI EXC3000 model: %d\n",
 424                          retry + 1, error);
 425         }
 426
 427         if (error)
 428                 return error;
 429
 430         i2c_set_clientdata(client, data);
 431
 432         error = devm_device_add_group(&client->dev, &exc3000_attribute_group);
 433         if (error)
 434                 return error;
 435
 436         return 0;
 437 }
 438
 439 static const struct i2c_device_id exc3000_id[] = {
 440         { "exc3000", EETI_EXC3000 },
 441         { "exc80h60", EETI_EXC80H60 },
 442         { "exc80h84", EETI_EXC80H84 },
 443         { }
 444 };
 445 MODULE_DEVICE_TABLE(i2c, exc3000_id);
 446
 447 #ifdef CONFIG_OF
 448 static const struct of_device_id exc3000_of_match[] = {
 449         { .compatible = "eeti,exc3000", .data = &exc3000_info[EETI_EXC3000] },
 450         { .compatible = "eeti,exc80h60", .data = &exc3000_info[EETI_EXC80H60] },
 451         { .compatible = "eeti,exc80h84", .data = &exc3000_info[EETI_EXC80H84] },
 452         { }
 453 };
 454 MODULE_DEVICE_TABLE(of, exc3000_of_match);
 455 #endif
 456
 457 static struct i2c_driver exc3000_driver = {
 458         .driver = {
 459                 .name   = "exc3000",
 460                 .of_match_table = of_match_ptr(exc3000_of_match),
 461         },
 462         .id_table       = exc3000_id,
 463         .probe_new      = exc3000_probe,
 464 };
 465
 466 module_i2c_driver(exc3000_driver);
 467
 468 MODULE_AUTHOR("Ahmet Inan <inan@distec.de>");
 469 MODULE_DESCRIPTION("I2C connected EETI EXC3000 multiple touch controller driver");
 470 MODULE_LICENSE("GPL v2");