drivers/input/touchscreen/cyttsp_core.c

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