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