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 <[email protected]>
   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 <[email protected]>");
 459 MODULE_DESCRIPTION("I2C connected EETI EXC3000 multiple touch controller driver");
 460 MODULE_LICENSE("GPL v2");