linux/drivers/input/touchscreen/edt-ft5x06.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (C) 2012 Simon Budig, <simon.budig@kernelconcepts.de>
   4 * Daniel Wagener <daniel.wagener@kernelconcepts.de> (M09 firmware support)
   5 * Lothar WaƟmann <LW@KARO-electronics.de> (DT support)
   6 */
   7
   8/*
   9 * This is a driver for the EDT "Polytouch" family of touch controllers
  10 * based on the FocalTech FT5x06 line of chips.
  11 *
  12 * Development of this driver has been sponsored by Glyn:
  13 *    http://www.glyn.com/Products/Displays
  14 */
  15
  16#include <linux/debugfs.h>
  17#include <linux/delay.h>
  18#include <linux/gpio/consumer.h>
  19#include <linux/i2c.h>
  20#include <linux/interrupt.h>
  21#include <linux/input.h>
  22#include <linux/input/mt.h>
  23#include <linux/input/touchscreen.h>
  24#include <linux/irq.h>
  25#include <linux/kernel.h>
  26#include <linux/module.h>
  27#include <linux/ratelimit.h>
  28#include <linux/regulator/consumer.h>
  29#include <linux/slab.h>
  30#include <linux/uaccess.h>
  31
  32#include <asm/unaligned.h>
  33
  34#define WORK_REGISTER_THRESHOLD         0x00
  35#define WORK_REGISTER_REPORT_RATE       0x08
  36#define WORK_REGISTER_GAIN              0x30
  37#define WORK_REGISTER_OFFSET            0x31
  38#define WORK_REGISTER_NUM_X             0x33
  39#define WORK_REGISTER_NUM_Y             0x34
  40
  41#define PMOD_REGISTER_ACTIVE            0x00
  42#define PMOD_REGISTER_HIBERNATE         0x03
  43
  44#define M09_REGISTER_THRESHOLD          0x80
  45#define M09_REGISTER_GAIN               0x92
  46#define M09_REGISTER_OFFSET             0x93
  47#define M09_REGISTER_NUM_X              0x94
  48#define M09_REGISTER_NUM_Y              0x95
  49
  50#define EV_REGISTER_THRESHOLD           0x40
  51#define EV_REGISTER_GAIN                0x41
  52#define EV_REGISTER_OFFSET_Y            0x45
  53#define EV_REGISTER_OFFSET_X            0x46
  54
  55#define NO_REGISTER                     0xff
  56
  57#define WORK_REGISTER_OPMODE            0x3c
  58#define FACTORY_REGISTER_OPMODE         0x01
  59#define PMOD_REGISTER_OPMODE            0xa5
  60
  61#define TOUCH_EVENT_DOWN                0x00
  62#define TOUCH_EVENT_UP                  0x01
  63#define TOUCH_EVENT_ON                  0x02
  64#define TOUCH_EVENT_RESERVED            0x03
  65
  66#define EDT_NAME_LEN                    23
  67#define EDT_SWITCH_MODE_RETRIES         10
  68#define EDT_SWITCH_MODE_DELAY           5 /* msec */
  69#define EDT_RAW_DATA_RETRIES            100
  70#define EDT_RAW_DATA_DELAY              1000 /* usec */
  71
  72#define EDT_DEFAULT_NUM_X               1024
  73#define EDT_DEFAULT_NUM_Y               1024
  74
  75enum edt_pmode {
  76        EDT_PMODE_NOT_SUPPORTED,
  77        EDT_PMODE_HIBERNATE,
  78        EDT_PMODE_POWEROFF,
  79};
  80
  81enum edt_ver {
  82        EDT_M06,
  83        EDT_M09,
  84        EDT_M12,
  85        EV_FT,
  86        GENERIC_FT,
  87};
  88
  89struct edt_reg_addr {
  90        int reg_threshold;
  91        int reg_report_rate;
  92        int reg_gain;
  93        int reg_offset;
  94        int reg_offset_x;
  95        int reg_offset_y;
  96        int reg_num_x;
  97        int reg_num_y;
  98};
  99
 100struct edt_ft5x06_ts_data {
 101        struct i2c_client *client;
 102        struct input_dev *input;
 103        struct touchscreen_properties prop;
 104        u16 num_x;
 105        u16 num_y;
 106        struct regulator *vcc;
 107        struct regulator *iovcc;
 108
 109        struct gpio_desc *reset_gpio;
 110        struct gpio_desc *wake_gpio;
 111
 112#if defined(CONFIG_DEBUG_FS)
 113        struct dentry *debug_dir;
 114        u8 *raw_buffer;
 115        size_t raw_bufsize;
 116#endif
 117
 118        struct mutex mutex;
 119        bool factory_mode;
 120        enum edt_pmode suspend_mode;
 121        int threshold;
 122        int gain;
 123        int offset;
 124        int offset_x;
 125        int offset_y;
 126        int report_rate;
 127        int max_support_points;
 128
 129        char name[EDT_NAME_LEN];
 130
 131        struct edt_reg_addr reg_addr;
 132        enum edt_ver version;
 133};
 134
 135struct edt_i2c_chip_data {
 136        int  max_support_points;
 137};
 138
 139static int edt_ft5x06_ts_readwrite(struct i2c_client *client,
 140                                   u16 wr_len, u8 *wr_buf,
 141                                   u16 rd_len, u8 *rd_buf)
 142{
 143        struct i2c_msg wrmsg[2];
 144        int i = 0;
 145        int ret;
 146
 147        if (wr_len) {
 148                wrmsg[i].addr  = client->addr;
 149                wrmsg[i].flags = 0;
 150                wrmsg[i].len = wr_len;
 151                wrmsg[i].buf = wr_buf;
 152                i++;
 153        }
 154        if (rd_len) {
 155                wrmsg[i].addr  = client->addr;
 156                wrmsg[i].flags = I2C_M_RD;
 157                wrmsg[i].len = rd_len;
 158                wrmsg[i].buf = rd_buf;
 159                i++;
 160        }
 161
 162        ret = i2c_transfer(client->adapter, wrmsg, i);
 163        if (ret < 0)
 164                return ret;
 165        if (ret != i)
 166                return -EIO;
 167
 168        return 0;
 169}
 170
 171static bool edt_ft5x06_ts_check_crc(struct edt_ft5x06_ts_data *tsdata,
 172                                    u8 *buf, int buflen)
 173{
 174        int i;
 175        u8 crc = 0;
 176
 177        for (i = 0; i < buflen - 1; i++)
 178                crc ^= buf[i];
 179
 180        if (crc != buf[buflen-1]) {
 181                dev_err_ratelimited(&tsdata->client->dev,
 182                                    "crc error: 0x%02x expected, got 0x%02x\n",
 183                                    crc, buf[buflen-1]);
 184                return false;
 185        }
 186
 187        return true;
 188}
 189
 190static irqreturn_t edt_ft5x06_ts_isr(int irq, void *dev_id)
 191{
 192        struct edt_ft5x06_ts_data *tsdata = dev_id;
 193        struct device *dev = &tsdata->client->dev;
 194        u8 cmd;
 195        u8 rdbuf[63];
 196        int i, type, x, y, id;
 197        int offset, tplen, datalen, crclen;
 198        int error;
 199
 200        switch (tsdata->version) {
 201        case EDT_M06:
 202                cmd = 0xf9; /* tell the controller to send touch data */
 203                offset = 5; /* where the actual touch data starts */
 204                tplen = 4;  /* data comes in so called frames */
 205                crclen = 1; /* length of the crc data */
 206                break;
 207
 208        case EDT_M09:
 209        case EDT_M12:
 210        case EV_FT:
 211        case GENERIC_FT:
 212                cmd = 0x0;
 213                offset = 3;
 214                tplen = 6;
 215                crclen = 0;
 216                break;
 217
 218        default:
 219                goto out;
 220        }
 221
 222        memset(rdbuf, 0, sizeof(rdbuf));
 223        datalen = tplen * tsdata->max_support_points + offset + crclen;
 224
 225        error = edt_ft5x06_ts_readwrite(tsdata->client,
 226                                        sizeof(cmd), &cmd,
 227                                        datalen, rdbuf);
 228        if (error) {
 229                dev_err_ratelimited(dev, "Unable to fetch data, error: %d\n",
 230                                    error);
 231                goto out;
 232        }
 233
 234        /* M09/M12 does not send header or CRC */
 235        if (tsdata->version == EDT_M06) {
 236                if (rdbuf[0] != 0xaa || rdbuf[1] != 0xaa ||
 237                        rdbuf[2] != datalen) {
 238                        dev_err_ratelimited(dev,
 239                                        "Unexpected header: %02x%02x%02x!\n",
 240                                        rdbuf[0], rdbuf[1], rdbuf[2]);
 241                        goto out;
 242                }
 243
 244                if (!edt_ft5x06_ts_check_crc(tsdata, rdbuf, datalen))
 245                        goto out;
 246        }
 247
 248        for (i = 0; i < tsdata->max_support_points; i++) {
 249                u8 *buf = &rdbuf[i * tplen + offset];
 250
 251                type = buf[0] >> 6;
 252                /* ignore Reserved events */
 253                if (type == TOUCH_EVENT_RESERVED)
 254                        continue;
 255
 256                /* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
 257                if (tsdata->version == EDT_M06 && type == TOUCH_EVENT_DOWN)
 258                        continue;
 259
 260                x = get_unaligned_be16(buf) & 0x0fff;
 261                y = get_unaligned_be16(buf + 2) & 0x0fff;
 262                /* The FT5x26 send the y coordinate first */
 263                if (tsdata->version == EV_FT)
 264                        swap(x, y);
 265
 266                id = (buf[2] >> 4) & 0x0f;
 267
 268                input_mt_slot(tsdata->input, id);
 269                if (input_mt_report_slot_state(tsdata->input, MT_TOOL_FINGER,
 270                                               type != TOUCH_EVENT_UP))
 271                        touchscreen_report_pos(tsdata->input, &tsdata->prop,
 272                                               x, y, true);
 273        }
 274
 275        input_mt_report_pointer_emulation(tsdata->input, true);
 276        input_sync(tsdata->input);
 277
 278out:
 279        return IRQ_HANDLED;
 280}
 281
 282static int edt_ft5x06_register_write(struct edt_ft5x06_ts_data *tsdata,
 283                                     u8 addr, u8 value)
 284{
 285        u8 wrbuf[4];
 286
 287        switch (tsdata->version) {
 288        case EDT_M06:
 289                wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
 290                wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
 291                wrbuf[2] = value;
 292                wrbuf[3] = wrbuf[0] ^ wrbuf[1] ^ wrbuf[2];
 293                return edt_ft5x06_ts_readwrite(tsdata->client, 4,
 294                                        wrbuf, 0, NULL);
 295
 296        case EDT_M09:
 297        case EDT_M12:
 298        case EV_FT:
 299        case GENERIC_FT:
 300                wrbuf[0] = addr;
 301                wrbuf[1] = value;
 302
 303                return edt_ft5x06_ts_readwrite(tsdata->client, 2,
 304                                        wrbuf, 0, NULL);
 305
 306        default:
 307                return -EINVAL;
 308        }
 309}
 310
 311static int edt_ft5x06_register_read(struct edt_ft5x06_ts_data *tsdata,
 312                                    u8 addr)
 313{
 314        u8 wrbuf[2], rdbuf[2];
 315        int error;
 316
 317        switch (tsdata->version) {
 318        case EDT_M06:
 319                wrbuf[0] = tsdata->factory_mode ? 0xf3 : 0xfc;
 320                wrbuf[1] = tsdata->factory_mode ? addr & 0x7f : addr & 0x3f;
 321                wrbuf[1] |= tsdata->factory_mode ? 0x80 : 0x40;
 322
 323                error = edt_ft5x06_ts_readwrite(tsdata->client, 2, wrbuf, 2,
 324                                                rdbuf);
 325                if (error)
 326                        return error;
 327
 328                if ((wrbuf[0] ^ wrbuf[1] ^ rdbuf[0]) != rdbuf[1]) {
 329                        dev_err(&tsdata->client->dev,
 330                                "crc error: 0x%02x expected, got 0x%02x\n",
 331                                wrbuf[0] ^ wrbuf[1] ^ rdbuf[0],
 332                                rdbuf[1]);
 333                        return -EIO;
 334                }
 335                break;
 336
 337        case EDT_M09:
 338        case EDT_M12:
 339        case EV_FT:
 340        case GENERIC_FT:
 341                wrbuf[0] = addr;
 342                error = edt_ft5x06_ts_readwrite(tsdata->client, 1,
 343                                                wrbuf, 1, rdbuf);
 344                if (error)
 345                        return error;
 346                break;
 347
 348        default:
 349                return -EINVAL;
 350        }
 351
 352        return rdbuf[0];
 353}
 354
 355struct edt_ft5x06_attribute {
 356        struct device_attribute dattr;
 357        size_t field_offset;
 358        u8 limit_low;
 359        u8 limit_high;
 360        u8 addr_m06;
 361        u8 addr_m09;
 362        u8 addr_ev;
 363};
 364
 365#define EDT_ATTR(_field, _mode, _addr_m06, _addr_m09, _addr_ev,         \
 366                _limit_low, _limit_high)                                \
 367        struct edt_ft5x06_attribute edt_ft5x06_attr_##_field = {        \
 368                .dattr = __ATTR(_field, _mode,                          \
 369                                edt_ft5x06_setting_show,                \
 370                                edt_ft5x06_setting_store),              \
 371                .field_offset = offsetof(struct edt_ft5x06_ts_data, _field), \
 372                .addr_m06 = _addr_m06,                                  \
 373                .addr_m09 = _addr_m09,                                  \
 374                .addr_ev  = _addr_ev,                                   \
 375                .limit_low = _limit_low,                                \
 376                .limit_high = _limit_high,                              \
 377        }
 378
 379static ssize_t edt_ft5x06_setting_show(struct device *dev,
 380                                       struct device_attribute *dattr,
 381                                       char *buf)
 382{
 383        struct i2c_client *client = to_i2c_client(dev);
 384        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
 385        struct edt_ft5x06_attribute *attr =
 386                        container_of(dattr, struct edt_ft5x06_attribute, dattr);
 387        u8 *field = (u8 *)tsdata + attr->field_offset;
 388        int val;
 389        size_t count = 0;
 390        int error = 0;
 391        u8 addr;
 392
 393        mutex_lock(&tsdata->mutex);
 394
 395        if (tsdata->factory_mode) {
 396                error = -EIO;
 397                goto out;
 398        }
 399
 400        switch (tsdata->version) {
 401        case EDT_M06:
 402                addr = attr->addr_m06;
 403                break;
 404
 405        case EDT_M09:
 406        case EDT_M12:
 407        case GENERIC_FT:
 408                addr = attr->addr_m09;
 409                break;
 410
 411        case EV_FT:
 412                addr = attr->addr_ev;
 413                break;
 414
 415        default:
 416                error = -ENODEV;
 417                goto out;
 418        }
 419
 420        if (addr != NO_REGISTER) {
 421                val = edt_ft5x06_register_read(tsdata, addr);
 422                if (val < 0) {
 423                        error = val;
 424                        dev_err(&tsdata->client->dev,
 425                                "Failed to fetch attribute %s, error %d\n",
 426                                dattr->attr.name, error);
 427                        goto out;
 428                }
 429        } else {
 430                val = *field;
 431        }
 432
 433        if (val != *field) {
 434                dev_warn(&tsdata->client->dev,
 435                         "%s: read (%d) and stored value (%d) differ\n",
 436                         dattr->attr.name, val, *field);
 437                *field = val;
 438        }
 439
 440        count = scnprintf(buf, PAGE_SIZE, "%d\n", val);
 441out:
 442        mutex_unlock(&tsdata->mutex);
 443        return error ?: count;
 444}
 445
 446static ssize_t edt_ft5x06_setting_store(struct device *dev,
 447                                        struct device_attribute *dattr,
 448                                        const char *buf, size_t count)
 449{
 450        struct i2c_client *client = to_i2c_client(dev);
 451        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
 452        struct edt_ft5x06_attribute *attr =
 453                        container_of(dattr, struct edt_ft5x06_attribute, dattr);
 454        u8 *field = (u8 *)tsdata + attr->field_offset;
 455        unsigned int val;
 456        int error;
 457        u8 addr;
 458
 459        mutex_lock(&tsdata->mutex);
 460
 461        if (tsdata->factory_mode) {
 462                error = -EIO;
 463                goto out;
 464        }
 465
 466        error = kstrtouint(buf, 0, &val);
 467        if (error)
 468                goto out;
 469
 470        if (val < attr->limit_low || val > attr->limit_high) {
 471                error = -ERANGE;
 472                goto out;
 473        }
 474
 475        switch (tsdata->version) {
 476        case EDT_M06:
 477                addr = attr->addr_m06;
 478                break;
 479
 480        case EDT_M09:
 481        case EDT_M12:
 482        case GENERIC_FT:
 483                addr = attr->addr_m09;
 484                break;
 485
 486        case EV_FT:
 487                addr = attr->addr_ev;
 488                break;
 489
 490        default:
 491                error = -ENODEV;
 492                goto out;
 493        }
 494
 495        if (addr != NO_REGISTER) {
 496                error = edt_ft5x06_register_write(tsdata, addr, val);
 497                if (error) {
 498                        dev_err(&tsdata->client->dev,
 499                                "Failed to update attribute %s, error: %d\n",
 500                                dattr->attr.name, error);
 501                        goto out;
 502                }
 503        }
 504        *field = val;
 505
 506out:
 507        mutex_unlock(&tsdata->mutex);
 508        return error ?: count;
 509}
 510
 511/* m06, m09: range 0-31, m12: range 0-5 */
 512static EDT_ATTR(gain, S_IWUSR | S_IRUGO, WORK_REGISTER_GAIN,
 513                M09_REGISTER_GAIN, EV_REGISTER_GAIN, 0, 31);
 514/* m06, m09: range 0-31, m12: range 0-16 */
 515static EDT_ATTR(offset, S_IWUSR | S_IRUGO, WORK_REGISTER_OFFSET,
 516                M09_REGISTER_OFFSET, NO_REGISTER, 0, 31);
 517/* m06, m09, m12: no supported, ev_ft: range 0-80 */
 518static EDT_ATTR(offset_x, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
 519                EV_REGISTER_OFFSET_X, 0, 80);
 520/* m06, m09, m12: no supported, ev_ft: range 0-80 */
 521static EDT_ATTR(offset_y, S_IWUSR | S_IRUGO, NO_REGISTER, NO_REGISTER,
 522                EV_REGISTER_OFFSET_Y, 0, 80);
 523/* m06: range 20 to 80, m09: range 0 to 30, m12: range 1 to 255... */
 524static EDT_ATTR(threshold, S_IWUSR | S_IRUGO, WORK_REGISTER_THRESHOLD,
 525                M09_REGISTER_THRESHOLD, EV_REGISTER_THRESHOLD, 0, 255);
 526/* m06: range 3 to 14, m12: (0x64: 100Hz) */
 527static EDT_ATTR(report_rate, S_IWUSR | S_IRUGO, WORK_REGISTER_REPORT_RATE,
 528                NO_REGISTER, NO_REGISTER, 0, 255);
 529
 530static struct attribute *edt_ft5x06_attrs[] = {
 531        &edt_ft5x06_attr_gain.dattr.attr,
 532        &edt_ft5x06_attr_offset.dattr.attr,
 533        &edt_ft5x06_attr_offset_x.dattr.attr,
 534        &edt_ft5x06_attr_offset_y.dattr.attr,
 535        &edt_ft5x06_attr_threshold.dattr.attr,
 536        &edt_ft5x06_attr_report_rate.dattr.attr,
 537        NULL
 538};
 539
 540static const struct attribute_group edt_ft5x06_attr_group = {
 541        .attrs = edt_ft5x06_attrs,
 542};
 543
 544static void edt_ft5x06_restore_reg_parameters(struct edt_ft5x06_ts_data *tsdata)
 545{
 546        struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
 547
 548        edt_ft5x06_register_write(tsdata, reg_addr->reg_threshold,
 549                                  tsdata->threshold);
 550        edt_ft5x06_register_write(tsdata, reg_addr->reg_gain,
 551                                  tsdata->gain);
 552        if (reg_addr->reg_offset != NO_REGISTER)
 553                edt_ft5x06_register_write(tsdata, reg_addr->reg_offset,
 554                                          tsdata->offset);
 555        if (reg_addr->reg_offset_x != NO_REGISTER)
 556                edt_ft5x06_register_write(tsdata, reg_addr->reg_offset_x,
 557                                          tsdata->offset_x);
 558        if (reg_addr->reg_offset_y != NO_REGISTER)
 559                edt_ft5x06_register_write(tsdata, reg_addr->reg_offset_y,
 560                                          tsdata->offset_y);
 561        if (reg_addr->reg_report_rate != NO_REGISTER)
 562                edt_ft5x06_register_write(tsdata, reg_addr->reg_report_rate,
 563                                  tsdata->report_rate);
 564
 565}
 566
 567#ifdef CONFIG_DEBUG_FS
 568static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
 569{
 570        struct i2c_client *client = tsdata->client;
 571        int retries = EDT_SWITCH_MODE_RETRIES;
 572        int ret;
 573        int error;
 574
 575        if (tsdata->version != EDT_M06) {
 576                dev_err(&client->dev,
 577                        "No factory mode support for non-M06 devices\n");
 578                return -EINVAL;
 579        }
 580
 581        disable_irq(client->irq);
 582
 583        if (!tsdata->raw_buffer) {
 584                tsdata->raw_bufsize = tsdata->num_x * tsdata->num_y *
 585                                      sizeof(u16);
 586                tsdata->raw_buffer = kzalloc(tsdata->raw_bufsize, GFP_KERNEL);
 587                if (!tsdata->raw_buffer) {
 588                        error = -ENOMEM;
 589                        goto err_out;
 590                }
 591        }
 592
 593        /* mode register is 0x3c when in the work mode */
 594        error = edt_ft5x06_register_write(tsdata, WORK_REGISTER_OPMODE, 0x03);
 595        if (error) {
 596                dev_err(&client->dev,
 597                        "failed to switch to factory mode, error %d\n", error);
 598                goto err_out;
 599        }
 600
 601        tsdata->factory_mode = true;
 602        do {
 603                mdelay(EDT_SWITCH_MODE_DELAY);
 604                /* mode register is 0x01 when in factory mode */
 605                ret = edt_ft5x06_register_read(tsdata, FACTORY_REGISTER_OPMODE);
 606                if (ret == 0x03)
 607                        break;
 608        } while (--retries > 0);
 609
 610        if (retries == 0) {
 611                dev_err(&client->dev, "not in factory mode after %dms.\n",
 612                        EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
 613                error = -EIO;
 614                goto err_out;
 615        }
 616
 617        return 0;
 618
 619err_out:
 620        kfree(tsdata->raw_buffer);
 621        tsdata->raw_buffer = NULL;
 622        tsdata->factory_mode = false;
 623        enable_irq(client->irq);
 624
 625        return error;
 626}
 627
 628static int edt_ft5x06_work_mode(struct edt_ft5x06_ts_data *tsdata)
 629{
 630        struct i2c_client *client = tsdata->client;
 631        int retries = EDT_SWITCH_MODE_RETRIES;
 632        int ret;
 633        int error;
 634
 635        /* mode register is 0x01 when in the factory mode */
 636        error = edt_ft5x06_register_write(tsdata, FACTORY_REGISTER_OPMODE, 0x1);
 637        if (error) {
 638                dev_err(&client->dev,
 639                        "failed to switch to work mode, error: %d\n", error);
 640                return error;
 641        }
 642
 643        tsdata->factory_mode = false;
 644
 645        do {
 646                mdelay(EDT_SWITCH_MODE_DELAY);
 647                /* mode register is 0x01 when in factory mode */
 648                ret = edt_ft5x06_register_read(tsdata, WORK_REGISTER_OPMODE);
 649                if (ret == 0x01)
 650                        break;
 651        } while (--retries > 0);
 652
 653        if (retries == 0) {
 654                dev_err(&client->dev, "not in work mode after %dms.\n",
 655                        EDT_SWITCH_MODE_RETRIES * EDT_SWITCH_MODE_DELAY);
 656                tsdata->factory_mode = true;
 657                return -EIO;
 658        }
 659
 660        kfree(tsdata->raw_buffer);
 661        tsdata->raw_buffer = NULL;
 662
 663        edt_ft5x06_restore_reg_parameters(tsdata);
 664        enable_irq(client->irq);
 665
 666        return 0;
 667}
 668
 669static int edt_ft5x06_debugfs_mode_get(void *data, u64 *mode)
 670{
 671        struct edt_ft5x06_ts_data *tsdata = data;
 672
 673        *mode = tsdata->factory_mode;
 674
 675        return 0;
 676};
 677
 678static int edt_ft5x06_debugfs_mode_set(void *data, u64 mode)
 679{
 680        struct edt_ft5x06_ts_data *tsdata = data;
 681        int retval = 0;
 682
 683        if (mode > 1)
 684                return -ERANGE;
 685
 686        mutex_lock(&tsdata->mutex);
 687
 688        if (mode != tsdata->factory_mode) {
 689                retval = mode ? edt_ft5x06_factory_mode(tsdata) :
 690                                edt_ft5x06_work_mode(tsdata);
 691        }
 692
 693        mutex_unlock(&tsdata->mutex);
 694
 695        return retval;
 696};
 697
 698DEFINE_SIMPLE_ATTRIBUTE(debugfs_mode_fops, edt_ft5x06_debugfs_mode_get,
 699                        edt_ft5x06_debugfs_mode_set, "%llu\n");
 700
 701static ssize_t edt_ft5x06_debugfs_raw_data_read(struct file *file,
 702                                char __user *buf, size_t count, loff_t *off)
 703{
 704        struct edt_ft5x06_ts_data *tsdata = file->private_data;
 705        struct i2c_client *client = tsdata->client;
 706        int retries  = EDT_RAW_DATA_RETRIES;
 707        int val, i, error;
 708        size_t read = 0;
 709        int colbytes;
 710        char wrbuf[3];
 711        u8 *rdbuf;
 712
 713        if (*off < 0 || *off >= tsdata->raw_bufsize)
 714                return 0;
 715
 716        mutex_lock(&tsdata->mutex);
 717
 718        if (!tsdata->factory_mode || !tsdata->raw_buffer) {
 719                error = -EIO;
 720                goto out;
 721        }
 722
 723        error = edt_ft5x06_register_write(tsdata, 0x08, 0x01);
 724        if (error) {
 725                dev_dbg(&client->dev,
 726                        "failed to write 0x08 register, error %d\n", error);
 727                goto out;
 728        }
 729
 730        do {
 731                usleep_range(EDT_RAW_DATA_DELAY, EDT_RAW_DATA_DELAY + 100);
 732                val = edt_ft5x06_register_read(tsdata, 0x08);
 733                if (val < 1)
 734                        break;
 735        } while (--retries > 0);
 736
 737        if (val < 0) {
 738                error = val;
 739                dev_dbg(&client->dev,
 740                        "failed to read 0x08 register, error %d\n", error);
 741                goto out;
 742        }
 743
 744        if (retries == 0) {
 745                dev_dbg(&client->dev,
 746                        "timed out waiting for register to settle\n");
 747                error = -ETIMEDOUT;
 748                goto out;
 749        }
 750
 751        rdbuf = tsdata->raw_buffer;
 752        colbytes = tsdata->num_y * sizeof(u16);
 753
 754        wrbuf[0] = 0xf5;
 755        wrbuf[1] = 0x0e;
 756        for (i = 0; i < tsdata->num_x; i++) {
 757                wrbuf[2] = i;  /* column index */
 758                error = edt_ft5x06_ts_readwrite(tsdata->client,
 759                                                sizeof(wrbuf), wrbuf,
 760                                                colbytes, rdbuf);
 761                if (error)
 762                        goto out;
 763
 764                rdbuf += colbytes;
 765        }
 766
 767        read = min_t(size_t, count, tsdata->raw_bufsize - *off);
 768        if (copy_to_user(buf, tsdata->raw_buffer + *off, read)) {
 769                error = -EFAULT;
 770                goto out;
 771        }
 772
 773        *off += read;
 774out:
 775        mutex_unlock(&tsdata->mutex);
 776        return error ?: read;
 777};
 778
 779static const struct file_operations debugfs_raw_data_fops = {
 780        .open = simple_open,
 781        .read = edt_ft5x06_debugfs_raw_data_read,
 782};
 783
 784static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
 785                                          const char *debugfs_name)
 786{
 787        tsdata->debug_dir = debugfs_create_dir(debugfs_name, NULL);
 788
 789        debugfs_create_u16("num_x", S_IRUSR, tsdata->debug_dir, &tsdata->num_x);
 790        debugfs_create_u16("num_y", S_IRUSR, tsdata->debug_dir, &tsdata->num_y);
 791
 792        debugfs_create_file("mode", S_IRUSR | S_IWUSR,
 793                            tsdata->debug_dir, tsdata, &debugfs_mode_fops);
 794        debugfs_create_file("raw_data", S_IRUSR,
 795                            tsdata->debug_dir, tsdata, &debugfs_raw_data_fops);
 796}
 797
 798static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
 799{
 800        debugfs_remove_recursive(tsdata->debug_dir);
 801        kfree(tsdata->raw_buffer);
 802}
 803
 804#else
 805
 806static int edt_ft5x06_factory_mode(struct edt_ft5x06_ts_data *tsdata)
 807{
 808        return -ENOSYS;
 809}
 810
 811static void edt_ft5x06_ts_prepare_debugfs(struct edt_ft5x06_ts_data *tsdata,
 812                                          const char *debugfs_name)
 813{
 814}
 815
 816static void edt_ft5x06_ts_teardown_debugfs(struct edt_ft5x06_ts_data *tsdata)
 817{
 818}
 819
 820#endif /* CONFIG_DEBUGFS */
 821
 822static int edt_ft5x06_ts_identify(struct i2c_client *client,
 823                                        struct edt_ft5x06_ts_data *tsdata,
 824                                        char *fw_version)
 825{
 826        u8 rdbuf[EDT_NAME_LEN];
 827        char *p;
 828        int error;
 829        char *model_name = tsdata->name;
 830
 831        /* see what we find if we assume it is a M06 *
 832         * if we get less than EDT_NAME_LEN, we don't want
 833         * to have garbage in there
 834         */
 835        memset(rdbuf, 0, sizeof(rdbuf));
 836        error = edt_ft5x06_ts_readwrite(client, 1, "\xBB",
 837                                        EDT_NAME_LEN - 1, rdbuf);
 838        if (error)
 839                return error;
 840
 841        /* Probe content for something consistent.
 842         * M06 starts with a response byte, M12 gives the data directly.
 843         * M09/Generic does not provide model number information.
 844         */
 845        if (!strncasecmp(rdbuf + 1, "EP0", 3)) {
 846                tsdata->version = EDT_M06;
 847
 848                /* remove last '$' end marker */
 849                rdbuf[EDT_NAME_LEN - 1] = '\0';
 850                if (rdbuf[EDT_NAME_LEN - 2] == '$')
 851                        rdbuf[EDT_NAME_LEN - 2] = '\0';
 852
 853                /* look for Model/Version separator */
 854                p = strchr(rdbuf, '*');
 855                if (p)
 856                        *p++ = '\0';
 857                strlcpy(model_name, rdbuf + 1, EDT_NAME_LEN);
 858                strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
 859        } else if (!strncasecmp(rdbuf, "EP0", 3)) {
 860                tsdata->version = EDT_M12;
 861
 862                /* remove last '$' end marker */
 863                rdbuf[EDT_NAME_LEN - 2] = '\0';
 864                if (rdbuf[EDT_NAME_LEN - 3] == '$')
 865                        rdbuf[EDT_NAME_LEN - 3] = '\0';
 866
 867                /* look for Model/Version separator */
 868                p = strchr(rdbuf, '*');
 869                if (p)
 870                        *p++ = '\0';
 871                strlcpy(model_name, rdbuf, EDT_NAME_LEN);
 872                strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
 873        } else {
 874                /* If it is not an EDT M06/M12 touchscreen, then the model
 875                 * detection is a bit hairy. The different ft5x06
 876                 * firmares around don't reliably implement the
 877                 * identification registers. Well, we'll take a shot.
 878                 *
 879                 * The main difference between generic focaltec based
 880                 * touches and EDT M09 is that we know how to retrieve
 881                 * the max coordinates for the latter.
 882                 */
 883                tsdata->version = GENERIC_FT;
 884
 885                error = edt_ft5x06_ts_readwrite(client, 1, "\xA6",
 886                                                2, rdbuf);
 887                if (error)
 888                        return error;
 889
 890                strlcpy(fw_version, rdbuf, 2);
 891
 892                error = edt_ft5x06_ts_readwrite(client, 1, "\xA8",
 893                                                1, rdbuf);
 894                if (error)
 895                        return error;
 896
 897                /* This "model identification" is not exact. Unfortunately
 898                 * not all firmwares for the ft5x06 put useful values in
 899                 * the identification registers.
 900                 */
 901                switch (rdbuf[0]) {
 902                case 0x35:   /* EDT EP0350M09 */
 903                case 0x43:   /* EDT EP0430M09 */
 904                case 0x50:   /* EDT EP0500M09 */
 905                case 0x57:   /* EDT EP0570M09 */
 906                case 0x70:   /* EDT EP0700M09 */
 907                        tsdata->version = EDT_M09;
 908                        snprintf(model_name, EDT_NAME_LEN, "EP0%i%i0M09",
 909                                rdbuf[0] >> 4, rdbuf[0] & 0x0F);
 910                        break;
 911                case 0xa1:   /* EDT EP1010ML00 */
 912                        tsdata->version = EDT_M09;
 913                        snprintf(model_name, EDT_NAME_LEN, "EP%i%i0ML00",
 914                                rdbuf[0] >> 4, rdbuf[0] & 0x0F);
 915                        break;
 916                case 0x5a:   /* Solomon Goldentek Display */
 917                        snprintf(model_name, EDT_NAME_LEN, "GKTW50SCED1R0");
 918                        break;
 919                case 0x59:  /* Evervision Display with FT5xx6 TS */
 920                        tsdata->version = EV_FT;
 921                        error = edt_ft5x06_ts_readwrite(client, 1, "\x53",
 922                                                        1, rdbuf);
 923                        if (error)
 924                                return error;
 925                        strlcpy(fw_version, rdbuf, 1);
 926                        snprintf(model_name, EDT_NAME_LEN,
 927                                 "EVERVISION-FT5726NEi");
 928                        break;
 929                default:
 930                        snprintf(model_name, EDT_NAME_LEN,
 931                                 "generic ft5x06 (%02x)",
 932                                 rdbuf[0]);
 933                        break;
 934                }
 935        }
 936
 937        return 0;
 938}
 939
 940static void edt_ft5x06_ts_get_defaults(struct device *dev,
 941                                       struct edt_ft5x06_ts_data *tsdata)
 942{
 943        struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
 944        u32 val;
 945        int error;
 946
 947        error = device_property_read_u32(dev, "threshold", &val);
 948        if (!error) {
 949                edt_ft5x06_register_write(tsdata, reg_addr->reg_threshold, val);
 950                tsdata->threshold = val;
 951        }
 952
 953        error = device_property_read_u32(dev, "gain", &val);
 954        if (!error) {
 955                edt_ft5x06_register_write(tsdata, reg_addr->reg_gain, val);
 956                tsdata->gain = val;
 957        }
 958
 959        error = device_property_read_u32(dev, "offset", &val);
 960        if (!error) {
 961                if (reg_addr->reg_offset != NO_REGISTER)
 962                        edt_ft5x06_register_write(tsdata,
 963                                                  reg_addr->reg_offset, val);
 964                tsdata->offset = val;
 965        }
 966
 967        error = device_property_read_u32(dev, "offset-x", &val);
 968        if (!error) {
 969                if (reg_addr->reg_offset_x != NO_REGISTER)
 970                        edt_ft5x06_register_write(tsdata,
 971                                                  reg_addr->reg_offset_x, val);
 972                tsdata->offset_x = val;
 973        }
 974
 975        error = device_property_read_u32(dev, "offset-y", &val);
 976        if (!error) {
 977                if (reg_addr->reg_offset_y != NO_REGISTER)
 978                        edt_ft5x06_register_write(tsdata,
 979                                                  reg_addr->reg_offset_y, val);
 980                tsdata->offset_y = val;
 981        }
 982}
 983
 984static void edt_ft5x06_ts_get_parameters(struct edt_ft5x06_ts_data *tsdata)
 985{
 986        struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
 987
 988        tsdata->threshold = edt_ft5x06_register_read(tsdata,
 989                                                     reg_addr->reg_threshold);
 990        tsdata->gain = edt_ft5x06_register_read(tsdata, reg_addr->reg_gain);
 991        if (reg_addr->reg_offset != NO_REGISTER)
 992                tsdata->offset =
 993                        edt_ft5x06_register_read(tsdata, reg_addr->reg_offset);
 994        if (reg_addr->reg_offset_x != NO_REGISTER)
 995                tsdata->offset_x = edt_ft5x06_register_read(tsdata,
 996                                                reg_addr->reg_offset_x);
 997        if (reg_addr->reg_offset_y != NO_REGISTER)
 998                tsdata->offset_y = edt_ft5x06_register_read(tsdata,
 999                                                reg_addr->reg_offset_y);
1000        if (reg_addr->reg_report_rate != NO_REGISTER)
1001                tsdata->report_rate = edt_ft5x06_register_read(tsdata,
1002                                                reg_addr->reg_report_rate);
1003        tsdata->num_x = EDT_DEFAULT_NUM_X;
1004        if (reg_addr->reg_num_x != NO_REGISTER)
1005                tsdata->num_x = edt_ft5x06_register_read(tsdata,
1006                                                         reg_addr->reg_num_x);
1007        tsdata->num_y = EDT_DEFAULT_NUM_Y;
1008        if (reg_addr->reg_num_y != NO_REGISTER)
1009                tsdata->num_y = edt_ft5x06_register_read(tsdata,
1010                                                         reg_addr->reg_num_y);
1011}
1012
1013static void edt_ft5x06_ts_set_regs(struct edt_ft5x06_ts_data *tsdata)
1014{
1015        struct edt_reg_addr *reg_addr = &tsdata->reg_addr;
1016
1017        switch (tsdata->version) {
1018        case EDT_M06:
1019                reg_addr->reg_threshold = WORK_REGISTER_THRESHOLD;
1020                reg_addr->reg_report_rate = WORK_REGISTER_REPORT_RATE;
1021                reg_addr->reg_gain = WORK_REGISTER_GAIN;
1022                reg_addr->reg_offset = WORK_REGISTER_OFFSET;
1023                reg_addr->reg_offset_x = NO_REGISTER;
1024                reg_addr->reg_offset_y = NO_REGISTER;
1025                reg_addr->reg_num_x = WORK_REGISTER_NUM_X;
1026                reg_addr->reg_num_y = WORK_REGISTER_NUM_Y;
1027                break;
1028
1029        case EDT_M09:
1030        case EDT_M12:
1031                reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1032                reg_addr->reg_report_rate = NO_REGISTER;
1033                reg_addr->reg_gain = M09_REGISTER_GAIN;
1034                reg_addr->reg_offset = M09_REGISTER_OFFSET;
1035                reg_addr->reg_offset_x = NO_REGISTER;
1036                reg_addr->reg_offset_y = NO_REGISTER;
1037                reg_addr->reg_num_x = M09_REGISTER_NUM_X;
1038                reg_addr->reg_num_y = M09_REGISTER_NUM_Y;
1039                break;
1040
1041        case EV_FT:
1042                reg_addr->reg_threshold = EV_REGISTER_THRESHOLD;
1043                reg_addr->reg_report_rate = NO_REGISTER;
1044                reg_addr->reg_gain = EV_REGISTER_GAIN;
1045                reg_addr->reg_offset = NO_REGISTER;
1046                reg_addr->reg_offset_x = EV_REGISTER_OFFSET_X;
1047                reg_addr->reg_offset_y = EV_REGISTER_OFFSET_Y;
1048                reg_addr->reg_num_x = NO_REGISTER;
1049                reg_addr->reg_num_y = NO_REGISTER;
1050                break;
1051
1052        case GENERIC_FT:
1053                /* this is a guesswork */
1054                reg_addr->reg_threshold = M09_REGISTER_THRESHOLD;
1055                reg_addr->reg_report_rate = NO_REGISTER;
1056                reg_addr->reg_gain = M09_REGISTER_GAIN;
1057                reg_addr->reg_offset = M09_REGISTER_OFFSET;
1058                reg_addr->reg_offset_x = NO_REGISTER;
1059                reg_addr->reg_offset_y = NO_REGISTER;
1060                reg_addr->reg_num_x = NO_REGISTER;
1061                reg_addr->reg_num_y = NO_REGISTER;
1062                break;
1063        }
1064}
1065
1066static void edt_ft5x06_disable_regulators(void *arg)
1067{
1068        struct edt_ft5x06_ts_data *data = arg;
1069
1070        regulator_disable(data->vcc);
1071        regulator_disable(data->iovcc);
1072}
1073
1074static int edt_ft5x06_ts_probe(struct i2c_client *client,
1075                                         const struct i2c_device_id *id)
1076{
1077        const struct edt_i2c_chip_data *chip_data;
1078        struct edt_ft5x06_ts_data *tsdata;
1079        u8 buf[2] = { 0xfc, 0x00 };
1080        struct input_dev *input;
1081        unsigned long irq_flags;
1082        int error;
1083        char fw_version[EDT_NAME_LEN];
1084
1085        dev_dbg(&client->dev, "probing for EDT FT5x06 I2C\n");
1086
1087        tsdata = devm_kzalloc(&client->dev, sizeof(*tsdata), GFP_KERNEL);
1088        if (!tsdata) {
1089                dev_err(&client->dev, "failed to allocate driver data.\n");
1090                return -ENOMEM;
1091        }
1092
1093        chip_data = device_get_match_data(&client->dev);
1094        if (!chip_data)
1095                chip_data = (const struct edt_i2c_chip_data *)id->driver_data;
1096        if (!chip_data || !chip_data->max_support_points) {
1097                dev_err(&client->dev, "invalid or missing chip data\n");
1098                return -EINVAL;
1099        }
1100
1101        tsdata->max_support_points = chip_data->max_support_points;
1102
1103        tsdata->vcc = devm_regulator_get(&client->dev, "vcc");
1104        if (IS_ERR(tsdata->vcc)) {
1105                error = PTR_ERR(tsdata->vcc);
1106                if (error != -EPROBE_DEFER)
1107                        dev_err(&client->dev,
1108                                "failed to request regulator: %d\n", error);
1109                return error;
1110        }
1111
1112        tsdata->iovcc = devm_regulator_get(&client->dev, "iovcc");
1113        if (IS_ERR(tsdata->iovcc)) {
1114                error = PTR_ERR(tsdata->iovcc);
1115                if (error != -EPROBE_DEFER)
1116                        dev_err(&client->dev,
1117                                "failed to request iovcc regulator: %d\n", error);
1118                return error;
1119        }
1120
1121        error = regulator_enable(tsdata->iovcc);
1122        if (error < 0) {
1123                dev_err(&client->dev, "failed to enable iovcc: %d\n", error);
1124                return error;
1125        }
1126
1127        /* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1128        usleep_range(10, 100);
1129
1130        error = regulator_enable(tsdata->vcc);
1131        if (error < 0) {
1132                dev_err(&client->dev, "failed to enable vcc: %d\n", error);
1133                regulator_disable(tsdata->iovcc);
1134                return error;
1135        }
1136
1137        error = devm_add_action_or_reset(&client->dev,
1138                                         edt_ft5x06_disable_regulators,
1139                                         tsdata);
1140        if (error)
1141                return error;
1142
1143        tsdata->reset_gpio = devm_gpiod_get_optional(&client->dev,
1144                                                     "reset", GPIOD_OUT_HIGH);
1145        if (IS_ERR(tsdata->reset_gpio)) {
1146                error = PTR_ERR(tsdata->reset_gpio);
1147                dev_err(&client->dev,
1148                        "Failed to request GPIO reset pin, error %d\n", error);
1149                return error;
1150        }
1151
1152        tsdata->wake_gpio = devm_gpiod_get_optional(&client->dev,
1153                                                    "wake", GPIOD_OUT_LOW);
1154        if (IS_ERR(tsdata->wake_gpio)) {
1155                error = PTR_ERR(tsdata->wake_gpio);
1156                dev_err(&client->dev,
1157                        "Failed to request GPIO wake pin, error %d\n", error);
1158                return error;
1159        }
1160
1161        /*
1162         * Check which sleep modes we can support. Power-off requieres the
1163         * reset-pin to ensure correct power-down/power-up behaviour. Start with
1164         * the EDT_PMODE_POWEROFF test since this is the deepest possible sleep
1165         * mode.
1166         */
1167        if (tsdata->reset_gpio)
1168                tsdata->suspend_mode = EDT_PMODE_POWEROFF;
1169        else if (tsdata->wake_gpio)
1170                tsdata->suspend_mode = EDT_PMODE_HIBERNATE;
1171        else
1172                tsdata->suspend_mode = EDT_PMODE_NOT_SUPPORTED;
1173
1174        if (tsdata->wake_gpio) {
1175                usleep_range(5000, 6000);
1176                gpiod_set_value_cansleep(tsdata->wake_gpio, 1);
1177        }
1178
1179        if (tsdata->reset_gpio) {
1180                usleep_range(5000, 6000);
1181                gpiod_set_value_cansleep(tsdata->reset_gpio, 0);
1182                msleep(300);
1183        }
1184
1185        input = devm_input_allocate_device(&client->dev);
1186        if (!input) {
1187                dev_err(&client->dev, "failed to allocate input device.\n");
1188                return -ENOMEM;
1189        }
1190
1191        mutex_init(&tsdata->mutex);
1192        tsdata->client = client;
1193        tsdata->input = input;
1194        tsdata->factory_mode = false;
1195
1196        error = edt_ft5x06_ts_identify(client, tsdata, fw_version);
1197        if (error) {
1198                dev_err(&client->dev, "touchscreen probe failed\n");
1199                return error;
1200        }
1201
1202        /*
1203         * Dummy read access. EP0700MLP1 returns bogus data on the first
1204         * register read access and ignores writes.
1205         */
1206        edt_ft5x06_ts_readwrite(tsdata->client, 2, buf, 2, buf);
1207
1208        edt_ft5x06_ts_set_regs(tsdata);
1209        edt_ft5x06_ts_get_defaults(&client->dev, tsdata);
1210        edt_ft5x06_ts_get_parameters(tsdata);
1211
1212        dev_dbg(&client->dev,
1213                "Model \"%s\", Rev. \"%s\", %dx%d sensors\n",
1214                tsdata->name, fw_version, tsdata->num_x, tsdata->num_y);
1215
1216        input->name = tsdata->name;
1217        input->id.bustype = BUS_I2C;
1218        input->dev.parent = &client->dev;
1219
1220        input_set_abs_params(input, ABS_MT_POSITION_X,
1221                             0, tsdata->num_x * 64 - 1, 0, 0);
1222        input_set_abs_params(input, ABS_MT_POSITION_Y,
1223                             0, tsdata->num_y * 64 - 1, 0, 0);
1224
1225        touchscreen_parse_properties(input, true, &tsdata->prop);
1226
1227        error = input_mt_init_slots(input, tsdata->max_support_points,
1228                                INPUT_MT_DIRECT);
1229        if (error) {
1230                dev_err(&client->dev, "Unable to init MT slots.\n");
1231                return error;
1232        }
1233
1234        i2c_set_clientdata(client, tsdata);
1235
1236        irq_flags = irq_get_trigger_type(client->irq);
1237        if (irq_flags == IRQF_TRIGGER_NONE)
1238                irq_flags = IRQF_TRIGGER_FALLING;
1239        irq_flags |= IRQF_ONESHOT;
1240
1241        error = devm_request_threaded_irq(&client->dev, client->irq,
1242                                        NULL, edt_ft5x06_ts_isr, irq_flags,
1243                                        client->name, tsdata);
1244        if (error) {
1245                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
1246                return error;
1247        }
1248
1249        error = devm_device_add_group(&client->dev, &edt_ft5x06_attr_group);
1250        if (error)
1251                return error;
1252
1253        error = input_register_device(input);
1254        if (error)
1255                return error;
1256
1257        edt_ft5x06_ts_prepare_debugfs(tsdata, dev_driver_string(&client->dev));
1258
1259        dev_dbg(&client->dev,
1260                "EDT FT5x06 initialized: IRQ %d, WAKE pin %d, Reset pin %d.\n",
1261                client->irq,
1262                tsdata->wake_gpio ? desc_to_gpio(tsdata->wake_gpio) : -1,
1263                tsdata->reset_gpio ? desc_to_gpio(tsdata->reset_gpio) : -1);
1264
1265        return 0;
1266}
1267
1268static int edt_ft5x06_ts_remove(struct i2c_client *client)
1269{
1270        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1271
1272        edt_ft5x06_ts_teardown_debugfs(tsdata);
1273
1274        return 0;
1275}
1276
1277static int __maybe_unused edt_ft5x06_ts_suspend(struct device *dev)
1278{
1279        struct i2c_client *client = to_i2c_client(dev);
1280        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1281        struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1282        int ret;
1283
1284        if (device_may_wakeup(dev))
1285                return 0;
1286
1287        if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1288                return 0;
1289
1290        /* Enter hibernate mode. */
1291        ret = edt_ft5x06_register_write(tsdata, PMOD_REGISTER_OPMODE,
1292                                        PMOD_REGISTER_HIBERNATE);
1293        if (ret)
1294                dev_warn(dev, "Failed to set hibernate mode\n");
1295
1296        if (tsdata->suspend_mode == EDT_PMODE_HIBERNATE)
1297                return 0;
1298
1299        /*
1300         * Power-off according the datasheet. Cut the power may leaf the irq
1301         * line in an undefined state depending on the host pull resistor
1302         * settings. Disable the irq to avoid adjusting each host till the
1303         * device is back in a full functional state.
1304         */
1305        disable_irq(tsdata->client->irq);
1306
1307        gpiod_set_value_cansleep(reset_gpio, 1);
1308        usleep_range(1000, 2000);
1309
1310        ret = regulator_disable(tsdata->vcc);
1311        if (ret)
1312                dev_warn(dev, "Failed to disable vcc\n");
1313        ret = regulator_disable(tsdata->iovcc);
1314        if (ret)
1315                dev_warn(dev, "Failed to disable iovcc\n");
1316
1317        return 0;
1318}
1319
1320static int __maybe_unused edt_ft5x06_ts_resume(struct device *dev)
1321{
1322        struct i2c_client *client = to_i2c_client(dev);
1323        struct edt_ft5x06_ts_data *tsdata = i2c_get_clientdata(client);
1324        int ret = 0;
1325
1326        if (device_may_wakeup(dev))
1327                return 0;
1328
1329        if (tsdata->suspend_mode == EDT_PMODE_NOT_SUPPORTED)
1330                return 0;
1331
1332        if (tsdata->suspend_mode == EDT_PMODE_POWEROFF) {
1333                struct gpio_desc *reset_gpio = tsdata->reset_gpio;
1334
1335                /*
1336                 * We can't check if the regulator is a dummy or a real
1337                 * regulator. So we need to specify the 5ms reset time (T_rst)
1338                 * here instead of the 100us T_rtp time. We also need to wait
1339                 * 300ms in case it was a real supply and the power was cutted
1340                 * of. Toggle the reset pin is also a way to exit the hibernate
1341                 * mode.
1342                 */
1343                gpiod_set_value_cansleep(reset_gpio, 1);
1344                usleep_range(5000, 6000);
1345
1346                ret = regulator_enable(tsdata->iovcc);
1347                if (ret) {
1348                        dev_err(dev, "Failed to enable iovcc\n");
1349                        return ret;
1350                }
1351
1352                /* Delay enabling VCC for > 10us (T_ivd) after IOVCC */
1353                usleep_range(10, 100);
1354
1355                ret = regulator_enable(tsdata->vcc);
1356                if (ret) {
1357                        dev_err(dev, "Failed to enable vcc\n");
1358                        regulator_disable(tsdata->iovcc);
1359                        return ret;
1360                }
1361
1362                usleep_range(1000, 2000);
1363                gpiod_set_value_cansleep(reset_gpio, 0);
1364                msleep(300);
1365
1366                edt_ft5x06_restore_reg_parameters(tsdata);
1367                enable_irq(tsdata->client->irq);
1368
1369                if (tsdata->factory_mode)
1370                        ret = edt_ft5x06_factory_mode(tsdata);
1371        } else {
1372                struct gpio_desc *wake_gpio = tsdata->wake_gpio;
1373
1374                gpiod_set_value_cansleep(wake_gpio, 0);
1375                usleep_range(5000, 6000);
1376                gpiod_set_value_cansleep(wake_gpio, 1);
1377        }
1378
1379
1380        return ret;
1381}
1382
1383static SIMPLE_DEV_PM_OPS(edt_ft5x06_ts_pm_ops,
1384                         edt_ft5x06_ts_suspend, edt_ft5x06_ts_resume);
1385
1386static const struct edt_i2c_chip_data edt_ft5x06_data = {
1387        .max_support_points = 5,
1388};
1389
1390static const struct edt_i2c_chip_data edt_ft5506_data = {
1391        .max_support_points = 10,
1392};
1393
1394static const struct edt_i2c_chip_data edt_ft6236_data = {
1395        .max_support_points = 2,
1396};
1397
1398static const struct i2c_device_id edt_ft5x06_ts_id[] = {
1399        { .name = "edt-ft5x06", .driver_data = (long)&edt_ft5x06_data },
1400        { .name = "edt-ft5506", .driver_data = (long)&edt_ft5506_data },
1401        { .name = "ev-ft5726", .driver_data = (long)&edt_ft5506_data },
1402        /* Note no edt- prefix for compatibility with the ft6236.c driver */
1403        { .name = "ft6236", .driver_data = (long)&edt_ft6236_data },
1404        { /* sentinel */ }
1405};
1406MODULE_DEVICE_TABLE(i2c, edt_ft5x06_ts_id);
1407
1408static const struct of_device_id edt_ft5x06_of_match[] = {
1409        { .compatible = "edt,edt-ft5206", .data = &edt_ft5x06_data },
1410        { .compatible = "edt,edt-ft5306", .data = &edt_ft5x06_data },
1411        { .compatible = "edt,edt-ft5406", .data = &edt_ft5x06_data },
1412        { .compatible = "edt,edt-ft5506", .data = &edt_ft5506_data },
1413        { .compatible = "evervision,ev-ft5726", .data = &edt_ft5506_data },
1414        /* Note focaltech vendor prefix for compatibility with ft6236.c */
1415        { .compatible = "focaltech,ft6236", .data = &edt_ft6236_data },
1416        { /* sentinel */ }
1417};
1418MODULE_DEVICE_TABLE(of, edt_ft5x06_of_match);
1419
1420static struct i2c_driver edt_ft5x06_ts_driver = {
1421        .driver = {
1422                .name = "edt_ft5x06",
1423                .of_match_table = edt_ft5x06_of_match,
1424                .pm = &edt_ft5x06_ts_pm_ops,
1425                .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1426        },
1427        .id_table = edt_ft5x06_ts_id,
1428        .probe    = edt_ft5x06_ts_probe,
1429        .remove   = edt_ft5x06_ts_remove,
1430};
1431
1432module_i2c_driver(edt_ft5x06_ts_driver);
1433
1434MODULE_AUTHOR("Simon Budig <simon.budig@kernelconcepts.de>");
1435MODULE_DESCRIPTION("EDT FT5x06 I2C Touchscreen Driver");
1436MODULE_LICENSE("GPL v2");
1437