1 /* 2 * ROHM BU21023/24 Dual touch support resistive touch screen driver 3 * Copyright (C) 2012 ROHM CO.,LTD. 4 * 5 * This software is licensed under the terms of the GNU General Public 6 * License version 2, as published by the Free Software Foundation, and 7 * may be copied, distributed, and modified under those terms. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 */ 14 #include <linux/delay.h> 15 #include <linux/firmware.h> 16 #include <linux/i2c.h> 17 #include <linux/input.h> 18 #include <linux/input/mt.h> 19 #include <linux/interrupt.h> 20 #include <linux/module.h> 21 #include <linux/slab.h> 22 23 #define BU21023_NAME "bu21023_ts" 24 #define BU21023_FIRMWARE_NAME "bu21023.bin" 25 26 #define MAX_CONTACTS 2 27 28 #define AXIS_ADJUST 4 29 #define AXIS_OFFSET 8 30 31 #define FIRMWARE_BLOCK_SIZE 32U 32 #define FIRMWARE_RETRY_MAX 4 33 34 #define SAMPLING_DELAY 12 /* msec */ 35 36 #define CALIBRATION_RETRY_MAX 6 37 38 #define ROHM_TS_ABS_X_MIN 40 39 #define ROHM_TS_ABS_X_MAX 990 40 #define ROHM_TS_ABS_Y_MIN 160 41 #define ROHM_TS_ABS_Y_MAX 920 42 #define ROHM_TS_DISPLACEMENT_MAX 0 /* zero for infinite */ 43 44 /* 45 * BU21023GUL/BU21023MUV/BU21024FV-M registers map 46 */ 47 #define VADOUT_YP_H 0x00 48 #define VADOUT_YP_L 0x01 49 #define VADOUT_XP_H 0x02 50 #define VADOUT_XP_L 0x03 51 #define VADOUT_YN_H 0x04 52 #define VADOUT_YN_L 0x05 53 #define VADOUT_XN_H 0x06 54 #define VADOUT_XN_L 0x07 55 56 #define PRM1_X_H 0x08 57 #define PRM1_X_L 0x09 58 #define PRM1_Y_H 0x0a 59 #define PRM1_Y_L 0x0b 60 #define PRM2_X_H 0x0c 61 #define PRM2_X_L 0x0d 62 #define PRM2_Y_H 0x0e 63 #define PRM2_Y_L 0x0f 64 65 #define MLT_PRM_MONI_X 0x10 66 #define MLT_PRM_MONI_Y 0x11 67 68 #define DEBUG_MONI_1 0x12 69 #define DEBUG_MONI_2 0x13 70 71 #define VADOUT_ZX_H 0x14 72 #define VADOUT_ZX_L 0x15 73 #define VADOUT_ZY_H 0x16 74 #define VADOUT_ZY_L 0x17 75 76 #define Z_PARAM_H 0x18 77 #define Z_PARAM_L 0x19 78 79 /* 80 * Value for VADOUT_*_L 81 */ 82 #define VADOUT_L_MASK 0x01 83 84 /* 85 * Value for PRM*_*_L 86 */ 87 #define PRM_L_MASK 0x01 88 89 #define POS_X1_H 0x20 90 #define POS_X1_L 0x21 91 #define POS_Y1_H 0x22 92 #define POS_Y1_L 0x23 93 #define POS_X2_H 0x24 94 #define POS_X2_L 0x25 95 #define POS_Y2_H 0x26 96 #define POS_Y2_L 0x27 97 98 /* 99 * Value for POS_*_L 100 */ 101 #define POS_L_MASK 0x01 102 103 #define TOUCH 0x28 104 #define TOUCH_DETECT 0x01 105 106 #define TOUCH_GESTURE 0x29 107 #define SINGLE_TOUCH 0x01 108 #define DUAL_TOUCH 0x03 109 #define TOUCH_MASK 0x03 110 #define CALIBRATION_REQUEST 0x04 111 #define CALIBRATION_STATUS 0x08 112 #define CALIBRATION_MASK 0x0c 113 #define GESTURE_SPREAD 0x10 114 #define GESTURE_PINCH 0x20 115 #define GESTURE_ROTATE_R 0x40 116 #define GESTURE_ROTATE_L 0x80 117 118 #define INT_STATUS 0x2a 119 #define INT_MASK 0x3d 120 #define INT_CLEAR 0x3e 121 122 /* 123 * Values for INT_* 124 */ 125 #define COORD_UPDATE 0x01 126 #define CALIBRATION_DONE 0x02 127 #define SLEEP_IN 0x04 128 #define SLEEP_OUT 0x08 129 #define PROGRAM_LOAD_DONE 0x10 130 #define ERROR 0x80 131 #define INT_ALL 0x9f 132 133 #define ERR_STATUS 0x2b 134 #define ERR_MASK 0x3f 135 136 /* 137 * Values for ERR_* 138 */ 139 #define ADC_TIMEOUT 0x01 140 #define CPU_TIMEOUT 0x02 141 #define CALIBRATION_ERR 0x04 142 #define PROGRAM_LOAD_ERR 0x10 143 144 #define COMMON_SETUP1 0x30 145 #define PROGRAM_LOAD_HOST 0x02 146 #define PROGRAM_LOAD_EEPROM 0x03 147 #define CENSOR_4PORT 0x04 148 #define CENSOR_8PORT 0x00 /* Not supported by BU21023 */ 149 #define CALIBRATION_TYPE_DEFAULT 0x08 150 #define CALIBRATION_TYPE_SPECIAL 0x00 151 #define INT_ACTIVE_HIGH 0x10 152 #define INT_ACTIVE_LOW 0x00 153 #define AUTO_CALIBRATION 0x40 154 #define MANUAL_CALIBRATION 0x00 155 #define COMMON_SETUP1_DEFAULT 0x4e 156 157 #define COMMON_SETUP2 0x31 158 #define MAF_NONE 0x00 159 #define MAF_1SAMPLE 0x01 160 #define MAF_3SAMPLES 0x02 161 #define MAF_5SAMPLES 0x03 162 #define INV_Y 0x04 163 #define INV_X 0x08 164 #define SWAP_XY 0x10 165 166 #define COMMON_SETUP3 0x32 167 #define EN_SLEEP 0x01 168 #define EN_MULTI 0x02 169 #define EN_GESTURE 0x04 170 #define EN_INTVL 0x08 171 #define SEL_STEP 0x10 172 #define SEL_MULTI 0x20 173 #define SEL_TBL_DEFAULT 0x40 174 175 #define INTERVAL_TIME 0x33 176 #define INTERVAL_TIME_DEFAULT 0x10 177 178 #define STEP_X 0x34 179 #define STEP_X_DEFAULT 0x41 180 181 #define STEP_Y 0x35 182 #define STEP_Y_DEFAULT 0x8d 183 184 #define OFFSET_X 0x38 185 #define OFFSET_X_DEFAULT 0x0c 186 187 #define OFFSET_Y 0x39 188 #define OFFSET_Y_DEFAULT 0x0c 189 190 #define THRESHOLD_TOUCH 0x3a 191 #define THRESHOLD_TOUCH_DEFAULT 0xa0 192 193 #define THRESHOLD_GESTURE 0x3b 194 #define THRESHOLD_GESTURE_DEFAULT 0x17 195 196 #define SYSTEM 0x40 197 #define ANALOG_POWER_ON 0x01 198 #define ANALOG_POWER_OFF 0x00 199 #define CPU_POWER_ON 0x02 200 #define CPU_POWER_OFF 0x00 201 202 #define FORCE_CALIBRATION 0x42 203 #define FORCE_CALIBRATION_ON 0x01 204 #define FORCE_CALIBRATION_OFF 0x00 205 206 #define CPU_FREQ 0x50 /* 10 / (reg + 1) MHz */ 207 #define CPU_FREQ_10MHZ 0x00 208 #define CPU_FREQ_5MHZ 0x01 209 #define CPU_FREQ_1MHZ 0x09 210 211 #define EEPROM_ADDR 0x51 212 213 #define CALIBRATION_ADJUST 0x52 214 #define CALIBRATION_ADJUST_DEFAULT 0x00 215 216 #define THRESHOLD_SLEEP_IN 0x53 217 218 #define EVR_XY 0x56 219 #define EVR_XY_DEFAULT 0x10 220 221 #define PRM_SWOFF_TIME 0x57 222 #define PRM_SWOFF_TIME_DEFAULT 0x04 223 224 #define PROGRAM_VERSION 0x5f 225 226 #define ADC_CTRL 0x60 227 #define ADC_DIV_MASK 0x1f /* The minimum value is 4 */ 228 #define ADC_DIV_DEFAULT 0x08 229 230 #define ADC_WAIT 0x61 231 #define ADC_WAIT_DEFAULT 0x0a 232 233 #define SWCONT 0x62 234 #define SWCONT_DEFAULT 0x0f 235 236 #define EVR_X 0x63 237 #define EVR_X_DEFAULT 0x86 238 239 #define EVR_Y 0x64 240 #define EVR_Y_DEFAULT 0x64 241 242 #define TEST1 0x65 243 #define DUALTOUCH_STABILIZE_ON 0x01 244 #define DUALTOUCH_STABILIZE_OFF 0x00 245 #define DUALTOUCH_REG_ON 0x20 246 #define DUALTOUCH_REG_OFF 0x00 247 248 #define CALIBRATION_REG1 0x68 249 #define CALIBRATION_REG1_DEFAULT 0xd9 250 251 #define CALIBRATION_REG2 0x69 252 #define CALIBRATION_REG2_DEFAULT 0x36 253 254 #define CALIBRATION_REG3 0x6a 255 #define CALIBRATION_REG3_DEFAULT 0x32 256 257 #define EX_ADDR_H 0x70 258 #define EX_ADDR_L 0x71 259 #define EX_WDAT 0x72 260 #define EX_RDAT 0x73 261 #define EX_CHK_SUM1 0x74 262 #define EX_CHK_SUM2 0x75 263 #define EX_CHK_SUM3 0x76 264 265 struct rohm_ts_data { 266 struct i2c_client *client; 267 struct input_dev *input; 268 269 bool initialized; 270 271 unsigned int contact_count[MAX_CONTACTS + 1]; 272 int finger_count; 273 274 u8 setup2; 275 }; 276 277 /* 278 * rohm_i2c_burst_read - execute combined I2C message for ROHM BU21023/24 279 * @client: Handle to ROHM BU21023/24 280 * @start: Where to start read address from ROHM BU21023/24 281 * @buf: Where to store read data from ROHM BU21023/24 282 * @len: How many bytes to read 283 * 284 * Returns negative errno, else zero on success. 285 * 286 * Note 287 * In BU21023/24 burst read, stop condition is needed after "address write". 288 * Therefore, transmission is performed in 2 steps. 289 */ 290 static int rohm_i2c_burst_read(struct i2c_client *client, u8 start, void *buf, 291 size_t len) 292 { 293 struct i2c_adapter *adap = client->adapter; 294 struct i2c_msg msg[2]; 295 int i, ret = 0; 296 297 msg[0].addr = client->addr; 298 msg[0].flags = 0; 299 msg[0].len = 1; 300 msg[0].buf = &start; 301 302 msg[1].addr = client->addr; 303 msg[1].flags = I2C_M_RD; 304 msg[1].len = len; 305 msg[1].buf = buf; 306 307 i2c_lock_adapter(adap); 308 309 for (i = 0; i < 2; i++) { 310 if (__i2c_transfer(adap, &msg[i], 1) < 0) { 311 ret = -EIO; 312 break; 313 } 314 } 315 316 i2c_unlock_adapter(adap); 317 318 return ret; 319 } 320 321 static int rohm_ts_manual_calibration(struct rohm_ts_data *ts) 322 { 323 struct i2c_client *client = ts->client; 324 struct device *dev = &client->dev; 325 u8 buf[33]; /* for PRM1_X_H(0x08)-TOUCH(0x28) */ 326 327 int retry; 328 bool success = false; 329 bool first_time = true; 330 bool calibration_done; 331 332 u8 reg1, reg2, reg3; 333 s32 reg1_orig, reg2_orig, reg3_orig; 334 s32 val; 335 336 int calib_x = 0, calib_y = 0; 337 int reg_x, reg_y; 338 int err_x, err_y; 339 340 int error, error2; 341 int i; 342 343 reg1_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG1); 344 if (reg1_orig < 0) 345 return reg1_orig; 346 347 reg2_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG2); 348 if (reg2_orig < 0) 349 return reg2_orig; 350 351 reg3_orig = i2c_smbus_read_byte_data(client, CALIBRATION_REG3); 352 if (reg3_orig < 0) 353 return reg3_orig; 354 355 error = i2c_smbus_write_byte_data(client, INT_MASK, 356 COORD_UPDATE | SLEEP_IN | SLEEP_OUT | 357 PROGRAM_LOAD_DONE); 358 if (error) 359 goto out; 360 361 error = i2c_smbus_write_byte_data(client, TEST1, 362 DUALTOUCH_STABILIZE_ON); 363 if (error) 364 goto out; 365 366 for (retry = 0; retry < CALIBRATION_RETRY_MAX; retry++) { 367 /* wait 2 sampling for update */ 368 mdelay(2 * SAMPLING_DELAY); 369 370 #define READ_CALIB_BUF(reg) buf[((reg) - PRM1_X_H)] 371 372 error = rohm_i2c_burst_read(client, PRM1_X_H, buf, sizeof(buf)); 373 if (error) 374 goto out; 375 376 if (READ_CALIB_BUF(TOUCH) & TOUCH_DETECT) 377 continue; 378 379 if (first_time) { 380 /* generate calibration parameter */ 381 calib_x = ((int)READ_CALIB_BUF(PRM1_X_H) << 2 | 382 READ_CALIB_BUF(PRM1_X_L)) - AXIS_OFFSET; 383 calib_y = ((int)READ_CALIB_BUF(PRM1_Y_H) << 2 | 384 READ_CALIB_BUF(PRM1_Y_L)) - AXIS_OFFSET; 385 386 error = i2c_smbus_write_byte_data(client, TEST1, 387 DUALTOUCH_STABILIZE_ON | DUALTOUCH_REG_ON); 388 if (error) 389 goto out; 390 391 first_time = false; 392 } else { 393 /* generate adjustment parameter */ 394 err_x = (int)READ_CALIB_BUF(PRM1_X_H) << 2 | 395 READ_CALIB_BUF(PRM1_X_L); 396 err_y = (int)READ_CALIB_BUF(PRM1_Y_H) << 2 | 397 READ_CALIB_BUF(PRM1_Y_L); 398 399 /* X axis ajust */ 400 if (err_x <= 4) 401 calib_x -= AXIS_ADJUST; 402 else if (err_x >= 60) 403 calib_x += AXIS_ADJUST; 404 405 /* Y axis ajust */ 406 if (err_y <= 4) 407 calib_y -= AXIS_ADJUST; 408 else if (err_y >= 60) 409 calib_y += AXIS_ADJUST; 410 } 411 412 /* generate calibration setting value */ 413 reg_x = calib_x + ((calib_x & 0x200) << 1); 414 reg_y = calib_y + ((calib_y & 0x200) << 1); 415 416 /* convert for register format */ 417 reg1 = reg_x >> 3; 418 reg2 = (reg_y & 0x7) << 4 | (reg_x & 0x7); 419 reg3 = reg_y >> 3; 420 421 error = i2c_smbus_write_byte_data(client, 422 CALIBRATION_REG1, reg1); 423 if (error) 424 goto out; 425 426 error = i2c_smbus_write_byte_data(client, 427 CALIBRATION_REG2, reg2); 428 if (error) 429 goto out; 430 431 error = i2c_smbus_write_byte_data(client, 432 CALIBRATION_REG3, reg3); 433 if (error) 434 goto out; 435 436 /* 437 * force calibration sequcence 438 */ 439 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, 440 FORCE_CALIBRATION_OFF); 441 if (error) 442 goto out; 443 444 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, 445 FORCE_CALIBRATION_ON); 446 if (error) 447 goto out; 448 449 /* clear all interrupts */ 450 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 451 if (error) 452 goto out; 453 454 /* 455 * Wait for the status change of calibration, max 10 sampling 456 */ 457 calibration_done = false; 458 459 for (i = 0; i < 10; i++) { 460 mdelay(SAMPLING_DELAY); 461 462 val = i2c_smbus_read_byte_data(client, TOUCH_GESTURE); 463 if (!(val & CALIBRATION_MASK)) { 464 calibration_done = true; 465 break; 466 } else if (val < 0) { 467 error = val; 468 goto out; 469 } 470 } 471 472 if (calibration_done) { 473 val = i2c_smbus_read_byte_data(client, INT_STATUS); 474 if (val == CALIBRATION_DONE) { 475 success = true; 476 break; 477 } else if (val < 0) { 478 error = val; 479 goto out; 480 } 481 } else { 482 dev_warn(dev, "calibration timeout\n"); 483 } 484 } 485 486 if (!success) { 487 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1, 488 reg1_orig); 489 if (error) 490 goto out; 491 492 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2, 493 reg2_orig); 494 if (error) 495 goto out; 496 497 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3, 498 reg3_orig); 499 if (error) 500 goto out; 501 502 /* calibration data enable */ 503 error = i2c_smbus_write_byte_data(client, TEST1, 504 DUALTOUCH_STABILIZE_ON | 505 DUALTOUCH_REG_ON); 506 if (error) 507 goto out; 508 509 /* wait 10 sampling */ 510 mdelay(10 * SAMPLING_DELAY); 511 512 error = -EBUSY; 513 } 514 515 out: 516 error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL); 517 if (!error2) 518 /* Clear all interrupts */ 519 error2 = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 520 521 return error ? error : error2; 522 } 523 524 static const unsigned int untouch_threshold[3] = { 0, 1, 5 }; 525 static const unsigned int single_touch_threshold[3] = { 0, 0, 4 }; 526 static const unsigned int dual_touch_threshold[3] = { 10, 8, 0 }; 527 528 static irqreturn_t rohm_ts_soft_irq(int irq, void *dev_id) 529 { 530 struct rohm_ts_data *ts = dev_id; 531 struct i2c_client *client = ts->client; 532 struct input_dev *input_dev = ts->input; 533 struct device *dev = &client->dev; 534 535 u8 buf[10]; /* for POS_X1_H(0x20)-TOUCH_GESTURE(0x29) */ 536 537 struct input_mt_pos pos[MAX_CONTACTS]; 538 int slots[MAX_CONTACTS]; 539 u8 touch_flags; 540 unsigned int threshold; 541 int finger_count = -1; 542 int prev_finger_count = ts->finger_count; 543 int count; 544 int error; 545 int i; 546 547 error = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL); 548 if (error) 549 return IRQ_HANDLED; 550 551 /* Clear all interrupts */ 552 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 553 if (error) 554 return IRQ_HANDLED; 555 556 #define READ_POS_BUF(reg) buf[((reg) - POS_X1_H)] 557 558 error = rohm_i2c_burst_read(client, POS_X1_H, buf, sizeof(buf)); 559 if (error) 560 return IRQ_HANDLED; 561 562 touch_flags = READ_POS_BUF(TOUCH_GESTURE) & TOUCH_MASK; 563 if (touch_flags) { 564 /* generate coordinates */ 565 pos[0].x = ((s16)READ_POS_BUF(POS_X1_H) << 2) | 566 READ_POS_BUF(POS_X1_L); 567 pos[0].y = ((s16)READ_POS_BUF(POS_Y1_H) << 2) | 568 READ_POS_BUF(POS_Y1_L); 569 pos[1].x = ((s16)READ_POS_BUF(POS_X2_H) << 2) | 570 READ_POS_BUF(POS_X2_L); 571 pos[1].y = ((s16)READ_POS_BUF(POS_Y2_H) << 2) | 572 READ_POS_BUF(POS_Y2_L); 573 } 574 575 switch (touch_flags) { 576 case 0: 577 threshold = untouch_threshold[prev_finger_count]; 578 if (++ts->contact_count[0] >= threshold) 579 finger_count = 0; 580 break; 581 582 case SINGLE_TOUCH: 583 threshold = single_touch_threshold[prev_finger_count]; 584 if (++ts->contact_count[1] >= threshold) 585 finger_count = 1; 586 587 if (finger_count == 1) { 588 if (pos[1].x != 0 && pos[1].y != 0) { 589 pos[0].x = pos[1].x; 590 pos[0].y = pos[1].y; 591 pos[1].x = 0; 592 pos[1].y = 0; 593 } 594 } 595 break; 596 597 case DUAL_TOUCH: 598 threshold = dual_touch_threshold[prev_finger_count]; 599 if (++ts->contact_count[2] >= threshold) 600 finger_count = 2; 601 break; 602 603 default: 604 dev_dbg(dev, 605 "Three or more touches are not supported\n"); 606 return IRQ_HANDLED; 607 } 608 609 if (finger_count >= 0) { 610 if (prev_finger_count != finger_count) { 611 count = ts->contact_count[finger_count]; 612 memset(ts->contact_count, 0, sizeof(ts->contact_count)); 613 ts->contact_count[finger_count] = count; 614 } 615 616 input_mt_assign_slots(input_dev, slots, pos, 617 finger_count, ROHM_TS_DISPLACEMENT_MAX); 618 619 for (i = 0; i < finger_count; i++) { 620 input_mt_slot(input_dev, slots[i]); 621 input_mt_report_slot_state(input_dev, 622 MT_TOOL_FINGER, true); 623 input_report_abs(input_dev, 624 ABS_MT_POSITION_X, pos[i].x); 625 input_report_abs(input_dev, 626 ABS_MT_POSITION_Y, pos[i].y); 627 } 628 629 input_mt_sync_frame(input_dev); 630 input_mt_report_pointer_emulation(input_dev, true); 631 input_sync(input_dev); 632 633 ts->finger_count = finger_count; 634 } 635 636 if (READ_POS_BUF(TOUCH_GESTURE) & CALIBRATION_REQUEST) { 637 error = rohm_ts_manual_calibration(ts); 638 if (error) 639 dev_warn(dev, "manual calibration failed: %d\n", 640 error); 641 } 642 643 i2c_smbus_write_byte_data(client, INT_MASK, 644 CALIBRATION_DONE | SLEEP_OUT | SLEEP_IN | 645 PROGRAM_LOAD_DONE); 646 647 return IRQ_HANDLED; 648 } 649 650 static int rohm_ts_load_firmware(struct i2c_client *client, 651 const char *firmware_name) 652 { 653 struct device *dev = &client->dev; 654 const struct firmware *fw; 655 s32 status; 656 unsigned int offset, len, xfer_len; 657 unsigned int retry = 0; 658 int error, error2; 659 660 error = request_firmware(&fw, firmware_name, dev); 661 if (error) { 662 dev_err(dev, "unable to retrieve firmware %s: %d\n", 663 firmware_name, error); 664 return error; 665 } 666 667 error = i2c_smbus_write_byte_data(client, INT_MASK, 668 COORD_UPDATE | CALIBRATION_DONE | 669 SLEEP_IN | SLEEP_OUT); 670 if (error) 671 goto out; 672 673 do { 674 if (retry) { 675 dev_warn(dev, "retrying firmware load\n"); 676 677 /* settings for retry */ 678 error = i2c_smbus_write_byte_data(client, EX_WDAT, 0); 679 if (error) 680 goto out; 681 } 682 683 error = i2c_smbus_write_byte_data(client, EX_ADDR_H, 0); 684 if (error) 685 goto out; 686 687 error = i2c_smbus_write_byte_data(client, EX_ADDR_L, 0); 688 if (error) 689 goto out; 690 691 error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 692 COMMON_SETUP1_DEFAULT); 693 if (error) 694 goto out; 695 696 /* firmware load to the device */ 697 offset = 0; 698 len = fw->size; 699 700 while (len) { 701 xfer_len = min(FIRMWARE_BLOCK_SIZE, len); 702 703 error = i2c_smbus_write_i2c_block_data(client, EX_WDAT, 704 xfer_len, &fw->data[offset]); 705 if (error) 706 goto out; 707 708 len -= xfer_len; 709 offset += xfer_len; 710 } 711 712 /* check firmware load result */ 713 status = i2c_smbus_read_byte_data(client, INT_STATUS); 714 if (status < 0) { 715 error = status; 716 goto out; 717 } 718 719 /* clear all interrupts */ 720 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 721 if (error) 722 goto out; 723 724 if (status == PROGRAM_LOAD_DONE) 725 break; 726 727 error = -EIO; 728 } while (++retry <= FIRMWARE_RETRY_MAX); 729 730 out: 731 error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL); 732 733 release_firmware(fw); 734 735 return error ? error : error2; 736 } 737 738 static ssize_t swap_xy_show(struct device *dev, struct device_attribute *attr, 739 char *buf) 740 { 741 struct i2c_client *client = to_i2c_client(dev); 742 struct rohm_ts_data *ts = i2c_get_clientdata(client); 743 744 return sprintf(buf, "%d\n", !!(ts->setup2 & SWAP_XY)); 745 } 746 747 static ssize_t swap_xy_store(struct device *dev, struct device_attribute *attr, 748 const char *buf, size_t count) 749 { 750 struct i2c_client *client = to_i2c_client(dev); 751 struct rohm_ts_data *ts = i2c_get_clientdata(client); 752 unsigned int val; 753 int error; 754 755 error = kstrtouint(buf, 0, &val); 756 if (error) 757 return error; 758 759 error = mutex_lock_interruptible(&ts->input->mutex); 760 if (error) 761 return error; 762 763 if (val) 764 ts->setup2 |= SWAP_XY; 765 else 766 ts->setup2 &= ~SWAP_XY; 767 768 if (ts->initialized) 769 error = i2c_smbus_write_byte_data(ts->client, COMMON_SETUP2, 770 ts->setup2); 771 772 mutex_unlock(&ts->input->mutex); 773 774 return error ? error : count; 775 } 776 777 static ssize_t inv_x_show(struct device *dev, struct device_attribute *attr, 778 char *buf) 779 { 780 struct i2c_client *client = to_i2c_client(dev); 781 struct rohm_ts_data *ts = i2c_get_clientdata(client); 782 783 return sprintf(buf, "%d\n", !!(ts->setup2 & INV_X)); 784 } 785 786 static ssize_t inv_x_store(struct device *dev, struct device_attribute *attr, 787 const char *buf, size_t count) 788 { 789 struct i2c_client *client = to_i2c_client(dev); 790 struct rohm_ts_data *ts = i2c_get_clientdata(client); 791 unsigned int val; 792 int error; 793 794 error = kstrtouint(buf, 0, &val); 795 if (error) 796 return error; 797 798 error = mutex_lock_interruptible(&ts->input->mutex); 799 if (error) 800 return error; 801 802 if (val) 803 ts->setup2 |= INV_X; 804 else 805 ts->setup2 &= ~INV_X; 806 807 if (ts->initialized) 808 error = i2c_smbus_write_byte_data(ts->client, COMMON_SETUP2, 809 ts->setup2); 810 811 mutex_unlock(&ts->input->mutex); 812 813 return error ? error : count; 814 } 815 816 static ssize_t inv_y_show(struct device *dev, struct device_attribute *attr, 817 char *buf) 818 { 819 struct i2c_client *client = to_i2c_client(dev); 820 struct rohm_ts_data *ts = i2c_get_clientdata(client); 821 822 return sprintf(buf, "%d\n", !!(ts->setup2 & INV_Y)); 823 } 824 825 static ssize_t inv_y_store(struct device *dev, struct device_attribute *attr, 826 const char *buf, size_t count) 827 { 828 struct i2c_client *client = to_i2c_client(dev); 829 struct rohm_ts_data *ts = i2c_get_clientdata(client); 830 unsigned int val; 831 int error; 832 833 error = kstrtouint(buf, 0, &val); 834 if (error) 835 return error; 836 837 error = mutex_lock_interruptible(&ts->input->mutex); 838 if (error) 839 return error; 840 841 if (val) 842 ts->setup2 |= INV_Y; 843 else 844 ts->setup2 &= ~INV_Y; 845 846 if (ts->initialized) 847 error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, 848 ts->setup2); 849 850 mutex_unlock(&ts->input->mutex); 851 852 return error ? error : count; 853 } 854 855 static DEVICE_ATTR_RW(swap_xy); 856 static DEVICE_ATTR_RW(inv_x); 857 static DEVICE_ATTR_RW(inv_y); 858 859 static struct attribute *rohm_ts_attrs[] = { 860 &dev_attr_swap_xy.attr, 861 &dev_attr_inv_x.attr, 862 &dev_attr_inv_y.attr, 863 NULL, 864 }; 865 866 static const struct attribute_group rohm_ts_attr_group = { 867 .attrs = rohm_ts_attrs, 868 }; 869 870 static int rohm_ts_device_init(struct i2c_client *client, u8 setup2) 871 { 872 struct device *dev = &client->dev; 873 int error; 874 875 disable_irq(client->irq); 876 877 /* 878 * Wait 200usec for reset 879 */ 880 udelay(200); 881 882 /* Release analog reset */ 883 error = i2c_smbus_write_byte_data(client, SYSTEM, 884 ANALOG_POWER_ON | CPU_POWER_OFF); 885 if (error) 886 return error; 887 888 /* Waiting for the analog warm-up, max. 200usec */ 889 udelay(200); 890 891 /* clear all interrupts */ 892 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 893 if (error) 894 return error; 895 896 error = i2c_smbus_write_byte_data(client, EX_WDAT, 0); 897 if (error) 898 return error; 899 900 error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0); 901 if (error) 902 return error; 903 904 error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, setup2); 905 if (error) 906 return error; 907 908 error = i2c_smbus_write_byte_data(client, COMMON_SETUP3, 909 SEL_TBL_DEFAULT | EN_MULTI); 910 if (error) 911 return error; 912 913 error = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE, 914 THRESHOLD_GESTURE_DEFAULT); 915 if (error) 916 return error; 917 918 error = i2c_smbus_write_byte_data(client, INTERVAL_TIME, 919 INTERVAL_TIME_DEFAULT); 920 if (error) 921 return error; 922 923 error = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ); 924 if (error) 925 return error; 926 927 error = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME, 928 PRM_SWOFF_TIME_DEFAULT); 929 if (error) 930 return error; 931 932 error = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT); 933 if (error) 934 return error; 935 936 error = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT); 937 if (error) 938 return error; 939 940 /* 941 * Panel setup, these values change with the panel. 942 */ 943 error = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT); 944 if (error) 945 return error; 946 947 error = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT); 948 if (error) 949 return error; 950 951 error = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT); 952 if (error) 953 return error; 954 955 error = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT); 956 if (error) 957 return error; 958 959 error = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH, 960 THRESHOLD_TOUCH_DEFAULT); 961 if (error) 962 return error; 963 964 error = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT); 965 if (error) 966 return error; 967 968 error = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT); 969 if (error) 970 return error; 971 972 error = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT); 973 if (error) 974 return error; 975 976 /* Fixed value settings */ 977 error = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST, 978 CALIBRATION_ADJUST_DEFAULT); 979 if (error) 980 return error; 981 982 error = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT); 983 if (error) 984 return error; 985 986 error = i2c_smbus_write_byte_data(client, TEST1, 987 DUALTOUCH_STABILIZE_ON | 988 DUALTOUCH_REG_ON); 989 if (error) 990 return error; 991 992 error = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME); 993 if (error) { 994 dev_err(dev, "failed to load firmware: %d\n", error); 995 return error; 996 } 997 998 /* 999 * Manual calibration results are not changed in same environment. 1000 * If the force calibration is performed, 1001 * the controller will not require calibration request interrupt 1002 * when the typical values are set to the calibration registers. 1003 */ 1004 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1, 1005 CALIBRATION_REG1_DEFAULT); 1006 if (error) 1007 return error; 1008 1009 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2, 1010 CALIBRATION_REG2_DEFAULT); 1011 if (error) 1012 return error; 1013 1014 error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3, 1015 CALIBRATION_REG3_DEFAULT); 1016 if (error) 1017 return error; 1018 1019 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, 1020 FORCE_CALIBRATION_OFF); 1021 if (error) 1022 return error; 1023 1024 error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION, 1025 FORCE_CALIBRATION_ON); 1026 if (error) 1027 return error; 1028 1029 /* Clear all interrupts */ 1030 error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff); 1031 if (error) 1032 return error; 1033 1034 /* Enable coordinates update interrupt */ 1035 error = i2c_smbus_write_byte_data(client, INT_MASK, 1036 CALIBRATION_DONE | SLEEP_OUT | 1037 SLEEP_IN | PROGRAM_LOAD_DONE); 1038 if (error) 1039 return error; 1040 1041 error = i2c_smbus_write_byte_data(client, ERR_MASK, 1042 PROGRAM_LOAD_ERR | CPU_TIMEOUT | 1043 ADC_TIMEOUT); 1044 if (error) 1045 return error; 1046 1047 /* controller CPU power on */ 1048 error = i2c_smbus_write_byte_data(client, SYSTEM, 1049 ANALOG_POWER_ON | CPU_POWER_ON); 1050 1051 enable_irq(client->irq); 1052 1053 return error; 1054 } 1055 1056 static int rohm_ts_power_off(struct i2c_client *client) 1057 { 1058 int error; 1059 1060 error = i2c_smbus_write_byte_data(client, SYSTEM, 1061 ANALOG_POWER_ON | CPU_POWER_OFF); 1062 if (error) { 1063 dev_err(&client->dev, 1064 "failed to power off device CPU: %d\n", error); 1065 return error; 1066 } 1067 1068 error = i2c_smbus_write_byte_data(client, SYSTEM, 1069 ANALOG_POWER_OFF | CPU_POWER_OFF); 1070 if (error) 1071 dev_err(&client->dev, 1072 "failed to power off the device: %d\n", error); 1073 1074 return error; 1075 } 1076 1077 static int rohm_ts_open(struct input_dev *input_dev) 1078 { 1079 struct rohm_ts_data *ts = input_get_drvdata(input_dev); 1080 struct i2c_client *client = ts->client; 1081 int error; 1082 1083 if (!ts->initialized) { 1084 error = rohm_ts_device_init(client, ts->setup2); 1085 if (error) { 1086 dev_err(&client->dev, 1087 "device initialization failed: %d\n", error); 1088 return error; 1089 } 1090 1091 ts->initialized = true; 1092 } 1093 1094 return 0; 1095 } 1096 1097 static void rohm_ts_close(struct input_dev *input_dev) 1098 { 1099 struct rohm_ts_data *ts = input_get_drvdata(input_dev); 1100 1101 rohm_ts_power_off(ts->client); 1102 1103 ts->initialized = false; 1104 } 1105 1106 static void rohm_ts_remove_sysfs_group(void *_dev) 1107 { 1108 struct device *dev = _dev; 1109 1110 sysfs_remove_group(&dev->kobj, &rohm_ts_attr_group); 1111 } 1112 1113 static int rohm_bu21023_i2c_probe(struct i2c_client *client, 1114 const struct i2c_device_id *id) 1115 { 1116 struct device *dev = &client->dev; 1117 struct rohm_ts_data *ts; 1118 struct input_dev *input; 1119 int error; 1120 1121 if (!client->irq) { 1122 dev_err(dev, "IRQ is not assigned\n"); 1123 return -EINVAL; 1124 } 1125 1126 if (!client->adapter->algo->master_xfer) { 1127 dev_err(dev, "I2C level transfers not supported\n"); 1128 return -EOPNOTSUPP; 1129 } 1130 1131 /* Turn off CPU just in case */ 1132 error = rohm_ts_power_off(client); 1133 if (error) 1134 return error; 1135 1136 ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL); 1137 if (!ts) 1138 return -ENOMEM; 1139 1140 ts->client = client; 1141 ts->setup2 = MAF_1SAMPLE; 1142 i2c_set_clientdata(client, ts); 1143 1144 input = devm_input_allocate_device(dev); 1145 if (!input) 1146 return -ENOMEM; 1147 1148 input->name = BU21023_NAME; 1149 input->id.bustype = BUS_I2C; 1150 input->open = rohm_ts_open; 1151 input->close = rohm_ts_close; 1152 1153 ts->input = input; 1154 input_set_drvdata(input, ts); 1155 1156 input_set_abs_params(input, ABS_MT_POSITION_X, 1157 ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0); 1158 input_set_abs_params(input, ABS_MT_POSITION_Y, 1159 ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0); 1160 1161 error = input_mt_init_slots(input, MAX_CONTACTS, 1162 INPUT_MT_DIRECT | INPUT_MT_TRACK | 1163 INPUT_MT_DROP_UNUSED); 1164 if (error) { 1165 dev_err(dev, "failed to multi touch slots initialization\n"); 1166 return error; 1167 } 1168 1169 error = devm_request_threaded_irq(dev, client->irq, 1170 NULL, rohm_ts_soft_irq, 1171 IRQF_ONESHOT, client->name, ts); 1172 if (error) { 1173 dev_err(dev, "failed to request IRQ: %d\n", error); 1174 return error; 1175 } 1176 1177 error = input_register_device(input); 1178 if (error) { 1179 dev_err(dev, "failed to register input device: %d\n", error); 1180 return error; 1181 } 1182 1183 error = sysfs_create_group(&dev->kobj, &rohm_ts_attr_group); 1184 if (error) { 1185 dev_err(dev, "failed to create sysfs group: %d\n", error); 1186 return error; 1187 } 1188 1189 error = devm_add_action(dev, rohm_ts_remove_sysfs_group, dev); 1190 if (error) { 1191 rohm_ts_remove_sysfs_group(dev); 1192 dev_err(dev, "Failed to add sysfs cleanup action: %d\n", 1193 error); 1194 return error; 1195 } 1196 1197 return error; 1198 } 1199 1200 static const struct i2c_device_id rohm_bu21023_i2c_id[] = { 1201 { BU21023_NAME, 0 }, 1202 { /* sentinel */ } 1203 }; 1204 MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id); 1205 1206 static struct i2c_driver rohm_bu21023_i2c_driver = { 1207 .driver = { 1208 .name = BU21023_NAME, 1209 }, 1210 .probe = rohm_bu21023_i2c_probe, 1211 .id_table = rohm_bu21023_i2c_id, 1212 }; 1213 module_i2c_driver(rohm_bu21023_i2c_driver); 1214 1215 MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver"); 1216 MODULE_LICENSE("GPL v2"); 1217 MODULE_AUTHOR("ROHM Co., Ltd."); 1218