1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Raydium touchscreen I2C driver. 4 * 5 * Copyright (C) 2012-2014, Raydium Semiconductor Corporation. 6 * 7 * Raydium reserves the right to make changes without further notice 8 * to the materials described herein. Raydium does not assume any 9 * liability arising out of the application described herein. 10 * 11 * Contact Raydium Semiconductor Corporation at www.rad-ic.com 12 */ 13 14 #include <linux/acpi.h> 15 #include <linux/delay.h> 16 #include <linux/firmware.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/i2c.h> 19 #include <linux/input.h> 20 #include <linux/input/mt.h> 21 #include <linux/interrupt.h> 22 #include <linux/module.h> 23 #include <linux/of.h> 24 #include <linux/regulator/consumer.h> 25 #include <linux/slab.h> 26 #include <asm/unaligned.h> 27 28 /* Slave I2C mode */ 29 #define RM_BOOT_BLDR 0x02 30 #define RM_BOOT_MAIN 0x03 31 32 /* I2C bootoloader commands */ 33 #define RM_CMD_BOOT_PAGE_WRT 0x0B /* send bl page write */ 34 #define RM_CMD_BOOT_WRT 0x11 /* send bl write */ 35 #define RM_CMD_BOOT_ACK 0x22 /* send ack*/ 36 #define RM_CMD_BOOT_CHK 0x33 /* send data check */ 37 #define RM_CMD_BOOT_READ 0x44 /* send wait bl data ready*/ 38 39 #define RM_BOOT_RDY 0xFF /* bl data ready */ 40 41 /* I2C main commands */ 42 #define RM_CMD_QUERY_BANK 0x2B 43 #define RM_CMD_DATA_BANK 0x4D 44 #define RM_CMD_ENTER_SLEEP 0x4E 45 #define RM_CMD_BANK_SWITCH 0xAA 46 47 #define RM_RESET_MSG_ADDR 0x40000004 48 49 #define RM_MAX_READ_SIZE 56 50 #define RM_PACKET_CRC_SIZE 2 51 52 /* Touch relative info */ 53 #define RM_MAX_RETRIES 3 54 #define RM_RETRY_DELAY_MS 20 55 #define RM_MAX_TOUCH_NUM 10 56 #define RM_BOOT_DELAY_MS 100 57 58 /* Offsets in contact data */ 59 #define RM_CONTACT_STATE_POS 0 60 #define RM_CONTACT_X_POS 1 61 #define RM_CONTACT_Y_POS 3 62 #define RM_CONTACT_PRESSURE_POS 5 63 #define RM_CONTACT_WIDTH_X_POS 6 64 #define RM_CONTACT_WIDTH_Y_POS 7 65 66 /* Bootloader relative info */ 67 #define RM_BL_WRT_CMD_SIZE 3 /* bl flash wrt cmd size */ 68 #define RM_BL_WRT_PKG_SIZE 32 /* bl wrt pkg size */ 69 #define RM_BL_WRT_LEN (RM_BL_WRT_PKG_SIZE + RM_BL_WRT_CMD_SIZE) 70 #define RM_FW_PAGE_SIZE 128 71 #define RM_MAX_FW_RETRIES 30 72 #define RM_MAX_FW_SIZE 0xD000 73 74 #define RM_POWERON_DELAY_USEC 500 75 #define RM_RESET_DELAY_MSEC 50 76 77 enum raydium_bl_cmd { 78 BL_HEADER = 0, 79 BL_PAGE_STR, 80 BL_PKG_IDX, 81 BL_DATA_STR, 82 }; 83 84 enum raydium_bl_ack { 85 RAYDIUM_ACK_NULL = 0, 86 RAYDIUM_WAIT_READY, 87 RAYDIUM_PATH_READY, 88 }; 89 90 enum raydium_boot_mode { 91 RAYDIUM_TS_MAIN = 0, 92 RAYDIUM_TS_BLDR, 93 }; 94 95 /* Response to RM_CMD_DATA_BANK request */ 96 struct raydium_data_info { 97 __le32 data_bank_addr; 98 u8 pkg_size; 99 u8 tp_info_size; 100 }; 101 102 struct raydium_info { 103 __le32 hw_ver; /*device version */ 104 u8 main_ver; 105 u8 sub_ver; 106 __le16 ft_ver; /* test version */ 107 u8 x_num; 108 u8 y_num; 109 __le16 x_max; 110 __le16 y_max; 111 u8 x_res; /* units/mm */ 112 u8 y_res; /* units/mm */ 113 }; 114 115 /* struct raydium_data - represents state of Raydium touchscreen device */ 116 struct raydium_data { 117 struct i2c_client *client; 118 struct input_dev *input; 119 120 struct regulator *avdd; 121 struct regulator *vccio; 122 struct gpio_desc *reset_gpio; 123 124 struct raydium_info info; 125 126 struct mutex sysfs_mutex; 127 128 u8 *report_data; 129 130 u32 data_bank_addr; 131 u8 report_size; 132 u8 contact_size; 133 u8 pkg_size; 134 135 enum raydium_boot_mode boot_mode; 136 137 bool wake_irq_enabled; 138 }; 139 140 /* 141 * Header to be sent for RM_CMD_BANK_SWITCH command. This is used by 142 * raydium_i2c_{read|send} below. 143 */ 144 struct __packed raydium_bank_switch_header { 145 u8 cmd; 146 __be32 be_addr; 147 }; 148 149 static int raydium_i2c_xfer(struct i2c_client *client, u32 addr, 150 struct i2c_msg *xfer, size_t xfer_count) 151 { 152 int ret; 153 /* 154 * If address is greater than 255, then RM_CMD_BANK_SWITCH needs to be 155 * sent first. Else, skip the header i.e. xfer[0]. 156 */ 157 int xfer_start_idx = (addr > 0xff) ? 0 : 1; 158 xfer_count -= xfer_start_idx; 159 160 ret = i2c_transfer(client->adapter, &xfer[xfer_start_idx], xfer_count); 161 if (likely(ret == xfer_count)) 162 return 0; 163 164 return ret < 0 ? ret : -EIO; 165 } 166 167 static int raydium_i2c_send(struct i2c_client *client, 168 u32 addr, const void *data, size_t len) 169 { 170 int tries = 0; 171 int error; 172 u8 *tx_buf; 173 u8 reg_addr = addr & 0xff; 174 175 tx_buf = kmalloc(len + 1, GFP_KERNEL); 176 if (!tx_buf) 177 return -ENOMEM; 178 179 tx_buf[0] = reg_addr; 180 memcpy(tx_buf + 1, data, len); 181 182 do { 183 struct raydium_bank_switch_header header = { 184 .cmd = RM_CMD_BANK_SWITCH, 185 .be_addr = cpu_to_be32(addr), 186 }; 187 188 /* 189 * Perform as a single i2c_transfer transaction to ensure that 190 * no other I2C transactions are initiated on the bus to any 191 * other device in between. Initiating transacations to other 192 * devices after RM_CMD_BANK_SWITCH is sent is known to cause 193 * issues. This is also why regmap infrastructure cannot be used 194 * for this driver. Regmap handles page(bank) switch and reads 195 * as separate i2c_transfer() operations. This can result in 196 * problems if the Raydium device is on a shared I2C bus. 197 */ 198 struct i2c_msg xfer[] = { 199 { 200 .addr = client->addr, 201 .len = sizeof(header), 202 .buf = (u8 *)&header, 203 }, 204 { 205 .addr = client->addr, 206 .len = len + 1, 207 .buf = tx_buf, 208 }, 209 }; 210 211 error = raydium_i2c_xfer(client, addr, xfer, ARRAY_SIZE(xfer)); 212 if (likely(!error)) 213 return 0; 214 215 msleep(RM_RETRY_DELAY_MS); 216 } while (++tries < RM_MAX_RETRIES); 217 218 dev_err(&client->dev, "%s failed: %d\n", __func__, error); 219 return error; 220 } 221 222 static int raydium_i2c_read(struct i2c_client *client, 223 u32 addr, void *data, size_t len) 224 { 225 int error; 226 227 while (len) { 228 u8 reg_addr = addr & 0xff; 229 struct raydium_bank_switch_header header = { 230 .cmd = RM_CMD_BANK_SWITCH, 231 .be_addr = cpu_to_be32(addr), 232 }; 233 size_t xfer_len = min_t(size_t, len, RM_MAX_READ_SIZE); 234 235 /* 236 * Perform as a single i2c_transfer transaction to ensure that 237 * no other I2C transactions are initiated on the bus to any 238 * other device in between. Initiating transacations to other 239 * devices after RM_CMD_BANK_SWITCH is sent is known to cause 240 * issues. This is also why regmap infrastructure cannot be used 241 * for this driver. Regmap handles page(bank) switch and writes 242 * as separate i2c_transfer() operations. This can result in 243 * problems if the Raydium device is on a shared I2C bus. 244 */ 245 struct i2c_msg xfer[] = { 246 { 247 .addr = client->addr, 248 .len = sizeof(header), 249 .buf = (u8 *)&header, 250 }, 251 { 252 .addr = client->addr, 253 .len = 1, 254 .buf = ®_addr, 255 }, 256 { 257 .addr = client->addr, 258 .len = xfer_len, 259 .buf = data, 260 .flags = I2C_M_RD, 261 } 262 }; 263 264 error = raydium_i2c_xfer(client, addr, xfer, ARRAY_SIZE(xfer)); 265 if (unlikely(error)) 266 return error; 267 268 len -= xfer_len; 269 data += xfer_len; 270 addr += xfer_len; 271 } 272 273 return 0; 274 } 275 276 static int raydium_i2c_sw_reset(struct i2c_client *client) 277 { 278 const u8 soft_rst_cmd = 0x01; 279 int error; 280 281 error = raydium_i2c_send(client, RM_RESET_MSG_ADDR, &soft_rst_cmd, 282 sizeof(soft_rst_cmd)); 283 if (error) { 284 dev_err(&client->dev, "software reset failed: %d\n", error); 285 return error; 286 } 287 288 msleep(RM_RESET_DELAY_MSEC); 289 290 return 0; 291 } 292 293 static int raydium_i2c_query_ts_info(struct raydium_data *ts) 294 { 295 struct i2c_client *client = ts->client; 296 struct raydium_data_info data_info; 297 __le32 query_bank_addr; 298 299 int error, retry_cnt; 300 301 for (retry_cnt = 0; retry_cnt < RM_MAX_RETRIES; retry_cnt++) { 302 error = raydium_i2c_read(client, RM_CMD_DATA_BANK, 303 &data_info, sizeof(data_info)); 304 if (error) 305 continue; 306 307 /* 308 * Warn user if we already allocated memory for reports and 309 * then the size changed (due to firmware update?) and keep 310 * old size instead. 311 */ 312 if (ts->report_data && ts->pkg_size != data_info.pkg_size) { 313 dev_warn(&client->dev, 314 "report size changes, was: %d, new: %d\n", 315 ts->pkg_size, data_info.pkg_size); 316 } else { 317 ts->pkg_size = data_info.pkg_size; 318 ts->report_size = ts->pkg_size - RM_PACKET_CRC_SIZE; 319 } 320 321 ts->contact_size = data_info.tp_info_size; 322 ts->data_bank_addr = le32_to_cpu(data_info.data_bank_addr); 323 324 dev_dbg(&client->dev, 325 "data_bank_addr: %#08x, report_size: %d, contact_size: %d\n", 326 ts->data_bank_addr, ts->report_size, ts->contact_size); 327 328 error = raydium_i2c_read(client, RM_CMD_QUERY_BANK, 329 &query_bank_addr, 330 sizeof(query_bank_addr)); 331 if (error) 332 continue; 333 334 error = raydium_i2c_read(client, le32_to_cpu(query_bank_addr), 335 &ts->info, sizeof(ts->info)); 336 if (error) 337 continue; 338 339 return 0; 340 } 341 342 dev_err(&client->dev, "failed to query device parameters: %d\n", error); 343 return error; 344 } 345 346 static int raydium_i2c_check_fw_status(struct raydium_data *ts) 347 { 348 struct i2c_client *client = ts->client; 349 static const u8 bl_ack = 0x62; 350 static const u8 main_ack = 0x66; 351 u8 buf[4]; 352 int error; 353 354 error = raydium_i2c_read(client, RM_CMD_BOOT_READ, buf, sizeof(buf)); 355 if (!error) { 356 if (buf[0] == bl_ack) 357 ts->boot_mode = RAYDIUM_TS_BLDR; 358 else if (buf[0] == main_ack) 359 ts->boot_mode = RAYDIUM_TS_MAIN; 360 return 0; 361 } 362 363 return error; 364 } 365 366 static int raydium_i2c_initialize(struct raydium_data *ts) 367 { 368 struct i2c_client *client = ts->client; 369 int error, retry_cnt; 370 371 for (retry_cnt = 0; retry_cnt < RM_MAX_RETRIES; retry_cnt++) { 372 /* Wait for Hello packet */ 373 msleep(RM_BOOT_DELAY_MS); 374 375 error = raydium_i2c_check_fw_status(ts); 376 if (error) { 377 dev_err(&client->dev, 378 "failed to read 'hello' packet: %d\n", error); 379 continue; 380 } 381 382 if (ts->boot_mode == RAYDIUM_TS_BLDR || 383 ts->boot_mode == RAYDIUM_TS_MAIN) { 384 break; 385 } 386 } 387 388 if (error) 389 ts->boot_mode = RAYDIUM_TS_BLDR; 390 391 if (ts->boot_mode == RAYDIUM_TS_BLDR) { 392 ts->info.hw_ver = cpu_to_le32(0xffffffffUL); 393 ts->info.main_ver = 0xff; 394 ts->info.sub_ver = 0xff; 395 } else { 396 raydium_i2c_query_ts_info(ts); 397 } 398 399 return error; 400 } 401 402 static int raydium_i2c_bl_chk_state(struct i2c_client *client, 403 enum raydium_bl_ack state) 404 { 405 static const u8 ack_ok[] = { 0xFF, 0x39, 0x30, 0x30, 0x54 }; 406 u8 rbuf[sizeof(ack_ok)]; 407 u8 retry; 408 int error; 409 410 for (retry = 0; retry < RM_MAX_FW_RETRIES; retry++) { 411 switch (state) { 412 case RAYDIUM_ACK_NULL: 413 return 0; 414 415 case RAYDIUM_WAIT_READY: 416 error = raydium_i2c_read(client, RM_CMD_BOOT_CHK, 417 &rbuf[0], 1); 418 if (!error && rbuf[0] == RM_BOOT_RDY) 419 return 0; 420 421 break; 422 423 case RAYDIUM_PATH_READY: 424 error = raydium_i2c_read(client, RM_CMD_BOOT_CHK, 425 rbuf, sizeof(rbuf)); 426 if (!error && !memcmp(rbuf, ack_ok, sizeof(ack_ok))) 427 return 0; 428 429 break; 430 431 default: 432 dev_err(&client->dev, "%s: invalid target state %d\n", 433 __func__, state); 434 return -EINVAL; 435 } 436 437 msleep(20); 438 } 439 440 return -ETIMEDOUT; 441 } 442 443 static int raydium_i2c_write_object(struct i2c_client *client, 444 const void *data, size_t len, 445 enum raydium_bl_ack state) 446 { 447 int error; 448 static const u8 cmd[] = { 0xFF, 0x39 }; 449 450 error = raydium_i2c_send(client, RM_CMD_BOOT_WRT, data, len); 451 if (error) { 452 dev_err(&client->dev, "WRT obj command failed: %d\n", 453 error); 454 return error; 455 } 456 457 error = raydium_i2c_send(client, RM_CMD_BOOT_ACK, cmd, sizeof(cmd)); 458 if (error) { 459 dev_err(&client->dev, "Ack obj command failed: %d\n", error); 460 return error; 461 } 462 463 error = raydium_i2c_bl_chk_state(client, state); 464 if (error) { 465 dev_err(&client->dev, "BL check state failed: %d\n", error); 466 return error; 467 } 468 return 0; 469 } 470 471 static int raydium_i2c_boot_trigger(struct i2c_client *client) 472 { 473 static const u8 cmd[7][6] = { 474 { 0x08, 0x0C, 0x09, 0x00, 0x50, 0xD7 }, 475 { 0x08, 0x04, 0x09, 0x00, 0x50, 0xA5 }, 476 { 0x08, 0x04, 0x09, 0x00, 0x50, 0x00 }, 477 { 0x08, 0x04, 0x09, 0x00, 0x50, 0xA5 }, 478 { 0x08, 0x0C, 0x09, 0x00, 0x50, 0x00 }, 479 { 0x06, 0x01, 0x00, 0x00, 0x00, 0x00 }, 480 { 0x02, 0xA2, 0x00, 0x00, 0x00, 0x00 }, 481 }; 482 int i; 483 int error; 484 485 for (i = 0; i < 7; i++) { 486 error = raydium_i2c_write_object(client, cmd[i], sizeof(cmd[i]), 487 RAYDIUM_WAIT_READY); 488 if (error) { 489 dev_err(&client->dev, 490 "boot trigger failed at step %d: %d\n", 491 i, error); 492 return error; 493 } 494 } 495 496 return 0; 497 } 498 499 static int raydium_i2c_fw_trigger(struct i2c_client *client) 500 { 501 static const u8 cmd[5][11] = { 502 { 0, 0x09, 0x71, 0x0C, 0x09, 0x00, 0x50, 0xD7, 0, 0, 0 }, 503 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0xA5, 0, 0, 0 }, 504 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0x00, 0, 0, 0 }, 505 { 0, 0x09, 0x71, 0x04, 0x09, 0x00, 0x50, 0xA5, 0, 0, 0 }, 506 { 0, 0x09, 0x71, 0x0C, 0x09, 0x00, 0x50, 0x00, 0, 0, 0 }, 507 }; 508 int i; 509 int error; 510 511 for (i = 0; i < 5; i++) { 512 error = raydium_i2c_write_object(client, cmd[i], sizeof(cmd[i]), 513 RAYDIUM_ACK_NULL); 514 if (error) { 515 dev_err(&client->dev, 516 "fw trigger failed at step %d: %d\n", 517 i, error); 518 return error; 519 } 520 } 521 522 return 0; 523 } 524 525 static int raydium_i2c_check_path(struct i2c_client *client) 526 { 527 static const u8 cmd[] = { 0x09, 0x00, 0x09, 0x00, 0x50, 0x10, 0x00 }; 528 int error; 529 530 error = raydium_i2c_write_object(client, cmd, sizeof(cmd), 531 RAYDIUM_PATH_READY); 532 if (error) { 533 dev_err(&client->dev, "check path command failed: %d\n", error); 534 return error; 535 } 536 537 return 0; 538 } 539 540 static int raydium_i2c_enter_bl(struct i2c_client *client) 541 { 542 static const u8 cal_cmd[] = { 0x00, 0x01, 0x52 }; 543 int error; 544 545 error = raydium_i2c_write_object(client, cal_cmd, sizeof(cal_cmd), 546 RAYDIUM_ACK_NULL); 547 if (error) { 548 dev_err(&client->dev, "enter bl command failed: %d\n", error); 549 return error; 550 } 551 552 msleep(RM_BOOT_DELAY_MS); 553 return 0; 554 } 555 556 static int raydium_i2c_leave_bl(struct i2c_client *client) 557 { 558 static const u8 leave_cmd[] = { 0x05, 0x00 }; 559 int error; 560 561 error = raydium_i2c_write_object(client, leave_cmd, sizeof(leave_cmd), 562 RAYDIUM_ACK_NULL); 563 if (error) { 564 dev_err(&client->dev, "leave bl command failed: %d\n", error); 565 return error; 566 } 567 568 msleep(RM_BOOT_DELAY_MS); 569 return 0; 570 } 571 572 static int raydium_i2c_write_checksum(struct i2c_client *client, 573 size_t length, u16 checksum) 574 { 575 u8 checksum_cmd[] = { 0x00, 0x05, 0x6D, 0x00, 0x00, 0x00, 0x00 }; 576 int error; 577 578 put_unaligned_le16(length, &checksum_cmd[3]); 579 put_unaligned_le16(checksum, &checksum_cmd[5]); 580 581 error = raydium_i2c_write_object(client, 582 checksum_cmd, sizeof(checksum_cmd), 583 RAYDIUM_ACK_NULL); 584 if (error) { 585 dev_err(&client->dev, "failed to write checksum: %d\n", 586 error); 587 return error; 588 } 589 590 return 0; 591 } 592 593 static int raydium_i2c_disable_watch_dog(struct i2c_client *client) 594 { 595 static const u8 cmd[] = { 0x0A, 0xAA }; 596 int error; 597 598 error = raydium_i2c_write_object(client, cmd, sizeof(cmd), 599 RAYDIUM_WAIT_READY); 600 if (error) { 601 dev_err(&client->dev, "disable watchdog command failed: %d\n", 602 error); 603 return error; 604 } 605 606 return 0; 607 } 608 609 static int raydium_i2c_fw_write_page(struct i2c_client *client, 610 u16 page_idx, const void *data, size_t len) 611 { 612 u8 buf[RM_BL_WRT_LEN]; 613 size_t xfer_len; 614 int error; 615 int i; 616 617 BUILD_BUG_ON((RM_FW_PAGE_SIZE % RM_BL_WRT_PKG_SIZE) != 0); 618 619 for (i = 0; i < RM_FW_PAGE_SIZE / RM_BL_WRT_PKG_SIZE; i++) { 620 buf[BL_HEADER] = RM_CMD_BOOT_PAGE_WRT; 621 buf[BL_PAGE_STR] = page_idx ? 0xff : 0; 622 buf[BL_PKG_IDX] = i + 1; 623 624 xfer_len = min_t(size_t, len, RM_BL_WRT_PKG_SIZE); 625 memcpy(&buf[BL_DATA_STR], data, xfer_len); 626 if (len < RM_BL_WRT_PKG_SIZE) 627 memset(&buf[BL_DATA_STR + xfer_len], 0xff, 628 RM_BL_WRT_PKG_SIZE - xfer_len); 629 630 error = raydium_i2c_write_object(client, buf, RM_BL_WRT_LEN, 631 RAYDIUM_WAIT_READY); 632 if (error) { 633 dev_err(&client->dev, 634 "page write command failed for page %d, chunk %d: %d\n", 635 page_idx, i, error); 636 return error; 637 } 638 639 data += xfer_len; 640 len -= xfer_len; 641 } 642 643 return error; 644 } 645 646 static u16 raydium_calc_chksum(const u8 *buf, u16 len) 647 { 648 u16 checksum = 0; 649 u16 i; 650 651 for (i = 0; i < len; i++) 652 checksum += buf[i]; 653 654 return checksum; 655 } 656 657 static int raydium_i2c_do_update_firmware(struct raydium_data *ts, 658 const struct firmware *fw) 659 { 660 struct i2c_client *client = ts->client; 661 const void *data; 662 size_t data_len; 663 size_t len; 664 int page_nr; 665 int i; 666 int error; 667 u16 fw_checksum; 668 669 if (fw->size == 0 || fw->size > RM_MAX_FW_SIZE) { 670 dev_err(&client->dev, "Invalid firmware length\n"); 671 return -EINVAL; 672 } 673 674 error = raydium_i2c_check_fw_status(ts); 675 if (error) { 676 dev_err(&client->dev, "Unable to access IC %d\n", error); 677 return error; 678 } 679 680 if (ts->boot_mode == RAYDIUM_TS_MAIN) { 681 for (i = 0; i < RM_MAX_RETRIES; i++) { 682 error = raydium_i2c_enter_bl(client); 683 if (!error) { 684 error = raydium_i2c_check_fw_status(ts); 685 if (error) { 686 dev_err(&client->dev, 687 "unable to access IC: %d\n", 688 error); 689 return error; 690 } 691 692 if (ts->boot_mode == RAYDIUM_TS_BLDR) 693 break; 694 } 695 } 696 697 if (ts->boot_mode == RAYDIUM_TS_MAIN) { 698 dev_err(&client->dev, 699 "failed to jump to boot loader: %d\n", 700 error); 701 return -EIO; 702 } 703 } 704 705 error = raydium_i2c_disable_watch_dog(client); 706 if (error) 707 return error; 708 709 error = raydium_i2c_check_path(client); 710 if (error) 711 return error; 712 713 error = raydium_i2c_boot_trigger(client); 714 if (error) { 715 dev_err(&client->dev, "send boot trigger fail: %d\n", error); 716 return error; 717 } 718 719 msleep(RM_BOOT_DELAY_MS); 720 721 data = fw->data; 722 data_len = fw->size; 723 page_nr = 0; 724 725 while (data_len) { 726 len = min_t(size_t, data_len, RM_FW_PAGE_SIZE); 727 728 error = raydium_i2c_fw_write_page(client, page_nr++, data, len); 729 if (error) 730 return error; 731 732 msleep(20); 733 734 data += len; 735 data_len -= len; 736 } 737 738 error = raydium_i2c_leave_bl(client); 739 if (error) { 740 dev_err(&client->dev, 741 "failed to leave boot loader: %d\n", error); 742 return error; 743 } 744 745 dev_dbg(&client->dev, "left boot loader mode\n"); 746 msleep(RM_BOOT_DELAY_MS); 747 748 error = raydium_i2c_check_fw_status(ts); 749 if (error) { 750 dev_err(&client->dev, 751 "failed to check fw status after write: %d\n", 752 error); 753 return error; 754 } 755 756 if (ts->boot_mode != RAYDIUM_TS_MAIN) { 757 dev_err(&client->dev, 758 "failed to switch to main fw after writing firmware: %d\n", 759 error); 760 return -EINVAL; 761 } 762 763 error = raydium_i2c_fw_trigger(client); 764 if (error) { 765 dev_err(&client->dev, "failed to trigger fw: %d\n", error); 766 return error; 767 } 768 769 fw_checksum = raydium_calc_chksum(fw->data, fw->size); 770 771 error = raydium_i2c_write_checksum(client, fw->size, fw_checksum); 772 if (error) 773 return error; 774 775 return 0; 776 } 777 778 static int raydium_i2c_fw_update(struct raydium_data *ts) 779 { 780 struct i2c_client *client = ts->client; 781 const struct firmware *fw = NULL; 782 char *fw_file; 783 int error; 784 785 fw_file = kasprintf(GFP_KERNEL, "raydium_%#04x.fw", 786 le32_to_cpu(ts->info.hw_ver)); 787 if (!fw_file) 788 return -ENOMEM; 789 790 dev_dbg(&client->dev, "firmware name: %s\n", fw_file); 791 792 error = request_firmware(&fw, fw_file, &client->dev); 793 if (error) { 794 dev_err(&client->dev, "Unable to open firmware %s\n", fw_file); 795 goto out_free_fw_file; 796 } 797 798 disable_irq(client->irq); 799 800 error = raydium_i2c_do_update_firmware(ts, fw); 801 if (error) { 802 dev_err(&client->dev, "firmware update failed: %d\n", error); 803 ts->boot_mode = RAYDIUM_TS_BLDR; 804 goto out_enable_irq; 805 } 806 807 error = raydium_i2c_initialize(ts); 808 if (error) { 809 dev_err(&client->dev, 810 "failed to initialize device after firmware update: %d\n", 811 error); 812 ts->boot_mode = RAYDIUM_TS_BLDR; 813 goto out_enable_irq; 814 } 815 816 ts->boot_mode = RAYDIUM_TS_MAIN; 817 818 out_enable_irq: 819 enable_irq(client->irq); 820 msleep(100); 821 822 release_firmware(fw); 823 824 out_free_fw_file: 825 kfree(fw_file); 826 827 return error; 828 } 829 830 static void raydium_mt_event(struct raydium_data *ts) 831 { 832 int i; 833 834 for (i = 0; i < ts->report_size / ts->contact_size; i++) { 835 u8 *contact = &ts->report_data[ts->contact_size * i]; 836 bool state = contact[RM_CONTACT_STATE_POS]; 837 u8 wx, wy; 838 839 input_mt_slot(ts->input, i); 840 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, state); 841 842 if (!state) 843 continue; 844 845 input_report_abs(ts->input, ABS_MT_POSITION_X, 846 get_unaligned_le16(&contact[RM_CONTACT_X_POS])); 847 input_report_abs(ts->input, ABS_MT_POSITION_Y, 848 get_unaligned_le16(&contact[RM_CONTACT_Y_POS])); 849 input_report_abs(ts->input, ABS_MT_PRESSURE, 850 contact[RM_CONTACT_PRESSURE_POS]); 851 852 wx = contact[RM_CONTACT_WIDTH_X_POS]; 853 wy = contact[RM_CONTACT_WIDTH_Y_POS]; 854 855 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, max(wx, wy)); 856 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, min(wx, wy)); 857 } 858 859 input_mt_sync_frame(ts->input); 860 input_sync(ts->input); 861 } 862 863 static irqreturn_t raydium_i2c_irq(int irq, void *_dev) 864 { 865 struct raydium_data *ts = _dev; 866 int error; 867 u16 fw_crc; 868 u16 calc_crc; 869 870 if (ts->boot_mode != RAYDIUM_TS_MAIN) 871 goto out; 872 873 error = raydium_i2c_read(ts->client, ts->data_bank_addr, 874 ts->report_data, ts->pkg_size); 875 if (error) 876 goto out; 877 878 fw_crc = get_unaligned_le16(&ts->report_data[ts->report_size]); 879 calc_crc = raydium_calc_chksum(ts->report_data, ts->report_size); 880 if (unlikely(fw_crc != calc_crc)) { 881 dev_warn(&ts->client->dev, 882 "%s: invalid packet crc %#04x vs %#04x\n", 883 __func__, calc_crc, fw_crc); 884 goto out; 885 } 886 887 raydium_mt_event(ts); 888 889 out: 890 return IRQ_HANDLED; 891 } 892 893 static ssize_t raydium_i2c_fw_ver_show(struct device *dev, 894 struct device_attribute *attr, char *buf) 895 { 896 struct i2c_client *client = to_i2c_client(dev); 897 struct raydium_data *ts = i2c_get_clientdata(client); 898 899 return sprintf(buf, "%d.%d\n", ts->info.main_ver, ts->info.sub_ver); 900 } 901 902 static ssize_t raydium_i2c_hw_ver_show(struct device *dev, 903 struct device_attribute *attr, char *buf) 904 { 905 struct i2c_client *client = to_i2c_client(dev); 906 struct raydium_data *ts = i2c_get_clientdata(client); 907 908 return sprintf(buf, "%#04x\n", le32_to_cpu(ts->info.hw_ver)); 909 } 910 911 static ssize_t raydium_i2c_boot_mode_show(struct device *dev, 912 struct device_attribute *attr, 913 char *buf) 914 { 915 struct i2c_client *client = to_i2c_client(dev); 916 struct raydium_data *ts = i2c_get_clientdata(client); 917 918 return sprintf(buf, "%s\n", 919 ts->boot_mode == RAYDIUM_TS_MAIN ? 920 "Normal" : "Recovery"); 921 } 922 923 static ssize_t raydium_i2c_update_fw_store(struct device *dev, 924 struct device_attribute *attr, 925 const char *buf, size_t count) 926 { 927 struct i2c_client *client = to_i2c_client(dev); 928 struct raydium_data *ts = i2c_get_clientdata(client); 929 int error; 930 931 error = mutex_lock_interruptible(&ts->sysfs_mutex); 932 if (error) 933 return error; 934 935 error = raydium_i2c_fw_update(ts); 936 937 mutex_unlock(&ts->sysfs_mutex); 938 939 return error ?: count; 940 } 941 942 static ssize_t raydium_i2c_calibrate_store(struct device *dev, 943 struct device_attribute *attr, 944 const char *buf, size_t count) 945 { 946 struct i2c_client *client = to_i2c_client(dev); 947 struct raydium_data *ts = i2c_get_clientdata(client); 948 static const u8 cal_cmd[] = { 0x00, 0x01, 0x9E }; 949 int error; 950 951 error = mutex_lock_interruptible(&ts->sysfs_mutex); 952 if (error) 953 return error; 954 955 error = raydium_i2c_write_object(client, cal_cmd, sizeof(cal_cmd), 956 RAYDIUM_WAIT_READY); 957 if (error) 958 dev_err(&client->dev, "calibrate command failed: %d\n", error); 959 960 mutex_unlock(&ts->sysfs_mutex); 961 return error ?: count; 962 } 963 964 static DEVICE_ATTR(fw_version, S_IRUGO, raydium_i2c_fw_ver_show, NULL); 965 static DEVICE_ATTR(hw_version, S_IRUGO, raydium_i2c_hw_ver_show, NULL); 966 static DEVICE_ATTR(boot_mode, S_IRUGO, raydium_i2c_boot_mode_show, NULL); 967 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, raydium_i2c_update_fw_store); 968 static DEVICE_ATTR(calibrate, S_IWUSR, NULL, raydium_i2c_calibrate_store); 969 970 static struct attribute *raydium_i2c_attributes[] = { 971 &dev_attr_update_fw.attr, 972 &dev_attr_boot_mode.attr, 973 &dev_attr_fw_version.attr, 974 &dev_attr_hw_version.attr, 975 &dev_attr_calibrate.attr, 976 NULL 977 }; 978 979 static const struct attribute_group raydium_i2c_attribute_group = { 980 .attrs = raydium_i2c_attributes, 981 }; 982 983 static int raydium_i2c_power_on(struct raydium_data *ts) 984 { 985 int error; 986 987 if (!ts->reset_gpio) 988 return 0; 989 990 gpiod_set_value_cansleep(ts->reset_gpio, 1); 991 992 error = regulator_enable(ts->avdd); 993 if (error) { 994 dev_err(&ts->client->dev, 995 "failed to enable avdd regulator: %d\n", error); 996 goto release_reset_gpio; 997 } 998 999 error = regulator_enable(ts->vccio); 1000 if (error) { 1001 regulator_disable(ts->avdd); 1002 dev_err(&ts->client->dev, 1003 "failed to enable vccio regulator: %d\n", error); 1004 goto release_reset_gpio; 1005 } 1006 1007 udelay(RM_POWERON_DELAY_USEC); 1008 1009 release_reset_gpio: 1010 gpiod_set_value_cansleep(ts->reset_gpio, 0); 1011 1012 if (error) 1013 return error; 1014 1015 msleep(RM_RESET_DELAY_MSEC); 1016 1017 return 0; 1018 } 1019 1020 static void raydium_i2c_power_off(void *_data) 1021 { 1022 struct raydium_data *ts = _data; 1023 1024 if (ts->reset_gpio) { 1025 gpiod_set_value_cansleep(ts->reset_gpio, 1); 1026 regulator_disable(ts->vccio); 1027 regulator_disable(ts->avdd); 1028 } 1029 } 1030 1031 static int raydium_i2c_probe(struct i2c_client *client, 1032 const struct i2c_device_id *id) 1033 { 1034 union i2c_smbus_data dummy; 1035 struct raydium_data *ts; 1036 int error; 1037 1038 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 1039 dev_err(&client->dev, 1040 "i2c check functionality error (need I2C_FUNC_I2C)\n"); 1041 return -ENXIO; 1042 } 1043 1044 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); 1045 if (!ts) 1046 return -ENOMEM; 1047 1048 mutex_init(&ts->sysfs_mutex); 1049 1050 ts->client = client; 1051 i2c_set_clientdata(client, ts); 1052 1053 ts->avdd = devm_regulator_get(&client->dev, "avdd"); 1054 if (IS_ERR(ts->avdd)) { 1055 error = PTR_ERR(ts->avdd); 1056 if (error != -EPROBE_DEFER) 1057 dev_err(&client->dev, 1058 "Failed to get 'avdd' regulator: %d\n", error); 1059 return error; 1060 } 1061 1062 ts->vccio = devm_regulator_get(&client->dev, "vccio"); 1063 if (IS_ERR(ts->vccio)) { 1064 error = PTR_ERR(ts->vccio); 1065 if (error != -EPROBE_DEFER) 1066 dev_err(&client->dev, 1067 "Failed to get 'vccio' regulator: %d\n", error); 1068 return error; 1069 } 1070 1071 ts->reset_gpio = devm_gpiod_get_optional(&client->dev, "reset", 1072 GPIOD_OUT_LOW); 1073 if (IS_ERR(ts->reset_gpio)) { 1074 error = PTR_ERR(ts->reset_gpio); 1075 if (error != -EPROBE_DEFER) 1076 dev_err(&client->dev, 1077 "failed to get reset gpio: %d\n", error); 1078 return error; 1079 } 1080 1081 error = raydium_i2c_power_on(ts); 1082 if (error) 1083 return error; 1084 1085 error = devm_add_action(&client->dev, raydium_i2c_power_off, ts); 1086 if (error) { 1087 dev_err(&client->dev, 1088 "failed to install power off action: %d\n", error); 1089 raydium_i2c_power_off(ts); 1090 return error; 1091 } 1092 1093 /* Make sure there is something at this address */ 1094 if (i2c_smbus_xfer(client->adapter, client->addr, 0, 1095 I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) { 1096 dev_err(&client->dev, "nothing at this address\n"); 1097 return -ENXIO; 1098 } 1099 1100 error = raydium_i2c_initialize(ts); 1101 if (error) { 1102 dev_err(&client->dev, "failed to initialize: %d\n", error); 1103 return error; 1104 } 1105 1106 ts->report_data = devm_kmalloc(&client->dev, 1107 ts->pkg_size, GFP_KERNEL); 1108 if (!ts->report_data) 1109 return -ENOMEM; 1110 1111 ts->input = devm_input_allocate_device(&client->dev); 1112 if (!ts->input) { 1113 dev_err(&client->dev, "Failed to allocate input device\n"); 1114 return -ENOMEM; 1115 } 1116 1117 ts->input->name = "Raydium Touchscreen"; 1118 ts->input->id.bustype = BUS_I2C; 1119 1120 input_set_abs_params(ts->input, ABS_MT_POSITION_X, 1121 0, le16_to_cpu(ts->info.x_max), 0, 0); 1122 input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 1123 0, le16_to_cpu(ts->info.y_max), 0, 0); 1124 input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->info.x_res); 1125 input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->info.y_res); 1126 1127 input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); 1128 input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0); 1129 1130 error = input_mt_init_slots(ts->input, RM_MAX_TOUCH_NUM, 1131 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 1132 if (error) { 1133 dev_err(&client->dev, 1134 "failed to initialize MT slots: %d\n", error); 1135 return error; 1136 } 1137 1138 error = input_register_device(ts->input); 1139 if (error) { 1140 dev_err(&client->dev, 1141 "unable to register input device: %d\n", error); 1142 return error; 1143 } 1144 1145 error = devm_request_threaded_irq(&client->dev, client->irq, 1146 NULL, raydium_i2c_irq, 1147 IRQF_ONESHOT, client->name, ts); 1148 if (error) { 1149 dev_err(&client->dev, "Failed to register interrupt\n"); 1150 return error; 1151 } 1152 1153 error = devm_device_add_group(&client->dev, 1154 &raydium_i2c_attribute_group); 1155 if (error) { 1156 dev_err(&client->dev, "failed to create sysfs attributes: %d\n", 1157 error); 1158 return error; 1159 } 1160 1161 return 0; 1162 } 1163 1164 static void __maybe_unused raydium_enter_sleep(struct i2c_client *client) 1165 { 1166 static const u8 sleep_cmd[] = { 0x5A, 0xff, 0x00, 0x0f }; 1167 int error; 1168 1169 error = raydium_i2c_send(client, RM_CMD_ENTER_SLEEP, 1170 sleep_cmd, sizeof(sleep_cmd)); 1171 if (error) 1172 dev_err(&client->dev, 1173 "sleep command failed: %d\n", error); 1174 } 1175 1176 static int __maybe_unused raydium_i2c_suspend(struct device *dev) 1177 { 1178 struct i2c_client *client = to_i2c_client(dev); 1179 struct raydium_data *ts = i2c_get_clientdata(client); 1180 1181 /* Sleep is not available in BLDR recovery mode */ 1182 if (ts->boot_mode != RAYDIUM_TS_MAIN) 1183 return -EBUSY; 1184 1185 disable_irq(client->irq); 1186 1187 if (device_may_wakeup(dev)) { 1188 raydium_enter_sleep(client); 1189 1190 ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0); 1191 } else { 1192 raydium_i2c_power_off(ts); 1193 } 1194 1195 return 0; 1196 } 1197 1198 static int __maybe_unused raydium_i2c_resume(struct device *dev) 1199 { 1200 struct i2c_client *client = to_i2c_client(dev); 1201 struct raydium_data *ts = i2c_get_clientdata(client); 1202 1203 if (device_may_wakeup(dev)) { 1204 if (ts->wake_irq_enabled) 1205 disable_irq_wake(client->irq); 1206 raydium_i2c_sw_reset(client); 1207 } else { 1208 raydium_i2c_power_on(ts); 1209 raydium_i2c_initialize(ts); 1210 } 1211 1212 enable_irq(client->irq); 1213 1214 return 0; 1215 } 1216 1217 static SIMPLE_DEV_PM_OPS(raydium_i2c_pm_ops, 1218 raydium_i2c_suspend, raydium_i2c_resume); 1219 1220 static const struct i2c_device_id raydium_i2c_id[] = { 1221 { "raydium_i2c" , 0 }, 1222 { "rm32380", 0 }, 1223 { /* sentinel */ } 1224 }; 1225 MODULE_DEVICE_TABLE(i2c, raydium_i2c_id); 1226 1227 #ifdef CONFIG_ACPI 1228 static const struct acpi_device_id raydium_acpi_id[] = { 1229 { "RAYD0001", 0 }, 1230 { /* sentinel */ } 1231 }; 1232 MODULE_DEVICE_TABLE(acpi, raydium_acpi_id); 1233 #endif 1234 1235 #ifdef CONFIG_OF 1236 static const struct of_device_id raydium_of_match[] = { 1237 { .compatible = "raydium,rm32380", }, 1238 { /* sentinel */ } 1239 }; 1240 MODULE_DEVICE_TABLE(of, raydium_of_match); 1241 #endif 1242 1243 static struct i2c_driver raydium_i2c_driver = { 1244 .probe = raydium_i2c_probe, 1245 .id_table = raydium_i2c_id, 1246 .driver = { 1247 .name = "raydium_ts", 1248 .pm = &raydium_i2c_pm_ops, 1249 .acpi_match_table = ACPI_PTR(raydium_acpi_id), 1250 .of_match_table = of_match_ptr(raydium_of_match), 1251 }, 1252 }; 1253 module_i2c_driver(raydium_i2c_driver); 1254 1255 MODULE_AUTHOR("Raydium"); 1256 MODULE_DESCRIPTION("Raydium I2c Touchscreen driver"); 1257 MODULE_LICENSE("GPL v2"); 1258