drivers/input/touchscreen/ili210x.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 #include <linux/delay.h>
   3 #include <linux/gpio/consumer.h>
   4 #include <linux/i2c.h>
   5 #include <linux/input.h>
   6 #include <linux/input/mt.h>
   7 #include <linux/input/touchscreen.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/module.h>
  10 #include <linux/of_device.h>
  11 #include <linux/sizes.h>
  12 #include <linux/slab.h>
  13 #include <asm/unaligned.h>
  14
  15 #define ILI2XXX_POLL_PERIOD     20
  16
  17 #define ILI210X_DATA_SIZE       64
  18 #define ILI211X_DATA_SIZE       43
  19 #define ILI251X_DATA_SIZE1      31
  20 #define ILI251X_DATA_SIZE2      20
  21
  22 /* Touchscreen commands */
  23 #define REG_TOUCHDATA           0x10
  24 #define REG_PANEL_INFO          0x20
  25 #define REG_CALIBRATE           0xcc
  26
  27 struct ili2xxx_chip {
  28         int (*read_reg)(struct i2c_client *client, u8 reg,
  29                         void *buf, size_t len);
  30         int (*get_touch_data)(struct i2c_client *client, u8 *data);
  31         bool (*parse_touch_data)(const u8 *data, unsigned int finger,
  32                                  unsigned int *x, unsigned int *y,
  33                                  unsigned int *z);
  34         bool (*continue_polling)(const u8 *data, bool touch);
  35         unsigned int max_touches;
  36         unsigned int resolution;
  37         bool has_calibrate_reg;
  38         bool has_pressure_reg;
  39 };
  40
  41 struct ili210x {
  42         struct i2c_client *client;
  43         struct input_dev *input;
  44         struct gpio_desc *reset_gpio;
  45         struct touchscreen_properties prop;
  46         const struct ili2xxx_chip *chip;
  47         bool stop;
  48 };
  49
  50 static int ili210x_read_reg(struct i2c_client *client,
  51                             u8 reg, void *buf, size_t len)
  52 {
  53         struct i2c_msg msg[] = {
  54                 {
  55                         .addr   = client->addr,
  56                         .flags  = 0,
  57                         .len    = 1,
  58                         .buf    = &reg,
  59                 },
  60                 {
  61                         .addr   = client->addr,
  62                         .flags  = I2C_M_RD,
  63                         .len    = len,
  64                         .buf    = buf,
  65                 }
  66         };
  67         int error, ret;
  68
  69         ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
  70         if (ret != ARRAY_SIZE(msg)) {
  71                 error = ret < 0 ? ret : -EIO;
  72                 dev_err(&client->dev, "%s failed: %d\n", __func__, error);
  73                 return error;
  74         }
  75
  76         return 0;
  77 }
  78
  79 static int ili210x_read_touch_data(struct i2c_client *client, u8 *data)
  80 {
  81         return ili210x_read_reg(client, REG_TOUCHDATA,
  82                                 data, ILI210X_DATA_SIZE);
  83 }
  84
  85 static bool ili210x_touchdata_to_coords(const u8 *touchdata,
  86                                         unsigned int finger,
  87                                         unsigned int *x, unsigned int *y,
  88                                         unsigned int *z)
  89 {
  90         if (!(touchdata[0] & BIT(finger)))
  91                 return false;
  92
  93         *x = get_unaligned_be16(touchdata + 1 + (finger * 4) + 0);
  94         *y = get_unaligned_be16(touchdata + 1 + (finger * 4) + 2);
  95
  96         return true;
  97 }
  98
  99 static bool ili210x_check_continue_polling(const u8 *data, bool touch)
 100 {
 101         return data[0] & 0xf3;
 102 }
 103
 104 static const struct ili2xxx_chip ili210x_chip = {
 105         .read_reg               = ili210x_read_reg,
 106         .get_touch_data         = ili210x_read_touch_data,
 107         .parse_touch_data       = ili210x_touchdata_to_coords,
 108         .continue_polling       = ili210x_check_continue_polling,
 109         .max_touches            = 2,
 110         .has_calibrate_reg      = true,
 111 };
 112
 113 static int ili211x_read_touch_data(struct i2c_client *client, u8 *data)
 114 {
 115         s16 sum = 0;
 116         int error;
 117         int ret;
 118         int i;
 119
 120         ret = i2c_master_recv(client, data, ILI211X_DATA_SIZE);
 121         if (ret != ILI211X_DATA_SIZE) {
 122                 error = ret < 0 ? ret : -EIO;
 123                 dev_err(&client->dev, "%s failed: %d\n", __func__, error);
 124                 return error;
 125         }
 126
 127         /* This chip uses custom checksum at the end of data */
 128         for (i = 0; i < ILI211X_DATA_SIZE - 1; i++)
 129                 sum = (sum + data[i]) & 0xff;
 130
 131         if ((-sum & 0xff) != data[ILI211X_DATA_SIZE - 1]) {
 132                 dev_err(&client->dev,
 133                         "CRC error (crc=0x%02x expected=0x%02x)\n",
 134                         sum, data[ILI211X_DATA_SIZE - 1]);
 135                 return -EIO;
 136         }
 137
 138         return 0;
 139 }
 140
 141 static bool ili211x_touchdata_to_coords(const u8 *touchdata,
 142                                         unsigned int finger,
 143                                         unsigned int *x, unsigned int *y,
 144                                         unsigned int *z)
 145 {
 146         u32 data;
 147
 148         data = get_unaligned_be32(touchdata + 1 + (finger * 4) + 0);
 149         if (data == 0xffffffff) /* Finger up */
 150                 return false;
 151
 152         *x = ((touchdata[1 + (finger * 4) + 0] & 0xf0) << 4) |
 153              touchdata[1 + (finger * 4) + 1];
 154         *y = ((touchdata[1 + (finger * 4) + 0] & 0x0f) << 8) |
 155              touchdata[1 + (finger * 4) + 2];
 156
 157         return true;
 158 }
 159
 160 static bool ili211x_decline_polling(const u8 *data, bool touch)
 161 {
 162         return false;
 163 }
 164
 165 static const struct ili2xxx_chip ili211x_chip = {
 166         .read_reg               = ili210x_read_reg,
 167         .get_touch_data         = ili211x_read_touch_data,
 168         .parse_touch_data       = ili211x_touchdata_to_coords,
 169         .continue_polling       = ili211x_decline_polling,
 170         .max_touches            = 10,
 171         .resolution             = 2048,
 172 };
 173
 174 static bool ili212x_touchdata_to_coords(const u8 *touchdata,
 175                                         unsigned int finger,
 176                                         unsigned int *x, unsigned int *y,
 177                                         unsigned int *z)
 178 {
 179         u16 val;
 180
 181         val = get_unaligned_be16(touchdata + 3 + (finger * 5) + 0);
 182         if (!(val & BIT(15)))   /* Touch indication */
 183                 return false;
 184
 185         *x = val & 0x3fff;
 186         *y = get_unaligned_be16(touchdata + 3 + (finger * 5) + 2);
 187
 188         return true;
 189 }
 190
 191 static bool ili212x_check_continue_polling(const u8 *data, bool touch)
 192 {
 193         return touch;
 194 }
 195
 196 static const struct ili2xxx_chip ili212x_chip = {
 197         .read_reg               = ili210x_read_reg,
 198         .get_touch_data         = ili210x_read_touch_data,
 199         .parse_touch_data       = ili212x_touchdata_to_coords,
 200         .continue_polling       = ili212x_check_continue_polling,
 201         .max_touches            = 10,
 202         .has_calibrate_reg      = true,
 203 };
 204
 205 static int ili251x_read_reg(struct i2c_client *client,
 206                             u8 reg, void *buf, size_t len)
 207 {
 208         int error;
 209         int ret;
 210
 211         ret = i2c_master_send(client, &reg, 1);
 212         if (ret == 1) {
 213                 usleep_range(5000, 5500);
 214
 215                 ret = i2c_master_recv(client, buf, len);
 216                 if (ret == len)
 217                         return 0;
 218         }
 219
 220         error = ret < 0 ? ret : -EIO;
 221         dev_err(&client->dev, "%s failed: %d\n", __func__, error);
 222         return ret;
 223 }
 224
 225 static int ili251x_read_touch_data(struct i2c_client *client, u8 *data)
 226 {
 227         int error;
 228
 229         error = ili251x_read_reg(client, REG_TOUCHDATA,
 230                                  data, ILI251X_DATA_SIZE1);
 231         if (!error && data[0] == 2) {
 232                 error = i2c_master_recv(client, data + ILI251X_DATA_SIZE1,
 233                                         ILI251X_DATA_SIZE2);
 234                 if (error >= 0 && error != ILI251X_DATA_SIZE2)
 235                         error = -EIO;
 236         }
 237
 238         return error;
 239 }
 240
 241 static bool ili251x_touchdata_to_coords(const u8 *touchdata,
 242                                         unsigned int finger,
 243                                         unsigned int *x, unsigned int *y,
 244                                         unsigned int *z)
 245 {
 246         u16 val;
 247
 248         val = get_unaligned_be16(touchdata + 1 + (finger * 5) + 0);
 249         if (!(val & BIT(15)))   /* Touch indication */
 250                 return false;
 251
 252         *x = val & 0x3fff;
 253         *y = get_unaligned_be16(touchdata + 1 + (finger * 5) + 2);
 254         *z = touchdata[1 + (finger * 5) + 4];
 255
 256         return true;
 257 }
 258
 259 static bool ili251x_check_continue_polling(const u8 *data, bool touch)
 260 {
 261         return touch;
 262 }
 263
 264 static const struct ili2xxx_chip ili251x_chip = {
 265         .read_reg               = ili251x_read_reg,
 266         .get_touch_data         = ili251x_read_touch_data,
 267         .parse_touch_data       = ili251x_touchdata_to_coords,
 268         .continue_polling       = ili251x_check_continue_polling,
 269         .max_touches            = 10,
 270         .has_calibrate_reg      = true,
 271         .has_pressure_reg       = true,
 272 };
 273
 274 static bool ili210x_report_events(struct ili210x *priv, u8 *touchdata)
 275 {
 276         struct input_dev *input = priv->input;
 277         int i;
 278         bool contact = false, touch;
 279         unsigned int x = 0, y = 0, z = 0;
 280
 281         for (i = 0; i < priv->chip->max_touches; i++) {
 282                 touch = priv->chip->parse_touch_data(touchdata, i, &x, &y, &z);
 283
 284                 input_mt_slot(input, i);
 285                 if (input_mt_report_slot_state(input, MT_TOOL_FINGER, touch)) {
 286                         touchscreen_report_pos(input, &priv->prop, x, y, true);
 287                         if (priv->chip->has_pressure_reg)
 288                                 input_report_abs(input, ABS_MT_PRESSURE, z);
 289                         contact = true;
 290                 }
 291         }
 292
 293         input_mt_report_pointer_emulation(input, false);
 294         input_sync(input);
 295
 296         return contact;
 297 }
 298
 299 static irqreturn_t ili210x_irq(int irq, void *irq_data)
 300 {
 301         struct ili210x *priv = irq_data;
 302         struct i2c_client *client = priv->client;
 303         const struct ili2xxx_chip *chip = priv->chip;
 304         u8 touchdata[ILI210X_DATA_SIZE] = { 0 };
 305         bool keep_polling;
 306         bool touch;
 307         int error;
 308
 309         do {
 310                 error = chip->get_touch_data(client, touchdata);
 311                 if (error) {
 312                         dev_err(&client->dev,
 313                                 "Unable to get touch data: %d\n", error);
 314                         break;
 315                 }
 316
 317                 touch = ili210x_report_events(priv, touchdata);
 318                 keep_polling = chip->continue_polling(touchdata, touch);
 319                 if (keep_polling)
 320                         msleep(ILI2XXX_POLL_PERIOD);
 321         } while (!priv->stop && keep_polling);
 322
 323         return IRQ_HANDLED;
 324 }
 325
 326 static ssize_t ili210x_calibrate(struct device *dev,
 327                                  struct device_attribute *attr,
 328                                  const char *buf, size_t count)
 329 {
 330         struct i2c_client *client = to_i2c_client(dev);
 331         struct ili210x *priv = i2c_get_clientdata(client);
 332         unsigned long calibrate;
 333         int rc;
 334         u8 cmd = REG_CALIBRATE;
 335
 336         if (kstrtoul(buf, 10, &calibrate))
 337                 return -EINVAL;
 338
 339         if (calibrate > 1)
 340                 return -EINVAL;
 341
 342         if (calibrate) {
 343                 rc = i2c_master_send(priv->client, &cmd, sizeof(cmd));
 344                 if (rc != sizeof(cmd))
 345                         return -EIO;
 346         }
 347
 348         return count;
 349 }
 350 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, ili210x_calibrate);
 351
 352 static struct attribute *ili210x_attributes[] = {
 353         &dev_attr_calibrate.attr,
 354         NULL,
 355 };
 356
 357 static umode_t ili210x_calibrate_visible(struct kobject *kobj,
 358                                           struct attribute *attr, int index)
 359 {
 360         struct device *dev = kobj_to_dev(kobj);
 361         struct i2c_client *client = to_i2c_client(dev);
 362         struct ili210x *priv = i2c_get_clientdata(client);
 363
 364         return priv->chip->has_calibrate_reg ? attr->mode : 0;
 365 }
 366
 367 static const struct attribute_group ili210x_attr_group = {
 368         .attrs = ili210x_attributes,
 369         .is_visible = ili210x_calibrate_visible,
 370 };
 371
 372 static void ili210x_power_down(void *data)
 373 {
 374         struct gpio_desc *reset_gpio = data;
 375
 376         gpiod_set_value_cansleep(reset_gpio, 1);
 377 }
 378
 379 static void ili210x_stop(void *data)
 380 {
 381         struct ili210x *priv = data;
 382
 383         /* Tell ISR to quit even if there is a contact. */
 384         priv->stop = true;
 385 }
 386
 387 static int ili210x_i2c_probe(struct i2c_client *client,
 388                              const struct i2c_device_id *id)
 389 {
 390         struct device *dev = &client->dev;
 391         const struct ili2xxx_chip *chip;
 392         struct ili210x *priv;
 393         struct gpio_desc *reset_gpio;
 394         struct input_dev *input;
 395         int error;
 396         unsigned int max_xy;
 397
 398         dev_dbg(dev, "Probing for ILI210X I2C Touschreen driver");
 399
 400         chip = device_get_match_data(dev);
 401         if (!chip && id)
 402                 chip = (const struct ili2xxx_chip *)id->driver_data;
 403         if (!chip) {
 404                 dev_err(&client->dev, "unknown device model\n");
 405                 return -ENODEV;
 406         }
 407
 408         if (client->irq <= 0) {
 409                 dev_err(dev, "No IRQ!\n");
 410                 return -EINVAL;
 411         }
 412
 413         reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 414         if (IS_ERR(reset_gpio))
 415                 return PTR_ERR(reset_gpio);
 416
 417         if (reset_gpio) {
 418                 error = devm_add_action_or_reset(dev, ili210x_power_down,
 419                                                  reset_gpio);
 420                 if (error)
 421                         return error;
 422
 423                 usleep_range(50, 100);
 424                 gpiod_set_value_cansleep(reset_gpio, 0);
 425                 msleep(100);
 426         }
 427
 428         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 429         if (!priv)
 430                 return -ENOMEM;
 431
 432         input = devm_input_allocate_device(dev);
 433         if (!input)
 434                 return -ENOMEM;
 435
 436         priv->client = client;
 437         priv->input = input;
 438         priv->reset_gpio = reset_gpio;
 439         priv->chip = chip;
 440         i2c_set_clientdata(client, priv);
 441
 442         /* Setup input device */
 443         input->name = "ILI210x Touchscreen";
 444         input->id.bustype = BUS_I2C;
 445
 446         /* Multi touch */
 447         max_xy = (chip->resolution ?: SZ_64K) - 1;
 448         input_set_abs_params(input, ABS_MT_POSITION_X, 0, max_xy, 0, 0);
 449         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, max_xy, 0, 0);
 450         if (priv->chip->has_pressure_reg)
 451                 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 0xa, 0, 0);
 452         touchscreen_parse_properties(input, true, &priv->prop);
 453
 454         error = input_mt_init_slots(input, priv->chip->max_touches,
 455                                     INPUT_MT_DIRECT);
 456         if (error) {
 457                 dev_err(dev, "Unable to set up slots, err: %d\n", error);
 458                 return error;
 459         }
 460
 461         error = devm_request_threaded_irq(dev, client->irq, NULL, ili210x_irq,
 462                                           IRQF_ONESHOT, client->name, priv);
 463         if (error) {
 464                 dev_err(dev, "Unable to request touchscreen IRQ, err: %d\n",
 465                         error);
 466                 return error;
 467         }
 468
 469         error = devm_add_action_or_reset(dev, ili210x_stop, priv);
 470         if (error)
 471                 return error;
 472
 473         error = devm_device_add_group(dev, &ili210x_attr_group);
 474         if (error) {
 475                 dev_err(dev, "Unable to create sysfs attributes, err: %d\n",
 476                         error);
 477                 return error;
 478         }
 479
 480         error = input_register_device(priv->input);
 481         if (error) {
 482                 dev_err(dev, "Cannot register input device, err: %d\n", error);
 483                 return error;
 484         }
 485
 486         return 0;
 487 }
 488
 489 static const struct i2c_device_id ili210x_i2c_id[] = {
 490         { "ili210x", (long)&ili210x_chip },
 491         { "ili2117", (long)&ili211x_chip },
 492         { "ili2120", (long)&ili212x_chip },
 493         { "ili251x", (long)&ili251x_chip },
 494         { }
 495 };
 496 MODULE_DEVICE_TABLE(i2c, ili210x_i2c_id);
 497
 498 static const struct of_device_id ili210x_dt_ids[] = {
 499         { .compatible = "ilitek,ili210x", .data = &ili210x_chip },
 500         { .compatible = "ilitek,ili2117", .data = &ili211x_chip },
 501         { .compatible = "ilitek,ili2120", .data = &ili212x_chip },
 502         { .compatible = "ilitek,ili251x", .data = &ili251x_chip },
 503         { }
 504 };
 505 MODULE_DEVICE_TABLE(of, ili210x_dt_ids);
 506
 507 static struct i2c_driver ili210x_ts_driver = {
 508         .driver = {
 509                 .name = "ili210x_i2c",
 510                 .of_match_table = ili210x_dt_ids,
 511         },
 512         .id_table = ili210x_i2c_id,
 513         .probe = ili210x_i2c_probe,
 514 };
 515
 516 module_i2c_driver(ili210x_ts_driver);
 517
 518 MODULE_AUTHOR("Olivier Sobrie <olivier@sobrie.be>");
 519 MODULE_DESCRIPTION("ILI210X I2C Touchscreen Driver");
 520 MODULE_LICENSE("GPL");