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 { 444 struct hycon_hy46xx_data *tsdata; 445 struct input_dev *input; 446 int error; 447 448 dev_dbg(&client->dev, "probing for HYCON HY46XX I2C\n"); 449 450 tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL); 451 if (!tsdata) 452 return -ENOMEM; 453 454 tsdata->vcc = devm_regulator_get(&client->dev, "vcc"); 455 if (IS_ERR(tsdata->vcc)) { 456 error = PTR_ERR(tsdata->vcc); 457 if (error != -EPROBE_DEFER) 458 dev_err(&client->dev, 459 "failed to request regulator: %d\n", error); 460 return error; 461 } 462 463 error = regulator_enable(tsdata->vcc); 464 if (error < 0) { 465 dev_err(&client->dev, "failed to enable vcc: %d\n", error); 466 return error; 467 } 468 469 error = devm_add_action_or_reset(&client->dev, 470 hycon_hy46xx_disable_regulator, 471 tsdata); 472 if (error) 473 return error; 474 475 tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev, 476 "reset", GPIOD_OUT_LOW); 477 if (IS_ERR(tsdata->reset_gpio)) { 478 error = PTR_ERR(tsdata->reset_gpio); 479 dev_err(&client->dev, 480 "Failed to request GPIO reset pin, error %d\n", error); 481 return error; 482 } 483 484 if (tsdata->reset_gpio) { 485 usleep_range(5000, 6000); 486 gpiod_set_value_cansleep(tsdata->reset_gpio, 1); 487 usleep_range(5000, 6000); 488 gpiod_set_value_cansleep(tsdata->reset_gpio, 0); 489 msleep(1000); 490 } 491 492 input = devm_input_allocate_device(&client->dev); 493 if (!input) { 494 dev_err(&client->dev, "failed to allocate input device.\n"); 495 return -ENOMEM; 496 } 497 498 mutex_init(&tsdata->mutex); 499 tsdata->client = client; 500 tsdata->input = input; 501 502 tsdata->regmap = devm_regmap_init_i2c(client, 503 &hycon_hy46xx_i2c_regmap_config); 504 if (IS_ERR(tsdata->regmap)) { 505 dev_err(&client->dev, "regmap allocation failed\n"); 506 return PTR_ERR(tsdata->regmap); 507 } 508 509 hycon_hy46xx_get_defaults(&client->dev, tsdata); 510 hycon_hy46xx_get_parameters(tsdata); 511 512 input->name = "Hycon Capacitive Touch"; 513 input->id.bustype = BUS_I2C; 514 input->dev.parent = &client->dev; 515 516 input_set_abs_params(input, ABS_MT_POSITION_X, 0, -1, 0, 0); 517 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, -1, 0, 0); 518 519 touchscreen_parse_properties(input, true, &tsdata->prop); 520 521 error = input_mt_init_slots(input, HY46XX_MAX_SUPPORTED_POINTS, 522 INPUT_MT_DIRECT); 523 if (error) { 524 dev_err(&client->dev, "Unable to init MT slots.\n"); 525 return error; 526 } 527 528 i2c_set_clientdata(client, tsdata); 529 530 error = devm_request_threaded_irq(&client->dev, client->irq, 531 NULL, hycon_hy46xx_isr, IRQF_ONESHOT, 532 client->name, tsdata); 533 if (error) { 534 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n"); 535 return error; 536 } 537 538 error = devm_device_add_group(&client->dev, &hycon_hy46xx_attr_group); 539 if (error) 540 return error; 541 542 error = input_register_device(input); 543 if (error) 544 return error; 545 546 dev_dbg(&client->dev, 547 "HYCON HY46XX initialized: IRQ %d, Reset pin %d.\n", 548 client->irq, 549 tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1); 550 551 return 0; 552 } 553 554 static const struct i2c_device_id hycon_hy46xx_id[] = { 555 { .name = "hy4613" }, 556 { .name = "hy4614" }, 557 { .name = "hy4621" }, 558 { .name = "hy4623" }, 559 { .name = "hy4633" }, 560 { .name = "hy4635" }, 561 { /* sentinel */ } 562 }; 563 MODULE_DEVICE_TABLE(i2c, hycon_hy46xx_id); 564 565 static const struct of_device_id hycon_hy46xx_of_match[] = { 566 { .compatible = "hycon,hy4613" }, 567 { .compatible = "hycon,hy4614" }, 568 { .compatible = "hycon,hy4621" }, 569 { .compatible = "hycon,hy4623" }, 570 { .compatible = "hycon,hy4633" }, 571 { .compatible = "hycon,hy4635" }, 572 { /* sentinel */ } 573 }; 574 MODULE_DEVICE_TABLE(of, hycon_hy46xx_of_match); 575 576 static struct i2c_driver hycon_hy46xx_driver = { 577 .driver = { 578 .name = "hycon_hy46xx", 579 .of_match_table = hycon_hy46xx_of_match, 580 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 581 }, 582 .id_table = hycon_hy46xx_id, 583 .probe_new = hycon_hy46xx_probe, 584 }; 585 586 module_i2c_driver(hycon_hy46xx_driver); 587 588 MODULE_AUTHOR("Giulio Benetti <giulio.benetti@benettiengineering.com>"); 589 MODULE_DESCRIPTION("HYCON HY46XX I2C Touchscreen Driver"); 590 MODULE_LICENSE("GPL v2"); 591