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           "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
 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         s32 status;
 647         unsigned int offset, len, xfer_len;
 648         unsigned int retry = 0;
 649         int error, error2;
 650
 651         const struct firmware *fw __free(firmware) = NULL;
 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
 722 out:
 723         error2 = i2c_smbus_write_byte_data(client, INT_MASK, INT_ALL);
 724
 725         return error ? error : error2;
 726 }
 727
 728 static int rohm_ts_update_setting(struct rohm_ts_data *ts,
 729                                   unsigned int setting_bit, bool on)
 730 {
 731         int error;
 732
 733         scoped_cond_guard(mutex_intr, return -EINTR, &ts->input->mutex) {
 734                 if (on)
 735                         ts->setup2 |= setting_bit;
 736                 else
 737                         ts->setup2 &= ~setting_bit;
 738
 739                 if (ts->initialized) {
 740                         error = i2c_smbus_write_byte_data(ts->client,
 741                                                           COMMON_SETUP2,
 742                                                           ts->setup2);
 743                         if (error)
 744                                 return error;
 745                 }
 746         }
 747
 748         return 0;
 749 }
 750
 751 static ssize_t swap_xy_show(struct device *dev, struct device_attribute *attr,
 752                             char *buf)
 753 {
 754         struct i2c_client *client = to_i2c_client(dev);
 755         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 756
 757         return sysfs_emit(buf, "%d\n", !!(ts->setup2 & SWAP_XY));
 758 }
 759
 760 static ssize_t swap_xy_store(struct device *dev, struct device_attribute *attr,
 761                              const char *buf, size_t count)
 762 {
 763         struct i2c_client *client = to_i2c_client(dev);
 764         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 765         unsigned int val;
 766         int error;
 767
 768         error = kstrtouint(buf, 0, &val);
 769         if (error)
 770                 return error;
 771
 772         error = rohm_ts_update_setting(ts, SWAP_XY, val);
 773         return error ?: count;
 774 }
 775
 776 static ssize_t inv_x_show(struct device *dev, struct device_attribute *attr,
 777                           char *buf)
 778 {
 779         struct i2c_client *client = to_i2c_client(dev);
 780         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 781
 782         return sysfs_emit(buf, "%d\n", !!(ts->setup2 & INV_X));
 783 }
 784
 785 static ssize_t inv_x_store(struct device *dev, struct device_attribute *attr,
 786                            const char *buf, size_t count)
 787 {
 788         struct i2c_client *client = to_i2c_client(dev);
 789         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 790         unsigned int val;
 791         int error;
 792
 793         error = kstrtouint(buf, 0, &val);
 794         if (error)
 795                 return error;
 796
 797         error = rohm_ts_update_setting(ts, INV_X, val);
 798         return error ?: count;
 799 }
 800
 801 static ssize_t inv_y_show(struct device *dev, struct device_attribute *attr,
 802                           char *buf)
 803 {
 804         struct i2c_client *client = to_i2c_client(dev);
 805         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 806
 807         return sysfs_emit(buf, "%d\n", !!(ts->setup2 & INV_Y));
 808 }
 809
 810 static ssize_t inv_y_store(struct device *dev, struct device_attribute *attr,
 811                            const char *buf, size_t count)
 812 {
 813         struct i2c_client *client = to_i2c_client(dev);
 814         struct rohm_ts_data *ts = i2c_get_clientdata(client);
 815         unsigned int val;
 816         int error;
 817
 818         error = kstrtouint(buf, 0, &val);
 819         if (error)
 820                 return error;
 821
 822         error = rohm_ts_update_setting(ts, INV_Y, val);
 823         return error ?: count;
 824 }
 825
 826 static DEVICE_ATTR_RW(swap_xy);
 827 static DEVICE_ATTR_RW(inv_x);
 828 static DEVICE_ATTR_RW(inv_y);
 829
 830 static struct attribute *rohm_ts_attrs[] = {
 831         &dev_attr_swap_xy.attr,
 832         &dev_attr_inv_x.attr,
 833         &dev_attr_inv_y.attr,
 834         NULL,
 835 };
 836 ATTRIBUTE_GROUPS(rohm_ts);
 837
 838 static int rohm_ts_device_init(struct i2c_client *client, u8 setup2)
 839 {
 840         struct device *dev = &client->dev;
 841         int error;
 842
 843         guard(disable_irq)(&client->irq);
 844
 845         /*
 846          * Wait 200usec for reset
 847          */
 848         udelay(200);
 849
 850         /* Release analog reset */
 851         error = i2c_smbus_write_byte_data(client, SYSTEM,
 852                                           ANALOG_POWER_ON | CPU_POWER_OFF);
 853         if (error)
 854                 return error;
 855
 856         /* Waiting for the analog warm-up, max. 200usec */
 857         udelay(200);
 858
 859         /* clear all interrupts */
 860         error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
 861         if (error)
 862                 return error;
 863
 864         error = i2c_smbus_write_byte_data(client, EX_WDAT, 0);
 865         if (error)
 866                 return error;
 867
 868         error = i2c_smbus_write_byte_data(client, COMMON_SETUP1, 0);
 869         if (error)
 870                 return error;
 871
 872         error = i2c_smbus_write_byte_data(client, COMMON_SETUP2, setup2);
 873         if (error)
 874                 return error;
 875
 876         error = i2c_smbus_write_byte_data(client, COMMON_SETUP3,
 877                                           SEL_TBL_DEFAULT | EN_MULTI);
 878         if (error)
 879                 return error;
 880
 881         error = i2c_smbus_write_byte_data(client, THRESHOLD_GESTURE,
 882                                           THRESHOLD_GESTURE_DEFAULT);
 883         if (error)
 884                 return error;
 885
 886         error = i2c_smbus_write_byte_data(client, INTERVAL_TIME,
 887                                           INTERVAL_TIME_DEFAULT);
 888         if (error)
 889                 return error;
 890
 891         error = i2c_smbus_write_byte_data(client, CPU_FREQ, CPU_FREQ_10MHZ);
 892         if (error)
 893                 return error;
 894
 895         error = i2c_smbus_write_byte_data(client, PRM_SWOFF_TIME,
 896                                           PRM_SWOFF_TIME_DEFAULT);
 897         if (error)
 898                 return error;
 899
 900         error = i2c_smbus_write_byte_data(client, ADC_CTRL, ADC_DIV_DEFAULT);
 901         if (error)
 902                 return error;
 903
 904         error = i2c_smbus_write_byte_data(client, ADC_WAIT, ADC_WAIT_DEFAULT);
 905         if (error)
 906                 return error;
 907
 908         /*
 909          * Panel setup, these values change with the panel.
 910          */
 911         error = i2c_smbus_write_byte_data(client, STEP_X, STEP_X_DEFAULT);
 912         if (error)
 913                 return error;
 914
 915         error = i2c_smbus_write_byte_data(client, STEP_Y, STEP_Y_DEFAULT);
 916         if (error)
 917                 return error;
 918
 919         error = i2c_smbus_write_byte_data(client, OFFSET_X, OFFSET_X_DEFAULT);
 920         if (error)
 921                 return error;
 922
 923         error = i2c_smbus_write_byte_data(client, OFFSET_Y, OFFSET_Y_DEFAULT);
 924         if (error)
 925                 return error;
 926
 927         error = i2c_smbus_write_byte_data(client, THRESHOLD_TOUCH,
 928                                           THRESHOLD_TOUCH_DEFAULT);
 929         if (error)
 930                 return error;
 931
 932         error = i2c_smbus_write_byte_data(client, EVR_XY, EVR_XY_DEFAULT);
 933         if (error)
 934                 return error;
 935
 936         error = i2c_smbus_write_byte_data(client, EVR_X, EVR_X_DEFAULT);
 937         if (error)
 938                 return error;
 939
 940         error = i2c_smbus_write_byte_data(client, EVR_Y, EVR_Y_DEFAULT);
 941         if (error)
 942                 return error;
 943
 944         /* Fixed value settings */
 945         error = i2c_smbus_write_byte_data(client, CALIBRATION_ADJUST,
 946                                           CALIBRATION_ADJUST_DEFAULT);
 947         if (error)
 948                 return error;
 949
 950         error = i2c_smbus_write_byte_data(client, SWCONT, SWCONT_DEFAULT);
 951         if (error)
 952                 return error;
 953
 954         error = i2c_smbus_write_byte_data(client, TEST1,
 955                                           DUALTOUCH_STABILIZE_ON |
 956                                           DUALTOUCH_REG_ON);
 957         if (error)
 958                 return error;
 959
 960         error = rohm_ts_load_firmware(client, BU21023_FIRMWARE_NAME);
 961         if (error) {
 962                 dev_err(dev, "failed to load firmware: %d\n", error);
 963                 return error;
 964         }
 965
 966         /*
 967          * Manual calibration results are not changed in same environment.
 968          * If the force calibration is performed,
 969          * the controller will not require calibration request interrupt
 970          * when the typical values are set to the calibration registers.
 971          */
 972         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG1,
 973                                           CALIBRATION_REG1_DEFAULT);
 974         if (error)
 975                 return error;
 976
 977         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG2,
 978                                           CALIBRATION_REG2_DEFAULT);
 979         if (error)
 980                 return error;
 981
 982         error = i2c_smbus_write_byte_data(client, CALIBRATION_REG3,
 983                                           CALIBRATION_REG3_DEFAULT);
 984         if (error)
 985                 return error;
 986
 987         error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
 988                                           FORCE_CALIBRATION_OFF);
 989         if (error)
 990                 return error;
 991
 992         error = i2c_smbus_write_byte_data(client, FORCE_CALIBRATION,
 993                                           FORCE_CALIBRATION_ON);
 994         if (error)
 995                 return error;
 996
 997         /* Clear all interrupts */
 998         error = i2c_smbus_write_byte_data(client, INT_CLEAR, 0xff);
 999         if (error)
1000                 return error;
1001
1002         /* Enable coordinates update interrupt */
1003         error = i2c_smbus_write_byte_data(client, INT_MASK,
1004                                           CALIBRATION_DONE | SLEEP_OUT |
1005                                           SLEEP_IN | PROGRAM_LOAD_DONE);
1006         if (error)
1007                 return error;
1008
1009         error = i2c_smbus_write_byte_data(client, ERR_MASK,
1010                                           PROGRAM_LOAD_ERR | CPU_TIMEOUT |
1011                                           ADC_TIMEOUT);
1012         if (error)
1013                 return error;
1014
1015         /* controller CPU power on */
1016         error = i2c_smbus_write_byte_data(client, SYSTEM,
1017                                           ANALOG_POWER_ON | CPU_POWER_ON);
1018         if (error)
1019                 return error;
1020
1021         return 0;
1022 }
1023
1024 static int rohm_ts_power_off(struct i2c_client *client)
1025 {
1026         int error;
1027
1028         error = i2c_smbus_write_byte_data(client, SYSTEM,
1029                                           ANALOG_POWER_ON | CPU_POWER_OFF);
1030         if (error) {
1031                 dev_err(&client->dev,
1032                         "failed to power off device CPU: %d\n", error);
1033                 return error;
1034         }
1035
1036         error = i2c_smbus_write_byte_data(client, SYSTEM,
1037                                           ANALOG_POWER_OFF | CPU_POWER_OFF);
1038         if (error)
1039                 dev_err(&client->dev,
1040                         "failed to power off the device: %d\n", error);
1041
1042         return error;
1043 }
1044
1045 static int rohm_ts_open(struct input_dev *input_dev)
1046 {
1047         struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1048         struct i2c_client *client = ts->client;
1049         int error;
1050
1051         if (!ts->initialized) {
1052                 error = rohm_ts_device_init(client, ts->setup2);
1053                 if (error) {
1054                         dev_err(&client->dev,
1055                                 "device initialization failed: %d\n", error);
1056                         return error;
1057                 }
1058
1059                 ts->initialized = true;
1060         }
1061
1062         return 0;
1063 }
1064
1065 static void rohm_ts_close(struct input_dev *input_dev)
1066 {
1067         struct rohm_ts_data *ts = input_get_drvdata(input_dev);
1068
1069         rohm_ts_power_off(ts->client);
1070
1071         ts->initialized = false;
1072 }
1073
1074 static int rohm_bu21023_i2c_probe(struct i2c_client *client)
1075 {
1076         struct device *dev = &client->dev;
1077         struct rohm_ts_data *ts;
1078         struct input_dev *input;
1079         int error;
1080
1081         if (!client->irq) {
1082                 dev_err(dev, "IRQ is not assigned\n");
1083                 return -EINVAL;
1084         }
1085
1086         if (!client->adapter->algo->master_xfer) {
1087                 dev_err(dev, "I2C level transfers not supported\n");
1088                 return -EOPNOTSUPP;
1089         }
1090
1091         /* Turn off CPU just in case */
1092         error = rohm_ts_power_off(client);
1093         if (error)
1094                 return error;
1095
1096         ts = devm_kzalloc(dev, sizeof(struct rohm_ts_data), GFP_KERNEL);
1097         if (!ts)
1098                 return -ENOMEM;
1099
1100         ts->client = client;
1101         ts->setup2 = MAF_1SAMPLE;
1102         i2c_set_clientdata(client, ts);
1103
1104         input = devm_input_allocate_device(dev);
1105         if (!input)
1106                 return -ENOMEM;
1107
1108         input->name = BU21023_NAME;
1109         input->id.bustype = BUS_I2C;
1110         input->open = rohm_ts_open;
1111         input->close = rohm_ts_close;
1112
1113         ts->input = input;
1114         input_set_drvdata(input, ts);
1115
1116         input_set_abs_params(input, ABS_MT_POSITION_X,
1117                              ROHM_TS_ABS_X_MIN, ROHM_TS_ABS_X_MAX, 0, 0);
1118         input_set_abs_params(input, ABS_MT_POSITION_Y,
1119                              ROHM_TS_ABS_Y_MIN, ROHM_TS_ABS_Y_MAX, 0, 0);
1120
1121         error = input_mt_init_slots(input, MAX_CONTACTS,
1122                                     INPUT_MT_DIRECT | INPUT_MT_TRACK |
1123                                     INPUT_MT_DROP_UNUSED);
1124         if (error) {
1125                 dev_err(dev, "failed to multi touch slots initialization\n");
1126                 return error;
1127         }
1128
1129         error = devm_request_threaded_irq(dev, client->irq,
1130                                           NULL, rohm_ts_soft_irq,
1131                                           IRQF_ONESHOT, client->name, ts);
1132         if (error) {
1133                 dev_err(dev, "failed to request IRQ: %d\n", error);
1134                 return error;
1135         }
1136
1137         error = input_register_device(input);
1138         if (error) {
1139                 dev_err(dev, "failed to register input device: %d\n", error);
1140                 return error;
1141         }
1142
1143         return error;
1144 }
1145
1146 static const struct i2c_device_id rohm_bu21023_i2c_id[] = {
1147         { BU21023_NAME },
1148         { /* sentinel */ }
1149 };
1150 MODULE_DEVICE_TABLE(i2c, rohm_bu21023_i2c_id);
1151
1152 static struct i2c_driver rohm_bu21023_i2c_driver = {
1153         .driver = {
1154                 .name = BU21023_NAME,
1155                 .dev_groups = rohm_ts_groups,
1156         },
1157         .probe = rohm_bu21023_i2c_probe,
1158         .id_table = rohm_bu21023_i2c_id,
1159 };
1160 module_i2c_driver(rohm_bu21023_i2c_driver);
1161
1162 MODULE_DESCRIPTION("ROHM BU21023/24 Touchscreen driver");
1163 MODULE_LICENSE("GPL v2");
1164 MODULE_AUTHOR("ROHM Co., Ltd.");