1 /* 2 * MELFAS MIP4 Touchscreen 3 * 4 * Copyright (C) 2016 MELFAS Inc. 5 * 6 * Author : Sangwon Jee <jeesw@melfas.com> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 2 11 * of the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/acpi.h> 20 #include <linux/delay.h> 21 #include <linux/firmware.h> 22 #include <linux/gpio/consumer.h> 23 #include <linux/i2c.h> 24 #include <linux/input.h> 25 #include <linux/input/mt.h> 26 #include <linux/interrupt.h> 27 #include <linux/module.h> 28 #include <linux/of.h> 29 #include <linux/slab.h> 30 #include <asm/unaligned.h> 31 32 #define MIP4_DEVICE_NAME "mip4_ts" 33 34 /***************************************************************** 35 * Protocol 36 * Version : MIP 4.0 Rev 5.4 37 *****************************************************************/ 38 39 /* Address */ 40 #define MIP4_R0_BOOT 0x00 41 #define MIP4_R1_BOOT_MODE 0x01 42 #define MIP4_R1_BOOT_BUF_ADDR 0x10 43 #define MIP4_R1_BOOT_STATUS 0x20 44 #define MIP4_R1_BOOT_CMD 0x30 45 #define MIP4_R1_BOOT_TARGET_ADDR 0x40 46 #define MIP4_R1_BOOT_SIZE 0x44 47 48 #define MIP4_R0_INFO 0x01 49 #define MIP4_R1_INFO_PRODUCT_NAME 0x00 50 #define MIP4_R1_INFO_RESOLUTION_X 0x10 51 #define MIP4_R1_INFO_RESOLUTION_Y 0x12 52 #define MIP4_R1_INFO_NODE_NUM_X 0x14 53 #define MIP4_R1_INFO_NODE_NUM_Y 0x15 54 #define MIP4_R1_INFO_KEY_NUM 0x16 55 #define MIP4_R1_INFO_PRESSURE_NUM 0x17 56 #define MIP4_R1_INFO_LENGTH_X 0x18 57 #define MIP4_R1_INFO_LENGTH_Y 0x1A 58 #define MIP4_R1_INFO_PPM_X 0x1C 59 #define MIP4_R1_INFO_PPM_Y 0x1D 60 #define MIP4_R1_INFO_VERSION_BOOT 0x20 61 #define MIP4_R1_INFO_VERSION_CORE 0x22 62 #define MIP4_R1_INFO_VERSION_APP 0x24 63 #define MIP4_R1_INFO_VERSION_PARAM 0x26 64 #define MIP4_R1_INFO_SECT_BOOT_START 0x30 65 #define MIP4_R1_INFO_SECT_BOOT_END 0x31 66 #define MIP4_R1_INFO_SECT_CORE_START 0x32 67 #define MIP4_R1_INFO_SECT_CORE_END 0x33 68 #define MIP4_R1_INFO_SECT_APP_START 0x34 69 #define MIP4_R1_INFO_SECT_APP_END 0x35 70 #define MIP4_R1_INFO_SECT_PARAM_START 0x36 71 #define MIP4_R1_INFO_SECT_PARAM_END 0x37 72 #define MIP4_R1_INFO_BUILD_DATE 0x40 73 #define MIP4_R1_INFO_BUILD_TIME 0x44 74 #define MIP4_R1_INFO_CHECKSUM_PRECALC 0x48 75 #define MIP4_R1_INFO_CHECKSUM_REALTIME 0x4A 76 #define MIP4_R1_INFO_PROTOCOL_NAME 0x50 77 #define MIP4_R1_INFO_PROTOCOL_VERSION 0x58 78 #define MIP4_R1_INFO_IC_ID 0x70 79 #define MIP4_R1_INFO_IC_NAME 0x71 80 #define MIP4_R1_INFO_IC_VENDOR_ID 0x75 81 #define MIP4_R1_INFO_IC_HW_CATEGORY 0x77 82 #define MIP4_R1_INFO_CONTACT_THD_SCR 0x78 83 #define MIP4_R1_INFO_CONTACT_THD_KEY 0x7A 84 #define MIP4_R1_INFO_PID 0x7C 85 #define MIP4_R1_INFO_VID 0x7E 86 #define MIP4_R1_INFO_SLAVE_ADDR 0x80 87 88 #define MIP4_R0_EVENT 0x02 89 #define MIP4_R1_EVENT_SUPPORTED_FUNC 0x00 90 #define MIP4_R1_EVENT_FORMAT 0x04 91 #define MIP4_R1_EVENT_SIZE 0x06 92 #define MIP4_R1_EVENT_PACKET_INFO 0x10 93 #define MIP4_R1_EVENT_PACKET_DATA 0x11 94 95 #define MIP4_R0_CTRL 0x06 96 #define MIP4_R1_CTRL_READY_STATUS 0x00 97 #define MIP4_R1_CTRL_EVENT_READY 0x01 98 #define MIP4_R1_CTRL_MODE 0x10 99 #define MIP4_R1_CTRL_EVENT_TRIGGER_TYPE 0x11 100 #define MIP4_R1_CTRL_RECALIBRATE 0x12 101 #define MIP4_R1_CTRL_POWER_STATE 0x13 102 #define MIP4_R1_CTRL_GESTURE_TYPE 0x14 103 #define MIP4_R1_CTRL_DISABLE_ESD_ALERT 0x18 104 #define MIP4_R1_CTRL_CHARGER_MODE 0x19 105 #define MIP4_R1_CTRL_HIGH_SENS_MODE 0x1A 106 #define MIP4_R1_CTRL_WINDOW_MODE 0x1B 107 #define MIP4_R1_CTRL_PALM_REJECTION 0x1C 108 #define MIP4_R1_CTRL_EDGE_CORRECTION 0x1D 109 #define MIP4_R1_CTRL_ENTER_GLOVE_MODE 0x1E 110 #define MIP4_R1_CTRL_I2C_ON_LPM 0x1F 111 #define MIP4_R1_CTRL_GESTURE_DEBUG 0x20 112 #define MIP4_R1_CTRL_PALM_EVENT 0x22 113 #define MIP4_R1_CTRL_PROXIMITY_SENSING 0x23 114 115 /* Value */ 116 #define MIP4_BOOT_MODE_BOOT 0x01 117 #define MIP4_BOOT_MODE_APP 0x02 118 119 #define MIP4_BOOT_STATUS_BUSY 0x05 120 #define MIP4_BOOT_STATUS_ERROR 0x0E 121 #define MIP4_BOOT_STATUS_DONE 0xA0 122 123 #define MIP4_BOOT_CMD_MASS_ERASE 0x15 124 #define MIP4_BOOT_CMD_PROGRAM 0x54 125 #define MIP4_BOOT_CMD_ERASE 0x8F 126 #define MIP4_BOOT_CMD_WRITE 0xA5 127 #define MIP4_BOOT_CMD_READ 0xC2 128 129 #define MIP4_EVENT_INPUT_TYPE_KEY 0 130 #define MIP4_EVENT_INPUT_TYPE_SCREEN 1 131 #define MIP4_EVENT_INPUT_TYPE_PROXIMITY 2 132 133 #define I2C_RETRY_COUNT 3 /* 2~ */ 134 135 #define MIP4_BUF_SIZE 128 136 #define MIP4_MAX_FINGERS 10 137 #define MIP4_MAX_KEYS 4 138 139 #define MIP4_TOUCH_MAJOR_MIN 0 140 #define MIP4_TOUCH_MAJOR_MAX 255 141 #define MIP4_TOUCH_MINOR_MIN 0 142 #define MIP4_TOUCH_MINOR_MAX 255 143 #define MIP4_PRESSURE_MIN 0 144 #define MIP4_PRESSURE_MAX 255 145 146 #define MIP4_FW_NAME "melfas_mip4.fw" 147 #define MIP4_FW_UPDATE_DEBUG 0 /* 0 (default) or 1 */ 148 149 struct mip4_fw_version { 150 u16 boot; 151 u16 core; 152 u16 app; 153 u16 param; 154 }; 155 156 struct mip4_ts { 157 struct i2c_client *client; 158 struct input_dev *input; 159 struct gpio_desc *gpio_ce; 160 161 char phys[32]; 162 char product_name[16]; 163 u16 product_id; 164 char ic_name[4]; 165 166 unsigned int max_x; 167 unsigned int max_y; 168 u8 node_x; 169 u8 node_y; 170 u8 node_key; 171 unsigned int ppm_x; 172 unsigned int ppm_y; 173 174 struct mip4_fw_version fw_version; 175 176 unsigned int event_size; 177 unsigned int event_format; 178 179 unsigned int key_num; 180 unsigned short key_code[MIP4_MAX_KEYS]; 181 182 bool wake_irq_enabled; 183 184 u8 buf[MIP4_BUF_SIZE]; 185 }; 186 187 static int mip4_i2c_xfer(struct mip4_ts *ts, 188 char *write_buf, unsigned int write_len, 189 char *read_buf, unsigned int read_len) 190 { 191 struct i2c_msg msg[] = { 192 { 193 .addr = ts->client->addr, 194 .flags = 0, 195 .buf = write_buf, 196 .len = write_len, 197 }, { 198 .addr = ts->client->addr, 199 .flags = I2C_M_RD, 200 .buf = read_buf, 201 .len = read_len, 202 }, 203 }; 204 int retry = I2C_RETRY_COUNT; 205 int res; 206 int error; 207 208 do { 209 res = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 210 if (res == ARRAY_SIZE(msg)) 211 return 0; 212 213 error = res < 0 ? res : -EIO; 214 dev_err(&ts->client->dev, 215 "%s - i2c_transfer failed: %d (%d)\n", 216 __func__, error, res); 217 } while (--retry); 218 219 return error; 220 } 221 222 static void mip4_parse_fw_version(const u8 *buf, struct mip4_fw_version *v) 223 { 224 v->boot = get_unaligned_le16(buf + 0); 225 v->core = get_unaligned_le16(buf + 2); 226 v->app = get_unaligned_le16(buf + 4); 227 v->param = get_unaligned_le16(buf + 6); 228 } 229 230 /* 231 * Read chip firmware version 232 */ 233 static int mip4_get_fw_version(struct mip4_ts *ts) 234 { 235 u8 cmd[] = { MIP4_R0_INFO, MIP4_R1_INFO_VERSION_BOOT }; 236 u8 buf[sizeof(ts->fw_version)]; 237 int error; 238 239 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, sizeof(buf)); 240 if (error) { 241 memset(&ts->fw_version, 0xff, sizeof(ts->fw_version)); 242 return error; 243 } 244 245 mip4_parse_fw_version(buf, &ts->fw_version); 246 247 return 0; 248 } 249 250 /* 251 * Fetch device characteristics 252 */ 253 static int mip4_query_device(struct mip4_ts *ts) 254 { 255 int error; 256 u8 cmd[2]; 257 u8 buf[14]; 258 259 /* Product name */ 260 cmd[0] = MIP4_R0_INFO; 261 cmd[1] = MIP4_R1_INFO_PRODUCT_NAME; 262 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), 263 ts->product_name, sizeof(ts->product_name)); 264 if (error) 265 dev_warn(&ts->client->dev, 266 "Failed to retrieve product name: %d\n", error); 267 else 268 dev_dbg(&ts->client->dev, "product name: %.*s\n", 269 (int)sizeof(ts->product_name), ts->product_name); 270 271 /* Product ID */ 272 cmd[0] = MIP4_R0_INFO; 273 cmd[1] = MIP4_R1_INFO_PID; 274 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, 2); 275 if (error) { 276 dev_warn(&ts->client->dev, 277 "Failed to retrieve product id: %d\n", error); 278 } else { 279 ts->product_id = get_unaligned_le16(&buf[0]); 280 dev_dbg(&ts->client->dev, "product id: %04X\n", ts->product_id); 281 } 282 283 /* IC name */ 284 cmd[0] = MIP4_R0_INFO; 285 cmd[1] = MIP4_R1_INFO_IC_NAME; 286 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), 287 ts->ic_name, sizeof(ts->ic_name)); 288 if (error) 289 dev_warn(&ts->client->dev, 290 "Failed to retrieve IC name: %d\n", error); 291 else 292 dev_dbg(&ts->client->dev, "IC name: %.*s\n", 293 (int)sizeof(ts->ic_name), ts->ic_name); 294 295 /* Firmware version */ 296 error = mip4_get_fw_version(ts); 297 if (error) 298 dev_warn(&ts->client->dev, 299 "Failed to retrieve FW version: %d\n", error); 300 else 301 dev_dbg(&ts->client->dev, "F/W Version: %04X %04X %04X %04X\n", 302 ts->fw_version.boot, ts->fw_version.core, 303 ts->fw_version.app, ts->fw_version.param); 304 305 /* Resolution */ 306 cmd[0] = MIP4_R0_INFO; 307 cmd[1] = MIP4_R1_INFO_RESOLUTION_X; 308 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, 14); 309 if (error) { 310 dev_warn(&ts->client->dev, 311 "Failed to retrieve touchscreen parameters: %d\n", 312 error); 313 } else { 314 ts->max_x = get_unaligned_le16(&buf[0]); 315 ts->max_y = get_unaligned_le16(&buf[2]); 316 dev_dbg(&ts->client->dev, "max_x: %d, max_y: %d\n", 317 ts->max_x, ts->max_y); 318 319 ts->node_x = buf[4]; 320 ts->node_y = buf[5]; 321 ts->node_key = buf[6]; 322 dev_dbg(&ts->client->dev, 323 "node_x: %d, node_y: %d, node_key: %d\n", 324 ts->node_x, ts->node_y, ts->node_key); 325 326 ts->ppm_x = buf[12]; 327 ts->ppm_y = buf[13]; 328 dev_dbg(&ts->client->dev, "ppm_x: %d, ppm_y: %d\n", 329 ts->ppm_x, ts->ppm_y); 330 331 /* Key ts */ 332 if (ts->node_key > 0) 333 ts->key_num = ts->node_key; 334 } 335 336 /* Protocol */ 337 cmd[0] = MIP4_R0_EVENT; 338 cmd[1] = MIP4_R1_EVENT_SUPPORTED_FUNC; 339 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), buf, 7); 340 if (error) { 341 dev_warn(&ts->client->dev, 342 "Failed to retrieve device type: %d\n", error); 343 ts->event_format = 0xff; 344 } else { 345 ts->event_format = get_unaligned_le16(&buf[4]); 346 ts->event_size = buf[6]; 347 dev_dbg(&ts->client->dev, "event_format: %d, event_size: %d\n", 348 ts->event_format, ts->event_size); 349 350 if (ts->event_format == 2 || ts->event_format > 3) 351 dev_warn(&ts->client->dev, 352 "Unknown event format %d\n", ts->event_format); 353 } 354 355 return 0; 356 } 357 358 static int mip4_power_on(struct mip4_ts *ts) 359 { 360 if (ts->gpio_ce) { 361 gpiod_set_value_cansleep(ts->gpio_ce, 1); 362 363 /* Booting delay : 200~300ms */ 364 usleep_range(200 * 1000, 300 * 1000); 365 } 366 367 return 0; 368 } 369 370 static void mip4_power_off(struct mip4_ts *ts) 371 { 372 if (ts->gpio_ce) 373 gpiod_set_value_cansleep(ts->gpio_ce, 0); 374 } 375 376 /* 377 * Clear touch input event status 378 */ 379 static void mip4_clear_input(struct mip4_ts *ts) 380 { 381 int i; 382 383 /* Screen */ 384 for (i = 0; i < MIP4_MAX_FINGERS; i++) { 385 input_mt_slot(ts->input, i); 386 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 0); 387 } 388 389 /* Keys */ 390 for (i = 0; i < ts->key_num; i++) 391 input_report_key(ts->input, ts->key_code[i], 0); 392 393 input_sync(ts->input); 394 } 395 396 static int mip4_enable(struct mip4_ts *ts) 397 { 398 int error; 399 400 error = mip4_power_on(ts); 401 if (error) 402 return error; 403 404 enable_irq(ts->client->irq); 405 406 return 0; 407 } 408 409 static void mip4_disable(struct mip4_ts *ts) 410 { 411 disable_irq(ts->client->irq); 412 413 mip4_power_off(ts); 414 415 mip4_clear_input(ts); 416 } 417 418 /***************************************************************** 419 * Input handling 420 *****************************************************************/ 421 422 static void mip4_report_keys(struct mip4_ts *ts, u8 *packet) 423 { 424 u8 key; 425 bool down; 426 427 switch (ts->event_format) { 428 case 0: 429 case 1: 430 key = packet[0] & 0x0F; 431 down = packet[0] & 0x80; 432 break; 433 434 case 3: 435 default: 436 key = packet[0] & 0x0F; 437 down = packet[1] & 0x01; 438 break; 439 } 440 441 /* Report key event */ 442 if (key >= 1 && key <= ts->key_num) { 443 unsigned short keycode = ts->key_code[key - 1]; 444 445 dev_dbg(&ts->client->dev, 446 "Key - ID: %d, keycode: %d, state: %d\n", 447 key, keycode, down); 448 449 input_event(ts->input, EV_MSC, MSC_SCAN, keycode); 450 input_report_key(ts->input, keycode, down); 451 452 } else { 453 dev_err(&ts->client->dev, "Unknown key: %d\n", key); 454 } 455 } 456 457 static void mip4_report_touch(struct mip4_ts *ts, u8 *packet) 458 { 459 int id; 460 bool hover; 461 bool palm; 462 bool state; 463 u16 x, y; 464 u8 pressure_stage = 0; 465 u8 pressure; 466 u8 size; 467 u8 touch_major; 468 u8 touch_minor; 469 470 switch (ts->event_format) { 471 case 0: 472 case 1: 473 /* Touch only */ 474 state = packet[0] & BIT(7); 475 hover = packet[0] & BIT(5); 476 palm = packet[0] & BIT(4); 477 id = (packet[0] & 0x0F) - 1; 478 x = ((packet[1] & 0x0F) << 8) | packet[2]; 479 y = (((packet[1] >> 4) & 0x0F) << 8) | 480 packet[3]; 481 pressure = packet[4]; 482 size = packet[5]; 483 if (ts->event_format == 0) { 484 touch_major = packet[5]; 485 touch_minor = packet[5]; 486 } else { 487 touch_major = packet[6]; 488 touch_minor = packet[7]; 489 } 490 break; 491 492 case 3: 493 default: 494 /* Touch + Force(Pressure) */ 495 id = (packet[0] & 0x0F) - 1; 496 hover = packet[1] & BIT(2); 497 palm = packet[1] & BIT(1); 498 state = packet[1] & BIT(0); 499 x = ((packet[2] & 0x0F) << 8) | packet[3]; 500 y = (((packet[2] >> 4) & 0x0F) << 8) | 501 packet[4]; 502 size = packet[6]; 503 pressure_stage = (packet[7] & 0xF0) >> 4; 504 pressure = ((packet[7] & 0x0F) << 8) | 505 packet[8]; 506 touch_major = packet[9]; 507 touch_minor = packet[10]; 508 break; 509 } 510 511 dev_dbg(&ts->client->dev, 512 "Screen - Slot: %d State: %d X: %04d Y: %04d Z: %d\n", 513 id, state, x, y, pressure); 514 515 if (unlikely(id < 0 || id >= MIP4_MAX_FINGERS)) { 516 dev_err(&ts->client->dev, "Screen - invalid slot ID: %d\n", id); 517 } else if (state) { 518 /* Press or Move event */ 519 input_mt_slot(ts->input, id); 520 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); 521 input_report_abs(ts->input, ABS_MT_POSITION_X, x); 522 input_report_abs(ts->input, ABS_MT_POSITION_Y, y); 523 input_report_abs(ts->input, ABS_MT_PRESSURE, pressure); 524 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, touch_major); 525 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, touch_minor); 526 } else { 527 /* Release event */ 528 input_mt_slot(ts->input, id); 529 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, 0); 530 } 531 532 input_mt_sync_frame(ts->input); 533 } 534 535 static int mip4_handle_packet(struct mip4_ts *ts, u8 *packet) 536 { 537 u8 type; 538 539 switch (ts->event_format) { 540 case 0: 541 case 1: 542 type = (packet[0] & 0x40) >> 6; 543 break; 544 545 case 3: 546 type = (packet[0] & 0xF0) >> 4; 547 break; 548 549 default: 550 /* Should not happen unless we have corrupted firmware */ 551 return -EINVAL; 552 } 553 554 dev_dbg(&ts->client->dev, "Type: %d\n", type); 555 556 /* Report input event */ 557 switch (type) { 558 case MIP4_EVENT_INPUT_TYPE_KEY: 559 mip4_report_keys(ts, packet); 560 break; 561 562 case MIP4_EVENT_INPUT_TYPE_SCREEN: 563 mip4_report_touch(ts, packet); 564 break; 565 566 default: 567 dev_err(&ts->client->dev, "Unknown event type: %d\n", type); 568 break; 569 } 570 571 return 0; 572 } 573 574 static irqreturn_t mip4_interrupt(int irq, void *dev_id) 575 { 576 struct mip4_ts *ts = dev_id; 577 struct i2c_client *client = ts->client; 578 unsigned int i; 579 int error; 580 u8 cmd[2]; 581 u8 size; 582 bool alert; 583 584 /* Read packet info */ 585 cmd[0] = MIP4_R0_EVENT; 586 cmd[1] = MIP4_R1_EVENT_PACKET_INFO; 587 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), ts->buf, 1); 588 if (error) { 589 dev_err(&client->dev, 590 "Failed to read packet info: %d\n", error); 591 goto out; 592 } 593 594 size = ts->buf[0] & 0x7F; 595 alert = ts->buf[0] & BIT(7); 596 dev_dbg(&client->dev, "packet size: %d, alert: %d\n", size, alert); 597 598 /* Check size */ 599 if (!size) { 600 dev_err(&client->dev, "Empty packet\n"); 601 goto out; 602 } 603 604 /* Read packet data */ 605 cmd[0] = MIP4_R0_EVENT; 606 cmd[1] = MIP4_R1_EVENT_PACKET_DATA; 607 error = mip4_i2c_xfer(ts, cmd, sizeof(cmd), ts->buf, size); 608 if (error) { 609 dev_err(&client->dev, 610 "Failed to read packet data: %d\n", error); 611 goto out; 612 } 613 614 if (alert) { 615 dev_dbg(&client->dev, "Alert: %d\n", ts->buf[0]); 616 } else { 617 for (i = 0; i < size; i += ts->event_size) { 618 error = mip4_handle_packet(ts, &ts->buf[i]); 619 if (error) 620 break; 621 } 622 623 input_sync(ts->input); 624 } 625 626 out: 627 return IRQ_HANDLED; 628 } 629 630 static int mip4_input_open(struct input_dev *dev) 631 { 632 struct mip4_ts *ts = input_get_drvdata(dev); 633 634 return mip4_enable(ts); 635 } 636 637 static void mip4_input_close(struct input_dev *dev) 638 { 639 struct mip4_ts *ts = input_get_drvdata(dev); 640 641 mip4_disable(ts); 642 } 643 644 /***************************************************************** 645 * Firmware update 646 *****************************************************************/ 647 648 /* Firmware Info */ 649 #define MIP4_BL_PAGE_SIZE 512 /* 512 */ 650 #define MIP4_BL_PACKET_SIZE 512 /* 512, 256, 128, 64, ... */ 651 652 /* 653 * Firmware binary tail info 654 */ 655 656 struct mip4_bin_tail { 657 u8 tail_mark[4]; 658 u8 chip_name[4]; 659 660 __le32 bin_start_addr; 661 __le32 bin_length; 662 663 __le16 ver_boot; 664 __le16 ver_core; 665 __le16 ver_app; 666 __le16 ver_param; 667 668 u8 boot_start; 669 u8 boot_end; 670 u8 core_start; 671 u8 core_end; 672 u8 app_start; 673 u8 app_end; 674 u8 param_start; 675 u8 param_end; 676 677 u8 checksum_type; 678 u8 hw_category; 679 680 __le16 param_id; 681 __le32 param_length; 682 __le32 build_date; 683 __le32 build_time; 684 685 __le32 reserved1; 686 __le32 reserved2; 687 __le16 reserved3; 688 __le16 tail_size; 689 __le32 crc; 690 } __packed; 691 692 #define MIP4_BIN_TAIL_MARK "MBT\001" 693 #define MIP4_BIN_TAIL_SIZE (sizeof(struct mip4_bin_tail)) 694 695 /* 696 * Bootloader - Read status 697 */ 698 static int mip4_bl_read_status(struct mip4_ts *ts) 699 { 700 u8 cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_STATUS }; 701 u8 result; 702 struct i2c_msg msg[] = { 703 { 704 .addr = ts->client->addr, 705 .flags = 0, 706 .buf = cmd, 707 .len = sizeof(cmd), 708 }, { 709 .addr = ts->client->addr, 710 .flags = I2C_M_RD, 711 .buf = &result, 712 .len = sizeof(result), 713 }, 714 }; 715 int ret; 716 int error; 717 int retry = 1000; 718 719 do { 720 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 721 if (ret != ARRAY_SIZE(msg)) { 722 error = ret < 0 ? ret : -EIO; 723 dev_err(&ts->client->dev, 724 "Failed to read bootloader status: %d\n", 725 error); 726 return error; 727 } 728 729 switch (result) { 730 case MIP4_BOOT_STATUS_DONE: 731 dev_dbg(&ts->client->dev, "%s - done\n", __func__); 732 return 0; 733 734 case MIP4_BOOT_STATUS_ERROR: 735 dev_err(&ts->client->dev, "Bootloader failure\n"); 736 return -EIO; 737 738 case MIP4_BOOT_STATUS_BUSY: 739 dev_dbg(&ts->client->dev, "%s - Busy\n", __func__); 740 error = -EBUSY; 741 break; 742 743 default: 744 dev_err(&ts->client->dev, 745 "Unexpected bootloader status: %#02x\n", 746 result); 747 error = -EINVAL; 748 break; 749 } 750 751 usleep_range(1000, 2000); 752 } while (--retry); 753 754 return error; 755 } 756 757 /* 758 * Bootloader - Change mode 759 */ 760 static int mip4_bl_change_mode(struct mip4_ts *ts, u8 mode) 761 { 762 u8 mode_chg_cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_MODE, mode }; 763 u8 mode_read_cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_MODE }; 764 u8 result; 765 struct i2c_msg msg[] = { 766 { 767 .addr = ts->client->addr, 768 .flags = 0, 769 .buf = mode_read_cmd, 770 .len = sizeof(mode_read_cmd), 771 }, { 772 .addr = ts->client->addr, 773 .flags = I2C_M_RD, 774 .buf = &result, 775 .len = sizeof(result), 776 }, 777 }; 778 int retry = 10; 779 int ret; 780 int error; 781 782 do { 783 /* Send mode change command */ 784 ret = i2c_master_send(ts->client, 785 mode_chg_cmd, sizeof(mode_chg_cmd)); 786 if (ret != sizeof(mode_chg_cmd)) { 787 error = ret < 0 ? ret : -EIO; 788 dev_err(&ts->client->dev, 789 "Failed to send %d mode change: %d (%d)\n", 790 mode, error, ret); 791 return error; 792 } 793 794 dev_dbg(&ts->client->dev, 795 "Sent mode change request (mode: %d)\n", mode); 796 797 /* Wait */ 798 msleep(1000); 799 800 /* Verify target mode */ 801 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 802 if (ret != ARRAY_SIZE(msg)) { 803 error = ret < 0 ? ret : -EIO; 804 dev_err(&ts->client->dev, 805 "Failed to read device mode: %d\n", error); 806 return error; 807 } 808 809 dev_dbg(&ts->client->dev, 810 "Current device mode: %d, want: %d\n", result, mode); 811 812 if (result == mode) 813 return 0; 814 815 } while (--retry); 816 817 return -EIO; 818 } 819 820 /* 821 * Bootloader - Start bootloader mode 822 */ 823 static int mip4_bl_enter(struct mip4_ts *ts) 824 { 825 return mip4_bl_change_mode(ts, MIP4_BOOT_MODE_BOOT); 826 } 827 828 /* 829 * Bootloader - Exit bootloader mode 830 */ 831 static int mip4_bl_exit(struct mip4_ts *ts) 832 { 833 return mip4_bl_change_mode(ts, MIP4_BOOT_MODE_APP); 834 } 835 836 static int mip4_bl_get_address(struct mip4_ts *ts, u16 *buf_addr) 837 { 838 u8 cmd[] = { MIP4_R0_BOOT, MIP4_R1_BOOT_BUF_ADDR }; 839 u8 result[sizeof(u16)]; 840 struct i2c_msg msg[] = { 841 { 842 .addr = ts->client->addr, 843 .flags = 0, 844 .buf = cmd, 845 .len = sizeof(cmd), 846 }, { 847 .addr = ts->client->addr, 848 .flags = I2C_M_RD, 849 .buf = result, 850 .len = sizeof(result), 851 }, 852 }; 853 int ret; 854 int error; 855 856 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 857 if (ret != ARRAY_SIZE(msg)) { 858 error = ret < 0 ? ret : -EIO; 859 dev_err(&ts->client->dev, 860 "Failed to retrieve bootloader buffer address: %d\n", 861 error); 862 return error; 863 } 864 865 *buf_addr = get_unaligned_le16(result); 866 dev_dbg(&ts->client->dev, 867 "Bootloader buffer address %#04x\n", *buf_addr); 868 869 return 0; 870 } 871 872 static int mip4_bl_program_page(struct mip4_ts *ts, int offset, 873 const u8 *data, int length, u16 buf_addr) 874 { 875 u8 cmd[6]; 876 u8 *data_buf; 877 u16 buf_offset; 878 int ret; 879 int error; 880 881 dev_dbg(&ts->client->dev, "Writing page @%#06x (%d)\n", 882 offset, length); 883 884 if (length > MIP4_BL_PAGE_SIZE || length % MIP4_BL_PACKET_SIZE) { 885 dev_err(&ts->client->dev, 886 "Invalid page length: %d\n", length); 887 return -EINVAL; 888 } 889 890 data_buf = kmalloc(2 + MIP4_BL_PACKET_SIZE, GFP_KERNEL); 891 if (!data_buf) 892 return -ENOMEM; 893 894 /* Addr */ 895 cmd[0] = MIP4_R0_BOOT; 896 cmd[1] = MIP4_R1_BOOT_TARGET_ADDR; 897 put_unaligned_le32(offset, &cmd[2]); 898 ret = i2c_master_send(ts->client, cmd, 6); 899 if (ret != 6) { 900 error = ret < 0 ? ret : -EIO; 901 dev_err(&ts->client->dev, 902 "Failed to send write page address: %d\n", error); 903 goto out; 904 } 905 906 /* Size */ 907 cmd[0] = MIP4_R0_BOOT; 908 cmd[1] = MIP4_R1_BOOT_SIZE; 909 put_unaligned_le32(length, &cmd[2]); 910 ret = i2c_master_send(ts->client, cmd, 6); 911 if (ret != 6) { 912 error = ret < 0 ? ret : -EIO; 913 dev_err(&ts->client->dev, 914 "Failed to send write page size: %d\n", error); 915 goto out; 916 } 917 918 /* Data */ 919 for (buf_offset = 0; 920 buf_offset < length; 921 buf_offset += MIP4_BL_PACKET_SIZE) { 922 dev_dbg(&ts->client->dev, 923 "writing chunk at %#04x (size %d)\n", 924 buf_offset, MIP4_BL_PACKET_SIZE); 925 put_unaligned_be16(buf_addr + buf_offset, data_buf); 926 memcpy(&data_buf[2], &data[buf_offset], MIP4_BL_PACKET_SIZE); 927 ret = i2c_master_send(ts->client, 928 data_buf, 2 + MIP4_BL_PACKET_SIZE); 929 if (ret != 2 + MIP4_BL_PACKET_SIZE) { 930 error = ret < 0 ? ret : -EIO; 931 dev_err(&ts->client->dev, 932 "Failed to read chunk at %#04x (size %d): %d\n", 933 buf_offset, MIP4_BL_PACKET_SIZE, error); 934 goto out; 935 } 936 } 937 938 /* Command */ 939 cmd[0] = MIP4_R0_BOOT; 940 cmd[1] = MIP4_R1_BOOT_CMD; 941 cmd[2] = MIP4_BOOT_CMD_PROGRAM; 942 ret = i2c_master_send(ts->client, cmd, 3); 943 if (ret != 3) { 944 error = ret < 0 ? ret : -EIO; 945 dev_err(&ts->client->dev, 946 "Failed to send 'write' command: %d\n", error); 947 goto out; 948 } 949 950 /* Status */ 951 error = mip4_bl_read_status(ts); 952 953 out: 954 kfree(data_buf); 955 return error ? error : 0; 956 } 957 958 static int mip4_bl_verify_page(struct mip4_ts *ts, int offset, 959 const u8 *data, int length, int buf_addr) 960 { 961 u8 cmd[8]; 962 u8 *read_buf; 963 int buf_offset; 964 struct i2c_msg msg[] = { 965 { 966 .addr = ts->client->addr, 967 .flags = 0, 968 .buf = cmd, 969 .len = 2, 970 }, { 971 .addr = ts->client->addr, 972 .flags = I2C_M_RD, 973 .len = MIP4_BL_PACKET_SIZE, 974 }, 975 }; 976 int ret; 977 int error; 978 979 dev_dbg(&ts->client->dev, "Validating page @%#06x (%d)\n", 980 offset, length); 981 982 /* Addr */ 983 cmd[0] = MIP4_R0_BOOT; 984 cmd[1] = MIP4_R1_BOOT_TARGET_ADDR; 985 put_unaligned_le32(offset, &cmd[2]); 986 ret = i2c_master_send(ts->client, cmd, 6); 987 if (ret != 6) { 988 error = ret < 0 ? ret : -EIO; 989 dev_err(&ts->client->dev, 990 "Failed to send read page address: %d\n", error); 991 return error; 992 } 993 994 /* Size */ 995 cmd[0] = MIP4_R0_BOOT; 996 cmd[1] = MIP4_R1_BOOT_SIZE; 997 put_unaligned_le32(length, &cmd[2]); 998 ret = i2c_master_send(ts->client, cmd, 6); 999 if (ret != 6) { 1000 error = ret < 0 ? ret : -EIO; 1001 dev_err(&ts->client->dev, 1002 "Failed to send read page size: %d\n", error); 1003 return error; 1004 } 1005 1006 /* Command */ 1007 cmd[0] = MIP4_R0_BOOT; 1008 cmd[1] = MIP4_R1_BOOT_CMD; 1009 cmd[2] = MIP4_BOOT_CMD_READ; 1010 ret = i2c_master_send(ts->client, cmd, 3); 1011 if (ret != 3) { 1012 error = ret < 0 ? ret : -EIO; 1013 dev_err(&ts->client->dev, 1014 "Failed to send 'read' command: %d\n", error); 1015 return error; 1016 } 1017 1018 /* Status */ 1019 error = mip4_bl_read_status(ts); 1020 if (error) 1021 return error; 1022 1023 /* Read */ 1024 msg[1].buf = read_buf = kmalloc(MIP4_BL_PACKET_SIZE, GFP_KERNEL); 1025 if (!read_buf) 1026 return -ENOMEM; 1027 1028 for (buf_offset = 0; 1029 buf_offset < length; 1030 buf_offset += MIP4_BL_PACKET_SIZE) { 1031 dev_dbg(&ts->client->dev, 1032 "reading chunk at %#04x (size %d)\n", 1033 buf_offset, MIP4_BL_PACKET_SIZE); 1034 put_unaligned_be16(buf_addr + buf_offset, cmd); 1035 ret = i2c_transfer(ts->client->adapter, msg, ARRAY_SIZE(msg)); 1036 if (ret != ARRAY_SIZE(msg)) { 1037 error = ret < 0 ? ret : -EIO; 1038 dev_err(&ts->client->dev, 1039 "Failed to read chunk at %#04x (size %d): %d\n", 1040 buf_offset, MIP4_BL_PACKET_SIZE, error); 1041 break; 1042 } 1043 1044 if (memcmp(&data[buf_offset], read_buf, MIP4_BL_PACKET_SIZE)) { 1045 dev_err(&ts->client->dev, 1046 "Failed to validate chunk at %#04x (size %d)\n", 1047 buf_offset, MIP4_BL_PACKET_SIZE); 1048 #if MIP4_FW_UPDATE_DEBUG 1049 print_hex_dump(KERN_DEBUG, 1050 MIP4_DEVICE_NAME " F/W File: ", 1051 DUMP_PREFIX_OFFSET, 16, 1, 1052 data + offset, MIP4_BL_PACKET_SIZE, 1053 false); 1054 print_hex_dump(KERN_DEBUG, 1055 MIP4_DEVICE_NAME " F/W Chip: ", 1056 DUMP_PREFIX_OFFSET, 16, 1, 1057 read_buf, MIP4_BL_PAGE_SIZE, false); 1058 #endif 1059 error = -EINVAL; 1060 break; 1061 } 1062 } 1063 1064 kfree(read_buf); 1065 return error ? error : 0; 1066 } 1067 1068 /* 1069 * Flash chip firmware 1070 */ 1071 static int mip4_flash_fw(struct mip4_ts *ts, 1072 const u8 *fw_data, u32 fw_size, u32 fw_offset) 1073 { 1074 struct i2c_client *client = ts->client; 1075 int offset; 1076 u16 buf_addr; 1077 int error, error2; 1078 1079 /* Enter bootloader mode */ 1080 dev_dbg(&client->dev, "Entering bootloader mode\n"); 1081 1082 error = mip4_bl_enter(ts); 1083 if (error) { 1084 dev_err(&client->dev, 1085 "Failed to enter bootloader mode: %d\n", 1086 error); 1087 return error; 1088 } 1089 1090 /* Read info */ 1091 error = mip4_bl_get_address(ts, &buf_addr); 1092 if (error) 1093 goto exit_bl; 1094 1095 /* Program & Verify */ 1096 dev_dbg(&client->dev, 1097 "Program & Verify, page size: %d, packet size: %d\n", 1098 MIP4_BL_PAGE_SIZE, MIP4_BL_PACKET_SIZE); 1099 1100 for (offset = fw_offset; 1101 offset < fw_offset + fw_size; 1102 offset += MIP4_BL_PAGE_SIZE) { 1103 /* Program */ 1104 error = mip4_bl_program_page(ts, offset, fw_data + offset, 1105 MIP4_BL_PAGE_SIZE, buf_addr); 1106 if (error) 1107 break; 1108 1109 /* Verify */ 1110 error = mip4_bl_verify_page(ts, offset, fw_data + offset, 1111 MIP4_BL_PAGE_SIZE, buf_addr); 1112 if (error) 1113 break; 1114 } 1115 1116 exit_bl: 1117 /* Exit bootloader mode */ 1118 dev_dbg(&client->dev, "Exiting bootloader mode\n"); 1119 1120 error2 = mip4_bl_exit(ts); 1121 if (error2) { 1122 dev_err(&client->dev, 1123 "Failed to exit bootloader mode: %d\n", error2); 1124 if (!error) 1125 error = error2; 1126 } 1127 1128 /* Reset chip */ 1129 mip4_power_off(ts); 1130 mip4_power_on(ts); 1131 1132 mip4_query_device(ts); 1133 1134 /* Refresh device parameters */ 1135 input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->max_x, 0, 0); 1136 input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->max_y, 0, 0); 1137 input_set_abs_params(ts->input, ABS_X, 0, ts->max_x, 0, 0); 1138 input_set_abs_params(ts->input, ABS_Y, 0, ts->max_y, 0, 0); 1139 input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->ppm_x); 1140 input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->ppm_y); 1141 input_abs_set_res(ts->input, ABS_X, ts->ppm_x); 1142 input_abs_set_res(ts->input, ABS_Y, ts->ppm_y); 1143 1144 return error ? error : 0; 1145 } 1146 1147 static int mip4_parse_firmware(struct mip4_ts *ts, const struct firmware *fw, 1148 u32 *fw_offset_start, u32 *fw_size, 1149 const struct mip4_bin_tail **pfw_info) 1150 { 1151 const struct mip4_bin_tail *fw_info; 1152 struct mip4_fw_version fw_version; 1153 u16 tail_size; 1154 1155 if (fw->size < MIP4_BIN_TAIL_SIZE) { 1156 dev_err(&ts->client->dev, 1157 "Invalid firmware, size mismatch (tail %zd vs %zd)\n", 1158 MIP4_BIN_TAIL_SIZE, fw->size); 1159 return -EINVAL; 1160 } 1161 1162 fw_info = (const void *)&fw->data[fw->size - MIP4_BIN_TAIL_SIZE]; 1163 1164 #if MIP4_FW_UPDATE_DEBUG 1165 print_hex_dump(KERN_ERR, MIP4_DEVICE_NAME " Bin Info: ", 1166 DUMP_PREFIX_OFFSET, 16, 1, *fw_info, tail_size, false); 1167 #endif 1168 1169 tail_size = get_unaligned_le16(&fw_info->tail_size); 1170 if (tail_size != MIP4_BIN_TAIL_SIZE) { 1171 dev_err(&ts->client->dev, 1172 "wrong tail size: %d (expected %zd)\n", 1173 tail_size, MIP4_BIN_TAIL_SIZE); 1174 return -EINVAL; 1175 } 1176 1177 /* Check bin format */ 1178 if (memcmp(fw_info->tail_mark, MIP4_BIN_TAIL_MARK, 1179 sizeof(fw_info->tail_mark))) { 1180 dev_err(&ts->client->dev, 1181 "unable to locate tail marker (%*ph vs %*ph)\n", 1182 (int)sizeof(fw_info->tail_mark), fw_info->tail_mark, 1183 (int)sizeof(fw_info->tail_mark), MIP4_BIN_TAIL_MARK); 1184 return -EINVAL; 1185 } 1186 1187 *fw_offset_start = get_unaligned_le32(&fw_info->bin_start_addr); 1188 *fw_size = get_unaligned_le32(&fw_info->bin_length); 1189 1190 dev_dbg(&ts->client->dev, 1191 "F/W Data offset: %#08x, size: %d\n", 1192 *fw_offset_start, *fw_size); 1193 1194 if (*fw_size % MIP4_BL_PAGE_SIZE) { 1195 dev_err(&ts->client->dev, 1196 "encoded fw length %d is not multiple of pages (%d)\n", 1197 *fw_size, MIP4_BL_PAGE_SIZE); 1198 return -EINVAL; 1199 } 1200 1201 if (fw->size != *fw_offset_start + *fw_size) { 1202 dev_err(&ts->client->dev, 1203 "Wrong firmware size, expected %d bytes, got %zd\n", 1204 *fw_offset_start + *fw_size, fw->size); 1205 return -EINVAL; 1206 } 1207 1208 mip4_parse_fw_version((const u8 *)&fw_info->ver_boot, &fw_version); 1209 1210 dev_dbg(&ts->client->dev, 1211 "F/W file version %04X %04X %04X %04X\n", 1212 fw_version.boot, fw_version.core, 1213 fw_version.app, fw_version.param); 1214 1215 dev_dbg(&ts->client->dev, "F/W chip version: %04X %04X %04X %04X\n", 1216 ts->fw_version.boot, ts->fw_version.core, 1217 ts->fw_version.app, ts->fw_version.param); 1218 1219 /* Check F/W type */ 1220 if (fw_version.boot != 0xEEEE && fw_version.boot != 0xFFFF && 1221 fw_version.core == 0xEEEE && 1222 fw_version.app == 0xEEEE && 1223 fw_version.param == 0xEEEE) { 1224 dev_dbg(&ts->client->dev, "F/W type: Bootloader\n"); 1225 } else if (fw_version.boot == 0xEEEE && 1226 fw_version.core != 0xEEEE && fw_version.core != 0xFFFF && 1227 fw_version.app != 0xEEEE && fw_version.app != 0xFFFF && 1228 fw_version.param != 0xEEEE && fw_version.param != 0xFFFF) { 1229 dev_dbg(&ts->client->dev, "F/W type: Main\n"); 1230 } else { 1231 dev_err(&ts->client->dev, "Wrong firmware type\n"); 1232 return -EINVAL; 1233 } 1234 1235 return 0; 1236 } 1237 1238 static int mip4_execute_fw_update(struct mip4_ts *ts, const struct firmware *fw) 1239 { 1240 const struct mip4_bin_tail *fw_info; 1241 u32 fw_start_offset; 1242 u32 fw_size; 1243 int retires = 3; 1244 int error; 1245 1246 error = mip4_parse_firmware(ts, fw, 1247 &fw_start_offset, &fw_size, &fw_info); 1248 if (error) 1249 return error; 1250 1251 if (ts->input->users) { 1252 disable_irq(ts->client->irq); 1253 } else { 1254 error = mip4_power_on(ts); 1255 if (error) 1256 return error; 1257 } 1258 1259 /* Update firmware */ 1260 do { 1261 error = mip4_flash_fw(ts, fw->data, fw_size, fw_start_offset); 1262 if (!error) 1263 break; 1264 } while (--retires); 1265 1266 if (error) 1267 dev_err(&ts->client->dev, 1268 "Failed to flash firmware: %d\n", error); 1269 1270 /* Enable IRQ */ 1271 if (ts->input->users) 1272 enable_irq(ts->client->irq); 1273 else 1274 mip4_power_off(ts); 1275 1276 return error ? error : 0; 1277 } 1278 1279 static ssize_t mip4_sysfs_fw_update(struct device *dev, 1280 struct device_attribute *attr, 1281 const char *buf, size_t count) 1282 { 1283 struct i2c_client *client = to_i2c_client(dev); 1284 struct mip4_ts *ts = i2c_get_clientdata(client); 1285 const struct firmware *fw; 1286 int error; 1287 1288 error = request_firmware(&fw, MIP4_FW_NAME, dev); 1289 if (error) { 1290 dev_err(&ts->client->dev, 1291 "Failed to retrieve firmware %s: %d\n", 1292 MIP4_FW_NAME, error); 1293 return error; 1294 } 1295 1296 /* 1297 * Take input mutex to prevent racing with itself and also with 1298 * userspace opening and closing the device and also suspend/resume 1299 * transitions. 1300 */ 1301 mutex_lock(&ts->input->mutex); 1302 1303 error = mip4_execute_fw_update(ts, fw); 1304 1305 mutex_unlock(&ts->input->mutex); 1306 1307 release_firmware(fw); 1308 1309 if (error) { 1310 dev_err(&ts->client->dev, 1311 "Firmware update failed: %d\n", error); 1312 return error; 1313 } 1314 1315 return count; 1316 } 1317 1318 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mip4_sysfs_fw_update); 1319 1320 static ssize_t mip4_sysfs_read_fw_version(struct device *dev, 1321 struct device_attribute *attr, 1322 char *buf) 1323 { 1324 struct i2c_client *client = to_i2c_client(dev); 1325 struct mip4_ts *ts = i2c_get_clientdata(client); 1326 size_t count; 1327 1328 /* Take lock to prevent racing with firmware update */ 1329 mutex_lock(&ts->input->mutex); 1330 1331 count = snprintf(buf, PAGE_SIZE, "%04X %04X %04X %04X\n", 1332 ts->fw_version.boot, ts->fw_version.core, 1333 ts->fw_version.app, ts->fw_version.param); 1334 1335 mutex_unlock(&ts->input->mutex); 1336 1337 return count; 1338 } 1339 1340 static DEVICE_ATTR(fw_version, S_IRUGO, mip4_sysfs_read_fw_version, NULL); 1341 1342 static ssize_t mip4_sysfs_read_hw_version(struct device *dev, 1343 struct device_attribute *attr, 1344 char *buf) 1345 { 1346 struct i2c_client *client = to_i2c_client(dev); 1347 struct mip4_ts *ts = i2c_get_clientdata(client); 1348 size_t count; 1349 1350 /* Take lock to prevent racing with firmware update */ 1351 mutex_lock(&ts->input->mutex); 1352 1353 /* 1354 * product_name shows the name or version of the hardware 1355 * paired with current firmware in the chip. 1356 */ 1357 count = snprintf(buf, PAGE_SIZE, "%.*s\n", 1358 (int)sizeof(ts->product_name), ts->product_name); 1359 1360 mutex_unlock(&ts->input->mutex); 1361 1362 return count; 1363 } 1364 1365 static DEVICE_ATTR(hw_version, S_IRUGO, mip4_sysfs_read_hw_version, NULL); 1366 1367 static ssize_t mip4_sysfs_read_product_id(struct device *dev, 1368 struct device_attribute *attr, 1369 char *buf) 1370 { 1371 struct i2c_client *client = to_i2c_client(dev); 1372 struct mip4_ts *ts = i2c_get_clientdata(client); 1373 size_t count; 1374 1375 mutex_lock(&ts->input->mutex); 1376 1377 count = snprintf(buf, PAGE_SIZE, "%04X\n", ts->product_id); 1378 1379 mutex_unlock(&ts->input->mutex); 1380 1381 return count; 1382 } 1383 1384 static DEVICE_ATTR(product_id, S_IRUGO, mip4_sysfs_read_product_id, NULL); 1385 1386 static ssize_t mip4_sysfs_read_ic_name(struct device *dev, 1387 struct device_attribute *attr, 1388 char *buf) 1389 { 1390 struct i2c_client *client = to_i2c_client(dev); 1391 struct mip4_ts *ts = i2c_get_clientdata(client); 1392 size_t count; 1393 1394 mutex_lock(&ts->input->mutex); 1395 1396 count = snprintf(buf, PAGE_SIZE, "%.*s\n", 1397 (int)sizeof(ts->ic_name), ts->ic_name); 1398 1399 mutex_unlock(&ts->input->mutex); 1400 1401 return count; 1402 } 1403 1404 static DEVICE_ATTR(ic_name, S_IRUGO, mip4_sysfs_read_ic_name, NULL); 1405 1406 static struct attribute *mip4_attrs[] = { 1407 &dev_attr_fw_version.attr, 1408 &dev_attr_hw_version.attr, 1409 &dev_attr_product_id.attr, 1410 &dev_attr_ic_name.attr, 1411 &dev_attr_update_fw.attr, 1412 NULL, 1413 }; 1414 1415 static const struct attribute_group mip4_attr_group = { 1416 .attrs = mip4_attrs, 1417 }; 1418 1419 static void mip4_sysfs_remove(void *_data) 1420 { 1421 struct mip4_ts *ts = _data; 1422 1423 sysfs_remove_group(&ts->client->dev.kobj, &mip4_attr_group); 1424 } 1425 1426 static int mip4_probe(struct i2c_client *client, const struct i2c_device_id *id) 1427 { 1428 struct mip4_ts *ts; 1429 struct input_dev *input; 1430 int error; 1431 1432 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 1433 dev_err(&client->dev, "Not supported I2C adapter\n"); 1434 return -ENXIO; 1435 } 1436 1437 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); 1438 if (!ts) 1439 return -ENOMEM; 1440 1441 input = devm_input_allocate_device(&client->dev); 1442 if (!input) 1443 return -ENOMEM; 1444 1445 ts->client = client; 1446 ts->input = input; 1447 1448 snprintf(ts->phys, sizeof(ts->phys), 1449 "%s/input0", dev_name(&client->dev)); 1450 1451 ts->gpio_ce = devm_gpiod_get_optional(&client->dev, 1452 "ce", GPIOD_OUT_LOW); 1453 if (IS_ERR(ts->gpio_ce)) { 1454 error = PTR_ERR(ts->gpio_ce); 1455 if (error != EPROBE_DEFER) 1456 dev_err(&client->dev, 1457 "Failed to get gpio: %d\n", error); 1458 return error; 1459 } 1460 1461 error = mip4_power_on(ts); 1462 if (error) 1463 return error; 1464 error = mip4_query_device(ts); 1465 mip4_power_off(ts); 1466 if (error) 1467 return error; 1468 1469 input->name = "MELFAS MIP4 Touchscreen"; 1470 input->phys = ts->phys; 1471 1472 input->id.bustype = BUS_I2C; 1473 input->id.vendor = 0x13c5; 1474 1475 input->open = mip4_input_open; 1476 input->close = mip4_input_close; 1477 1478 input_set_drvdata(input, ts); 1479 1480 input->keycode = ts->key_code; 1481 input->keycodesize = sizeof(*ts->key_code); 1482 input->keycodemax = ts->key_num; 1483 1484 input_set_abs_params(input, ABS_MT_POSITION_X, 0, ts->max_x, 0, 0); 1485 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, ts->max_y, 0, 0); 1486 input_set_abs_params(input, ABS_MT_PRESSURE, 1487 MIP4_PRESSURE_MIN, MIP4_PRESSURE_MAX, 0, 0); 1488 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 1489 MIP4_TOUCH_MAJOR_MIN, MIP4_TOUCH_MAJOR_MAX, 0, 0); 1490 input_set_abs_params(input, ABS_MT_TOUCH_MINOR, 1491 MIP4_TOUCH_MINOR_MIN, MIP4_TOUCH_MINOR_MAX, 0, 0); 1492 input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->ppm_x); 1493 input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->ppm_y); 1494 1495 error = input_mt_init_slots(input, MIP4_MAX_FINGERS, INPUT_MT_DIRECT); 1496 if (error) 1497 return error; 1498 1499 i2c_set_clientdata(client, ts); 1500 1501 error = devm_request_threaded_irq(&client->dev, client->irq, 1502 NULL, mip4_interrupt, 1503 IRQF_ONESHOT, MIP4_DEVICE_NAME, ts); 1504 if (error) { 1505 dev_err(&client->dev, 1506 "Failed to request interrupt %d: %d\n", 1507 client->irq, error); 1508 return error; 1509 } 1510 1511 disable_irq(client->irq); 1512 1513 error = input_register_device(input); 1514 if (error) { 1515 dev_err(&client->dev, 1516 "Failed to register input device: %d\n", error); 1517 return error; 1518 } 1519 1520 error = sysfs_create_group(&client->dev.kobj, &mip4_attr_group); 1521 if (error) { 1522 dev_err(&client->dev, 1523 "Failed to create sysfs attribute group: %d\n", error); 1524 return error; 1525 } 1526 1527 error = devm_add_action(&client->dev, mip4_sysfs_remove, ts); 1528 if (error) { 1529 mip4_sysfs_remove(ts); 1530 dev_err(&client->dev, 1531 "Failed to install sysfs remoce action: %d\n", error); 1532 return error; 1533 } 1534 1535 return 0; 1536 } 1537 1538 static int __maybe_unused mip4_suspend(struct device *dev) 1539 { 1540 struct i2c_client *client = to_i2c_client(dev); 1541 struct mip4_ts *ts = i2c_get_clientdata(client); 1542 struct input_dev *input = ts->input; 1543 1544 mutex_lock(&input->mutex); 1545 1546 if (device_may_wakeup(dev)) 1547 ts->wake_irq_enabled = enable_irq_wake(client->irq) == 0; 1548 else if (input->users) 1549 mip4_disable(ts); 1550 1551 mutex_unlock(&input->mutex); 1552 1553 return 0; 1554 } 1555 1556 static int __maybe_unused mip4_resume(struct device *dev) 1557 { 1558 struct i2c_client *client = to_i2c_client(dev); 1559 struct mip4_ts *ts = i2c_get_clientdata(client); 1560 struct input_dev *input = ts->input; 1561 1562 mutex_lock(&input->mutex); 1563 1564 if (ts->wake_irq_enabled) 1565 disable_irq_wake(client->irq); 1566 else if (input->users) 1567 mip4_enable(ts); 1568 1569 mutex_unlock(&input->mutex); 1570 1571 return 0; 1572 } 1573 1574 static SIMPLE_DEV_PM_OPS(mip4_pm_ops, mip4_suspend, mip4_resume); 1575 1576 #ifdef CONFIG_OF 1577 static const struct of_device_id mip4_of_match[] = { 1578 { .compatible = "melfas,"MIP4_DEVICE_NAME, }, 1579 { }, 1580 }; 1581 MODULE_DEVICE_TABLE(of, mip4_of_match); 1582 #endif 1583 1584 #ifdef CONFIG_ACPI 1585 static const struct acpi_device_id mip4_acpi_match[] = { 1586 { "MLFS0000", 0}, 1587 { }, 1588 }; 1589 MODULE_DEVICE_TABLE(acpi, mip4_acpi_match); 1590 #endif 1591 1592 static const struct i2c_device_id mip4_i2c_ids[] = { 1593 { MIP4_DEVICE_NAME, 0 }, 1594 { }, 1595 }; 1596 MODULE_DEVICE_TABLE(i2c, mip4_i2c_ids); 1597 1598 static struct i2c_driver mip4_driver = { 1599 .id_table = mip4_i2c_ids, 1600 .probe = mip4_probe, 1601 .driver = { 1602 .name = MIP4_DEVICE_NAME, 1603 .of_match_table = of_match_ptr(mip4_of_match), 1604 .acpi_match_table = ACPI_PTR(mip4_acpi_match), 1605 .pm = &mip4_pm_ops, 1606 }, 1607 }; 1608 module_i2c_driver(mip4_driver); 1609 1610 MODULE_DESCRIPTION("MELFAS MIP4 Touchscreen"); 1611 MODULE_VERSION("2016.10.20"); 1612 MODULE_AUTHOR("Sangwon Jee <jeesw@melfas.com>"); 1613 MODULE_LICENSE("GPL"); 1614