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 return error; 413 } 414 415 if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE || 416 IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) { 417 return -ENODEV; 418 } 419 420 error = cyttsp_set_sysinfo_mode(ts); 421 if (error) 422 return error; 423 424 error = cyttsp_set_sysinfo_regs(ts); 425 if (error) 426 return error; 427 428 error = cyttsp_set_operational_mode(ts); 429 if (error) 430 return error; 431 432 /* init active distance */ 433 error = cyttsp_act_dist_setup(ts); 434 if (error) 435 return error; 436 437 ts->state = CY_ACTIVE_STATE; 438 439 return 0; 440 } 441 442 static int cyttsp_enable(struct cyttsp *ts) 443 { 444 int error; 445 446 /* 447 * The device firmware can wake on an I2C or SPI memory slave 448 * address match. So just reading a register is sufficient to 449 * wake up the device. The first read attempt will fail but it 450 * will wake it up making the second read attempt successful. 451 */ 452 error = ttsp_read_block_data(ts, CY_REG_BASE, 453 sizeof(ts->xy_data), &ts->xy_data); 454 if (error) 455 return error; 456 457 if (GET_HSTMODE(ts->xy_data.hst_mode)) 458 return -EIO; 459 460 enable_irq(ts->irq); 461 462 return 0; 463 } 464 465 static int cyttsp_disable(struct cyttsp *ts) 466 { 467 int error; 468 469 error = ttsp_send_command(ts, CY_LOW_POWER_MODE); 470 if (error) 471 return error; 472 473 disable_irq(ts->irq); 474 475 return 0; 476 } 477 478 static int __maybe_unused cyttsp_suspend(struct device *dev) 479 { 480 struct cyttsp *ts = dev_get_drvdata(dev); 481 int retval = 0; 482 483 mutex_lock(&ts->input->mutex); 484 485 if (input_device_enabled(ts->input)) { 486 retval = cyttsp_disable(ts); 487 if (retval == 0) 488 ts->suspended = true; 489 } 490 491 mutex_unlock(&ts->input->mutex); 492 493 return retval; 494 } 495 496 static int __maybe_unused cyttsp_resume(struct device *dev) 497 { 498 struct cyttsp *ts = dev_get_drvdata(dev); 499 500 mutex_lock(&ts->input->mutex); 501 502 if (input_device_enabled(ts->input)) 503 cyttsp_enable(ts); 504 505 ts->suspended = false; 506 507 mutex_unlock(&ts->input->mutex); 508 509 return 0; 510 } 511 512 SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume); 513 EXPORT_SYMBOL_GPL(cyttsp_pm_ops); 514 515 static int cyttsp_open(struct input_dev *dev) 516 { 517 struct cyttsp *ts = input_get_drvdata(dev); 518 int retval = 0; 519 520 if (!ts->suspended) 521 retval = cyttsp_enable(ts); 522 523 return retval; 524 } 525 526 static void cyttsp_close(struct input_dev *dev) 527 { 528 struct cyttsp *ts = input_get_drvdata(dev); 529 530 if (!ts->suspended) 531 cyttsp_disable(ts); 532 } 533 534 static int cyttsp_parse_properties(struct cyttsp *ts) 535 { 536 struct device *dev = ts->dev; 537 u32 dt_value; 538 int ret; 539 540 ts->bl_keys = devm_kzalloc(dev, CY_NUM_BL_KEYS, GFP_KERNEL); 541 if (!ts->bl_keys) 542 return -ENOMEM; 543 544 /* Set some default values */ 545 ts->use_hndshk = false; 546 ts->act_dist = CY_ACT_DIST_DFLT; 547 ts->act_intrvl = CY_ACT_INTRVL_DFLT; 548 ts->tch_tmout = CY_TCH_TMOUT_DFLT; 549 ts->lp_intrvl = CY_LP_INTRVL_DFLT; 550 551 ret = device_property_read_u8_array(dev, "bootloader-key", 552 ts->bl_keys, CY_NUM_BL_KEYS); 553 if (ret) { 554 dev_err(dev, 555 "bootloader-key property could not be retrieved\n"); 556 return ret; 557 } 558 559 ts->use_hndshk = device_property_present(dev, "use-handshake"); 560 561 if (!device_property_read_u32(dev, "active-distance", &dt_value)) { 562 if (dt_value > 15) { 563 dev_err(dev, "active-distance (%u) must be [0-15]\n", 564 dt_value); 565 return -EINVAL; 566 } 567 ts->act_dist &= ~CY_ACT_DIST_MASK; 568 ts->act_dist |= dt_value; 569 } 570 571 if (!device_property_read_u32(dev, "active-interval-ms", &dt_value)) { 572 if (dt_value > 255) { 573 dev_err(dev, "active-interval-ms (%u) must be [0-255]\n", 574 dt_value); 575 return -EINVAL; 576 } 577 ts->act_intrvl = dt_value; 578 } 579 580 if (!device_property_read_u32(dev, "lowpower-interval-ms", &dt_value)) { 581 if (dt_value > 2550) { 582 dev_err(dev, "lowpower-interval-ms (%u) must be [0-2550]\n", 583 dt_value); 584 return -EINVAL; 585 } 586 /* Register value is expressed in 0.01s / bit */ 587 ts->lp_intrvl = dt_value / 10; 588 } 589 590 if (!device_property_read_u32(dev, "touch-timeout-ms", &dt_value)) { 591 if (dt_value > 2550) { 592 dev_err(dev, "touch-timeout-ms (%u) must be [0-2550]\n", 593 dt_value); 594 return -EINVAL; 595 } 596 /* Register value is expressed in 0.01s / bit */ 597 ts->tch_tmout = dt_value / 10; 598 } 599 600 return 0; 601 } 602 603 struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops, 604 struct device *dev, int irq, size_t xfer_buf_size) 605 { 606 struct cyttsp *ts; 607 struct input_dev *input_dev; 608 int error; 609 610 ts = devm_kzalloc(dev, sizeof(*ts) + xfer_buf_size, GFP_KERNEL); 611 if (!ts) 612 return ERR_PTR(-ENOMEM); 613 614 input_dev = devm_input_allocate_device(dev); 615 if (!input_dev) 616 return ERR_PTR(-ENOMEM); 617 618 ts->dev = dev; 619 ts->input = input_dev; 620 ts->bus_ops = bus_ops; 621 ts->irq = irq; 622 623 ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); 624 if (IS_ERR(ts->reset_gpio)) { 625 error = PTR_ERR(ts->reset_gpio); 626 dev_err(dev, "Failed to request reset gpio, error %d\n", error); 627 return ERR_PTR(error); 628 } 629 630 error = cyttsp_parse_properties(ts); 631 if (error) 632 return ERR_PTR(error); 633 634 init_completion(&ts->bl_ready); 635 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev)); 636 637 input_dev->name = "Cypress TTSP TouchScreen"; 638 input_dev->phys = ts->phys; 639 input_dev->id.bustype = bus_ops->bustype; 640 input_dev->dev.parent = ts->dev; 641 642 input_dev->open = cyttsp_open; 643 input_dev->close = cyttsp_close; 644 645 input_set_drvdata(input_dev, ts); 646 647 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X); 648 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y); 649 touchscreen_parse_properties(input_dev, true, NULL); 650 651 error = input_mt_init_slots(input_dev, CY_MAX_ID, 0); 652 if (error) { 653 dev_err(dev, "Unable to init MT slots.\n"); 654 return ERR_PTR(error); 655 } 656 657 error = devm_request_threaded_irq(dev, ts->irq, NULL, cyttsp_irq, 658 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 659 "cyttsp", ts); 660 if (error) { 661 dev_err(ts->dev, "failed to request IRQ %d, err: %d\n", 662 ts->irq, error); 663 return ERR_PTR(error); 664 } 665 666 disable_irq(ts->irq); 667 668 cyttsp_hard_reset(ts); 669 670 error = cyttsp_power_on(ts); 671 if (error) 672 return ERR_PTR(error); 673 674 error = input_register_device(input_dev); 675 if (error) { 676 dev_err(ts->dev, "failed to register input device: %d\n", 677 error); 678 return ERR_PTR(error); 679 } 680 681 return ts; 682 } 683 EXPORT_SYMBOL_GPL(cyttsp_probe); 684 685 MODULE_LICENSE("GPL"); 686 MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core"); 687 MODULE_AUTHOR("Cypress"); 688