drivers/input/touchscreen/s6sy761.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // Samsung S6SY761 Touchscreen device driver
   3 //
   4 // Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5 // Copyright (c) 2017 Andi Shyti <andi@etezian.org>
   6
   7 #include <linux/unaligned.h>
   8 #include <linux/delay.h>
   9 #include <linux/i2c.h>
  10 #include <linux/input/mt.h>
  11 #include <linux/input/touchscreen.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/irq.h>
  14 #include <linux/module.h>
  15 #include <linux/pm_runtime.h>
  16 #include <linux/regulator/consumer.h>
  17
  18 /* commands */
  19 #define S6SY761_SENSE_ON                0x10
  20 #define S6SY761_SENSE_OFF               0x11
  21 #define S6SY761_TOUCH_FUNCTION          0x30 /* R/W for get/set */
  22 #define S6SY761_FIRMWARE_INTEGRITY      0x21
  23 #define S6SY761_PANEL_INFO              0x23
  24 #define S6SY761_DEVICE_ID               0x52
  25 #define S6SY761_BOOT_STATUS             0x55
  26 #define S6SY761_READ_ONE_EVENT          0x60
  27 #define S6SY761_READ_ALL_EVENT          0x61
  28 #define S6SY761_CLEAR_EVENT_STACK       0x62
  29 #define S6SY761_APPLICATION_MODE        0xe4
  30
  31 /* events */
  32 #define S6SY761_EVENT_INFO              0x02
  33 #define S6SY761_EVENT_VENDOR_INFO       0x07
  34
  35 /* info */
  36 #define S6SY761_INFO_BOOT_COMPLETE      0x00
  37
  38 /* firmware status */
  39 #define S6SY761_FW_OK                   0x80
  40
  41 /*
  42  * the functionalities are put as a reference
  43  * as in the device I am using none of them
  44  * works therefore not used in this driver yet.
  45  */
  46 /* touchscreen functionalities */
  47 #define S6SY761_MASK_TOUCH              BIT(0)
  48 #define S6SY761_MASK_HOVER              BIT(1)
  49 #define S6SY761_MASK_COVER              BIT(2)
  50 #define S6SY761_MASK_GLOVE              BIT(3)
  51 #define S6SY761_MASK_STYLUS             BIT(4)
  52 #define S6SY761_MASK_PALM               BIT(5)
  53 #define S6SY761_MASK_WET                BIT(6)
  54 #define S6SY761_MASK_PROXIMITY          BIT(7)
  55
  56 /* boot status (BS) */
  57 #define S6SY761_BS_BOOT_LOADER          0x10
  58 #define S6SY761_BS_APPLICATION          0x20
  59
  60 /* event id */
  61 #define S6SY761_EVENT_ID_COORDINATE     0x00
  62 #define S6SY761_EVENT_ID_STATUS         0x01
  63
  64 /* event register masks */
  65 #define S6SY761_MASK_TOUCH_STATE        0xc0 /* byte 0 */
  66 #define S6SY761_MASK_TID                0x3c
  67 #define S6SY761_MASK_EID                0x03
  68 #define S6SY761_MASK_X                  0xf0 /* byte 3 */
  69 #define S6SY761_MASK_Y                  0x0f
  70 #define S6SY761_MASK_Z                  0x3f /* byte 6 */
  71 #define S6SY761_MASK_LEFT_EVENTS        0x3f /* byte 7 */
  72 #define S6SY761_MASK_TOUCH_TYPE         0xc0 /* MSB in byte 6, LSB in byte 7 */
  73
  74 /* event touch state values */
  75 #define S6SY761_TS_NONE                 0x00
  76 #define S6SY761_TS_PRESS                0x01
  77 #define S6SY761_TS_MOVE                 0x02
  78 #define S6SY761_TS_RELEASE              0x03
  79
  80 /* application modes */
  81 #define S6SY761_APP_NORMAL              0x0
  82 #define S6SY761_APP_LOW_POWER           0x1
  83 #define S6SY761_APP_TEST                0x2
  84 #define S6SY761_APP_FLASH               0x3
  85 #define S6SY761_APP_SLEEP               0x4
  86
  87 #define S6SY761_EVENT_SIZE              8
  88 #define S6SY761_EVENT_COUNT             32
  89 #define S6SY761_DEVID_SIZE              3
  90 #define S6SY761_PANEL_ID_SIZE           11
  91 #define S6SY761_TS_STATUS_SIZE          5
  92 #define S6SY761_MAX_FINGERS             10
  93
  94 #define S6SY761_DEV_NAME        "s6sy761"
  95
  96 enum s6sy761_regulators {
  97         S6SY761_REGULATOR_VDD,
  98         S6SY761_REGULATOR_AVDD,
  99 };
 100
 101 struct s6sy761_data {
 102         struct i2c_client *client;
 103         struct regulator_bulk_data regulators[2];
 104         struct input_dev *input;
 105         struct touchscreen_properties prop;
 106
 107         u8 data[S6SY761_EVENT_SIZE * S6SY761_EVENT_COUNT];
 108
 109         u16 devid;
 110         u8 tx_channel;
 111 };
 112
 113 /*
 114  * We can't simply use i2c_smbus_read_i2c_block_data because we
 115  * need to read more than 255 bytes
 116  */
 117 static int s6sy761_read_events(struct s6sy761_data *sdata, u16 n_events)
 118 {
 119         u8 cmd = S6SY761_READ_ALL_EVENT;
 120         struct i2c_msg msgs[2] = {
 121                 {
 122                         .addr   = sdata->client->addr,
 123                         .len    = 1,
 124                         .buf    = &cmd,
 125                 },
 126                 {
 127                         .addr   = sdata->client->addr,
 128                         .flags  = I2C_M_RD,
 129                         .len    = (n_events * S6SY761_EVENT_SIZE),
 130                         .buf    = sdata->data + S6SY761_EVENT_SIZE,
 131                 },
 132         };
 133         int ret;
 134
 135         ret = i2c_transfer(sdata->client->adapter, msgs, ARRAY_SIZE(msgs));
 136         if (ret < 0)
 137                 return ret;
 138
 139         return ret == ARRAY_SIZE(msgs) ? 0 : -EIO;
 140 }
 141
 142 static void s6sy761_report_coordinates(struct s6sy761_data *sdata,
 143                                        u8 *event, u8 tid)
 144 {
 145         u8 major = event[4];
 146         u8 minor = event[5];
 147         u8 z = event[6] & S6SY761_MASK_Z;
 148         u16 x = (event[1] << 4) | ((event[3] & S6SY761_MASK_X) >> 4);
 149         u16 y = (event[2] << 4) | (event[3] & S6SY761_MASK_Y);
 150
 151         input_mt_slot(sdata->input, tid);
 152
 153         input_mt_report_slot_state(sdata->input, MT_TOOL_FINGER, true);
 154         input_report_abs(sdata->input, ABS_MT_POSITION_X, x);
 155         input_report_abs(sdata->input, ABS_MT_POSITION_Y, y);
 156         input_report_abs(sdata->input, ABS_MT_TOUCH_MAJOR, major);
 157         input_report_abs(sdata->input, ABS_MT_TOUCH_MINOR, minor);
 158         input_report_abs(sdata->input, ABS_MT_PRESSURE, z);
 159
 160         input_sync(sdata->input);
 161 }
 162
 163 static void s6sy761_report_release(struct s6sy761_data *sdata,
 164                                    u8 *event, u8 tid)
 165 {
 166         input_mt_slot(sdata->input, tid);
 167         input_mt_report_slot_state(sdata->input, MT_TOOL_FINGER, false);
 168
 169         input_sync(sdata->input);
 170 }
 171
 172 static void s6sy761_handle_coordinates(struct s6sy761_data *sdata, u8 *event)
 173 {
 174         u8 tid;
 175         u8 touch_state;
 176
 177         if (unlikely(!(event[0] & S6SY761_MASK_TID)))
 178                 return;
 179
 180         tid = ((event[0] & S6SY761_MASK_TID) >> 2) - 1;
 181         touch_state = (event[0] & S6SY761_MASK_TOUCH_STATE) >> 6;
 182
 183         switch (touch_state) {
 184
 185         case S6SY761_TS_NONE:
 186                 break;
 187         case S6SY761_TS_RELEASE:
 188                 s6sy761_report_release(sdata, event, tid);
 189                 break;
 190         case S6SY761_TS_PRESS:
 191         case S6SY761_TS_MOVE:
 192                 s6sy761_report_coordinates(sdata, event, tid);
 193                 break;
 194         }
 195 }
 196
 197 static void s6sy761_handle_events(struct s6sy761_data *sdata, u8 n_events)
 198 {
 199         int i;
 200
 201         for (i = 0; i < n_events; i++) {
 202                 u8 *event = &sdata->data[i * S6SY761_EVENT_SIZE];
 203                 u8 event_id = event[0] & S6SY761_MASK_EID;
 204
 205                 if (!event[0])
 206                         return;
 207
 208                 switch (event_id) {
 209
 210                 case S6SY761_EVENT_ID_COORDINATE:
 211                         s6sy761_handle_coordinates(sdata, event);
 212                         break;
 213
 214                 case S6SY761_EVENT_ID_STATUS:
 215                         break;
 216
 217                 default:
 218                         break;
 219                 }
 220         }
 221 }
 222
 223 static irqreturn_t s6sy761_irq_handler(int irq, void *dev)
 224 {
 225         struct s6sy761_data *sdata = dev;
 226         int ret;
 227         u8 n_events;
 228
 229         ret = i2c_smbus_read_i2c_block_data(sdata->client,
 230                                             S6SY761_READ_ONE_EVENT,
 231                                             S6SY761_EVENT_SIZE,
 232                                             sdata->data);
 233         if (ret < 0) {
 234                 dev_err(&sdata->client->dev, "failed to read events\n");
 235                 return IRQ_HANDLED;
 236         }
 237
 238         if (!sdata->data[0])
 239                 return IRQ_HANDLED;
 240
 241         n_events = sdata->data[7] & S6SY761_MASK_LEFT_EVENTS;
 242         if (unlikely(n_events > S6SY761_EVENT_COUNT - 1))
 243                 return IRQ_HANDLED;
 244
 245         if (n_events) {
 246                 ret = s6sy761_read_events(sdata, n_events);
 247                 if (ret < 0) {
 248                         dev_err(&sdata->client->dev, "failed to read events\n");
 249                         return IRQ_HANDLED;
 250                 }
 251         }
 252
 253         s6sy761_handle_events(sdata, n_events +  1);
 254
 255         return IRQ_HANDLED;
 256 }
 257
 258 static int s6sy761_input_open(struct input_dev *dev)
 259 {
 260         struct s6sy761_data *sdata = input_get_drvdata(dev);
 261
 262         return i2c_smbus_write_byte(sdata->client, S6SY761_SENSE_ON);
 263 }
 264
 265 static void s6sy761_input_close(struct input_dev *dev)
 266 {
 267         struct s6sy761_data *sdata = input_get_drvdata(dev);
 268         int ret;
 269
 270         ret = i2c_smbus_write_byte(sdata->client, S6SY761_SENSE_OFF);
 271         if (ret)
 272                 dev_err(&sdata->client->dev, "failed to turn off sensing\n");
 273 }
 274
 275 static ssize_t s6sy761_sysfs_devid(struct device *dev,
 276                                 struct device_attribute *attr, char *buf)
 277 {
 278         struct s6sy761_data *sdata = dev_get_drvdata(dev);
 279
 280         return sprintf(buf, "%#x\n", sdata->devid);
 281 }
 282
 283 static DEVICE_ATTR(devid, 0444, s6sy761_sysfs_devid, NULL);
 284
 285 static struct attribute *s6sy761_sysfs_attrs[] = {
 286         &dev_attr_devid.attr,
 287         NULL
 288 };
 289 ATTRIBUTE_GROUPS(s6sy761_sysfs);
 290
 291 static int s6sy761_power_on(struct s6sy761_data *sdata)
 292 {
 293         u8 buffer[S6SY761_EVENT_SIZE];
 294         u8 event;
 295         int ret;
 296
 297         ret = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators),
 298                                     sdata->regulators);
 299         if (ret)
 300                 return ret;
 301
 302         msleep(140);
 303
 304         /* double check whether the touch is functional */
 305         ret = i2c_smbus_read_i2c_block_data(sdata->client,
 306                                             S6SY761_READ_ONE_EVENT,
 307                                             S6SY761_EVENT_SIZE,
 308                                             buffer);
 309         if (ret < 0)
 310                 return ret;
 311
 312         event = (buffer[0] >> 2) & 0xf;
 313
 314         if ((event != S6SY761_EVENT_INFO &&
 315              event != S6SY761_EVENT_VENDOR_INFO) ||
 316             buffer[1] != S6SY761_INFO_BOOT_COMPLETE) {
 317                 return -ENODEV;
 318         }
 319
 320         ret = i2c_smbus_read_byte_data(sdata->client, S6SY761_BOOT_STATUS);
 321         if (ret < 0)
 322                 return ret;
 323
 324         /* for some reasons the device might be stuck in the bootloader */
 325         if (ret != S6SY761_BS_APPLICATION)
 326                 return -ENODEV;
 327
 328         /* enable touch functionality */
 329         ret = i2c_smbus_write_word_data(sdata->client,
 330                                         S6SY761_TOUCH_FUNCTION,
 331                                         S6SY761_MASK_TOUCH);
 332         if (ret)
 333                 return ret;
 334
 335         return 0;
 336 }
 337
 338 static int s6sy761_hw_init(struct s6sy761_data *sdata,
 339                            unsigned int *max_x, unsigned int *max_y)
 340 {
 341         u8 buffer[S6SY761_PANEL_ID_SIZE]; /* larger read size */
 342         int ret;
 343
 344         ret = s6sy761_power_on(sdata);
 345         if (ret)
 346                 return ret;
 347
 348         ret = i2c_smbus_read_i2c_block_data(sdata->client,
 349                                             S6SY761_DEVICE_ID,
 350                                             S6SY761_DEVID_SIZE,
 351                                             buffer);
 352         if (ret < 0)
 353                 return ret;
 354
 355         sdata->devid = get_unaligned_be16(buffer + 1);
 356
 357         ret = i2c_smbus_read_i2c_block_data(sdata->client,
 358                                             S6SY761_PANEL_INFO,
 359                                             S6SY761_PANEL_ID_SIZE,
 360                                             buffer);
 361         if (ret < 0)
 362                 return ret;
 363
 364         *max_x = get_unaligned_be16(buffer);
 365         *max_y = get_unaligned_be16(buffer + 2);
 366
 367         /* if no tx channels defined, at least keep one */
 368         sdata->tx_channel = max_t(u8, buffer[8], 1);
 369
 370         ret = i2c_smbus_read_byte_data(sdata->client,
 371                                        S6SY761_FIRMWARE_INTEGRITY);
 372         if (ret < 0)
 373                 return ret;
 374         else if (ret != S6SY761_FW_OK)
 375                 return -ENODEV;
 376
 377         return 0;
 378 }
 379
 380 static void s6sy761_power_off(void *data)
 381 {
 382         struct s6sy761_data *sdata = data;
 383
 384         disable_irq(sdata->client->irq);
 385         regulator_bulk_disable(ARRAY_SIZE(sdata->regulators),
 386                                                 sdata->regulators);
 387 }
 388
 389 static int s6sy761_probe(struct i2c_client *client)
 390 {
 391         struct s6sy761_data *sdata;
 392         unsigned int max_x, max_y;
 393         int err;
 394
 395         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
 396                                                 I2C_FUNC_SMBUS_BYTE_DATA |
 397                                                 I2C_FUNC_SMBUS_I2C_BLOCK))
 398                 return -ENODEV;
 399
 400         sdata = devm_kzalloc(&client->dev, sizeof(*sdata), GFP_KERNEL);
 401         if (!sdata)
 402                 return -ENOMEM;
 403
 404         i2c_set_clientdata(client, sdata);
 405         sdata->client = client;
 406
 407         sdata->regulators[S6SY761_REGULATOR_VDD].supply = "vdd";
 408         sdata->regulators[S6SY761_REGULATOR_AVDD].supply = "avdd";
 409         err = devm_regulator_bulk_get(&client->dev,
 410                                       ARRAY_SIZE(sdata->regulators),
 411                                       sdata->regulators);
 412         if (err)
 413                 return err;
 414
 415         err = devm_add_action_or_reset(&client->dev, s6sy761_power_off, sdata);
 416         if (err)
 417                 return err;
 418
 419         err = s6sy761_hw_init(sdata, &max_x, &max_y);
 420         if (err)
 421                 return err;
 422
 423         sdata->input = devm_input_allocate_device(&client->dev);
 424         if (!sdata->input)
 425                 return -ENOMEM;
 426
 427         sdata->input->name = S6SY761_DEV_NAME;
 428         sdata->input->id.bustype = BUS_I2C;
 429         sdata->input->open = s6sy761_input_open;
 430         sdata->input->close = s6sy761_input_close;
 431
 432         input_set_abs_params(sdata->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
 433         input_set_abs_params(sdata->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
 434         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 435         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
 436         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 437         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
 438         input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
 439
 440         touchscreen_parse_properties(sdata->input, true, &sdata->prop);
 441
 442         if (!input_abs_get_max(sdata->input, ABS_X) ||
 443             !input_abs_get_max(sdata->input, ABS_Y)) {
 444                 dev_warn(&client->dev, "the axis have not been set\n");
 445         }
 446
 447         err = input_mt_init_slots(sdata->input, sdata->tx_channel,
 448                                   INPUT_MT_DIRECT);
 449         if (err)
 450                 return err;
 451
 452         input_set_drvdata(sdata->input, sdata);
 453
 454         err = input_register_device(sdata->input);
 455         if (err)
 456                 return err;
 457
 458         err = devm_request_threaded_irq(&client->dev, client->irq, NULL,
 459                                         s6sy761_irq_handler,
 460                                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 461                                         "s6sy761_irq", sdata);
 462         if (err)
 463                 return err;
 464
 465         pm_runtime_enable(&client->dev);
 466
 467         return 0;
 468 }
 469
 470 static void s6sy761_remove(struct i2c_client *client)
 471 {
 472         pm_runtime_disable(&client->dev);
 473 }
 474
 475 static int s6sy761_runtime_suspend(struct device *dev)
 476 {
 477         struct s6sy761_data *sdata = dev_get_drvdata(dev);
 478
 479         return i2c_smbus_write_byte_data(sdata->client,
 480                                 S6SY761_APPLICATION_MODE, S6SY761_APP_SLEEP);
 481 }
 482
 483 static int s6sy761_runtime_resume(struct device *dev)
 484 {
 485         struct s6sy761_data *sdata = dev_get_drvdata(dev);
 486
 487         return i2c_smbus_write_byte_data(sdata->client,
 488                                 S6SY761_APPLICATION_MODE, S6SY761_APP_NORMAL);
 489 }
 490
 491 static int s6sy761_suspend(struct device *dev)
 492 {
 493         struct s6sy761_data *sdata = dev_get_drvdata(dev);
 494
 495         s6sy761_power_off(sdata);
 496
 497         return 0;
 498 }
 499
 500 static int s6sy761_resume(struct device *dev)
 501 {
 502         struct s6sy761_data *sdata = dev_get_drvdata(dev);
 503
 504         enable_irq(sdata->client->irq);
 505
 506         return s6sy761_power_on(sdata);
 507 }
 508
 509 static const struct dev_pm_ops s6sy761_pm_ops = {
 510         SYSTEM_SLEEP_PM_OPS(s6sy761_suspend, s6sy761_resume)
 511         RUNTIME_PM_OPS(s6sy761_runtime_suspend, s6sy761_runtime_resume, NULL)
 512 };
 513
 514 #ifdef CONFIG_OF
 515 static const struct of_device_id s6sy761_of_match[] = {
 516         { .compatible = "samsung,s6sy761", },
 517         { },
 518 };
 519 MODULE_DEVICE_TABLE(of, s6sy761_of_match);
 520 #endif
 521
 522 static const struct i2c_device_id s6sy761_id[] = {
 523         { "s6sy761" },
 524         { }
 525 };
 526 MODULE_DEVICE_TABLE(i2c, s6sy761_id);
 527
 528 static struct i2c_driver s6sy761_driver = {
 529         .driver = {
 530                 .name = S6SY761_DEV_NAME,
 531                 .dev_groups = s6sy761_sysfs_groups,
 532                 .of_match_table = of_match_ptr(s6sy761_of_match),
 533                 .pm = pm_ptr(&s6sy761_pm_ops),
 534         },
 535         .probe = s6sy761_probe,
 536         .remove = s6sy761_remove,
 537         .id_table = s6sy761_id,
 538 };
 539
 540 module_i2c_driver(s6sy761_driver);
 541
 542 MODULE_AUTHOR("Andi Shyti <andi.shyti@samsung.com>");
 543 MODULE_DESCRIPTION("Samsung S6SY761 Touch Screen");
 544 MODULE_LICENSE("GPL v2");