drivers/input/touchscreen/rohm_bu21023.c

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