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 fallthrough; 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 input_set_drvdata(input, iqs5xx); 506 iqs5xx->input = input; 507 } 508 509 touchscreen_parse_properties(iqs5xx->input, true, &prop); 510 511 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_RX, &val); 512 if (error) 513 return error; 514 max_x_hw = (val - 1) * IQS5XX_NUM_POINTS; 515 516 error = iqs5xx_read_byte(client, IQS5XX_TOTAL_TX, &val); 517 if (error) 518 return error; 519 max_y_hw = (val - 1) * IQS5XX_NUM_POINTS; 520 521 error = iqs5xx_read_byte(client, IQS5XX_XY_CFG0, &val); 522 if (error) 523 return error; 524 525 if (val & IQS5XX_SWITCH_XY_AXIS) 526 swap(max_x_hw, max_y_hw); 527 528 if (prop.swap_x_y) 529 val ^= IQS5XX_SWITCH_XY_AXIS; 530 531 if (prop.invert_x) 532 val ^= prop.swap_x_y ? IQS5XX_FLIP_Y : IQS5XX_FLIP_X; 533 534 if (prop.invert_y) 535 val ^= prop.swap_x_y ? IQS5XX_FLIP_X : IQS5XX_FLIP_Y; 536 537 error = iqs5xx_write_byte(client, IQS5XX_XY_CFG0, val); 538 if (error) 539 return error; 540 541 if (prop.max_x > max_x_hw) { 542 dev_err(&client->dev, "Invalid maximum x-coordinate: %u > %u\n", 543 prop.max_x, max_x_hw); 544 return -EINVAL; 545 } else if (prop.max_x == 0) { 546 error = iqs5xx_read_word(client, IQS5XX_X_RES, &max_x); 547 if (error) 548 return error; 549 550 input_abs_set_max(iqs5xx->input, 551 prop.swap_x_y ? ABS_MT_POSITION_Y : 552 ABS_MT_POSITION_X, 553 max_x); 554 } else { 555 max_x = (u16)prop.max_x; 556 } 557 558 if (prop.max_y > max_y_hw) { 559 dev_err(&client->dev, "Invalid maximum y-coordinate: %u > %u\n", 560 prop.max_y, max_y_hw); 561 return -EINVAL; 562 } else if (prop.max_y == 0) { 563 error = iqs5xx_read_word(client, IQS5XX_Y_RES, &max_y); 564 if (error) 565 return error; 566 567 input_abs_set_max(iqs5xx->input, 568 prop.swap_x_y ? ABS_MT_POSITION_X : 569 ABS_MT_POSITION_Y, 570 max_y); 571 } else { 572 max_y = (u16)prop.max_y; 573 } 574 575 /* 576 * Write horizontal and vertical resolution to the device in case its 577 * original defaults were overridden or swapped as per the properties 578 * specified in the device tree. 579 */ 580 error = iqs5xx_write_word(client, 581 prop.swap_x_y ? IQS5XX_Y_RES : IQS5XX_X_RES, 582 max_x); 583 if (error) 584 return error; 585 586 error = iqs5xx_write_word(client, 587 prop.swap_x_y ? IQS5XX_X_RES : IQS5XX_Y_RES, 588 max_y); 589 if (error) 590 return error; 591 592 error = input_mt_init_slots(iqs5xx->input, IQS5XX_NUM_CONTACTS, 593 INPUT_MT_DIRECT); 594 if (error) 595 dev_err(&client->dev, "Failed to initialize slots: %d\n", 596 error); 597 598 return error; 599 } 600 601 static int iqs5xx_dev_init(struct i2c_client *client) 602 { 603 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 604 struct iqs5xx_dev_id_info *dev_id_info; 605 int error; 606 u8 val; 607 u8 buf[sizeof(*dev_id_info) + 1]; 608 609 error = iqs5xx_read_burst(client, IQS5XX_PROD_NUM, 610 &buf[1], sizeof(*dev_id_info)); 611 if (error) 612 return iqs5xx_bl_open(client); 613 614 /* 615 * A000 and B000 devices use 8-bit and 16-bit addressing, respectively. 616 * Querying an A000 device's version information with 16-bit addressing 617 * gives the appearance that the data is shifted by one byte; a nonzero 618 * leading array element suggests this could be the case (in which case 619 * the missing zero is prepended). 620 */ 621 buf[0] = 0; 622 dev_id_info = (struct iqs5xx_dev_id_info *)&buf[(buf[1] > 0) ? 0 : 1]; 623 624 switch (be16_to_cpu(dev_id_info->prod_num)) { 625 case IQS5XX_PROD_NUM_IQS550: 626 case IQS5XX_PROD_NUM_IQS572: 627 case IQS5XX_PROD_NUM_IQS525: 628 break; 629 default: 630 dev_err(&client->dev, "Unrecognized product number: %u\n", 631 be16_to_cpu(dev_id_info->prod_num)); 632 return -EINVAL; 633 } 634 635 switch (be16_to_cpu(dev_id_info->proj_num)) { 636 case IQS5XX_PROJ_NUM_A000: 637 dev_err(&client->dev, "Unsupported project number: %u\n", 638 be16_to_cpu(dev_id_info->proj_num)); 639 return iqs5xx_bl_open(client); 640 case IQS5XX_PROJ_NUM_B000: 641 break; 642 default: 643 dev_err(&client->dev, "Unrecognized project number: %u\n", 644 be16_to_cpu(dev_id_info->proj_num)); 645 return -EINVAL; 646 } 647 648 if (dev_id_info->major_ver < IQS5XX_MAJOR_VER_MIN) { 649 dev_err(&client->dev, "Unsupported major version: %u\n", 650 dev_id_info->major_ver); 651 return iqs5xx_bl_open(client); 652 } 653 654 switch (dev_id_info->bl_status) { 655 case IQS5XX_BL_STATUS_AVAIL: 656 case IQS5XX_BL_STATUS_NONE: 657 break; 658 default: 659 dev_err(&client->dev, 660 "Unrecognized bootloader status: 0x%02X\n", 661 dev_id_info->bl_status); 662 return -EINVAL; 663 } 664 665 error = iqs5xx_axis_init(client); 666 if (error) 667 return error; 668 669 error = iqs5xx_read_byte(client, IQS5XX_SYS_CFG0, &val); 670 if (error) 671 return error; 672 673 val |= IQS5XX_SETUP_COMPLETE; 674 val &= ~IQS5XX_SW_INPUT_EVENT; 675 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG0, val); 676 if (error) 677 return error; 678 679 val = IQS5XX_TP_EVENT | IQS5XX_EVENT_MODE; 680 error = iqs5xx_write_byte(client, IQS5XX_SYS_CFG1, val); 681 if (error) 682 return error; 683 684 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0); 685 if (error) 686 return error; 687 688 iqs5xx->bl_status = dev_id_info->bl_status; 689 690 /* 691 * Closure of the first communication window that appears following the 692 * release of reset appears to kick off an initialization period during 693 * which further communication is met with clock stretching. The return 694 * from this function is delayed so that further communication attempts 695 * avoid this period. 696 */ 697 msleep(100); 698 699 return 0; 700 } 701 702 static irqreturn_t iqs5xx_irq(int irq, void *data) 703 { 704 struct iqs5xx_private *iqs5xx = data; 705 struct iqs5xx_touch_data touch_data[IQS5XX_NUM_CONTACTS]; 706 struct i2c_client *client = iqs5xx->client; 707 struct input_dev *input = iqs5xx->input; 708 int error, i; 709 710 /* 711 * This check is purely a precaution, as the device does not assert the 712 * RDY output during bootloader mode. If the device operates outside of 713 * bootloader mode, the input device is guaranteed to be allocated. 714 */ 715 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET) 716 return IRQ_NONE; 717 718 error = iqs5xx_read_burst(client, IQS5XX_ABS_X, 719 touch_data, sizeof(touch_data)); 720 if (error) 721 return IRQ_NONE; 722 723 for (i = 0; i < ARRAY_SIZE(touch_data); i++) { 724 u16 pressure = be16_to_cpu(touch_data[i].strength); 725 726 input_mt_slot(input, i); 727 if (input_mt_report_slot_state(input, MT_TOOL_FINGER, 728 pressure != 0)) { 729 input_report_abs(input, ABS_MT_POSITION_X, 730 be16_to_cpu(touch_data[i].abs_x)); 731 input_report_abs(input, ABS_MT_POSITION_Y, 732 be16_to_cpu(touch_data[i].abs_y)); 733 input_report_abs(input, ABS_MT_PRESSURE, pressure); 734 } 735 } 736 737 input_mt_sync_frame(input); 738 input_sync(input); 739 740 error = iqs5xx_write_byte(client, IQS5XX_END_COMM, 0); 741 if (error) 742 return IRQ_NONE; 743 744 /* 745 * Once the communication window is closed, a small delay is added to 746 * ensure the device's RDY output has been deasserted by the time the 747 * interrupt handler returns. 748 */ 749 usleep_range(50, 100); 750 751 return IRQ_HANDLED; 752 } 753 754 static int iqs5xx_fw_file_parse(struct i2c_client *client, 755 const char *fw_file, u8 *pmap) 756 { 757 const struct firmware *fw; 758 struct iqs5xx_ihex_rec *rec; 759 size_t pos = 0; 760 int error, i; 761 u16 rec_num = 1; 762 u16 rec_addr; 763 u8 rec_len, rec_type, rec_chksm, chksm; 764 u8 rec_hdr[IQS5XX_REC_HDR_LEN]; 765 u8 rec_data[IQS5XX_REC_LEN_MAX]; 766 767 /* 768 * Firmware exported from the vendor's configuration tool deviates from 769 * standard ihex as follows: (1) the checksum for records corresponding 770 * to user-exported settings is not recalculated, and (2) an address of 771 * 0xFFFF is used for the EOF record. 772 * 773 * Because the ihex2fw tool tolerates neither (1) nor (2), the slightly 774 * nonstandard ihex firmware is parsed directly by the driver. 775 */ 776 error = request_firmware(&fw, fw_file, &client->dev); 777 if (error) { 778 dev_err(&client->dev, "Failed to request firmware %s: %d\n", 779 fw_file, error); 780 return error; 781 } 782 783 do { 784 if (pos + sizeof(*rec) > fw->size) { 785 dev_err(&client->dev, "Insufficient firmware size\n"); 786 error = -EINVAL; 787 break; 788 } 789 rec = (struct iqs5xx_ihex_rec *)(fw->data + pos); 790 pos += sizeof(*rec); 791 792 if (rec->start != ':') { 793 dev_err(&client->dev, "Invalid start at record %u\n", 794 rec_num); 795 error = -EINVAL; 796 break; 797 } 798 799 error = hex2bin(rec_hdr, rec->len, sizeof(rec_hdr)); 800 if (error) { 801 dev_err(&client->dev, "Invalid header at record %u\n", 802 rec_num); 803 break; 804 } 805 806 rec_len = *rec_hdr; 807 rec_addr = get_unaligned_be16(rec_hdr + sizeof(rec_len)); 808 rec_type = *(rec_hdr + sizeof(rec_len) + sizeof(rec_addr)); 809 810 if (pos + rec_len * 2 > fw->size) { 811 dev_err(&client->dev, "Insufficient firmware size\n"); 812 error = -EINVAL; 813 break; 814 } 815 pos += (rec_len * 2); 816 817 error = hex2bin(rec_data, rec->data, rec_len); 818 if (error) { 819 dev_err(&client->dev, "Invalid data at record %u\n", 820 rec_num); 821 break; 822 } 823 824 error = hex2bin(&rec_chksm, 825 rec->data + rec_len * 2, sizeof(rec_chksm)); 826 if (error) { 827 dev_err(&client->dev, "Invalid checksum at record %u\n", 828 rec_num); 829 break; 830 } 831 832 chksm = 0; 833 for (i = 0; i < sizeof(rec_hdr); i++) 834 chksm += rec_hdr[i]; 835 for (i = 0; i < rec_len; i++) 836 chksm += rec_data[i]; 837 chksm = ~chksm + 1; 838 839 if (chksm != rec_chksm && rec_addr < IQS5XX_CSTM) { 840 dev_err(&client->dev, 841 "Incorrect checksum at record %u\n", 842 rec_num); 843 error = -EINVAL; 844 break; 845 } 846 847 switch (rec_type) { 848 case IQS5XX_REC_TYPE_DATA: 849 if (rec_addr < IQS5XX_CHKSM || 850 rec_addr > IQS5XX_PMAP_END) { 851 dev_err(&client->dev, 852 "Invalid address at record %u\n", 853 rec_num); 854 error = -EINVAL; 855 } else { 856 memcpy(pmap + rec_addr - IQS5XX_CHKSM, 857 rec_data, rec_len); 858 } 859 break; 860 case IQS5XX_REC_TYPE_EOF: 861 break; 862 default: 863 dev_err(&client->dev, "Invalid type at record %u\n", 864 rec_num); 865 error = -EINVAL; 866 } 867 868 if (error) 869 break; 870 871 rec_num++; 872 while (pos < fw->size) { 873 if (*(fw->data + pos) == ':') 874 break; 875 pos++; 876 } 877 } while (rec_type != IQS5XX_REC_TYPE_EOF); 878 879 release_firmware(fw); 880 881 return error; 882 } 883 884 static int iqs5xx_fw_file_write(struct i2c_client *client, const char *fw_file) 885 { 886 struct iqs5xx_private *iqs5xx = i2c_get_clientdata(client); 887 int error; 888 u8 *pmap; 889 890 if (iqs5xx->bl_status == IQS5XX_BL_STATUS_NONE) 891 return -EPERM; 892 893 pmap = kzalloc(IQS5XX_PMAP_LEN, GFP_KERNEL); 894 if (!pmap) 895 return -ENOMEM; 896 897 error = iqs5xx_fw_file_parse(client, fw_file, pmap); 898 if (error) 899 goto err_kfree; 900 901 mutex_lock(&iqs5xx->lock); 902 903 /* 904 * Disable the interrupt line in case the first attempt(s) to enter the 905 * bootloader don't happen quickly enough, in which case the device may 906 * assert the RDY output until the next attempt. 907 */ 908 disable_irq(client->irq); 909 910 iqs5xx->bl_status = IQS5XX_BL_STATUS_RESET; 911 912 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_VER, 0); 913 if (error) { 914 error = iqs5xx_bl_open(client); 915 if (error) 916 goto err_reset; 917 } 918 919 error = iqs5xx_bl_write(client, IQS5XX_CHKSM, pmap, IQS5XX_PMAP_LEN); 920 if (error) 921 goto err_reset; 922 923 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_CRC, 0); 924 if (error) 925 goto err_reset; 926 927 error = iqs5xx_bl_verify(client, IQS5XX_CSTM, 928 pmap + IQS5XX_CHKSM_LEN + IQS5XX_APP_LEN, 929 IQS5XX_CSTM_LEN); 930 if (error) 931 goto err_reset; 932 933 error = iqs5xx_bl_cmd(client, IQS5XX_BL_CMD_EXEC, 0); 934 935 err_reset: 936 if (error) { 937 iqs5xx_reset(client); 938 usleep_range(10000, 10100); 939 } 940 941 error = iqs5xx_dev_init(client); 942 if (!error && iqs5xx->bl_status == IQS5XX_BL_STATUS_RESET) 943 error = -EINVAL; 944 945 enable_irq(client->irq); 946 947 mutex_unlock(&iqs5xx->lock); 948 949 err_kfree: 950 kfree(pmap); 951 952 return error; 953 } 954 955 static ssize_t fw_file_store(struct device *dev, struct device_attribute *attr, 956 const char *buf, size_t count) 957 { 958 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 959 struct i2c_client *client = iqs5xx->client; 960 size_t len = count; 961 bool input_reg = !iqs5xx->input; 962 char fw_file[IQS5XX_FW_FILE_LEN + 1]; 963 int error; 964 965 if (!len) 966 return -EINVAL; 967 968 if (buf[len - 1] == '\n') 969 len--; 970 971 if (len > IQS5XX_FW_FILE_LEN) 972 return -ENAMETOOLONG; 973 974 memcpy(fw_file, buf, len); 975 fw_file[len] = '\0'; 976 977 error = iqs5xx_fw_file_write(client, fw_file); 978 if (error) 979 return error; 980 981 /* 982 * If the input device was not allocated already, it is guaranteed to 983 * be allocated by this point and can finally be registered. 984 */ 985 if (input_reg) { 986 error = input_register_device(iqs5xx->input); 987 if (error) { 988 dev_err(&client->dev, 989 "Failed to register device: %d\n", 990 error); 991 return error; 992 } 993 } 994 995 return count; 996 } 997 998 static DEVICE_ATTR_WO(fw_file); 999 1000 static struct attribute *iqs5xx_attrs[] = { 1001 &dev_attr_fw_file.attr, 1002 NULL, 1003 }; 1004 1005 static const struct attribute_group iqs5xx_attr_group = { 1006 .attrs = iqs5xx_attrs, 1007 }; 1008 1009 static int __maybe_unused iqs5xx_suspend(struct device *dev) 1010 { 1011 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 1012 struct input_dev *input = iqs5xx->input; 1013 int error = 0; 1014 1015 if (!input) 1016 return error; 1017 1018 mutex_lock(&input->mutex); 1019 1020 if (input_device_enabled(input)) 1021 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_SUSPEND); 1022 1023 mutex_unlock(&input->mutex); 1024 1025 return error; 1026 } 1027 1028 static int __maybe_unused iqs5xx_resume(struct device *dev) 1029 { 1030 struct iqs5xx_private *iqs5xx = dev_get_drvdata(dev); 1031 struct input_dev *input = iqs5xx->input; 1032 int error = 0; 1033 1034 if (!input) 1035 return error; 1036 1037 mutex_lock(&input->mutex); 1038 1039 if (input_device_enabled(input)) 1040 error = iqs5xx_set_state(iqs5xx->client, IQS5XX_RESUME); 1041 1042 mutex_unlock(&input->mutex); 1043 1044 return error; 1045 } 1046 1047 static SIMPLE_DEV_PM_OPS(iqs5xx_pm, iqs5xx_suspend, iqs5xx_resume); 1048 1049 static int iqs5xx_probe(struct i2c_client *client, 1050 const struct i2c_device_id *id) 1051 { 1052 struct iqs5xx_private *iqs5xx; 1053 int error; 1054 1055 iqs5xx = devm_kzalloc(&client->dev, sizeof(*iqs5xx), GFP_KERNEL); 1056 if (!iqs5xx) 1057 return -ENOMEM; 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