FILE
atmel_mxt_ts.c
File preview with syntax highlighting.
linux-6.19.14/drivers/input/touchscreen/atmel_mxt_ts.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Atmel maXTouch Touchscreen driver 4 * 5 * Copyright (C) 2010 Samsung Electronics Co.Ltd 6 * Copyright (C) 2011-2014 Atmel Corporation 7 * Copyright (C) 2012 Google, Inc. 8 * Copyright (C) 2016 Zodiac Inflight Innovations 9 * 10 * Author: Joonyoung Shim <jy0922.shim@samsung.com> 11 */ 12 13#include <linux/acpi.h> 14#include <linux/dmi.h> 15#include <linux/module.h> 16#include <linux/init.h> 17#include <linux/completion.h> 18#include <linux/delay.h> 19#include <linux/firmware.h> 20#include <linux/i2c.h> 21#include <linux/input/mt.h> 22#include <linux/input/touchscreen.h> 23#include <linux/interrupt.h> 24#include <linux/irq.h> 25#include <linux/of.h> 26#include <linux/property.h> 27#include <linux/slab.h> 28#include <linux/regulator/consumer.h> 29#include <linux/gpio/consumer.h> 30#include <linux/unaligned.h> 31#include <media/v4l2-device.h> 32#include <media/v4l2-ioctl.h> 33#include <media/videobuf2-v4l2.h> 34#include <media/videobuf2-vmalloc.h> 35#include <dt-bindings/input/atmel-maxtouch.h> 36 37/* Firmware files */ 38#define MXT_FW_NAME "maxtouch.fw" 39#define MXT_CFG_NAME "maxtouch.cfg" 40#define MXT_CFG_MAGIC "OBP_RAW V1" 41 42/* Registers */ 43#define MXT_OBJECT_START 0x07 44#define MXT_OBJECT_SIZE 6 45#define MXT_INFO_CHECKSUM_SIZE 3 46#define MXT_MAX_BLOCK_WRITE 256 47 48/* Object types */ 49#define MXT_DEBUG_DIAGNOSTIC_T37 37 50#define MXT_GEN_MESSAGE_T5 5 51#define MXT_GEN_COMMAND_T6 6 52#define MXT_GEN_POWER_T7 7 53#define MXT_GEN_ACQUIRE_T8 8 54#define MXT_GEN_DATASOURCE_T53 53 55#define MXT_TOUCH_MULTI_T9 9 56#define MXT_TOUCH_KEYARRAY_T15 15 57#define MXT_TOUCH_PROXIMITY_T23 23 58#define MXT_TOUCH_PROXKEY_T52 52 59#define MXT_TOUCH_PTC_KEYS_T97 97 60#define MXT_PROCI_GRIPFACE_T20 20 61#define MXT_PROCG_NOISE_T22 22 62#define MXT_PROCI_ONETOUCH_T24 24 63#define MXT_PROCI_TWOTOUCH_T27 27 64#define MXT_PROCI_GRIP_T40 40 65#define MXT_PROCI_PALM_T41 41 66#define MXT_PROCI_TOUCHSUPPRESSION_T42 42 67#define MXT_PROCI_STYLUS_T47 47 68#define MXT_PROCG_NOISESUPPRESSION_T48 48 69#define MXT_SPT_COMMSCONFIG_T18 18 70#define MXT_SPT_GPIOPWM_T19 19 71#define MXT_SPT_SELFTEST_T25 25 72#define MXT_SPT_CTECONFIG_T28 28 73#define MXT_SPT_USERDATA_T38 38 74#define MXT_SPT_DIGITIZER_T43 43 75#define MXT_SPT_MESSAGECOUNT_T44 44 76#define MXT_SPT_CTECONFIG_T46 46 77#define MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71 71 78#define MXT_TOUCH_MULTITOUCHSCREEN_T100 100 79 80/* MXT_GEN_MESSAGE_T5 object */ 81#define MXT_RPTID_NOMSG 0xff 82 83/* MXT_GEN_COMMAND_T6 field */ 84#define MXT_COMMAND_RESET 0 85#define MXT_COMMAND_BACKUPNV 1 86#define MXT_COMMAND_CALIBRATE 2 87#define MXT_COMMAND_REPORTALL 3 88#define MXT_COMMAND_DIAGNOSTIC 5 89 90/* Define for T6 status byte */ 91#define MXT_T6_STATUS_RESET BIT(7) 92#define MXT_T6_STATUS_OFL BIT(6) 93#define MXT_T6_STATUS_SIGERR BIT(5) 94#define MXT_T6_STATUS_CAL BIT(4) 95#define MXT_T6_STATUS_CFGERR BIT(3) 96#define MXT_T6_STATUS_COMSERR BIT(2) 97 98/* MXT_GEN_POWER_T7 field */ 99struct t7_config { 100 u8 idle; 101 u8 active; 102} __packed; 103 104#define MXT_POWER_CFG_RUN 0 105#define MXT_POWER_CFG_DEEPSLEEP 1 106 107/* MXT_TOUCH_MULTI_T9 field */ 108#define MXT_T9_CTRL 0 109#define MXT_T9_XSIZE 3 110#define MXT_T9_YSIZE 4 111#define MXT_T9_ORIENT 9 112#define MXT_T9_RANGE 18 113 114/* MXT_TOUCH_MULTI_T9 status */ 115#define MXT_T9_UNGRIP BIT(0) 116#define MXT_T9_SUPPRESS BIT(1) 117#define MXT_T9_AMP BIT(2) 118#define MXT_T9_VECTOR BIT(3) 119#define MXT_T9_MOVE BIT(4) 120#define MXT_T9_RELEASE BIT(5) 121#define MXT_T9_PRESS BIT(6) 122#define MXT_T9_DETECT BIT(7) 123 124struct t9_range { 125 __le16 x; 126 __le16 y; 127} __packed; 128 129/* MXT_TOUCH_MULTI_T9 orient */ 130#define MXT_T9_ORIENT_SWITCH BIT(0) 131#define MXT_T9_ORIENT_INVERTX BIT(1) 132#define MXT_T9_ORIENT_INVERTY BIT(2) 133 134/* MXT_SPT_COMMSCONFIG_T18 */ 135#define MXT_COMMS_CTRL 0 136#define MXT_COMMS_CMD 1 137#define MXT_COMMS_RETRIGEN BIT(6) 138 139/* MXT_DEBUG_DIAGNOSTIC_T37 */ 140#define MXT_DIAGNOSTIC_PAGEUP 0x01 141#define MXT_DIAGNOSTIC_DELTAS 0x10 142#define MXT_DIAGNOSTIC_REFS 0x11 143#define MXT_DIAGNOSTIC_SIZE 128 144 145#define MXT_FAMILY_1386 160 146#define MXT1386_COLUMNS 3 147#define MXT1386_PAGES_PER_COLUMN 8 148 149struct t37_debug { 150#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37 151 u8 mode; 152 u8 page; 153 u8 data[MXT_DIAGNOSTIC_SIZE]; 154#endif 155}; 156 157/* Define for MXT_GEN_COMMAND_T6 */ 158#define MXT_BOOT_VALUE 0xa5 159#define MXT_RESET_VALUE 0x01 160#define MXT_BACKUP_VALUE 0x55 161 162/* T100 Multiple Touch Touchscreen */ 163#define MXT_T100_CTRL 0 164#define MXT_T100_CFG1 1 165#define MXT_T100_TCHAUX 3 166#define MXT_T100_XSIZE 9 167#define MXT_T100_XRANGE 13 168#define MXT_T100_YSIZE 20 169#define MXT_T100_YRANGE 24 170 171#define MXT_T100_CFG_SWITCHXY BIT(5) 172#define MXT_T100_CFG_INVERTY BIT(6) 173#define MXT_T100_CFG_INVERTX BIT(7) 174 175#define MXT_T100_TCHAUX_VECT BIT(0) 176#define MXT_T100_TCHAUX_AMPL BIT(1) 177#define MXT_T100_TCHAUX_AREA BIT(2) 178 179#define MXT_T100_DETECT BIT(7) 180#define MXT_T100_TYPE_MASK 0x70 181 182enum t100_type { 183 MXT_T100_TYPE_FINGER = 1, 184 MXT_T100_TYPE_PASSIVE_STYLUS = 2, 185 MXT_T100_TYPE_HOVERING_FINGER = 4, 186 MXT_T100_TYPE_GLOVE = 5, 187 MXT_T100_TYPE_LARGE_TOUCH = 6, 188}; 189 190#define MXT_DISTANCE_ACTIVE_TOUCH 0 191#define MXT_DISTANCE_HOVERING 1 192 193#define MXT_TOUCH_MAJOR_DEFAULT 1 194#define MXT_PRESSURE_DEFAULT 1 195 196/* Delay times */ 197#define MXT_BACKUP_TIME 50 /* msec */ 198#define MXT_RESET_GPIO_TIME 20 /* msec */ 199#define MXT_RESET_INVALID_CHG 100 /* msec */ 200#define MXT_RESET_TIME 200 /* msec */ 201#define MXT_RESET_TIMEOUT 3000 /* msec */ 202#define MXT_CRC_TIMEOUT 1000 /* msec */ 203#define MXT_FW_RESET_TIME 3000 /* msec */ 204#define MXT_FW_CHG_TIMEOUT 300 /* msec */ 205#define MXT_WAKEUP_TIME 25 /* msec */ 206 207/* Command to unlock bootloader */ 208#define MXT_UNLOCK_CMD_MSB 0xaa 209#define MXT_UNLOCK_CMD_LSB 0xdc 210 211/* Bootloader mode status */ 212#define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */ 213#define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */ 214#define MXT_FRAME_CRC_CHECK 0x02 215#define MXT_FRAME_CRC_FAIL 0x03 216#define MXT_FRAME_CRC_PASS 0x04 217#define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */ 218#define MXT_BOOT_STATUS_MASK 0x3f 219#define MXT_BOOT_EXTENDED_ID BIT(5) 220#define MXT_BOOT_ID_MASK 0x1f 221 222/* Touchscreen absolute values */ 223#define MXT_MAX_AREA 0xff 224 225#define MXT_PIXELS_PER_MM 20 226 227struct mxt_info { 228 u8 family_id; 229 u8 variant_id; 230 u8 version; 231 u8 build; 232 u8 matrix_xsize; 233 u8 matrix_ysize; 234 u8 object_num; 235}; 236 237struct mxt_object { 238 u8 type; 239 u16 start_address; 240 u8 size_minus_one; 241 u8 instances_minus_one; 242 u8 num_report_ids; 243} __packed; 244 245struct mxt_dbg { 246 u16 t37_address; 247 u16 diag_cmd_address; 248 struct t37_debug *t37_buf; 249 unsigned int t37_pages; 250 unsigned int t37_nodes; 251 252 struct v4l2_device v4l2; 253 struct v4l2_pix_format format; 254 struct video_device vdev; 255 struct vb2_queue queue; 256 struct mutex lock; 257 int input; 258}; 259 260enum v4l_dbg_inputs { 261 MXT_V4L_INPUT_DELTAS, 262 MXT_V4L_INPUT_REFS, 263 MXT_V4L_INPUT_MAX, 264}; 265 266enum mxt_suspend_mode { 267 MXT_SUSPEND_DEEP_SLEEP = 0, 268 MXT_SUSPEND_T9_CTRL = 1, 269}; 270 271/* Config update context */ 272struct mxt_cfg { 273 u8 *raw; 274 size_t raw_size; 275 off_t raw_pos; 276 277 u8 *mem; 278 size_t mem_size; 279 int start_ofs; 280 281 struct mxt_info info; 282}; 283 284/* Each client has this additional data */ 285struct mxt_data { 286 struct i2c_client *client; 287 struct input_dev *input_dev; 288 char phys[64]; /* device physical location */ 289 struct mxt_object *object_table; 290 struct mxt_info *info; 291 void *raw_info_block; 292 unsigned int irq; 293 unsigned int max_x; 294 unsigned int max_y; 295 bool invertx; 296 bool inverty; 297 bool xy_switch; 298 u8 xsize; 299 u8 ysize; 300 bool in_bootloader; 301 u16 mem_size; 302 u8 t100_aux_ampl; 303 u8 t100_aux_area; 304 u8 t100_aux_vect; 305 u8 max_reportid; 306 u32 config_crc; 307 u32 info_crc; 308 u8 bootloader_addr; 309 u8 *msg_buf; 310 u8 t6_status; 311 bool update_input; 312 u8 last_message_count; 313 u8 num_touchids; 314 u8 multitouch; 315 struct t7_config t7_cfg; 316 struct mxt_dbg dbg; 317 struct regulator_bulk_data regulators[2]; 318 struct gpio_desc *reset_gpio; 319 struct gpio_desc *wake_gpio; 320 bool use_retrigen_workaround; 321 322 /* Cached parameters from object table */ 323 u16 T5_address; 324 u8 T5_msg_size; 325 u8 T6_reportid; 326 u16 T6_address; 327 u16 T7_address; 328 u16 T71_address; 329 u8 T9_reportid_min; 330 u8 T9_reportid_max; 331 u8 T15_reportid_min; 332 u8 T15_reportid_max; 333 u16 T18_address; 334 u8 T19_reportid; 335 u16 T44_address; 336 u8 T97_reportid_min; 337 u8 T97_reportid_max; 338 u8 T100_reportid_min; 339 u8 T100_reportid_max; 340 341 /* for fw update in bootloader */ 342 struct completion bl_completion; 343 344 /* for reset handling */ 345 struct completion reset_completion; 346 347 /* for config update handling */ 348 struct completion crc_completion; 349 350 u32 *t19_keymap; 351 unsigned int t19_num_keys; 352 353 u32 *t15_keymap; 354 unsigned int t15_num_keys; 355 356 enum mxt_suspend_mode suspend_mode; 357 358 u32 wakeup_method; 359 360 struct touchscreen_properties prop; 361}; 362 363struct mxt_vb2_buffer { 364 struct vb2_buffer vb; 365 struct list_head list; 366}; 367 368static size_t mxt_obj_size(const struct mxt_object *obj) 369{ 370 return obj->size_minus_one + 1; 371} 372 373static size_t mxt_obj_instances(const struct mxt_object *obj) 374{ 375 return obj->instances_minus_one + 1; 376} 377 378static bool mxt_object_readable(unsigned int type) 379{ 380 switch (type) { 381 case MXT_GEN_COMMAND_T6: 382 case MXT_GEN_POWER_T7: 383 case MXT_GEN_ACQUIRE_T8: 384 case MXT_GEN_DATASOURCE_T53: 385 case MXT_TOUCH_MULTI_T9: 386 case MXT_TOUCH_KEYARRAY_T15: 387 case MXT_TOUCH_PROXIMITY_T23: 388 case MXT_TOUCH_PROXKEY_T52: 389 case MXT_TOUCH_PTC_KEYS_T97: 390 case MXT_TOUCH_MULTITOUCHSCREEN_T100: 391 case MXT_PROCI_GRIPFACE_T20: 392 case MXT_PROCG_NOISE_T22: 393 case MXT_PROCI_ONETOUCH_T24: 394 case MXT_PROCI_TWOTOUCH_T27: 395 case MXT_PROCI_GRIP_T40: 396 case MXT_PROCI_PALM_T41: 397 case MXT_PROCI_TOUCHSUPPRESSION_T42: 398 case MXT_PROCI_STYLUS_T47: 399 case MXT_PROCG_NOISESUPPRESSION_T48: 400 case MXT_SPT_COMMSCONFIG_T18: 401 case MXT_SPT_GPIOPWM_T19: 402 case MXT_SPT_SELFTEST_T25: 403 case MXT_SPT_CTECONFIG_T28: 404 case MXT_SPT_USERDATA_T38: 405 case MXT_SPT_DIGITIZER_T43: 406 case MXT_SPT_CTECONFIG_T46: 407 case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71: 408 return true; 409 default: 410 return false; 411 } 412} 413 414static void mxt_dump_message(struct mxt_data *data, u8 *message) 415{ 416 dev_dbg(&data->client->dev, "message: %*ph\n", 417 data->T5_msg_size, message); 418} 419 420static int mxt_wait_for_completion(struct mxt_data *data, 421 struct completion *comp, 422 unsigned int timeout_ms) 423{ 424 struct device *dev = &data->client->dev; 425 unsigned long timeout = msecs_to_jiffies(timeout_ms); 426 long ret; 427 428 ret = wait_for_completion_interruptible_timeout(comp, timeout); 429 if (ret < 0) { 430 return ret; 431 } else if (ret == 0) { 432 dev_err(dev, "Wait for completion timed out.\n"); 433 return -ETIMEDOUT; 434 } 435 return 0; 436} 437 438static int mxt_bootloader_read(struct mxt_data *data, 439 u8 *val, unsigned int count) 440{ 441 int ret; 442 struct i2c_msg msg; 443 444 msg.addr = data->bootloader_addr; 445 msg.flags = data->client->flags & I2C_M_TEN; 446 msg.flags |= I2C_M_RD; 447 msg.len = count; 448 msg.buf = val; 449 450 ret = i2c_transfer(data->client->adapter, &msg, 1); 451 if (ret == 1) { 452 ret = 0; 453 } else { 454 ret = ret < 0 ? ret : -EIO; 455 dev_err(&data->client->dev, "%s: i2c recv failed (%d)\n", 456 __func__, ret); 457 } 458 459 return ret; 460} 461 462static int mxt_bootloader_write(struct mxt_data *data, 463 const u8 * const val, unsigned int count) 464{ 465 int ret; 466 struct i2c_msg msg; 467 468 msg.addr = data->bootloader_addr; 469 msg.flags = data->client->flags & I2C_M_TEN; 470 msg.len = count; 471 msg.buf = (u8 *)val; 472 473 ret = i2c_transfer(data->client->adapter, &msg, 1); 474 if (ret == 1) { 475 ret = 0; 476 } else { 477 ret = ret < 0 ? ret : -EIO; 478 dev_err(&data->client->dev, "%s: i2c send failed (%d)\n", 479 __func__, ret); 480 } 481 482 return ret; 483} 484 485static int mxt_lookup_bootloader_address(struct mxt_data *data, bool retry) 486{ 487 u8 appmode = data->client->addr; 488 u8 bootloader; 489 u8 family_id = data->info ? data->info->family_id : 0; 490 491 switch (appmode) { 492 case 0x4a: 493 case 0x4b: 494 /* Chips after 1664S use different scheme */ 495 if (retry || family_id >= 0xa2) { 496 bootloader = appmode - 0x24; 497 break; 498 } 499 fallthrough; /* for normal case */ 500 case 0x4c: 501 case 0x4d: 502 case 0x5a: 503 case 0x5b: 504 bootloader = appmode - 0x26; 505 break; 506 507 default: 508 dev_err(&data->client->dev, 509 "Appmode i2c address 0x%02x not found\n", 510 appmode); 511 return -EINVAL; 512 } 513 514 data->bootloader_addr = bootloader; 515 return 0; 516} 517 518static int mxt_probe_bootloader(struct mxt_data *data, bool alt_address) 519{ 520 struct device *dev = &data->client->dev; 521 int error; 522 u8 val; 523 bool crc_failure; 524 525 error = mxt_lookup_bootloader_address(data, alt_address); 526 if (error) 527 return error; 528 529 error = mxt_bootloader_read(data, &val, 1); 530 if (error) 531 return error; 532 533 /* Check app crc fail mode */ 534 crc_failure = (val & ~MXT_BOOT_STATUS_MASK) == MXT_APP_CRC_FAIL; 535 536 dev_err(dev, "Detected bootloader, status:%02X%s\n", 537 val, crc_failure ? ", APP_CRC_FAIL" : ""); 538 539 return 0; 540} 541 542static u8 mxt_get_bootloader_version(struct mxt_data *data, u8 val) 543{ 544 struct device *dev = &data->client->dev; 545 u8 buf[3]; 546 547 if (val & MXT_BOOT_EXTENDED_ID) { 548 if (mxt_bootloader_read(data, &buf[0], 3) != 0) { 549 dev_err(dev, "%s: i2c failure\n", __func__); 550 return val; 551 } 552 553 dev_dbg(dev, "Bootloader ID:%d Version:%d\n", buf[1], buf[2]); 554 555 return buf[0]; 556 } else { 557 dev_dbg(dev, "Bootloader ID:%d\n", val & MXT_BOOT_ID_MASK); 558 559 return val; 560 } 561} 562 563static int mxt_check_bootloader(struct mxt_data *data, unsigned int state, 564 bool wait) 565{ 566 struct device *dev = &data->client->dev; 567 u8 val; 568 int ret; 569 570recheck: 571 if (wait) { 572 /* 573 * In application update mode, the interrupt 574 * line signals state transitions. We must wait for the 575 * CHG assertion before reading the status byte. 576 * Once the status byte has been read, the line is deasserted. 577 */ 578 ret = mxt_wait_for_completion(data, &data->bl_completion, 579 MXT_FW_CHG_TIMEOUT); 580 if (ret) { 581 /* 582 * TODO: handle -ERESTARTSYS better by terminating 583 * fw update process before returning to userspace 584 * by writing length 0x000 to device (iff we are in 585 * WAITING_FRAME_DATA state). 586 */ 587 dev_err(dev, "Update wait error %d\n", ret); 588 return ret; 589 } 590 } 591 592 ret = mxt_bootloader_read(data, &val, 1); 593 if (ret) 594 return ret; 595 596 if (state == MXT_WAITING_BOOTLOAD_CMD) 597 val = mxt_get_bootloader_version(data, val); 598 599 switch (state) { 600 case MXT_WAITING_BOOTLOAD_CMD: 601 case MXT_WAITING_FRAME_DATA: 602 case MXT_APP_CRC_FAIL: 603 val &= ~MXT_BOOT_STATUS_MASK; 604 break; 605 case MXT_FRAME_CRC_PASS: 606 if (val == MXT_FRAME_CRC_CHECK) { 607 goto recheck; 608 } else if (val == MXT_FRAME_CRC_FAIL) { 609 dev_err(dev, "Bootloader CRC fail\n"); 610 return -EINVAL; 611 } 612 break; 613 default: 614 return -EINVAL; 615 } 616 617 if (val != state) { 618 dev_err(dev, "Invalid bootloader state %02X != %02X\n", 619 val, state); 620 return -EINVAL; 621 } 622 623 return 0; 624} 625 626static int mxt_send_bootloader_cmd(struct mxt_data *data, bool unlock) 627{ 628 u8 buf[2]; 629 630 if (unlock) { 631 buf[0] = MXT_UNLOCK_CMD_LSB; 632 buf[1] = MXT_UNLOCK_CMD_MSB; 633 } else { 634 buf[0] = 0x01; 635 buf[1] = 0x01; 636 } 637 638 return mxt_bootloader_write(data, buf, sizeof(buf)); 639} 640 641static bool mxt_wakeup_toggle(struct i2c_client *client, 642 bool wake_up, bool in_i2c) 643{ 644 struct mxt_data *data = i2c_get_clientdata(client); 645 646 switch (data->wakeup_method) { 647 case ATMEL_MXT_WAKEUP_I2C_SCL: 648 if (!in_i2c) 649 return false; 650 break; 651 652 case ATMEL_MXT_WAKEUP_GPIO: 653 if (in_i2c) 654 return false; 655 656 gpiod_set_value(data->wake_gpio, wake_up); 657 break; 658 659 default: 660 return false; 661 } 662 663 if (wake_up) { 664 dev_dbg(&client->dev, "waking up controller\n"); 665 666 msleep(MXT_WAKEUP_TIME); 667 } 668 669 return true; 670} 671 672static int __mxt_read_reg(struct i2c_client *client, 673 u16 reg, u16 len, void *val) 674{ 675 struct i2c_msg xfer[2]; 676 bool retried = false; 677 u8 buf[2]; 678 int ret; 679 680 buf[0] = reg & 0xff; 681 buf[1] = (reg >> 8) & 0xff; 682 683 /* Write register */ 684 xfer[0].addr = client->addr; 685 xfer[0].flags = 0; 686 xfer[0].len = 2; 687 xfer[0].buf = buf; 688 689 /* Read data */ 690 xfer[1].addr = client->addr; 691 xfer[1].flags = I2C_M_RD; 692 xfer[1].len = len; 693 xfer[1].buf = val; 694 695retry: 696 ret = i2c_transfer(client->adapter, xfer, 2); 697 if (ret == 2) { 698 ret = 0; 699 } else if (!retried && mxt_wakeup_toggle(client, true, true)) { 700 retried = true; 701 goto retry; 702 } else { 703 if (ret >= 0) 704 ret = -EIO; 705 dev_err(&client->dev, "%s: i2c transfer failed (%d)\n", 706 __func__, ret); 707 } 708 709 return ret; 710} 711 712static int __mxt_write_reg(struct i2c_client *client, u16 reg, u16 len, 713 const void *val) 714{ 715 bool retried = false; 716 u8 *buf; 717 size_t count; 718 int ret; 719 720 count = len + 2; 721 buf = kmalloc(count, GFP_KERNEL); 722 if (!buf) 723 return -ENOMEM; 724 725 buf[0] = reg & 0xff; 726 buf[1] = (reg >> 8) & 0xff; 727 memcpy(&buf[2], val, len); 728 729retry: 730 ret = i2c_master_send(client, buf, count); 731 if (ret == count) { 732 ret = 0; 733 } else if (!retried && mxt_wakeup_toggle(client, true, true)) { 734 retried = true; 735 goto retry; 736 } else { 737 if (ret >= 0) 738 ret = -EIO; 739 dev_err(&client->dev, "%s: i2c send failed (%d)\n", 740 __func__, ret); 741 } 742 743 kfree(buf); 744 return ret; 745} 746 747static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val) 748{ 749 return __mxt_write_reg(client, reg, 1, &val); 750} 751 752static struct mxt_object * 753mxt_get_object(struct mxt_data *data, u8 type) 754{ 755 struct mxt_object *object; 756 int i; 757 758 for (i = 0; i < data->info->object_num; i++) { 759 object = data->object_table + i; 760 if (object->type == type) 761 return object; 762 } 763 764 dev_warn(&data->client->dev, "Invalid object type T%u\n", type); 765 return NULL; 766} 767 768static void mxt_proc_t6_messages(struct mxt_data *data, u8 *msg) 769{ 770 struct device *dev = &data->client->dev; 771 u8 status = msg[1]; 772 u32 crc = msg[2] | (msg[3] << 8) | (msg[4] << 16); 773 774 if (crc != data->config_crc) { 775 data->config_crc = crc; 776 dev_dbg(dev, "T6 Config Checksum: 0x%06X\n", crc); 777 } 778 779 complete(&data->crc_completion); 780 781 /* Detect reset */ 782 if (status & MXT_T6_STATUS_RESET) 783 complete(&data->reset_completion); 784 785 /* Output debug if status has changed */ 786 if (status != data->t6_status) 787 dev_dbg(dev, "T6 Status 0x%02X%s%s%s%s%s%s%s\n", 788 status, 789 status == 0 ? " OK" : "", 790 status & MXT_T6_STATUS_RESET ? " RESET" : "", 791 status & MXT_T6_STATUS_OFL ? " OFL" : "", 792 status & MXT_T6_STATUS_SIGERR ? " SIGERR" : "", 793 status & MXT_T6_STATUS_CAL ? " CAL" : "", 794 status & MXT_T6_STATUS_CFGERR ? " CFGERR" : "", 795 status & MXT_T6_STATUS_COMSERR ? " COMSERR" : ""); 796 797 /* Save current status */ 798 data->t6_status = status; 799} 800 801static int mxt_write_object(struct mxt_data *data, 802 u8 type, u8 offset, u8 val) 803{ 804 struct mxt_object *object; 805 u16 reg; 806 807 object = mxt_get_object(data, type); 808 if (!object || offset >= mxt_obj_size(object)) 809 return -EINVAL; 810 811 reg = object->start_address; 812 return mxt_write_reg(data->client, reg + offset, val); 813} 814 815static void mxt_input_button(struct mxt_data *data, u8 *message) 816{ 817 struct input_dev *input = data->input_dev; 818 int i; 819 820 for (i = 0; i < data->t19_num_keys; i++) { 821 if (data->t19_keymap[i] == KEY_RESERVED) 822 continue; 823 824 /* Active-low switch */ 825 input_report_key(input, data->t19_keymap[i], 826 !(message[1] & BIT(i))); 827 } 828} 829 830static void mxt_input_sync(struct mxt_data *data) 831{ 832 input_mt_report_pointer_emulation(data->input_dev, 833 data->t19_num_keys); 834 input_sync(data->input_dev); 835} 836 837static void mxt_proc_t9_message(struct mxt_data *data, u8 *message) 838{ 839 struct device *dev = &data->client->dev; 840 struct input_dev *input_dev = data->input_dev; 841 int id; 842 u8 status; 843 int x; 844 int y; 845 int area; 846 int amplitude; 847 848 id = message[0] - data->T9_reportid_min; 849 status = message[1]; 850 x = (message[2] << 4) | ((message[4] >> 4) & 0xf); 851 y = (message[3] << 4) | ((message[4] & 0xf)); 852 853 /* Handle 10/12 bit switching */ 854 if (data->max_x < 1024) 855 x >>= 2; 856 if (data->max_y < 1024) 857 y >>= 2; 858 859 area = message[5]; 860 amplitude = message[6]; 861 862 dev_dbg(dev, 863 "[%u] %c%c%c%c%c%c%c%c x: %5u y: %5u area: %3u amp: %3u\n", 864 id, 865 (status & MXT_T9_DETECT) ? 'D' : '.', 866 (status & MXT_T9_PRESS) ? 'P' : '.', 867 (status & MXT_T9_RELEASE) ? 'R' : '.', 868 (status & MXT_T9_MOVE) ? 'M' : '.', 869 (status & MXT_T9_VECTOR) ? 'V' : '.', 870 (status & MXT_T9_AMP) ? 'A' : '.', 871 (status & MXT_T9_SUPPRESS) ? 'S' : '.', 872 (status & MXT_T9_UNGRIP) ? 'U' : '.', 873 x, y, area, amplitude); 874 875 input_mt_slot(input_dev, id); 876 877 if (status & MXT_T9_DETECT) { 878 /* 879 * Multiple bits may be set if the host is slow to read 880 * the status messages, indicating all the events that 881 * have happened. 882 */ 883 if (status & MXT_T9_RELEASE) { 884 input_mt_report_slot_inactive(input_dev); 885 mxt_input_sync(data); 886 } 887 888 /* if active, pressure must be non-zero */ 889 if (!amplitude) 890 amplitude = MXT_PRESSURE_DEFAULT; 891 892 /* Touch active */ 893 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 1); 894 touchscreen_report_pos(input_dev, &data->prop, x, y, true); 895 input_report_abs(input_dev, ABS_MT_PRESSURE, amplitude); 896 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, area); 897 } else { 898 /* Touch no longer active, close out slot */ 899 input_mt_report_slot_inactive(input_dev); 900 } 901 902 data->update_input = true; 903} 904 905static void mxt_proc_t15_messages(struct mxt_data *data, u8 *message) 906{ 907 struct input_dev *input_dev = data->input_dev; 908 unsigned long keystates = get_unaligned_le32(&message[2]); 909 int key; 910 911 for (key = 0; key < data->t15_num_keys; key++) 912 input_report_key(input_dev, data->t15_keymap[key], 913 keystates & BIT(key)); 914 915 data->update_input = true; 916} 917 918static void mxt_proc_t97_messages(struct mxt_data *data, u8 *message) 919{ 920 mxt_proc_t15_messages(data, message); 921} 922 923static void mxt_proc_t100_message(struct mxt_data *data, u8 *message) 924{ 925 struct device *dev = &data->client->dev; 926 struct input_dev *input_dev = data->input_dev; 927 int id; 928 u8 status; 929 u8 type = 0; 930 u16 x; 931 u16 y; 932 int distance = 0; 933 int tool = 0; 934 u8 major = 0; 935 u8 pressure = 0; 936 u8 orientation = 0; 937 938 id = message[0] - data->T100_reportid_min - 2; 939 940 /* ignore SCRSTATUS events */ 941 if (id < 0) 942 return; 943 944 status = message[1]; 945 x = get_unaligned_le16(&message[2]); 946 y = get_unaligned_le16(&message[4]); 947 948 if (status & MXT_T100_DETECT) { 949 type = (status & MXT_T100_TYPE_MASK) >> 4; 950 951 switch (type) { 952 case MXT_T100_TYPE_HOVERING_FINGER: 953 tool = MT_TOOL_FINGER; 954 distance = MXT_DISTANCE_HOVERING; 955 956 if (data->t100_aux_vect) 957 orientation = message[data->t100_aux_vect]; 958 959 break; 960 961 case MXT_T100_TYPE_FINGER: 962 case MXT_T100_TYPE_GLOVE: 963 tool = MT_TOOL_FINGER; 964 distance = MXT_DISTANCE_ACTIVE_TOUCH; 965 966 if (data->t100_aux_area) 967 major = message[data->t100_aux_area]; 968 969 if (data->t100_aux_ampl) 970 pressure = message[data->t100_aux_ampl]; 971 972 if (data->t100_aux_vect) 973 orientation = message[data->t100_aux_vect]; 974 975 break; 976 977 case MXT_T100_TYPE_PASSIVE_STYLUS: 978 tool = MT_TOOL_PEN; 979 980 /* 981 * Passive stylus is reported with size zero so 982 * hardcode. 983 */ 984 major = MXT_TOUCH_MAJOR_DEFAULT; 985 986 if (data->t100_aux_ampl) 987 pressure = message[data->t100_aux_ampl]; 988 989 break; 990 991 case MXT_T100_TYPE_LARGE_TOUCH: 992 /* Ignore suppressed touch */ 993 break; 994 995 default: 996 dev_dbg(dev, "Unexpected T100 type\n"); 997 return; 998 } 999 } 1000 1001 /* 1002 * Values reported should be non-zero if tool is touching the 1003 * device 1004 */ 1005 if (!pressure && type != MXT_T100_TYPE_HOVERING_FINGER) 1006 pressure = MXT_PRESSURE_DEFAULT; 1007 1008 input_mt_slot(input_dev, id); 1009 1010 if (status & MXT_T100_DETECT) { 1011 dev_dbg(dev, "[%u] type:%u x:%u y:%u a:%02X p:%02X v:%02X\n", 1012 id, type, x, y, major, pressure, orientation); 1013 1014 input_mt_report_slot_state(input_dev, tool, 1); 1015 touchscreen_report_pos(input_dev, &data->prop, x, y, true); 1016 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, major); 1017 input_report_abs(input_dev, ABS_MT_PRESSURE, pressure); 1018 input_report_abs(input_dev, ABS_MT_DISTANCE, distance); 1019 input_report_abs(input_dev, ABS_MT_ORIENTATION, orientation); 1020 } else { 1021 dev_dbg(dev, "[%u] release\n", id); 1022 1023 /* close out slot */ 1024 input_mt_report_slot_inactive(input_dev); 1025 } 1026 1027 data->update_input = true; 1028} 1029 1030static int mxt_proc_message(struct mxt_data *data, u8 *message) 1031{ 1032 u8 report_id = message[0]; 1033 1034 if (report_id == MXT_RPTID_NOMSG) 1035 return 0; 1036 1037 if (report_id == data->T6_reportid) { 1038 mxt_proc_t6_messages(data, message); 1039 } else if (!data->input_dev) { 1040 /* 1041 * Do not report events if input device 1042 * is not yet registered. 1043 */ 1044 mxt_dump_message(data, message); 1045 } else if (report_id >= data->T9_reportid_min && 1046 report_id <= data->T9_reportid_max) { 1047 mxt_proc_t9_message(data, message); 1048 } else if (report_id >= data->T15_reportid_min && 1049 report_id <= data->T15_reportid_max) { 1050 mxt_proc_t15_messages(data, message); 1051 } else if (report_id >= data->T97_reportid_min && 1052 report_id <= data->T97_reportid_max) { 1053 mxt_proc_t97_messages(data, message); 1054 } else if (report_id >= data->T100_reportid_min && 1055 report_id <= data->T100_reportid_max) { 1056 mxt_proc_t100_message(data, message); 1057 } else if (report_id == data->T19_reportid) { 1058 mxt_input_button(data, message); 1059 data->update_input = true; 1060 } else { 1061 mxt_dump_message(data, message); 1062 } 1063 1064 return 1; 1065} 1066 1067static int mxt_read_and_process_messages(struct mxt_data *data, u8 count) 1068{ 1069 struct device *dev = &data->client->dev; 1070 int ret; 1071 int i; 1072 u8 num_valid = 0; 1073 1074 /* Safety check for msg_buf */ 1075 if (count > data->max_reportid) 1076 return -EINVAL; 1077 1078 /* Process remaining messages if necessary */ 1079 ret = __mxt_read_reg(data->client, data->T5_address, 1080 data->T5_msg_size * count, data->msg_buf); 1081 if (ret) { 1082 dev_err(dev, "Failed to read %u messages (%d)\n", count, ret); 1083 return ret; 1084 } 1085 1086 for (i = 0; i < count; i++) { 1087 ret = mxt_proc_message(data, 1088 data->msg_buf + data->T5_msg_size * i); 1089 1090 if (ret == 1) 1091 num_valid++; 1092 } 1093 1094 /* return number of messages read */ 1095 return num_valid; 1096} 1097 1098static irqreturn_t mxt_process_messages_t44(struct mxt_data *data) 1099{ 1100 struct device *dev = &data->client->dev; 1101 int ret; 1102 u8 count, num_left; 1103 1104 /* Read T44 and T5 together */ 1105 ret = __mxt_read_reg(data->client, data->T44_address, 1106 data->T5_msg_size + 1, data->msg_buf); 1107 if (ret) { 1108 dev_err(dev, "Failed to read T44 and T5 (%d)\n", ret); 1109 return IRQ_NONE; 1110 } 1111 1112 count = data->msg_buf[0]; 1113 1114 /* 1115 * This condition may be caused by the CHG line being configured in 1116 * Mode 0. It results in unnecessary I2C operations but it is benign. 1117 */ 1118 if (count == 0) 1119 return IRQ_NONE; 1120 1121 if (count > data->max_reportid) { 1122 dev_warn(dev, "T44 count %d exceeded max report id\n", count); 1123 count = data->max_reportid; 1124 } 1125 1126 /* Process first message */ 1127 ret = mxt_proc_message(data, data->msg_buf + 1); 1128 if (ret < 0) { 1129 dev_warn(dev, "Unexpected invalid message\n"); 1130 return IRQ_NONE; 1131 } 1132 1133 num_left = count - 1; 1134 1135 /* Process remaining messages if necessary */ 1136 if (num_left) { 1137 ret = mxt_read_and_process_messages(data, num_left); 1138 if (ret < 0) 1139 goto end; 1140 else if (ret != num_left) 1141 dev_warn(dev, "Unexpected invalid message\n"); 1142 } 1143 1144end: 1145 if (data->update_input) { 1146 mxt_input_sync(data); 1147 data->update_input = false; 1148 } 1149 1150 return IRQ_HANDLED; 1151} 1152 1153static int mxt_process_messages_until_invalid(struct mxt_data *data) 1154{ 1155 struct device *dev = &data->client->dev; 1156 int count, read; 1157 u8 tries = 2; 1158 1159 count = data->max_reportid; 1160 1161 /* Read messages until we force an invalid */ 1162 do { 1163 read = mxt_read_and_process_messages(data, count); 1164 if (read < count) 1165 return 0; 1166 } while (--tries); 1167 1168 if (data->update_input) { 1169 mxt_input_sync(data); 1170 data->update_input = false; 1171 } 1172 1173 dev_err(dev, "CHG pin isn't cleared\n"); 1174 return -EBUSY; 1175} 1176 1177static irqreturn_t mxt_process_messages(struct mxt_data *data) 1178{ 1179 int total_handled, num_handled; 1180 u8 count = data->last_message_count; 1181 1182 if (count < 1 || count > data->max_reportid) 1183 count = 1; 1184 1185 /* include final invalid message */ 1186 total_handled = mxt_read_and_process_messages(data, count + 1); 1187 if (total_handled < 0) 1188 return IRQ_NONE; 1189 /* if there were invalid messages, then we are done */ 1190 else if (total_handled <= count) 1191 goto update_count; 1192 1193 /* keep reading two msgs until one is invalid or reportid limit */ 1194 do { 1195 num_handled = mxt_read_and_process_messages(data, 2); 1196 if (num_handled < 0) 1197 return IRQ_NONE; 1198 1199 total_handled += num_handled; 1200 1201 if (num_handled < 2) 1202 break; 1203 } while (total_handled < data->num_touchids); 1204 1205update_count: 1206 data->last_message_count = total_handled; 1207 1208 if (data->update_input) { 1209 mxt_input_sync(data); 1210 data->update_input = false; 1211 } 1212 1213 return IRQ_HANDLED; 1214} 1215 1216static irqreturn_t mxt_interrupt(int irq, void *dev_id) 1217{ 1218 struct mxt_data *data = dev_id; 1219 1220 if (data->in_bootloader) { 1221 /* bootloader state transition completion */ 1222 complete(&data->bl_completion); 1223 return IRQ_HANDLED; 1224 } 1225 1226 if (!data->object_table) 1227 return IRQ_HANDLED; 1228 1229 if (data->T44_address) { 1230 return mxt_process_messages_t44(data); 1231 } else { 1232 return mxt_process_messages(data); 1233 } 1234} 1235 1236static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset, 1237 u8 value, bool wait) 1238{ 1239 u16 reg; 1240 u8 command_register; 1241 int timeout_counter = 0; 1242 int ret; 1243 1244 reg = data->T6_address + cmd_offset; 1245 1246 ret = mxt_write_reg(data->client, reg, value); 1247 if (ret) 1248 return ret; 1249 1250 if (!wait) 1251 return 0; 1252 1253 do { 1254 msleep(20); 1255 ret = __mxt_read_reg(data->client, reg, 1, &command_register); 1256 if (ret) 1257 return ret; 1258 } while (command_register != 0 && timeout_counter++ <= 100); 1259 1260 if (timeout_counter > 100) { 1261 dev_err(&data->client->dev, "Command failed!\n"); 1262 return -EIO; 1263 } 1264 1265 return 0; 1266} 1267 1268static int mxt_acquire_irq(struct mxt_data *data) 1269{ 1270 int error; 1271 1272 enable_irq(data->irq); 1273 1274 if (data->use_retrigen_workaround) { 1275 error = mxt_process_messages_until_invalid(data); 1276 if (error) 1277 return error; 1278 } 1279 1280 return 0; 1281} 1282 1283static int mxt_soft_reset(struct mxt_data *data) 1284{ 1285 struct device *dev = &data->client->dev; 1286 int ret = 0; 1287 1288 dev_info(dev, "Resetting device\n"); 1289 1290 disable_irq(data->irq); 1291 1292 reinit_completion(&data->reset_completion); 1293 1294 ret = mxt_t6_command(data, MXT_COMMAND_RESET, MXT_RESET_VALUE, false); 1295 if (ret) 1296 return ret; 1297 1298 /* Ignore CHG line for 100ms after reset */ 1299 msleep(MXT_RESET_INVALID_CHG); 1300 1301 mxt_acquire_irq(data); 1302 1303 ret = mxt_wait_for_completion(data, &data->reset_completion, 1304 MXT_RESET_TIMEOUT); 1305 if (ret) 1306 return ret; 1307 1308 return 0; 1309} 1310 1311static void mxt_update_crc(struct mxt_data *data, u8 cmd, u8 value) 1312{ 1313 /* 1314 * On failure, CRC is set to 0 and config will always be 1315 * downloaded. 1316 */ 1317 data->config_crc = 0; 1318 reinit_completion(&data->crc_completion); 1319 1320 mxt_t6_command(data, cmd, value, true); 1321 1322 /* 1323 * Wait for crc message. On failure, CRC is set to 0 and config will 1324 * always be downloaded. 1325 */ 1326 mxt_wait_for_completion(data, &data->crc_completion, MXT_CRC_TIMEOUT); 1327} 1328 1329static void mxt_calc_crc24(u32 *crc, u8 firstbyte, u8 secondbyte) 1330{ 1331 static const unsigned int crcpoly = 0x80001B; 1332 u32 result; 1333 u32 data_word; 1334 1335 data_word = (secondbyte << 8) | firstbyte; 1336 result = ((*crc << 1) ^ data_word); 1337 1338 if (result & 0x1000000) 1339 result ^= crcpoly; 1340 1341 *crc = result; 1342} 1343 1344static u32 mxt_calculate_crc(u8 *base, off_t start_off, off_t end_off) 1345{ 1346 u32 crc = 0; 1347 u8 *ptr = base + start_off; 1348 u8 *last_val = base + end_off - 1; 1349 1350 if (end_off < start_off) 1351 return -EINVAL; 1352 1353 while (ptr < last_val) { 1354 mxt_calc_crc24(&crc, *ptr, *(ptr + 1)); 1355 ptr += 2; 1356 } 1357 1358 /* if len is odd, fill the last byte with 0 */ 1359 if (ptr == last_val) 1360 mxt_calc_crc24(&crc, *ptr, 0); 1361 1362 /* Mask to 24-bit */ 1363 crc &= 0x00FFFFFF; 1364 1365 return crc; 1366} 1367 1368static int mxt_check_retrigen(struct mxt_data *data) 1369{ 1370 struct i2c_client *client = data->client; 1371 int error; 1372 int val; 1373 struct irq_data *irqd; 1374 1375 data->use_retrigen_workaround = false; 1376 1377 irqd = irq_get_irq_data(data->irq); 1378 if (!irqd) 1379 return -EINVAL; 1380 1381 if (irqd_is_level_type(irqd)) 1382 return 0; 1383 1384 if (data->T18_address) { 1385 error = __mxt_read_reg(client, 1386 data->T18_address + MXT_COMMS_CTRL, 1387 1, &val); 1388 if (error) 1389 return error; 1390 1391 if (val & MXT_COMMS_RETRIGEN) 1392 return 0; 1393 } 1394 1395 dev_warn(&client->dev, "Enabling RETRIGEN workaround\n"); 1396 data->use_retrigen_workaround = true; 1397 return 0; 1398} 1399 1400static int mxt_prepare_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg) 1401{ 1402 struct device *dev = &data->client->dev; 1403 struct mxt_object *object; 1404 unsigned int type, instance, size, byte_offset; 1405 int offset; 1406 int ret; 1407 int i; 1408 u16 reg; 1409 u8 val; 1410 1411 while (cfg->raw_pos < cfg->raw_size) { 1412 /* Read type, instance, length */ 1413 ret = sscanf(cfg->raw + cfg->raw_pos, "%x %x %x%n", 1414 &type, &instance, &size, &offset); 1415 if (ret == 0) { 1416 /* EOF */ 1417 break; 1418 } else if (ret != 3) { 1419 dev_err(dev, "Bad format: failed to parse object\n"); 1420 return -EINVAL; 1421 } 1422 cfg->raw_pos += offset; 1423 1424 object = mxt_get_object(data, type); 1425 if (!object) { 1426 /* Skip object */ 1427 for (i = 0; i < size; i++) { 1428 ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n", 1429 &val, &offset); 1430 if (ret != 1) { 1431 dev_err(dev, "Bad format in T%d at %d\n", 1432 type, i); 1433 return -EINVAL; 1434 } 1435 cfg->raw_pos += offset; 1436 } 1437 continue; 1438 } 1439 1440 if (size > mxt_obj_size(object)) { 1441 /* 1442 * Either we are in fallback mode due to wrong 1443 * config or config from a later fw version, 1444 * or the file is corrupt or hand-edited. 1445 */ 1446 dev_warn(dev, "Discarding %zu byte(s) in T%u\n", 1447 size - mxt_obj_size(object), type); 1448 } else if (mxt_obj_size(object) > size) { 1449 /* 1450 * If firmware is upgraded, new bytes may be added to 1451 * end of objects. It is generally forward compatible 1452 * to zero these bytes - previous behaviour will be 1453 * retained. However this does invalidate the CRC and 1454 * will force fallback mode until the configuration is 1455 * updated. We warn here but do nothing else - the 1456 * malloc has zeroed the entire configuration. 1457 */ 1458 dev_warn(dev, "Zeroing %zu byte(s) in T%d\n", 1459 mxt_obj_size(object) - size, type); 1460 } 1461 1462 if (instance >= mxt_obj_instances(object)) { 1463 dev_err(dev, "Object instances exceeded!\n"); 1464 return -EINVAL; 1465 } 1466 1467 reg = object->start_address + mxt_obj_size(object) * instance; 1468 1469 for (i = 0; i < size; i++) { 1470 ret = sscanf(cfg->raw + cfg->raw_pos, "%hhx%n", 1471 &val, 1472 &offset); 1473 if (ret != 1) { 1474 dev_err(dev, "Bad format in T%d at %d\n", 1475 type, i); 1476 return -EINVAL; 1477 } 1478 cfg->raw_pos += offset; 1479 1480 if (i > mxt_obj_size(object)) 1481 continue; 1482 1483 byte_offset = reg + i - cfg->start_ofs; 1484 1485 if (byte_offset >= 0 && byte_offset < cfg->mem_size) { 1486 *(cfg->mem + byte_offset) = val; 1487 } else { 1488 dev_err(dev, "Bad object: reg:%d, T%d, ofs=%d\n", 1489 reg, object->type, byte_offset); 1490 return -EINVAL; 1491 } 1492 } 1493 } 1494 1495 return 0; 1496} 1497 1498static int mxt_upload_cfg_mem(struct mxt_data *data, struct mxt_cfg *cfg) 1499{ 1500 unsigned int byte_offset = 0; 1501 int error; 1502 1503 /* Write configuration as blocks */ 1504 while (byte_offset < cfg->mem_size) { 1505 unsigned int size = cfg->mem_size - byte_offset; 1506 1507 if (size > MXT_MAX_BLOCK_WRITE) 1508 size = MXT_MAX_BLOCK_WRITE; 1509 1510 error = __mxt_write_reg(data->client, 1511 cfg->start_ofs + byte_offset, 1512 size, cfg->mem + byte_offset); 1513 if (error) { 1514 dev_err(&data->client->dev, 1515 "Config write error, ret=%d\n", error); 1516 return error; 1517 } 1518 1519 byte_offset += size; 1520 } 1521 1522 return 0; 1523} 1524 1525static int mxt_init_t7_power_cfg(struct mxt_data *data); 1526 1527/* 1528 * mxt_update_cfg - download configuration to chip 1529 * 1530 * Atmel Raw Config File Format 1531 * 1532 * The first four lines of the raw config file contain: 1533 * 1) Version 1534 * 2) Chip ID Information (first 7 bytes of device memory) 1535 * 3) Chip Information Block 24-bit CRC Checksum 1536 * 4) Chip Configuration 24-bit CRC Checksum 1537 * 1538 * The rest of the file consists of one line per object instance: 1539 * <TYPE> <INSTANCE> <SIZE> <CONTENTS> 1540 * 1541 * <TYPE> - 2-byte object type as hex 1542 * <INSTANCE> - 2-byte object instance number as hex 1543 * <SIZE> - 2-byte object size as hex 1544 * <CONTENTS> - array of <SIZE> 1-byte hex values 1545 */ 1546static int mxt_update_cfg(struct mxt_data *data, const struct firmware *fw) 1547{ 1548 struct device *dev = &data->client->dev; 1549 struct mxt_cfg cfg; 1550 int ret; 1551 int offset; 1552 int i; 1553 u32 info_crc, config_crc, calculated_crc; 1554 u16 crc_start = 0; 1555 1556 /* Make zero terminated copy of the OBP_RAW file */ 1557 cfg.raw = kmemdup_nul(fw->data, fw->size, GFP_KERNEL); 1558 if (!cfg.raw) 1559 return -ENOMEM; 1560 1561 cfg.raw_size = fw->size; 1562 1563 mxt_update_crc(data, MXT_COMMAND_REPORTALL, 1); 1564 1565 if (strncmp(cfg.raw, MXT_CFG_MAGIC, strlen(MXT_CFG_MAGIC))) { 1566 dev_err(dev, "Unrecognised config file\n"); 1567 ret = -EINVAL; 1568 goto release_raw; 1569 } 1570 1571 cfg.raw_pos = strlen(MXT_CFG_MAGIC); 1572 1573 /* Load information block and check */ 1574 for (i = 0; i < sizeof(struct mxt_info); i++) { 1575 ret = sscanf(cfg.raw + cfg.raw_pos, "%hhx%n", 1576 (unsigned char *)&cfg.info + i, 1577 &offset); 1578 if (ret != 1) { 1579 dev_err(dev, "Bad format\n"); 1580 ret = -EINVAL; 1581 goto release_raw; 1582 } 1583 1584 cfg.raw_pos += offset; 1585 } 1586 1587 if (cfg.info.family_id != data->info->family_id) { 1588 dev_err(dev, "Family ID mismatch!\n"); 1589 ret = -EINVAL; 1590 goto release_raw; 1591 } 1592 1593 if (cfg.info.variant_id != data->info->variant_id) { 1594 dev_err(dev, "Variant ID mismatch!\n"); 1595 ret = -EINVAL; 1596 goto release_raw; 1597 } 1598 1599 /* Read CRCs */ 1600 ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &info_crc, &offset); 1601 if (ret != 1) { 1602 dev_err(dev, "Bad format: failed to parse Info CRC\n"); 1603 ret = -EINVAL; 1604 goto release_raw; 1605 } 1606 cfg.raw_pos += offset; 1607 1608 ret = sscanf(cfg.raw + cfg.raw_pos, "%x%n", &config_crc, &offset); 1609 if (ret != 1) { 1610 dev_err(dev, "Bad format: failed to parse Config CRC\n"); 1611 ret = -EINVAL; 1612 goto release_raw; 1613 } 1614 cfg.raw_pos += offset; 1615 1616 /* 1617 * The Info Block CRC is calculated over mxt_info and the object 1618 * table. If it does not match then we are trying to load the 1619 * configuration from a different chip or firmware version, so 1620 * the configuration CRC is invalid anyway. 1621 */ 1622 if (info_crc == data->info_crc) { 1623 if (config_crc == 0 || data->config_crc == 0) { 1624 dev_info(dev, "CRC zero, attempting to apply config\n"); 1625 } else if (config_crc == data->config_crc) { 1626 dev_dbg(dev, "Config CRC 0x%06X: OK\n", 1627 data->config_crc); 1628 ret = 0; 1629 goto release_raw; 1630 } else { 1631 dev_info(dev, "Config CRC 0x%06X: does not match file 0x%06X\n", 1632 data->config_crc, config_crc); 1633 } 1634 } else { 1635 dev_warn(dev, 1636 "Warning: Info CRC error - device=0x%06X file=0x%06X\n", 1637 data->info_crc, info_crc); 1638 } 1639 1640 /* Malloc memory to store configuration */ 1641 cfg.start_ofs = MXT_OBJECT_START + 1642 data->info->object_num * sizeof(struct mxt_object) + 1643 MXT_INFO_CHECKSUM_SIZE; 1644 cfg.mem_size = data->mem_size - cfg.start_ofs; 1645 cfg.mem = kzalloc(cfg.mem_size, GFP_KERNEL); 1646 if (!cfg.mem) { 1647 ret = -ENOMEM; 1648 goto release_raw; 1649 } 1650 1651 ret = mxt_prepare_cfg_mem(data, &cfg); 1652 if (ret) 1653 goto release_mem; 1654 1655 /* Calculate crc of the received configs (not the raw config file) */ 1656 if (data->T71_address) 1657 crc_start = data->T71_address; 1658 else if (data->T7_address) 1659 crc_start = data->T7_address; 1660 else 1661 dev_warn(dev, "Could not find CRC start\n"); 1662 1663 if (crc_start > cfg.start_ofs) { 1664 calculated_crc = mxt_calculate_crc(cfg.mem, 1665 crc_start - cfg.start_ofs, 1666 cfg.mem_size); 1667 1668 if (config_crc > 0 && config_crc != calculated_crc) 1669 dev_warn(dev, "Config CRC in file inconsistent, calculated=%06X, file=%06X\n", 1670 calculated_crc, config_crc); 1671 } 1672 1673 ret = mxt_upload_cfg_mem(data, &cfg); 1674 if (ret) 1675 goto release_mem; 1676 1677 mxt_update_crc(data, MXT_COMMAND_BACKUPNV, MXT_BACKUP_VALUE); 1678 1679 ret = mxt_check_retrigen(data); 1680 if (ret) 1681 goto release_mem; 1682 1683 ret = mxt_soft_reset(data); 1684 if (ret) 1685 goto release_mem; 1686 1687 dev_info(dev, "Config successfully updated\n"); 1688 1689 /* T7 config may have changed */ 1690 mxt_init_t7_power_cfg(data); 1691 1692release_mem: 1693 kfree(cfg.mem); 1694release_raw: 1695 kfree(cfg.raw); 1696 return ret; 1697} 1698 1699static void mxt_free_input_device(struct mxt_data *data) 1700{ 1701 if (data->input_dev) { 1702 input_unregister_device(data->input_dev); 1703 data->input_dev = NULL; 1704 } 1705} 1706 1707static void mxt_free_object_table(struct mxt_data *data) 1708{ 1709#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37 1710 video_unregister_device(&data->dbg.vdev); 1711 v4l2_device_unregister(&data->dbg.v4l2); 1712#endif 1713 data->object_table = NULL; 1714 data->info = NULL; 1715 kfree(data->raw_info_block); 1716 data->raw_info_block = NULL; 1717 kfree(data->msg_buf); 1718 data->msg_buf = NULL; 1719 data->T5_address = 0; 1720 data->T5_msg_size = 0; 1721 data->T6_reportid = 0; 1722 data->T7_address = 0; 1723 data->T71_address = 0; 1724 data->T9_reportid_min = 0; 1725 data->T9_reportid_max = 0; 1726 data->T15_reportid_min = 0; 1727 data->T15_reportid_max = 0; 1728 data->T18_address = 0; 1729 data->T19_reportid = 0; 1730 data->T44_address = 0; 1731 data->T97_reportid_min = 0; 1732 data->T97_reportid_max = 0; 1733 data->T100_reportid_min = 0; 1734 data->T100_reportid_max = 0; 1735 data->max_reportid = 0; 1736} 1737 1738static int mxt_parse_object_table(struct mxt_data *data, 1739 struct mxt_object *object_table) 1740{ 1741 struct i2c_client *client = data->client; 1742 int i; 1743 u8 reportid; 1744 u16 end_address; 1745 1746 /* Valid Report IDs start counting from 1 */ 1747 reportid = 1; 1748 data->mem_size = 0; 1749 for (i = 0; i < data->info->object_num; i++) { 1750 struct mxt_object *object = object_table + i; 1751 u8 min_id, max_id; 1752 1753 le16_to_cpus(&object->start_address); 1754 1755 if (object->num_report_ids) { 1756 min_id = reportid; 1757 reportid += object->num_report_ids * 1758 mxt_obj_instances(object); 1759 max_id = reportid - 1; 1760 } else { 1761 min_id = 0; 1762 max_id = 0; 1763 } 1764 1765 dev_dbg(&data->client->dev, 1766 "T%u Start:%u Size:%zu Instances:%zu Report IDs:%u-%u\n", 1767 object->type, object->start_address, 1768 mxt_obj_size(object), mxt_obj_instances(object), 1769 min_id, max_id); 1770 1771 switch (object->type) { 1772 case MXT_GEN_MESSAGE_T5: 1773 if (data->info->family_id == 0x80 && 1774 data->info->version < 0x20) { 1775 /* 1776 * On mXT224 firmware versions prior to V2.0 1777 * read and discard unused CRC byte otherwise 1778 * DMA reads are misaligned. 1779 */ 1780 data->T5_msg_size = mxt_obj_size(object); 1781 } else { 1782 /* CRC not enabled, so skip last byte */ 1783 data->T5_msg_size = mxt_obj_size(object) - 1; 1784 } 1785 data->T5_address = object->start_address; 1786 break; 1787 case MXT_GEN_COMMAND_T6: 1788 data->T6_reportid = min_id; 1789 data->T6_address = object->start_address; 1790 break; 1791 case MXT_GEN_POWER_T7: 1792 data->T7_address = object->start_address; 1793 break; 1794 case MXT_SPT_DYNAMICCONFIGURATIONCONTAINER_T71: 1795 data->T71_address = object->start_address; 1796 break; 1797 case MXT_TOUCH_MULTI_T9: 1798 data->multitouch = MXT_TOUCH_MULTI_T9; 1799 /* Only handle messages from first T9 instance */ 1800 data->T9_reportid_min = min_id; 1801 data->T9_reportid_max = min_id + 1802 object->num_report_ids - 1; 1803 data->num_touchids = object->num_report_ids; 1804 break; 1805 case MXT_TOUCH_KEYARRAY_T15: 1806 data->T15_reportid_min = min_id; 1807 data->T15_reportid_max = max_id; 1808 break; 1809 case MXT_SPT_COMMSCONFIG_T18: 1810 data->T18_address = object->start_address; 1811 break; 1812 case MXT_SPT_MESSAGECOUNT_T44: 1813 data->T44_address = object->start_address; 1814 break; 1815 case MXT_SPT_GPIOPWM_T19: 1816 data->T19_reportid = min_id; 1817 break; 1818 case MXT_TOUCH_PTC_KEYS_T97: 1819 data->T97_reportid_min = min_id; 1820 data->T97_reportid_max = max_id; 1821 break; 1822 case MXT_TOUCH_MULTITOUCHSCREEN_T100: 1823 data->multitouch = MXT_TOUCH_MULTITOUCHSCREEN_T100; 1824 data->T100_reportid_min = min_id; 1825 data->T100_reportid_max = max_id; 1826 /* first two report IDs reserved */ 1827 data->num_touchids = object->num_report_ids - 2; 1828 break; 1829 } 1830 1831 end_address = object->start_address 1832 + mxt_obj_size(object) * mxt_obj_instances(object) - 1; 1833 1834 if (end_address >= data->mem_size) 1835 data->mem_size = end_address + 1; 1836 } 1837 1838 /* Store maximum reportid */ 1839 data->max_reportid = reportid; 1840 1841 /* If T44 exists, T5 position has to be directly after */ 1842 if (data->T44_address && (data->T5_address != data->T44_address + 1)) { 1843 dev_err(&client->dev, "Invalid T44 position\n"); 1844 return -EINVAL; 1845 } 1846 1847 data->msg_buf = kcalloc(data->max_reportid, 1848 data->T5_msg_size, GFP_KERNEL); 1849 if (!data->msg_buf) 1850 return -ENOMEM; 1851 1852 return 0; 1853} 1854 1855static int mxt_read_info_block(struct mxt_data *data) 1856{ 1857 struct i2c_client *client = data->client; 1858 int error; 1859 size_t size; 1860 void *id_buf, *buf; 1861 uint8_t num_objects; 1862 u32 calculated_crc; 1863 u8 *crc_ptr; 1864 1865 /* If info block already allocated, free it */ 1866 if (data->raw_info_block) 1867 mxt_free_object_table(data); 1868 1869 /* Read 7-byte ID information block starting at address 0 */ 1870 size = sizeof(struct mxt_info); 1871 id_buf = kzalloc(size, GFP_KERNEL); 1872 if (!id_buf) 1873 return -ENOMEM; 1874 1875 error = __mxt_read_reg(client, 0, size, id_buf); 1876 if (error) 1877 goto err_free_mem; 1878 1879 /* Resize buffer to give space for rest of info block */ 1880 num_objects = ((struct mxt_info *)id_buf)->object_num; 1881 size += (num_objects * sizeof(struct mxt_object)) 1882 + MXT_INFO_CHECKSUM_SIZE; 1883 1884 buf = krealloc(id_buf, size, GFP_KERNEL); 1885 if (!buf) { 1886 error = -ENOMEM; 1887 goto err_free_mem; 1888 } 1889 id_buf = buf; 1890 1891 /* Read rest of info block */ 1892 error = __mxt_read_reg(client, MXT_OBJECT_START, 1893 size - MXT_OBJECT_START, 1894 id_buf + MXT_OBJECT_START); 1895 if (error) 1896 goto err_free_mem; 1897 1898 /* Extract & calculate checksum */ 1899 crc_ptr = id_buf + size - MXT_INFO_CHECKSUM_SIZE; 1900 data->info_crc = crc_ptr[0] | (crc_ptr[1] << 8) | (crc_ptr[2] << 16); 1901 1902 calculated_crc = mxt_calculate_crc(id_buf, 0, 1903 size - MXT_INFO_CHECKSUM_SIZE); 1904 1905 /* 1906 * CRC mismatch can be caused by data corruption due to I2C comms 1907 * issue or else device is not using Object Based Protocol (eg i2c-hid) 1908 */ 1909 if ((data->info_crc == 0) || (data->info_crc != calculated_crc)) { 1910 dev_err(&client->dev, 1911 "Info Block CRC error calculated=0x%06X read=0x%06X\n", 1912 calculated_crc, data->info_crc); 1913 error = -EIO; 1914 goto err_free_mem; 1915 } 1916 1917 data->raw_info_block = id_buf; 1918 data->info = (struct mxt_info *)id_buf; 1919 1920 dev_info(&client->dev, 1921 "Family: %u Variant: %u Firmware V%u.%u.%02X Objects: %u\n", 1922 data->info->family_id, data->info->variant_id, 1923 data->info->version >> 4, data->info->version & 0xf, 1924 data->info->build, data->info->object_num); 1925 1926 /* Parse object table information */ 1927 error = mxt_parse_object_table(data, id_buf + MXT_OBJECT_START); 1928 if (error) { 1929 dev_err(&client->dev, "Error %d parsing object table\n", error); 1930 mxt_free_object_table(data); 1931 return error; 1932 } 1933 1934 data->object_table = (struct mxt_object *)(id_buf + MXT_OBJECT_START); 1935 1936 return 0; 1937 1938err_free_mem: 1939 kfree(id_buf); 1940 return error; 1941} 1942 1943static int mxt_read_t9_resolution(struct mxt_data *data) 1944{ 1945 struct i2c_client *client = data->client; 1946 int error; 1947 struct t9_range range; 1948 unsigned char orient; 1949 struct mxt_object *object; 1950 1951 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9); 1952 if (!object) 1953 return -EINVAL; 1954 1955 error = __mxt_read_reg(client, 1956 object->start_address + MXT_T9_XSIZE, 1957 sizeof(data->xsize), &data->xsize); 1958 if (error) 1959 return error; 1960 1961 error = __mxt_read_reg(client, 1962 object->start_address + MXT_T9_YSIZE, 1963 sizeof(data->ysize), &data->ysize); 1964 if (error) 1965 return error; 1966 1967 error = __mxt_read_reg(client, 1968 object->start_address + MXT_T9_RANGE, 1969 sizeof(range), &range); 1970 if (error) 1971 return error; 1972 1973 data->max_x = get_unaligned_le16(&range.x); 1974 data->max_y = get_unaligned_le16(&range.y); 1975 1976 error = __mxt_read_reg(client, 1977 object->start_address + MXT_T9_ORIENT, 1978 1, &orient); 1979 if (error) 1980 return error; 1981 1982 data->xy_switch = orient & MXT_T9_ORIENT_SWITCH; 1983 data->invertx = orient & MXT_T9_ORIENT_INVERTX; 1984 data->inverty = orient & MXT_T9_ORIENT_INVERTY; 1985 1986 return 0; 1987} 1988 1989static int mxt_read_t100_config(struct mxt_data *data) 1990{ 1991 struct i2c_client *client = data->client; 1992 int error; 1993 struct mxt_object *object; 1994 u16 range_x, range_y; 1995 u8 cfg, tchaux; 1996 u8 aux; 1997 1998 object = mxt_get_object(data, MXT_TOUCH_MULTITOUCHSCREEN_T100); 1999 if (!object) 2000 return -EINVAL; 2001 2002 /* read touchscreen dimensions */ 2003 error = __mxt_read_reg(client, 2004 object->start_address + MXT_T100_XRANGE, 2005 sizeof(range_x), &range_x); 2006 if (error) 2007 return error; 2008 2009 data->max_x = get_unaligned_le16(&range_x); 2010 2011 error = __mxt_read_reg(client, 2012 object->start_address + MXT_T100_YRANGE, 2013 sizeof(range_y), &range_y); 2014 if (error) 2015 return error; 2016 2017 data->max_y = get_unaligned_le16(&range_y); 2018 2019 error = __mxt_read_reg(client, 2020 object->start_address + MXT_T100_XSIZE, 2021 sizeof(data->xsize), &data->xsize); 2022 if (error) 2023 return error; 2024 2025 error = __mxt_read_reg(client, 2026 object->start_address + MXT_T100_YSIZE, 2027 sizeof(data->ysize), &data->ysize); 2028 if (error) 2029 return error; 2030 2031 /* read orientation config */ 2032 error = __mxt_read_reg(client, 2033 object->start_address + MXT_T100_CFG1, 2034 1, &cfg); 2035 if (error) 2036 return error; 2037 2038 data->xy_switch = cfg & MXT_T100_CFG_SWITCHXY; 2039 data->invertx = cfg & MXT_T100_CFG_INVERTX; 2040 data->inverty = cfg & MXT_T100_CFG_INVERTY; 2041 2042 /* allocate aux bytes */ 2043 error = __mxt_read_reg(client, 2044 object->start_address + MXT_T100_TCHAUX, 2045 1, &tchaux); 2046 if (error) 2047 return error; 2048 2049 aux = 6; 2050 2051 if (tchaux & MXT_T100_TCHAUX_VECT) 2052 data->t100_aux_vect = aux++; 2053 2054 if (tchaux & MXT_T100_TCHAUX_AMPL) 2055 data->t100_aux_ampl = aux++; 2056 2057 if (tchaux & MXT_T100_TCHAUX_AREA) 2058 data->t100_aux_area = aux++; 2059 2060 dev_dbg(&client->dev, 2061 "T100 aux mappings vect:%u ampl:%u area:%u\n", 2062 data->t100_aux_vect, data->t100_aux_ampl, data->t100_aux_area); 2063 2064 return 0; 2065} 2066 2067static int mxt_input_open(struct input_dev *dev); 2068static void mxt_input_close(struct input_dev *dev); 2069 2070static void mxt_set_up_as_touchpad(struct input_dev *input_dev, 2071 struct mxt_data *data) 2072{ 2073 int i; 2074 2075 input_dev->name = "Atmel maXTouch Touchpad"; 2076 2077 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit); 2078 2079 input_abs_set_res(input_dev, ABS_X, MXT_PIXELS_PER_MM); 2080 input_abs_set_res(input_dev, ABS_Y, MXT_PIXELS_PER_MM); 2081 input_abs_set_res(input_dev, ABS_MT_POSITION_X, 2082 MXT_PIXELS_PER_MM); 2083 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, 2084 MXT_PIXELS_PER_MM); 2085 2086 for (i = 0; i < data->t19_num_keys; i++) 2087 if (data->t19_keymap[i] != KEY_RESERVED) 2088 input_set_capability(input_dev, EV_KEY, 2089 data->t19_keymap[i]); 2090} 2091 2092static int mxt_initialize_input_device(struct mxt_data *data) 2093{ 2094 struct device *dev = &data->client->dev; 2095 struct input_dev *input_dev; 2096 int error; 2097 unsigned int num_mt_slots; 2098 unsigned int mt_flags = 0; 2099 int i; 2100 2101 switch (data->multitouch) { 2102 case MXT_TOUCH_MULTI_T9: 2103 num_mt_slots = data->T9_reportid_max - data->T9_reportid_min + 1; 2104 error = mxt_read_t9_resolution(data); 2105 if (error) 2106 dev_warn(dev, "Failed to initialize T9 resolution\n"); 2107 break; 2108 2109 case MXT_TOUCH_MULTITOUCHSCREEN_T100: 2110 num_mt_slots = data->num_touchids; 2111 error = mxt_read_t100_config(data); 2112 if (error) 2113 dev_warn(dev, "Failed to read T100 config\n"); 2114 break; 2115 2116 default: 2117 dev_err(dev, "Invalid multitouch object\n"); 2118 return -EINVAL; 2119 } 2120 2121 /* Handle default values and orientation switch */ 2122 if (data->max_x == 0) 2123 data->max_x = 1023; 2124 2125 if (data->max_y == 0) 2126 data->max_y = 1023; 2127 2128 if (data->xy_switch) 2129 swap(data->max_x, data->max_y); 2130 2131 dev_info(dev, "Touchscreen size X%uY%u\n", data->max_x, data->max_y); 2132 2133 /* Register input device */ 2134 input_dev = input_allocate_device(); 2135 if (!input_dev) 2136 return -ENOMEM; 2137 2138 input_dev->name = "Atmel maXTouch Touchscreen"; 2139 input_dev->phys = data->phys; 2140 input_dev->id.bustype = BUS_I2C; 2141 input_dev->dev.parent = dev; 2142 input_dev->open = mxt_input_open; 2143 input_dev->close = mxt_input_close; 2144 2145 input_dev->keycode = data->t15_keymap; 2146 input_dev->keycodemax = data->t15_num_keys; 2147 input_dev->keycodesize = sizeof(data->t15_keymap[0]); 2148 2149 input_set_capability(input_dev, EV_KEY, BTN_TOUCH); 2150 2151 /* For single touch */ 2152 input_set_abs_params(input_dev, ABS_X, 0, data->max_x, 0, 0); 2153 input_set_abs_params(input_dev, ABS_Y, 0, data->max_y, 0, 0); 2154 2155 if (data->multitouch == MXT_TOUCH_MULTI_T9 || 2156 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 && 2157 data->t100_aux_ampl)) { 2158 input_set_abs_params(input_dev, ABS_PRESSURE, 0, 255, 0, 0); 2159 } 2160 2161 /* If device has buttons we assume it is a touchpad */ 2162 if (data->t19_num_keys) { 2163 mxt_set_up_as_touchpad(input_dev, data); 2164 mt_flags |= INPUT_MT_POINTER; 2165 } else { 2166 mt_flags |= INPUT_MT_DIRECT; 2167 } 2168 2169 /* For multi touch */ 2170 error = input_mt_init_slots(input_dev, num_mt_slots, mt_flags); 2171 if (error) { 2172 dev_err(dev, "Error %d initialising slots\n", error); 2173 goto err_free_mem; 2174 } 2175 2176 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100) { 2177 input_set_abs_params(input_dev, ABS_MT_TOOL_TYPE, 2178 0, MT_TOOL_MAX, 0, 0); 2179 input_set_abs_params(input_dev, ABS_MT_DISTANCE, 2180 MXT_DISTANCE_ACTIVE_TOUCH, 2181 MXT_DISTANCE_HOVERING, 2182 0, 0); 2183 } 2184 2185 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 2186 0, data->max_x, 0, 0); 2187 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 2188 0, data->max_y, 0, 0); 2189 2190 if (data->multitouch == MXT_TOUCH_MULTI_T9 || 2191 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 && 2192 data->t100_aux_area)) { 2193 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 2194 0, MXT_MAX_AREA, 0, 0); 2195 } 2196 2197 if (data->multitouch == MXT_TOUCH_MULTI_T9 || 2198 (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 && 2199 data->t100_aux_ampl)) { 2200 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 2201 0, 255, 0, 0); 2202 } 2203 2204 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 && 2205 data->t100_aux_vect) { 2206 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 2207 0, 255, 0, 0); 2208 } 2209 2210 if (data->multitouch == MXT_TOUCH_MULTITOUCHSCREEN_T100 && 2211 data->t100_aux_vect) { 2212 input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 2213 0, 255, 0, 0); 2214 } 2215 2216 touchscreen_parse_properties(input_dev, true, &data->prop); 2217 2218 /* For T15 and T97 Key Array */ 2219 if (data->T15_reportid_min || data->T97_reportid_min) { 2220 for (i = 0; i < data->t15_num_keys; i++) 2221 input_set_capability(input_dev, 2222 EV_KEY, data->t15_keymap[i]); 2223 } 2224 2225 input_set_drvdata(input_dev, data); 2226 2227 error = input_register_device(input_dev); 2228 if (error) { 2229 dev_err(dev, "Error %d registering input device\n", error); 2230 goto err_free_mem; 2231 } 2232 2233 data->input_dev = input_dev; 2234 2235 return 0; 2236 2237err_free_mem: 2238 input_free_device(input_dev); 2239 return error; 2240} 2241 2242static int mxt_configure_objects(struct mxt_data *data, 2243 const struct firmware *cfg); 2244 2245static void mxt_config_cb(const struct firmware *cfg, void *ctx) 2246{ 2247 mxt_configure_objects(ctx, cfg); 2248 release_firmware(cfg); 2249} 2250 2251static int mxt_initialize(struct mxt_data *data) 2252{ 2253 struct i2c_client *client = data->client; 2254 int recovery_attempts = 0; 2255 int error; 2256 2257 while (1) { 2258 error = mxt_read_info_block(data); 2259 if (!error) 2260 break; 2261 2262 /* Check bootloader state */ 2263 error = mxt_probe_bootloader(data, false); 2264 if (error) { 2265 dev_info(&client->dev, "Trying alternate bootloader address\n"); 2266 error = mxt_probe_bootloader(data, true); 2267 if (error) { 2268 /* Chip is not in appmode or bootloader mode */ 2269 return error; 2270 } 2271 } 2272 2273 /* OK, we are in bootloader, see if we can recover */ 2274 if (++recovery_attempts > 1) { 2275 dev_err(&client->dev, "Could not recover from bootloader mode\n"); 2276 /* 2277 * We can reflash from this state, so do not 2278 * abort initialization. 2279 */ 2280 data->in_bootloader = true; 2281 return 0; 2282 } 2283 2284 /* Attempt to exit bootloader into app mode */ 2285 mxt_send_bootloader_cmd(data, false); 2286 msleep(MXT_FW_RESET_TIME); 2287 } 2288 2289 error = mxt_check_retrigen(data); 2290 if (error) 2291 return error; 2292 2293 error = mxt_acquire_irq(data); 2294 if (error) 2295 return error; 2296 2297 error = request_firmware_nowait(THIS_MODULE, true, MXT_CFG_NAME, 2298 &client->dev, GFP_KERNEL, data, 2299 mxt_config_cb); 2300 if (error) { 2301 dev_err(&client->dev, "Failed to invoke firmware loader: %d\n", 2302 error); 2303 return error; 2304 } 2305 2306 return 0; 2307} 2308 2309static int mxt_set_t7_power_cfg(struct mxt_data *data, u8 sleep) 2310{ 2311 struct device *dev = &data->client->dev; 2312 int error; 2313 struct t7_config *new_config; 2314 struct t7_config deepsleep = { .active = 0, .idle = 0 }; 2315 2316 if (sleep == MXT_POWER_CFG_DEEPSLEEP) 2317 new_config = &deepsleep; 2318 else 2319 new_config = &data->t7_cfg; 2320 2321 error = __mxt_write_reg(data->client, data->T7_address, 2322 sizeof(data->t7_cfg), new_config); 2323 if (error) 2324 return error; 2325 2326 dev_dbg(dev, "Set T7 ACTV:%d IDLE:%d\n", 2327 new_config->active, new_config->idle); 2328 2329 return 0; 2330} 2331 2332static int mxt_init_t7_power_cfg(struct mxt_data *data) 2333{ 2334 struct device *dev = &data->client->dev; 2335 int error; 2336 bool retry = false; 2337 2338recheck: 2339 error = __mxt_read_reg(data->client, data->T7_address, 2340 sizeof(data->t7_cfg), &data->t7_cfg); 2341 if (error) 2342 return error; 2343 2344 if (data->t7_cfg.active == 0 || data->t7_cfg.idle == 0) { 2345 if (!retry) { 2346 dev_dbg(dev, "T7 cfg zero, resetting\n"); 2347 mxt_soft_reset(data); 2348 retry = true; 2349 goto recheck; 2350 } else { 2351 dev_dbg(dev, "T7 cfg zero after reset, overriding\n"); 2352 data->t7_cfg.active = 20; 2353 data->t7_cfg.idle = 100; 2354 return mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN); 2355 } 2356 } 2357 2358 dev_dbg(dev, "Initialized power cfg: ACTV %d, IDLE %d\n", 2359 data->t7_cfg.active, data->t7_cfg.idle); 2360 return 0; 2361} 2362 2363#ifdef CONFIG_TOUCHSCREEN_ATMEL_MXT_T37 2364static const struct v4l2_file_operations mxt_video_fops = { 2365 .owner = THIS_MODULE, 2366 .open = v4l2_fh_open, 2367 .release = vb2_fop_release, 2368 .unlocked_ioctl = video_ioctl2, 2369 .read = vb2_fop_read, 2370 .mmap = vb2_fop_mmap, 2371 .poll = vb2_fop_poll, 2372}; 2373 2374static u16 mxt_get_debug_value(struct mxt_data *data, unsigned int x, 2375 unsigned int y) 2376{ 2377 struct mxt_info *info = data->info; 2378 struct mxt_dbg *dbg = &data->dbg; 2379 unsigned int ofs, page; 2380 unsigned int col = 0; 2381 unsigned int col_width; 2382 2383 if (info->family_id == MXT_FAMILY_1386) { 2384 col_width = info->matrix_ysize / MXT1386_COLUMNS; 2385 col = y / col_width; 2386 y = y % col_width; 2387 } else { 2388 col_width = info->matrix_ysize; 2389 } 2390 2391 ofs = (y + (x * col_width)) * sizeof(u16); 2392 page = ofs / MXT_DIAGNOSTIC_SIZE; 2393 ofs %= MXT_DIAGNOSTIC_SIZE; 2394 2395 if (info->family_id == MXT_FAMILY_1386) 2396 page += col * MXT1386_PAGES_PER_COLUMN; 2397 2398 return get_unaligned_le16(&dbg->t37_buf[page].data[ofs]); 2399} 2400 2401static int mxt_convert_debug_pages(struct mxt_data *data, u16 *outbuf) 2402{ 2403 struct mxt_dbg *dbg = &data->dbg; 2404 unsigned int x = 0; 2405 unsigned int y = 0; 2406 unsigned int i, rx, ry; 2407 2408 for (i = 0; i < dbg->t37_nodes; i++) { 2409 /* Handle orientation */ 2410 rx = data->xy_switch ? y : x; 2411 ry = data->xy_switch ? x : y; 2412 rx = data->invertx ? (data->xsize - 1 - rx) : rx; 2413 ry = data->inverty ? (data->ysize - 1 - ry) : ry; 2414 2415 outbuf[i] = mxt_get_debug_value(data, rx, ry); 2416 2417 /* Next value */ 2418 if (++x >= (data->xy_switch ? data->ysize : data->xsize)) { 2419 x = 0; 2420 y++; 2421 } 2422 } 2423 2424 return 0; 2425} 2426 2427static int mxt_read_diagnostic_debug(struct mxt_data *data, u8 mode, 2428 u16 *outbuf) 2429{ 2430 struct mxt_dbg *dbg = &data->dbg; 2431 int retries = 0; 2432 int page; 2433 int ret; 2434 u8 cmd = mode; 2435 struct t37_debug *p; 2436 u8 cmd_poll; 2437 2438 for (page = 0; page < dbg->t37_pages; page++) { 2439 p = dbg->t37_buf + page; 2440 2441 ret = mxt_write_reg(data->client, dbg->diag_cmd_address, 2442 cmd); 2443 if (ret) 2444 return ret; 2445 2446 retries = 0; 2447 msleep(20); 2448wait_cmd: 2449 /* Read back command byte */ 2450 ret = __mxt_read_reg(data->client, dbg->diag_cmd_address, 2451 sizeof(cmd_poll), &cmd_poll); 2452 if (ret) 2453 return ret; 2454 2455 /* Field is cleared once the command has been processed */ 2456 if (cmd_poll) { 2457 if (retries++ > 100) 2458 return -EINVAL; 2459 2460 msleep(20); 2461 goto wait_cmd; 2462 } 2463 2464 /* Read T37 page */ 2465 ret = __mxt_read_reg(data->client, dbg->t37_address, 2466 sizeof(struct t37_debug), p); 2467 if (ret) 2468 return ret; 2469 2470 if (p->mode != mode || p->page != page) { 2471 dev_err(&data->client->dev, "T37 page mismatch\n"); 2472 return -EINVAL; 2473 } 2474 2475 dev_dbg(&data->client->dev, "%s page:%d retries:%d\n", 2476 __func__, page, retries); 2477 2478 /* For remaining pages, write PAGEUP rather than mode */ 2479 cmd = MXT_DIAGNOSTIC_PAGEUP; 2480 } 2481 2482 return mxt_convert_debug_pages(data, outbuf); 2483} 2484 2485static int mxt_queue_setup(struct vb2_queue *q, 2486 unsigned int *nbuffers, unsigned int *nplanes, 2487 unsigned int sizes[], struct device *alloc_devs[]) 2488{ 2489 struct mxt_data *data = q->drv_priv; 2490 size_t size = data->dbg.t37_nodes * sizeof(u16); 2491 2492 if (*nplanes) 2493 return sizes[0] < size ? -EINVAL : 0; 2494 2495 *nplanes = 1; 2496 sizes[0] = size; 2497 2498 return 0; 2499} 2500 2501static void mxt_buffer_queue(struct vb2_buffer *vb) 2502{ 2503 struct mxt_data *data = vb2_get_drv_priv(vb->vb2_queue); 2504 u16 *ptr; 2505 int ret; 2506 u8 mode; 2507 2508 ptr = vb2_plane_vaddr(vb, 0); 2509 if (!ptr) { 2510 dev_err(&data->client->dev, "Error acquiring frame ptr\n"); 2511 goto fault; 2512 } 2513 2514 switch (data->dbg.input) { 2515 case MXT_V4L_INPUT_DELTAS: 2516 default: 2517 mode = MXT_DIAGNOSTIC_DELTAS; 2518 break; 2519 2520 case MXT_V4L_INPUT_REFS: 2521 mode = MXT_DIAGNOSTIC_REFS; 2522 break; 2523 } 2524 2525 ret = mxt_read_diagnostic_debug(data, mode, ptr); 2526 if (ret) 2527 goto fault; 2528 2529 vb2_set_plane_payload(vb, 0, data->dbg.t37_nodes * sizeof(u16)); 2530 vb2_buffer_done(vb, VB2_BUF_STATE_DONE); 2531 return; 2532 2533fault: 2534 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR); 2535} 2536 2537/* V4L2 structures */ 2538static const struct vb2_ops mxt_queue_ops = { 2539 .queue_setup = mxt_queue_setup, 2540 .buf_queue = mxt_buffer_queue, 2541}; 2542 2543static const struct vb2_queue mxt_queue = { 2544 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, 2545 .io_modes = VB2_MMAP | VB2_USERPTR | VB2_DMABUF | VB2_READ, 2546 .buf_struct_size = sizeof(struct mxt_vb2_buffer), 2547 .ops = &mxt_queue_ops, 2548 .mem_ops = &vb2_vmalloc_memops, 2549 .timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC, 2550 .min_queued_buffers = 1, 2551}; 2552 2553static int mxt_vidioc_querycap(struct file *file, void *priv, 2554 struct v4l2_capability *cap) 2555{ 2556 struct mxt_data *data = video_drvdata(file); 2557 2558 strscpy(cap->driver, "atmel_mxt_ts", sizeof(cap->driver)); 2559 strscpy(cap->card, "atmel_mxt_ts touch", sizeof(cap->card)); 2560 snprintf(cap->bus_info, sizeof(cap->bus_info), 2561 "I2C:%s", dev_name(&data->client->dev)); 2562 return 0; 2563} 2564 2565static int mxt_vidioc_enum_input(struct file *file, void *priv, 2566 struct v4l2_input *i) 2567{ 2568 if (i->index >= MXT_V4L_INPUT_MAX) 2569 return -EINVAL; 2570 2571 i->type = V4L2_INPUT_TYPE_TOUCH; 2572 2573 switch (i->index) { 2574 case MXT_V4L_INPUT_REFS: 2575 strscpy(i->name, "Mutual Capacitance References", 2576 sizeof(i->name)); 2577 break; 2578 case MXT_V4L_INPUT_DELTAS: 2579 strscpy(i->name, "Mutual Capacitance Deltas", sizeof(i->name)); 2580 break; 2581 } 2582 2583 return 0; 2584} 2585 2586static int mxt_set_input(struct mxt_data *data, unsigned int i) 2587{ 2588 struct v4l2_pix_format *f = &data->dbg.format; 2589 2590 if (i >= MXT_V4L_INPUT_MAX) 2591 return -EINVAL; 2592 2593 if (i == MXT_V4L_INPUT_DELTAS) 2594 f->pixelformat = V4L2_TCH_FMT_DELTA_TD16; 2595 else 2596 f->pixelformat = V4L2_TCH_FMT_TU16; 2597 2598 f->width = data->xy_switch ? data->ysize : data->xsize; 2599 f->height = data->xy_switch ? data->xsize : data->ysize; 2600 f->field = V4L2_FIELD_NONE; 2601 f->colorspace = V4L2_COLORSPACE_RAW; 2602 f->bytesperline = f->width * sizeof(u16); 2603 f->sizeimage = f->width * f->height * sizeof(u16); 2604 2605 data->dbg.input = i; 2606 2607 return 0; 2608} 2609 2610static int mxt_vidioc_s_input(struct file *file, void *priv, unsigned int i) 2611{ 2612 return mxt_set_input(video_drvdata(file), i); 2613} 2614 2615static int mxt_vidioc_g_input(struct file *file, void *priv, unsigned int *i) 2616{ 2617 struct mxt_data *data = video_drvdata(file); 2618 2619 *i = data->dbg.input; 2620 2621 return 0; 2622} 2623 2624static int mxt_vidioc_fmt(struct file *file, void *priv, struct v4l2_format *f) 2625{ 2626 struct mxt_data *data = video_drvdata(file); 2627 2628 f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 2629 f->fmt.pix = data->dbg.format; 2630 2631 return 0; 2632} 2633 2634static int mxt_vidioc_enum_fmt(struct file *file, void *priv, 2635 struct v4l2_fmtdesc *fmt) 2636{ 2637 if (fmt->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2638 return -EINVAL; 2639 2640 switch (fmt->index) { 2641 case 0: 2642 fmt->pixelformat = V4L2_TCH_FMT_TU16; 2643 break; 2644 2645 case 1: 2646 fmt->pixelformat = V4L2_TCH_FMT_DELTA_TD16; 2647 break; 2648 2649 default: 2650 return -EINVAL; 2651 } 2652 2653 return 0; 2654} 2655 2656static int mxt_vidioc_g_parm(struct file *file, void *fh, 2657 struct v4l2_streamparm *a) 2658{ 2659 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 2660 return -EINVAL; 2661 2662 a->parm.capture.readbuffers = 1; 2663 a->parm.capture.timeperframe.numerator = 1; 2664 a->parm.capture.timeperframe.denominator = 10; 2665 return 0; 2666} 2667 2668static const struct v4l2_ioctl_ops mxt_video_ioctl_ops = { 2669 .vidioc_querycap = mxt_vidioc_querycap, 2670 2671 .vidioc_enum_fmt_vid_cap = mxt_vidioc_enum_fmt, 2672 .vidioc_s_fmt_vid_cap = mxt_vidioc_fmt, 2673 .vidioc_g_fmt_vid_cap = mxt_vidioc_fmt, 2674 .vidioc_try_fmt_vid_cap = mxt_vidioc_fmt, 2675 .vidioc_g_parm = mxt_vidioc_g_parm, 2676 2677 .vidioc_enum_input = mxt_vidioc_enum_input, 2678 .vidioc_g_input = mxt_vidioc_g_input, 2679 .vidioc_s_input = mxt_vidioc_s_input, 2680 2681 .vidioc_reqbufs = vb2_ioctl_reqbufs, 2682 .vidioc_create_bufs = vb2_ioctl_create_bufs, 2683 .vidioc_querybuf = vb2_ioctl_querybuf, 2684 .vidioc_qbuf = vb2_ioctl_qbuf, 2685 .vidioc_dqbuf = vb2_ioctl_dqbuf, 2686 .vidioc_expbuf = vb2_ioctl_expbuf, 2687 2688 .vidioc_streamon = vb2_ioctl_streamon, 2689 .vidioc_streamoff = vb2_ioctl_streamoff, 2690}; 2691 2692static const struct video_device mxt_video_device = { 2693 .name = "Atmel maxTouch", 2694 .fops = &mxt_video_fops, 2695 .ioctl_ops = &mxt_video_ioctl_ops, 2696 .release = video_device_release_empty, 2697 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_TOUCH | 2698 V4L2_CAP_READWRITE | V4L2_CAP_STREAMING, 2699}; 2700 2701static void mxt_debug_init(struct mxt_data *data) 2702{ 2703 struct mxt_info *info = data->info; 2704 struct mxt_dbg *dbg = &data->dbg; 2705 struct mxt_object *object; 2706 int error; 2707 2708 object = mxt_get_object(data, MXT_GEN_COMMAND_T6); 2709 if (!object) 2710 goto error; 2711 2712 dbg->diag_cmd_address = object->start_address + MXT_COMMAND_DIAGNOSTIC; 2713 2714 object = mxt_get_object(data, MXT_DEBUG_DIAGNOSTIC_T37); 2715 if (!object) 2716 goto error; 2717 2718 if (mxt_obj_size(object) != sizeof(struct t37_debug)) { 2719 dev_warn(&data->client->dev, "Bad T37 size"); 2720 goto error; 2721 } 2722 2723 dbg->t37_address = object->start_address; 2724 2725 /* Calculate size of data and allocate buffer */ 2726 dbg->t37_nodes = data->xsize * data->ysize; 2727 2728 if (info->family_id == MXT_FAMILY_1386) 2729 dbg->t37_pages = MXT1386_COLUMNS * MXT1386_PAGES_PER_COLUMN; 2730 else 2731 dbg->t37_pages = DIV_ROUND_UP(data->xsize * 2732 info->matrix_ysize * 2733 sizeof(u16), 2734 sizeof(dbg->t37_buf->data)); 2735 2736 dbg->t37_buf = devm_kmalloc_array(&data->client->dev, dbg->t37_pages, 2737 sizeof(struct t37_debug), GFP_KERNEL); 2738 if (!dbg->t37_buf) 2739 goto error; 2740 2741 /* init channel to zero */ 2742 mxt_set_input(data, 0); 2743 2744 /* register video device */ 2745 snprintf(dbg->v4l2.name, sizeof(dbg->v4l2.name), "%s", "atmel_mxt_ts"); 2746 error = v4l2_device_register(&data->client->dev, &dbg->v4l2); 2747 if (error) 2748 goto error; 2749 2750 /* initialize the queue */ 2751 mutex_init(&dbg->lock); 2752 dbg->queue = mxt_queue; 2753 dbg->queue.drv_priv = data; 2754 dbg->queue.lock = &dbg->lock; 2755 dbg->queue.dev = &data->client->dev; 2756 2757 error = vb2_queue_init(&dbg->queue); 2758 if (error) 2759 goto error_unreg_v4l2; 2760 2761 dbg->vdev = mxt_video_device; 2762 dbg->vdev.v4l2_dev = &dbg->v4l2; 2763 dbg->vdev.lock = &dbg->lock; 2764 dbg->vdev.vfl_dir = VFL_DIR_RX; 2765 dbg->vdev.queue = &dbg->queue; 2766 video_set_drvdata(&dbg->vdev, data); 2767 2768 error = video_register_device(&dbg->vdev, VFL_TYPE_TOUCH, -1); 2769 if (error) 2770 goto error_unreg_v4l2; 2771 2772 return; 2773 2774error_unreg_v4l2: 2775 v4l2_device_unregister(&dbg->v4l2); 2776error: 2777 dev_warn(&data->client->dev, "Error initializing T37\n"); 2778} 2779#else 2780static void mxt_debug_init(struct mxt_data *data) 2781{ 2782} 2783#endif 2784 2785static int mxt_configure_objects(struct mxt_data *data, 2786 const struct firmware *cfg) 2787{ 2788 struct device *dev = &data->client->dev; 2789 int error; 2790 2791 error = mxt_init_t7_power_cfg(data); 2792 if (error) { 2793 dev_err(dev, "Failed to initialize power cfg\n"); 2794 return error; 2795 } 2796 2797 if (cfg) { 2798 error = mxt_update_cfg(data, cfg); 2799 if (error) 2800 dev_warn(dev, "Error %d updating config\n", error); 2801 } 2802 2803 if (data->multitouch) { 2804 error = mxt_initialize_input_device(data); 2805 if (error) 2806 return error; 2807 } else { 2808 dev_warn(dev, "No touch object detected\n"); 2809 } 2810 2811 mxt_debug_init(data); 2812 2813 return 0; 2814} 2815 2816/* Firmware Version is returned as Major.Minor.Build */ 2817static ssize_t mxt_fw_version_show(struct device *dev, 2818 struct device_attribute *attr, char *buf) 2819{ 2820 struct mxt_data *data = dev_get_drvdata(dev); 2821 struct mxt_info *info = data->info; 2822 return sysfs_emit(buf, "%u.%u.%02X\n", 2823 info->version >> 4, info->version & 0xf, info->build); 2824} 2825 2826/* Hardware Version is returned as FamilyID.VariantID */ 2827static ssize_t mxt_hw_version_show(struct device *dev, 2828 struct device_attribute *attr, char *buf) 2829{ 2830 struct mxt_data *data = dev_get_drvdata(dev); 2831 struct mxt_info *info = data->info; 2832 return sysfs_emit(buf, "%u.%u\n", info->family_id, info->variant_id); 2833} 2834 2835static ssize_t mxt_show_instance(char *buf, int count, 2836 struct mxt_object *object, int instance, 2837 const u8 *val) 2838{ 2839 int i; 2840 2841 if (mxt_obj_instances(object) > 1) 2842 count += sysfs_emit_at(buf, count, "Instance %u\n", instance); 2843 2844 for (i = 0; i < mxt_obj_size(object); i++) 2845 count += sysfs_emit_at(buf, count, "\t[%2u]: %02x (%d)\n", 2846 i, val[i], val[i]); 2847 count += sysfs_emit_at(buf, count, "\n"); 2848 2849 return count; 2850} 2851 2852static ssize_t mxt_object_show(struct device *dev, 2853 struct device_attribute *attr, char *buf) 2854{ 2855 struct mxt_data *data = dev_get_drvdata(dev); 2856 struct mxt_object *object; 2857 int count = 0; 2858 int i, j; 2859 int error; 2860 u8 *obuf; 2861 2862 /* Pre-allocate buffer large enough to hold max sized object. */ 2863 obuf = kmalloc(256, GFP_KERNEL); 2864 if (!obuf) 2865 return -ENOMEM; 2866 2867 error = 0; 2868 for (i = 0; i < data->info->object_num; i++) { 2869 object = data->object_table + i; 2870 2871 if (!mxt_object_readable(object->type)) 2872 continue; 2873 2874 count += sysfs_emit_at(buf, count, "T%u:\n", object->type); 2875 2876 for (j = 0; j < mxt_obj_instances(object); j++) { 2877 u16 size = mxt_obj_size(object); 2878 u16 addr = object->start_address + j * size; 2879 2880 error = __mxt_read_reg(data->client, addr, size, obuf); 2881 if (error) 2882 goto done; 2883 2884 count = mxt_show_instance(buf, count, object, j, obuf); 2885 } 2886 } 2887 2888done: 2889 kfree(obuf); 2890 return error ?: count; 2891} 2892 2893static int mxt_check_firmware_format(struct device *dev, 2894 const struct firmware *fw) 2895{ 2896 unsigned int pos = 0; 2897 char c; 2898 2899 while (pos < fw->size) { 2900 c = *(fw->data + pos); 2901 2902 if (c < '0' || (c > '9' && c < 'A') || c > 'F') 2903 return 0; 2904 2905 pos++; 2906 } 2907 2908 /* 2909 * To convert file try: 2910 * xxd -r -p mXTXXX__APP_VX-X-XX.enc > maxtouch.fw 2911 */ 2912 dev_err(dev, "Aborting: firmware file must be in binary format\n"); 2913 2914 return -EINVAL; 2915} 2916 2917static int mxt_load_fw(struct device *dev, const char *fn) 2918{ 2919 struct mxt_data *data = dev_get_drvdata(dev); 2920 const struct firmware *fw = NULL; 2921 unsigned int frame_size; 2922 unsigned int pos = 0; 2923 unsigned int retry = 0; 2924 unsigned int frame = 0; 2925 int ret; 2926 2927 ret = request_firmware(&fw, fn, dev); 2928 if (ret) { 2929 dev_err(dev, "Unable to open firmware %s\n", fn); 2930 return ret; 2931 } 2932 2933 /* Check for incorrect enc file */ 2934 ret = mxt_check_firmware_format(dev, fw); 2935 if (ret) 2936 goto release_firmware; 2937 2938 if (!data->in_bootloader) { 2939 /* Change to the bootloader mode */ 2940 data->in_bootloader = true; 2941 2942 ret = mxt_t6_command(data, MXT_COMMAND_RESET, 2943 MXT_BOOT_VALUE, false); 2944 if (ret) 2945 goto release_firmware; 2946 2947 msleep(MXT_RESET_TIME); 2948 2949 /* Do not need to scan since we know family ID */ 2950 ret = mxt_lookup_bootloader_address(data, 0); 2951 if (ret) 2952 goto release_firmware; 2953 2954 mxt_free_input_device(data); 2955 mxt_free_object_table(data); 2956 } else { 2957 enable_irq(data->irq); 2958 } 2959 2960 reinit_completion(&data->bl_completion); 2961 2962 ret = mxt_check_bootloader(data, MXT_WAITING_BOOTLOAD_CMD, false); 2963 if (ret) { 2964 /* Bootloader may still be unlocked from previous attempt */ 2965 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, false); 2966 if (ret) 2967 goto disable_irq; 2968 } else { 2969 dev_info(dev, "Unlocking bootloader\n"); 2970 2971 /* Unlock bootloader */ 2972 ret = mxt_send_bootloader_cmd(data, true); 2973 if (ret) 2974 goto disable_irq; 2975 } 2976 2977 while (pos < fw->size) { 2978 ret = mxt_check_bootloader(data, MXT_WAITING_FRAME_DATA, true); 2979 if (ret) 2980 goto disable_irq; 2981 2982 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1)); 2983 2984 /* Take account of CRC bytes */ 2985 frame_size += 2; 2986 2987 /* Write one frame to device */ 2988 ret = mxt_bootloader_write(data, fw->data + pos, frame_size); 2989 if (ret) 2990 goto disable_irq; 2991 2992 ret = mxt_check_bootloader(data, MXT_FRAME_CRC_PASS, true); 2993 if (ret) { 2994 retry++; 2995 2996 /* Back off by 20ms per retry */ 2997 msleep(retry * 20); 2998 2999 if (retry > 20) { 3000 dev_err(dev, "Retry count exceeded\n"); 3001 goto disable_irq; 3002 } 3003 } else { 3004 retry = 0; 3005 pos += frame_size; 3006 frame++; 3007 } 3008 3009 if (frame % 50 == 0) 3010 dev_dbg(dev, "Sent %d frames, %d/%zd bytes\n", 3011 frame, pos, fw->size); 3012 } 3013 3014 /* Wait for flash. */ 3015 ret = mxt_wait_for_completion(data, &data->bl_completion, 3016 MXT_FW_RESET_TIME); 3017 if (ret) 3018 goto disable_irq; 3019 3020 dev_dbg(dev, "Sent %d frames, %d bytes\n", frame, pos); 3021 3022 /* 3023 * Wait for device to reset. Some bootloader versions do not assert 3024 * the CHG line after bootloading has finished, so ignore potential 3025 * errors. 3026 */ 3027 mxt_wait_for_completion(data, &data->bl_completion, MXT_FW_RESET_TIME); 3028 3029 data->in_bootloader = false; 3030 3031disable_irq: 3032 disable_irq(data->irq); 3033release_firmware: 3034 release_firmware(fw); 3035 return ret; 3036} 3037 3038static ssize_t mxt_update_fw_store(struct device *dev, 3039 struct device_attribute *attr, 3040 const char *buf, size_t count) 3041{ 3042 struct mxt_data *data = dev_get_drvdata(dev); 3043 int error; 3044 3045 error = mxt_load_fw(dev, MXT_FW_NAME); 3046 if (error) { 3047 dev_err(dev, "The firmware update failed(%d)\n", error); 3048 count = error; 3049 } else { 3050 dev_info(dev, "The firmware update succeeded\n"); 3051 3052 error = mxt_initialize(data); 3053 if (error) 3054 return error; 3055 } 3056 3057 return count; 3058} 3059 3060static DEVICE_ATTR(fw_version, S_IRUGO, mxt_fw_version_show, NULL); 3061static DEVICE_ATTR(hw_version, S_IRUGO, mxt_hw_version_show, NULL); 3062static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL); 3063static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store); 3064 3065static struct attribute *mxt_attrs[] = { 3066 &dev_attr_fw_version.attr, 3067 &dev_attr_hw_version.attr, 3068 &dev_attr_object.attr, 3069 &dev_attr_update_fw.attr, 3070 NULL 3071}; 3072 3073ATTRIBUTE_GROUPS(mxt); 3074 3075static void mxt_start(struct mxt_data *data) 3076{ 3077 mxt_wakeup_toggle(data->client, true, false); 3078 3079 switch (data->suspend_mode) { 3080 case MXT_SUSPEND_T9_CTRL: 3081 mxt_soft_reset(data); 3082 3083 /* Touch enable */ 3084 /* 0x83 = SCANEN | RPTEN | ENABLE */ 3085 mxt_write_object(data, 3086 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0x83); 3087 break; 3088 3089 case MXT_SUSPEND_DEEP_SLEEP: 3090 default: 3091 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_RUN); 3092 3093 /* Recalibrate since chip has been in deep sleep */ 3094 mxt_t6_command(data, MXT_COMMAND_CALIBRATE, 1, false); 3095 break; 3096 } 3097} 3098 3099static void mxt_stop(struct mxt_data *data) 3100{ 3101 switch (data->suspend_mode) { 3102 case MXT_SUSPEND_T9_CTRL: 3103 /* Touch disable */ 3104 mxt_write_object(data, 3105 MXT_TOUCH_MULTI_T9, MXT_T9_CTRL, 0); 3106 break; 3107 3108 case MXT_SUSPEND_DEEP_SLEEP: 3109 default: 3110 mxt_set_t7_power_cfg(data, MXT_POWER_CFG_DEEPSLEEP); 3111 break; 3112 } 3113 3114 mxt_wakeup_toggle(data->client, false, false); 3115} 3116 3117static int mxt_input_open(struct input_dev *dev) 3118{ 3119 struct mxt_data *data = input_get_drvdata(dev); 3120 3121 mxt_start(data); 3122 3123 return 0; 3124} 3125 3126static void mxt_input_close(struct input_dev *dev) 3127{ 3128 struct mxt_data *data = input_get_drvdata(dev); 3129 3130 mxt_stop(data); 3131} 3132 3133static int mxt_parse_device_properties(struct mxt_data *data) 3134{ 3135 static const char keymap_property[] = "linux,gpio-keymap"; 3136 static const char buttons_property[] = "linux,keycodes"; 3137 struct device *dev = &data->client->dev; 3138 u32 *keymap; 3139 u32 *buttonmap; 3140 int n_keys; 3141 int error; 3142 3143 if (device_property_present(dev, keymap_property)) { 3144 n_keys = device_property_count_u32(dev, keymap_property); 3145 if (n_keys <= 0) { 3146 error = n_keys < 0 ? n_keys : -EINVAL; 3147 dev_err(dev, "invalid/malformed '%s' property: %d\n", 3148 keymap_property, error); 3149 return error; 3150 } 3151 3152 keymap = devm_kmalloc_array(dev, n_keys, sizeof(*keymap), 3153 GFP_KERNEL); 3154 if (!keymap) 3155 return -ENOMEM; 3156 3157 error = device_property_read_u32_array(dev, keymap_property, 3158 keymap, n_keys); 3159 if (error) { 3160 dev_err(dev, "failed to parse '%s' property: %d\n", 3161 keymap_property, error); 3162 return error; 3163 } 3164 3165 data->t19_keymap = keymap; 3166 data->t19_num_keys = n_keys; 3167 } 3168 3169 if (device_property_present(dev, buttons_property)) { 3170 n_keys = device_property_count_u32(dev, buttons_property); 3171 if (n_keys <= 0) { 3172 error = n_keys < 0 ? n_keys : -EINVAL; 3173 dev_err(dev, "invalid/malformed '%s' property: %d\n", 3174 buttons_property, error); 3175 return error; 3176 } 3177 3178 buttonmap = devm_kmalloc_array(dev, n_keys, sizeof(*buttonmap), 3179 GFP_KERNEL); 3180 if (!buttonmap) 3181 return -ENOMEM; 3182 3183 error = device_property_read_u32_array(dev, buttons_property, 3184 buttonmap, n_keys); 3185 if (error) { 3186 dev_err(dev, "failed to parse '%s' property: %d\n", 3187 buttons_property, error); 3188 return error; 3189 } 3190 3191 data->t15_keymap = buttonmap; 3192 data->t15_num_keys = n_keys; 3193 } 3194 3195 return 0; 3196} 3197 3198static const struct dmi_system_id chromebook_T9_suspend_dmi[] = { 3199 { 3200 .matches = { 3201 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 3202 DMI_MATCH(DMI_PRODUCT_NAME, "Link"), 3203 }, 3204 }, 3205 { 3206 .matches = { 3207 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"), 3208 }, 3209 }, 3210 { } 3211}; 3212 3213static int mxt_probe(struct i2c_client *client) 3214{ 3215 struct mxt_data *data; 3216 int error; 3217 3218 /* 3219 * Ignore devices that do not have device properties attached to 3220 * them, as we need help determining whether we are dealing with 3221 * touch screen or touchpad. 3222 * 3223 * So far on x86 the only users of Atmel touch controllers are 3224 * Chromebooks, and chromeos_laptop driver will ensure that 3225 * necessary properties are provided (if firmware does not do that). 3226 */ 3227 if (!device_property_present(&client->dev, "compatible")) 3228 return -ENXIO; 3229 3230 /* 3231 * Ignore ACPI devices representing bootloader mode. 3232 * 3233 * This is a bit of a hack: Google Chromebook BIOS creates ACPI 3234 * devices for both application and bootloader modes, but we are 3235 * interested in application mode only (if device is in bootloader 3236 * mode we'll end up switching into application anyway). So far 3237 * application mode addresses were all above 0x40, so we'll use it 3238 * as a threshold. 3239 */ 3240 if (ACPI_COMPANION(&client->dev) && client->addr < 0x40) 3241 return -ENXIO; 3242 3243 data = devm_kzalloc(&client->dev, sizeof(struct mxt_data), GFP_KERNEL); 3244 if (!data) 3245 return -ENOMEM; 3246 3247 snprintf(data->phys, sizeof(data->phys), "i2c-%u-%04x/input0", 3248 client->adapter->nr, client->addr); 3249 3250 data->client = client; 3251 data->irq = client->irq; 3252 i2c_set_clientdata(client, data); 3253 3254 init_completion(&data->bl_completion); 3255 init_completion(&data->reset_completion); 3256 init_completion(&data->crc_completion); 3257 3258 data->suspend_mode = dmi_check_system(chromebook_T9_suspend_dmi) ? 3259 MXT_SUSPEND_T9_CTRL : MXT_SUSPEND_DEEP_SLEEP; 3260 3261 error = mxt_parse_device_properties(data); 3262 if (error) 3263 return error; 3264 3265 /* 3266 * VDDA is the analog voltage supply 2.57..3.47 V 3267 * VDD is the digital voltage supply 1.71..3.47 V 3268 */ 3269 data->regulators[0].supply = "vdda"; 3270 data->regulators[1].supply = "vdd"; 3271 error = devm_regulator_bulk_get(&client->dev, ARRAY_SIZE(data->regulators), 3272 data->regulators); 3273 if (error) { 3274 if (error != -EPROBE_DEFER) 3275 dev_err(&client->dev, "Failed to get regulators %d\n", 3276 error); 3277 return error; 3278 } 3279 3280 /* Request the RESET line as asserted so we go into reset */ 3281 data->reset_gpio = devm_gpiod_get_optional(&client->dev, 3282 "reset", GPIOD_OUT_HIGH); 3283 if (IS_ERR(data->reset_gpio)) { 3284 error = PTR_ERR(data->reset_gpio); 3285 dev_err(&client->dev, "Failed to get reset gpio: %d\n", error); 3286 return error; 3287 } 3288 3289 /* Request the WAKE line as asserted so we go out of sleep */ 3290 data->wake_gpio = devm_gpiod_get_optional(&client->dev, 3291 "wake", GPIOD_OUT_HIGH); 3292 if (IS_ERR(data->wake_gpio)) { 3293 error = PTR_ERR(data->wake_gpio); 3294 dev_err(&client->dev, "Failed to get wake gpio: %d\n", error); 3295 return error; 3296 } 3297 3298 error = devm_request_threaded_irq(&client->dev, client->irq, 3299 NULL, mxt_interrupt, 3300 IRQF_ONESHOT | IRQF_NO_AUTOEN, 3301 client->name, data); 3302 if (error) { 3303 dev_err(&client->dev, "Failed to register interrupt\n"); 3304 return error; 3305 } 3306 3307 error = regulator_bulk_enable(ARRAY_SIZE(data->regulators), 3308 data->regulators); 3309 if (error) { 3310 dev_err(&client->dev, "failed to enable regulators: %d\n", 3311 error); 3312 return error; 3313 } 3314 /* 3315 * The device takes 40ms to come up after power-on according 3316 * to the mXT224 datasheet, page 13. 3317 */ 3318 msleep(MXT_BACKUP_TIME); 3319 3320 if (data->reset_gpio) { 3321 /* Wait a while and then de-assert the RESET GPIO line */ 3322 msleep(MXT_RESET_GPIO_TIME); 3323 gpiod_set_value_cansleep(data->reset_gpio, 0); 3324 msleep(MXT_RESET_INVALID_CHG); 3325 } 3326 3327 /* 3328 * Controllers like mXT1386 have a dedicated WAKE line that could be 3329 * connected to a GPIO or to I2C SCL pin, or permanently asserted low. 3330 * 3331 * This WAKE line is used for waking controller from a deep-sleep and 3332 * it needs to be asserted low for 25 milliseconds before I2C transfers 3333 * could be accepted by controller if it was in a deep-sleep mode. 3334 * Controller will go into sleep automatically after 2 seconds of 3335 * inactivity if WAKE line is deasserted and deep sleep is activated. 3336 * 3337 * If WAKE line is connected to I2C SCL pin, then the first I2C transfer 3338 * will get an instant NAK and transfer needs to be retried after 25ms. 3339 * 3340 * If WAKE line is connected to a GPIO line, the line must be asserted 3341 * 25ms before the host attempts to communicate with the controller. 3342 */ 3343 device_property_read_u32(&client->dev, "atmel,wakeup-method", 3344 &data->wakeup_method); 3345 3346 error = mxt_initialize(data); 3347 if (error) 3348 goto err_disable_regulators; 3349 3350 return 0; 3351 3352err_disable_regulators: 3353 regulator_bulk_disable(ARRAY_SIZE(data->regulators), 3354 data->regulators); 3355 return error; 3356} 3357 3358static void mxt_remove(struct i2c_client *client) 3359{ 3360 struct mxt_data *data = i2c_get_clientdata(client); 3361 3362 disable_irq(data->irq); 3363 mxt_free_input_device(data); 3364 mxt_free_object_table(data); 3365 regulator_bulk_disable(ARRAY_SIZE(data->regulators), 3366 data->regulators); 3367} 3368 3369static int mxt_suspend(struct device *dev) 3370{ 3371 struct i2c_client *client = to_i2c_client(dev); 3372 struct mxt_data *data = i2c_get_clientdata(client); 3373 struct input_dev *input_dev = data->input_dev; 3374 3375 if (!input_dev) 3376 return 0; 3377 3378 mutex_lock(&input_dev->mutex); 3379 3380 if (input_device_enabled(input_dev)) 3381 mxt_stop(data); 3382 3383 mutex_unlock(&input_dev->mutex); 3384 3385 disable_irq(data->irq); 3386 3387 return 0; 3388} 3389 3390static int mxt_resume(struct device *dev) 3391{ 3392 struct i2c_client *client = to_i2c_client(dev); 3393 struct mxt_data *data = i2c_get_clientdata(client); 3394 struct input_dev *input_dev = data->input_dev; 3395 3396 if (!input_dev) 3397 return 0; 3398 3399 enable_irq(data->irq); 3400 3401 mutex_lock(&input_dev->mutex); 3402 3403 if (input_device_enabled(input_dev)) 3404 mxt_start(data); 3405 3406 mutex_unlock(&input_dev->mutex); 3407 3408 return 0; 3409} 3410 3411static DEFINE_SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume); 3412 3413static const struct of_device_id mxt_of_match[] = { 3414 { .compatible = "atmel,maxtouch", }, 3415 /* Compatibles listed below are deprecated */ 3416 { .compatible = "atmel,qt602240_ts", }, 3417 { .compatible = "atmel,atmel_mxt_ts", }, 3418 { .compatible = "atmel,atmel_mxt_tp", }, 3419 { .compatible = "atmel,mXT224", }, 3420 {}, 3421}; 3422MODULE_DEVICE_TABLE(of, mxt_of_match); 3423 3424#ifdef CONFIG_ACPI 3425static const struct acpi_device_id mxt_acpi_id[] = { 3426 { "ATML0000", 0 }, /* Touchpad */ 3427 { "ATML0001", 0 }, /* Touchscreen */ 3428 { } 3429}; 3430MODULE_DEVICE_TABLE(acpi, mxt_acpi_id); 3431#endif 3432 3433static const struct i2c_device_id mxt_id[] = { 3434 { "qt602240_ts" }, 3435 { "atmel_mxt_ts" }, 3436 { "atmel_mxt_tp" }, 3437 { "maxtouch" }, 3438 { "mXT224" }, 3439 { } 3440}; 3441MODULE_DEVICE_TABLE(i2c, mxt_id); 3442 3443static struct i2c_driver mxt_driver = { 3444 .driver = { 3445 .name = "atmel_mxt_ts", 3446 .dev_groups = mxt_groups, 3447 .of_match_table = mxt_of_match, 3448 .acpi_match_table = ACPI_PTR(mxt_acpi_id), 3449 .pm = pm_sleep_ptr(&mxt_pm_ops), 3450 }, 3451 .probe = mxt_probe, 3452 .remove = mxt_remove, 3453 .id_table = mxt_id, 3454}; 3455 3456module_i2c_driver(mxt_driver); 3457 3458/* Module information */ 3459MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 3460MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver"); 3461MODULE_LICENSE("GPL");
~/
Read-only file preview.