drivers/input/touchscreen/cyttsp5.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Parade TrueTouch(TM) Standard Product V5 Module.
   4  *
   5  * Copyright (C) 2015 Parade Technologies
   6  * Copyright (C) 2012-2015 Cypress Semiconductor
   7  * Copyright (C) 2018 Bootlin
   8  *
   9  * Authors: Mylène Josserand <mylene.josserand@bootlin.com>
  10  *                Alistair Francis <alistair@alistair23.me>
  11  */
  12
  13 #include <linux/crc-itu-t.h>
  14 #include <linux/delay.h>
  15 #include <linux/device.h>
  16 #include <linux/gpio/consumer.h>
  17 #include <linux/input/mt.h>
  18 #include <linux/input/touchscreen.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/i2c.h>
  21 #include <linux/module.h>
  22 #include <linux/of_device.h>
  23 #include <linux/regmap.h>
  24 #include <asm/unaligned.h>
  25
  26 #define CYTTSP5_NAME                            "cyttsp5"
  27 #define CY_I2C_DATA_SIZE                        (2 * 256)
  28 #define HID_VERSION                             0x0100
  29 #define CY_MAX_INPUT                            512
  30 #define CYTTSP5_PREALLOCATED_CMD_BUFFER         32
  31 #define CY_BITS_PER_BTN                         1
  32 #define CY_NUM_BTN_EVENT_ID                     GENMASK(CY_BITS_PER_BTN - 1, 0)
  33
  34 #define MAX_AREA                                255
  35 #define HID_OUTPUT_BL_SOP                       0x1
  36 #define HID_OUTPUT_BL_EOP                       0x17
  37 #define HID_OUTPUT_BL_LAUNCH_APP                0x3B
  38 #define HID_OUTPUT_BL_LAUNCH_APP_SIZE           11
  39 #define HID_OUTPUT_GET_SYSINFO                  0x2
  40 #define HID_OUTPUT_GET_SYSINFO_SIZE             5
  41 #define HID_OUTPUT_MAX_CMD_SIZE                 12
  42
  43 #define HID_DESC_REG                            0x1
  44 #define HID_INPUT_REG                           0x3
  45 #define HID_OUTPUT_REG                          0x4
  46 #define HID_COMMAND_REG                         0x5
  47
  48 #define REPORT_ID_TOUCH                         0x1
  49 #define REPORT_ID_BTN                           0x3
  50 #define REPORT_SIZE_5                           5
  51 #define REPORT_SIZE_8                           8
  52 #define REPORT_SIZE_16                          16
  53
  54 /* Touch reports offsets */
  55 /* Header offsets */
  56 #define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT      16
  57 /* Record offsets */
  58 #define TOUCH_REPORT_DESC_CONTACTID             8
  59 #define TOUCH_REPORT_DESC_X                     16
  60 #define TOUCH_REPORT_DESC_Y                     32
  61 #define TOUCH_REPORT_DESC_P                     48
  62 #define TOUCH_REPORT_DESC_MAJ                   56
  63 #define TOUCH_REPORT_DESC_MIN                   64
  64
  65 /* HID */
  66 #define HID_TOUCH_REPORT_ID                     0x1
  67 #define HID_BTN_REPORT_ID                       0x3
  68 #define HID_APP_RESPONSE_REPORT_ID              0x1F
  69 #define HID_APP_OUTPUT_REPORT_ID                0x2F
  70 #define HID_BL_RESPONSE_REPORT_ID               0x30
  71 #define HID_BL_OUTPUT_REPORT_ID                 0x40
  72 #define HID_RESPONSE_REPORT_ID                  0xF0
  73
  74 #define HID_OUTPUT_RESPONSE_REPORT_OFFSET       2
  75 #define HID_OUTPUT_RESPONSE_CMD_OFFSET          4
  76 #define HID_OUTPUT_RESPONSE_CMD_MASK            GENMASK(6, 0)
  77
  78 #define HID_SYSINFO_SENSING_OFFSET              33
  79 #define HID_SYSINFO_BTN_OFFSET                  48
  80 #define HID_SYSINFO_BTN_MASK                    GENMASK(7, 0)
  81 #define HID_SYSINFO_MAX_BTN                     8
  82
  83 #define HID_CMD_SET_POWER                       0x8
  84
  85 #define HID_POWER_ON                            0x0
  86 #define HID_POWER_SLEEP                         0x1
  87
  88 #define CY_HID_OUTPUT_TIMEOUT_MS                200
  89 #define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT_MS    3000
  90 #define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT_MS    4000
  91 #define CY_HID_SET_POWER_TIMEOUT                500
  92
  93 /* maximum number of concurrent tracks */
  94 #define TOUCH_REPORT_SIZE                       10
  95 #define TOUCH_INPUT_HEADER_SIZE                 7
  96 #define BTN_REPORT_SIZE                         9
  97 #define BTN_INPUT_HEADER_SIZE                   5
  98
  99 #define MAX_CY_TCH_T_IDS                        32
 100
 101 /* All usage pages for Touch Report */
 102 #define TOUCH_REPORT_USAGE_PG_X                 0x00010030
 103 #define TOUCH_REPORT_USAGE_PG_Y                 0x00010031
 104 #define TOUCH_REPORT_USAGE_PG_P                 0x000D0030
 105 #define TOUCH_REPORT_USAGE_PG_CONTACTID         0x000D0051
 106 #define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT      0x000D0054
 107 #define TOUCH_REPORT_USAGE_PG_MAJ               0xFF010062
 108 #define TOUCH_REPORT_USAGE_PG_MIN               0xFF010063
 109 #define TOUCH_COL_USAGE_PG                      0x000D0022
 110
 111 #define SET_CMD_LOW(byte, bits) \
 112         ((byte) = (((byte) & 0xF0) | ((bits) & 0x0F)))
 113 #define SET_CMD_HIGH(byte, bits)\
 114         ((byte) = (((byte) & 0x0F) | ((bits) & 0xF0)))
 115 #define SET_CMD_OPCODE(byte, opcode) SET_CMD_LOW(byte, opcode)
 116 #define SET_CMD_REPORT_TYPE(byte, type) SET_CMD_HIGH(byte, ((type) << 4))
 117 #define SET_CMD_REPORT_ID(byte, id) SET_CMD_LOW(byte, id)
 118
 119 /* System Information interface definitions */
 120 struct cyttsp5_sensing_conf_data_dev {
 121         u8 electrodes_x;
 122         u8 electrodes_y;
 123         __le16 len_x;
 124         __le16 len_y;
 125         __le16 res_x;
 126         __le16 res_y;
 127         __le16 max_z;
 128         u8 origin_x;
 129         u8 origin_y;
 130         u8 panel_id;
 131         u8 btn;
 132         u8 scan_mode;
 133         u8 max_num_of_tch_per_refresh_cycle;
 134 } __packed;
 135
 136 struct cyttsp5_sensing_conf_data {
 137         u16 res_x;
 138         u16 res_y;
 139         u16 max_z;
 140         u16 len_x;
 141         u16 len_y;
 142         u8 origin_x;
 143         u8 origin_y;
 144         u8 max_tch;
 145 };
 146
 147 enum cyttsp5_tch_abs {  /* for ordering within the extracted touch data array */
 148         CY_TCH_X,       /* X */
 149         CY_TCH_Y,       /* Y */
 150         CY_TCH_P,       /* P (Z) */
 151         CY_TCH_T,       /* TOUCH ID */
 152         CY_TCH_MAJ,     /* TOUCH_MAJOR */
 153         CY_TCH_MIN,     /* TOUCH_MINOR */
 154         CY_TCH_NUM_ABS
 155 };
 156
 157 struct cyttsp5_tch_abs_params {
 158         size_t ofs;     /* abs byte offset */
 159         size_t size;    /* size in bits */
 160         size_t min;     /* min value */
 161         size_t max;     /* max value */
 162         size_t bofs;    /* bit offset */
 163 };
 164
 165 struct cyttsp5_touch {
 166         int abs[CY_TCH_NUM_ABS];
 167 };
 168
 169 struct cyttsp5_sysinfo {
 170         struct cyttsp5_sensing_conf_data sensing_conf_data;
 171         int num_btns;
 172         struct cyttsp5_tch_abs_params tch_hdr;
 173         struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
 174         u32 key_code[HID_SYSINFO_MAX_BTN];
 175 };
 176
 177 struct cyttsp5_hid_desc {
 178         __le16 hid_desc_len;
 179         u8 packet_id;
 180         u8 reserved_byte;
 181         __le16 bcd_version;
 182         __le16 report_desc_len;
 183         __le16 report_desc_register;
 184         __le16 input_register;
 185         __le16 max_input_len;
 186         __le16 output_register;
 187         __le16 max_output_len;
 188         __le16 command_register;
 189         __le16 data_register;
 190         __le16 vendor_id;
 191         __le16 product_id;
 192         __le16 version_id;
 193         u8 reserved[4];
 194 } __packed;
 195
 196 struct cyttsp5 {
 197         struct device *dev;
 198         struct completion cmd_done;
 199         struct cyttsp5_sysinfo sysinfo;
 200         struct cyttsp5_hid_desc hid_desc;
 201         u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
 202         u8 input_buf[CY_MAX_INPUT];
 203         u8 response_buf[CY_MAX_INPUT];
 204         struct gpio_desc *reset_gpio;
 205         struct input_dev *input;
 206         char phys[NAME_MAX];
 207         int num_prv_rec;
 208         struct regmap *regmap;
 209         struct touchscreen_properties prop;
 210         struct regulator *vdd;
 211 };
 212
 213 /*
 214  * For what is understood in the datasheet, the register does not
 215  * matter. For consistency, use the Input Register address
 216  * but it does mean anything to the device. The important data
 217  * to send is the I2C address
 218  */
 219 static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
 220 {
 221         int error;
 222         u32 size;
 223         u8 temp[2];
 224
 225         /* Read the frame to retrieve the size */
 226         error = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, sizeof(temp));
 227         if (error)
 228                 return error;
 229
 230         size = get_unaligned_le16(temp);
 231         if (!size || size == 2)
 232                 return 0;
 233
 234         if (size > max)
 235                 return -EINVAL;
 236
 237         /* Get the real value */
 238         return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
 239 }
 240
 241 static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
 242                          size_t size)
 243 {
 244         u8 cmd[HID_OUTPUT_MAX_CMD_SIZE];
 245
 246         if (size + 1 > HID_OUTPUT_MAX_CMD_SIZE)
 247                 return -E2BIG;
 248
 249         /* High bytes of register address needed as first byte of cmd */
 250         cmd[0] = (reg >> 8) & 0xFF;
 251
 252         /* Copy the rest of the data */
 253         if (data)
 254                 memcpy(&cmd[1], data, size);
 255
 256         /*
 257          * The hardware wants to receive a frame with the address register
 258          * contained in the first two bytes. As the regmap_write function
 259          * add the register adresse in the frame, we use the low byte as
 260          * first frame byte for the address register and the first
 261          * data byte is the high register + left of the cmd to send
 262          */
 263         return regmap_bulk_write(ts->regmap, reg & 0xFF, cmd, size + 1);
 264 }
 265
 266 static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
 267                                    int bofs)
 268 {
 269         int nbyte;
 270
 271         for (nbyte = 0, *axis = 0; nbyte < size; nbyte++)
 272                 *axis += ((xy_data[nbyte] >> bofs) << (nbyte * 8));
 273
 274         *axis &= max - 1;
 275 }
 276
 277 static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
 278                                      struct cyttsp5_touch *touch, u8 *xy_data)
 279 {
 280         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 281         enum cyttsp5_tch_abs abs;
 282
 283         for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++)
 284                 cyttsp5_get_touch_axis(&touch->abs[abs],
 285                                        si->tch_abs[abs].size,
 286                                        si->tch_abs[abs].max,
 287                                        xy_data + si->tch_abs[abs].ofs,
 288                                        si->tch_abs[abs].bofs);
 289 }
 290
 291 static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
 292                                    struct cyttsp5_touch *tch, int num_cur_tch)
 293 {
 294         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 295         int i, t = 0, offset = 0;
 296         DECLARE_BITMAP(ids, MAX_CY_TCH_T_IDS);
 297         u8 *tch_addr;
 298         int tmp;
 299
 300         bitmap_zero(ids, MAX_CY_TCH_T_IDS);
 301         memset(tch->abs, 0, sizeof(tch->abs));
 302
 303         switch (ts->input_buf[2]) {
 304         case HID_TOUCH_REPORT_ID:
 305                 offset = TOUCH_INPUT_HEADER_SIZE;
 306                 break;
 307         case HID_BTN_REPORT_ID:
 308                 offset = BTN_INPUT_HEADER_SIZE;
 309                 break;
 310         }
 311
 312         for (i = 0; i < num_cur_tch; i++) {
 313                 tch_addr = ts->input_buf + offset + (i * TOUCH_REPORT_SIZE);
 314                 cyttsp5_get_touch_record(ts, tch, tch_addr);
 315
 316                 /* Convert MAJOR/MINOR from mm to resolution */
 317                 tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
 318                 tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
 319                 tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
 320                 tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
 321
 322                 t = tch->abs[CY_TCH_T];
 323                 input_mt_slot(ts->input, t);
 324                 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
 325                 __set_bit(t, ids);
 326
 327                 /* position and pressure fields */
 328                 touchscreen_report_pos(ts->input, &ts->prop,
 329                                        tch->abs[CY_TCH_X], tch->abs[CY_TCH_Y],
 330                                        true);
 331                 input_report_abs(ts->input, ABS_MT_PRESSURE,
 332                                  tch->abs[CY_TCH_P]);
 333
 334                 /* Get the extended touch fields */
 335                 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
 336                                  tch->abs[CY_TCH_MAJ]);
 337                 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
 338                                  tch->abs[CY_TCH_MIN]);
 339         }
 340
 341         ts->num_prv_rec = num_cur_tch;
 342 }
 343
 344 static int cyttsp5_mt_attention(struct device *dev)
 345 {
 346         struct cyttsp5 *ts = dev_get_drvdata(dev);
 347         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 348         int max_tch = si->sensing_conf_data.max_tch;
 349         struct cyttsp5_touch tch;
 350         int num_cur_tch;
 351
 352         cyttsp5_get_touch_axis(&num_cur_tch, si->tch_hdr.size,
 353                                si->tch_hdr.max,
 354                                ts->input_buf + 3 + si->tch_hdr.ofs,
 355                                si->tch_hdr.bofs);
 356
 357         if (num_cur_tch > max_tch) {
 358                 dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
 359                 num_cur_tch = max_tch;
 360         }
 361
 362         if (num_cur_tch == 0 && ts->num_prv_rec == 0)
 363                 return 0;
 364
 365         /* extract xy_data for all currently reported touches */
 366         if (num_cur_tch)
 367                 cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
 368
 369         input_mt_sync_frame(ts->input);
 370         input_sync(ts->input);
 371
 372         return 0;
 373 }
 374
 375 static int cyttsp5_setup_input_device(struct device *dev)
 376 {
 377         struct cyttsp5 *ts = dev_get_drvdata(dev);
 378         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 379         int max_x, max_y, max_p;
 380         int max_x_tmp, max_y_tmp;
 381         int error;
 382
 383         max_x_tmp = si->sensing_conf_data.res_x;
 384         max_y_tmp = si->sensing_conf_data.res_y;
 385         max_x = max_x_tmp - 1;
 386         max_y = max_y_tmp - 1;
 387         max_p = si->sensing_conf_data.max_z;
 388
 389         input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
 390         input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
 391         input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
 392
 393         input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
 394         input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
 395
 396         error = input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max,
 397                                     INPUT_MT_DROP_UNUSED | INPUT_MT_DIRECT);
 398         if (error)
 399                 return error;
 400
 401         error = input_register_device(ts->input);
 402         if (error) {
 403                 dev_err(dev, "failed to register input device: %d\n", error);
 404                 return error;
 405         }
 406
 407         return error;
 408 }
 409
 410 static int cyttsp5_parse_dt_key_code(struct device *dev)
 411 {
 412         struct cyttsp5 *ts = dev_get_drvdata(dev);
 413         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 414
 415         if (!si->num_btns)
 416                 return 0;
 417
 418         /* Initialize the button to RESERVED */
 419         memset32(si->key_code, KEY_RESERVED,  si->num_btns);
 420
 421         return device_property_read_u32_array(dev, "linux,keycodes",
 422                                               si->key_code, si->num_btns);
 423 }
 424
 425 static int cyttsp5_btn_attention(struct device *dev)
 426 {
 427         struct cyttsp5 *ts = dev_get_drvdata(dev);
 428         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 429         int cur_btn, offset = 0;
 430         int cur_btn_state;
 431
 432         switch (ts->input_buf[2]) {
 433         case HID_TOUCH_REPORT_ID:
 434                 offset = TOUCH_INPUT_HEADER_SIZE;
 435                 break;
 436         case HID_BTN_REPORT_ID:
 437                 offset = BTN_INPUT_HEADER_SIZE;
 438                 break;
 439         }
 440
 441         if (ts->input_buf[2] != HID_BTN_REPORT_ID)
 442                 return 0;
 443
 444         /* extract button press/release touch information */
 445         for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
 446                 /* Get current button state */
 447                 cur_btn_state = (ts->input_buf[offset] >> (cur_btn * CY_BITS_PER_BTN))
 448                                 & CY_NUM_BTN_EVENT_ID;
 449
 450                 input_report_key(ts->input, si->key_code[cur_btn],
 451                                  cur_btn_state);
 452                 input_sync(ts->input);
 453         }
 454
 455         return 0;
 456 }
 457
 458 static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
 459 {
 460         u16 size, crc;
 461         u8 status, report_id;
 462         int command_code;
 463
 464         size = get_unaligned_le16(&ts->response_buf[0]);
 465         if (!size)
 466                 return 0;
 467
 468         report_id = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
 469
 470         switch (report_id) {
 471         case HID_BL_RESPONSE_REPORT_ID:
 472                 if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
 473                         dev_err(ts->dev, "HID output response, wrong SOP\n");
 474                         return -EPROTO;
 475                 }
 476
 477                 if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
 478                         dev_err(ts->dev, "HID output response, wrong EOP\n");
 479                         return -EPROTO;
 480                 }
 481
 482                 crc = crc_itu_t(0xFFFF, &ts->response_buf[4], size - 7);
 483                 if (get_unaligned_le16(&ts->response_buf[size - 3]) != crc) {
 484                         dev_err(ts->dev,
 485                                 "HID output response, wrong CRC 0x%X\n",
 486                                 crc);
 487                         return -EPROTO;
 488                 }
 489
 490                 status = ts->response_buf[5];
 491                 if (status) {
 492                         dev_err(ts->dev, "HID output response, ERROR:%d\n",
 493                                 status);
 494                         return -EPROTO;
 495                 }
 496                 break;
 497
 498         case HID_APP_RESPONSE_REPORT_ID:
 499                 command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
 500                         & HID_OUTPUT_RESPONSE_CMD_MASK;
 501                 if (command_code != code) {
 502                         dev_err(ts->dev,
 503                                 "HID output response, wrong command_code:%X\n",
 504                                 command_code);
 505                         return -EPROTO;
 506                 }
 507                 break;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
 514 {
 515         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 516         unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET] &
 517                                 HID_SYSINFO_BTN_MASK;
 518
 519         si->num_btns = hweight8(btns);
 520 }
 521
 522 static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
 523 {
 524         struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
 525         struct cyttsp5_sensing_conf_data_dev *scd_dev =
 526                 (struct cyttsp5_sensing_conf_data_dev *)
 527                 &ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
 528
 529         cyttsp5_si_get_btn_data(ts);
 530
 531         scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
 532         scd->res_x = get_unaligned_le16(&scd_dev->res_x);
 533         scd->res_y = get_unaligned_le16(&scd_dev->res_y);
 534         scd->max_z = get_unaligned_le16(&scd_dev->max_z);
 535         scd->len_x = get_unaligned_le16(&scd_dev->len_x);
 536         scd->len_y = get_unaligned_le16(&scd_dev->len_y);
 537
 538         return 0;
 539 }
 540
 541 static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
 542 {
 543         int rc;
 544         u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
 545
 546         /* HI bytes of Output register address */
 547         put_unaligned_le16(HID_OUTPUT_GET_SYSINFO_SIZE, cmd);
 548         cmd[2] = HID_APP_OUTPUT_REPORT_ID;
 549         cmd[3] = 0x0; /* Reserved */
 550         cmd[4] = HID_OUTPUT_GET_SYSINFO;
 551
 552         rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
 553                            HID_OUTPUT_GET_SYSINFO_SIZE);
 554         if (rc) {
 555                 dev_err(ts->dev, "Failed to write command %d", rc);
 556                 return rc;
 557         }
 558
 559         rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
 560                                                 msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT_MS));
 561         if (rc <= 0) {
 562                 dev_err(ts->dev, "HID output cmd execution timed out\n");
 563                 rc = -ETIMEDOUT;
 564                 return rc;
 565         }
 566
 567         rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
 568         if (rc) {
 569                 dev_err(ts->dev, "Validation of the response failed\n");
 570                 return rc;
 571         }
 572
 573         return cyttsp5_get_sysinfo_regs(ts);
 574 }
 575
 576 static int cyttsp5_power_control(struct cyttsp5 *ts, bool on)
 577 {
 578         u8 state = on ? HID_POWER_ON : HID_POWER_SLEEP;
 579         u8 cmd[2] = { 0 };
 580         int rc;
 581
 582         SET_CMD_REPORT_TYPE(cmd[0], 0);
 583         SET_CMD_REPORT_ID(cmd[0], HID_POWER_SLEEP);
 584         SET_CMD_OPCODE(cmd[1], HID_CMD_SET_POWER);
 585
 586         rc = cyttsp5_write(ts, HID_COMMAND_REG, cmd, sizeof(cmd));
 587         if (rc) {
 588                 dev_err(ts->dev, "Failed to write power command %d", rc);
 589                 return rc;
 590         }
 591
 592         rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
 593                                 msecs_to_jiffies(CY_HID_SET_POWER_TIMEOUT));
 594         if (rc <= 0) {
 595                 dev_err(ts->dev, "HID power cmd execution timed out\n");
 596                 return -ETIMEDOUT;
 597         }
 598
 599         if (ts->response_buf[2] != HID_RESPONSE_REPORT_ID ||
 600             (ts->response_buf[3] & 0x03) != state ||
 601             (ts->response_buf[4] & 0x0f) != HID_CMD_SET_POWER) {
 602                 dev_err(ts->dev, "Validation of the %s response failed\n",
 603                         on ? "wakeup" : "sleep");
 604                 return -EINVAL;
 605         }
 606
 607         return 0;
 608 }
 609
 610 static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
 611 {
 612         int rc;
 613         u8 cmd[HID_OUTPUT_BL_LAUNCH_APP_SIZE];
 614         u16 crc;
 615
 616         put_unaligned_le16(HID_OUTPUT_BL_LAUNCH_APP_SIZE, cmd);
 617         cmd[2] = HID_BL_OUTPUT_REPORT_ID;
 618         cmd[3] = 0x0; /* Reserved */
 619         cmd[4] = HID_OUTPUT_BL_SOP;
 620         cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
 621         put_unaligned_le16(0x00, &cmd[6]);
 622         crc = crc_itu_t(0xFFFF, &cmd[4], 4);
 623         put_unaligned_le16(crc, &cmd[8]);
 624         cmd[10] = HID_OUTPUT_BL_EOP;
 625
 626         rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
 627                            HID_OUTPUT_BL_LAUNCH_APP_SIZE);
 628         if (rc) {
 629                 dev_err(ts->dev, "Failed to write command %d", rc);
 630                 return rc;
 631         }
 632
 633         rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
 634                                 msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT_MS));
 635         if (rc <= 0) {
 636                 dev_err(ts->dev, "HID output cmd execution timed out\n");
 637                 rc = -ETIMEDOUT;
 638                 return rc;
 639         }
 640
 641         rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
 642         if (rc) {
 643                 dev_err(ts->dev, "Validation of the response failed\n");
 644                 return rc;
 645         }
 646
 647         return 0;
 648 }
 649
 650 static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
 651                                       struct cyttsp5_hid_desc *desc)
 652 {
 653         struct device *dev = ts->dev;
 654         int rc;
 655
 656         rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
 657         if (rc) {
 658                 dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
 659                 return rc;
 660         }
 661
 662         rc = wait_for_completion_interruptible_timeout(&ts->cmd_done,
 663                         msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT_MS));
 664         if (rc <= 0) {
 665                 dev_err(ts->dev, "HID get descriptor timed out\n");
 666                 rc = -ETIMEDOUT;
 667                 return rc;
 668         }
 669
 670         memcpy(desc, ts->response_buf, sizeof(*desc));
 671
 672         /* Check HID descriptor length and version */
 673         if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
 674             le16_to_cpu(desc->bcd_version) != HID_VERSION) {
 675                 dev_err(dev, "Unsupported HID version\n");
 676                 return -ENODEV;
 677         }
 678
 679         return 0;
 680 }
 681
 682 static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
 683                         int offset)
 684 {
 685         tch_abs->ofs = offset / 8;
 686         tch_abs->size = report_size / 8;
 687         if (report_size % 8)
 688                 tch_abs->size += 1;
 689         tch_abs->min = 0;
 690         tch_abs->max = 1 << report_size;
 691         tch_abs->bofs = offset - (tch_abs->ofs << 3);
 692
 693         return 0;
 694 }
 695
 696 static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
 697 {
 698         struct cyttsp5 *ts = handle;
 699         int report_id;
 700         int size;
 701         int error;
 702
 703         error = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
 704         if (error)
 705                 return IRQ_HANDLED;
 706
 707         size = get_unaligned_le16(&ts->input_buf[0]);
 708         if (size == 0) {
 709                 /* reset */
 710                 report_id = 0;
 711                 size = 2;
 712         } else {
 713                 report_id = ts->input_buf[2];
 714         }
 715
 716         switch (report_id) {
 717         case HID_TOUCH_REPORT_ID:
 718                 cyttsp5_mt_attention(ts->dev);
 719                 break;
 720         case HID_BTN_REPORT_ID:
 721                 cyttsp5_btn_attention(ts->dev);
 722                 break;
 723         case HID_RESPONSE_REPORT_ID:
 724                 memcpy(ts->response_buf, ts->input_buf, size);
 725                 complete(&ts->cmd_done);
 726                 break;
 727         default:
 728                 /* It is not an input but a command response */
 729                 memcpy(ts->response_buf, ts->input_buf, size);
 730                 complete(&ts->cmd_done);
 731         }
 732
 733         return IRQ_HANDLED;
 734 }
 735
 736 static int cyttsp5_deassert_int(struct cyttsp5 *ts)
 737 {
 738         u16 size;
 739         u8 buf[2];
 740         int error;
 741
 742         error = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, sizeof(buf));
 743         if (error < 0)
 744                 return error;
 745
 746         size = get_unaligned_le16(&buf[0]);
 747         if (size == 2 || size == 0)
 748                 return 0;
 749
 750         return -EINVAL;
 751 }
 752
 753 static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
 754 {
 755         struct cyttsp5_sysinfo *si = &ts->sysinfo;
 756
 757         fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
 758                      TOUCH_REPORT_DESC_X);
 759         fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
 760                      TOUCH_REPORT_DESC_Y);
 761         fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
 762                      TOUCH_REPORT_DESC_P);
 763         fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
 764                      TOUCH_REPORT_DESC_CONTACTID);
 765         fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
 766                      TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
 767         fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
 768                      TOUCH_REPORT_DESC_MAJ);
 769         fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
 770                      TOUCH_REPORT_DESC_MIN);
 771
 772         return 0;
 773 }
 774
 775 static int cyttsp5_startup(struct cyttsp5 *ts)
 776 {
 777         int error;
 778
 779         error = cyttsp5_deassert_int(ts);
 780         if (error) {
 781                 dev_err(ts->dev, "Error on deassert int r=%d\n", error);
 782                 return -ENODEV;
 783         }
 784
 785         /*
 786          * Launch the application as the device starts in bootloader mode
 787          * because of a power-on-reset
 788          */
 789         error = cyttsp5_hid_output_bl_launch_app(ts);
 790         if (error < 0) {
 791                 dev_err(ts->dev, "Error on launch app r=%d\n", error);
 792                 return error;
 793         }
 794
 795         error = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
 796         if (error < 0) {
 797                 dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", error);
 798                 return error;
 799         }
 800
 801         error = cyttsp5_fill_all_touch(ts);
 802         if (error < 0) {
 803                 dev_err(ts->dev, "Error on report descriptor r=%d\n", error);
 804                 return error;
 805         }
 806
 807         error = cyttsp5_hid_output_get_sysinfo(ts);
 808         if (error) {
 809                 dev_err(ts->dev, "Error on getting sysinfo r=%d\n", error);
 810                 return error;
 811         }
 812
 813         return error;
 814 }
 815
 816 static void cyttsp5_cleanup(void *data)
 817 {
 818         struct cyttsp5 *ts = data;
 819
 820         regulator_disable(ts->vdd);
 821 }
 822
 823 static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
 824                          const char *name)
 825 {
 826         struct cyttsp5 *ts;
 827         struct cyttsp5_sysinfo *si;
 828         int error, i;
 829
 830         ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
 831         if (!ts)
 832                 return -ENOMEM;
 833
 834         /* Initialize device info */
 835         ts->regmap = regmap;
 836         ts->dev = dev;
 837         si = &ts->sysinfo;
 838         dev_set_drvdata(dev, ts);
 839
 840         init_completion(&ts->cmd_done);
 841
 842         /* Power up the device */
 843         ts->vdd = devm_regulator_get(dev, "vdd");
 844         if (IS_ERR(ts->vdd)) {
 845                 error = PTR_ERR(ts->vdd);
 846                 return error;
 847         }
 848
 849         error = devm_add_action_or_reset(dev, cyttsp5_cleanup, ts);
 850         if (error)
 851                 return error;
 852
 853         error = regulator_enable(ts->vdd);
 854         if (error)
 855                 return error;
 856
 857         ts->input = devm_input_allocate_device(dev);
 858         if (!ts->input) {
 859                 dev_err(dev, "Error, failed to allocate input device\n");
 860                 return -ENODEV;
 861         }
 862
 863         ts->input->name = "cyttsp5";
 864         scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
 865         ts->input->phys = ts->phys;
 866         input_set_drvdata(ts->input, ts);
 867
 868         /* Reset the gpio to be in a reset state */
 869         ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
 870         if (IS_ERR(ts->reset_gpio)) {
 871                 error = PTR_ERR(ts->reset_gpio);
 872                 dev_err(dev, "Failed to request reset gpio, error %d\n", error);
 873                 return error;
 874         }
 875         gpiod_set_value_cansleep(ts->reset_gpio, 0);
 876
 877         /* Need a delay to have device up */
 878         msleep(20);
 879
 880         error = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
 881                                           IRQF_ONESHOT, name, ts);
 882         if (error) {
 883                 dev_err(dev, "unable to request IRQ\n");
 884                 return error;
 885         }
 886
 887         error = cyttsp5_startup(ts);
 888         if (error) {
 889                 dev_err(ts->dev, "Fail initial startup r=%d\n", error);
 890                 return error;
 891         }
 892
 893         error = cyttsp5_parse_dt_key_code(dev);
 894         if (error < 0) {
 895                 dev_err(ts->dev, "Error while parsing dts %d\n", error);
 896                 return error;
 897         }
 898
 899         touchscreen_parse_properties(ts->input, true, &ts->prop);
 900
 901         __set_bit(EV_KEY, ts->input->evbit);
 902         for (i = 0; i < si->num_btns; i++)
 903                 __set_bit(si->key_code[i], ts->input->keybit);
 904
 905         return cyttsp5_setup_input_device(dev);
 906 }
 907
 908 static int cyttsp5_i2c_probe(struct i2c_client *client)
 909 {
 910         struct regmap *regmap;
 911         static const struct regmap_config config = {
 912                 .reg_bits = 8,
 913                 .val_bits = 8,
 914         };
 915
 916         regmap = devm_regmap_init_i2c(client, &config);
 917         if (IS_ERR(regmap)) {
 918                 dev_err(&client->dev, "regmap allocation failed: %ld\n",
 919                         PTR_ERR(regmap));
 920                 return PTR_ERR(regmap);
 921         }
 922
 923         return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
 924 }
 925
 926 static const struct of_device_id cyttsp5_of_match[] = {
 927         { .compatible = "cypress,tt21000", },
 928         { }
 929 };
 930 MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
 931
 932 static const struct i2c_device_id cyttsp5_i2c_id[] = {
 933         { CYTTSP5_NAME, 0, },
 934         { }
 935 };
 936 MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
 937
 938 static int __maybe_unused cyttsp5_suspend(struct device *dev)
 939 {
 940         struct cyttsp5 *ts = dev_get_drvdata(dev);
 941
 942         if (!device_may_wakeup(dev))
 943                 cyttsp5_power_control(ts, false);
 944
 945         return 0;
 946 }
 947
 948 static int __maybe_unused cyttsp5_resume(struct device *dev)
 949 {
 950         struct cyttsp5 *ts = dev_get_drvdata(dev);
 951
 952         if (!device_may_wakeup(dev))
 953                 cyttsp5_power_control(ts, true);
 954
 955         return 0;
 956 }
 957
 958 static SIMPLE_DEV_PM_OPS(cyttsp5_pm, cyttsp5_suspend, cyttsp5_resume);
 959
 960 static struct i2c_driver cyttsp5_i2c_driver = {
 961         .driver = {
 962                 .name = CYTTSP5_NAME,
 963                 .of_match_table = cyttsp5_of_match,
 964                 .pm = &cyttsp5_pm,
 965         },
 966         .probe = cyttsp5_i2c_probe,
 967         .id_table = cyttsp5_i2c_id,
 968 };
 969 module_i2c_driver(cyttsp5_i2c_driver);
 970
 971 MODULE_LICENSE("GPL");
 972 MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
 973 MODULE_AUTHOR("Mylène Josserand <mylene.josserand@bootlin.com>");