1 /* 2 * Atmel maXTouch Touchscreen driver 3 * 4 * Copyright (C) 2010 Samsung Electronics Co.Ltd 5 * Copyright (C) 2011-2014 Atmel Corporation 6 * Copyright (C) 2012 Google, Inc. 7 * 8 * Author: Joonyoung Shim <jy0922.shim@samsung.com> 9 * 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the 12 * Free Software Foundation; either version 2 of the License, or (at your 13 * option) any later version. 14 * 15 */ 16 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/completion.h> 20 #include <linux/delay.h> 21 #include <linux/firmware.h> 22 #include <linux/i2c.h> 23 #include <linux/i2c/atmel_mxt_ts.h> 24 #include <linux/input/mt.h> 25 #include <linux/interrupt.h> 26 #include <linux/of.h> 27 #include <linux/slab.h> 28 29 /* Version */ 30 #define MXT_VER_20 20 31 #define MXT_VER_21 21 32 #define MXT_VER_22 22 33 34 /* Firmware files */ 35 #define MXT_FW_NAME "maxtouch.fw" 36 #define MXT_CFG_NAME "maxtouch.cfg" 37 #define MXT_CFG_MAGIC "OBP_RAW V1" 38 39 /* Registers */ 40 #define MXT_INFO 0x00 41 #define MXT_FAMILY_ID 0x00 42 #define MXT_VARIANT_ID 0x01 43 #define MXT_VERSION 0x02 44 #define MXT_BUILD 0x03 45 #define MXT_MATRIX_X_SIZE 0x04 46 #define MXT_MATRIX_Y_SIZE 0x05 47 #define MXT_OBJECT_NUM 0x06 48 #define MXT_OBJECT_START 0x07 49 50 #define MXT_OBJECT_SIZE 6 51 #define MXT_INFO_CHECKSUM_SIZE 3 52 #define MXT_MAX_BLOCK_WRITE 256 53 54 /* Object types */ 55 #define MXT_DEBUG_DIAGNOSTIC_T37 37 56 #define MXT_GEN_MESSAGE_T5 5 57 #define MXT_GEN_COMMAND_T6 6 58 #define MXT_GEN_POWER_T7 7 59 #define MXT_GEN_ACQUIRE_T8 8 60 #define MXT_GEN_DATASOURCE_T53 53 61 #define MXT_TOUCH_MULTI_T9 9 62 #define MXT_TOUCH_KEYARRAY_T15 15 63 #define MXT_TOUCH_PROXIMITY_T23 23 64 #define MXT_TOUCH_PROXKEY_T52 52 65 #define MXT_PROCI_GRIPFACE_T20 20 66 #define MXT_PROCG_NOISE_T22 22 67 #define MXT_PROCI_ONETOUCH_T24 24 68 #define MXT_PROCI_TWOTOUCH_T27 27 69 #define MXT_PROCI_GRIP_T40 40 70 #define MXT_PROCI_PALM_T41 41 71 #define MXT_PROCI_TOUCHSUPPRESSION_T42 42 72 #define MXT_PROCI_STYLUS_T47 47 73 #define MXT_PROCG_NOISESUPPRESSION_T48 48 74 #define MXT_SPT_COMMSCONFIG_T18 18 75 #define MXT_SPT_GPIOPWM_T19 19 76 #define MXT_SPT_SELFTEST_T25 25 77 #define MXT_SPT_CTECONFIG_T28 28 78 #define MXT_SPT_USERDATA_T38 38 79 #define MXT_SPT_DIGITIZER_T43 43 80 #define MXT_SPT_MESSAGECOUNT_T44 44 81 #define MXT_SPT_CTECONFIG_T46 46 82 83 /* MXT_GEN_MESSAGE_T5 object */ 84 #define MXT_RPTID_NOMSG 0xff 85 86 /* MXT_GEN_COMMAND_T6 field */ 87 #define MXT_COMMAND_RESET 0 88 #define MXT_COMMAND_BACKUPNV 1 89 #define MXT_COMMAND_CALIBRATE 2 90 #define MXT_COMMAND_REPORTALL 3 91 #define MXT_COMMAND_DIAGNOSTIC 5 92 93 /* Define for T6 status byte */ 94 #define MXT_T6_STATUS_RESET (1 << 7) 95 #define MXT_T6_STATUS_OFL (1 << 6) 96 #define MXT_T6_STATUS_SIGERR (1 << 5) 97 #define MXT_T6_STATUS_CAL (1 << 4) 98 #define MXT_T6_STATUS_CFGERR (1 << 3) 99 #define MXT_T6_STATUS_COMSERR (1 << 2) 100 101 /* MXT_GEN_POWER_T7 field */ 102 struct t7_config { 103 u8 idle; 104 u8 active; 105 } __packed; 106 107 #define MXT_POWER_CFG_RUN 0 108 #define MXT_POWER_CFG_DEEPSLEEP 1 109 110 /* MXT_GEN_ACQUIRE_T8 field */ 111 #define MXT_ACQUIRE_CHRGTIME 0 112 #define MXT_ACQUIRE_TCHDRIFT 2 113 #define MXT_ACQUIRE_DRIFTST 3 114 #define MXT_ACQUIRE_TCHAUTOCAL 4 115 #define MXT_ACQUIRE_SYNC 5 116 #define MXT_ACQUIRE_ATCHCALST 6 117 #define MXT_ACQUIRE_ATCHCALSTHR 7 118 119 /* MXT_TOUCH_MULTI_T9 field */ 120 #define MXT_T9_ORIENT 9 121 #define MXT_T9_RANGE 18 122 123 /* MXT_TOUCH_MULTI_T9 status */ 124 #define MXT_T9_UNGRIP (1 << 0) 125 #define MXT_T9_SUPPRESS (1 << 1) 126 #define MXT_T9_AMP (1 << 2) 127 #define MXT_T9_VECTOR (1 << 3) 128 #define MXT_T9_MOVE (1 << 4) 129 #define MXT_T9_RELEASE (1 << 5) 130 #define MXT_T9_PRESS (1 << 6) 131 #define MXT_T9_DETECT (1 << 7) 132 133 struct t9_range { 134 u16 x; 135 u16 y; 136 } __packed; 137 138 /* MXT_TOUCH_MULTI_T9 orient */ 139 #define MXT_T9_ORIENT_SWITCH (1 << 0) 140 141 /* MXT_PROCI_GRIPFACE_T20 field */ 142 #define MXT_GRIPFACE_CTRL 0 143 #define MXT_GRIPFACE_XLOGRIP 1 144 #define MXT_GRIPFACE_XHIGRIP 2 145 #define MXT_GRIPFACE_YLOGRIP 3 146 #define MXT_GRIPFACE_YHIGRIP 4 147 #define MXT_GRIPFACE_MAXTCHS 5 148 #define MXT_GRIPFACE_SZTHR1 7 149 #define MXT_GRIPFACE_SZTHR2 8 150 #define MXT_GRIPFACE_SHPTHR1 9 151 #define MXT_GRIPFACE_SHPTHR2 10 152 #define MXT_GRIPFACE_SUPEXTTO 11 153 154 /* MXT_PROCI_NOISE field */ 155 #define MXT_NOISE_CTRL 0 156 #define MXT_NOISE_OUTFLEN 1 157 #define MXT_NOISE_GCAFUL_LSB 3 158 #define MXT_NOISE_GCAFUL_MSB 4 159 #define MXT_NOISE_GCAFLL_LSB 5 160 #define MXT_NOISE_GCAFLL_MSB 6 161 #define MXT_NOISE_ACTVGCAFVALID 7 162 #define MXT_NOISE_NOISETHR 8 163 #define MXT_NOISE_FREQHOPSCALE 10 164 #define MXT_NOISE_FREQ0 11 165 #define MXT_NOISE_FREQ1 12 166 #define MXT_NOISE_FREQ2 13 167 #define MXT_NOISE_FREQ3 14 168 #define MXT_NOISE_FREQ4 15 169 #define MXT_NOISE_IDLEGCAFVALID 16 170 171 /* MXT_SPT_COMMSCONFIG_T18 */ 172 #define MXT_COMMS_CTRL 0 173 #define MXT_COMMS_CMD 1 174 175 /* MXT_SPT_CTECONFIG_T28 field */ 176 #define MXT_CTE_CTRL 0 177 #define MXT_CTE_CMD 1 178 #define MXT_CTE_MODE 2 179 #define MXT_CTE_IDLEGCAFDEPTH 3 180 #define MXT_CTE_ACTVGCAFDEPTH 4 181 #define MXT_CTE_VOLTAGE 5 182 183 #define MXT_VOLTAGE_DEFAULT 2700000 184 #define MXT_VOLTAGE_STEP 10000 185 186 /* Define for MXT_GEN_COMMAND_T6 */ 187 #define MXT_BOOT_VALUE 0xa5 188 #define MXT_RESET_VALUE 0x01 189 #define MXT_BACKUP_VALUE 0x55 190 191 /* Delay times */ 192 #define MXT_BACKUP_TIME 50 /* msec */ 193 #define MXT_RESET_TIME 200 /* msec */ 194 #define MXT_RESET_TIMEOUT 3000 /* msec */ 195 #define MXT_CRC_TIMEOUT 1000 /* msec */ 196 #define MXT_FW_RESET_TIME 3000 /* msec */ 197 #define MXT_FW_CHG_TIMEOUT 300 /* msec */ 198 199 /* Command to unlock bootloader */ 200 #define MXT_UNLOCK_CMD_MSB 0xaa 201 #define MXT_UNLOCK_CMD_LSB 0xdc 202 203 /* Bootloader mode status */ 204 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */ 205 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */ 206 #define MXT_FRAME_CRC_CHECK 0x02 207 #define MXT_FRAME_CRC_FAIL 0x03 208 #define MXT_FRAME_CRC_PASS 0x04 209 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */ 210 #define MXT_BOOT_STATUS_MASK 0x3f 211 #define MXT_BOOT_EXTENDED_ID (1 << 5) 212 #define MXT_BOOT_ID_MASK 0x1f 213 214 /* Touchscreen absolute values */ 215 #define MXT_MAX_AREA 0xff 216 217 #define MXT_PIXELS_PER_MM 20 218 219 struct mxt_info { 220 u8 family_id; 221 u8 variant_id; 222 u8 version; 223 u8 build; 224 u8 matrix_xsize; 225 u8 matrix_ysize; 226 u8 object_num; 227 }; 228 229 struct mxt_object { 230 u8 type; 231 u16 start_address; 232 u8 size_minus_one; 233 u8 instances_minus_one; 234 u8 num_report_ids; 235 } __packed; 236 237 /* Each client has this additional data */ 238 struct mxt_data { 239 struct i2c_client *client; 240 struct input_dev *input_dev; 241 char phys[64]; /* device physical location */ 242 const struct mxt_platform_data *pdata; 243 struct mxt_object *object_table; 244 struct mxt_info info; 245 unsigned int irq; 246 unsigned int max_x; 247 unsigned int max_y; 248 bool in_bootloader; 249 u16 mem_size; 250 u8 max_reportid; 251 u32 config_crc; 252 u32 info_crc; 253 u8 bootloader_addr; 254 u8 *msg_buf; 255 u8 t6_status; 256 bool update_input; 257 u8 last_message_count; 258 u8 num_touchids; 259 struct t7_config t7_cfg; 260 261 /* Cached parameters from object table */ 262 u16 T5_address; 263 u8 T5_msg_size; 264 u8 T6_reportid; 265 u16 T6_address; 266 u16 T7_address; 267 u8 T9_reportid_min; 268 u8 T9_reportid_max; 269 u8 T19_reportid; 270 u16 T44_address; 271 272 /* for fw update in bootloader */ 273 struct completion bl_completion; 274 275 /* for reset handling */ 276 struct completion reset_completion; 277 278 /* for config update handling */ 279 struct completion crc_completion; 280 }; 281 282 static size_t mxt_obj_size(const struct mxt_object *obj) 283 { 284 return obj->size_minus_one + 1; 285 } 286 287 static size_t mxt_obj_instances(const struct mxt_object *obj) 288 { 289 return obj->instances_minus_one + 1; 290 } 291 292 static bool mxt_object_readable(unsigned int type) 293 { 294 switch (type) { 295 case MXT_GEN_COMMAND_T6: 296 case MXT_GEN_POWER_T7: 297 case MXT_GEN_ACQUIRE_T8: 298 case MXT_GEN_DATASOURCE_T53: 299 case MXT_TOUCH_MULTI_T9: 300 case MXT_TOUCH_KEYARRAY_T15: 301 case MXT_TOUCH_PROXIMITY_T23: 302 case MXT_TOUCH_PROXKEY_T52: 303 case MXT_PROCI_GRIPFACE_T20: 304 case MXT_PROCG_NOISE_T22: 305 case MXT_PROCI_ONETOUCH_T24: 306 case MXT_PROCI_TWOTOUCH_T27: 307 case MXT_PROCI_GRIP_T40: 308 case MXT_PROCI_PALM_T41: 309 case MXT_PROCI_TOUCHSUPPRESSION_T42: 310 case MXT_PROCI_STYLUS_T47: 311 case MXT_PROCG_NOISESUPPRESSION_T48: 312 case MXT_SPT_COMMSCONFIG_T18: 313 case MXT_SPT_GPIOPWM_T19: 314 case MXT_SPT_SELFTEST_T25: 315 case MXT_SPT_CTECONFIG_T28: 316 case MXT_SPT_USERDATA_T38: 317 case MXT_SPT_DIGITIZER_T43: 318 case MXT_SPT_CTECONFIG_T46: 319 return true; 320 default: 321 return false; 322 } 323 } 324 325 static void mxt_dump_message(struct mxt_data *data, u8 *message) 326 { 327 dev_dbg(&data->client->dev, "message: %*ph\n", 328 data->T5_msg_size, message); 329 } 330 331 static int mxt_wait_for_completion(struct mxt_data *data, 332 struct completion *comp, 333 unsigned int timeout_ms) 334 { 335 struct device *dev = &data->client->dev; 336 unsigned long timeout = msecs_to_jiffies(timeout_ms); 337 long ret; 338 339 ret = wait_for_completion_interruptible_timeout(comp, timeout); 340 if (ret < 0) { 341 return ret; 342 } else if (ret == 0) { 343 dev_err(dev, "Wait for completion timed out.\n"); 344 return -ETIMEDOUT; 345 } 346 return 0; 347 } 348 349 static int mxt_bootloader_read(struct mxt_data *data, 350 u8 *val, unsigned int count) 351 { 352 int ret; 353 struct i2c_msg msg; 354 355 msg.addr = data->bootloader_addr; 356 msg.flags = data->client->flags & I2C_M_TEN; 357 msg.flags |= I2C_M_RD; 358 msg.len = count; 359 msg.buf = val; 360 361 ret = i2c_transfer(data->client->adapter, &msg, 1); 362 if (ret == 1) { 363 ret = 0; 364 } else { 365 ret = ret < 0 ? ret : -EIO; 366 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n", 367 __func__, ret); 368 } 369 370 return ret; 371 } 372 373 static int mxt_bootloader_write(struct mxt_data *data, 374 const u8 * const val, unsigned int count) 375 { 376 int ret; 377 struct i2c_msg msg; 378 379 msg.addr = data->bootloader_addr; 380 msg.flags = data->client->flags & I2C_M_TEN; 381 msg.len = count; 382 msg.buf = (u8 *)val; 383 384 ret = i2c_transfer(data->client->adapter, &msg, 1); 385 if (ret == 1) { 386 ret = 0; 387 } else { 388 ret = ret < 0 ? ret : -EIO; 389 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n", 390 __func__, ret); 391 } 392 393 return ret; 394 } 395 396 static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry) 397 { 398 u8 appmode = data->client->addr; 399 u8 bootloader; 400 401 switch (appmode) { 402 case 0x4a: 403 case 0x4b: 404 /* Chips after 1664S use different scheme */ 405 if (retry || data->info.family_id >= 0xa2) { 406 bootloader = appmode - 0x24; 407 break; 408 } 409 /* Fall through for normal case */ 410 case 0x4c: 411 case 0x4d: 412 case 0x5a: 413 case 0x5b: 414 bootloader = appmode - 0x26; 415 break; 416 417 default: 418 dev_err(&data->client->dev, 419 "Appmode i2c address 0x%02x not found\n", 420 appmode); 421 return -EINVAL; 422 } 423 424 data->bootloader_addr = bootloader; 425 return 0; 426 } 427 428 static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address) 429 { 430 struct device *dev = &data->client->dev; 431 int error; 432 u8 val; 433 bool crc_failure; 434 435 error = mxt_lookup_bootloader_address(data, alt_address); 436 if (error) 437 return error; 438 439 error = mxt_bootloader_read(data, &val, 1); 440 if (error) 441 return error; 442 443 /* Check app crc fail mode */ 444 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL; 445 446 dev_err(dev, "Detected bootloader, status:%02X%s\n", 447 val, crc_failure ? ", APP_CRC_FAIL" : ""); 448 449 return 0; 450 } 451 452 static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val) 453 { 454 struct device *dev = &data->client->dev; 455 u8 buf[3]; 456 457 if (val & MXT_BOOT_EXTENDED_ID) { 458 if (mxt_bootloader_read(data, &buf[0], 3) != 0) { 459 dev_err(dev, "%s: i2c failure\n", __func__); 460 return val; 461 } 462 463 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]); 464 465 return buf[0]; 466 } else { 467 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK); 468 469 return val; 470 } 471 } 472 473 static int mxt_check_bootloader(struct mxt_data *data, unsigned int state, 474 bool wait) 475 { 476 struct device *dev = &data->client->dev; 477 u8 val; 478 int ret; 479 480 recheck: 481 if (wait) { 482 /* 483 * In application update mode, the interrupt 484 * line signals state transitions. We must wait for the 485 * CHG assertion before reading the status byte. 486 * Once the status byte has been read, the line is deasserted. 487 */ 488 ret = mxt_wait_for_completion(data, &data->bl_completion, 489 MXT_FW_CHG_TIMEOUT); 490 if (ret) { 491 /* 492 * TODO: handle -ERESTARTSYS better by terminating 493 * fw update process before returning to userspace 494 * by writing length 0x000 to device (iff we are in 495 * WAITING_FRAME_DATA state). 496 */ 497 dev_err(dev, "Update wait error %d\n", ret); 498 return ret; 499 } 500 } 501 502 ret = mxt_bootloader_read(data, &val, 1); 503 if (ret) 504 return ret; 505 506 if (state == MXT_WAITING_BOOTLOAD_CMD) 507 val = mxt_get_bootloader_version(data, val); 508 509 switch (state) { 510 case MXT_WAITING_BOOTLOAD_CMD: 511 case MXT_WAITING_FRAME_DATA: 512 case MXT_APP_CRC_FAIL: 513 val &= ~MXT_BOOT_STATUS_MASK; 514 break; 515 case MXT_FRAME_CRC_PASS: 516 if (val == MXT_FRAME_CRC_CHECK) { 517 goto recheck; 518 } else if (val == MXT_FRAME_CRC_FAIL) { 519 dev_err(dev, "Bootloader CRC fail\n"); 520 return -EINVAL; 521 } 522 break; 523 default: 524 return -EINVAL; 525 } 526 527 if (val != state) { 528 dev_err(dev, "Invalid bootloader state %02X != %02X\n", 529 val, state); 530 return -EINVAL; 531 } 532 533 return 0; 534 } 535 536 static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock) 537 { 538 int ret; 539 u8 buf[2]; 540 541 if (unlock) { 542 buf[0] = MXT_UNLOCK_CMD_LSB; 543 buf[1] = MXT_UNLOCK_CMD_MSB; 544 } else { 545 buf[0] = 0x01; 546 buf[1] = 0x01; 547 } 548 549 ret = mxt_bootloader_write(data, buf, 2); 550 if (ret) 551 return ret; 552 553 return 0; 554 } 555 556 static int __mxt_read_reg(struct i2c_client *client, 557 u16 reg, u16 len, void *val) 558 { 559 struct i2c_msg xfer[2]; 560 u8 buf[2]; 561 int ret; 562 563 buf[0] = reg & 0xff; 564 buf[1] = (reg >> 8) & 0xff; 565 566 /* Write register */ 567 xfer[0].addr = client->addr; 568 xfer[0].flags = 0; 569 xfer[0].len = 2; 570 xfer[0].buf = buf; 571 572 /* Read data */ 573 xfer[1].addr = client->addr; 574 xfer[1].flags = I2C_M_RD; 575 xfer[1].len = len; 576 xfer[1].buf = val; 577 578 ret = i2c_transfer(client->adapter, xfer, 2); 579 if (ret == 2) { 580 ret = 0; 581 } else { 582 if (ret >= 0) 583 ret = -EIO; 584 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n", 585 __func__, ret); 586 } 587 588 return ret; 589 } 590 591 static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len, 592 const void *val) 593 { 594 u8 *buf; 595 size_t count; 596 int ret; 597 598 count = len + 2; 599 buf = kmalloc(count, GFP_KERNEL); 600 if (!buf) 601 return -ENOMEM; 602 603 buf[0] = reg & 0xff; 604 buf[1] = (reg >> 8) & 0xff; 605 memcpy(&buf[2], val, len); 606 607 ret = i2c_master_send(client, buf, count); 608 if (ret == count) { 609 ret = 0; 610 } else { 611 if (ret >= 0) 612 ret = -EIO; 613 dev_err(&client->dev, "%s: i2c send failed (%d)\n", 614 __func__, ret); 615 } 616 617 kfree(buf); 618 return ret; 619 } 620 621 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val) 622 { 623 return __mxt_write_reg(client, reg, 1, &val); 624 } 625 626 static struct mxt_object * 627 mxt_get_object(struct mxt_data *data, u8 type) 628 { 629 struct mxt_object *object; 630 int i; 631 632 for (i = 0; i < data->info.object_num; i++) { 633 object = data->object_table + i; 634 if (object->type == type) 635 return object; 636 } 637 638 dev_warn(&data->client->dev, "Invalid object type T%u\n", type); 639 return NULL; 640 } 641 642 static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg) 643 { 644 struct device *dev = &data->client->dev; 645 u8 status = msg[1]; 646 u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16); 647 648 complete(&data->crc_completion); 649 650 if (crc != data->config_crc) { 651 data->config_crc = crc; 652 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc); 653 } 654 655 /* Detect reset */ 656 if (status & MXT_T6_STATUS_RESET) 657 complete(&data->reset_completion); 658 659 /* Output debug if status has changed */ 660 if (status != data->t6_status) 661 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n", 662 status, 663 status == 0 ? " OK" : "", 664 status & MXT_T6_STATUS_RESET ? " RESET" : "", 665 status & MXT_T6_STATUS_OFL ? " OFL" : "", 666 status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "", 667 status & MXT_T6_STATUS_CAL ? " CAL" : "", 668 status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "", 669 status & MXT_T6_STATUS_COMSERR ? " COMSERR" : ""); 670 671 /* Save current status */ 672 data->t6_status = status; 673 } 674 675 static void mxt_input_button(struct mxt_data *data, u8 *message) 676 { 677 struct input_dev *input = data->input_dev; 678 const struct mxt_platform_data *pdata = data->pdata; 679 bool button; 680 int i; 681 682 /* Active-low switch */ 683 for (i = 0; i < pdata->t19_num_keys; i++) { 684 if (pdata->t19_keymap[i] == KEY_RESERVED) 685 continue; 686 button = !(message[1] & (1 << i)); 687 input_report_key(input, pdata->t19_keymap[i], button); 688 } 689 } 690 691 static void mxt_input_sync(struct mxt_data *data) 692 { 693 input_mt_report_pointer_emulation(data->input_dev, 694 data->pdata->t19_num_keys); 695 input_sync(data->input_dev); 696 } 697 698 static void mxt_proc_t9_message(struct mxt_data *data, u8 *message) 699 { 700 struct device *dev = &data->client->dev; 701 struct input_dev *input_dev = data->input_dev; 702 int id; 703 u8 status; 704 int x; 705 int y; 706 int area; 707 int amplitude; 708 709 id = message[0] - data->T9_reportid_min; 710 status = message[1]; 711 x = (message[2] << 4) | ((message[4] >> 4) & 0xf); 712 y = (message[3] << 4) | ((message[4] & 0xf)); 713 714 /* Handle 10/12 bit switching */ 715 if (data->max_x < 1024) 716 x >>= 2; 717 if (data->max_y < 1024) 718 y >>= 2; 719 720 area = message[5]; 721 amplitude = message[6]; 722 723 dev_dbg(dev, 724 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n", 725 id, 726 (status & MXT_T9_DETECT) ? 'D' : '.', 727 (status & MXT_T9_PRESS) ? 'P' : '.', 728 (status & MXT_T9_RELEASE) ? 'R' : '.', 729 (status & MXT_T9_MOVE) ? 'M' : '.', 730 (status & MXT_T9_VECTOR) ? 'V' : '.', 731 (status & MXT_T9_AMP) ? 'A' : '.', 732 (status & MXT_T9_SUPPRESS) ? 'S' : '.', 733 (status & MXT_T9_UNGRIP) ? 'U' : '.', 734 x, y, area, amplitude); 735 736 input_mt_slot(input_dev, id); 737 738 if (status & MXT_T9_DETECT) { 739 /* 740 * Multiple bits may be set if the host is slow to read 741 * the status messages, indicating all the events that 742 * have happened. 743 */ 744 if (status & MXT_T9_RELEASE) { 745 input_mt_report_slot_state(input_dev, 746 MT_TOOL_FINGER, 0); 747 mxt_input_sync(data); 748 } 749 750 /* Touch active */ 751 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1); 752 input_report_abs(input_dev, ABS_MT_POSITION_X, x); 753 input_report_abs(input_dev, ABS_MT_POSITION_Y, y); 754 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude); 755 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area); 756 } else { 757 /* Touch no longer active, close out slot */ 758 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 0); 759 } 760 761 data->update_input = true; 762 } 763 764 static int mxt_proc_message(struct mxt_data *data, u8 *message) 765 { 766 u8 report_id = message[0]; 767 768 if (report_id == MXT_RPTID_NOMSG) 769 return 0; 770 771 if (report_id == data->T6_reportid) { 772 mxt_proc_t6_messages(data, message); 773 } else if (!data->input_dev) { 774 /* 775 * Do not report events if input device 776 * is not yet registered. 777 */ 778 mxt_dump_message(data, message); 779 } else if (report_id >= data->T9_reportid_min 780 && report_id <= data->T9_reportid_max) { 781 mxt_proc_t9_message(data, message); 782 } else if (report_id == data->T19_reportid) { 783 mxt_input_button(data, message); 784 data->update_input = true; 785 } else { 786 mxt_dump_message(data, message); 787 } 788 789 return 1; 790 } 791 792 static int mxt_read_and_process_messages(struct mxt_data *data, u8 count) 793 { 794 struct device *dev = &data->client->dev; 795 int ret; 796 int i; 797 u8 num_valid = 0; 798 799 /* Safety check for msg_buf */ 800 if (count > data->max_reportid) 801 return -EINVAL; 802 803 /* Process remaining messages if necessary */ 804 ret = __mxt_read_reg(data->client, data->T5_address, 805 data->T5_msg_size * count, data->msg_buf); 806 if (ret) { 807 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret); 808 return ret; 809 } 810 811 for (i = 0; i < count; i++) { 812 ret = mxt_proc_message(data, 813 data->msg_buf + data->T5_msg_size * i); 814 815 if (ret == 1) 816 num_valid++; 817 } 818 819 /* return number of messages read */ 820 return num_valid; 821 } 822 823 static irqreturn_t mxt_process_messages_t44(struct mxt_data *data) 824 { 825 struct device *dev = &data->client->dev; 826 int ret; 827 u8 count, num_left; 828 829 /* Read T44 and T5 together */ 830 ret = __mxt_read_reg(data->client, data->T44_address, 831 data->T5_msg_size + 1, data->msg_buf); 832 if (ret) { 833 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret); 834 return IRQ_NONE; 835 } 836 837 count = data->msg_buf[0]; 838 839 if (count == 0) { 840 dev_warn(dev, "Interrupt triggered but zero messages\n"); 841 return IRQ_NONE; 842 } else if (count > data->max_reportid) { 843 dev_err(dev, "T44 count %d exceeded max report id\n", count); 844 count = data->max_reportid; 845 } 846 847 /* Process first message */ 848 ret = mxt_proc_message(data, data->msg_buf + 1); 849 if (ret < 0) { 850 dev_warn(dev, "Unexpected invalid message\n"); 851 return IRQ_NONE; 852 } 853 854 num_left = count - 1; 855 856 /* Process remaining messages if necessary */ 857 if (num_left) { 858 ret = mxt_read_and_process_messages(data, num_left); 859 if (ret < 0) 860 goto end; 861 else if (ret != num_left) 862 dev_warn(dev, "Unexpected invalid message\n"); 863 } 864 865 end: 866 if (data->update_input) { 867 mxt_input_sync(data); 868 data->update_input = false; 869 } 870 871 return IRQ_HANDLED; 872 } 873 874 static int mxt_process_messages_until_invalid(struct mxt_data *data) 875 { 876 struct device *dev = &data->client->dev; 877 int count, read; 878 u8 tries = 2; 879 880 count = data->max_reportid; 881 882 /* Read messages until we force an invalid */ 883 do { 884 read = mxt_read_and_process_messages(data, count); 885 if (read < count) 886 return 0; 887 } while (--tries); 888 889 if (data->update_input) { 890 mxt_input_sync(data); 891 data->update_input = false; 892 } 893 894 dev_err(dev, "CHG pin isn't cleared\n"); 895 return -EBUSY; 896 } 897 898 static irqreturn_t mxt_process_messages(struct mxt_data *data) 899 { 900 int total_handled, num_handled; 901 u8 count = data->last_message_count; 902 903 if (count < 1 || count > data->max_reportid) 904 count = 1; 905 906 /* include final invalid message */ 907 total_handled = mxt_read_and_process_messages(data, count + 1); 908 if (total_handled < 0) 909 return IRQ_NONE; 910 /* if there were invalid messages, then we are done */ 911 else if (total_handled <= count) 912 goto update_count; 913 914 /* keep reading two msgs until one is invalid or reportid limit */ 915 do { 916 num_handled = mxt_read_and_process_messages(data, 2); 917 if (num_handled < 0) 918 return IRQ_NONE; 919 920 total_handled += num_handled; 921 922 if (num_handled < 2) 923 break; 924 } while (total_handled < data->num_touchids); 925 926 update_count: 927 data->last_message_count = total_handled; 928 929 if (data->update_input) { 930 mxt_input_sync(data); 931 data->update_input = false; 932 } 933 934 return IRQ_HANDLED; 935 } 936 937 static irqreturn_t mxt_interrupt(int irq, void *dev_id) 938 { 939 struct mxt_data *data = dev_id; 940 941 if (data->in_bootloader) { 942 /* bootloader state transition completion */ 943 complete(&data->bl_completion); 944 return IRQ_HANDLED; 945 } 946 947 if (!data->object_table) 948 return IRQ_HANDLED; 949 950 if (data->T44_address) { 951 return mxt_process_messages_t44(data); 952 } else { 953 return mxt_process_messages(data); 954 } 955 } 956 957 static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset, 958 u8 value, bool wait) 959 { 960 u16 reg; 961 u8 command_register; 962 int timeout_counter = 0; 963 int ret; 964 965 reg = data->T6_address + cmd_offset; 966 967 ret = mxt_write_reg(data->client, reg, value); 968 if (ret) 969 return ret; 970 971 if (!wait) 972 return 0; 973 974 do { 975 msleep(20); 976 ret = __mxt_read_reg(data->client, reg, 1, &command_register); 977 if (ret) 978 return ret; 979 } while (command_register != 0 && timeout_counter++ <= 100); 980 981 if (timeout_counter > 100) { 982 dev_err(&data->client->dev, "Command failed!\n"); 983 return -EIO; 984 } 985 986 return 0; 987 } 988 989 static int mxt_soft_reset(struct mxt_data *data) 990 { 991 struct device *dev = &data->client->dev; 992 int ret = 0; 993 994 dev_info(dev, "Resetting chip\n"); 995 996 reinit_completion(&data->reset_completion); 997 998 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false); 999 if (ret) 1000 return ret; 1001 1002 ret = mxt_wait_for_completion(data, &data->reset_completion, 1003 MXT_RESET_TIMEOUT); 1004 if (ret) 1005 return ret; 1006 1007 return 0; 1008 } 1009 1010 static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value) 1011 { 1012 /* 1013 * On failure, CRC is set to 0 and config will always be 1014 * downloaded. 1015 */ 1016 data->config_crc = 0; 1017 reinit_completion(&data->crc_completion); 1018 1019 mxt_t6_command(data, cmd, value, true); 1020 1021 /* 1022 * Wait for crc message. On failure, CRC is set to 0 and config will 1023 * always be downloaded. 1024 */ 1025 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT); 1026 } 1027 1028 static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte) 1029 { 1030 static const unsigned int crcpoly = 0x80001B; 1031 u32 result; 1032 u32 data_word; 1033 1034 data_word = (secondbyte << 8) | firstbyte; 1035 result = ((*crc << 1) ^ data_word); 1036 1037 if (result & 0x1000000) 1038 result ^= crcpoly; 1039 1040 *crc = result; 1041 } 1042 1043 static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off) 1044 { 1045 u32 crc = 0; 1046 u8 *ptr = base + start_off; 1047 u8 *last_val = base + end_off - 1; 1048 1049 if (end_off < start_off) 1050 return -EINVAL; 1051 1052 while (ptr < last_val) { 1053 mxt_calc_crc24(&crc, *ptr, *(ptr + 1)); 1054 ptr += 2; 1055 } 1056 1057 /* if len is odd, fill the last byte with 0 */ 1058 if (ptr == last_val) 1059 mxt_calc_crc24(&crc, *ptr, 0); 1060 1061 /* Mask to 24-bit */ 1062 crc &= 0x00FFFFFF; 1063 1064 return crc; 1065 } 1066 1067 static int mxt_prepare_cfg_mem(struct mxt_data *data, 1068 const struct firmware *cfg, 1069 unsigned int data_pos, 1070 unsigned int cfg_start_ofs, 1071 u8 *config_mem, 1072 size_t config_mem_size) 1073 { 1074 struct device *dev = &data->client->dev; 1075 struct mxt_object *object; 1076 unsigned int type, instance, size, byte_offset; 1077 int offset; 1078 int ret; 1079 int i; 1080 u16 reg; 1081 u8 val; 1082 1083 while (data_pos < cfg->size) { 1084 /* Read type, instance, length */ 1085 ret = sscanf(cfg->data + data_pos, "%x %x %x%n", 1086 &type, &instance, &size, &offset); 1087 if (ret == 0) { 1088 /* EOF */ 1089 break; 1090 } else if (ret != 3) { 1091 dev_err(dev, "Bad format: failed to parse object\n"); 1092 return -EINVAL; 1093 } 1094 data_pos += offset; 1095 1096 object = mxt_get_object(data, type); 1097 if (!object) { 1098 /* Skip object */ 1099 for (i = 0; i < size; i++) { 1100 ret = sscanf(cfg->data + data_pos, "%hhx%n", 1101 &val, &offset); 1102 if (ret != 1) { 1103 dev_err(dev, "Bad format in T%d at %d\n", 1104 type, i); 1105 return -EINVAL; 1106 } 1107 data_pos += offset; 1108 } 1109 continue; 1110 } 1111 1112 if (size > mxt_obj_size(object)) { 1113 /* 1114 * Either we are in fallback mode due to wrong 1115 * config or config from a later fw version, 1116 * or the file is corrupt or hand-edited. 1117 */ 1118 dev_warn(dev, "Discarding %zu byte(s) in T%u\n", 1119 size - mxt_obj_size(object), type); 1120 } else if (mxt_obj_size(object) > size) { 1121 /* 1122 * If firmware is upgraded, new bytes may be added to 1123 * end of objects. It is generally forward compatible 1124 * to zero these bytes - previous behaviour will be 1125 * retained. However this does invalidate the CRC and 1126 * will force fallback mode until the configuration is 1127 * updated. We warn here but do nothing else - the 1128 * malloc has zeroed the entire configuration. 1129 */ 1130 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n", 1131 mxt_obj_size(object) - size, type); 1132 } 1133 1134 if (instance >= mxt_obj_instances(object)) { 1135 dev_err(dev, "Object instances exceeded!\n"); 1136 return -EINVAL; 1137 } 1138 1139 reg = object->start_address + mxt_obj_size(object) * instance; 1140 1141 for (i = 0; i < size; i++) { 1142 ret = sscanf(cfg->data + data_pos, "%hhx%n", 1143 &val, 1144 &offset); 1145 if (ret != 1) { 1146 dev_err(dev, "Bad format in T%d at %d\n", 1147 type, i); 1148 return -EINVAL; 1149 } 1150 data_pos += offset; 1151 1152 if (i > mxt_obj_size(object)) 1153 continue; 1154 1155 byte_offset = reg + i - cfg_start_ofs; 1156 1157 if (byte_offset >= 0 && byte_offset < config_mem_size) { 1158 *(config_mem + byte_offset) = val; 1159 } else { 1160 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n", 1161 reg, object->type, byte_offset); 1162 return -EINVAL; 1163 } 1164 } 1165 } 1166 1167 return 0; 1168 } 1169 1170 static int mxt_upload_cfg_mem(struct mxt_data *data, unsigned int cfg_start, 1171 u8 *config_mem, size_t config_mem_size) 1172 { 1173 unsigned int byte_offset = 0; 1174 int error; 1175 1176 /* Write configuration as blocks */ 1177 while (byte_offset < config_mem_size) { 1178 unsigned int size = config_mem_size - byte_offset; 1179 1180 if (size > MXT_MAX_BLOCK_WRITE) 1181 size = MXT_MAX_BLOCK_WRITE; 1182 1183 error = __mxt_write_reg(data->client, 1184 cfg_start + byte_offset, 1185 size, config_mem + byte_offset); 1186 if (error) { 1187 dev_err(&data->client->dev, 1188 "Config write error, ret=%d\n", error); 1189 return error; 1190 } 1191 1192 byte_offset += size; 1193 } 1194 1195 return 0; 1196 } 1197 1198 /* 1199 * mxt_update_cfg - download configuration to chip 1200 * 1201 * Atmel Raw Config File Format 1202 * 1203 * The first four lines of the raw config file contain: 1204 * 1) Version 1205 * 2) Chip ID Information (first 7 bytes of device memory) 1206 * 3) Chip Information Block 24-bit CRC Checksum 1207 * 4) Chip Configuration 24-bit CRC Checksum 1208 * 1209 * The rest of the file consists of one line per object instance: 1210 * <TYPE> <INSTANCE> <SIZE> <CONTENTS> 1211 * 1212 * <TYPE> - 2-byte object type as hex 1213 * <INSTANCE> - 2-byte object instance number as hex 1214 * <SIZE> - 2-byte object size as hex 1215 * <CONTENTS> - array of <SIZE> 1-byte hex values 1216 */ 1217 static int mxt_update_cfg(struct mxt_data *data, const struct firmware *cfg) 1218 { 1219 struct device *dev = &data->client->dev; 1220 struct mxt_info cfg_info; 1221 int ret; 1222 int offset; 1223 int data_pos; 1224 int i; 1225 int cfg_start_ofs; 1226 u32 info_crc, config_crc, calculated_crc; 1227 u8 *config_mem; 1228 size_t config_mem_size; 1229 1230 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1); 1231 1232 if (strncmp(cfg->data, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) { 1233 dev_err(dev, "Unrecognised config file\n"); 1234 return -EINVAL; 1235 } 1236 1237 data_pos = strlen(MXT_CFG_MAGIC); 1238 1239 /* Load information block and check */ 1240 for (i = 0; i < sizeof(struct mxt_info); i++) { 1241 ret = sscanf(cfg->data + data_pos, "%hhx%n", 1242 (unsigned char *)&cfg_info + i, 1243 &offset); 1244 if (ret != 1) { 1245 dev_err(dev, "Bad format\n"); 1246 return -EINVAL; 1247 } 1248 1249 data_pos += offset; 1250 } 1251 1252 if (cfg_info.family_id != data->info.family_id) { 1253 dev_err(dev, "Family ID mismatch!\n"); 1254 return -EINVAL; 1255 } 1256 1257 if (cfg_info.variant_id != data->info.variant_id) { 1258 dev_err(dev, "Variant ID mismatch!\n"); 1259 return -EINVAL; 1260 } 1261 1262 /* Read CRCs */ 1263 ret = sscanf(cfg->data + data_pos, "%x%n", &info_crc, &offset); 1264 if (ret != 1) { 1265 dev_err(dev, "Bad format: failed to parse Info CRC\n"); 1266 return -EINVAL; 1267 } 1268 data_pos += offset; 1269 1270 ret = sscanf(cfg->data + data_pos, "%x%n", &config_crc, &offset); 1271 if (ret != 1) { 1272 dev_err(dev, "Bad format: failed to parse Config CRC\n"); 1273 return -EINVAL; 1274 } 1275 data_pos += offset; 1276 1277 /* 1278 * The Info Block CRC is calculated over mxt_info and the object 1279 * table. If it does not match then we are trying to load the 1280 * configuration from a different chip or firmware version, so 1281 * the configuration CRC is invalid anyway. 1282 */ 1283 if (info_crc == data->info_crc) { 1284 if (config_crc == 0 || data->config_crc == 0) { 1285 dev_info(dev, "CRC zero, attempting to apply config\n"); 1286 } else if (config_crc == data->config_crc) { 1287 dev_dbg(dev, "Config CRC 0x%06X: OK\n", 1288 data->config_crc); 1289 return 0; 1290 } else { 1291 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n", 1292 data->config_crc, config_crc); 1293 } 1294 } else { 1295 dev_warn(dev, 1296 "Warning: Info CRC error - device=0x%06X file=0x%06X\n", 1297 data->info_crc, info_crc); 1298 } 1299 1300 /* Malloc memory to store configuration */ 1301 cfg_start_ofs = MXT_OBJECT_START + 1302 data->info.object_num * sizeof(struct mxt_object) + 1303 MXT_INFO_CHECKSUM_SIZE; 1304 config_mem_size = data->mem_size - cfg_start_ofs; 1305 config_mem = kzalloc(config_mem_size, GFP_KERNEL); 1306 if (!config_mem) { 1307 dev_err(dev, "Failed to allocate memory\n"); 1308 return -ENOMEM; 1309 } 1310 1311 ret = mxt_prepare_cfg_mem(data, cfg, data_pos, cfg_start_ofs, 1312 config_mem, config_mem_size); 1313 if (ret) 1314 goto release_mem; 1315 1316 /* Calculate crc of the received configs (not the raw config file) */ 1317 if (data->T7_address < cfg_start_ofs) { 1318 dev_err(dev, "Bad T7 address, T7addr = %x, config offset %x\n", 1319 data->T7_address, cfg_start_ofs); 1320 ret = 0; 1321 goto release_mem; 1322 } 1323 1324 calculated_crc = mxt_calculate_crc(config_mem, 1325 data->T7_address - cfg_start_ofs, 1326 config_mem_size); 1327 1328 if (config_crc > 0 && config_crc != calculated_crc) 1329 dev_warn(dev, "Config CRC error, calculated=%06X, file=%06X\n", 1330 calculated_crc, config_crc); 1331 1332 ret = mxt_upload_cfg_mem(data, cfg_start_ofs, 1333 config_mem, config_mem_size); 1334 if (ret) 1335 goto release_mem; 1336 1337 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE); 1338 1339 ret = mxt_soft_reset(data); 1340 if (ret) 1341 goto release_mem; 1342 1343 dev_info(dev, "Config successfully updated\n"); 1344 1345 release_mem: 1346 kfree(config_mem); 1347 return ret; 1348 } 1349 1350 static int mxt_acquire_irq(struct mxt_data *data) 1351 { 1352 int error; 1353 1354 enable_irq(data->irq); 1355 1356 error = mxt_process_messages_until_invalid(data); 1357 if (error) 1358 return error; 1359 1360 return 0; 1361 } 1362 1363 static int mxt_get_info(struct mxt_data *data) 1364 { 1365 struct i2c_client *client = data->client; 1366 struct mxt_info *info = &data->info; 1367 int error; 1368 1369 /* Read 7-byte info block starting at address 0 */ 1370 error = __mxt_read_reg(client, MXT_INFO, sizeof(*info), info); 1371 if (error) 1372 return error; 1373 1374 return 0; 1375 } 1376 1377 static void mxt_free_object_table(struct mxt_data *data) 1378 { 1379 input_unregister_device(data->input_dev); 1380 data->input_dev = NULL; 1381 1382 kfree(data->object_table); 1383 data->object_table = NULL; 1384 kfree(data->msg_buf); 1385 data->msg_buf = NULL; 1386 data->T5_address = 0; 1387 data->T5_msg_size = 0; 1388 data->T6_reportid = 0; 1389 data->T7_address = 0; 1390 data->T9_reportid_min = 0; 1391 data->T9_reportid_max = 0; 1392 data->T19_reportid = 0; 1393 data->T44_address = 0; 1394 data->max_reportid = 0; 1395 } 1396 1397 static int mxt_get_object_table(struct mxt_data *data) 1398 { 1399 struct i2c_client *client = data->client; 1400 size_t table_size; 1401 struct mxt_object *object_table; 1402 int error; 1403 int i; 1404 u8 reportid; 1405 u16 end_address; 1406 1407 table_size = data->info.object_num * sizeof(struct mxt_object); 1408 object_table = kzalloc(table_size, GFP_KERNEL); 1409 if (!object_table) { 1410 dev_err(&data->client->dev, "Failed to allocate memory\n"); 1411 return -ENOMEM; 1412 } 1413 1414 error = __mxt_read_reg(client, MXT_OBJECT_START, table_size, 1415 object_table); 1416 if (error) { 1417 kfree(object_table); 1418 return error; 1419 } 1420 1421 /* Valid Report IDs start counting from 1 */ 1422 reportid = 1; 1423 data->mem_size = 0; 1424 for (i = 0; i < data->info.object_num; i++) { 1425 struct mxt_object *object = object_table + i; 1426 u8 min_id, max_id; 1427 1428 le16_to_cpus(&object->start_address); 1429 1430 if (object->num_report_ids) { 1431 min_id = reportid; 1432 reportid += object->num_report_ids * 1433 mxt_obj_instances(object); 1434 max_id = reportid - 1; 1435 } else { 1436 min_id = 0; 1437 max_id = 0; 1438 } 1439 1440 dev_dbg(&data->client->dev, 1441 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n", 1442 object->type, object->start_address, 1443 mxt_obj_size(object), mxt_obj_instances(object), 1444 min_id, max_id); 1445 1446 switch (object->type) { 1447 case MXT_GEN_MESSAGE_T5: 1448 if (data->info.family_id == 0x80 && 1449 data->info.version < 0x20) { 1450 /* 1451 * On mXT224 firmware versions prior to V2.0 1452 * read and discard unused CRC byte otherwise 1453 * DMA reads are misaligned. 1454 */ 1455 data->T5_msg_size = mxt_obj_size(object); 1456 } else { 1457 /* CRC not enabled, so skip last byte */ 1458 data->T5_msg_size = mxt_obj_size(object) - 1; 1459 } 1460 data->T5_address = object->start_address; 1461 break; 1462 case MXT_GEN_COMMAND_T6: 1463 data->T6_reportid = min_id; 1464 data->T6_address = object->start_address; 1465 break; 1466 case MXT_GEN_POWER_T7: 1467 data->T7_address = object->start_address; 1468 break; 1469 case MXT_TOUCH_MULTI_T9: 1470 data->T9_reportid_min = min_id; 1471 data->T9_reportid_max = max_id; 1472 data->num_touchids = object->num_report_ids 1473 * mxt_obj_instances(object); 1474 break; 1475 case MXT_SPT_MESSAGECOUNT_T44: 1476 data->T44_address = object->start_address; 1477 break; 1478 case MXT_SPT_GPIOPWM_T19: 1479 data->T19_reportid = min_id; 1480 break; 1481 } 1482 1483 end_address = object->start_address 1484 + mxt_obj_size(object) * mxt_obj_instances(object) - 1; 1485 1486 if (end_address >= data->mem_size) 1487 data->mem_size = end_address + 1; 1488 } 1489 1490 /* Store maximum reportid */ 1491 data->max_reportid = reportid; 1492 1493 /* If T44 exists, T5 position has to be directly after */ 1494 if (data->T44_address && (data->T5_address != data->T44_address + 1)) { 1495 dev_err(&client->dev, "Invalid T44 position\n"); 1496 error = -EINVAL; 1497 goto free_object_table; 1498 } 1499 1500 data->msg_buf = kcalloc(data->max_reportid, 1501 data->T5_msg_size, GFP_KERNEL); 1502 if (!data->msg_buf) { 1503 dev_err(&client->dev, "Failed to allocate message buffer\n"); 1504 error = -ENOMEM; 1505 goto free_object_table; 1506 } 1507 1508 data->object_table = object_table; 1509 1510 return 0; 1511 1512 free_object_table: 1513 mxt_free_object_table(data); 1514 return error; 1515 } 1516 1517 static int mxt_read_t9_resolution(struct mxt_data *data) 1518 { 1519 struct i2c_client *client = data->client; 1520 int error; 1521 struct t9_range range; 1522 unsigned char orient; 1523 struct mxt_object *object; 1524 1525 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9); 1526 if (!object) 1527 return -EINVAL; 1528 1529 error = __mxt_read_reg(client, 1530 object->start_address + MXT_T9_RANGE, 1531 sizeof(range), &range); 1532 if (error) 1533 return error; 1534 1535 le16_to_cpus(&range.x); 1536 le16_to_cpus(&range.y); 1537 1538 error = __mxt_read_reg(client, 1539 object->start_address + MXT_T9_ORIENT, 1540 1, &orient); 1541 if (error) 1542 return error; 1543 1544 /* Handle default values */ 1545 if (range.x == 0) 1546 range.x = 1023; 1547 1548 if (range.y == 0) 1549 range.y = 1023; 1550 1551 if (orient & MXT_T9_ORIENT_SWITCH) { 1552 data->max_x = range.y; 1553 data->max_y = range.x; 1554 } else { 1555 data->max_x = range.x; 1556 data->max_y = range.y; 1557 } 1558 1559 dev_dbg(&client->dev, 1560 "Touchscreen size X%uY%u\n", data->max_x, data->max_y); 1561 1562 return 0; 1563 } 1564 1565 static int mxt_input_open(struct input_dev *dev); 1566 static void mxt_input_close(struct input_dev *dev); 1567 1568 static int mxt_initialize_t9_input_device(struct mxt_data *data) 1569 { 1570 struct device *dev = &data->client->dev; 1571 const struct mxt_platform_data *pdata = data->pdata; 1572 struct input_dev *input_dev; 1573 int error; 1574 unsigned int num_mt_slots; 1575 unsigned int mt_flags = 0; 1576 int i; 1577 1578 error = mxt_read_t9_resolution(data); 1579 if (error) 1580 dev_warn(dev, "Failed to initialize T9 resolution\n"); 1581 1582 input_dev = input_allocate_device(); 1583 if (!input_dev) { 1584 dev_err(dev, "Failed to allocate memory\n"); 1585 return -ENOMEM; 1586 } 1587 1588 input_dev->name = "Atmel maXTouch Touchscreen"; 1589 input_dev->phys = data->phys; 1590 input_dev->id.bustype = BUS_I2C; 1591 input_dev->dev.parent = dev; 1592 input_dev->open = mxt_input_open; 1593 input_dev->close = mxt_input_close; 1594 1595 __set_bit(EV_ABS, input_dev->evbit); 1596 __set_bit(EV_KEY, input_dev->evbit); 1597 __set_bit(BTN_TOUCH, input_dev->keybit); 1598 1599 if (pdata->t19_num_keys) { 1600 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit); 1601 1602 for (i = 0; i < pdata->t19_num_keys; i++) 1603 if (pdata->t19_keymap[i] != KEY_RESERVED) 1604 input_set_capability(input_dev, EV_KEY, 1605 pdata->t19_keymap[i]); 1606 1607 mt_flags |= INPUT_MT_POINTER; 1608 1609 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM); 1610 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM); 1611 input_abs_set_res(input_dev, ABS_MT_POSITION_X, 1612 MXT_PIXELS_PER_MM); 1613 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, 1614 MXT_PIXELS_PER_MM); 1615 1616 input_dev->name = "Atmel maXTouch Touchpad"; 1617 } 1618 1619 /* For single touch */ 1620 input_set_abs_params(input_dev, ABS_X, 1621 0, data->max_x, 0, 0); 1622 input_set_abs_params(input_dev, ABS_Y, 1623 0, data->max_y, 0, 0); 1624 input_set_abs_params(input_dev, ABS_PRESSURE, 1625 0, 255, 0, 0); 1626 1627 /* For multi touch */ 1628 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1; 1629 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags); 1630 if (error) { 1631 dev_err(dev, "Error %d initialising slots\n", error); 1632 goto err_free_mem; 1633 } 1634 1635 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 1636 0, MXT_MAX_AREA, 0, 0); 1637 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 1638 0, data->max_x, 0, 0); 1639 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 1640 0, data->max_y, 0, 0); 1641 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 1642 0, 255, 0, 0); 1643 1644 input_set_drvdata(input_dev, data); 1645 1646 error = input_register_device(input_dev); 1647 if (error) { 1648 dev_err(dev, "Error %d registering input device\n", error); 1649 goto err_free_mem; 1650 } 1651 1652 data->input_dev = input_dev; 1653 1654 return 0; 1655 1656 err_free_mem: 1657 input_free_device(input_dev); 1658 return error; 1659 } 1660 1661 static int mxt_configure_objects(struct mxt_data *data, 1662 const struct firmware *cfg); 1663 1664 static void mxt_config_cb(const struct firmware *cfg, void *ctx) 1665 { 1666 mxt_configure_objects(ctx, cfg); 1667 release_firmware(cfg); 1668 } 1669 1670 static int mxt_initialize(struct mxt_data *data) 1671 { 1672 struct i2c_client *client = data->client; 1673 int recovery_attempts = 0; 1674 int error; 1675 1676 while (1) { 1677 error = mxt_get_info(data); 1678 if (!error) 1679 break; 1680 1681 /* Check bootloader state */ 1682 error = mxt_probe_bootloader(data, false); 1683 if (error) { 1684 dev_info(&client->dev, "Trying alternate bootloader address\n"); 1685 error = mxt_probe_bootloader(data, true); 1686 if (error) { 1687 /* Chip is not in appmode or bootloader mode */ 1688 return error; 1689 } 1690 } 1691 1692 /* OK, we are in bootloader, see if we can recover */ 1693 if (++recovery_attempts > 1) { 1694 dev_err(&client->dev, "Could not recover from bootloader mode\n"); 1695 /* 1696 * We can reflash from this state, so do not 1697 * abort initialization. 1698 */ 1699 data->in_bootloader = true; 1700 return 0; 1701 } 1702 1703 /* Attempt to exit bootloader into app mode */ 1704 mxt_send_bootloader_cmd(data, false); 1705 msleep(MXT_FW_RESET_TIME); 1706 } 1707 1708 /* Get object table information */ 1709 error = mxt_get_object_table(data); 1710 if (error) { 1711 dev_err(&client->dev, "Error %d reading object table\n", error); 1712 return error; 1713 } 1714 1715 error = mxt_acquire_irq(data); 1716 if (error) 1717 goto err_free_object_table; 1718 1719 error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME, 1720 &client->dev, GFP_KERNEL, data, 1721 mxt_config_cb); 1722 if (error) { 1723 dev_err(&client->dev, "Failed to invoke firmware loader: %d\n", 1724 error); 1725 goto err_free_object_table; 1726 } 1727 1728 return 0; 1729 1730 err_free_object_table: 1731 mxt_free_object_table(data); 1732 return error; 1733 } 1734 1735 static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep) 1736 { 1737 struct device *dev = &data->client->dev; 1738 int error; 1739 struct t7_config *new_config; 1740 struct t7_config deepsleep = { .active = 0, .idle = 0 }; 1741 1742 if (sleep == MXT_POWER_CFG_DEEPSLEEP) 1743 new_config = &deepsleep; 1744 else 1745 new_config = &data->t7_cfg; 1746 1747 error = __mxt_write_reg(data->client, data->T7_address, 1748 sizeof(data->t7_cfg), new_config); 1749 if (error) 1750 return error; 1751 1752 dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n", 1753 new_config->active, new_config->idle); 1754 1755 return 0; 1756 } 1757 1758 static int mxt_init_t7_power_cfg(struct mxt_data *data) 1759 { 1760 struct device *dev = &data->client->dev; 1761 int error; 1762 bool retry = false; 1763 1764 recheck: 1765 error = __mxt_read_reg(data->client, data->T7_address, 1766 sizeof(data->t7_cfg), &data->t7_cfg); 1767 if (error) 1768 return error; 1769 1770 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) { 1771 if (!retry) { 1772 dev_dbg(dev, "T7 cfg zero, resetting\n"); 1773 mxt_soft_reset(data); 1774 retry = true; 1775 goto recheck; 1776 } else { 1777 dev_dbg(dev, "T7 cfg zero after reset, overriding\n"); 1778 data->t7_cfg.active = 20; 1779 data->t7_cfg.idle = 100; 1780 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN); 1781 } 1782 } 1783 1784 dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n", 1785 data->t7_cfg.active, data->t7_cfg.idle); 1786 return 0; 1787 } 1788 1789 static int mxt_configure_objects(struct mxt_data *data, 1790 const struct firmware *cfg) 1791 { 1792 struct device *dev = &data->client->dev; 1793 struct mxt_info *info = &data->info; 1794 int error; 1795 1796 if (cfg) { 1797 error = mxt_update_cfg(data, cfg); 1798 if (error) 1799 dev_warn(dev, "Error %d updating config\n", error); 1800 } 1801 1802 error = mxt_init_t7_power_cfg(data); 1803 if (error) { 1804 dev_err(dev, "Failed to initialize power cfg\n"); 1805 return error; 1806 } 1807 1808 error = mxt_initialize_t9_input_device(data); 1809 if (error) 1810 return error; 1811 1812 dev_info(dev, 1813 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n", 1814 info->family_id, info->variant_id, info->version >> 4, 1815 info->version & 0xf, info->build, info->object_num); 1816 1817 return 0; 1818 } 1819 1820 /* Firmware Version is returned as Major.Minor.Build */ 1821 static ssize_t mxt_fw_version_show(struct device *dev, 1822 struct device_attribute *attr, char *buf) 1823 { 1824 struct mxt_data *data = dev_get_drvdata(dev); 1825 struct mxt_info *info = &data->info; 1826 return scnprintf(buf, PAGE_SIZE, "%u.%u.%02X\n", 1827 info->version >> 4, info->version & 0xf, info->build); 1828 } 1829 1830 /* Hardware Version is returned as FamilyID.VariantID */ 1831 static ssize_t mxt_hw_version_show(struct device *dev, 1832 struct device_attribute *attr, char *buf) 1833 { 1834 struct mxt_data *data = dev_get_drvdata(dev); 1835 struct mxt_info *info = &data->info; 1836 return scnprintf(buf, PAGE_SIZE, "%u.%u\n", 1837 info->family_id, info->variant_id); 1838 } 1839 1840 static ssize_t mxt_show_instance(char *buf, int count, 1841 struct mxt_object *object, int instance, 1842 const u8 *val) 1843 { 1844 int i; 1845 1846 if (mxt_obj_instances(object) > 1) 1847 count += scnprintf(buf + count, PAGE_SIZE - count, 1848 "Instance %u\n", instance); 1849 1850 for (i = 0; i < mxt_obj_size(object); i++) 1851 count += scnprintf(buf + count, PAGE_SIZE - count, 1852 "\t[%2u]: %02x (%d)\n", i, val[i], val[i]); 1853 count += scnprintf(buf + count, PAGE_SIZE - count, "\n"); 1854 1855 return count; 1856 } 1857 1858 static ssize_t mxt_object_show(struct device *dev, 1859 struct device_attribute *attr, char *buf) 1860 { 1861 struct mxt_data *data = dev_get_drvdata(dev); 1862 struct mxt_object *object; 1863 int count = 0; 1864 int i, j; 1865 int error; 1866 u8 *obuf; 1867 1868 /* Pre-allocate buffer large enough to hold max sized object. */ 1869 obuf = kmalloc(256, GFP_KERNEL); 1870 if (!obuf) 1871 return -ENOMEM; 1872 1873 error = 0; 1874 for (i = 0; i < data->info.object_num; i++) { 1875 object = data->object_table + i; 1876 1877 if (!mxt_object_readable(object->type)) 1878 continue; 1879 1880 count += scnprintf(buf + count, PAGE_SIZE - count, 1881 "T%u:\n", object->type); 1882 1883 for (j = 0; j < mxt_obj_instances(object); j++) { 1884 u16 size = mxt_obj_size(object); 1885 u16 addr = object->start_address + j * size; 1886 1887 error = __mxt_read_reg(data->client, addr, size, obuf); 1888 if (error) 1889 goto done; 1890 1891 count = mxt_show_instance(buf, count, object, j, obuf); 1892 } 1893 } 1894 1895 done: 1896 kfree(obuf); 1897 return error ?: count; 1898 } 1899 1900 static int mxt_check_firmware_format(struct device *dev, 1901 const struct firmware *fw) 1902 { 1903 unsigned int pos = 0; 1904 char c; 1905 1906 while (pos < fw->size) { 1907 c = *(fw->data + pos); 1908 1909 if (c < '0' || (c > '9' && c < 'A') || c > 'F') 1910 return 0; 1911 1912 pos++; 1913 } 1914 1915 /* 1916 * To convert file try: 1917 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw 1918 */ 1919 dev_err(dev, "Aborting: firmware file must be in binary format\n"); 1920 1921 return -EINVAL; 1922 } 1923 1924 static int mxt_load_fw(struct device *dev, const char *fn) 1925 { 1926 struct mxt_data *data = dev_get_drvdata(dev); 1927 const struct firmware *fw = NULL; 1928 unsigned int frame_size; 1929 unsigned int pos = 0; 1930 unsigned int retry = 0; 1931 unsigned int frame = 0; 1932 int ret; 1933 1934 ret = request_firmware(&fw, fn, dev); 1935 if (ret) { 1936 dev_err(dev, "Unable to open firmware %s\n", fn); 1937 return ret; 1938 } 1939 1940 /* Check for incorrect enc file */ 1941 ret = mxt_check_firmware_format(dev, fw); 1942 if (ret) 1943 goto release_firmware; 1944 1945 if (!data->in_bootloader) { 1946 /* Change to the bootloader mode */ 1947 data->in_bootloader = true; 1948 1949 ret = mxt_t6_command(data, MXT_COMMAND_RESET, 1950 MXT_BOOT_VALUE, false); 1951 if (ret) 1952 goto release_firmware; 1953 1954 msleep(MXT_RESET_TIME); 1955 1956 /* Do not need to scan since we know family ID */ 1957 ret = mxt_lookup_bootloader_address(data, 0); 1958 if (ret) 1959 goto release_firmware; 1960 } else { 1961 enable_irq(data->irq); 1962 } 1963 1964 mxt_free_object_table(data); 1965 reinit_completion(&data->bl_completion); 1966 1967 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false); 1968 if (ret) { 1969 /* Bootloader may still be unlocked from previous attempt */ 1970 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false); 1971 if (ret) 1972 goto disable_irq; 1973 } else { 1974 dev_info(dev, "Unlocking bootloader\n"); 1975 1976 /* Unlock bootloader */ 1977 ret = mxt_send_bootloader_cmd(data, true); 1978 if (ret) 1979 goto disable_irq; 1980 } 1981 1982 while (pos < fw->size) { 1983 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true); 1984 if (ret) 1985 goto disable_irq; 1986 1987 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1)); 1988 1989 /* Take account of CRC bytes */ 1990 frame_size += 2; 1991 1992 /* Write one frame to device */ 1993 ret = mxt_bootloader_write(data, fw->data + pos, frame_size); 1994 if (ret) 1995 goto disable_irq; 1996 1997 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true); 1998 if (ret) { 1999 retry++; 2000 2001 /* Back off by 20ms per retry */ 2002 msleep(retry * 20); 2003 2004 if (retry > 20) { 2005 dev_err(dev, "Retry count exceeded\n"); 2006 goto disable_irq; 2007 } 2008 } else { 2009 retry = 0; 2010 pos += frame_size; 2011 frame++; 2012 } 2013 2014 if (frame % 50 == 0) 2015 dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n", 2016 frame, pos, fw->size); 2017 } 2018 2019 /* Wait for flash. */ 2020 ret = mxt_wait_for_completion(data, &data->bl_completion, 2021 MXT_FW_RESET_TIME); 2022 if (ret) 2023 goto disable_irq; 2024 2025 dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos); 2026 2027 /* 2028 * Wait for device to reset. Some bootloader versions do not assert 2029 * the CHG line after bootloading has finished, so ignore potential 2030 * errors. 2031 */ 2032 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME); 2033 2034 data->in_bootloader = false; 2035 2036 disable_irq: 2037 disable_irq(data->irq); 2038 release_firmware: 2039 release_firmware(fw); 2040 return ret; 2041 } 2042 2043 static ssize_t mxt_update_fw_store(struct device *dev, 2044 struct device_attribute *attr, 2045 const char *buf, size_t count) 2046 { 2047 struct mxt_data *data = dev_get_drvdata(dev); 2048 int error; 2049 2050 error = mxt_load_fw(dev, MXT_FW_NAME); 2051 if (error) { 2052 dev_err(dev, "The firmware update failed(%d)\n", error); 2053 count = error; 2054 } else { 2055 dev_info(dev, "The firmware update succeeded\n"); 2056 2057 error = mxt_initialize(data); 2058 if (error) 2059 return error; 2060 } 2061 2062 return count; 2063 } 2064 2065 static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL); 2066 static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL); 2067 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL); 2068 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store); 2069 2070 static struct attribute *mxt_attrs[] = { 2071 &dev_attr_fw_version.attr, 2072 &dev_attr_hw_version.attr, 2073 &dev_attr_object.attr, 2074 &dev_attr_update_fw.attr, 2075 NULL 2076 }; 2077 2078 static const struct attribute_group mxt_attr_group = { 2079 .attrs = mxt_attrs, 2080 }; 2081 2082 static void mxt_start(struct mxt_data *data) 2083 { 2084 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN); 2085 2086 /* Recalibrate since chip has been in deep sleep */ 2087 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false); 2088 } 2089 2090 static void mxt_stop(struct mxt_data *data) 2091 { 2092 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP); 2093 } 2094 2095 static int mxt_input_open(struct input_dev *dev) 2096 { 2097 struct mxt_data *data = input_get_drvdata(dev); 2098 2099 mxt_start(data); 2100 2101 return 0; 2102 } 2103 2104 static void mxt_input_close(struct input_dev *dev) 2105 { 2106 struct mxt_data *data = input_get_drvdata(dev); 2107 2108 mxt_stop(data); 2109 } 2110 2111 #ifdef CONFIG_OF 2112 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client) 2113 { 2114 struct mxt_platform_data *pdata; 2115 u32 *keymap; 2116 u32 keycode; 2117 int proplen, i, ret; 2118 2119 if (!client->dev.of_node) 2120 return ERR_PTR(-ENODEV); 2121 2122 pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL); 2123 if (!pdata) 2124 return ERR_PTR(-ENOMEM); 2125 2126 if (of_find_property(client->dev.of_node, "linux,gpio-keymap", 2127 &proplen)) { 2128 pdata->t19_num_keys = proplen / sizeof(u32); 2129 2130 keymap = devm_kzalloc(&client->dev, 2131 pdata->t19_num_keys * sizeof(keymap[0]), 2132 GFP_KERNEL); 2133 if (!keymap) 2134 return ERR_PTR(-ENOMEM); 2135 2136 for (i = 0; i < pdata->t19_num_keys; i++) { 2137 ret = of_property_read_u32_index(client->dev.of_node, 2138 "linux,gpio-keymap", i, &keycode); 2139 if (ret) 2140 keycode = KEY_RESERVED; 2141 2142 keymap[i] = keycode; 2143 } 2144 2145 pdata->t19_keymap = keymap; 2146 } 2147 2148 return pdata; 2149 } 2150 #else 2151 static struct mxt_platform_data *mxt_parse_dt(struct i2c_client *client) 2152 { 2153 dev_dbg(&client->dev, "No platform data specified\n"); 2154 return ERR_PTR(-EINVAL); 2155 } 2156 #endif 2157 2158 static int mxt_probe(struct i2c_client *client, const struct i2c_device_id *id) 2159 { 2160 struct mxt_data *data; 2161 const struct mxt_platform_data *pdata; 2162 int error; 2163 2164 pdata = dev_get_platdata(&client->dev); 2165 if (!pdata) { 2166 pdata = mxt_parse_dt(client); 2167 if (IS_ERR(pdata)) 2168 return PTR_ERR(pdata); 2169 } 2170 2171 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL); 2172 if (!data) { 2173 dev_err(&client->dev, "Failed to allocate memory\n"); 2174 return -ENOMEM; 2175 } 2176 2177 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0", 2178 client->adapter->nr, client->addr); 2179 2180 data->client = client; 2181 data->pdata = pdata; 2182 data->irq = client->irq; 2183 i2c_set_clientdata(client, data); 2184 2185 init_completion(&data->bl_completion); 2186 init_completion(&data->reset_completion); 2187 init_completion(&data->crc_completion); 2188 2189 error = request_threaded_irq(client->irq, NULL, mxt_interrupt, 2190 pdata->irqflags | IRQF_ONESHOT, 2191 client->name, data); 2192 if (error) { 2193 dev_err(&client->dev, "Failed to register interrupt\n"); 2194 goto err_free_mem; 2195 } 2196 2197 disable_irq(client->irq); 2198 2199 error = mxt_initialize(data); 2200 if (error) 2201 goto err_free_irq; 2202 2203 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group); 2204 if (error) { 2205 dev_err(&client->dev, "Failure %d creating sysfs group\n", 2206 error); 2207 goto err_free_object; 2208 } 2209 2210 return 0; 2211 2212 err_free_object: 2213 mxt_free_object_table(data); 2214 err_free_irq: 2215 free_irq(client->irq, data); 2216 err_free_mem: 2217 kfree(data); 2218 return error; 2219 } 2220 2221 static int mxt_remove(struct i2c_client *client) 2222 { 2223 struct mxt_data *data = i2c_get_clientdata(client); 2224 2225 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group); 2226 free_irq(data->irq, data); 2227 input_unregister_device(data->input_dev); 2228 mxt_free_object_table(data); 2229 kfree(data); 2230 2231 return 0; 2232 } 2233 2234 #ifdef CONFIG_PM_SLEEP 2235 static int mxt_suspend(struct device *dev) 2236 { 2237 struct i2c_client *client = to_i2c_client(dev); 2238 struct mxt_data *data = i2c_get_clientdata(client); 2239 struct input_dev *input_dev = data->input_dev; 2240 2241 mutex_lock(&input_dev->mutex); 2242 2243 if (input_dev->users) 2244 mxt_stop(data); 2245 2246 mutex_unlock(&input_dev->mutex); 2247 2248 return 0; 2249 } 2250 2251 static int mxt_resume(struct device *dev) 2252 { 2253 struct i2c_client *client = to_i2c_client(dev); 2254 struct mxt_data *data = i2c_get_clientdata(client); 2255 struct input_dev *input_dev = data->input_dev; 2256 2257 mutex_lock(&input_dev->mutex); 2258 2259 if (input_dev->users) 2260 mxt_start(data); 2261 2262 mutex_unlock(&input_dev->mutex); 2263 2264 return 0; 2265 } 2266 #endif 2267 2268 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume); 2269 2270 static const struct of_device_id mxt_of_match[] = { 2271 { .compatible = "atmel,maxtouch", }, 2272 {}, 2273 }; 2274 MODULE_DEVICE_TABLE(of, mxt_of_match); 2275 2276 static const struct i2c_device_id mxt_id[] = { 2277 { "qt602240_ts", 0 }, 2278 { "atmel_mxt_ts", 0 }, 2279 { "atmel_mxt_tp", 0 }, 2280 { "mXT224", 0 }, 2281 { } 2282 }; 2283 MODULE_DEVICE_TABLE(i2c, mxt_id); 2284 2285 static struct i2c_driver mxt_driver = { 2286 .driver = { 2287 .name = "atmel_mxt_ts", 2288 .owner = THIS_MODULE, 2289 .of_match_table = of_match_ptr(mxt_of_match), 2290 .pm = &mxt_pm_ops, 2291 }, 2292 .probe = mxt_probe, 2293 .remove = mxt_remove, 2294 .id_table = mxt_id, 2295 }; 2296 2297 module_i2c_driver(mxt_driver); 2298 2299 /* Module information */ 2300 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 2301 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver"); 2302 MODULE_LICENSE("GPL"); 2303