1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Azoteq IQS550/572/525 Trackpad/Touchscreen Controller 4 * 5 * Copyright (C) 2018 6 * Author: Jeff LaBundy <jeff@labundy.com> 7 * 8 * These devices require firmware exported from a PC-based configuration tool 9 * made available by the vendor. Firmware files may be pushed to the device's 10 * nonvolatile memory by writing the filename to the 'fw_file' sysfs control. 11 * 12 * Link to PC-based configuration tool and data sheet: http://www.azoteq.com/ 13 */ 14 15 #include <linux/delay.h> 16 #include <linux/device.h> 17 #include <linux/err.h> 18 #include <linux/firmware.h> 19 #include <linux/gpio/consumer.h> 20 #include <linux/i2c.h> 21 #include <linux/input.h> 22 #include <linux/input/mt.h> 23 #include <linux/input/touchscreen.h> 24 #include <linux/interrupt.h> 25 #include <linux/kernel.h> 26 #include <linux/module.h> 27 #include <linux/of_device.h> 28 #include <linux/slab.h> 29 #include <asm/unaligned.h> 30 31 #define IQS5XX_FW_FILE_LEN 64 32 #define IQS5XX_NUM_RETRIES 10 33 #define IQS5XX_NUM_POINTS 256 34 #define IQS5XX_NUM_CONTACTS 5 35 #define IQS5XX_WR_BYTES_MAX 2 36 37 #define IQS5XX_PROD_NUM_IQS550 40 38 #define IQS5XX_PROD_NUM_IQS572 58 39 #define IQS5XX_PROD_NUM_IQS525 52 40 #define IQS5XX_PROJ_NUM_A000 0 41 #define IQS5XX_PROJ_NUM_B000 15 42 #define IQS5XX_MAJOR_VER_MIN 2 43 44 #define IQS5XX_RESUME 0x00 45 #define IQS5XX_SUSPEND 0x01 46 47 #define IQS5XX_SW_INPUT_EVENT 0x10 48 #define IQS5XX_SETUP_COMPLETE 0x40 49 #define IQS5XX_EVENT_MODE 0x01 50 #define IQS5XX_TP_EVENT 0x04 51 52 #define IQS5XX_FLIP_X 0x01 53 #define IQS5XX_FLIP_Y 0x02 54 #define IQS5XX_SWITCH_XY_AXIS 0x04 55 56 #define IQS5XX_PROD_NUM 0x0000 57 #define IQS5XX_ABS_X 0x0016 58 #define IQS5XX_ABS_Y 0x0018 59 #define IQS5XX_SYS_CTRL0 0x0431 60 #define IQS5XX_SYS_CTRL1 0x0432 61 #define IQS5XX_SYS_CFG0 0x058E 62 #define IQS5XX_SYS_CFG1 0x058F 63 #define IQS5XX_TOTAL_RX 0x063D 64 #define IQS5XX_TOTAL_TX 0x063E 65 #define IQS5XX_XY_CFG0 0x0669 66 #define IQS5XX_X_RES 0x066E 67 #define IQS5XX_Y_RES 0x0670 68 #define IQS5XX_CHKSM 0x83C0 69 #define IQS5XX_APP 0x8400 70 #define IQS5XX_CSTM 0xBE00 71 #define IQS5XX_PMAP_END 0xBFFF 72 #define IQS5XX_END_COMM 0xEEEE 73 74 #define IQS5XX_CHKSM_LEN (IQS5XX_APP - IQS5XX_CHKSM) 75 #define IQS5XX_APP_LEN (IQS5XX_CSTM - IQS5XX_APP) 76 #define IQS5XX_CSTM_LEN (IQS5XX_PMAP_END + 1 - IQS5XX_CSTM) 77 #define IQS5XX_PMAP_LEN (IQS5XX_PMAP_END + 1 - IQS5XX_CHKSM) 78 79 #define IQS5XX_REC_HDR_LEN 4 80 #define IQS5XX_REC_LEN_MAX 255 81 #define IQS5XX_REC_TYPE_DATA 0x00 82 #define IQS5XX_REC_TYPE_EOF 0x01 83 84 #define IQS5XX_BL_ADDR_MASK 0x40 85 #define IQS5XX_BL_CMD_VER 0x00 86 #define IQS5XX_BL_CMD_READ 0x01 87 #define IQS5XX_BL_CMD_EXEC 0x02 88 #define IQS5XX_BL_CMD_CRC 0x03 89 #define IQS5XX_BL_BLK_LEN_MAX 64 90 #define IQS5XX_BL_ID 0x0200 91 #define IQS5XX_BL_STATUS_RESET 0x00 92 #define IQS5XX_BL_STATUS_AVAIL 0xA5 93 #define IQS5XX_BL_STATUS_NONE 0xEE 94 #define IQS5XX_BL_CRC_PASS 0x00 95 #define IQS5XX_BL_CRC_FAIL 0x01 96 #define IQS5XX_BL_ATTEMPTS 3 97 98 struct iqs5xx_private { 99 struct i2c_client *client; 100 struct input_dev *input; 101 struct gpio_desc *reset_gpio; 102 struct mutex lock; 103 u8 bl_status; 104 }; 105 106 struct iqs5xx_dev_id_info { 107 __be16 prod_num; 108 __be16 proj_num; 109 u8 major_ver; 110 u8 minor_ver; 111 u8 bl_status; 112 } __packed; 113 114 struct iqs5xx_ihex_rec { 115 char start; 116 char len[2]; 117 char addr[4]; 118 char type[2]; 119 char data[2]; 120 } __packed; 121 122 struct iqs5xx_touch_data { 123 __be16 abs_x; 124 __be16 abs_y; 125 __be16 strength; 126 u8 area; 127 } __packed; 128 129 static int iqs5xx_read_burst(struct i2c_client *client, 130 u16 reg, void *val, u16 len) 131 { 132 __be16 reg_buf = cpu_to_be16(reg); 133 int ret, i; 134 struct i2c_msg msg[] = { 135 { 136 .addr = client->addr, 137 .flags = 0, 138 .len = sizeof(reg_buf), 139 .buf = (u8 *)®_buf, 140 }, 141 { 142 .addr = client->addr, 143 .flags = I2C_M_RD, 144 .len = len, 145 .buf = (u8 *)val, 146 }, 147 }; 148 149 /* 150 * The first addressing attempt outside of a communication window fails 151 * and must be retried, after which the device clock stretches until it 152 * is available. 153 */ 154 for (i = 0; i < IQS5XX_NUM_RETRIES; i++) { 155 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); 156 if (ret == ARRAY_SIZE(msg)) 157 return 0; 158 159 usleep_range(200, 300); 160 } 161 162 if (ret >= 0) 163 ret = -EIO; 164 165 dev_err(&client->dev, "Failed to read from address 0x%04X: %d\n", 166 reg, ret); 167 168 return ret; 169 } 170 171 static int iqs5xx_read_word(struct i2c_client *client, u16 reg, u16 *val) 172 { 173 __be16 val_buf; 174 int error; 175 176 error = iqs5xx_read_burst(client, reg, &val_buf, sizeof(val_buf)); 177 if (error) 178 return error; 179 180 *val = be16_to_cpu(val_buf); 181 182 return 0; 183 } 184 185 static int iqs5xx_read_byte(struct i2c_client *client, u16 reg, u8 *val) 186 { 187 return iqs5xx_read_burst(client, reg, val, sizeof(*val)); 188 } 189 190 static int iqs5xx_write_burst(struct i2c_client *client, 191 u16 reg, const void *val, u16 len) 192 { 193 int ret, i; 194 u16 mlen = sizeof(reg) + len; 195 u8 mbuf[sizeof(reg) + IQS5XX_WR_BYTES_MAX]; 196 197 if (len > IQS5XX_WR_BYTES_MAX) 198 return -EINVAL; 199 200 put_unaligned_be16(reg, mbuf); 201 memcpy(mbuf + sizeof(reg), val, len); 202 203 /* 204 * The first addressing attempt outside of a communication window fails 205 * and must be retried, after which the device clock stretches until it 206 * is available. 207 */ 208 for (i = 0; i < IQS5XX_NUM_RETRIES; i++) { 209 ret = i2c_master_send(client, mbuf, mlen); 210 if (ret == mlen) 211 return 0; 212 213 usleep_range(200, 300); 214 } 215 216 if (ret >= 0) 217 ret = -EIO; 218 219 dev_err(&client->dev, "Failed to write to address 0x%04X: %d\n", 220 reg, ret); 221 222 return ret; 223 } 224 225 static int iqs5xx_write_word(struct i2c_client *client, u16 reg, u16 val) 226 { 227 __be16 val_buf = cpu_to_be16(val); 228 229 return iqs5xx_write_burst(client, reg, &val_buf, sizeof(val_buf)); 230 } 231 232 static int iqs5xx_write_byte(struct i2c_client *client, u16 reg, u8 val) 233 { 234 return iqs5xx_write_burst(client, reg, &val, sizeof(val)); 235 } 236 237 static void iqs5xx_reset(struct i2c_client *client) 238 { 239 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 240 241 gpiod_set_value_cansleep(iqs5xx->reset_gpio, 1); 242 usleep_range(200, 300); 243 244 gpiod_set_value_cansleep(iqs5xx->reset_gpio, 0); 245 } 246 247 static int iqs5xx_bl_cmd(struct i2c_client *client, u8 bl_cmd, u16 bl_addr) 248 { 249 struct i2c_msg msg; 250 int ret; 251 u8 mbuf[sizeof(bl_cmd) + sizeof(bl_addr)]; 252 253 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK; 254 msg.flags = 0; 255 msg.len = sizeof(bl_cmd); 256 msg.buf = mbuf; 257 258 *mbuf = bl_cmd; 259 260 switch (bl_cmd) { 261 case IQS5XX_BL_CMD_VER: 262 case IQS5XX_BL_CMD_CRC: 263 case IQS5XX_BL_CMD_EXEC: 264 break; 265 case IQS5XX_BL_CMD_READ: 266 msg.len += sizeof(bl_addr); 267 put_unaligned_be16(bl_addr, mbuf + sizeof(bl_cmd)); 268 break; 269 default: 270 return -EINVAL; 271 } 272 273 ret = i2c_transfer(client->adapter, &msg, 1); 274 if (ret != 1) 275 goto msg_fail; 276 277 switch (bl_cmd) { 278 case IQS5XX_BL_CMD_VER: 279 msg.len = sizeof(u16); 280 break; 281 case IQS5XX_BL_CMD_CRC: 282 msg.len = sizeof(u8); 283 /* 284 * This delay saves the bus controller the trouble of having to 285 * tolerate a relatively long clock-stretching period while the 286 * CRC is calculated. 287 */ 288 msleep(50); 289 break; 290 case IQS5XX_BL_CMD_EXEC: 291 usleep_range(10000, 10100); 292 /* fall through */ 293 default: 294 return 0; 295 } 296 297 msg.flags = I2C_M_RD; 298 299 ret = i2c_transfer(client->adapter, &msg, 1); 300 if (ret != 1) 301 goto msg_fail; 302 303 if (bl_cmd == IQS5XX_BL_CMD_VER && 304 get_unaligned_be16(mbuf) != IQS5XX_BL_ID) { 305 dev_err(&client->dev, "Unrecognized bootloader ID: 0x%04X\n", 306 get_unaligned_be16(mbuf)); 307 return -EINVAL; 308 } 309 310 if (bl_cmd == IQS5XX_BL_CMD_CRC && *mbuf != IQS5XX_BL_CRC_PASS) { 311 dev_err(&client->dev, "Bootloader CRC failed\n"); 312 return -EIO; 313 } 314 315 return 0; 316 317 msg_fail: 318 if (ret >= 0) 319 ret = -EIO; 320 321 if (bl_cmd != IQS5XX_BL_CMD_VER) 322 dev_err(&client->dev, 323 "Unsuccessful bootloader command 0x%02X: %d\n", 324 bl_cmd, ret); 325 326 return ret; 327 } 328 329 static int iqs5xx_bl_open(struct i2c_client *client) 330 { 331 int error, i, j; 332 333 /* 334 * The device opens a bootloader polling window for 2 ms following the 335 * release of reset. If the host cannot establish communication during 336 * this time frame, it must cycle reset again. 337 */ 338 for (i = 0; i < IQS5XX_BL_ATTEMPTS; i++) { 339 iqs5xx_reset(client); 340 341 for (j = 0; j < IQS5XX_NUM_RETRIES; j++) { 342 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0); 343 if (!error || error == -EINVAL) 344 return error; 345 } 346 } 347 348 dev_err(&client->dev, "Failed to open bootloader: %d\n", error); 349 350 return error; 351 } 352 353 static int iqs5xx_bl_write(struct i2c_client *client, 354 u16 bl_addr, u8 *pmap_data, u16 pmap_len) 355 { 356 struct i2c_msg msg; 357 int ret, i; 358 u8 mbuf[sizeof(bl_addr) + IQS5XX_BL_BLK_LEN_MAX]; 359 360 if (pmap_len % IQS5XX_BL_BLK_LEN_MAX) 361 return -EINVAL; 362 363 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK; 364 msg.flags = 0; 365 msg.len = sizeof(mbuf); 366 msg.buf = mbuf; 367 368 for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) { 369 put_unaligned_be16(bl_addr + i, mbuf); 370 memcpy(mbuf + sizeof(bl_addr), pmap_data + i, 371 sizeof(mbuf) - sizeof(bl_addr)); 372 373 ret = i2c_transfer(client->adapter, &msg, 1); 374 if (ret != 1) 375 goto msg_fail; 376 377 usleep_range(10000, 10100); 378 } 379 380 return 0; 381 382 msg_fail: 383 if (ret >= 0) 384 ret = -EIO; 385 386 dev_err(&client->dev, "Failed to write block at address 0x%04X: %d\n", 387 bl_addr + i, ret); 388 389 return ret; 390 } 391 392 static int iqs5xx_bl_verify(struct i2c_client *client, 393 u16 bl_addr, u8 *pmap_data, u16 pmap_len) 394 { 395 struct i2c_msg msg; 396 int ret, i; 397 u8 bl_data[IQS5XX_BL_BLK_LEN_MAX]; 398 399 if (pmap_len % IQS5XX_BL_BLK_LEN_MAX) 400 return -EINVAL; 401 402 msg.addr = client->addr ^ IQS5XX_BL_ADDR_MASK; 403 msg.flags = I2C_M_RD; 404 msg.len = sizeof(bl_data); 405 msg.buf = bl_data; 406 407 for (i = 0; i < pmap_len; i += IQS5XX_BL_BLK_LEN_MAX) { 408 ret = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_READ, bl_addr + i); 409 if (ret) 410 return ret; 411 412 ret = i2c_transfer(client->adapter, &msg, 1); 413 if (ret != 1) 414 goto msg_fail; 415 416 if (memcmp(bl_data, pmap_data + i, sizeof(bl_data))) { 417 dev_err(&client->dev, 418 "Failed to verify block at address 0x%04X\n", 419 bl_addr + i); 420 return -EIO; 421 } 422 } 423 424 return 0; 425 426 msg_fail: 427 if (ret >= 0) 428 ret = -EIO; 429 430 dev_err(&client->dev, "Failed to read block at address 0x%04X: %d\n", 431 bl_addr + i, ret); 432 433 return ret; 434 } 435 436 static int iqs5xx_set_state(struct i2c_client *client, u8 state) 437 { 438 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 439 int error1, error2; 440 441 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET) 442 return 0; 443 444 mutex_lock(&iqs5xx->lock); 445 446 /* 447 * Addressing the device outside of a communication window prompts it 448 * to assert the RDY output, so disable the interrupt line to prevent 449 * the handler from servicing a false interrupt. 450 */ 451 disable_irq(client->irq); 452 453 error1 = iqs5xx_write_byte(client, IQS5XX_SYS_CTRL1, state); 454 error2 = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0); 455 456 usleep_range(50, 100); 457 enable_irq(client->irq); 458 459 mutex_unlock(&iqs5xx->lock); 460 461 if (error1) 462 return error1; 463 464 return error2; 465 } 466 467 static int iqs5xx_open(struct input_dev *input) 468 { 469 struct iqs5xx_private *iqs5xx = input_get_drvdata(input); 470 471 return iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME); 472 } 473 474 static void iqs5xx_close(struct input_dev *input) 475 { 476 struct iqs5xx_private *iqs5xx = input_get_drvdata(input); 477 478 iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND); 479 } 480 481 static int iqs5xx_axis_init(struct i2c_client *client) 482 { 483 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 484 struct touchscreen_properties prop; 485 struct input_dev *input; 486 int error; 487 u16 max_x, max_x_hw; 488 u16 max_y, max_y_hw; 489 u8 val; 490 491 if (!iqs5xx->input) { 492 input = devm_input_allocate_device(&client->dev); 493 if (!input) 494 return -ENOMEM; 495 496 input->name = client->name; 497 input->id.bustype = BUS_I2C; 498 input->open = iqs5xx_open; 499 input->close = iqs5xx_close; 500 501 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); 502 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); 503 input_set_capability(input, EV_ABS, ABS_MT_PRESSURE); 504 505 error = input_mt_init_slots(input, 506 IQS5XX_NUM_CONTACTS, INPUT_MT_DIRECT); 507 if (error) { 508 dev_err(&client->dev, 509 "Failed to initialize slots: %d\n", error); 510 return error; 511 } 512 513 input_set_drvdata(input, iqs5xx); 514 iqs5xx->input = input; 515 } 516 517 touchscreen_parse_properties(iqs5xx->input, true, &prop); 518 519 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_RX, &val); 520 if (error) 521 return error; 522 max_x_hw = (val - 1) * IQS5XX_NUM_POINTS; 523 524 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_TX, &val); 525 if (error) 526 return error; 527 max_y_hw = (val - 1) * IQS5XX_NUM_POINTS; 528 529 error = iqs5xx_read_byte(client, IQS5XX_XY_CFG0, &val); 530 if (error) 531 return error; 532 533 if (val & IQS5XX_SWITCH_XY_AXIS) 534 swap(max_x_hw, max_y_hw); 535 536 if (prop.swap_x_y) 537 val ^= IQS5XX_SWITCH_XY_AXIS; 538 539 if (prop.invert_x) 540 val ^= prop.swap_x_y ? IQS5XX_FLIP_Y : IQS5XX_FLIP_X; 541 542 if (prop.invert_y) 543 val ^= prop.swap_x_y ? IQS5XX_FLIP_X : IQS5XX_FLIP_Y; 544 545 error = iqs5xx_write_byte(client, IQS5XX_XY_CFG0, val); 546 if (error) 547 return error; 548 549 if (prop.max_x > max_x_hw) { 550 dev_err(&client->dev, "Invalid maximum x-coordinate: %u > %u\n", 551 prop.max_x, max_x_hw); 552 return -EINVAL; 553 } else if (prop.max_x == 0) { 554 error = iqs5xx_read_word(client, IQS5XX_X_RES, &max_x); 555 if (error) 556 return error; 557 558 input_abs_set_max(iqs5xx->input, 559 prop.swap_x_y ? ABS_MT_POSITION_Y : 560 ABS_MT_POSITION_X, 561 max_x); 562 } else { 563 max_x = (u16)prop.max_x; 564 } 565 566 if (prop.max_y > max_y_hw) { 567 dev_err(&client->dev, "Invalid maximum y-coordinate: %u > %u\n", 568 prop.max_y, max_y_hw); 569 return -EINVAL; 570 } else if (prop.max_y == 0) { 571 error = iqs5xx_read_word(client, IQS5XX_Y_RES, &max_y); 572 if (error) 573 return error; 574 575 input_abs_set_max(iqs5xx->input, 576 prop.swap_x_y ? ABS_MT_POSITION_X : 577 ABS_MT_POSITION_Y, 578 max_y); 579 } else { 580 max_y = (u16)prop.max_y; 581 } 582 583 /* 584 * Write horizontal and vertical resolution to the device in case its 585 * original defaults were overridden or swapped as per the properties 586 * specified in the device tree. 587 */ 588 error = iqs5xx_write_word(client, 589 prop.swap_x_y ? IQS5XX_Y_RES : IQS5XX_X_RES, 590 max_x); 591 if (error) 592 return error; 593 594 return iqs5xx_write_word(client, 595 prop.swap_x_y ? IQS5XX_X_RES : IQS5XX_Y_RES, 596 max_y); 597 } 598 599 static int iqs5xx_dev_init(struct i2c_client *client) 600 { 601 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 602 struct iqs5xx_dev_id_info *dev_id_info; 603 int error; 604 u8 val; 605 u8 buf[sizeof(*dev_id_info) + 1]; 606 607 error = iqs5xx_read_burst(client, IQS5XX_PROD_NUM, 608 &buf[1], sizeof(*dev_id_info)); 609 if (error) 610 return iqs5xx_bl_open(client); 611 612 /* 613 * A000 and B000 devices use 8-bit and 16-bit addressing, respectively. 614 * Querying an A000 device's version information with 16-bit addressing 615 * gives the appearance that the data is shifted by one byte; a nonzero 616 * leading array element suggests this could be the case (in which case 617 * the missing zero is prepended). 618 */ 619 buf[0] = 0; 620 dev_id_info = (struct iqs5xx_dev_id_info *)&buf[(buf[1] > 0) ? 0 : 1]; 621 622 switch (be16_to_cpu(dev_id_info->prod_num)) { 623 case IQS5XX_PROD_NUM_IQS550: 624 case IQS5XX_PROD_NUM_IQS572: 625 case IQS5XX_PROD_NUM_IQS525: 626 break; 627 default: 628 dev_err(&client->dev, "Unrecognized product number: %u\n", 629 be16_to_cpu(dev_id_info->prod_num)); 630 return -EINVAL; 631 } 632 633 switch (be16_to_cpu(dev_id_info->proj_num)) { 634 case IQS5XX_PROJ_NUM_A000: 635 dev_err(&client->dev, "Unsupported project number: %u\n", 636 be16_to_cpu(dev_id_info->proj_num)); 637 return iqs5xx_bl_open(client); 638 case IQS5XX_PROJ_NUM_B000: 639 break; 640 default: 641 dev_err(&client->dev, "Unrecognized project number: %u\n", 642 be16_to_cpu(dev_id_info->proj_num)); 643 return -EINVAL; 644 } 645 646 if (dev_id_info->major_ver < IQS5XX_MAJOR_VER_MIN) { 647 dev_err(&client->dev, "Unsupported major version: %u\n", 648 dev_id_info->major_ver); 649 return iqs5xx_bl_open(client); 650 } 651 652 switch (dev_id_info->bl_status) { 653 case IQS5XX_BL_STATUS_AVAIL: 654 case IQS5XX_BL_STATUS_NONE: 655 break; 656 default: 657 dev_err(&client->dev, 658 "Unrecognized bootloader status: 0x%02X\n", 659 dev_id_info->bl_status); 660 return -EINVAL; 661 } 662 663 error = iqs5xx_axis_init(client); 664 if (error) 665 return error; 666 667 error = iqs5xx_read_byte(client, IQS5XX_SYS_CFG0, &val); 668 if (error) 669 return error; 670 671 val |= IQS5XX_SETUP_COMPLETE; 672 val &= ~IQS5XX_SW_INPUT_EVENT; 673 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG0, val); 674 if (error) 675 return error; 676 677 val = IQS5XX_TP_EVENT | IQS5XX_EVENT_MODE; 678 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG1, val); 679 if (error) 680 return error; 681 682 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0); 683 if (error) 684 return error; 685 686 iqs5xx->bl_status = dev_id_info->bl_status; 687 688 /* 689 * Closure of the first communication window that appears following the 690 * release of reset appears to kick off an initialization period during 691 * which further communication is met with clock stretching. The return 692 * from this function is delayed so that further communication attempts 693 * avoid this period. 694 */ 695 msleep(100); 696 697 return 0; 698 } 699 700 static irqreturn_t iqs5xx_irq(int irq, void *data) 701 { 702 struct iqs5xx_private *iqs5xx = data; 703 struct iqs5xx_touch_data touch_data[IQS5XX_NUM_CONTACTS]; 704 struct i2c_client *client = iqs5xx->client; 705 struct input_dev *input = iqs5xx->input; 706 int error, i; 707 708 /* 709 * This check is purely a precaution, as the device does not assert the 710 * RDY output during bootloader mode. If the device operates outside of 711 * bootloader mode, the input device is guaranteed to be allocated. 712 */ 713 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET) 714 return IRQ_NONE; 715 716 error = iqs5xx_read_burst(client, IQS5XX_ABS_X, 717 touch_data, sizeof(touch_data)); 718 if (error) 719 return IRQ_NONE; 720 721 for (i = 0; i < ARRAY_SIZE(touch_data); i++) { 722 u16 pressure = be16_to_cpu(touch_data[i].strength); 723 724 input_mt_slot(input, i); 725 if (input_mt_report_slot_state(input, MT_TOOL_FINGER, 726 pressure != 0)) { 727 input_report_abs(input, ABS_MT_POSITION_X, 728 be16_to_cpu(touch_data[i].abs_x)); 729 input_report_abs(input, ABS_MT_POSITION_Y, 730 be16_to_cpu(touch_data[i].abs_y)); 731 input_report_abs(input, ABS_MT_PRESSURE, pressure); 732 } 733 } 734 735 input_mt_sync_frame(input); 736 input_sync(input); 737 738 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0); 739 if (error) 740 return IRQ_NONE; 741 742 /* 743 * Once the communication window is closed, a small delay is added to 744 * ensure the device's RDY output has been deasserted by the time the 745 * interrupt handler returns. 746 */ 747 usleep_range(50, 100); 748 749 return IRQ_HANDLED; 750 } 751 752 static int iqs5xx_fw_file_parse(struct i2c_client *client, 753 const char *fw_file, u8 *pmap) 754 { 755 const struct firmware *fw; 756 struct iqs5xx_ihex_rec *rec; 757 size_t pos = 0; 758 int error, i; 759 u16 rec_num = 1; 760 u16 rec_addr; 761 u8 rec_len, rec_type, rec_chksm, chksm; 762 u8 rec_hdr[IQS5XX_REC_HDR_LEN]; 763 u8 rec_data[IQS5XX_REC_LEN_MAX]; 764 765 /* 766 * Firmware exported from the vendor's configuration tool deviates from 767 * standard ihex as follows: (1) the checksum for records corresponding 768 * to user-exported settings is not recalculated, and (2) an address of 769 * 0xFFFF is used for the EOF record. 770 * 771 * Because the ihex2fw tool tolerates neither (1) nor (2), the slightly 772 * nonstandard ihex firmware is parsed directly by the driver. 773 */ 774 error = request_firmware(&fw, fw_file, &client->dev); 775 if (error) { 776 dev_err(&client->dev, "Failed to request firmware %s: %d\n", 777 fw_file, error); 778 return error; 779 } 780 781 do { 782 if (pos + sizeof(*rec) > fw->size) { 783 dev_err(&client->dev, "Insufficient firmware size\n"); 784 error = -EINVAL; 785 break; 786 } 787 rec = (struct iqs5xx_ihex_rec *)(fw->data + pos); 788 pos += sizeof(*rec); 789 790 if (rec->start != ':') { 791 dev_err(&client->dev, "Invalid start at record %u\n", 792 rec_num); 793 error = -EINVAL; 794 break; 795 } 796 797 error = hex2bin(rec_hdr, rec->len, sizeof(rec_hdr)); 798 if (error) { 799 dev_err(&client->dev, "Invalid header at record %u\n", 800 rec_num); 801 break; 802 } 803 804 rec_len = *rec_hdr; 805 rec_addr = get_unaligned_be16(rec_hdr + sizeof(rec_len)); 806 rec_type = *(rec_hdr + sizeof(rec_len) + sizeof(rec_addr)); 807 808 if (pos + rec_len * 2 > fw->size) { 809 dev_err(&client->dev, "Insufficient firmware size\n"); 810 error = -EINVAL; 811 break; 812 } 813 pos += (rec_len * 2); 814 815 error = hex2bin(rec_data, rec->data, rec_len); 816 if (error) { 817 dev_err(&client->dev, "Invalid data at record %u\n", 818 rec_num); 819 break; 820 } 821 822 error = hex2bin(&rec_chksm, 823 rec->data + rec_len * 2, sizeof(rec_chksm)); 824 if (error) { 825 dev_err(&client->dev, "Invalid checksum at record %u\n", 826 rec_num); 827 break; 828 } 829 830 chksm = 0; 831 for (i = 0; i < sizeof(rec_hdr); i++) 832 chksm += rec_hdr[i]; 833 for (i = 0; i < rec_len; i++) 834 chksm += rec_data[i]; 835 chksm = ~chksm + 1; 836 837 if (chksm != rec_chksm && rec_addr < IQS5XX_CSTM) { 838 dev_err(&client->dev, 839 "Incorrect checksum at record %u\n", 840 rec_num); 841 error = -EINVAL; 842 break; 843 } 844 845 switch (rec_type) { 846 case IQS5XX_REC_TYPE_DATA: 847 if (rec_addr < IQS5XX_CHKSM || 848 rec_addr > IQS5XX_PMAP_END) { 849 dev_err(&client->dev, 850 "Invalid address at record %u\n", 851 rec_num); 852 error = -EINVAL; 853 } else { 854 memcpy(pmap + rec_addr - IQS5XX_CHKSM, 855 rec_data, rec_len); 856 } 857 break; 858 case IQS5XX_REC_TYPE_EOF: 859 break; 860 default: 861 dev_err(&client->dev, "Invalid type at record %u\n", 862 rec_num); 863 error = -EINVAL; 864 } 865 866 if (error) 867 break; 868 869 rec_num++; 870 while (pos < fw->size) { 871 if (*(fw->data + pos) == ':') 872 break; 873 pos++; 874 } 875 } while (rec_type != IQS5XX_REC_TYPE_EOF); 876 877 release_firmware(fw); 878 879 return error; 880 } 881 882 static int iqs5xx_fw_file_write(struct i2c_client *client, const char *fw_file) 883 { 884 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 885 int error; 886 u8 *pmap; 887 888 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_NONE) 889 return -EPERM; 890 891 pmap = kzalloc(IQS5XX_PMAP_LEN, GFP_KERNEL); 892 if (!pmap) 893 return -ENOMEM; 894 895 error = iqs5xx_fw_file_parse(client, fw_file, pmap); 896 if (error) 897 goto err_kfree; 898 899 mutex_lock(&iqs5xx->lock); 900 901 /* 902 * Disable the interrupt line in case the first attempt(s) to enter the 903 * bootloader don't happen quickly enough, in which case the device may 904 * assert the RDY output until the next attempt. 905 */ 906 disable_irq(client->irq); 907 908 iqs5xx->bl_status = IQS5XX_BL_STATUS_RESET; 909 910 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0); 911 if (error) { 912 error = iqs5xx_bl_open(client); 913 if (error) 914 goto err_reset; 915 } 916 917 error = iqs5xx_bl_write(client, IQS5XX_CHKSM, pmap, IQS5XX_PMAP_LEN); 918 if (error) 919 goto err_reset; 920 921 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_CRC, 0); 922 if (error) 923 goto err_reset; 924 925 error = iqs5xx_bl_verify(client, IQS5XX_CSTM, 926 pmap + IQS5XX_CHKSM_LEN + IQS5XX_APP_LEN, 927 IQS5XX_CSTM_LEN); 928 if (error) 929 goto err_reset; 930 931 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_EXEC, 0); 932 933 err_reset: 934 if (error) { 935 iqs5xx_reset(client); 936 usleep_range(10000, 10100); 937 } 938 939 error = iqs5xx_dev_init(client); 940 if (!error && iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET) 941 error = -EINVAL; 942 943 enable_irq(client->irq); 944 945 mutex_unlock(&iqs5xx->lock); 946 947 err_kfree: 948 kfree(pmap); 949 950 return error; 951 } 952 953 static ssize_t fw_file_store(struct device *dev, struct device_attribute *attr, 954 const char *buf, size_t count) 955 { 956 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 957 struct i2c_client *client = iqs5xx->client; 958 size_t len = count; 959 bool input_reg = !iqs5xx->input; 960 char fw_file[IQS5XX_FW_FILE_LEN + 1]; 961 int error; 962 963 if (!len) 964 return -EINVAL; 965 966 if (buf[len - 1] == '\n') 967 len--; 968 969 if (len > IQS5XX_FW_FILE_LEN) 970 return -ENAMETOOLONG; 971 972 memcpy(fw_file, buf, len); 973 fw_file[len] = '\0'; 974 975 error = iqs5xx_fw_file_write(client, fw_file); 976 if (error) 977 return error; 978 979 /* 980 * If the input device was not allocated already, it is guaranteed to 981 * be allocated by this point and can finally be registered. 982 */ 983 if (input_reg) { 984 error = input_register_device(iqs5xx->input); 985 if (error) { 986 dev_err(&client->dev, 987 "Failed to register device: %d\n", 988 error); 989 return error; 990 } 991 } 992 993 return count; 994 } 995 996 static DEVICE_ATTR_WO(fw_file); 997 998 static struct attribute *iqs5xx_attrs[] = { 999 &dev_attr_fw_file.attr, 1000 NULL, 1001 }; 1002 1003 static const struct attribute_group iqs5xx_attr_group = { 1004 .attrs = iqs5xx_attrs, 1005 }; 1006 1007 static int __maybe_unused iqs5xx_suspend(struct device *dev) 1008 { 1009 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 1010 struct input_dev *input = iqs5xx->input; 1011 int error = 0; 1012 1013 if (!input) 1014 return error; 1015 1016 mutex_lock(&input->mutex); 1017 1018 if (input->users) 1019 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND); 1020 1021 mutex_unlock(&input->mutex); 1022 1023 return error; 1024 } 1025 1026 static int __maybe_unused iqs5xx_resume(struct device *dev) 1027 { 1028 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 1029 struct input_dev *input = iqs5xx->input; 1030 int error = 0; 1031 1032 if (!input) 1033 return error; 1034 1035 mutex_lock(&input->mutex); 1036 1037 if (input->users) 1038 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME); 1039 1040 mutex_unlock(&input->mutex); 1041 1042 return error; 1043 } 1044 1045 static SIMPLE_DEV_PM_OPS(iqs5xx_pm, iqs5xx_suspend, iqs5xx_resume); 1046 1047 static int iqs5xx_probe(struct i2c_client *client, 1048 const struct i2c_device_id *id) 1049 { 1050 struct iqs5xx_private *iqs5xx; 1051 int error; 1052 1053 iqs5xx = devm_kzalloc(&client->dev, sizeof(*iqs5xx), GFP_KERNEL); 1054 if (!iqs5xx) 1055 return -ENOMEM; 1056 1057 dev_set_drvdata(&client->dev, iqs5xx); 1058 1059 i2c_set_clientdata(client, iqs5xx); 1060 iqs5xx->client = client; 1061 1062 iqs5xx->reset_gpio = devm_gpiod_get(&client->dev, 1063 "reset", GPIOD_OUT_LOW); 1064 if (IS_ERR(iqs5xx->reset_gpio)) { 1065 error = PTR_ERR(iqs5xx->reset_gpio); 1066 dev_err(&client->dev, "Failed to request GPIO: %d\n", error); 1067 return error; 1068 } 1069 1070 mutex_init(&iqs5xx->lock); 1071 1072 iqs5xx_reset(client); 1073 usleep_range(10000, 10100); 1074 1075 error = iqs5xx_dev_init(client); 1076 if (error) 1077 return error; 1078 1079 error = devm_request_threaded_irq(&client->dev, client->irq, 1080 NULL, iqs5xx_irq, IRQF_ONESHOT, 1081 client->name, iqs5xx); 1082 if (error) { 1083 dev_err(&client->dev, "Failed to request IRQ: %d\n", error); 1084 return error; 1085 } 1086 1087 error = devm_device_add_group(&client->dev, &iqs5xx_attr_group); 1088 if (error) { 1089 dev_err(&client->dev, "Failed to add attributes: %d\n", error); 1090 return error; 1091 } 1092 1093 if (iqs5xx->input) { 1094 error = input_register_device(iqs5xx->input); 1095 if (error) 1096 dev_err(&client->dev, 1097 "Failed to register device: %d\n", 1098 error); 1099 } 1100 1101 return error; 1102 } 1103 1104 static const struct i2c_device_id iqs5xx_id[] = { 1105 { "iqs550", 0 }, 1106 { "iqs572", 1 }, 1107 { "iqs525", 2 }, 1108 { } 1109 }; 1110 MODULE_DEVICE_TABLE(i2c, iqs5xx_id); 1111 1112 static const struct of_device_id iqs5xx_of_match[] = { 1113 { .compatible = "azoteq,iqs550" }, 1114 { .compatible = "azoteq,iqs572" }, 1115 { .compatible = "azoteq,iqs525" }, 1116 { } 1117 }; 1118 MODULE_DEVICE_TABLE(of, iqs5xx_of_match); 1119 1120 static struct i2c_driver iqs5xx_i2c_driver = { 1121 .driver = { 1122 .name = "iqs5xx", 1123 .of_match_table = iqs5xx_of_match, 1124 .pm = &iqs5xx_pm, 1125 }, 1126 .id_table = iqs5xx_id, 1127 .probe = iqs5xx_probe, 1128 }; 1129 module_i2c_driver(iqs5xx_i2c_driver); 1130 1131 MODULE_AUTHOR("Jeff LaBundy <jeff@labundy.com>"); 1132 MODULE_DESCRIPTION("Azoteq IQS550/572/525 Trackpad/Touchscreen Controller"); 1133 MODULE_LICENSE("GPL"); 1134