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 int 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 device *dev = &bt541->client->dev;
 256         int error;
 257
 258         /*
 259          * Some older device trees have erroneous names for the regulators,
 260          * so check if "vddo" is present and in that case use these names.
 261          * Else use the proper supply names on the component.
 262          */
 263         if (of_find_property(dev->of_node, "vddo-supply", NULL)) {
 264                 bt541->supplies[0].supply = "vdd";
 265                 bt541->supplies[1].supply = "vddo";
 266         } else {
 267                 /* Else use the proper supply names */
 268                 bt541->supplies[0].supply = "vcca";
 269                 bt541->supplies[1].supply = "vdd";
 270         }
 271         error = devm_regulator_bulk_get(dev,
 272                                         ARRAY_SIZE(bt541->supplies),
 273                                         bt541->supplies);
 274         if (error < 0) {
 275                 dev_err(dev, "Failed to get regulators: %d\n", error);
 276                 return error;
 277         }
 278
 279         return 0;
 280 }
 281
 282 static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541)
 283 {
 284         int error;
 285         struct i2c_client *client = bt541->client;
 286
 287         error = zinitix_write_u16(client, 0xc000, 0x0001);
 288         if (error) {
 289                 dev_err(&client->dev,
 290                         "Failed to send power sequence(vendor cmd enable)\n");
 291                 return error;
 292         }
 293         udelay(10);
 294
 295         error = zinitix_write_cmd(client, 0xc004);
 296         if (error) {
 297                 dev_err(&client->dev,
 298                         "Failed to send power sequence (intn clear)\n");
 299                 return error;
 300         }
 301         udelay(10);
 302
 303         error = zinitix_write_u16(client, 0xc002, 0x0001);
 304         if (error) {
 305                 dev_err(&client->dev,
 306                         "Failed to send power sequence (nvm init)\n");
 307                 return error;
 308         }
 309         mdelay(2);
 310
 311         error = zinitix_write_u16(client, 0xc001, 0x0001);
 312         if (error) {
 313                 dev_err(&client->dev,
 314                         "Failed to send power sequence (program start)\n");
 315                 return error;
 316         }
 317         msleep(FIRMWARE_ON_DELAY);
 318
 319         return 0;
 320 }
 321
 322 static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot,
 323                                   const struct point_coord *p)
 324 {
 325         input_mt_slot(bt541->input_dev, slot);
 326         input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, true);
 327         touchscreen_report_pos(bt541->input_dev, &bt541->prop,
 328                                le16_to_cpu(p->x), le16_to_cpu(p->y), true);
 329         input_report_abs(bt541->input_dev, ABS_MT_TOUCH_MAJOR, p->width);
 330 }
 331
 332 static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler)
 333 {
 334         struct bt541_ts_data *bt541 = bt541_handler;
 335         struct i2c_client *client = bt541->client;
 336         struct touch_event touch_event;
 337         int error;
 338         int i;
 339
 340         memset(&touch_event, 0, sizeof(struct touch_event));
 341
 342         error = zinitix_read_data(bt541->client, BT541_POINT_STATUS_REG,
 343                                   &touch_event, sizeof(struct touch_event));
 344         if (error) {
 345                 dev_err(&client->dev, "Failed to read in touchpoint struct\n");
 346                 goto out;
 347         }
 348
 349         for (i = 0; i < MAX_SUPPORTED_FINGER_NUM; i++)
 350                 if (touch_event.point_coord[i].sub_status & SUB_BIT_EXIST)
 351                         zinitix_report_finger(bt541, i,
 352                                               &touch_event.point_coord[i]);
 353
 354         input_mt_sync_frame(bt541->input_dev);
 355         input_sync(bt541->input_dev);
 356
 357 out:
 358         zinitix_write_cmd(bt541->client, BT541_CLEAR_INT_STATUS_CMD);
 359         return IRQ_HANDLED;
 360 }
 361
 362 static int zinitix_start(struct bt541_ts_data *bt541)
 363 {
 364         int error;
 365
 366         error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies),
 367                                       bt541->supplies);
 368         if (error) {
 369                 dev_err(&bt541->client->dev,
 370                         "Failed to enable regulators: %d\n", error);
 371                 return error;
 372         }
 373
 374         msleep(CHIP_ON_DELAY);
 375
 376         error = zinitix_send_power_on_sequence(bt541);
 377         if (error) {
 378                 dev_err(&bt541->client->dev,
 379                         "Error while sending power-on sequence: %d\n", error);
 380                 return error;
 381         }
 382
 383         error = zinitix_init_touch(bt541);
 384         if (error) {
 385                 dev_err(&bt541->client->dev,
 386                         "Error while configuring touch IC\n");
 387                 return error;
 388         }
 389
 390         enable_irq(bt541->client->irq);
 391
 392         return 0;
 393 }
 394
 395 static int zinitix_stop(struct bt541_ts_data *bt541)
 396 {
 397         int error;
 398
 399         disable_irq(bt541->client->irq);
 400
 401         error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies),
 402                                        bt541->supplies);
 403         if (error) {
 404                 dev_err(&bt541->client->dev,
 405                         "Failed to disable regulators: %d\n", error);
 406                 return error;
 407         }
 408
 409         return 0;
 410 }
 411
 412 static int zinitix_input_open(struct input_dev *dev)
 413 {
 414         struct bt541_ts_data *bt541 = input_get_drvdata(dev);
 415
 416         return zinitix_start(bt541);
 417 }
 418
 419 static void zinitix_input_close(struct input_dev *dev)
 420 {
 421         struct bt541_ts_data *bt541 = input_get_drvdata(dev);
 422
 423         zinitix_stop(bt541);
 424 }
 425
 426 static int zinitix_init_input_dev(struct bt541_ts_data *bt541)
 427 {
 428         struct input_dev *input_dev;
 429         int error;
 430
 431         input_dev = devm_input_allocate_device(&bt541->client->dev);
 432         if (!input_dev) {
 433                 dev_err(&bt541->client->dev,
 434                         "Failed to allocate input device.");
 435                 return -ENOMEM;
 436         }
 437
 438         input_set_drvdata(input_dev, bt541);
 439         bt541->input_dev = input_dev;
 440
 441         input_dev->name = "Zinitix Capacitive TouchScreen";
 442         input_dev->phys = "input/ts";
 443         input_dev->id.bustype = BUS_I2C;
 444         input_dev->open = zinitix_input_open;
 445         input_dev->close = zinitix_input_close;
 446
 447         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
 448         input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
 449         input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 450         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 451
 452         touchscreen_parse_properties(input_dev, true, &bt541->prop);
 453         if (!bt541->prop.max_x || !bt541->prop.max_y) {
 454                 dev_err(&bt541->client->dev,
 455                         "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n");
 456                 return -EINVAL;
 457         }
 458
 459         error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM,
 460                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 461         if (error) {
 462                 dev_err(&bt541->client->dev,
 463                         "Failed to initialize MT slots: %d", error);
 464                 return error;
 465         }
 466
 467         error = input_register_device(input_dev);
 468         if (error) {
 469                 dev_err(&bt541->client->dev,
 470                         "Failed to register input device: %d", error);
 471                 return error;
 472         }
 473
 474         return 0;
 475 }
 476
 477 static int zinitix_ts_probe(struct i2c_client *client)
 478 {
 479         struct bt541_ts_data *bt541;
 480         int error;
 481
 482         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 483                 dev_err(&client->dev,
 484                         "Failed to assert adapter's support for plain I2C.\n");
 485                 return -ENXIO;
 486         }
 487
 488         bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL);
 489         if (!bt541)
 490                 return -ENOMEM;
 491
 492         bt541->client = client;
 493         i2c_set_clientdata(client, bt541);
 494
 495         error = zinitix_init_regulators(bt541);
 496         if (error) {
 497                 dev_err(&client->dev,
 498                         "Failed to initialize regulators: %d\n", error);
 499                 return error;
 500         }
 501
 502         error = devm_request_threaded_irq(&client->dev, client->irq,
 503                                           NULL, zinitix_ts_irq_handler,
 504                                           IRQF_ONESHOT | IRQF_NO_AUTOEN,
 505                                           client->name, bt541);
 506         if (error) {
 507                 dev_err(&client->dev, "Failed to request IRQ: %d\n", error);
 508                 return error;
 509         }
 510
 511         error = zinitix_init_input_dev(bt541);
 512         if (error) {
 513                 dev_err(&client->dev,
 514                         "Failed to initialize input device: %d\n", error);
 515                 return error;
 516         }
 517
 518         error = device_property_read_u32(&client->dev, "zinitix,mode",
 519                                          &bt541->zinitix_mode);
 520         if (error < 0) {
 521                 /* fall back to mode 2 */
 522                 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE;
 523         }
 524
 525         if (bt541->zinitix_mode != 2) {
 526                 /*
 527                  * If there are devices that don't support mode 2, support
 528                  * for other modes (0, 1) will be needed.
 529                  */
 530                 dev_err(&client->dev,
 531                         "Malformed zinitix,mode property, must be 2 (supplied: %d)\n",
 532                         bt541->zinitix_mode);
 533                 return -EINVAL;
 534         }
 535
 536         return 0;
 537 }
 538
 539 static int __maybe_unused zinitix_suspend(struct device *dev)
 540 {
 541         struct i2c_client *client = to_i2c_client(dev);
 542         struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
 543
 544         mutex_lock(&bt541->input_dev->mutex);
 545
 546         if (input_device_enabled(bt541->input_dev))
 547                 zinitix_stop(bt541);
 548
 549         mutex_unlock(&bt541->input_dev->mutex);
 550
 551         return 0;
 552 }
 553
 554 static int __maybe_unused zinitix_resume(struct device *dev)
 555 {
 556         struct i2c_client *client = to_i2c_client(dev);
 557         struct bt541_ts_data *bt541 = i2c_get_clientdata(client);
 558         int ret = 0;
 559
 560         mutex_lock(&bt541->input_dev->mutex);
 561
 562         if (input_device_enabled(bt541->input_dev))
 563                 ret = zinitix_start(bt541);
 564
 565         mutex_unlock(&bt541->input_dev->mutex);
 566
 567         return ret;
 568 }
 569
 570 static SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume);
 571
 572 #ifdef CONFIG_OF
 573 static const struct of_device_id zinitix_of_match[] = {
 574         { .compatible = "zinitix,bt532" },
 575         { .compatible = "zinitix,bt541" },
 576         { }
 577 };
 578 MODULE_DEVICE_TABLE(of, zinitix_of_match);
 579 #endif
 580
 581 static struct i2c_driver zinitix_ts_driver = {
 582         .probe_new = zinitix_ts_probe,
 583         .driver = {
 584                 .name = "Zinitix-TS",
 585                 .pm = &zinitix_pm_ops,
 586                 .of_match_table = of_match_ptr(zinitix_of_match),
 587         },
 588 };
 589 module_i2c_driver(zinitix_ts_driver);
 590
 591 MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>");
 592 MODULE_DESCRIPTION("Zinitix touchscreen driver");
 593 MODULE_LICENSE("GPL v2");