1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Core Source for: 4 * Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers. 5 * For use with Cypress Txx3xx parts. 6 * Supported parts include: 7 * CY8CTST341 8 * CY8CTMA340 9 * 10 * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc. 11 * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org> 12 * 13 * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com> 14 */ 15 16 #include <linux/delay.h> 17 #include <linux/input.h> 18 #include <linux/input/mt.h> 19 #include <linux/input/touchscreen.h> 20 #include <linux/gpio.h> 21 #include <linux/interrupt.h> 22 #include <linux/slab.h> 23 #include <linux/property.h> 24 #include <linux/gpio/consumer.h> 25 26 #include "cyttsp_core.h" 27 28 /* Bootloader number of command keys */ 29 #define CY_NUM_BL_KEYS 8 30 31 /* helpers */ 32 #define GET_NUM_TOUCHES(x) ((x) & 0x0F) 33 #define IS_LARGE_AREA(x) (((x) & 0x10) >> 4) 34 #define IS_BAD_PKT(x) ((x) & 0x20) 35 #define IS_VALID_APP(x) ((x) & 0x01) 36 #define IS_OPERATIONAL_ERR(x) ((x) & 0x3F) 37 #define GET_HSTMODE(reg) (((reg) & 0x70) >> 4) 38 #define GET_BOOTLOADERMODE(reg) (((reg) & 0x10) >> 4) 39 40 #define CY_REG_BASE 0x00 41 #define CY_REG_ACT_DIST 0x1E 42 #define CY_REG_ACT_INTRVL 0x1D 43 #define CY_REG_TCH_TMOUT (CY_REG_ACT_INTRVL + 1) 44 #define CY_REG_LP_INTRVL (CY_REG_TCH_TMOUT + 1) 45 #define CY_MAXZ 255 46 #define CY_DELAY_DFLT 20 /* ms */ 47 #define CY_DELAY_MAX 500 48 #define CY_ACT_DIST_DFLT 0xF8 49 #define CY_ACT_DIST_MASK 0x0F 50 #define CY_HNDSHK_BIT 0x80 51 /* device mode bits */ 52 #define CY_OPERATE_MODE 0x00 53 #define CY_SYSINFO_MODE 0x10 54 /* power mode select bits */ 55 #define CY_SOFT_RESET_MODE 0x01 /* return to Bootloader mode */ 56 #define CY_DEEP_SLEEP_MODE 0x02 57 #define CY_LOW_POWER_MODE 0x04 58 59 /* Slots management */ 60 #define CY_MAX_FINGER 4 61 #define CY_MAX_ID 16 62 63 static const u8 bl_command[] = { 64 0x00, /* file offset */ 65 0xFF, /* command */ 66 0xA5, /* exit bootloader command */ 67 0, 1, 2, 3, 4, 5, 6, 7 /* default keys */ 68 }; 69 70 static int ttsp_read_block_data(struct cyttsp *ts, u8 command, 71 u8 length, void *buf) 72 { 73 int error; 74 int tries; 75 76 for (tries = 0; tries < CY_NUM_RETRY; tries++) { 77 error = ts->bus_ops->read(ts->dev, ts->xfer_buf, command, 78 length, buf); 79 if (!error) 80 return 0; 81 82 msleep(CY_DELAY_DFLT); 83 } 84 85 return -EIO; 86 } 87 88 static int ttsp_write_block_data(struct cyttsp *ts, u8 command, 89 u8 length, void *buf) 90 { 91 int error; 92 int tries; 93 94 for (tries = 0; tries < CY_NUM_RETRY; tries++) { 95 error = ts->bus_ops->write(ts->dev, ts->xfer_buf, command, 96 length, buf); 97 if (!error) 98 return 0; 99 100 msleep(CY_DELAY_DFLT); 101 } 102 103 return -EIO; 104 } 105 106 static int ttsp_send_command(struct cyttsp *ts, u8 cmd) 107 { 108 return ttsp_write_block_data(ts, CY_REG_BASE, sizeof(cmd), &cmd); 109 } 110 111 static int cyttsp_handshake(struct cyttsp *ts) 112 { 113 if (ts->use_hndshk) 114 return ttsp_send_command(ts, 115 ts->xy_data.hst_mode ^ CY_HNDSHK_BIT); 116 117 return 0; 118 } 119 120 static int cyttsp_load_bl_regs(struct cyttsp *ts) 121 { 122 memset(&ts->bl_data, 0, sizeof(ts->bl_data)); 123 ts->bl_data.bl_status = 0x10; 124 125 return ttsp_read_block_data(ts, CY_REG_BASE, 126 sizeof(ts->bl_data), &ts->bl_data); 127 } 128 129 static int cyttsp_exit_bl_mode(struct cyttsp *ts) 130 { 131 int error; 132 u8 bl_cmd[sizeof(bl_command)]; 133 134 memcpy(bl_cmd, bl_command, sizeof(bl_command)); 135 if (ts->bl_keys) 136 memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS], 137 ts->bl_keys, CY_NUM_BL_KEYS); 138 139 error = ttsp_write_block_data(ts, CY_REG_BASE, 140 sizeof(bl_cmd), bl_cmd); 141 if (error) 142 return error; 143 144 /* wait for TTSP Device to complete the operation */ 145 msleep(CY_DELAY_DFLT); 146 147 error = cyttsp_load_bl_regs(ts); 148 if (error) 149 return error; 150 151 if (GET_BOOTLOADERMODE(ts->bl_data.bl_status)) 152 return -EIO; 153 154 return 0; 155 } 156 157 static int cyttsp_set_operational_mode(struct cyttsp *ts) 158 { 159 int error; 160 161 error = ttsp_send_command(ts, CY_OPERATE_MODE); 162 if (error) 163 return error; 164 165 /* wait for TTSP Device to complete switch to Operational mode */ 166 error = ttsp_read_block_data(ts, CY_REG_BASE, 167 sizeof(ts->xy_data), &ts->xy_data); 168 if (error) 169 return error; 170 171 error = cyttsp_handshake(ts); 172 if (error) 173 return error; 174 175 return ts->xy_data.act_dist == CY_ACT_DIST_DFLT ? -EIO : 0; 176 } 177 178 static int cyttsp_set_sysinfo_mode(struct cyttsp *ts) 179 { 180 int error; 181 182 memset(&ts->sysinfo_data, 0, sizeof(ts->sysinfo_data)); 183 184 /* switch to sysinfo mode */ 185 error = ttsp_send_command(ts, CY_SYSINFO_MODE); 186 if (error) 187 return error; 188 189 /* read sysinfo registers */ 190 msleep(CY_DELAY_DFLT); 191 error = ttsp_read_block_data(ts, CY_REG_BASE, sizeof(ts->sysinfo_data), 192 &ts->sysinfo_data); 193 if (error) 194 return error; 195 196 error = cyttsp_handshake(ts); 197 if (error) 198 return error; 199 200 if (!ts->sysinfo_data.tts_verh && !ts->sysinfo_data.tts_verl) 201 return -EIO; 202 203 return 0; 204 } 205 206 static int cyttsp_set_sysinfo_regs(struct cyttsp *ts) 207 { 208 int retval = 0; 209 210 if (ts->act_intrvl != CY_ACT_INTRVL_DFLT || 211 ts->tch_tmout != CY_TCH_TMOUT_DFLT || 212 ts->lp_intrvl != CY_LP_INTRVL_DFLT) { 213 214 u8 intrvl_ray[] = { 215 ts->act_intrvl, 216 ts->tch_tmout, 217 ts->lp_intrvl 218 }; 219 220 /* set intrvl registers */ 221 retval = ttsp_write_block_data(ts, CY_REG_ACT_INTRVL, 222 sizeof(intrvl_ray), intrvl_ray); 223 msleep(CY_DELAY_DFLT); 224 } 225 226 return retval; 227 } 228 229 static void cyttsp_hard_reset(struct cyttsp *ts) 230 { 231 if (ts->reset_gpio) { 232 gpiod_set_value_cansleep(ts->reset_gpio, 1); 233 msleep(CY_DELAY_DFLT); 234 gpiod_set_value_cansleep(ts->reset_gpio, 0); 235 msleep(CY_DELAY_DFLT); 236 } 237 } 238 239 static int cyttsp_soft_reset(struct cyttsp *ts) 240 { 241 int retval; 242 243 /* wait for interrupt to set ready completion */ 244 reinit_completion(&ts->bl_ready); 245 ts->state = CY_BL_STATE; 246 247 enable_irq(ts->irq); 248 249 retval = ttsp_send_command(ts, CY_SOFT_RESET_MODE); 250 if (retval) { 251 dev_err(ts->dev, "failed to send soft reset\n"); 252 goto out; 253 } 254 255 if (!wait_for_completion_timeout(&ts->bl_ready, 256 msecs_to_jiffies(CY_DELAY_DFLT * CY_DELAY_MAX))) { 257 dev_err(ts->dev, "timeout waiting for soft reset\n"); 258 retval = -EIO; 259 } 260 261 out: 262 ts->state = CY_IDLE_STATE; 263 disable_irq(ts->irq); 264 return retval; 265 } 266 267 static int cyttsp_act_dist_setup(struct cyttsp *ts) 268 { 269 u8 act_dist_setup = ts->act_dist; 270 271 /* Init gesture; active distance setup */ 272 return ttsp_write_block_data(ts, CY_REG_ACT_DIST, 273 sizeof(act_dist_setup), &act_dist_setup); 274 } 275 276 static void cyttsp_extract_track_ids(struct cyttsp_xydata *xy_data, int *ids) 277 { 278 ids[0] = xy_data->touch12_id >> 4; 279 ids[1] = xy_data->touch12_id & 0xF; 280 ids[2] = xy_data->touch34_id >> 4; 281 ids[3] = xy_data->touch34_id & 0xF; 282 } 283 284 static const struct cyttsp_tch *cyttsp_get_tch(struct cyttsp_xydata *xy_data, 285 int idx) 286 { 287 switch (idx) { 288 case 0: 289 return &xy_data->tch1; 290 case 1: 291 return &xy_data->tch2; 292 case 2: 293 return &xy_data->tch3; 294 case 3: 295 return &xy_data->tch4; 296 default: 297 return NULL; 298 } 299 } 300 301 static void cyttsp_report_tchdata(struct cyttsp *ts) 302 { 303 struct cyttsp_xydata *xy_data = &ts->xy_data; 304 struct input_dev *input = ts->input; 305 int num_tch = GET_NUM_TOUCHES(xy_data->tt_stat); 306 const struct cyttsp_tch *tch; 307 int ids[CY_MAX_ID]; 308 int i; 309 DECLARE_BITMAP(used, CY_MAX_ID); 310 311 if (IS_LARGE_AREA(xy_data->tt_stat) == 1) { 312 /* terminate all active tracks */ 313 num_tch = 0; 314 dev_dbg(ts->dev, "%s: Large area detected\n", __func__); 315 } else if (num_tch > CY_MAX_FINGER) { 316 /* terminate all active tracks */ 317 num_tch = 0; 318 dev_dbg(ts->dev, "%s: Num touch error detected\n", __func__); 319 } else if (IS_BAD_PKT(xy_data->tt_mode)) { 320 /* terminate all active tracks */ 321 num_tch = 0; 322 dev_dbg(ts->dev, "%s: Invalid buffer detected\n", __func__); 323 } 324 325 cyttsp_extract_track_ids(xy_data, ids); 326 327 bitmap_zero(used, CY_MAX_ID); 328 329 for (i = 0; i < num_tch; i++) { 330 tch = cyttsp_get_tch(xy_data, i); 331 332 input_mt_slot(input, ids[i]); 333 input_mt_report_slot_state(input, MT_TOOL_FINGER, true); 334 input_report_abs(input, ABS_MT_POSITION_X, be16_to_cpu(tch->x)); 335 input_report_abs(input, ABS_MT_POSITION_Y, be16_to_cpu(tch->y)); 336 input_report_abs(input, ABS_MT_TOUCH_MAJOR, tch->z); 337 338 __set_bit(ids[i], used); 339 } 340 341 for (i = 0; i < CY_MAX_ID; i++) { 342 if (test_bit(i, used)) 343 continue; 344 345 input_mt_slot(input, i); 346 input_mt_report_slot_inactive(input); 347 } 348 349 input_sync(input); 350 } 351 352 static irqreturn_t cyttsp_irq(int irq, void *handle) 353 { 354 struct cyttsp *ts = handle; 355 int error; 356 357 if (unlikely(ts->state == CY_BL_STATE)) { 358 complete(&ts->bl_ready); 359 goto out; 360 } 361 362 /* Get touch data from CYTTSP device */ 363 error = ttsp_read_block_data(ts, CY_REG_BASE, 364 sizeof(struct cyttsp_xydata), &ts->xy_data); 365 if (error) 366 goto out; 367 368 /* provide flow control handshake */ 369 error = cyttsp_handshake(ts); 370 if (error) 371 goto out; 372 373 if (unlikely(ts->state == CY_IDLE_STATE)) 374 goto out; 375 376 if (GET_BOOTLOADERMODE(ts->xy_data.tt_mode)) { 377 /* 378 * TTSP device has reset back to bootloader mode. 379 * Restore to operational mode. 380 */ 381 error = cyttsp_exit_bl_mode(ts); 382 if (error) { 383 dev_err(ts->dev, 384 "Could not return to operational mode, err: %d\n", 385 error); 386 ts->state = CY_IDLE_STATE; 387 } 388 } else { 389 cyttsp_report_tchdata(ts); 390 } 391 392 out: 393 return IRQ_HANDLED; 394 } 395 396 static int cyttsp_power_on(struct cyttsp *ts) 397 { 398 int error; 399 400 error = cyttsp_soft_reset(ts); 401 if (error) 402 return error; 403 404 error = cyttsp_load_bl_regs(ts); 405 if (error) 406 return error; 407 408 if (GET_BOOTLOADERMODE(ts->bl_data.bl_status) && 409 IS_VALID_APP(ts->bl_data.bl_status)) { 410 error = cyttsp_exit_bl_mode(ts); 411 if (error) { 412 dev_err(ts->dev, "failed to exit bootloader mode\n"); 413 return error; 414 } 415 } 416 417 if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE || 418 IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) { 419 return -ENODEV; 420 } 421 422 error = cyttsp_set_sysinfo_mode(ts); 423 if (error) 424 return error; 425 426 error = cyttsp_set_sysinfo_regs(ts); 427 if (error) 428 return error; 429 430 error = cyttsp_set_operational_mode(ts); 431 if (error) 432 return error; 433 434 /* init active distance */ 435 error = cyttsp_act_dist_setup(ts); 436 if (error) 437 return error; 438 439 ts->state = CY_ACTIVE_STATE; 440 441 return 0; 442 } 443 444 static int cyttsp_enable(struct cyttsp *ts) 445 { 446 int error; 447 448 /* 449 * The device firmware can wake on an I2C or SPI memory slave 450 * address match. So just reading a register is sufficient to 451 * wake up the device. The first read attempt will fail but it 452 * will wake it up making the second read attempt successful. 453 */ 454 error = ttsp_read_block_data(ts, CY_REG_BASE, 455 sizeof(ts->xy_data), &ts->xy_data); 456 if (error) 457 return error; 458 459 if (GET_HSTMODE(ts->xy_data.hst_mode)) 460 return -EIO; 461 462 enable_irq(ts->irq); 463 464 return 0; 465 } 466 467 static int cyttsp_disable(struct cyttsp *ts) 468 { 469 int error; 470 471 error = ttsp_send_command(ts, CY_LOW_POWER_MODE); 472 if (error) 473 return error; 474 475 disable_irq(ts->irq); 476 477 return 0; 478 } 479 480 static int __maybe_unused cyttsp_suspend(struct device *dev) 481 { 482 struct cyttsp *ts = dev_get_drvdata(dev); 483 int retval = 0; 484 485 mutex_lock(&ts->input->mutex); 486 487 if (input_device_enabled(ts->input)) { 488 retval = cyttsp_disable(ts); 489 if (retval == 0) 490 ts->suspended = true; 491 } 492 493 mutex_unlock(&ts->input->mutex); 494 495 return retval; 496 } 497 498 static int __maybe_unused cyttsp_resume(struct device *dev) 499 { 500 struct cyttsp *ts = dev_get_drvdata(dev); 501 502 mutex_lock(&ts->input->mutex); 503 504 if (input_device_enabled(ts->input)) 505 cyttsp_enable(ts); 506 507 ts->suspended = false; 508 509 mutex_unlock(&ts->input->mutex); 510 511 return 0; 512 } 513 514 SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume); 515 EXPORT_SYMBOL_GPL(cyttsp_pm_ops); 516 517 static int cyttsp_open(struct input_dev *dev) 518 { 519 struct cyttsp *ts = input_get_drvdata(dev); 520 int retval = 0; 521 522 if (!ts->suspended) 523 retval = cyttsp_enable(ts); 524 525 return retval; 526 } 527 528 static void cyttsp_close(struct input_dev *dev) 529 { 530 struct cyttsp *ts = input_get_drvdata(dev); 531 532 if (!ts->suspended) 533 cyttsp_disable(ts); 534 } 535 536 static int cyttsp_parse_properties(struct cyttsp *ts) 537 { 538 struct device *dev = ts->dev; 539 u32 dt_value; 540 int ret; 541 542 ts->bl_keys = devm_kzalloc(dev, CY_NUM_BL_KEYS, GFP_KERNEL); 543 if (!ts->bl_keys) 544 return -ENOMEM; 545 546 /* Set some default values */ 547 ts->use_hndshk = false; 548 ts->act_dist = CY_ACT_DIST_DFLT; 549 ts->act_intrvl = CY_ACT_INTRVL_DFLT; 550 ts->tch_tmout = CY_TCH_TMOUT_DFLT; 551 ts->lp_intrvl = CY_LP_INTRVL_DFLT; 552 553 ret = device_property_read_u8_array(dev, "bootloader-key", 554 ts->bl_keys, CY_NUM_BL_KEYS); 555 if (ret) { 556 dev_err(dev, 557 "bootloader-key property could not be retrieved\n"); 558 return ret; 559 } 560 561 ts->use_hndshk = device_property_present(dev, "use-handshake"); 562 563 if (!device_property_read_u32(dev, "active-distance", &dt_value)) { 564 if (dt_value > 15) { 565 dev_err(dev, "active-distance (%u) must be [0-15]\n", 566 dt_value); 567 return -EINVAL; 568 } 569 ts->act_dist &= ~CY_ACT_DIST_MASK; 570 ts->act_dist |= dt_value; 571 } 572 573 if (!device_property_read_u32(dev, "active-interval-ms", &dt_value)) { 574 if (dt_value > 255) { 575 dev_err(dev, "active-interval-ms (%u) must be [0-255]\n", 576 dt_value); 577 return -EINVAL; 578 } 579 ts->act_intrvl = dt_value; 580 } 581 582 if (!device_property_read_u32(dev, "lowpower-interval-ms", &dt_value)) { 583 if (dt_value > 2550) { 584 dev_err(dev, "lowpower-interval-ms (%u) must be [0-2550]\n", 585 dt_value); 586 return -EINVAL; 587 } 588 /* Register value is expressed in 0.01s / bit */ 589 ts->lp_intrvl = dt_value / 10; 590 } 591 592 if (!device_property_read_u32(dev, "touch-timeout-ms", &dt_value)) { 593 if (dt_value > 2550) { 594 dev_err(dev, "touch-timeout-ms (%u) must be [0-2550]\n", 595 dt_value); 596 return -EINVAL; 597 } 598 /* Register value is expressed in 0.01s / bit */ 599 ts->tch_tmout = dt_value / 10; 600 } 601 602 return 0; 603 } 604 605 struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops, 606 struct device *dev, int irq, size_t xfer_buf_size) 607 { 608 struct cyttsp *ts; 609 struct input_dev *input_dev; 610 int error; 611 612 ts = devm_kzalloc(dev, sizeof(*ts) + xfer_buf_size, GFP_KERNEL); 613 if (!ts) 614 return ERR_PTR(-ENOMEM); 615 616 input_dev = devm_input_allocate_device(dev); 617 if (!input_dev) 618 return ERR_PTR(-ENOMEM); 619 620 ts->dev = dev; 621 ts->input = input_dev; 622 ts->bus_ops = bus_ops; 623 ts->irq = irq; 624 625 ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 626 if (IS_ERR(ts->reset_gpio)) { 627 error = PTR_ERR(ts->reset_gpio); 628 dev_err(dev, "Failed to request reset gpio, error %d\n", error); 629 return ERR_PTR(error); 630 } 631 632 error = cyttsp_parse_properties(ts); 633 if (error) 634 return ERR_PTR(error); 635 636 init_completion(&ts->bl_ready); 637 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev)); 638 639 input_dev->name = "Cypress TTSP TouchScreen"; 640 input_dev->phys = ts->phys; 641 input_dev->id.bustype = bus_ops->bustype; 642 input_dev->dev.parent = ts->dev; 643 644 input_dev->open = cyttsp_open; 645 input_dev->close = cyttsp_close; 646 647 input_set_drvdata(input_dev, ts); 648 649 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X); 650 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y); 651 touchscreen_parse_properties(input_dev, true, NULL); 652 653 error = input_mt_init_slots(input_dev, CY_MAX_ID, 0); 654 if (error) { 655 dev_err(dev, "Unable to init MT slots.\n"); 656 return ERR_PTR(error); 657 } 658 659 error = devm_request_threaded_irq(dev, ts->irq, NULL, cyttsp_irq, 660 IRQF_TRIGGER_FALLING | IRQF_ONESHOT | 661 IRQF_NO_AUTOEN, 662 "cyttsp", ts); 663 if (error) { 664 dev_err(ts->dev, "failed to request IRQ %d, err: %d\n", 665 ts->irq, error); 666 return ERR_PTR(error); 667 } 668 669 cyttsp_hard_reset(ts); 670 671 error = cyttsp_power_on(ts); 672 if (error) 673 return ERR_PTR(error); 674 675 error = input_register_device(input_dev); 676 if (error) { 677 dev_err(ts->dev, "failed to register input device: %d\n", 678 error); 679 return ERR_PTR(error); 680 } 681 682 return ts; 683 } 684 EXPORT_SYMBOL_GPL(cyttsp_probe); 685 686 MODULE_LICENSE("GPL"); 687 MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core"); 688 MODULE_AUTHOR("Cypress"); 689