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