1 /* 2 * Atmel maXTouch Touchscreen driver 3 * 4 * Copyright (C) 2010 Samsung Electronics Co.Ltd 5 * Author: Joonyoung Shim <jy0922.shim@samsung.com> 6 * 7 * This program is free software; you can redistribute it and/or modify it 8 * under the terms of the GNU General Public License as published by the 9 * Free Software Foundation; either version 2 of the License, or (at your 10 * option) any later version. 11 * 12 */ 13 14 #include <linux/module.h> 15 #include <linux/init.h> 16 #include <linux/delay.h> 17 #include <linux/firmware.h> 18 #include <linux/i2c.h> 19 #include <linux/i2c/atmel_mxt_ts.h> 20 #include <linux/input/mt.h> 21 #include <linux/interrupt.h> 22 #include <linux/slab.h> 23 24 /* Version */ 25 #define MXT_VER_20 20 26 #define MXT_VER_21 21 27 #define MXT_VER_22 22 28 29 /* Slave addresses */ 30 #define MXT_APP_LOW 0x4a 31 #define MXT_APP_HIGH 0x4b 32 #define MXT_BOOT_LOW 0x24 33 #define MXT_BOOT_HIGH 0x25 34 35 /* Firmware */ 36 #define MXT_FW_NAME "maxtouch.fw" 37 38 /* Registers */ 39 #define MXT_FAMILY_ID 0x00 40 #define MXT_VARIANT_ID 0x01 41 #define MXT_VERSION 0x02 42 #define MXT_BUILD 0x03 43 #define MXT_MATRIX_X_SIZE 0x04 44 #define MXT_MATRIX_Y_SIZE 0x05 45 #define MXT_OBJECT_NUM 0x06 46 #define MXT_OBJECT_START 0x07 47 48 #define MXT_OBJECT_SIZE 6 49 50 /* Object types */ 51 #define MXT_DEBUG_DIAGNOSTIC_T37 37 52 #define MXT_GEN_MESSAGE_T5 5 53 #define MXT_GEN_COMMAND_T6 6 54 #define MXT_GEN_POWER_T7 7 55 #define MXT_GEN_ACQUIRE_T8 8 56 #define MXT_GEN_DATASOURCE_T53 53 57 #define MXT_TOUCH_MULTI_T9 9 58 #define MXT_TOUCH_KEYARRAY_T15 15 59 #define MXT_TOUCH_PROXIMITY_T23 23 60 #define MXT_TOUCH_PROXKEY_T52 52 61 #define MXT_PROCI_GRIPFACE_T20 20 62 #define MXT_PROCG_NOISE_T22 22 63 #define MXT_PROCI_ONETOUCH_T24 24 64 #define MXT_PROCI_TWOTOUCH_T27 27 65 #define MXT_PROCI_GRIP_T40 40 66 #define MXT_PROCI_PALM_T41 41 67 #define MXT_PROCI_TOUCHSUPPRESSION_T42 42 68 #define MXT_PROCI_STYLUS_T47 47 69 #define MXT_PROCG_NOISESUPPRESSION_T48 48 70 #define MXT_SPT_COMMSCONFIG_T18 18 71 #define MXT_SPT_GPIOPWM_T19 19 72 #define MXT_SPT_SELFTEST_T25 25 73 #define MXT_SPT_CTECONFIG_T28 28 74 #define MXT_SPT_USERDATA_T38 38 75 #define MXT_SPT_DIGITIZER_T43 43 76 #define MXT_SPT_MESSAGECOUNT_T44 44 77 #define MXT_SPT_CTECONFIG_T46 46 78 79 /* MXT_GEN_COMMAND_T6 field */ 80 #define MXT_COMMAND_RESET 0 81 #define MXT_COMMAND_BACKUPNV 1 82 #define MXT_COMMAND_CALIBRATE 2 83 #define MXT_COMMAND_REPORTALL 3 84 #define MXT_COMMAND_DIAGNOSTIC 5 85 86 /* MXT_GEN_POWER_T7 field */ 87 #define MXT_POWER_IDLEACQINT 0 88 #define MXT_POWER_ACTVACQINT 1 89 #define MXT_POWER_ACTV2IDLETO 2 90 91 /* MXT_GEN_ACQUIRE_T8 field */ 92 #define MXT_ACQUIRE_CHRGTIME 0 93 #define MXT_ACQUIRE_TCHDRIFT 2 94 #define MXT_ACQUIRE_DRIFTST 3 95 #define MXT_ACQUIRE_TCHAUTOCAL 4 96 #define MXT_ACQUIRE_SYNC 5 97 #define MXT_ACQUIRE_ATCHCALST 6 98 #define MXT_ACQUIRE_ATCHCALSTHR 7 99 100 /* MXT_TOUCH_MULTI_T9 field */ 101 #define MXT_TOUCH_CTRL 0 102 #define MXT_TOUCH_XORIGIN 1 103 #define MXT_TOUCH_YORIGIN 2 104 #define MXT_TOUCH_XSIZE 3 105 #define MXT_TOUCH_YSIZE 4 106 #define MXT_TOUCH_BLEN 6 107 #define MXT_TOUCH_TCHTHR 7 108 #define MXT_TOUCH_TCHDI 8 109 #define MXT_TOUCH_ORIENT 9 110 #define MXT_TOUCH_MOVHYSTI 11 111 #define MXT_TOUCH_MOVHYSTN 12 112 #define MXT_TOUCH_NUMTOUCH 14 113 #define MXT_TOUCH_MRGHYST 15 114 #define MXT_TOUCH_MRGTHR 16 115 #define MXT_TOUCH_AMPHYST 17 116 #define MXT_TOUCH_XRANGE_LSB 18 117 #define MXT_TOUCH_XRANGE_MSB 19 118 #define MXT_TOUCH_YRANGE_LSB 20 119 #define MXT_TOUCH_YRANGE_MSB 21 120 #define MXT_TOUCH_XLOCLIP 22 121 #define MXT_TOUCH_XHICLIP 23 122 #define MXT_TOUCH_YLOCLIP 24 123 #define MXT_TOUCH_YHICLIP 25 124 #define MXT_TOUCH_XEDGECTRL 26 125 #define MXT_TOUCH_XEDGEDIST 27 126 #define MXT_TOUCH_YEDGECTRL 28 127 #define MXT_TOUCH_YEDGEDIST 29 128 #define MXT_TOUCH_JUMPLIMIT 30 129 130 /* MXT_PROCI_GRIPFACE_T20 field */ 131 #define MXT_GRIPFACE_CTRL 0 132 #define MXT_GRIPFACE_XLOGRIP 1 133 #define MXT_GRIPFACE_XHIGRIP 2 134 #define MXT_GRIPFACE_YLOGRIP 3 135 #define MXT_GRIPFACE_YHIGRIP 4 136 #define MXT_GRIPFACE_MAXTCHS 5 137 #define MXT_GRIPFACE_SZTHR1 7 138 #define MXT_GRIPFACE_SZTHR2 8 139 #define MXT_GRIPFACE_SHPTHR1 9 140 #define MXT_GRIPFACE_SHPTHR2 10 141 #define MXT_GRIPFACE_SUPEXTTO 11 142 143 /* MXT_PROCI_NOISE field */ 144 #define MXT_NOISE_CTRL 0 145 #define MXT_NOISE_OUTFLEN 1 146 #define MXT_NOISE_GCAFUL_LSB 3 147 #define MXT_NOISE_GCAFUL_MSB 4 148 #define MXT_NOISE_GCAFLL_LSB 5 149 #define MXT_NOISE_GCAFLL_MSB 6 150 #define MXT_NOISE_ACTVGCAFVALID 7 151 #define MXT_NOISE_NOISETHR 8 152 #define MXT_NOISE_FREQHOPSCALE 10 153 #define MXT_NOISE_FREQ0 11 154 #define MXT_NOISE_FREQ1 12 155 #define MXT_NOISE_FREQ2 13 156 #define MXT_NOISE_FREQ3 14 157 #define MXT_NOISE_FREQ4 15 158 #define MXT_NOISE_IDLEGCAFVALID 16 159 160 /* MXT_SPT_COMMSCONFIG_T18 */ 161 #define MXT_COMMS_CTRL 0 162 #define MXT_COMMS_CMD 1 163 164 /* MXT_SPT_CTECONFIG_T28 field */ 165 #define MXT_CTE_CTRL 0 166 #define MXT_CTE_CMD 1 167 #define MXT_CTE_MODE 2 168 #define MXT_CTE_IDLEGCAFDEPTH 3 169 #define MXT_CTE_ACTVGCAFDEPTH 4 170 #define MXT_CTE_VOLTAGE 5 171 172 #define MXT_VOLTAGE_DEFAULT 2700000 173 #define MXT_VOLTAGE_STEP 10000 174 175 /* Define for MXT_GEN_COMMAND_T6 */ 176 #define MXT_BOOT_VALUE 0xa5 177 #define MXT_BACKUP_VALUE 0x55 178 #define MXT_BACKUP_TIME 25 /* msec */ 179 #define MXT_RESET_TIME 65 /* msec */ 180 181 #define MXT_FWRESET_TIME 175 /* msec */ 182 183 /* Command to unlock bootloader */ 184 #define MXT_UNLOCK_CMD_MSB 0xaa 185 #define MXT_UNLOCK_CMD_LSB 0xdc 186 187 /* Bootloader mode status */ 188 #define MXT_WAITING_BOOTLOAD_CMD 0xc0 /* valid 7 6 bit only */ 189 #define MXT_WAITING_FRAME_DATA 0x80 /* valid 7 6 bit only */ 190 #define MXT_FRAME_CRC_CHECK 0x02 191 #define MXT_FRAME_CRC_FAIL 0x03 192 #define MXT_FRAME_CRC_PASS 0x04 193 #define MXT_APP_CRC_FAIL 0x40 /* valid 7 8 bit only */ 194 #define MXT_BOOT_STATUS_MASK 0x3f 195 196 /* Touch status */ 197 #define MXT_SUPPRESS (1 << 1) 198 #define MXT_AMP (1 << 2) 199 #define MXT_VECTOR (1 << 3) 200 #define MXT_MOVE (1 << 4) 201 #define MXT_RELEASE (1 << 5) 202 #define MXT_PRESS (1 << 6) 203 #define MXT_DETECT (1 << 7) 204 205 /* Touch orient bits */ 206 #define MXT_XY_SWITCH (1 << 0) 207 #define MXT_X_INVERT (1 << 1) 208 #define MXT_Y_INVERT (1 << 2) 209 210 /* Touchscreen absolute values */ 211 #define MXT_MAX_AREA 0xff 212 213 #define MXT_MAX_FINGER 10 214 215 struct mxt_info { 216 u8 family_id; 217 u8 variant_id; 218 u8 version; 219 u8 build; 220 u8 matrix_xsize; 221 u8 matrix_ysize; 222 u8 object_num; 223 }; 224 225 struct mxt_object { 226 u8 type; 227 u16 start_address; 228 u8 size; 229 u8 instances; 230 u8 num_report_ids; 231 232 /* to map object and message */ 233 u8 max_reportid; 234 }; 235 236 struct mxt_message { 237 u8 reportid; 238 u8 message[7]; 239 }; 240 241 struct mxt_finger { 242 int status; 243 int x; 244 int y; 245 int area; 246 int pressure; 247 }; 248 249 /* Each client has this additional data */ 250 struct mxt_data { 251 struct i2c_client *client; 252 struct input_dev *input_dev; 253 const struct mxt_platform_data *pdata; 254 struct mxt_object *object_table; 255 struct mxt_info info; 256 struct mxt_finger finger[MXT_MAX_FINGER]; 257 unsigned int irq; 258 unsigned int max_x; 259 unsigned int max_y; 260 }; 261 262 static bool mxt_object_readable(unsigned int type) 263 { 264 switch (type) { 265 case MXT_GEN_MESSAGE_T5: 266 case MXT_GEN_COMMAND_T6: 267 case MXT_GEN_POWER_T7: 268 case MXT_GEN_ACQUIRE_T8: 269 case MXT_GEN_DATASOURCE_T53: 270 case MXT_TOUCH_MULTI_T9: 271 case MXT_TOUCH_KEYARRAY_T15: 272 case MXT_TOUCH_PROXIMITY_T23: 273 case MXT_TOUCH_PROXKEY_T52: 274 case MXT_PROCI_GRIPFACE_T20: 275 case MXT_PROCG_NOISE_T22: 276 case MXT_PROCI_ONETOUCH_T24: 277 case MXT_PROCI_TWOTOUCH_T27: 278 case MXT_PROCI_GRIP_T40: 279 case MXT_PROCI_PALM_T41: 280 case MXT_PROCI_TOUCHSUPPRESSION_T42: 281 case MXT_PROCI_STYLUS_T47: 282 case MXT_PROCG_NOISESUPPRESSION_T48: 283 case MXT_SPT_COMMSCONFIG_T18: 284 case MXT_SPT_GPIOPWM_T19: 285 case MXT_SPT_SELFTEST_T25: 286 case MXT_SPT_CTECONFIG_T28: 287 case MXT_SPT_USERDATA_T38: 288 case MXT_SPT_DIGITIZER_T43: 289 case MXT_SPT_CTECONFIG_T46: 290 return true; 291 default: 292 return false; 293 } 294 } 295 296 static bool mxt_object_writable(unsigned int type) 297 { 298 switch (type) { 299 case MXT_GEN_COMMAND_T6: 300 case MXT_GEN_POWER_T7: 301 case MXT_GEN_ACQUIRE_T8: 302 case MXT_TOUCH_MULTI_T9: 303 case MXT_TOUCH_KEYARRAY_T15: 304 case MXT_TOUCH_PROXIMITY_T23: 305 case MXT_TOUCH_PROXKEY_T52: 306 case MXT_PROCI_GRIPFACE_T20: 307 case MXT_PROCG_NOISE_T22: 308 case MXT_PROCI_ONETOUCH_T24: 309 case MXT_PROCI_TWOTOUCH_T27: 310 case MXT_PROCI_GRIP_T40: 311 case MXT_PROCI_PALM_T41: 312 case MXT_PROCI_TOUCHSUPPRESSION_T42: 313 case MXT_PROCI_STYLUS_T47: 314 case MXT_PROCG_NOISESUPPRESSION_T48: 315 case MXT_SPT_COMMSCONFIG_T18: 316 case MXT_SPT_GPIOPWM_T19: 317 case MXT_SPT_SELFTEST_T25: 318 case MXT_SPT_CTECONFIG_T28: 319 case MXT_SPT_DIGITIZER_T43: 320 case MXT_SPT_CTECONFIG_T46: 321 return true; 322 default: 323 return false; 324 } 325 } 326 327 static void mxt_dump_message(struct device *dev, 328 struct mxt_message *message) 329 { 330 dev_dbg(dev, "reportid: %u\tmessage: %02x %02x %02x %02x %02x %02x %02x\n", 331 message->reportid, message->message[0], message->message[1], 332 message->message[2], message->message[3], message->message[4], 333 message->message[5], message->message[6]); 334 } 335 336 static int mxt_check_bootloader(struct i2c_client *client, 337 unsigned int state) 338 { 339 u8 val; 340 341 recheck: 342 if (i2c_master_recv(client, &val, 1) != 1) { 343 dev_err(&client->dev, "%s: i2c recv failed\n", __func__); 344 return -EIO; 345 } 346 347 switch (state) { 348 case MXT_WAITING_BOOTLOAD_CMD: 349 case MXT_WAITING_FRAME_DATA: 350 val &= ~MXT_BOOT_STATUS_MASK; 351 break; 352 case MXT_FRAME_CRC_PASS: 353 if (val == MXT_FRAME_CRC_CHECK) 354 goto recheck; 355 break; 356 default: 357 return -EINVAL; 358 } 359 360 if (val != state) { 361 dev_err(&client->dev, "Unvalid bootloader mode state\n"); 362 return -EINVAL; 363 } 364 365 return 0; 366 } 367 368 static int mxt_unlock_bootloader(struct i2c_client *client) 369 { 370 u8 buf[2]; 371 372 buf[0] = MXT_UNLOCK_CMD_LSB; 373 buf[1] = MXT_UNLOCK_CMD_MSB; 374 375 if (i2c_master_send(client, buf, 2) != 2) { 376 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 377 return -EIO; 378 } 379 380 return 0; 381 } 382 383 static int mxt_fw_write(struct i2c_client *client, 384 const u8 *data, unsigned int frame_size) 385 { 386 if (i2c_master_send(client, data, frame_size) != frame_size) { 387 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 388 return -EIO; 389 } 390 391 return 0; 392 } 393 394 static int __mxt_read_reg(struct i2c_client *client, 395 u16 reg, u16 len, void *val) 396 { 397 struct i2c_msg xfer[2]; 398 u8 buf[2]; 399 400 buf[0] = reg & 0xff; 401 buf[1] = (reg >> 8) & 0xff; 402 403 /* Write register */ 404 xfer[0].addr = client->addr; 405 xfer[0].flags = 0; 406 xfer[0].len = 2; 407 xfer[0].buf = buf; 408 409 /* Read data */ 410 xfer[1].addr = client->addr; 411 xfer[1].flags = I2C_M_RD; 412 xfer[1].len = len; 413 xfer[1].buf = val; 414 415 if (i2c_transfer(client->adapter, xfer, 2) != 2) { 416 dev_err(&client->dev, "%s: i2c transfer failed\n", __func__); 417 return -EIO; 418 } 419 420 return 0; 421 } 422 423 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val) 424 { 425 return __mxt_read_reg(client, reg, 1, val); 426 } 427 428 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val) 429 { 430 u8 buf[3]; 431 432 buf[0] = reg & 0xff; 433 buf[1] = (reg >> 8) & 0xff; 434 buf[2] = val; 435 436 if (i2c_master_send(client, buf, 3) != 3) { 437 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 438 return -EIO; 439 } 440 441 return 0; 442 } 443 444 static int mxt_read_object_table(struct i2c_client *client, 445 u16 reg, u8 *object_buf) 446 { 447 return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE, 448 object_buf); 449 } 450 451 static struct mxt_object * 452 mxt_get_object(struct mxt_data *data, u8 type) 453 { 454 struct mxt_object *object; 455 int i; 456 457 for (i = 0; i < data->info.object_num; i++) { 458 object = data->object_table + i; 459 if (object->type == type) 460 return object; 461 } 462 463 dev_err(&data->client->dev, "Invalid object type\n"); 464 return NULL; 465 } 466 467 static int mxt_read_message(struct mxt_data *data, 468 struct mxt_message *message) 469 { 470 struct mxt_object *object; 471 u16 reg; 472 473 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5); 474 if (!object) 475 return -EINVAL; 476 477 reg = object->start_address; 478 return __mxt_read_reg(data->client, reg, 479 sizeof(struct mxt_message), message); 480 } 481 482 static int mxt_read_object(struct mxt_data *data, 483 u8 type, u8 offset, u8 *val) 484 { 485 struct mxt_object *object; 486 u16 reg; 487 488 object = mxt_get_object(data, type); 489 if (!object) 490 return -EINVAL; 491 492 reg = object->start_address; 493 return __mxt_read_reg(data->client, reg + offset, 1, val); 494 } 495 496 static int mxt_write_object(struct mxt_data *data, 497 u8 type, u8 offset, u8 val) 498 { 499 struct mxt_object *object; 500 u16 reg; 501 502 object = mxt_get_object(data, type); 503 if (!object || offset >= object->size + 1) 504 return -EINVAL; 505 506 reg = object->start_address; 507 return mxt_write_reg(data->client, reg + offset, val); 508 } 509 510 static void mxt_input_report(struct mxt_data *data, int single_id) 511 { 512 struct mxt_finger *finger = data->finger; 513 struct input_dev *input_dev = data->input_dev; 514 int status = finger[single_id].status; 515 int finger_num = 0; 516 int id; 517 518 for (id = 0; id < MXT_MAX_FINGER; id++) { 519 if (!finger[id].status) 520 continue; 521 522 input_mt_slot(input_dev, id); 523 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 524 finger[id].status != MXT_RELEASE); 525 526 if (finger[id].status != MXT_RELEASE) { 527 finger_num++; 528 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 529 finger[id].area); 530 input_report_abs(input_dev, ABS_MT_POSITION_X, 531 finger[id].x); 532 input_report_abs(input_dev, ABS_MT_POSITION_Y, 533 finger[id].y); 534 input_report_abs(input_dev, ABS_MT_PRESSURE, 535 finger[id].pressure); 536 } else { 537 finger[id].status = 0; 538 } 539 } 540 541 input_report_key(input_dev, BTN_TOUCH, finger_num > 0); 542 543 if (status != MXT_RELEASE) { 544 input_report_abs(input_dev, ABS_X, finger[single_id].x); 545 input_report_abs(input_dev, ABS_Y, finger[single_id].y); 546 input_report_abs(input_dev, 547 ABS_PRESSURE, finger[single_id].pressure); 548 } 549 550 input_sync(input_dev); 551 } 552 553 static void mxt_input_touchevent(struct mxt_data *data, 554 struct mxt_message *message, int id) 555 { 556 struct mxt_finger *finger = data->finger; 557 struct device *dev = &data->client->dev; 558 u8 status = message->message[0]; 559 int x; 560 int y; 561 int area; 562 int pressure; 563 564 /* Check the touch is present on the screen */ 565 if (!(status & MXT_DETECT)) { 566 if (status & MXT_RELEASE) { 567 dev_dbg(dev, "[%d] released\n", id); 568 569 finger[id].status = MXT_RELEASE; 570 mxt_input_report(data, id); 571 } 572 return; 573 } 574 575 /* Check only AMP detection */ 576 if (!(status & (MXT_PRESS | MXT_MOVE))) 577 return; 578 579 x = (message->message[1] << 4) | ((message->message[3] >> 4) & 0xf); 580 y = (message->message[2] << 4) | ((message->message[3] & 0xf)); 581 if (data->max_x < 1024) 582 x = x >> 2; 583 if (data->max_y < 1024) 584 y = y >> 2; 585 586 area = message->message[4]; 587 pressure = message->message[5]; 588 589 dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id, 590 status & MXT_MOVE ? "moved" : "pressed", 591 x, y, area); 592 593 finger[id].status = status & MXT_MOVE ? 594 MXT_MOVE : MXT_PRESS; 595 finger[id].x = x; 596 finger[id].y = y; 597 finger[id].area = area; 598 finger[id].pressure = pressure; 599 600 mxt_input_report(data, id); 601 } 602 603 static irqreturn_t mxt_interrupt(int irq, void *dev_id) 604 { 605 struct mxt_data *data = dev_id; 606 struct mxt_message message; 607 struct mxt_object *object; 608 struct device *dev = &data->client->dev; 609 int id; 610 u8 reportid; 611 u8 max_reportid; 612 u8 min_reportid; 613 614 do { 615 if (mxt_read_message(data, &message)) { 616 dev_err(dev, "Failed to read message\n"); 617 goto end; 618 } 619 620 reportid = message.reportid; 621 622 /* whether reportid is thing of MXT_TOUCH_MULTI_T9 */ 623 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9); 624 if (!object) 625 goto end; 626 627 max_reportid = object->max_reportid; 628 min_reportid = max_reportid - object->num_report_ids + 1; 629 id = reportid - min_reportid; 630 631 if (reportid >= min_reportid && reportid <= max_reportid) 632 mxt_input_touchevent(data, &message, id); 633 else 634 mxt_dump_message(dev, &message); 635 } while (reportid != 0xff); 636 637 end: 638 return IRQ_HANDLED; 639 } 640 641 static int mxt_check_reg_init(struct mxt_data *data) 642 { 643 const struct mxt_platform_data *pdata = data->pdata; 644 struct mxt_object *object; 645 struct device *dev = &data->client->dev; 646 int index = 0; 647 int i, j, config_offset; 648 649 if (!pdata->config) { 650 dev_dbg(dev, "No cfg data defined, skipping reg init\n"); 651 return 0; 652 } 653 654 for (i = 0; i < data->info.object_num; i++) { 655 object = data->object_table + i; 656 657 if (!mxt_object_writable(object->type)) 658 continue; 659 660 for (j = 0; 661 j < (object->size + 1) * (object->instances + 1); 662 j++) { 663 config_offset = index + j; 664 if (config_offset > pdata->config_length) { 665 dev_err(dev, "Not enough config data!\n"); 666 return -EINVAL; 667 } 668 mxt_write_object(data, object->type, j, 669 pdata->config[config_offset]); 670 } 671 index += (object->size + 1) * (object->instances + 1); 672 } 673 674 return 0; 675 } 676 677 static int mxt_make_highchg(struct mxt_data *data) 678 { 679 struct device *dev = &data->client->dev; 680 struct mxt_message message; 681 int count = 10; 682 int error; 683 684 /* Read dummy message to make high CHG pin */ 685 do { 686 error = mxt_read_message(data, &message); 687 if (error) 688 return error; 689 } while (message.reportid != 0xff && --count); 690 691 if (!count) { 692 dev_err(dev, "CHG pin isn't cleared\n"); 693 return -EBUSY; 694 } 695 696 return 0; 697 } 698 699 static void mxt_handle_pdata(struct mxt_data *data) 700 { 701 const struct mxt_platform_data *pdata = data->pdata; 702 u8 voltage; 703 704 /* Set touchscreen lines */ 705 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE, 706 pdata->x_line); 707 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE, 708 pdata->y_line); 709 710 /* Set touchscreen orient */ 711 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT, 712 pdata->orient); 713 714 /* Set touchscreen burst length */ 715 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 716 MXT_TOUCH_BLEN, pdata->blen); 717 718 /* Set touchscreen threshold */ 719 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 720 MXT_TOUCH_TCHTHR, pdata->threshold); 721 722 /* Set touchscreen resolution */ 723 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 724 MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff); 725 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 726 MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8); 727 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 728 MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff); 729 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 730 MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8); 731 732 /* Set touchscreen voltage */ 733 if (pdata->voltage) { 734 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) { 735 voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) / 736 MXT_VOLTAGE_STEP; 737 voltage = 0xff - voltage + 1; 738 } else 739 voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) / 740 MXT_VOLTAGE_STEP; 741 742 mxt_write_object(data, MXT_SPT_CTECONFIG_T28, 743 MXT_CTE_VOLTAGE, voltage); 744 } 745 } 746 747 static int mxt_get_info(struct mxt_data *data) 748 { 749 struct i2c_client *client = data->client; 750 struct mxt_info *info = &data->info; 751 int error; 752 u8 val; 753 754 error = mxt_read_reg(client, MXT_FAMILY_ID, &val); 755 if (error) 756 return error; 757 info->family_id = val; 758 759 error = mxt_read_reg(client, MXT_VARIANT_ID, &val); 760 if (error) 761 return error; 762 info->variant_id = val; 763 764 error = mxt_read_reg(client, MXT_VERSION, &val); 765 if (error) 766 return error; 767 info->version = val; 768 769 error = mxt_read_reg(client, MXT_BUILD, &val); 770 if (error) 771 return error; 772 info->build = val; 773 774 error = mxt_read_reg(client, MXT_OBJECT_NUM, &val); 775 if (error) 776 return error; 777 info->object_num = val; 778 779 return 0; 780 } 781 782 static int mxt_get_object_table(struct mxt_data *data) 783 { 784 int error; 785 int i; 786 u16 reg; 787 u8 reportid = 0; 788 u8 buf[MXT_OBJECT_SIZE]; 789 790 for (i = 0; i < data->info.object_num; i++) { 791 struct mxt_object *object = data->object_table + i; 792 793 reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i; 794 error = mxt_read_object_table(data->client, reg, buf); 795 if (error) 796 return error; 797 798 object->type = buf[0]; 799 object->start_address = (buf[2] << 8) | buf[1]; 800 object->size = buf[3]; 801 object->instances = buf[4]; 802 object->num_report_ids = buf[5]; 803 804 if (object->num_report_ids) { 805 reportid += object->num_report_ids * 806 (object->instances + 1); 807 object->max_reportid = reportid; 808 } 809 } 810 811 return 0; 812 } 813 814 static int mxt_initialize(struct mxt_data *data) 815 { 816 struct i2c_client *client = data->client; 817 struct mxt_info *info = &data->info; 818 int error; 819 u8 val; 820 821 error = mxt_get_info(data); 822 if (error) 823 return error; 824 825 data->object_table = kcalloc(info->object_num, 826 sizeof(struct mxt_object), 827 GFP_KERNEL); 828 if (!data->object_table) { 829 dev_err(&client->dev, "Failed to allocate memory\n"); 830 return -ENOMEM; 831 } 832 833 /* Get object table information */ 834 error = mxt_get_object_table(data); 835 if (error) 836 return error; 837 838 /* Check register init values */ 839 error = mxt_check_reg_init(data); 840 if (error) 841 return error; 842 843 mxt_handle_pdata(data); 844 845 /* Backup to memory */ 846 mxt_write_object(data, MXT_GEN_COMMAND_T6, 847 MXT_COMMAND_BACKUPNV, 848 MXT_BACKUP_VALUE); 849 msleep(MXT_BACKUP_TIME); 850 851 /* Soft reset */ 852 mxt_write_object(data, MXT_GEN_COMMAND_T6, 853 MXT_COMMAND_RESET, 1); 854 msleep(MXT_RESET_TIME); 855 856 /* Update matrix size at info struct */ 857 error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val); 858 if (error) 859 return error; 860 info->matrix_xsize = val; 861 862 error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val); 863 if (error) 864 return error; 865 info->matrix_ysize = val; 866 867 dev_info(&client->dev, 868 "Family ID: %d Variant ID: %d Version: %d Build: %d\n", 869 info->family_id, info->variant_id, info->version, 870 info->build); 871 872 dev_info(&client->dev, 873 "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n", 874 info->matrix_xsize, info->matrix_ysize, 875 info->object_num); 876 877 return 0; 878 } 879 880 static void mxt_calc_resolution(struct mxt_data *data) 881 { 882 unsigned int max_x = data->pdata->x_size - 1; 883 unsigned int max_y = data->pdata->y_size - 1; 884 885 if (data->pdata->orient & MXT_XY_SWITCH) { 886 data->max_x = max_y; 887 data->max_y = max_x; 888 } else { 889 data->max_x = max_x; 890 data->max_y = max_y; 891 } 892 } 893 894 static ssize_t mxt_object_show(struct device *dev, 895 struct device_attribute *attr, char *buf) 896 { 897 struct mxt_data *data = dev_get_drvdata(dev); 898 struct mxt_object *object; 899 int count = 0; 900 int i, j; 901 int error; 902 u8 val; 903 904 for (i = 0; i < data->info.object_num; i++) { 905 object = data->object_table + i; 906 907 count += snprintf(buf + count, PAGE_SIZE - count, 908 "Object[%d] (Type %d)\n", 909 i + 1, object->type); 910 if (count >= PAGE_SIZE) 911 return PAGE_SIZE - 1; 912 913 if (!mxt_object_readable(object->type)) { 914 count += snprintf(buf + count, PAGE_SIZE - count, 915 "\n"); 916 if (count >= PAGE_SIZE) 917 return PAGE_SIZE - 1; 918 continue; 919 } 920 921 for (j = 0; j < object->size + 1; j++) { 922 error = mxt_read_object(data, 923 object->type, j, &val); 924 if (error) 925 return error; 926 927 count += snprintf(buf + count, PAGE_SIZE - count, 928 "\t[%2d]: %02x (%d)\n", j, val, val); 929 if (count >= PAGE_SIZE) 930 return PAGE_SIZE - 1; 931 } 932 933 count += snprintf(buf + count, PAGE_SIZE - count, "\n"); 934 if (count >= PAGE_SIZE) 935 return PAGE_SIZE - 1; 936 } 937 938 return count; 939 } 940 941 static int mxt_load_fw(struct device *dev, const char *fn) 942 { 943 struct mxt_data *data = dev_get_drvdata(dev); 944 struct i2c_client *client = data->client; 945 const struct firmware *fw = NULL; 946 unsigned int frame_size; 947 unsigned int pos = 0; 948 int ret; 949 950 ret = request_firmware(&fw, fn, dev); 951 if (ret) { 952 dev_err(dev, "Unable to open firmware %s\n", fn); 953 return ret; 954 } 955 956 /* Change to the bootloader mode */ 957 mxt_write_object(data, MXT_GEN_COMMAND_T6, 958 MXT_COMMAND_RESET, MXT_BOOT_VALUE); 959 msleep(MXT_RESET_TIME); 960 961 /* Change to slave address of bootloader */ 962 if (client->addr == MXT_APP_LOW) 963 client->addr = MXT_BOOT_LOW; 964 else 965 client->addr = MXT_BOOT_HIGH; 966 967 ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD); 968 if (ret) 969 goto out; 970 971 /* Unlock bootloader */ 972 mxt_unlock_bootloader(client); 973 974 while (pos < fw->size) { 975 ret = mxt_check_bootloader(client, 976 MXT_WAITING_FRAME_DATA); 977 if (ret) 978 goto out; 979 980 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1)); 981 982 /* We should add 2 at frame size as the the firmware data is not 983 * included the CRC bytes. 984 */ 985 frame_size += 2; 986 987 /* Write one frame to device */ 988 mxt_fw_write(client, fw->data + pos, frame_size); 989 990 ret = mxt_check_bootloader(client, 991 MXT_FRAME_CRC_PASS); 992 if (ret) 993 goto out; 994 995 pos += frame_size; 996 997 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size); 998 } 999 1000 out: 1001 release_firmware(fw); 1002 1003 /* Change to slave address of application */ 1004 if (client->addr == MXT_BOOT_LOW) 1005 client->addr = MXT_APP_LOW; 1006 else 1007 client->addr = MXT_APP_HIGH; 1008 1009 return ret; 1010 } 1011 1012 static ssize_t mxt_update_fw_store(struct device *dev, 1013 struct device_attribute *attr, 1014 const char *buf, size_t count) 1015 { 1016 struct mxt_data *data = dev_get_drvdata(dev); 1017 int error; 1018 1019 disable_irq(data->irq); 1020 1021 error = mxt_load_fw(dev, MXT_FW_NAME); 1022 if (error) { 1023 dev_err(dev, "The firmware update failed(%d)\n", error); 1024 count = error; 1025 } else { 1026 dev_dbg(dev, "The firmware update succeeded\n"); 1027 1028 /* Wait for reset */ 1029 msleep(MXT_FWRESET_TIME); 1030 1031 kfree(data->object_table); 1032 data->object_table = NULL; 1033 1034 mxt_initialize(data); 1035 } 1036 1037 enable_irq(data->irq); 1038 1039 error = mxt_make_highchg(data); 1040 if (error) 1041 return error; 1042 1043 return count; 1044 } 1045 1046 static DEVICE_ATTR(object, S_IRUGO, mxt_object_show, NULL); 1047 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, mxt_update_fw_store); 1048 1049 static struct attribute *mxt_attrs[] = { 1050 &dev_attr_object.attr, 1051 &dev_attr_update_fw.attr, 1052 NULL 1053 }; 1054 1055 static const struct attribute_group mxt_attr_group = { 1056 .attrs = mxt_attrs, 1057 }; 1058 1059 static void mxt_start(struct mxt_data *data) 1060 { 1061 /* Touch enable */ 1062 mxt_write_object(data, 1063 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83); 1064 } 1065 1066 static void mxt_stop(struct mxt_data *data) 1067 { 1068 /* Touch disable */ 1069 mxt_write_object(data, 1070 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0); 1071 } 1072 1073 static int mxt_input_open(struct input_dev *dev) 1074 { 1075 struct mxt_data *data = input_get_drvdata(dev); 1076 1077 mxt_start(data); 1078 1079 return 0; 1080 } 1081 1082 static void mxt_input_close(struct input_dev *dev) 1083 { 1084 struct mxt_data *data = input_get_drvdata(dev); 1085 1086 mxt_stop(data); 1087 } 1088 1089 static int __devinit mxt_probe(struct i2c_client *client, 1090 const struct i2c_device_id *id) 1091 { 1092 const struct mxt_platform_data *pdata = client->dev.platform_data; 1093 struct mxt_data *data; 1094 struct input_dev *input_dev; 1095 int error; 1096 1097 if (!pdata) 1098 return -EINVAL; 1099 1100 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL); 1101 input_dev = input_allocate_device(); 1102 if (!data || !input_dev) { 1103 dev_err(&client->dev, "Failed to allocate memory\n"); 1104 error = -ENOMEM; 1105 goto err_free_mem; 1106 } 1107 1108 input_dev->name = "Atmel maXTouch Touchscreen"; 1109 input_dev->id.bustype = BUS_I2C; 1110 input_dev->dev.parent = &client->dev; 1111 input_dev->open = mxt_input_open; 1112 input_dev->close = mxt_input_close; 1113 1114 data->client = client; 1115 data->input_dev = input_dev; 1116 data->pdata = pdata; 1117 data->irq = client->irq; 1118 1119 mxt_calc_resolution(data); 1120 1121 __set_bit(EV_ABS, input_dev->evbit); 1122 __set_bit(EV_KEY, input_dev->evbit); 1123 __set_bit(BTN_TOUCH, input_dev->keybit); 1124 1125 /* For single touch */ 1126 input_set_abs_params(input_dev, ABS_X, 1127 0, data->max_x, 0, 0); 1128 input_set_abs_params(input_dev, ABS_Y, 1129 0, data->max_y, 0, 0); 1130 input_set_abs_params(input_dev, ABS_PRESSURE, 1131 0, 255, 0, 0); 1132 1133 /* For multi touch */ 1134 input_mt_init_slots(input_dev, MXT_MAX_FINGER); 1135 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 1136 0, MXT_MAX_AREA, 0, 0); 1137 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 1138 0, data->max_x, 0, 0); 1139 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 1140 0, data->max_y, 0, 0); 1141 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 1142 0, 255, 0, 0); 1143 1144 input_set_drvdata(input_dev, data); 1145 i2c_set_clientdata(client, data); 1146 1147 error = mxt_initialize(data); 1148 if (error) 1149 goto err_free_object; 1150 1151 error = request_threaded_irq(client->irq, NULL, mxt_interrupt, 1152 pdata->irqflags | IRQF_ONESHOT, 1153 client->dev.driver->name, data); 1154 if (error) { 1155 dev_err(&client->dev, "Failed to register interrupt\n"); 1156 goto err_free_object; 1157 } 1158 1159 error = mxt_make_highchg(data); 1160 if (error) 1161 goto err_free_irq; 1162 1163 error = input_register_device(input_dev); 1164 if (error) 1165 goto err_free_irq; 1166 1167 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group); 1168 if (error) 1169 goto err_unregister_device; 1170 1171 return 0; 1172 1173 err_unregister_device: 1174 input_unregister_device(input_dev); 1175 input_dev = NULL; 1176 err_free_irq: 1177 free_irq(client->irq, data); 1178 err_free_object: 1179 kfree(data->object_table); 1180 err_free_mem: 1181 input_free_device(input_dev); 1182 kfree(data); 1183 return error; 1184 } 1185 1186 static int __devexit mxt_remove(struct i2c_client *client) 1187 { 1188 struct mxt_data *data = i2c_get_clientdata(client); 1189 1190 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group); 1191 free_irq(data->irq, data); 1192 input_unregister_device(data->input_dev); 1193 kfree(data->object_table); 1194 kfree(data); 1195 1196 return 0; 1197 } 1198 1199 #ifdef CONFIG_PM_SLEEP 1200 static int mxt_suspend(struct device *dev) 1201 { 1202 struct i2c_client *client = to_i2c_client(dev); 1203 struct mxt_data *data = i2c_get_clientdata(client); 1204 struct input_dev *input_dev = data->input_dev; 1205 1206 mutex_lock(&input_dev->mutex); 1207 1208 if (input_dev->users) 1209 mxt_stop(data); 1210 1211 mutex_unlock(&input_dev->mutex); 1212 1213 return 0; 1214 } 1215 1216 static int mxt_resume(struct device *dev) 1217 { 1218 struct i2c_client *client = to_i2c_client(dev); 1219 struct mxt_data *data = i2c_get_clientdata(client); 1220 struct input_dev *input_dev = data->input_dev; 1221 1222 /* Soft reset */ 1223 mxt_write_object(data, MXT_GEN_COMMAND_T6, 1224 MXT_COMMAND_RESET, 1); 1225 1226 msleep(MXT_RESET_TIME); 1227 1228 mutex_lock(&input_dev->mutex); 1229 1230 if (input_dev->users) 1231 mxt_start(data); 1232 1233 mutex_unlock(&input_dev->mutex); 1234 1235 return 0; 1236 } 1237 #endif 1238 1239 static SIMPLE_DEV_PM_OPS(mxt_pm_ops, mxt_suspend, mxt_resume); 1240 1241 static const struct i2c_device_id mxt_id[] = { 1242 { "qt602240_ts", 0 }, 1243 { "atmel_mxt_ts", 0 }, 1244 { "mXT224", 0 }, 1245 { } 1246 }; 1247 MODULE_DEVICE_TABLE(i2c, mxt_id); 1248 1249 static struct i2c_driver mxt_driver = { 1250 .driver = { 1251 .name = "atmel_mxt_ts", 1252 .owner = THIS_MODULE, 1253 .pm = &mxt_pm_ops, 1254 }, 1255 .probe = mxt_probe, 1256 .remove = __devexit_p(mxt_remove), 1257 .id_table = mxt_id, 1258 }; 1259 1260 module_i2c_driver(mxt_driver); 1261 1262 /* Module information */ 1263 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>"); 1264 MODULE_DESCRIPTION("Atmel maXTouch Touchscreen driver"); 1265 MODULE_LICENSE("GPL"); 1266