drivers/input/touchscreen/zinitix.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2
   3 #include <linux/delay.h>
   4 #include <linux/i2c.h>
   5 #include <linux/input.h>
   6 #include <linux/input/mt.h>
   7 #include <linux/input/touchscreen.h>
   8 #include <linux/interrupt.h>
   9 #include <linux/irq.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/of.h>
  13 #include <linux/regulator/consumer.h>
  14 #include <linux/slab.h>
  15
  16 /* Register Map */
  17
  18 #define BT541_SWRESET_CMD                       0x0000
  19 #define BT541_WAKEUP_CMD                        0x0001
  20
  21 #define BT541_IDLE_CMD                          0x0004
  22 #define BT541_SLEEP_CMD                         0x0005
  23
  24 #define BT541_CLEAR_INT_STATUS_CMD              0x0003
  25 #define BT541_CALIBRATE_CMD                     0x0006
  26 #define BT541_SAVE_STATUS_CMD                   0x0007
  27 #define BT541_SAVE_CALIBRATION_CMD              0x0008
  28 #define BT541_RECALL_FACTORY_CMD                0x000f
  29
  30 #define BT541_THRESHOLD                         0x0020
  31
  32 #define BT541_LARGE_PALM_REJECT_AREA_TH         0x003F
  33
  34 #define BT541_DEBUG_REG                         0x0115 /* 0~7 */
  35
  36 #define BT541_TOUCH_MODE                        0x0010
  37 #define BT541_CHIP_REVISION                     0x0011
  38 #define BT541_FIRMWARE_VERSION                  0x0012
  39
  40 #define ZINITIX_USB_DETECT                      0x116
  41
  42 #define BT541_MINOR_FW_VERSION                  0x0121
  43
  44 #define BT541_VENDOR_ID                         0x001C
  45 #define BT541_HW_ID                             0x0014
  46
  47 #define BT541_DATA_VERSION_REG                  0x0013
  48 #define BT541_SUPPORTED_FINGER_NUM              0x0015
  49 #define BT541_EEPROM_INFO                       0x0018
  50 #define BT541_INITIAL_TOUCH_MODE                0x0019
  51
  52 #define BT541_TOTAL_NUMBER_OF_X                 0x0060
  53 #define BT541_TOTAL_NUMBER_OF_Y                 0x0061
  54
  55 #define BT541_DELAY_RAW_FOR_HOST                0x007f
  56
  57 #define BT541_BUTTON_SUPPORTED_NUM              0x00B0
  58 #define BT541_BUTTON_SENSITIVITY                0x00B2
  59 #define BT541_DUMMY_BUTTON_SENSITIVITY          0X00C8
  60
  61 #define BT541_X_RESOLUTION                      0x00C0
  62 #define BT541_Y_RESOLUTION                      0x00C1
  63
  64 #define BT541_POINT_STATUS_REG                  0x0080
  65 #define BT541_ICON_STATUS_REG                   0x00AA
  66
  67 #define BT541_POINT_COORD_REG                   (BT541_POINT_STATUS_REG + 2)
  68
  69 #define BT541_AFE_FREQUENCY                     0x0100
  70 #define BT541_DND_N_COUNT                       0x0122
  71 #define BT541_DND_U_COUNT                       0x0135
  72
  73 #define BT541_RAWDATA_REG                       0x0200
  74
  75 #define BT541_EEPROM_INFO_REG                   0x0018
  76
  77 #define BT541_INT_ENABLE_FLAG                   0x00f0
  78 #define BT541_PERIODICAL_INTERRUPT_INTERVAL     0x00f1
  79
  80 #define BT541_BTN_WIDTH                         0x016d
  81
  82 #define BT541_CHECKSUM_RESULT                   0x012c
  83
  84 #define BT541_INIT_FLASH                        0x01d0
  85 #define BT541_WRITE_FLASH                       0x01d1
  86 #define BT541_READ_FLASH                        0x01d2
  87
  88 #define ZINITIX_INTERNAL_FLAG_02                0x011e
  89 #define ZINITIX_INTERNAL_FLAG_03                0x011f
  90
  91 #define ZINITIX_I2C_CHECKSUM_WCNT               0x016a
  92 #define ZINITIX_I2C_CHECKSUM_RESULT             0x016c
  93
  94 /* Interrupt & status register flags */
  95
  96 #define BIT_PT_CNT_CHANGE                       BIT(0)
  97 #define BIT_DOWN                                BIT(1)
  98 #define BIT_MOVE                                BIT(2)
  99 #define BIT_UP                                  BIT(3)
 100 #define BIT_PALM                                BIT(4)
 101 #define BIT_PALM_REJECT                         BIT(5)
 102 #define BIT_RESERVED_0                          BIT(6)
 103 #define BIT_RESERVED_1                          BIT(7)
 104 #define BIT_WEIGHT_CHANGE                       BIT(8)
 105 #define BIT_PT_NO_CHANGE                        BIT(9)
 106 #define BIT_REJECT                              BIT(10)
 107 #define BIT_PT_EXIST                            BIT(11)
 108 #define BIT_RESERVED_2                          BIT(12)
 109 #define BIT_ERROR                               BIT(13)
 110 #define BIT_DEBUG                               BIT(14)
 111 #define BIT_ICON_EVENT                          BIT(15)
 112
 113 #define SUB_BIT_EXIST                           BIT(0)
 114 #define SUB_BIT_DOWN                            BIT(1)
 115 #define SUB_BIT_MOVE                            BIT(2)
 116 #define SUB_BIT_UP                              BIT(3)
 117 #define SUB_BIT_UPDATE                          BIT(4)
 118 #define SUB_BIT_WAIT                            BIT(5)
 119
 120 #define DEFAULT_TOUCH_POINT_MODE                2
 121 #define MAX_SUPPORTED_FINGER_NUM                5
 122
 123 #define CHIP_ON_DELAY                           15 // ms
 124 #define FIRMWARE_ON_DELAY                       40 // ms
 125
 126 struct point_coord {
 127         __le16  x;
 128         __le16  y;
 129         u8      width;
 130         u8      sub_status;
 131         // currently unused, but needed as padding:
 132         u8      minor_width;
 133         u8      angle;
 134 };
 135
 136 struct touch_event {
 137         __le16  status;
 138         u8      finger_cnt;
 139         u8      time_stamp;
 140         struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM];
 141 };
 142
 143 struct bt541_ts_data {
 144         struct i2c_client *client;
 145         struct input_dev *input_dev;
 146         struct touchscreen_properties prop;
 147         struct regulator_bulk_data supplies[2];
 148         u32 zinitix_mode;
 149 };
 150
 151 static int zinitix_read_data(struct i2c_client *client,
 152                              u16 reg, void *values, size_t length)
 153 {
 154         __le16 reg_le = cpu_to_le16(reg);
 155         int ret;
 156
 157         /* A single i2c_transfer() transaction does not work here. */
 158         ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
 159         if (ret != sizeof(reg_le))
 160                 return ret < 0 ? ret : -EIO;
 161
 162         ret = i2c_master_recv(client, (u8 *)values, length);
 163         if (ret != length)
 164                 return ret < 0 ? ret : -EIO; ;
 165
 166         return 0;
 167 }
 168
 169 static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value)
 170 {
 171         __le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)};
 172         int ret;
 173
 174         ret = i2c_master_send(client, (u8 *)packet, sizeof(packet));
 175         if (ret != sizeof(packet))
 176                 return ret < 0 ? ret : -EIO;
 177
 178         return 0;
 179 }
 180
 181 static int zinitix_write_cmd(struct i2c_client *client, u16 reg)
 182 {
 183         __le16 reg_le = cpu_to_le16(reg);
 184         int ret;
 185
 186         ret = i2c_master_send(client, (u8 *)&reg_le, sizeof(reg_le));
 187         if (ret != sizeof(reg_le))
 188                 return ret < 0 ? ret : -EIO;
 189
 190         return 0;
 191 }
 192
 193 static bool zinitix_init_touch(struct bt541_ts_data *bt541)
 194 {
 195         struct i2c_client *client = bt541->client;
 196         int i;
 197         int error;
 198
 199         error = zinitix_write_cmd(client, BT541_SWRESET_CMD);
 200         if (error) {
 201                 dev_err(&client->dev, "Failed to write reset command\n");
 202                 return error;
 203         }
 204
 205         error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG, 0x0);
 206         if (error) {
 207                 dev_err(&client->dev,
 208                         "Failed to reset interrupt enable flag\n");
 209                 return error;
 210         }
 211
 212         /* initialize */
 213         error = zinitix_write_u16(client, BT541_X_RESOLUTION,
 214                                   bt541->prop.max_x);
 215         if (error)
 216                 return error;
 217
 218         error = zinitix_write_u16(client, BT541_Y_RESOLUTION,
 219                                   bt541->prop.max_y);
 220         if (error)
 221                 return error;
 222
 223         error = zinitix_write_u16(client, BT541_SUPPORTED_FINGER_NUM,
 224                                   MAX_SUPPORTED_FINGER_NUM);
 225         if (error)
 226                 return error;
 227
 228         error = zinitix_write_u16(client, BT541_INITIAL_TOUCH_MODE,
 229                                   bt541->zinitix_mode);
 230         if (error)
 231                 return error;
 232
 233         error = zinitix_write_u16(client, BT541_TOUCH_MODE,
 234                                   bt541->zinitix_mode);
 235         if (error)
 236                 return error;
 237
 238         error = zinitix_write_u16(client, BT541_INT_ENABLE_FLAG,
 239                                   BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE |
 240                                         BIT_UP);
 241         if (error)
 242                 return error;
 243
 244         /* clear queue */
 245         for (i = 0; i < 10; i++) {
 246                 zinitix_write_cmd(client, BT541_CLEAR_INT_STATUS_CMD);
 247                 udelay(10);
 248         }
 249
 250         return 0;
 251 }
 252
 253 static int zinitix_init_regulators(struct bt541_ts_data *bt541)
 254 {
 255         struct i2c_client *client = bt541->client;
 256         int error;
 257
 258         bt541->supplies[0].supply = "vdd";
 259         bt541->supplies[1].supply = "vddo";
 260         error = devm_regulator_bulk_get(&client->dev,
 261                                         ARRAY_SIZE(bt541->supplies),
 262                                         bt541->supplies);
 263         if (error < 0) {
 264                 dev_err(&client->dev, "Failed to get regulators: %d\n", error);
 265                 return error;
 266         }
 267
 268         return 0;
 269 }
 270
 271 static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
 272 {
 273         int error;
 274         struct i2c_client *client = bt541->client;
 275
 276         error = zinitix_write_u16(client, 0xc000, 0x0001);
 277         if (error) {
 278                 dev_err(&client->dev,
 279                         "Failed to send power sequence(vendor cmd enable)\n");
 280                 return error;
 281         }
 282         udelay(10);
 283
 284         error = zinitix_write_cmd(client, 0xc004);
 285         if (error) {
 286                 dev_err(&client->dev,
 287                         "Failed to send power sequence (intn clear)\n");
 288                 return error;
 289         }
 290         udelay(10);
 291
 292         error = zinitix_write_u16(client, 0xc002, 0x0001);
 293         if (error) {
 294                 dev_err(&client->dev,
 295                         "Failed to send power sequence (nvm init)\n");
 296                 return error;
 297         }
 298         mdelay(2);
 299
 300         error = zinitix_write_u16(client, 0xc001, 0x0001);
 301         if (error) {
 302                 dev_err(&client->dev,
 303                         "Failed to send power sequence (program start)\n");
 304                 return error;
 305         }
 306         msleep(FIRMWARE_ON_DELAY);
 307
 308         return 0;
 309 }
 310
 311 static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
 312                                   const struct point_coord *p)
 313 {
 314         input_mt_slot(bt541->input_dev, slot);
 315         input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
 316         touchscreen_report_pos(bt541->input_dev, &bt541->prop,
 317                                le16_to_cpu(p->x), le16_to_cpu(p->y), true);
 318         input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, p->width);
 319 }
 320
 321 static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
 322 {
 323         struct bt541_ts_data *bt541 = bt541_handler;
 324         struct i2c_client *client = bt541->client;
 325         struct touch_event touch_event;
 326         int error;
 327         int i;
 328
 329         memset(&touch_event, 0, sizeof(struct touch_event));
 330
 331         error = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
 332                                   &touch_event, sizeof(struct touch_event));
 333         if (error) {
 334                 dev_err(&client->dev, "Failed to read in touchpoint struct\n");
 335                 goto out;
 336         }
 337
 338         for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++)
 339                 if (touch_event.point_coord[i].sub_status & SUB_BIT_EXIST)
 340                         zinitix_report_finger(bt541, i,
 341                                               &touch_event.point_coord[i]);
 342
 343         input_mt_sync_frame(bt541->input_dev);
 344         input_sync(bt541->input_dev);
 345
 346 out:
 347         zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
 348         return IRQ_HANDLED;
 349 }
 350
 351 static int zinitix_start(struct bt541_ts_data *bt541)
 352 {
 353         int error;
 354
 355         error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
 356                                       bt541->supplies);
 357         if (error) {
 358                 dev_err(&bt541->client->dev,
 359                         "Failed to enable regulators: %d\n", error);
 360                 return error;
 361         }
 362
 363         msleep(CHIP_ON_DELAY);
 364
 365         error = zinitix_send_power_on_sequence(bt541);
 366         if (error) {
 367                 dev_err(&bt541->client->dev,
 368                         "Error while sending power-on sequence: %d\n", error);
 369                 return error;
 370         }
 371
 372         error = zinitix_init_touch(bt541);
 373         if (error) {
 374                 dev_err(&bt541->client->dev,
 375                         "Error while configuring touch IC\n");
 376                 return error;
 377         }
 378
 379         enable_irq(bt541->client->irq);
 380
 381         return 0;
 382 }
 383
 384 static int zinitix_stop(struct bt541_ts_data *bt541)
 385 {
 386         int error;
 387
 388         disable_irq(bt541->client->irq);
 389
 390         error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
 391                                        bt541->supplies);
 392         if (error) {
 393                 dev_err(&bt541->client->dev,
 394                         "Failed to disable regulators: %d\n", error);
 395                 return error;
 396         }
 397
 398         return 0;
 399 }
 400
 401 static int zinitix_input_open(struct input_dev *dev)
 402 {
 403         struct bt541_ts_data *bt541 = input_get_drvdata(dev);
 404
 405         return zinitix_start(bt541);
 406 }
 407
 408 static void zinitix_input_close(struct input_dev *dev)
 409 {
 410         struct bt541_ts_data *bt541 = input_get_drvdata(dev);
 411
 412         zinitix_stop(bt541);
 413 }
 414
 415 static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
 416 {
 417         struct input_dev *input_dev;
 418         int error;
 419
 420         input_dev = devm_input_allocate_device(&bt541->client->dev);
 421         if (!input_dev) {
 422                 dev_err(&bt541->client->dev,
 423                         "Failed to allocate input device.");
 424                 return -ENOMEM;
 425         }
 426
 427         input_set_drvdata(input_dev, bt541);
 428         bt541->input_dev = input_dev;
 429
 430         input_dev->name = "Zinitix Capacitive TouchScreen";
 431         input_dev->phys = "input/ts";
 432         input_dev->id.bustype = BUS_I2C;
 433         input_dev->open = zinitix_input_open;
 434         input_dev->close = zinitix_input_close;
 435
 436         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
 437         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
 438         input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 439         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 440
 441         touchscreen_parse_properties(input_dev, true, &bt541->prop);
 442         if (!bt541->prop.max_x || !bt541->prop.max_y) {
 443                 dev_err(&bt541->client->dev,
 444                         "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
 445                 return -EINVAL;
 446         }
 447
 448         error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
 449                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 450         if (error) {
 451                 dev_err(&bt541->client->dev,
 452                         "Failed to initialize MT slots: %d", error);
 453                 return error;
 454         }
 455
 456         error = input_register_device(input_dev);
 457         if (error) {
 458                 dev_err(&bt541->client->dev,
 459                         "Failed to register input device: %d", error);
 460                 return error;
 461         }
 462
 463         return 0;
 464 }
 465
 466 static int zinitix_ts_probe(struct i2c_client *client)
 467 {
 468         struct bt541_ts_data *bt541;
 469         int error;
 470
 471         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 472                 dev_err(&client->dev,
 473                         "Failed to assert adapter's support for plain I2C.\n");
 474                 return -ENXIO;
 475         }
 476
 477         bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
 478         if (!bt541)
 479                 return -ENOMEM;
 480
 481         bt541->client = client;
 482         i2c_set_clientdata(client, bt541);
 483
 484         error = zinitix_init_regulators(bt541);
 485         if (error) {
 486                 dev_err(&client->dev,
 487                         "Failed to initialize regulators: %d\n", error);
 488                 return error;
 489         }
 490
 491         error = zinitix_init_input_dev(bt541);
 492         if (error) {
 493                 dev_err(&client->dev,
 494                         "Failed to initialize input device: %d\n", error);
 495                 return error;
 496         }
 497
 498         error = device_property_read_u32(&client->dev, "zinitix,mode",
 499                                          &bt541->zinitix_mode);
 500         if (error < 0) {
 501                 /* fall back to mode 2 */
 502                 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
 503         }
 504
 505         if (bt541->zinitix_mode != 2) {
 506                 /*
 507                  * If there are devices that don't support mode 2, support
 508                  * for other modes (0, 1) will be needed.
 509                  */
 510                 dev_err(&client->dev,
 511                         "Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
 512                         bt541->zinitix_mode);
 513                 return -EINVAL;
 514         }
 515
 516         irq_set_status_flags(client->irq, IRQ_NOAUTOEN);
 517         error = devm_request_threaded_irq(&client->dev, client->irq,
 518                                           NULL, zinitix_ts_irq_handler,
 519                                           IRQF_ONESHOT, client->name, bt541);
 520         if (error) {
 521                 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
 522                 return error;
 523         }
 524
 525         return 0;
 526 }
 527
 528 static int __maybe_unused zinitix_suspend(struct device *dev)
 529 {
 530         struct i2c_client *client = to_i2c_client(dev);
 531         struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
 532
 533         mutex_lock(&bt541->input_dev->mutex);
 534
 535         if (input_device_enabled(bt541->input_dev))
 536                 zinitix_stop(bt541);
 537
 538         mutex_unlock(&bt541->input_dev->mutex);
 539
 540         return 0;
 541 }
 542
 543 static int __maybe_unused zinitix_resume(struct device *dev)
 544 {
 545         struct i2c_client *client = to_i2c_client(dev);
 546         struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
 547         int ret = 0;
 548
 549         mutex_lock(&bt541->input_dev->mutex);
 550
 551         if (input_device_enabled(bt541->input_dev))
 552                 ret = zinitix_start(bt541);
 553
 554         mutex_unlock(&bt541->input_dev->mutex);
 555
 556         return ret;
 557 }
 558
 559 static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
 560
 561 #ifdef CONFIG_OF
 562 static const struct of_device_id zinitix_of_match[] = {
 563         { .compatible = "zinitix,bt541" },
 564         { }
 565 };
 566 MODULE_DEVICE_TABLE(of, zinitix_of_match);
 567 #endif
 568
 569 static struct i2c_driver zinitix_ts_driver = {
 570         .probe_new = zinitix_ts_probe,
 571         .driver = {
 572                 .name = "Zinitix-TS",
 573                 .pm = &zinitix_pm_ops,
 574                 .of_match_table = of_match_ptr(zinitix_of_match),
 575         },
 576 };
 577 module_i2c_driver(zinitix_ts_driver);
 578
 579 MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
 580 MODULE_DESCRIPTION("Zinitix touchscreen driver");
 581 MODULE_LICENSE("GPL v2");