1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Driver for ChipOne icn8505 i2c touchscreen controller 4 * 5 * Copyright (c) 2015-2018 Red Hat Inc. 6 * 7 * Red Hat authors: 8 * Hans de Goede <hdegoede@redhat.com> 9 */ 10 11 #include <asm/unaligned.h> 12 #include <linux/acpi.h> 13 #include <linux/crc32.h> 14 #include <linux/delay.h> 15 #include <linux/firmware.h> 16 #include <linux/interrupt.h> 17 #include <linux/i2c.h> 18 #include <linux/input.h> 19 #include <linux/input/mt.h> 20 #include <linux/input/touchscreen.h> 21 #include <linux/module.h> 22 23 /* Normal operation mode defines */ 24 #define ICN8505_REG_ADDR_WIDTH 16 25 26 #define ICN8505_REG_POWER 0x0004 27 #define ICN8505_REG_TOUCHDATA 0x1000 28 #define ICN8505_REG_CONFIGDATA 0x8000 29 30 /* ICN8505_REG_POWER commands */ 31 #define ICN8505_POWER_ACTIVE 0x00 32 #define ICN8505_POWER_MONITOR 0x01 33 #define ICN8505_POWER_HIBERNATE 0x02 34 /* 35 * The Android driver uses these to turn on/off the charger filter, but the 36 * filter is way too aggressive making e.g. onscreen keyboards unusable. 37 */ 38 #define ICN8505_POWER_ENA_CHARGER_MODE 0x55 39 #define ICN8505_POWER_DIS_CHARGER_MODE 0x66 40 41 #define ICN8505_MAX_TOUCHES 10 42 43 /* Programming mode defines */ 44 #define ICN8505_PROG_I2C_ADDR 0x30 45 #define ICN8505_PROG_REG_ADDR_WIDTH 24 46 47 #define MAX_FW_UPLOAD_TRIES 3 48 49 struct icn8505_touch { 50 u8 slot; 51 u8 x[2]; 52 u8 y[2]; 53 u8 pressure; /* Seems more like finger width then pressure really */ 54 u8 event; 55 /* The difference between 2 and 3 is unclear */ 56 #define ICN8505_EVENT_NO_DATA 1 /* No finger seen yet since wakeup */ 57 #define ICN8505_EVENT_UPDATE1 2 /* New or updated coordinates */ 58 #define ICN8505_EVENT_UPDATE2 3 /* New or updated coordinates */ 59 #define ICN8505_EVENT_END 4 /* Finger lifted */ 60 } __packed; 61 62 struct icn8505_touch_data { 63 u8 softbutton; 64 u8 touch_count; 65 struct icn8505_touch touches[ICN8505_MAX_TOUCHES]; 66 } __packed; 67 68 struct icn8505_data { 69 struct i2c_client *client; 70 struct input_dev *input; 71 struct gpio_desc *wake_gpio; 72 struct touchscreen_properties prop; 73 char firmware_name[32]; 74 }; 75 76 static int icn8505_read_xfer(struct i2c_client *client, u16 i2c_addr, 77 int reg_addr, int reg_addr_width, 78 void *data, int len, bool silent) 79 { 80 u8 buf[3]; 81 int i, ret; 82 struct i2c_msg msg[2] = { 83 { 84 .addr = i2c_addr, 85 .buf = buf, 86 .len = reg_addr_width / 8, 87 }, 88 { 89 .addr = i2c_addr, 90 .flags = I2C_M_RD, 91 .buf = data, 92 .len = len, 93 } 94 }; 95 96 for (i = 0; i < (reg_addr_width / 8); i++) 97 buf[i] = (reg_addr >> (reg_addr_width - (i + 1) * 8)) & 0xff; 98 99 ret = i2c_transfer(client->adapter, msg, 2); 100 if (ret != ARRAY_SIZE(msg)) { 101 if (ret >= 0) 102 ret = -EIO; 103 if (!silent) 104 dev_err(&client->dev, 105 "Error reading addr %#x reg %#x: %d\n", 106 i2c_addr, reg_addr, ret); 107 return ret; 108 } 109 110 return 0; 111 } 112 113 static int icn8505_write_xfer(struct i2c_client *client, u16 i2c_addr, 114 int reg_addr, int reg_addr_width, 115 const void *data, int len, bool silent) 116 { 117 u8 buf[3 + 32]; /* 3 bytes for 24 bit reg-addr + 32 bytes max len */ 118 int i, ret; 119 struct i2c_msg msg = { 120 .addr = i2c_addr, 121 .buf = buf, 122 .len = reg_addr_width / 8 + len, 123 }; 124 125 if (WARN_ON(len > 32)) 126 return -EINVAL; 127 128 for (i = 0; i < (reg_addr_width / 8); i++) 129 buf[i] = (reg_addr >> (reg_addr_width - (i + 1) * 8)) & 0xff; 130 131 memcpy(buf + reg_addr_width / 8, data, len); 132 133 ret = i2c_transfer(client->adapter, &msg, 1); 134 if (ret != 1) { 135 if (ret >= 0) 136 ret = -EIO; 137 if (!silent) 138 dev_err(&client->dev, 139 "Error writing addr %#x reg %#x: %d\n", 140 i2c_addr, reg_addr, ret); 141 return ret; 142 } 143 144 return 0; 145 } 146 147 static int icn8505_read_data(struct icn8505_data *icn8505, int reg, 148 void *buf, int len) 149 { 150 return icn8505_read_xfer(icn8505->client, icn8505->client->addr, reg, 151 ICN8505_REG_ADDR_WIDTH, buf, len, false); 152 } 153 154 static int icn8505_read_reg_silent(struct icn8505_data *icn8505, int reg) 155 { 156 u8 buf; 157 int error; 158 159 error = icn8505_read_xfer(icn8505->client, icn8505->client->addr, reg, 160 ICN8505_REG_ADDR_WIDTH, &buf, 1, true); 161 if (error) 162 return error; 163 164 return buf; 165 } 166 167 static int icn8505_write_reg(struct icn8505_data *icn8505, int reg, u8 val) 168 { 169 return icn8505_write_xfer(icn8505->client, icn8505->client->addr, reg, 170 ICN8505_REG_ADDR_WIDTH, &val, 1, false); 171 } 172 173 static int icn8505_read_prog_data(struct icn8505_data *icn8505, int reg, 174 void *buf, int len) 175 { 176 return icn8505_read_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg, 177 ICN8505_PROG_REG_ADDR_WIDTH, buf, len, false); 178 } 179 180 static int icn8505_write_prog_data(struct icn8505_data *icn8505, int reg, 181 const void *buf, int len) 182 { 183 return icn8505_write_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg, 184 ICN8505_PROG_REG_ADDR_WIDTH, buf, len, false); 185 } 186 187 static int icn8505_write_prog_reg(struct icn8505_data *icn8505, int reg, u8 val) 188 { 189 return icn8505_write_xfer(icn8505->client, ICN8505_PROG_I2C_ADDR, reg, 190 ICN8505_PROG_REG_ADDR_WIDTH, &val, 1, false); 191 } 192 193 /* 194 * Note this function uses a number of magic register addresses and values, 195 * there are deliberately no defines for these because the algorithm is taken 196 * from the icn85xx Android driver and I do not want to make up possibly wrong 197 * names for the addresses and/or values. 198 */ 199 static int icn8505_try_fw_upload(struct icn8505_data *icn8505, 200 const struct firmware *fw) 201 { 202 struct device *dev = &icn8505->client->dev; 203 size_t offset, count; 204 int error; 205 u8 buf[4]; 206 u32 crc; 207 208 /* Put the controller in programming mode */ 209 error = icn8505_write_prog_reg(icn8505, 0xcc3355, 0x5a); 210 if (error) 211 return error; 212 213 usleep_range(2000, 5000); 214 215 error = icn8505_write_prog_reg(icn8505, 0x040400, 0x01); 216 if (error) 217 return error; 218 219 usleep_range(2000, 5000); 220 221 error = icn8505_read_prog_data(icn8505, 0x040002, buf, 1); 222 if (error) 223 return error; 224 225 if (buf[0] != 0x85) { 226 dev_err(dev, "Failed to enter programming mode\n"); 227 return -ENODEV; 228 } 229 230 usleep_range(1000, 5000); 231 232 /* Enable CRC mode */ 233 error = icn8505_write_prog_reg(icn8505, 0x40028, 1); 234 if (error) 235 return error; 236 237 /* Send the firmware to SRAM */ 238 for (offset = 0; offset < fw->size; offset += count) { 239 count = min_t(size_t, fw->size - offset, 32); 240 error = icn8505_write_prog_data(icn8505, offset, 241 fw->data + offset, count); 242 if (error) 243 return error; 244 } 245 246 /* Disable CRC mode */ 247 error = icn8505_write_prog_reg(icn8505, 0x40028, 0); 248 if (error) 249 return error; 250 251 /* Get and check length and CRC */ 252 error = icn8505_read_prog_data(icn8505, 0x40034, buf, 2); 253 if (error) 254 return error; 255 256 if (get_unaligned_le16(buf) != fw->size) { 257 dev_warn(dev, "Length mismatch after uploading fw\n"); 258 return -EIO; 259 } 260 261 error = icn8505_read_prog_data(icn8505, 0x4002c, buf, 4); 262 if (error) 263 return error; 264 265 crc = crc32_be(0, fw->data, fw->size); 266 if (get_unaligned_le32(buf) != crc) { 267 dev_warn(dev, "CRC mismatch after uploading fw\n"); 268 return -EIO; 269 } 270 271 /* Boot controller from SRAM */ 272 error = icn8505_write_prog_reg(icn8505, 0x40400, 0x03); 273 if (error) 274 return error; 275 276 usleep_range(2000, 5000); 277 return 0; 278 } 279 280 static int icn8505_upload_fw(struct icn8505_data *icn8505) 281 { 282 struct device *dev = &icn8505->client->dev; 283 const struct firmware *fw; 284 int i, error; 285 286 /* 287 * Always load the firmware, even if we don't need it at boot, we 288 * we may need it at resume. Having loaded it once will make the 289 * firmware class code cache it at suspend/resume. 290 */ 291 error = firmware_request_platform(&fw, icn8505->firmware_name, dev); 292 if (error) { 293 dev_err(dev, "Firmware request error %d\n", error); 294 return error; 295 } 296 297 /* Check if the controller is not already up and running */ 298 if (icn8505_read_reg_silent(icn8505, 0x000a) == 0x85) 299 goto success; 300 301 for (i = 1; i <= MAX_FW_UPLOAD_TRIES; i++) { 302 error = icn8505_try_fw_upload(icn8505, fw); 303 if (!error) 304 goto success; 305 306 dev_err(dev, "Failed to upload firmware: %d (attempt %d/%d)\n", 307 error, i, MAX_FW_UPLOAD_TRIES); 308 usleep_range(2000, 5000); 309 } 310 311 success: 312 release_firmware(fw); 313 return error; 314 } 315 316 static bool icn8505_touch_active(u8 event) 317 { 318 return event == ICN8505_EVENT_UPDATE1 || 319 event == ICN8505_EVENT_UPDATE2; 320 } 321 322 static irqreturn_t icn8505_irq(int irq, void *dev_id) 323 { 324 struct icn8505_data *icn8505 = dev_id; 325 struct device *dev = &icn8505->client->dev; 326 struct icn8505_touch_data touch_data; 327 int i, error; 328 329 error = icn8505_read_data(icn8505, ICN8505_REG_TOUCHDATA, 330 &touch_data, sizeof(touch_data)); 331 if (error) { 332 dev_err(dev, "Error reading touch data: %d\n", error); 333 return IRQ_HANDLED; 334 } 335 336 if (touch_data.touch_count > ICN8505_MAX_TOUCHES) { 337 dev_warn(dev, "Too many touches %d > %d\n", 338 touch_data.touch_count, ICN8505_MAX_TOUCHES); 339 touch_data.touch_count = ICN8505_MAX_TOUCHES; 340 } 341 342 for (i = 0; i < touch_data.touch_count; i++) { 343 struct icn8505_touch *touch = &touch_data.touches[i]; 344 bool act = icn8505_touch_active(touch->event); 345 346 input_mt_slot(icn8505->input, touch->slot); 347 input_mt_report_slot_state(icn8505->input, MT_TOOL_FINGER, act); 348 if (!act) 349 continue; 350 351 touchscreen_report_pos(icn8505->input, &icn8505->prop, 352 get_unaligned_le16(touch->x), 353 get_unaligned_le16(touch->y), 354 true); 355 } 356 357 input_mt_sync_frame(icn8505->input); 358 input_report_key(icn8505->input, KEY_LEFTMETA, 359 touch_data.softbutton == 1); 360 input_sync(icn8505->input); 361 362 return IRQ_HANDLED; 363 } 364 365 static int icn8505_probe_acpi(struct icn8505_data *icn8505, struct device *dev) 366 { 367 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 368 const char *subsys = "unknown"; 369 struct acpi_device *adev; 370 union acpi_object *obj; 371 acpi_status status; 372 373 adev = ACPI_COMPANION(dev); 374 if (!adev) 375 return -ENODEV; 376 377 status = acpi_evaluate_object(adev->handle, "_SUB", NULL, &buffer); 378 if (ACPI_SUCCESS(status)) { 379 obj = buffer.pointer; 380 if (obj->type == ACPI_TYPE_STRING) 381 subsys = obj->string.pointer; 382 else 383 dev_warn(dev, "Warning ACPI _SUB did not return a string\n"); 384 } else { 385 dev_warn(dev, "Warning ACPI _SUB failed: %#x\n", status); 386 buffer.pointer = NULL; 387 } 388 389 snprintf(icn8505->firmware_name, sizeof(icn8505->firmware_name), 390 "chipone/icn8505-%s.fw", subsys); 391 392 kfree(buffer.pointer); 393 return 0; 394 } 395 396 static int icn8505_probe(struct i2c_client *client) 397 { 398 struct device *dev = &client->dev; 399 struct icn8505_data *icn8505; 400 struct input_dev *input; 401 __le16 resolution[2]; 402 int error; 403 404 if (!client->irq) { 405 dev_err(dev, "No irq specified\n"); 406 return -EINVAL; 407 } 408 409 icn8505 = devm_kzalloc(dev, sizeof(*icn8505), GFP_KERNEL); 410 if (!icn8505) 411 return -ENOMEM; 412 413 input = devm_input_allocate_device(dev); 414 if (!input) 415 return -ENOMEM; 416 417 input->name = client->name; 418 input->id.bustype = BUS_I2C; 419 420 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); 421 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); 422 input_set_capability(input, EV_KEY, KEY_LEFTMETA); 423 424 icn8505->client = client; 425 icn8505->input = input; 426 input_set_drvdata(input, icn8505); 427 428 error = icn8505_probe_acpi(icn8505, dev); 429 if (error) 430 return error; 431 432 error = icn8505_upload_fw(icn8505); 433 if (error) 434 return error; 435 436 error = icn8505_read_data(icn8505, ICN8505_REG_CONFIGDATA, 437 resolution, sizeof(resolution)); 438 if (error) { 439 dev_err(dev, "Error reading resolution: %d\n", error); 440 return error; 441 } 442 443 input_set_abs_params(input, ABS_MT_POSITION_X, 0, 444 le16_to_cpu(resolution[0]) - 1, 0, 0); 445 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, 446 le16_to_cpu(resolution[1]) - 1, 0, 0); 447 448 touchscreen_parse_properties(input, true, &icn8505->prop); 449 if (!input_abs_get_max(input, ABS_MT_POSITION_X) || 450 !input_abs_get_max(input, ABS_MT_POSITION_Y)) { 451 dev_err(dev, "Error touchscreen-size-x and/or -y missing\n"); 452 return -EINVAL; 453 } 454 455 error = input_mt_init_slots(input, ICN8505_MAX_TOUCHES, 456 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 457 if (error) 458 return error; 459 460 error = devm_request_threaded_irq(dev, client->irq, NULL, icn8505_irq, 461 IRQF_ONESHOT, client->name, icn8505); 462 if (error) { 463 dev_err(dev, "Error requesting irq: %d\n", error); 464 return error; 465 } 466 467 error = input_register_device(input); 468 if (error) 469 return error; 470 471 i2c_set_clientdata(client, icn8505); 472 return 0; 473 } 474 475 static int __maybe_unused icn8505_suspend(struct device *dev) 476 { 477 struct icn8505_data *icn8505 = i2c_get_clientdata(to_i2c_client(dev)); 478 479 disable_irq(icn8505->client->irq); 480 481 icn8505_write_reg(icn8505, ICN8505_REG_POWER, ICN8505_POWER_HIBERNATE); 482 483 return 0; 484 } 485 486 static int __maybe_unused icn8505_resume(struct device *dev) 487 { 488 struct icn8505_data *icn8505 = i2c_get_clientdata(to_i2c_client(dev)); 489 int error; 490 491 error = icn8505_upload_fw(icn8505); 492 if (error) 493 return error; 494 495 enable_irq(icn8505->client->irq); 496 return 0; 497 } 498 499 static SIMPLE_DEV_PM_OPS(icn8505_pm_ops, icn8505_suspend, icn8505_resume); 500 501 static const struct acpi_device_id icn8505_acpi_match[] = { 502 { "CHPN0001" }, 503 { } 504 }; 505 MODULE_DEVICE_TABLE(acpi, icn8505_acpi_match); 506 507 static struct i2c_driver icn8505_driver = { 508 .driver = { 509 .name = "chipone_icn8505", 510 .pm = &icn8505_pm_ops, 511 .acpi_match_table = icn8505_acpi_match, 512 }, 513 .probe_new = icn8505_probe, 514 }; 515 516 module_i2c_driver(icn8505_driver); 517 518 MODULE_DESCRIPTION("ChipOne icn8505 I2C Touchscreen Driver"); 519 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); 520 MODULE_LICENSE("GPL"); 521