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 u8 checksum; 240 }; 241 242 struct mxt_finger { 243 int status; 244 int x; 245 int y; 246 int area; 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:\t0x%x\n", message->reportid); 331 dev_dbg(dev, "message1:\t0x%x\n", message->message[0]); 332 dev_dbg(dev, "message2:\t0x%x\n", message->message[1]); 333 dev_dbg(dev, "message3:\t0x%x\n", message->message[2]); 334 dev_dbg(dev, "message4:\t0x%x\n", message->message[3]); 335 dev_dbg(dev, "message5:\t0x%x\n", message->message[4]); 336 dev_dbg(dev, "message6:\t0x%x\n", message->message[5]); 337 dev_dbg(dev, "message7:\t0x%x\n", message->message[6]); 338 dev_dbg(dev, "checksum:\t0x%x\n", message->checksum); 339 } 340 341 static int mxt_check_bootloader(struct i2c_client *client, 342 unsigned int state) 343 { 344 u8 val; 345 346 recheck: 347 if (i2c_master_recv(client, &val, 1) != 1) { 348 dev_err(&client->dev, "%s: i2c recv failed\n", __func__); 349 return -EIO; 350 } 351 352 switch (state) { 353 case MXT_WAITING_BOOTLOAD_CMD: 354 case MXT_WAITING_FRAME_DATA: 355 val &= ~MXT_BOOT_STATUS_MASK; 356 break; 357 case MXT_FRAME_CRC_PASS: 358 if (val == MXT_FRAME_CRC_CHECK) 359 goto recheck; 360 break; 361 default: 362 return -EINVAL; 363 } 364 365 if (val != state) { 366 dev_err(&client->dev, "Unvalid bootloader mode state\n"); 367 return -EINVAL; 368 } 369 370 return 0; 371 } 372 373 static int mxt_unlock_bootloader(struct i2c_client *client) 374 { 375 u8 buf[2]; 376 377 buf[0] = MXT_UNLOCK_CMD_LSB; 378 buf[1] = MXT_UNLOCK_CMD_MSB; 379 380 if (i2c_master_send(client, buf, 2) != 2) { 381 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 382 return -EIO; 383 } 384 385 return 0; 386 } 387 388 static int mxt_fw_write(struct i2c_client *client, 389 const u8 *data, unsigned int frame_size) 390 { 391 if (i2c_master_send(client, data, frame_size) != frame_size) { 392 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 393 return -EIO; 394 } 395 396 return 0; 397 } 398 399 static int __mxt_read_reg(struct i2c_client *client, 400 u16 reg, u16 len, void *val) 401 { 402 struct i2c_msg xfer[2]; 403 u8 buf[2]; 404 405 buf[0] = reg & 0xff; 406 buf[1] = (reg >> 8) & 0xff; 407 408 /* Write register */ 409 xfer[0].addr = client->addr; 410 xfer[0].flags = 0; 411 xfer[0].len = 2; 412 xfer[0].buf = buf; 413 414 /* Read data */ 415 xfer[1].addr = client->addr; 416 xfer[1].flags = I2C_M_RD; 417 xfer[1].len = len; 418 xfer[1].buf = val; 419 420 if (i2c_transfer(client->adapter, xfer, 2) != 2) { 421 dev_err(&client->dev, "%s: i2c transfer failed\n", __func__); 422 return -EIO; 423 } 424 425 return 0; 426 } 427 428 static int mxt_read_reg(struct i2c_client *client, u16 reg, u8 *val) 429 { 430 return __mxt_read_reg(client, reg, 1, val); 431 } 432 433 static int mxt_write_reg(struct i2c_client *client, u16 reg, u8 val) 434 { 435 u8 buf[3]; 436 437 buf[0] = reg & 0xff; 438 buf[1] = (reg >> 8) & 0xff; 439 buf[2] = val; 440 441 if (i2c_master_send(client, buf, 3) != 3) { 442 dev_err(&client->dev, "%s: i2c send failed\n", __func__); 443 return -EIO; 444 } 445 446 return 0; 447 } 448 449 static int mxt_read_object_table(struct i2c_client *client, 450 u16 reg, u8 *object_buf) 451 { 452 return __mxt_read_reg(client, reg, MXT_OBJECT_SIZE, 453 object_buf); 454 } 455 456 static struct mxt_object * 457 mxt_get_object(struct mxt_data *data, u8 type) 458 { 459 struct mxt_object *object; 460 int i; 461 462 for (i = 0; i < data->info.object_num; i++) { 463 object = data->object_table + i; 464 if (object->type == type) 465 return object; 466 } 467 468 dev_err(&data->client->dev, "Invalid object type\n"); 469 return NULL; 470 } 471 472 static int mxt_read_message(struct mxt_data *data, 473 struct mxt_message *message) 474 { 475 struct mxt_object *object; 476 u16 reg; 477 478 object = mxt_get_object(data, MXT_GEN_MESSAGE_T5); 479 if (!object) 480 return -EINVAL; 481 482 reg = object->start_address; 483 return __mxt_read_reg(data->client, reg, 484 sizeof(struct mxt_message), message); 485 } 486 487 static int mxt_read_object(struct mxt_data *data, 488 u8 type, u8 offset, u8 *val) 489 { 490 struct mxt_object *object; 491 u16 reg; 492 493 object = mxt_get_object(data, type); 494 if (!object) 495 return -EINVAL; 496 497 reg = object->start_address; 498 return __mxt_read_reg(data->client, reg + offset, 1, val); 499 } 500 501 static int mxt_write_object(struct mxt_data *data, 502 u8 type, u8 offset, u8 val) 503 { 504 struct mxt_object *object; 505 u16 reg; 506 507 object = mxt_get_object(data, type); 508 if (!object) 509 return -EINVAL; 510 511 reg = object->start_address; 512 return mxt_write_reg(data->client, reg + offset, val); 513 } 514 515 static void mxt_input_report(struct mxt_data *data, int single_id) 516 { 517 struct mxt_finger *finger = data->finger; 518 struct input_dev *input_dev = data->input_dev; 519 int status = finger[single_id].status; 520 int finger_num = 0; 521 int id; 522 523 for (id = 0; id < MXT_MAX_FINGER; id++) { 524 if (!finger[id].status) 525 continue; 526 527 input_mt_slot(input_dev, id); 528 input_mt_report_slot_state(input_dev, MT_TOOL_FINGER, 529 finger[id].status != MXT_RELEASE); 530 531 if (finger[id].status != MXT_RELEASE) { 532 finger_num++; 533 input_report_abs(input_dev, ABS_MT_TOUCH_MAJOR, 534 finger[id].area); 535 input_report_abs(input_dev, ABS_MT_POSITION_X, 536 finger[id].x); 537 input_report_abs(input_dev, ABS_MT_POSITION_Y, 538 finger[id].y); 539 } else { 540 finger[id].status = 0; 541 } 542 } 543 544 input_report_key(input_dev, BTN_TOUCH, finger_num > 0); 545 546 if (status != MXT_RELEASE) { 547 input_report_abs(input_dev, ABS_X, finger[single_id].x); 548 input_report_abs(input_dev, ABS_Y, finger[single_id].y); 549 } 550 551 input_sync(input_dev); 552 } 553 554 static void mxt_input_touchevent(struct mxt_data *data, 555 struct mxt_message *message, int id) 556 { 557 struct mxt_finger *finger = data->finger; 558 struct device *dev = &data->client->dev; 559 u8 status = message->message[0]; 560 int x; 561 int y; 562 int area; 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 588 dev_dbg(dev, "[%d] %s x: %d, y: %d, area: %d\n", id, 589 status & MXT_MOVE ? "moved" : "pressed", 590 x, y, area); 591 592 finger[id].status = status & MXT_MOVE ? 593 MXT_MOVE : MXT_PRESS; 594 finger[id].x = x; 595 finger[id].y = y; 596 finger[id].area = area; 597 598 mxt_input_report(data, id); 599 } 600 601 static irqreturn_t mxt_interrupt(int irq, void *dev_id) 602 { 603 struct mxt_data *data = dev_id; 604 struct mxt_message message; 605 struct mxt_object *object; 606 struct device *dev = &data->client->dev; 607 int id; 608 u8 reportid; 609 u8 max_reportid; 610 u8 min_reportid; 611 612 do { 613 if (mxt_read_message(data, &message)) { 614 dev_err(dev, "Failed to read message\n"); 615 goto end; 616 } 617 618 reportid = message.reportid; 619 620 /* whether reportid is thing of MXT_TOUCH_MULTI_T9 */ 621 object = mxt_get_object(data, MXT_TOUCH_MULTI_T9); 622 if (!object) 623 goto end; 624 625 max_reportid = object->max_reportid; 626 min_reportid = max_reportid - object->num_report_ids + 1; 627 id = reportid - min_reportid; 628 629 if (reportid >= min_reportid && reportid <= max_reportid) 630 mxt_input_touchevent(data, &message, id); 631 else 632 mxt_dump_message(dev, &message); 633 } while (reportid != 0xff); 634 635 end: 636 return IRQ_HANDLED; 637 } 638 639 static int mxt_check_reg_init(struct mxt_data *data) 640 { 641 const struct mxt_platform_data *pdata = data->pdata; 642 struct mxt_object *object; 643 struct device *dev = &data->client->dev; 644 int index = 0; 645 int i, j, config_offset; 646 647 if (!pdata->config) { 648 dev_dbg(dev, "No cfg data defined, skipping reg init\n"); 649 return 0; 650 } 651 652 for (i = 0; i < data->info.object_num; i++) { 653 object = data->object_table + i; 654 655 if (!mxt_object_writable(object->type)) 656 continue; 657 658 for (j = 0; 659 j < (object->size + 1) * (object->instances + 1); 660 j++) { 661 config_offset = index + j; 662 if (config_offset > pdata->config_length) { 663 dev_err(dev, "Not enough config data!\n"); 664 return -EINVAL; 665 } 666 mxt_write_object(data, object->type, j, 667 pdata->config[config_offset]); 668 } 669 index += (object->size + 1) * (object->instances + 1); 670 } 671 672 return 0; 673 } 674 675 static int mxt_make_highchg(struct mxt_data *data) 676 { 677 struct device *dev = &data->client->dev; 678 struct mxt_message message; 679 int count = 10; 680 int error; 681 682 /* Read dummy message to make high CHG pin */ 683 do { 684 error = mxt_read_message(data, &message); 685 if (error) 686 return error; 687 } while (message.reportid != 0xff && --count); 688 689 if (!count) { 690 dev_err(dev, "CHG pin isn't cleared\n"); 691 return -EBUSY; 692 } 693 694 return 0; 695 } 696 697 static void mxt_handle_pdata(struct mxt_data *data) 698 { 699 const struct mxt_platform_data *pdata = data->pdata; 700 u8 voltage; 701 702 /* Set touchscreen lines */ 703 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_XSIZE, 704 pdata->x_line); 705 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_YSIZE, 706 pdata->y_line); 707 708 /* Set touchscreen orient */ 709 mxt_write_object(data, MXT_TOUCH_MULTI_T9, MXT_TOUCH_ORIENT, 710 pdata->orient); 711 712 /* Set touchscreen burst length */ 713 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 714 MXT_TOUCH_BLEN, pdata->blen); 715 716 /* Set touchscreen threshold */ 717 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 718 MXT_TOUCH_TCHTHR, pdata->threshold); 719 720 /* Set touchscreen resolution */ 721 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 722 MXT_TOUCH_XRANGE_LSB, (pdata->x_size - 1) & 0xff); 723 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 724 MXT_TOUCH_XRANGE_MSB, (pdata->x_size - 1) >> 8); 725 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 726 MXT_TOUCH_YRANGE_LSB, (pdata->y_size - 1) & 0xff); 727 mxt_write_object(data, MXT_TOUCH_MULTI_T9, 728 MXT_TOUCH_YRANGE_MSB, (pdata->y_size - 1) >> 8); 729 730 /* Set touchscreen voltage */ 731 if (pdata->voltage) { 732 if (pdata->voltage < MXT_VOLTAGE_DEFAULT) { 733 voltage = (MXT_VOLTAGE_DEFAULT - pdata->voltage) / 734 MXT_VOLTAGE_STEP; 735 voltage = 0xff - voltage + 1; 736 } else 737 voltage = (pdata->voltage - MXT_VOLTAGE_DEFAULT) / 738 MXT_VOLTAGE_STEP; 739 740 mxt_write_object(data, MXT_SPT_CTECONFIG_T28, 741 MXT_CTE_VOLTAGE, voltage); 742 } 743 } 744 745 static int mxt_get_info(struct mxt_data *data) 746 { 747 struct i2c_client *client = data->client; 748 struct mxt_info *info = &data->info; 749 int error; 750 u8 val; 751 752 error = mxt_read_reg(client, MXT_FAMILY_ID, &val); 753 if (error) 754 return error; 755 info->family_id = val; 756 757 error = mxt_read_reg(client, MXT_VARIANT_ID, &val); 758 if (error) 759 return error; 760 info->variant_id = val; 761 762 error = mxt_read_reg(client, MXT_VERSION, &val); 763 if (error) 764 return error; 765 info->version = val; 766 767 error = mxt_read_reg(client, MXT_BUILD, &val); 768 if (error) 769 return error; 770 info->build = val; 771 772 error = mxt_read_reg(client, MXT_OBJECT_NUM, &val); 773 if (error) 774 return error; 775 info->object_num = val; 776 777 return 0; 778 } 779 780 static int mxt_get_object_table(struct mxt_data *data) 781 { 782 int error; 783 int i; 784 u16 reg; 785 u8 reportid = 0; 786 u8 buf[MXT_OBJECT_SIZE]; 787 788 for (i = 0; i < data->info.object_num; i++) { 789 struct mxt_object *object = data->object_table + i; 790 791 reg = MXT_OBJECT_START + MXT_OBJECT_SIZE * i; 792 error = mxt_read_object_table(data->client, reg, buf); 793 if (error) 794 return error; 795 796 object->type = buf[0]; 797 object->start_address = (buf[2] << 8) | buf[1]; 798 object->size = buf[3]; 799 object->instances = buf[4]; 800 object->num_report_ids = buf[5]; 801 802 if (object->num_report_ids) { 803 reportid += object->num_report_ids * 804 (object->instances + 1); 805 object->max_reportid = reportid; 806 } 807 } 808 809 return 0; 810 } 811 812 static int mxt_initialize(struct mxt_data *data) 813 { 814 struct i2c_client *client = data->client; 815 struct mxt_info *info = &data->info; 816 int error; 817 u8 val; 818 819 error = mxt_get_info(data); 820 if (error) 821 return error; 822 823 data->object_table = kcalloc(info->object_num, 824 sizeof(struct mxt_object), 825 GFP_KERNEL); 826 if (!data->object_table) { 827 dev_err(&client->dev, "Failed to allocate memory\n"); 828 return -ENOMEM; 829 } 830 831 /* Get object table information */ 832 error = mxt_get_object_table(data); 833 if (error) 834 return error; 835 836 /* Check register init values */ 837 error = mxt_check_reg_init(data); 838 if (error) 839 return error; 840 841 mxt_handle_pdata(data); 842 843 /* Backup to memory */ 844 mxt_write_object(data, MXT_GEN_COMMAND_T6, 845 MXT_COMMAND_BACKUPNV, 846 MXT_BACKUP_VALUE); 847 msleep(MXT_BACKUP_TIME); 848 849 /* Soft reset */ 850 mxt_write_object(data, MXT_GEN_COMMAND_T6, 851 MXT_COMMAND_RESET, 1); 852 msleep(MXT_RESET_TIME); 853 854 /* Update matrix size at info struct */ 855 error = mxt_read_reg(client, MXT_MATRIX_X_SIZE, &val); 856 if (error) 857 return error; 858 info->matrix_xsize = val; 859 860 error = mxt_read_reg(client, MXT_MATRIX_Y_SIZE, &val); 861 if (error) 862 return error; 863 info->matrix_ysize = val; 864 865 dev_info(&client->dev, 866 "Family ID: %d Variant ID: %d Version: %d Build: %d\n", 867 info->family_id, info->variant_id, info->version, 868 info->build); 869 870 dev_info(&client->dev, 871 "Matrix X Size: %d Matrix Y Size: %d Object Num: %d\n", 872 info->matrix_xsize, info->matrix_ysize, 873 info->object_num); 874 875 return 0; 876 } 877 878 static void mxt_calc_resolution(struct mxt_data *data) 879 { 880 unsigned int max_x = data->pdata->x_size - 1; 881 unsigned int max_y = data->pdata->y_size - 1; 882 883 if (data->pdata->orient & MXT_XY_SWITCH) { 884 data->max_x = max_y; 885 data->max_y = max_x; 886 } else { 887 data->max_x = max_x; 888 data->max_y = max_y; 889 } 890 } 891 892 static ssize_t mxt_object_show(struct device *dev, 893 struct device_attribute *attr, char *buf) 894 { 895 struct mxt_data *data = dev_get_drvdata(dev); 896 struct mxt_object *object; 897 int count = 0; 898 int i, j; 899 int error; 900 u8 val; 901 902 for (i = 0; i < data->info.object_num; i++) { 903 object = data->object_table + i; 904 905 count += sprintf(buf + count, 906 "Object Table Element %d(Type %d)\n", 907 i + 1, object->type); 908 909 if (!mxt_object_readable(object->type)) { 910 count += sprintf(buf + count, "\n"); 911 continue; 912 } 913 914 for (j = 0; j < object->size + 1; j++) { 915 error = mxt_read_object(data, 916 object->type, j, &val); 917 if (error) 918 return error; 919 920 count += sprintf(buf + count, 921 " Byte %d: 0x%x (%d)\n", j, val, val); 922 } 923 924 count += sprintf(buf + count, "\n"); 925 } 926 927 return count; 928 } 929 930 static int mxt_load_fw(struct device *dev, const char *fn) 931 { 932 struct mxt_data *data = dev_get_drvdata(dev); 933 struct i2c_client *client = data->client; 934 const struct firmware *fw = NULL; 935 unsigned int frame_size; 936 unsigned int pos = 0; 937 int ret; 938 939 ret = request_firmware(&fw, fn, dev); 940 if (ret) { 941 dev_err(dev, "Unable to open firmware %s\n", fn); 942 return ret; 943 } 944 945 /* Change to the bootloader mode */ 946 mxt_write_object(data, MXT_GEN_COMMAND_T6, 947 MXT_COMMAND_RESET, MXT_BOOT_VALUE); 948 msleep(MXT_RESET_TIME); 949 950 /* Change to slave address of bootloader */ 951 if (client->addr == MXT_APP_LOW) 952 client->addr = MXT_BOOT_LOW; 953 else 954 client->addr = MXT_BOOT_HIGH; 955 956 ret = mxt_check_bootloader(client, MXT_WAITING_BOOTLOAD_CMD); 957 if (ret) 958 goto out; 959 960 /* Unlock bootloader */ 961 mxt_unlock_bootloader(client); 962 963 while (pos < fw->size) { 964 ret = mxt_check_bootloader(client, 965 MXT_WAITING_FRAME_DATA); 966 if (ret) 967 goto out; 968 969 frame_size = ((*(fw->data + pos) << 8) | *(fw->data + pos + 1)); 970 971 /* We should add 2 at frame size as the the firmware data is not 972 * included the CRC bytes. 973 */ 974 frame_size += 2; 975 976 /* Write one frame to device */ 977 mxt_fw_write(client, fw->data + pos, frame_size); 978 979 ret = mxt_check_bootloader(client, 980 MXT_FRAME_CRC_PASS); 981 if (ret) 982 goto out; 983 984 pos += frame_size; 985 986 dev_dbg(dev, "Updated %d bytes / %zd bytes\n", pos, fw->size); 987 } 988 989 out: 990 release_firmware(fw); 991 992 /* Change to slave address of application */ 993 if (client->addr == MXT_BOOT_LOW) 994 client->addr = MXT_APP_LOW; 995 else 996 client->addr = MXT_APP_HIGH; 997 998 return ret; 999 } 1000 1001 static ssize_t mxt_update_fw_store(struct device *dev, 1002 struct device_attribute *attr, 1003 const char *buf, size_t count) 1004 { 1005 struct mxt_data *data = dev_get_drvdata(dev); 1006 int error; 1007 1008 disable_irq(data->irq); 1009 1010 error = mxt_load_fw(dev, MXT_FW_NAME); 1011 if (error) { 1012 dev_err(dev, "The firmware update failed(%d)\n", error); 1013 count = error; 1014 } else { 1015 dev_dbg(dev, "The firmware update succeeded\n"); 1016 1017 /* Wait for reset */ 1018 msleep(MXT_FWRESET_TIME); 1019 1020 kfree(data->object_table); 1021 data->object_table = NULL; 1022 1023 mxt_initialize(data); 1024 } 1025 1026 enable_irq(data->irq); 1027 1028 error = mxt_make_highchg(data); 1029 if (error) 1030 return error; 1031 1032 return count; 1033 } 1034 1035 static DEVICE_ATTR(object, 0444, mxt_object_show, NULL); 1036 static DEVICE_ATTR(update_fw, 0664, NULL, mxt_update_fw_store); 1037 1038 static struct attribute *mxt_attrs[] = { 1039 &dev_attr_object.attr, 1040 &dev_attr_update_fw.attr, 1041 NULL 1042 }; 1043 1044 static const struct attribute_group mxt_attr_group = { 1045 .attrs = mxt_attrs, 1046 }; 1047 1048 static void mxt_start(struct mxt_data *data) 1049 { 1050 /* Touch enable */ 1051 mxt_write_object(data, 1052 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0x83); 1053 } 1054 1055 static void mxt_stop(struct mxt_data *data) 1056 { 1057 /* Touch disable */ 1058 mxt_write_object(data, 1059 MXT_TOUCH_MULTI_T9, MXT_TOUCH_CTRL, 0); 1060 } 1061 1062 static int mxt_input_open(struct input_dev *dev) 1063 { 1064 struct mxt_data *data = input_get_drvdata(dev); 1065 1066 mxt_start(data); 1067 1068 return 0; 1069 } 1070 1071 static void mxt_input_close(struct input_dev *dev) 1072 { 1073 struct mxt_data *data = input_get_drvdata(dev); 1074 1075 mxt_stop(data); 1076 } 1077 1078 static int __devinit mxt_probe(struct i2c_client *client, 1079 const struct i2c_device_id *id) 1080 { 1081 const struct mxt_platform_data *pdata = client->dev.platform_data; 1082 struct mxt_data *data; 1083 struct input_dev *input_dev; 1084 int error; 1085 1086 if (!pdata) 1087 return -EINVAL; 1088 1089 data = kzalloc(sizeof(struct mxt_data), GFP_KERNEL); 1090 input_dev = input_allocate_device(); 1091 if (!data || !input_dev) { 1092 dev_err(&client->dev, "Failed to allocate memory\n"); 1093 error = -ENOMEM; 1094 goto err_free_mem; 1095 } 1096 1097 input_dev->name = "Atmel maXTouch Touchscreen"; 1098 input_dev->id.bustype = BUS_I2C; 1099 input_dev->dev.parent = &client->dev; 1100 input_dev->open = mxt_input_open; 1101 input_dev->close = mxt_input_close; 1102 1103 data->client = client; 1104 data->input_dev = input_dev; 1105 data->pdata = pdata; 1106 data->irq = client->irq; 1107 1108 mxt_calc_resolution(data); 1109 1110 __set_bit(EV_ABS, input_dev->evbit); 1111 __set_bit(EV_KEY, input_dev->evbit); 1112 __set_bit(BTN_TOUCH, input_dev->keybit); 1113 1114 /* For single touch */ 1115 input_set_abs_params(input_dev, ABS_X, 1116 0, data->max_x, 0, 0); 1117 input_set_abs_params(input_dev, ABS_Y, 1118 0, data->max_y, 0, 0); 1119 1120 /* For multi touch */ 1121 input_mt_init_slots(input_dev, MXT_MAX_FINGER); 1122 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 1123 0, MXT_MAX_AREA, 0, 0); 1124 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 1125 0, data->max_x, 0, 0); 1126 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 1127 0, data->max_y, 0, 0); 1128 1129 input_set_drvdata(input_dev, data); 1130 i2c_set_clientdata(client, data); 1131 1132 error = mxt_initialize(data); 1133 if (error) 1134 goto err_free_object; 1135 1136 error = request_threaded_irq(client->irq, NULL, mxt_interrupt, 1137 pdata->irqflags, client->dev.driver->name, data); 1138 if (error) { 1139 dev_err(&client->dev, "Failed to register interrupt\n"); 1140 goto err_free_object; 1141 } 1142 1143 error = mxt_make_highchg(data); 1144 if (error) 1145 goto err_free_irq; 1146 1147 error = input_register_device(input_dev); 1148 if (error) 1149 goto err_free_irq; 1150 1151 error = sysfs_create_group(&client->dev.kobj, &mxt_attr_group); 1152 if (error) 1153 goto err_unregister_device; 1154 1155 return 0; 1156 1157 err_unregister_device: 1158 input_unregister_device(input_dev); 1159 input_dev = NULL; 1160 err_free_irq: 1161 free_irq(client->irq, data); 1162 err_free_object: 1163 kfree(data->object_table); 1164 err_free_mem: 1165 input_free_device(input_dev); 1166 kfree(data); 1167 return error; 1168 } 1169 1170 static int __devexit mxt_remove(struct i2c_client *client) 1171 { 1172 struct mxt_data *data = i2c_get_clientdata(client); 1173 1174 sysfs_remove_group(&client->dev.kobj, &mxt_attr_group); 1175 free_irq(data->irq, data); 1176 input_unregister_device(data->input_dev); 1177 kfree(data->object_table); 1178 kfree(data); 1179 1180 return 0; 1181 } 1182 1183 #ifdef CONFIG_PM 1184 static int mxt_suspend(struct device *dev) 1185 { 1186 struct i2c_client *client = to_i2c_client(dev); 1187 struct mxt_data *data = i2c_get_clientdata(client); 1188 struct input_dev *input_dev = data->input_dev; 1189 1190 mutex_lock(&input_dev->mutex); 1191 1192 if (input_dev->users) 1193 mxt_stop(data); 1194 1195 mutex_unlock(&input_dev->mutex); 1196 1197 return 0; 1198 } 1199 1200 static int mxt_resume(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 /* Soft reset */ 1207 mxt_write_object(data, MXT_GEN_COMMAND_T6, 1208 MXT_COMMAND_RESET, 1); 1209 1210 msleep(MXT_RESET_TIME); 1211 1212 mutex_lock(&input_dev->mutex); 1213 1214 if (input_dev->users) 1215 mxt_start(data); 1216 1217 mutex_unlock(&input_dev->mutex); 1218 1219 return 0; 1220 } 1221 1222 static const struct dev_pm_ops mxt_pm_ops = { 1223 .suspend = mxt_suspend, 1224 .resume = mxt_resume, 1225 }; 1226 #endif 1227 1228 static const struct i2c_device_id mxt_id[] = { 1229 { "qt602240_ts", 0 }, 1230 { "atmel_mxt_ts", 0 }, 1231 { "mXT224", 0 }, 1232 { } 1233 }; 1234 MODULE_DEVICE_TABLE(i2c, mxt_id); 1235 1236 static struct i2c_driver mxt_driver = { 1237 .driver = { 1238 .name = "atmel_mxt_ts", 1239 .owner = THIS_MODULE, 1240 #ifdef CONFIG_PM 1241 .pm = &mxt_pm_ops, 1242 #endif 1243 }, 1244 .probe = mxt_probe, 1245 .remove = __devexit_p(mxt_remove), 1246 .id_table = mxt_id, 1247 }; 1248 1249 static int __init mxt_init(void) 1250 { 1251 return i2c_add_driver(&mxt_driver); 1252 } 1253 1254 static void __exit mxt_exit(void) 1255 { 1256 i2c_del_driver(&mxt_driver); 1257 } 1258 1259 module_init(mxt_init); 1260 module_exit(mxt_exit); 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