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