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 = ®, 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, ®, 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"); 521