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