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