drivers/input/touchscreen/rohm_bu21023.c

   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           "/*(DEBLOBBED)*/"
  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
 257 struct 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  */
 282 static 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
 313 static 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
 507 out:
 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
 516 static const unsigned int untouch_threshold[3] = { 0, 1, 5 };
 517 static const unsigned int single_touch_threshold[3] = { 0, 0, 4 };
 518 static const unsigned int dual_touch_threshold[3] = { 10, 8, 0 };
 519
 520 static 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
 642 static 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 = reject_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
 722 out:
 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
 730 static 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
 739 static 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
 769 static 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
 778 static 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
 808 static 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
 817 static 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
 847 static DEVICE_ATTR_RW(swap_xy);
 848 static DEVICE_ATTR_RW(inv_x);
 849 static DEVICE_ATTR_RW(inv_y);
 850
 851 static 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 ATTRIBUTE_GROUPS(rohm_ts);
 858
 859 static int rohm_ts_device_init(struct i2c_client *client, u8 setup2)
 860 {
 861         struct device *dev = &client->dev;
 862         int error;
 863
 864         disable_irq(client->irq);
 865
 866         /*
 867          * Wait 200usec for reset
 868          */
 869         udelay(200);
 870
 871         /* Release analog reset */
 872         error = i2c_smbus_write_byte_data(client, SYSTEM,
 873                                           ANALOG_POWER_ON | CPU_POWER_OFF);
 874         if (error)
 875                 return error;
 876
 877         /* Waiting for the analog warm-up, max. 200usec */
 878         udelay(200);
 879
 880         /* clear all interrupts */
 881         error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
 882         if (error)
 883                 return error;
 884
 885         error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
 886         if (error)
 887                 return error;
 888
 889         error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
 890         if (error)
 891                 return error;
 892
 893         error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, setup2);
 894         if (error)
 895                 return error;
 896
 897         error = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
 898                                           SEL_TBL_DEFAULT | EN_MULTI);
 899         if (error)
 900                 return error;
 901
 902         error = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
 903                                           THRESHOLD_GESTURE_DEFAULT);
 904         if (error)
 905                 return error;
 906
 907         error = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
 908                                           INTERVAL_TIME_DEFAULT);
 909         if (error)
 910                 return error;
 911
 912         error = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
 913         if (error)
 914                 return error;
 915
 916         error = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
 917                                           PRM_SWOFF_TIME_DEFAULT);
 918         if (error)
 919                 return error;
 920
 921         error = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
 922         if (error)
 923                 return error;
 924
 925         error = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
 926         if (error)
 927                 return error;
 928
 929         /*
 930          * Panel setup, these values change with the panel.
 931          */
 932         error = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
 933         if (error)
 934                 return error;
 935
 936         error = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
 937         if (error)
 938                 return error;
 939
 940         error = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
 941         if (error)
 942                 return error;
 943
 944         error = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
 945         if (error)
 946                 return error;
 947
 948         error = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
 949                                           THRESHOLD_TOUCH_DEFAULT);
 950         if (error)
 951                 return error;
 952
 953         error = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
 954         if (error)
 955                 return error;
 956
 957         error = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
 958         if (error)
 959                 return error;
 960
 961         error = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
 962         if (error)
 963                 return error;
 964
 965         /* Fixed value settings */
 966         error = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
 967                                           CALIBRATION_ADJUST_DEFAULT);
 968         if (error)
 969                 return error;
 970
 971         error = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
 972         if (error)
 973                 return error;
 974
 975         error = i2c_smbus_write_byte_data(client, TEST1,
 976                                           DUALTOUCH_STABILIZE_ON |
 977                                           DUALTOUCH_REG_ON);
 978         if (error)
 979                 return error;
 980
 981         error = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
 982         if (error) {
 983                 dev_err(dev, "failed to load firmware: %d\n", error);
 984                 return error;
 985         }
 986
 987         /*
 988          * Manual calibration results are not changed in same environment.
 989          * If the force calibration is performed,
 990          * the controller will not require calibration request interrupt
 991          * when the typical values are set to the calibration registers.
 992          */
 993         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
 994                                           CALIBRATION_REG1_DEFAULT);
 995         if (error)
 996                 return error;
 997
 998         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
 999                                           CALIBRATION_REG2_DEFAULT);
1000         if (error)
1001                 return error;
1002
1003         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
1004                                           CALIBRATION_REG3_DEFAULT);
1005         if (error)
1006                 return error;
1007
1008         error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
1009                                           FORCE_CALIBRATION_OFF);
1010         if (error)
1011                 return error;
1012
1013         error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
1014                                           FORCE_CALIBRATION_ON);
1015         if (error)
1016                 return error;
1017
1018         /* Clear all interrupts */
1019         error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
1020         if (error)
1021                 return error;
1022
1023         /* Enable coordinates update interrupt */
1024         error = i2c_smbus_write_byte_data(client, INT_MASK,
1025                                           CALIBRATION_DONE | SLEEP_OUT |
1026                                           SLEEP_IN | PROGRAM_LOAD_DONE);
1027         if (error)
1028                 return error;
1029
1030         error = i2c_smbus_write_byte_data(client, ERR_MASK,
1031                                           PROGRAM_LOAD_ERR | CPU_TIMEOUT |
1032                                           ADC_TIMEOUT);
1033         if (error)
1034                 return error;
1035
1036         /* controller CPU power on */
1037         error = i2c_smbus_write_byte_data(client, SYSTEM,
1038                                           ANALOG_POWER_ON | CPU_POWER_ON);
1039
1040         enable_irq(client->irq);
1041
1042         return error;
1043 }
1044
1045 static int rohm_ts_power_off(struct i2c_client *client)
1046 {
1047         int error;
1048
1049         error = i2c_smbus_write_byte_data(client, SYSTEM,
1050                                           ANALOG_POWER_ON | CPU_POWER_OFF);
1051         if (error) {
1052                 dev_err(&client->dev,
1053                         "failed to power off device CPU: %d\n", error);
1054                 return error;
1055         }
1056
1057         error = i2c_smbus_write_byte_data(client, SYSTEM,
1058                                           ANALOG_POWER_OFF | CPU_POWER_OFF);
1059         if (error)
1060                 dev_err(&client->dev,
1061                         "failed to power off the device: %d\n", error);
1062
1063         return error;
1064 }
1065
1066 static int rohm_ts_open(struct input_dev *input_dev)
1067 {
1068         struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1069         struct i2c_client *client = ts->client;
1070         int error;
1071
1072         if (!ts->initialized) {
1073                 error = rohm_ts_device_init(client, ts->setup2);
1074                 if (error) {
1075                         dev_err(&client->dev,
1076                                 "device initialization failed: %d\n", error);
1077                         return error;
1078                 }
1079
1080                 ts->initialized = true;
1081         }
1082
1083         return 0;
1084 }
1085
1086 static void rohm_ts_close(struct input_dev *input_dev)
1087 {
1088         struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1089
1090         rohm_ts_power_off(ts->client);
1091
1092         ts->initialized = false;
1093 }
1094
1095 static int rohm_bu21023_i2c_probe(struct i2c_client *client)
1096 {
1097         struct device *dev = &client->dev;
1098         struct rohm_ts_data *ts;
1099         struct input_dev *input;
1100         int error;
1101
1102         if (!client->irq) {
1103                 dev_err(dev, "IRQ is not assigned\n");
1104                 return -EINVAL;
1105         }
1106
1107         if (!client->adapter->algo->master_xfer) {
1108                 dev_err(dev, "I2C level transfers not supported\n");
1109                 return -EOPNOTSUPP;
1110         }
1111
1112         /* Turn off CPU just in case */
1113         error = rohm_ts_power_off(client);
1114         if (error)
1115                 return error;
1116
1117         ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
1118         if (!ts)
1119                 return -ENOMEM;
1120
1121         ts->client = client;
1122         ts->setup2 = MAF_1SAMPLE;
1123         i2c_set_clientdata(client, ts);
1124
1125         input = devm_input_allocate_device(dev);
1126         if (!input)
1127                 return -ENOMEM;
1128
1129         input->name = BU21023_NAME;
1130         input->id.bustype = BUS_I2C;
1131         input->open = rohm_ts_open;
1132         input->close = rohm_ts_close;
1133
1134         ts->input = input;
1135         input_set_drvdata(input, ts);
1136
1137         input_set_abs_params(input, ABS_MT_POSITION_X,
1138                              ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
1139         input_set_abs_params(input, ABS_MT_POSITION_Y,
1140                              ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
1141
1142         error = input_mt_init_slots(input, MAX_CONTACTS,
1143                                     INPUT_MT_DIRECT | INPUT_MT_TRACK |
1144                                     INPUT_MT_DROP_UNUSED);
1145         if (error) {
1146                 dev_err(dev, "failed to multi touch slots initialization\n");
1147                 return error;
1148         }
1149
1150         error = devm_request_threaded_irq(dev, client->irq,
1151                                           NULL, rohm_ts_soft_irq,
1152                                           IRQF_ONESHOT, client->name, ts);
1153         if (error) {
1154                 dev_err(dev, "failed to request IRQ: %d\n", error);
1155                 return error;
1156         }
1157
1158         error = input_register_device(input);
1159         if (error) {
1160                 dev_err(dev, "failed to register input device: %d\n", error);
1161                 return error;
1162         }
1163
1164         return error;
1165 }
1166
1167 static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
1168         { BU21023_NAME, 0 },
1169         { /* sentinel */ }
1170 };
1171 MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);
1172
1173 static struct i2c_driver rohm_bu21023_i2c_driver = {
1174         .driver = {
1175                 .name = BU21023_NAME,
1176                 .dev_groups = rohm_ts_groups,
1177         },
1178         .probe = rohm_bu21023_i2c_probe,
1179         .id_table = rohm_bu21023_i2c_id,
1180 };
1181 module_i2c_driver(rohm_bu21023_i2c_driver);
1182
1183 MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
1184 MODULE_LICENSE("GPL v2");
1185 MODULE_AUTHOR("ROHM Co., Ltd.");