drivers/input/touchscreen/hycon-hy46xx.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2021
   4  * Author(s): Giulio Benetti <giulio.benetti@benettiengineering.com>
   5  */
   6
   7 #include <linux/delay.h>
   8 #include <linux/gpio/consumer.h>
   9 #include <linux/i2c.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/input.h>
  12 #include <linux/input/mt.h>
  13 #include <linux/input/touchscreen.h>
  14 #include <linux/irq.h>
  15 #include <linux/regulator/consumer.h>
  16 #include <linux/regmap.h>
  17
  18 #include <asm/unaligned.h>
  19
  20 #define HY46XX_CHKSUM_CODE              0x1
  21 #define HY46XX_FINGER_NUM               0x2
  22 #define HY46XX_CHKSUM_LEN               0x7
  23 #define HY46XX_THRESHOLD                0x80
  24 #define HY46XX_GLOVE_EN                 0x84
  25 #define HY46XX_REPORT_SPEED             0x88
  26 #define HY46XX_PWR_NOISE_EN             0x89
  27 #define HY46XX_FILTER_DATA              0x8A
  28 #define HY46XX_GAIN                     0x92
  29 #define HY46XX_EDGE_OFFSET              0x93
  30 #define HY46XX_RX_NR_USED               0x94
  31 #define HY46XX_TX_NR_USED               0x95
  32 #define HY46XX_PWR_MODE                 0xA5
  33 #define HY46XX_FW_VERSION               0xA6
  34 #define HY46XX_LIB_VERSION              0xA7
  35 #define HY46XX_TP_INFO                  0xA8
  36 #define HY46XX_TP_CHIP_ID               0xA9
  37 #define HY46XX_BOOT_VER                 0xB0
  38
  39 #define HY46XX_TPLEN                    0x6
  40 #define HY46XX_REPORT_PKT_LEN           0x44
  41
  42 #define HY46XX_MAX_SUPPORTED_POINTS     11
  43
  44 #define TOUCH_EVENT_DOWN                0x00
  45 #define TOUCH_EVENT_UP                  0x01
  46 #define TOUCH_EVENT_CONTACT             0x02
  47 #define TOUCH_EVENT_RESERVED            0x03
  48
  49 struct hycon_hy46xx_data {
  50         struct i2c_client *client;
  51         struct input_dev *input;
  52         struct touchscreen_properties prop;
  53         struct regulator *vcc;
  54
  55         struct gpio_desc *reset_gpio;
  56
  57         struct mutex mutex;
  58         struct regmap *regmap;
  59
  60         int threshold;
  61         bool glove_enable;
  62         int report_speed;
  63         bool noise_filter_enable;
  64         int filter_data;
  65         int gain;
  66         int edge_offset;
  67         int rx_number_used;
  68         int tx_number_used;
  69         int power_mode;
  70         int fw_version;
  71         int lib_version;
  72         int tp_information;
  73         int tp_chip_id;
  74         int bootloader_version;
  75 };
  76
  77 static const struct regmap_config hycon_hy46xx_i2c_regmap_config = {
  78         .reg_bits = 8,
  79         .val_bits = 8,
  80 };
  81
  82 static bool hycon_hy46xx_check_checksum(struct hycon_hy46xx_data *tsdata, u8 *buf)
  83 {
  84         u8 chksum = 0;
  85         int i;
  86
  87         for (i = 2; i < buf[HY46XX_CHKSUM_LEN]; i++)
  88                 chksum += buf[i];
  89
  90         if (chksum == buf[HY46XX_CHKSUM_CODE])
  91                 return true;
  92
  93         dev_err_ratelimited(&tsdata->client->dev,
  94                             "checksum error: 0x%02x expected, got 0x%02x\n",
  95                             chksum, buf[HY46XX_CHKSUM_CODE]);
  96
  97         return false;
  98 }
  99
 100 static irqreturn_t hycon_hy46xx_isr(int irq, void *dev_id)
 101 {
 102         struct hycon_hy46xx_data *tsdata = dev_id;
 103         struct device *dev = &tsdata->client->dev;
 104         u8 rdbuf[HY46XX_REPORT_PKT_LEN];
 105         int i, x, y, id;
 106         int error;
 107
 108         memset(rdbuf, 0, sizeof(rdbuf));
 109
 110         error = regmap_bulk_read(tsdata->regmap, 0, rdbuf, sizeof(rdbuf));
 111         if (error) {
 112                 dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
 113                                     error);
 114                 goto out;
 115         }
 116
 117         if (!hycon_hy46xx_check_checksum(tsdata, rdbuf))
 118                 goto out;
 119
 120         for (i = 0; i < HY46XX_MAX_SUPPORTED_POINTS; i++) {
 121                 u8 *buf = &rdbuf[3 + (HY46XX_TPLEN * i)];
 122                 int type = buf[0] >> 6;
 123
 124                 if (type == TOUCH_EVENT_RESERVED)
 125                         continue;
 126
 127                 x = get_unaligned_be16(buf) & 0x0fff;
 128                 y = get_unaligned_be16(buf + 2) & 0x0fff;
 129
 130                 id = buf[2] >> 4;
 131
 132                 input_mt_slot(tsdata->input, id);
 133                 if (input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER,
 134                                                type != TOUCH_EVENT_UP))
 135                         touchscreen_report_pos(tsdata->input, &tsdata->prop,
 136                                                x, y, true);
 137         }
 138
 139         input_mt_report_pointer_emulation(tsdata->input, false);
 140         input_sync(tsdata->input);
 141
 142 out:
 143         return IRQ_HANDLED;
 144 }
 145
 146 struct hycon_hy46xx_attribute {
 147         struct device_attribute dattr;
 148         size_t field_offset;
 149         u8 address;
 150         u8 limit_low;
 151         u8 limit_high;
 152 };
 153
 154 #define HYCON_ATTR_U8(_field, _mode, _address, _limit_low, _limit_high) \
 155         struct hycon_hy46xx_attribute hycon_hy46xx_attr_##_field = {            \
 156                 .dattr = __ATTR(_field, _mode,                          \
 157                                 hycon_hy46xx_setting_show,                      \
 158                                 hycon_hy46xx_setting_store),                    \
 159                 .field_offset = offsetof(struct hycon_hy46xx_data, _field),     \
 160                 .address = _address,                                    \
 161                 .limit_low = _limit_low,                                \
 162                 .limit_high = _limit_high,                              \
 163         }
 164
 165 #define HYCON_ATTR_BOOL(_field, _mode, _address)                        \
 166         struct hycon_hy46xx_attribute hycon_hy46xx_attr_##_field = {            \
 167                 .dattr = __ATTR(_field, _mode,                          \
 168                                 hycon_hy46xx_setting_show,                      \
 169                                 hycon_hy46xx_setting_store),                    \
 170                 .field_offset = offsetof(struct hycon_hy46xx_data, _field),     \
 171                 .address = _address,                                    \
 172                 .limit_low = false,                                     \
 173                 .limit_high = true,                                     \
 174         }
 175
 176 static ssize_t hycon_hy46xx_setting_show(struct device *dev,
 177                                    struct device_attribute *dattr, char *buf)
 178 {
 179         struct i2c_client *client = to_i2c_client(dev);
 180         struct hycon_hy46xx_data *tsdata = i2c_get_clientdata(client);
 181         struct hycon_hy46xx_attribute *attr =
 182                         container_of(dattr, struct hycon_hy46xx_attribute, dattr);
 183         u8 *field = (u8 *)tsdata + attr->field_offset;
 184         size_t count = 0;
 185         int error = 0;
 186         int val;
 187
 188         mutex_lock(&tsdata->mutex);
 189
 190         error = regmap_read(tsdata->regmap, attr->address, &val);
 191         if (error < 0) {
 192                 dev_err(&tsdata->client->dev,
 193                         "Failed to fetch attribute %s, error %d\n",
 194                         dattr->attr.name, error);
 195                 goto out;
 196         }
 197
 198         if (val != *field) {
 199                 dev_warn(&tsdata->client->dev,
 200                          "%s: read (%d) and stored value (%d) differ\n",
 201                          dattr->attr.name, val, *field);
 202                 *field = val;
 203         }
 204
 205         count = scnprintf(buf, PAGE_SIZE, "%d\n", val);
 206
 207 out:
 208         mutex_unlock(&tsdata->mutex);
 209         return error ?: count;
 210 }
 211
 212 static ssize_t hycon_hy46xx_setting_store(struct device *dev,
 213                                         struct device_attribute *dattr,
 214                                         const char *buf, size_t count)
 215 {
 216         struct i2c_client *client = to_i2c_client(dev);
 217         struct hycon_hy46xx_data *tsdata = i2c_get_clientdata(client);
 218         struct hycon_hy46xx_attribute *attr =
 219                         container_of(dattr, struct hycon_hy46xx_attribute, dattr);
 220         u8 *field = (u8 *)tsdata + attr->field_offset;
 221         unsigned int val;
 222         int error;
 223
 224         mutex_lock(&tsdata->mutex);
 225
 226         error = kstrtouint(buf, 0, &val);
 227         if (error)
 228                 goto out;
 229
 230         if (val < attr->limit_low || val > attr->limit_high) {
 231                 error = -ERANGE;
 232                 goto out;
 233         }
 234
 235         error = regmap_write(tsdata->regmap, attr->address, val);
 236         if (error < 0) {
 237                 dev_err(&tsdata->client->dev,
 238                         "Failed to update attribute %s, error: %d\n",
 239                         dattr->attr.name, error);
 240                 goto out;
 241         }
 242         *field = val;
 243
 244 out:
 245         mutex_unlock(&tsdata->mutex);
 246         return error ?: count;
 247 }
 248
 249 static HYCON_ATTR_U8(threshold, 0644, HY46XX_THRESHOLD, 0, 255);
 250 static HYCON_ATTR_BOOL(glove_enable, 0644, HY46XX_GLOVE_EN);
 251 static HYCON_ATTR_U8(report_speed, 0644, HY46XX_REPORT_SPEED, 0, 255);
 252 static HYCON_ATTR_BOOL(noise_filter_enable, 0644, HY46XX_PWR_NOISE_EN);
 253 static HYCON_ATTR_U8(filter_data, 0644, HY46XX_FILTER_DATA, 0, 5);
 254 static HYCON_ATTR_U8(gain, 0644, HY46XX_GAIN, 0, 5);
 255 static HYCON_ATTR_U8(edge_offset, 0644, HY46XX_EDGE_OFFSET, 0, 5);
 256 static HYCON_ATTR_U8(fw_version, 0444, HY46XX_FW_VERSION, 0, 255);
 257 static HYCON_ATTR_U8(lib_version, 0444, HY46XX_LIB_VERSION, 0, 255);
 258 static HYCON_ATTR_U8(tp_information, 0444, HY46XX_TP_INFO, 0, 255);
 259 static HYCON_ATTR_U8(tp_chip_id, 0444, HY46XX_TP_CHIP_ID, 0, 255);
 260 static HYCON_ATTR_U8(bootloader_version, 0444, HY46XX_BOOT_VER, 0, 255);
 261
 262 static struct attribute *hycon_hy46xx_attrs[] = {
 263         &hycon_hy46xx_attr_threshold.dattr.attr,
 264         &hycon_hy46xx_attr_glove_enable.dattr.attr,
 265         &hycon_hy46xx_attr_report_speed.dattr.attr,
 266         &hycon_hy46xx_attr_noise_filter_enable.dattr.attr,
 267         &hycon_hy46xx_attr_filter_data.dattr.attr,
 268         &hycon_hy46xx_attr_gain.dattr.attr,
 269         &hycon_hy46xx_attr_edge_offset.dattr.attr,
 270         &hycon_hy46xx_attr_fw_version.dattr.attr,
 271         &hycon_hy46xx_attr_lib_version.dattr.attr,
 272         &hycon_hy46xx_attr_tp_information.dattr.attr,
 273         &hycon_hy46xx_attr_tp_chip_id.dattr.attr,
 274         &hycon_hy46xx_attr_bootloader_version.dattr.attr,
 275         NULL
 276 };
 277
 278 static const struct attribute_group hycon_hy46xx_attr_group = {
 279         .attrs = hycon_hy46xx_attrs,
 280 };
 281
 282 static void hycon_hy46xx_get_defaults(struct device *dev, struct hycon_hy46xx_data *tsdata)
 283 {
 284         bool val_bool;
 285         int error;
 286         u32 val;
 287
 288         error = device_property_read_u32(dev, "hycon,threshold", &val);
 289         if (!error) {
 290                 error = regmap_write(tsdata->regmap, HY46XX_THRESHOLD, val);
 291                 if (error < 0)
 292                         goto out;
 293
 294                 tsdata->threshold = val;
 295         }
 296
 297         val_bool = device_property_read_bool(dev, "hycon,glove-enable");
 298         error = regmap_write(tsdata->regmap, HY46XX_GLOVE_EN, val_bool);
 299         if (error < 0)
 300                 goto out;
 301         tsdata->glove_enable = val_bool;
 302
 303         error = device_property_read_u32(dev, "hycon,report-speed-hz", &val);
 304         if (!error) {
 305                 error = regmap_write(tsdata->regmap, HY46XX_REPORT_SPEED, val);
 306                 if (error < 0)
 307                         goto out;
 308
 309                 tsdata->report_speed = val;
 310         }
 311
 312         val_bool = device_property_read_bool(dev, "hycon,noise-filter-enable");
 313         error = regmap_write(tsdata->regmap, HY46XX_PWR_NOISE_EN, val_bool);
 314         if (error < 0)
 315                 goto out;
 316         tsdata->noise_filter_enable = val_bool;
 317
 318         error = device_property_read_u32(dev, "hycon,filter-data", &val);
 319         if (!error) {
 320                 error = regmap_write(tsdata->regmap, HY46XX_FILTER_DATA, val);
 321                 if (error < 0)
 322                         goto out;
 323
 324                 tsdata->filter_data = val;
 325         }
 326
 327         error = device_property_read_u32(dev, "hycon,gain", &val);
 328         if (!error) {
 329                 error = regmap_write(tsdata->regmap, HY46XX_GAIN, val);
 330                 if (error < 0)
 331                         goto out;
 332
 333                 tsdata->gain = val;
 334         }
 335
 336         error = device_property_read_u32(dev, "hycon,edge-offset", &val);
 337         if (!error) {
 338                 error = regmap_write(tsdata->regmap, HY46XX_EDGE_OFFSET, val);
 339                 if (error < 0)
 340                         goto out;
 341
 342                 tsdata->edge_offset = val;
 343         }
 344
 345         return;
 346 out:
 347         dev_err(&tsdata->client->dev, "Failed to set default settings");
 348 }
 349
 350 static void hycon_hy46xx_get_parameters(struct hycon_hy46xx_data *tsdata)
 351 {
 352         int error;
 353         u32 val;
 354
 355         error = regmap_read(tsdata->regmap, HY46XX_THRESHOLD, &val);
 356         if (error < 0)
 357                 goto out;
 358         tsdata->threshold = val;
 359
 360         error = regmap_read(tsdata->regmap, HY46XX_GLOVE_EN, &val);
 361         if (error < 0)
 362                 goto out;
 363         tsdata->glove_enable = val;
 364
 365         error = regmap_read(tsdata->regmap, HY46XX_REPORT_SPEED, &val);
 366         if (error < 0)
 367                 goto out;
 368         tsdata->report_speed = val;
 369
 370         error = regmap_read(tsdata->regmap, HY46XX_PWR_NOISE_EN, &val);
 371         if (error < 0)
 372                 goto out;
 373         tsdata->noise_filter_enable = val;
 374
 375         error = regmap_read(tsdata->regmap, HY46XX_FILTER_DATA, &val);
 376         if (error < 0)
 377                 goto out;
 378         tsdata->filter_data = val;
 379
 380         error = regmap_read(tsdata->regmap, HY46XX_GAIN, &val);
 381         if (error < 0)
 382                 goto out;
 383         tsdata->gain = val;
 384
 385         error = regmap_read(tsdata->regmap, HY46XX_EDGE_OFFSET, &val);
 386         if (error < 0)
 387                 goto out;
 388         tsdata->edge_offset = val;
 389
 390         error = regmap_read(tsdata->regmap, HY46XX_RX_NR_USED, &val);
 391         if (error < 0)
 392                 goto out;
 393         tsdata->rx_number_used = val;
 394
 395         error = regmap_read(tsdata->regmap, HY46XX_TX_NR_USED, &val);
 396         if (error < 0)
 397                 goto out;
 398         tsdata->tx_number_used = val;
 399
 400         error = regmap_read(tsdata->regmap, HY46XX_PWR_MODE, &val);
 401         if (error < 0)
 402                 goto out;
 403         tsdata->power_mode = val;
 404
 405         error = regmap_read(tsdata->regmap, HY46XX_FW_VERSION, &val);
 406         if (error < 0)
 407                 goto out;
 408         tsdata->fw_version = val;
 409
 410         error = regmap_read(tsdata->regmap, HY46XX_LIB_VERSION, &val);
 411         if (error < 0)
 412                 goto out;
 413         tsdata->lib_version = val;
 414
 415         error = regmap_read(tsdata->regmap, HY46XX_TP_INFO, &val);
 416         if (error < 0)
 417                 goto out;
 418         tsdata->tp_information = val;
 419
 420         error = regmap_read(tsdata->regmap, HY46XX_TP_CHIP_ID, &val);
 421         if (error < 0)
 422                 goto out;
 423         tsdata->tp_chip_id = val;
 424
 425         error = regmap_read(tsdata->regmap, HY46XX_BOOT_VER, &val);
 426         if (error < 0)
 427                 goto out;
 428         tsdata->bootloader_version = val;
 429
 430         return;
 431 out:
 432         dev_err(&tsdata->client->dev, "Failed to read default settings");
 433 }
 434
 435 static void hycon_hy46xx_disable_regulator(void *arg)
 436 {
 437         struct hycon_hy46xx_data *data = arg;
 438
 439         regulator_disable(data->vcc);
 440 }
 441
 442 static int hycon_hy46xx_probe(struct i2c_client *client,
 443                                          const struct i2c_device_id *id)
 444 {
 445         struct hycon_hy46xx_data *tsdata;
 446         struct input_dev *input;
 447         int error;
 448
 449         dev_dbg(&client->dev, "probing for HYCON HY46XX I2C\n");
 450
 451         tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL);
 452         if (!tsdata)
 453                 return -ENOMEM;
 454
 455         tsdata->vcc = devm_regulator_get(&client->dev, "vcc");
 456         if (IS_ERR(tsdata->vcc)) {
 457                 error = PTR_ERR(tsdata->vcc);
 458                 if (error != -EPROBE_DEFER)
 459                         dev_err(&client->dev,
 460                                 "failed to request regulator: %d\n", error);
 461                 return error;
 462         }
 463
 464         error = regulator_enable(tsdata->vcc);
 465         if (error < 0) {
 466                 dev_err(&client->dev, "failed to enable vcc: %d\n", error);
 467                 return error;
 468         }
 469
 470         error = devm_add_action_or_reset(&client->dev,
 471                                          hycon_hy46xx_disable_regulator,
 472                                          tsdata);
 473         if (error)
 474                 return error;
 475
 476         tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
 477                                                      "reset", GPIOD_OUT_LOW);
 478         if (IS_ERR(tsdata->reset_gpio)) {
 479                 error = PTR_ERR(tsdata->reset_gpio);
 480                 dev_err(&client->dev,
 481                         "Failed to request GPIO reset pin, error %d\n", error);
 482                 return error;
 483         }
 484
 485         if (tsdata->reset_gpio) {
 486                 usleep_range(5000, 6000);
 487                 gpiod_set_value_cansleep(tsdata->reset_gpio, 1);
 488                 usleep_range(5000, 6000);
 489                 gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
 490                 msleep(1000);
 491         }
 492
 493         input = devm_input_allocate_device(&client->dev);
 494         if (!input) {
 495                 dev_err(&client->dev, "failed to allocate input device.\n");
 496                 return -ENOMEM;
 497         }
 498
 499         mutex_init(&tsdata->mutex);
 500         tsdata->client = client;
 501         tsdata->input = input;
 502
 503         tsdata->regmap = devm_regmap_init_i2c(client,
 504                                               &hycon_hy46xx_i2c_regmap_config);
 505         if (IS_ERR(tsdata->regmap)) {
 506                 dev_err(&client->dev, "regmap allocation failed\n");
 507                 return PTR_ERR(tsdata->regmap);
 508         }
 509
 510         hycon_hy46xx_get_defaults(&client->dev, tsdata);
 511         hycon_hy46xx_get_parameters(tsdata);
 512
 513         input->name = "Hycon Capacitive Touch";
 514         input->id.bustype = BUS_I2C;
 515         input->dev.parent = &client->dev;
 516
 517         input_set_abs_params(input, ABS_MT_POSITION_X, 0, -1, 0, 0);
 518         input_set_abs_params(input, ABS_MT_POSITION_Y, 0, -1, 0, 0);
 519
 520         touchscreen_parse_properties(input, true, &tsdata->prop);
 521
 522         error = input_mt_init_slots(input, HY46XX_MAX_SUPPORTED_POINTS,
 523                                     INPUT_MT_DIRECT);
 524         if (error) {
 525                 dev_err(&client->dev, "Unable to init MT slots.\n");
 526                 return error;
 527         }
 528
 529         i2c_set_clientdata(client, tsdata);
 530
 531         error = devm_request_threaded_irq(&client->dev, client->irq,
 532                                           NULL, hycon_hy46xx_isr, IRQF_ONESHOT,
 533                                           client->name, tsdata);
 534         if (error) {
 535                 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
 536                 return error;
 537         }
 538
 539         error = devm_device_add_group(&client->dev, &hycon_hy46xx_attr_group);
 540         if (error)
 541                 return error;
 542
 543         error = input_register_device(input);
 544         if (error)
 545                 return error;
 546
 547         dev_dbg(&client->dev,
 548                 "HYCON HY46XX initialized: IRQ %d, Reset pin %d.\n",
 549                 client->irq,
 550                 tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);
 551
 552         return 0;
 553 }
 554
 555 static const struct i2c_device_id hycon_hy46xx_id[] = {
 556         { .name = "hy4613" },
 557         { .name = "hy4614" },
 558         { .name = "hy4621" },
 559         { .name = "hy4623" },
 560         { .name = "hy4633" },
 561         { .name = "hy4635" },
 562         { /* sentinel */ }
 563 };
 564 MODULE_DEVICE_TABLE(i2c, hycon_hy46xx_id);
 565
 566 static const struct of_device_id hycon_hy46xx_of_match[] = {
 567         { .compatible = "hycon,hy4613" },
 568         { .compatible = "hycon,hy4614" },
 569         { .compatible = "hycon,hy4621" },
 570         { .compatible = "hycon,hy4623" },
 571         { .compatible = "hycon,hy4633" },
 572         { .compatible = "hycon,hy4635" },
 573         { /* sentinel */ }
 574 };
 575 MODULE_DEVICE_TABLE(of, hycon_hy46xx_of_match);
 576
 577 static struct i2c_driver hycon_hy46xx_driver = {
 578         .driver = {
 579                 .name = "hycon_hy46xx",
 580                 .of_match_table = hycon_hy46xx_of_match,
 581                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 582         },
 583         .id_table = hycon_hy46xx_id,
 584         .probe    = hycon_hy46xx_probe,
 585 };
 586
 587 module_i2c_driver(hycon_hy46xx_driver);
 588
 589 MODULE_AUTHOR("Giulio Benetti <giulio.benetti@benettiengineering.com>");
 590 MODULE_DESCRIPTION("HYCON HY46XX I2C Touchscreen Driver");
 591 MODULE_LICENSE("GPL v2");