linux/drivers/input/touchscreen/zforce_ts.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2012-2013 MundoReader S.L.
   3 * Author: Heiko Stuebner <heiko@sntech.de>
   4 *
   5 * based in parts on Nook zforce driver
   6 *
   7 * Copyright (C) 2010 Barnes & Noble, Inc.
   8 * Author: Pieter Truter<ptruter@intrinsyc.com>
   9 *
  10 * This software is licensed under the terms of the GNU General Public
  11 * License version 2, as published by the Free Software Foundation, and
  12 * may be copied, distributed, and modified under those terms.
  13 *
  14 * This program is distributed in the hope that it will be useful,
  15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 * GNU General Public License for more details.
  18 */
  19
  20#include <linux/module.h>
  21#include <linux/hrtimer.h>
  22#include <linux/slab.h>
  23#include <linux/input.h>
  24#include <linux/interrupt.h>
  25#include <linux/i2c.h>
  26#include <linux/delay.h>
  27#include <linux/gpio/consumer.h>
  28#include <linux/device.h>
  29#include <linux/sysfs.h>
  30#include <linux/input/mt.h>
  31#include <linux/platform_data/zforce_ts.h>
  32#include <linux/regulator/consumer.h>
  33#include <linux/of.h>
  34
  35#define WAIT_TIMEOUT            msecs_to_jiffies(1000)
  36
  37#define FRAME_START             0xee
  38#define FRAME_MAXSIZE           257
  39
  40/* Offsets of the different parts of the payload the controller sends */
  41#define PAYLOAD_HEADER          0
  42#define PAYLOAD_LENGTH          1
  43#define PAYLOAD_BODY            2
  44
  45/* Response offsets */
  46#define RESPONSE_ID             0
  47#define RESPONSE_DATA           1
  48
  49/* Commands */
  50#define COMMAND_DEACTIVATE      0x00
  51#define COMMAND_INITIALIZE      0x01
  52#define COMMAND_RESOLUTION      0x02
  53#define COMMAND_SETCONFIG       0x03
  54#define COMMAND_DATAREQUEST     0x04
  55#define COMMAND_SCANFREQ        0x08
  56#define COMMAND_STATUS          0X1e
  57
  58/*
  59 * Responses the controller sends as a result of
  60 * command requests
  61 */
  62#define RESPONSE_DEACTIVATE     0x00
  63#define RESPONSE_INITIALIZE     0x01
  64#define RESPONSE_RESOLUTION     0x02
  65#define RESPONSE_SETCONFIG      0x03
  66#define RESPONSE_SCANFREQ       0x08
  67#define RESPONSE_STATUS         0X1e
  68
  69/*
  70 * Notifications are sent by the touch controller without
  71 * being requested by the driver and include for example
  72 * touch indications
  73 */
  74#define NOTIFICATION_TOUCH              0x04
  75#define NOTIFICATION_BOOTCOMPLETE       0x07
  76#define NOTIFICATION_OVERRUN            0x25
  77#define NOTIFICATION_PROXIMITY          0x26
  78#define NOTIFICATION_INVALID_COMMAND    0xfe
  79
  80#define ZFORCE_REPORT_POINTS            2
  81#define ZFORCE_MAX_AREA                 0xff
  82
  83#define STATE_DOWN                      0
  84#define STATE_MOVE                      1
  85#define STATE_UP                        2
  86
  87#define SETCONFIG_DUALTOUCH             (1 << 0)
  88
  89struct zforce_point {
  90        int coord_x;
  91        int coord_y;
  92        int state;
  93        int id;
  94        int area_major;
  95        int area_minor;
  96        int orientation;
  97        int pressure;
  98        int prblty;
  99};
 100
 101/*
 102 * @client              the i2c_client
 103 * @input               the input device
 104 * @suspending          in the process of going to suspend (don't emit wakeup
 105 *                      events for commands executed to suspend the device)
 106 * @suspended           device suspended
 107 * @access_mutex        serialize i2c-access, to keep multipart reads together
 108 * @command_done        completion to wait for the command result
 109 * @command_mutex       serialize commands sent to the ic
 110 * @command_waiting     the id of the command that is currently waiting
 111 *                      for a result
 112 * @command_result      returned result of the command
 113 */
 114struct zforce_ts {
 115        struct i2c_client       *client;
 116        struct input_dev        *input;
 117        const struct zforce_ts_platdata *pdata;
 118        char                    phys[32];
 119
 120        struct regulator        *reg_vdd;
 121
 122        struct gpio_desc        *gpio_int;
 123        struct gpio_desc        *gpio_rst;
 124
 125        bool                    suspending;
 126        bool                    suspended;
 127        bool                    boot_complete;
 128
 129        /* Firmware version information */
 130        u16                     version_major;
 131        u16                     version_minor;
 132        u16                     version_build;
 133        u16                     version_rev;
 134
 135        struct mutex            access_mutex;
 136
 137        struct completion       command_done;
 138        struct mutex            command_mutex;
 139        int                     command_waiting;
 140        int                     command_result;
 141};
 142
 143static int zforce_command(struct zforce_ts *ts, u8 cmd)
 144{
 145        struct i2c_client *client = ts->client;
 146        char buf[3];
 147        int ret;
 148
 149        dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd);
 150
 151        buf[0] = FRAME_START;
 152        buf[1] = 1; /* data size, command only */
 153        buf[2] = cmd;
 154
 155        mutex_lock(&ts->access_mutex);
 156        ret = i2c_master_send(client, &buf[0], ARRAY_SIZE(buf));
 157        mutex_unlock(&ts->access_mutex);
 158        if (ret < 0) {
 159                dev_err(&client->dev, "i2c send data request error: %d\n", ret);
 160                return ret;
 161        }
 162
 163        return 0;
 164}
 165
 166static void zforce_reset_assert(struct zforce_ts *ts)
 167{
 168        gpiod_set_value_cansleep(ts->gpio_rst, 1);
 169}
 170
 171static void zforce_reset_deassert(struct zforce_ts *ts)
 172{
 173        gpiod_set_value_cansleep(ts->gpio_rst, 0);
 174}
 175
 176static int zforce_send_wait(struct zforce_ts *ts, const char *buf, int len)
 177{
 178        struct i2c_client *client = ts->client;
 179        int ret;
 180
 181        ret = mutex_trylock(&ts->command_mutex);
 182        if (!ret) {
 183                dev_err(&client->dev, "already waiting for a command\n");
 184                return -EBUSY;
 185        }
 186
 187        dev_dbg(&client->dev, "sending %d bytes for command 0x%x\n",
 188                buf[1], buf[2]);
 189
 190        ts->command_waiting = buf[2];
 191
 192        mutex_lock(&ts->access_mutex);
 193        ret = i2c_master_send(client, buf, len);
 194        mutex_unlock(&ts->access_mutex);
 195        if (ret < 0) {
 196                dev_err(&client->dev, "i2c send data request error: %d\n", ret);
 197                goto unlock;
 198        }
 199
 200        dev_dbg(&client->dev, "waiting for result for command 0x%x\n", buf[2]);
 201
 202        if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0) {
 203                ret = -ETIME;
 204                goto unlock;
 205        }
 206
 207        ret = ts->command_result;
 208
 209unlock:
 210        mutex_unlock(&ts->command_mutex);
 211        return ret;
 212}
 213
 214static int zforce_command_wait(struct zforce_ts *ts, u8 cmd)
 215{
 216        struct i2c_client *client = ts->client;
 217        char buf[3];
 218        int ret;
 219
 220        dev_dbg(&client->dev, "%s: 0x%x\n", __func__, cmd);
 221
 222        buf[0] = FRAME_START;
 223        buf[1] = 1; /* data size, command only */
 224        buf[2] = cmd;
 225
 226        ret = zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf));
 227        if (ret < 0) {
 228                dev_err(&client->dev, "i2c send data request error: %d\n", ret);
 229                return ret;
 230        }
 231
 232        return 0;
 233}
 234
 235static int zforce_resolution(struct zforce_ts *ts, u16 x, u16 y)
 236{
 237        struct i2c_client *client = ts->client;
 238        char buf[7] = { FRAME_START, 5, COMMAND_RESOLUTION,
 239                        (x & 0xff), ((x >> 8) & 0xff),
 240                        (y & 0xff), ((y >> 8) & 0xff) };
 241
 242        dev_dbg(&client->dev, "set resolution to (%d,%d)\n", x, y);
 243
 244        return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf));
 245}
 246
 247static int zforce_scan_frequency(struct zforce_ts *ts, u16 idle, u16 finger,
 248                                 u16 stylus)
 249{
 250        struct i2c_client *client = ts->client;
 251        char buf[9] = { FRAME_START, 7, COMMAND_SCANFREQ,
 252                        (idle & 0xff), ((idle >> 8) & 0xff),
 253                        (finger & 0xff), ((finger >> 8) & 0xff),
 254                        (stylus & 0xff), ((stylus >> 8) & 0xff) };
 255
 256        dev_dbg(&client->dev,
 257                "set scan frequency to (idle: %d, finger: %d, stylus: %d)\n",
 258                idle, finger, stylus);
 259
 260        return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf));
 261}
 262
 263static int zforce_setconfig(struct zforce_ts *ts, char b1)
 264{
 265        struct i2c_client *client = ts->client;
 266        char buf[7] = { FRAME_START, 5, COMMAND_SETCONFIG,
 267                        b1, 0, 0, 0 };
 268
 269        dev_dbg(&client->dev, "set config to (%d)\n", b1);
 270
 271        return zforce_send_wait(ts, &buf[0], ARRAY_SIZE(buf));
 272}
 273
 274static int zforce_start(struct zforce_ts *ts)
 275{
 276        struct i2c_client *client = ts->client;
 277        const struct zforce_ts_platdata *pdata = ts->pdata;
 278        int ret;
 279
 280        dev_dbg(&client->dev, "starting device\n");
 281
 282        ret = zforce_command_wait(ts, COMMAND_INITIALIZE);
 283        if (ret) {
 284                dev_err(&client->dev, "Unable to initialize, %d\n", ret);
 285                return ret;
 286        }
 287
 288        ret = zforce_resolution(ts, pdata->x_max, pdata->y_max);
 289        if (ret) {
 290                dev_err(&client->dev, "Unable to set resolution, %d\n", ret);
 291                goto error;
 292        }
 293
 294        ret = zforce_scan_frequency(ts, 10, 50, 50);
 295        if (ret) {
 296                dev_err(&client->dev, "Unable to set scan frequency, %d\n",
 297                        ret);
 298                goto error;
 299        }
 300
 301        ret = zforce_setconfig(ts, SETCONFIG_DUALTOUCH);
 302        if (ret) {
 303                dev_err(&client->dev, "Unable to set config\n");
 304                goto error;
 305        }
 306
 307        /* start sending touch events */
 308        ret = zforce_command(ts, COMMAND_DATAREQUEST);
 309        if (ret) {
 310                dev_err(&client->dev, "Unable to request data\n");
 311                goto error;
 312        }
 313
 314        /*
 315         * Per NN, initial cal. take max. of 200msec.
 316         * Allow time to complete this calibration
 317         */
 318        msleep(200);
 319
 320        return 0;
 321
 322error:
 323        zforce_command_wait(ts, COMMAND_DEACTIVATE);
 324        return ret;
 325}
 326
 327static int zforce_stop(struct zforce_ts *ts)
 328{
 329        struct i2c_client *client = ts->client;
 330        int ret;
 331
 332        dev_dbg(&client->dev, "stopping device\n");
 333
 334        /* Deactivates touch sensing and puts the device into sleep. */
 335        ret = zforce_command_wait(ts, COMMAND_DEACTIVATE);
 336        if (ret != 0) {
 337                dev_err(&client->dev, "could not deactivate device, %d\n",
 338                        ret);
 339                return ret;
 340        }
 341
 342        return 0;
 343}
 344
 345static int zforce_touch_event(struct zforce_ts *ts, u8 *payload)
 346{
 347        struct i2c_client *client = ts->client;
 348        const struct zforce_ts_platdata *pdata = ts->pdata;
 349        struct zforce_point point;
 350        int count, i, num = 0;
 351
 352        count = payload[0];
 353        if (count > ZFORCE_REPORT_POINTS) {
 354                dev_warn(&client->dev,
 355                         "too many coordinates %d, expected max %d\n",
 356                         count, ZFORCE_REPORT_POINTS);
 357                count = ZFORCE_REPORT_POINTS;
 358        }
 359
 360        for (i = 0; i < count; i++) {
 361                point.coord_x =
 362                        payload[9 * i + 2] << 8 | payload[9 * i + 1];
 363                point.coord_y =
 364                        payload[9 * i + 4] << 8 | payload[9 * i + 3];
 365
 366                if (point.coord_x > pdata->x_max ||
 367                    point.coord_y > pdata->y_max) {
 368                        dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
 369                                point.coord_x, point.coord_y);
 370                        point.coord_x = point.coord_y = 0;
 371                }
 372
 373                point.state = payload[9 * i + 5] & 0x0f;
 374                point.id = (payload[9 * i + 5] & 0xf0) >> 4;
 375
 376                /* determine touch major, minor and orientation */
 377                point.area_major = max(payload[9 * i + 6],
 378                                          payload[9 * i + 7]);
 379                point.area_minor = min(payload[9 * i + 6],
 380                                          payload[9 * i + 7]);
 381                point.orientation = payload[9 * i + 6] > payload[9 * i + 7];
 382
 383                point.pressure = payload[9 * i + 8];
 384                point.prblty = payload[9 * i + 9];
 385
 386                dev_dbg(&client->dev,
 387                        "point %d/%d: state %d, id %d, pressure %d, prblty %d, x %d, y %d, amajor %d, aminor %d, ori %d\n",
 388                        i, count, point.state, point.id,
 389                        point.pressure, point.prblty,
 390                        point.coord_x, point.coord_y,
 391                        point.area_major, point.area_minor,
 392                        point.orientation);
 393
 394                /* the zforce id starts with "1", so needs to be decreased */
 395                input_mt_slot(ts->input, point.id - 1);
 396
 397                input_mt_report_slot_state(ts->input, MT_TOOL_FINGER,
 398                                                point.state != STATE_UP);
 399
 400                if (point.state != STATE_UP) {
 401                        input_report_abs(ts->input, ABS_MT_POSITION_X,
 402                                         point.coord_x);
 403                        input_report_abs(ts->input, ABS_MT_POSITION_Y,
 404                                         point.coord_y);
 405                        input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
 406                                         point.area_major);
 407                        input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
 408                                         point.area_minor);
 409                        input_report_abs(ts->input, ABS_MT_ORIENTATION,
 410                                         point.orientation);
 411                        num++;
 412                }
 413        }
 414
 415        input_mt_sync_frame(ts->input);
 416
 417        input_mt_report_finger_count(ts->input, num);
 418
 419        input_sync(ts->input);
 420
 421        return 0;
 422}
 423
 424static int zforce_read_packet(struct zforce_ts *ts, u8 *buf)
 425{
 426        struct i2c_client *client = ts->client;
 427        int ret;
 428
 429        mutex_lock(&ts->access_mutex);
 430
 431        /* read 2 byte message header */
 432        ret = i2c_master_recv(client, buf, 2);
 433        if (ret < 0) {
 434                dev_err(&client->dev, "error reading header: %d\n", ret);
 435                goto unlock;
 436        }
 437
 438        if (buf[PAYLOAD_HEADER] != FRAME_START) {
 439                dev_err(&client->dev, "invalid frame start: %d\n", buf[0]);
 440                ret = -EIO;
 441                goto unlock;
 442        }
 443
 444        if (buf[PAYLOAD_LENGTH] == 0) {
 445                dev_err(&client->dev, "invalid payload length: %d\n",
 446                        buf[PAYLOAD_LENGTH]);
 447                ret = -EIO;
 448                goto unlock;
 449        }
 450
 451        /* read the message */
 452        ret = i2c_master_recv(client, &buf[PAYLOAD_BODY], buf[PAYLOAD_LENGTH]);
 453        if (ret < 0) {
 454                dev_err(&client->dev, "error reading payload: %d\n", ret);
 455                goto unlock;
 456        }
 457
 458        dev_dbg(&client->dev, "read %d bytes for response command 0x%x\n",
 459                buf[PAYLOAD_LENGTH], buf[PAYLOAD_BODY]);
 460
 461unlock:
 462        mutex_unlock(&ts->access_mutex);
 463        return ret;
 464}
 465
 466static void zforce_complete(struct zforce_ts *ts, int cmd, int result)
 467{
 468        struct i2c_client *client = ts->client;
 469
 470        if (ts->command_waiting == cmd) {
 471                dev_dbg(&client->dev, "completing command 0x%x\n", cmd);
 472                ts->command_result = result;
 473                complete(&ts->command_done);
 474        } else {
 475                dev_dbg(&client->dev, "command %d not for us\n", cmd);
 476        }
 477}
 478
 479static irqreturn_t zforce_irq(int irq, void *dev_id)
 480{
 481        struct zforce_ts *ts = dev_id;
 482        struct i2c_client *client = ts->client;
 483
 484        if (ts->suspended && device_may_wakeup(&client->dev))
 485                pm_wakeup_event(&client->dev, 500);
 486
 487        return IRQ_WAKE_THREAD;
 488}
 489
 490static irqreturn_t zforce_irq_thread(int irq, void *dev_id)
 491{
 492        struct zforce_ts *ts = dev_id;
 493        struct i2c_client *client = ts->client;
 494        int ret;
 495        u8 payload_buffer[FRAME_MAXSIZE];
 496        u8 *payload;
 497
 498        /*
 499         * When still suspended, return.
 500         * Due to the level-interrupt we will get re-triggered later.
 501         */
 502        if (ts->suspended) {
 503                msleep(20);
 504                return IRQ_HANDLED;
 505        }
 506
 507        dev_dbg(&client->dev, "handling interrupt\n");
 508
 509        /* Don't emit wakeup events from commands run by zforce_suspend */
 510        if (!ts->suspending && device_may_wakeup(&client->dev))
 511                pm_stay_awake(&client->dev);
 512
 513        /*
 514         * Run at least once and exit the loop if
 515         * - the optional interrupt GPIO isn't specified
 516         *   (there is only one packet read per ISR invocation, then)
 517         * or
 518         * - the GPIO isn't active any more
 519         *   (packet read until the level GPIO indicates that there is
 520         *    no IRQ any more)
 521         */
 522        do {
 523                ret = zforce_read_packet(ts, payload_buffer);
 524                if (ret < 0) {
 525                        dev_err(&client->dev,
 526                                "could not read packet, ret: %d\n", ret);
 527                        break;
 528                }
 529
 530                payload =  &payload_buffer[PAYLOAD_BODY];
 531
 532                switch (payload[RESPONSE_ID]) {
 533                case NOTIFICATION_TOUCH:
 534                        /*
 535                         * Always report touch-events received while
 536                         * suspending, when being a wakeup source
 537                         */
 538                        if (ts->suspending && device_may_wakeup(&client->dev))
 539                                pm_wakeup_event(&client->dev, 500);
 540                        zforce_touch_event(ts, &payload[RESPONSE_DATA]);
 541                        break;
 542
 543                case NOTIFICATION_BOOTCOMPLETE:
 544                        ts->boot_complete = payload[RESPONSE_DATA];
 545                        zforce_complete(ts, payload[RESPONSE_ID], 0);
 546                        break;
 547
 548                case RESPONSE_INITIALIZE:
 549                case RESPONSE_DEACTIVATE:
 550                case RESPONSE_SETCONFIG:
 551                case RESPONSE_RESOLUTION:
 552                case RESPONSE_SCANFREQ:
 553                        zforce_complete(ts, payload[RESPONSE_ID],
 554                                        payload[RESPONSE_DATA]);
 555                        break;
 556
 557                case RESPONSE_STATUS:
 558                        /*
 559                         * Version Payload Results
 560                         * [2:major] [2:minor] [2:build] [2:rev]
 561                         */
 562                        ts->version_major = (payload[RESPONSE_DATA + 1] << 8) |
 563                                                payload[RESPONSE_DATA];
 564                        ts->version_minor = (payload[RESPONSE_DATA + 3] << 8) |
 565                                                payload[RESPONSE_DATA + 2];
 566                        ts->version_build = (payload[RESPONSE_DATA + 5] << 8) |
 567                                                payload[RESPONSE_DATA + 4];
 568                        ts->version_rev   = (payload[RESPONSE_DATA + 7] << 8) |
 569                                                payload[RESPONSE_DATA + 6];
 570                        dev_dbg(&ts->client->dev,
 571                                "Firmware Version %04x:%04x %04x:%04x\n",
 572                                ts->version_major, ts->version_minor,
 573                                ts->version_build, ts->version_rev);
 574
 575                        zforce_complete(ts, payload[RESPONSE_ID], 0);
 576                        break;
 577
 578                case NOTIFICATION_INVALID_COMMAND:
 579                        dev_err(&ts->client->dev, "invalid command: 0x%x\n",
 580                                payload[RESPONSE_DATA]);
 581                        break;
 582
 583                default:
 584                        dev_err(&ts->client->dev,
 585                                "unrecognized response id: 0x%x\n",
 586                                payload[RESPONSE_ID]);
 587                        break;
 588                }
 589        } while (gpiod_get_value_cansleep(ts->gpio_int));
 590
 591        if (!ts->suspending && device_may_wakeup(&client->dev))
 592                pm_relax(&client->dev);
 593
 594        dev_dbg(&client->dev, "finished interrupt\n");
 595
 596        return IRQ_HANDLED;
 597}
 598
 599static int zforce_input_open(struct input_dev *dev)
 600{
 601        struct zforce_ts *ts = input_get_drvdata(dev);
 602
 603        return zforce_start(ts);
 604}
 605
 606static void zforce_input_close(struct input_dev *dev)
 607{
 608        struct zforce_ts *ts = input_get_drvdata(dev);
 609        struct i2c_client *client = ts->client;
 610        int ret;
 611
 612        ret = zforce_stop(ts);
 613        if (ret)
 614                dev_warn(&client->dev, "stopping zforce failed\n");
 615
 616        return;
 617}
 618
 619static int __maybe_unused zforce_suspend(struct device *dev)
 620{
 621        struct i2c_client *client = to_i2c_client(dev);
 622        struct zforce_ts *ts = i2c_get_clientdata(client);
 623        struct input_dev *input = ts->input;
 624        int ret = 0;
 625
 626        mutex_lock(&input->mutex);
 627        ts->suspending = true;
 628
 629        /*
 630         * When configured as a wakeup source device should always wake
 631         * the system, therefore start device if necessary.
 632         */
 633        if (device_may_wakeup(&client->dev)) {
 634                dev_dbg(&client->dev, "suspend while being a wakeup source\n");
 635
 636                /* Need to start device, if not open, to be a wakeup source. */
 637                if (!input->users) {
 638                        ret = zforce_start(ts);
 639                        if (ret)
 640                                goto unlock;
 641                }
 642
 643                enable_irq_wake(client->irq);
 644        } else if (input->users) {
 645                dev_dbg(&client->dev,
 646                        "suspend without being a wakeup source\n");
 647
 648                ret = zforce_stop(ts);
 649                if (ret)
 650                        goto unlock;
 651
 652                disable_irq(client->irq);
 653        }
 654
 655        ts->suspended = true;
 656
 657unlock:
 658        ts->suspending = false;
 659        mutex_unlock(&input->mutex);
 660
 661        return ret;
 662}
 663
 664static int __maybe_unused zforce_resume(struct device *dev)
 665{
 666        struct i2c_client *client = to_i2c_client(dev);
 667        struct zforce_ts *ts = i2c_get_clientdata(client);
 668        struct input_dev *input = ts->input;
 669        int ret = 0;
 670
 671        mutex_lock(&input->mutex);
 672
 673        ts->suspended = false;
 674
 675        if (device_may_wakeup(&client->dev)) {
 676                dev_dbg(&client->dev, "resume from being a wakeup source\n");
 677
 678                disable_irq_wake(client->irq);
 679
 680                /* need to stop device if it was not open on suspend */
 681                if (!input->users) {
 682                        ret = zforce_stop(ts);
 683                        if (ret)
 684                                goto unlock;
 685                }
 686        } else if (input->users) {
 687                dev_dbg(&client->dev, "resume without being a wakeup source\n");
 688
 689                enable_irq(client->irq);
 690
 691                ret = zforce_start(ts);
 692                if (ret < 0)
 693                        goto unlock;
 694        }
 695
 696unlock:
 697        mutex_unlock(&input->mutex);
 698
 699        return ret;
 700}
 701
 702static SIMPLE_DEV_PM_OPS(zforce_pm_ops, zforce_suspend, zforce_resume);
 703
 704static void zforce_reset(void *data)
 705{
 706        struct zforce_ts *ts = data;
 707
 708        zforce_reset_assert(ts);
 709
 710        udelay(10);
 711
 712        if (!IS_ERR(ts->reg_vdd))
 713                regulator_disable(ts->reg_vdd);
 714}
 715
 716static struct zforce_ts_platdata *zforce_parse_dt(struct device *dev)
 717{
 718        struct zforce_ts_platdata *pdata;
 719        struct device_node *np = dev->of_node;
 720
 721        if (!np)
 722                return ERR_PTR(-ENOENT);
 723
 724        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 725        if (!pdata) {
 726                dev_err(dev, "failed to allocate platform data\n");
 727                return ERR_PTR(-ENOMEM);
 728        }
 729
 730        if (of_property_read_u32(np, "x-size", &pdata->x_max)) {
 731                dev_err(dev, "failed to get x-size property\n");
 732                return ERR_PTR(-EINVAL);
 733        }
 734
 735        if (of_property_read_u32(np, "y-size", &pdata->y_max)) {
 736                dev_err(dev, "failed to get y-size property\n");
 737                return ERR_PTR(-EINVAL);
 738        }
 739
 740        return pdata;
 741}
 742
 743static int zforce_probe(struct i2c_client *client,
 744                        const struct i2c_device_id *id)
 745{
 746        const struct zforce_ts_platdata *pdata = dev_get_platdata(&client->dev);
 747        struct zforce_ts *ts;
 748        struct input_dev *input_dev;
 749        int ret;
 750
 751        if (!pdata) {
 752                pdata = zforce_parse_dt(&client->dev);
 753                if (IS_ERR(pdata))
 754                        return PTR_ERR(pdata);
 755        }
 756
 757        ts = devm_kzalloc(&client->dev, sizeof(struct zforce_ts), GFP_KERNEL);
 758        if (!ts)
 759                return -ENOMEM;
 760
 761        ts->gpio_rst = devm_gpiod_get_optional(&client->dev, "reset",
 762                                               GPIOD_OUT_HIGH);
 763        if (IS_ERR(ts->gpio_rst)) {
 764                ret = PTR_ERR(ts->gpio_rst);
 765                dev_err(&client->dev,
 766                        "failed to request reset GPIO: %d\n", ret);
 767                return ret;
 768        }
 769
 770        if (ts->gpio_rst) {
 771                ts->gpio_int = devm_gpiod_get_optional(&client->dev, "irq",
 772                                                       GPIOD_IN);
 773                if (IS_ERR(ts->gpio_int)) {
 774                        ret = PTR_ERR(ts->gpio_int);
 775                        dev_err(&client->dev,
 776                                "failed to request interrupt GPIO: %d\n", ret);
 777                        return ret;
 778                }
 779        } else {
 780                /*
 781                 * Deprecated GPIO handling for compatibility
 782                 * with legacy binding.
 783                 */
 784
 785                /* INT GPIO */
 786                ts->gpio_int = devm_gpiod_get_index(&client->dev, NULL, 0,
 787                                                    GPIOD_IN);
 788                if (IS_ERR(ts->gpio_int)) {
 789                        ret = PTR_ERR(ts->gpio_int);
 790                        dev_err(&client->dev,
 791                                "failed to request interrupt GPIO: %d\n", ret);
 792                        return ret;
 793                }
 794
 795                /* RST GPIO */
 796                ts->gpio_rst = devm_gpiod_get_index(&client->dev, NULL, 1,
 797                                            GPIOD_OUT_HIGH);
 798                if (IS_ERR(ts->gpio_rst)) {
 799                        ret = PTR_ERR(ts->gpio_rst);
 800                        dev_err(&client->dev,
 801                                "failed to request reset GPIO: %d\n", ret);
 802                        return ret;
 803                }
 804        }
 805
 806        ts->reg_vdd = devm_regulator_get_optional(&client->dev, "vdd");
 807        if (IS_ERR(ts->reg_vdd)) {
 808                ret = PTR_ERR(ts->reg_vdd);
 809                if (ret == -EPROBE_DEFER)
 810                        return ret;
 811        } else {
 812                ret = regulator_enable(ts->reg_vdd);
 813                if (ret)
 814                        return ret;
 815
 816                /*
 817                 * according to datasheet add 100us grace time after regular
 818                 * regulator enable delay.
 819                 */
 820                udelay(100);
 821        }
 822
 823        ret = devm_add_action(&client->dev, zforce_reset, ts);
 824        if (ret) {
 825                dev_err(&client->dev, "failed to register reset action, %d\n",
 826                        ret);
 827
 828                /* hereafter the regulator will be disabled by the action */
 829                if (!IS_ERR(ts->reg_vdd))
 830                        regulator_disable(ts->reg_vdd);
 831
 832                return ret;
 833        }
 834
 835        snprintf(ts->phys, sizeof(ts->phys),
 836                 "%s/input0", dev_name(&client->dev));
 837
 838        input_dev = devm_input_allocate_device(&client->dev);
 839        if (!input_dev) {
 840                dev_err(&client->dev, "could not allocate input device\n");
 841                return -ENOMEM;
 842        }
 843
 844        mutex_init(&ts->access_mutex);
 845        mutex_init(&ts->command_mutex);
 846
 847        ts->pdata = pdata;
 848        ts->client = client;
 849        ts->input = input_dev;
 850
 851        input_dev->name = "Neonode zForce touchscreen";
 852        input_dev->phys = ts->phys;
 853        input_dev->id.bustype = BUS_I2C;
 854
 855        input_dev->open = zforce_input_open;
 856        input_dev->close = zforce_input_close;
 857
 858        __set_bit(EV_KEY, input_dev->evbit);
 859        __set_bit(EV_SYN, input_dev->evbit);
 860        __set_bit(EV_ABS, input_dev->evbit);
 861
 862        /* For multi touch */
 863        input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
 864                             pdata->x_max, 0, 0);
 865        input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
 866                             pdata->y_max, 0, 0);
 867
 868        input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
 869                             ZFORCE_MAX_AREA, 0, 0);
 870        input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
 871                             ZFORCE_MAX_AREA, 0, 0);
 872        input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
 873        input_mt_init_slots(input_dev, ZFORCE_REPORT_POINTS, INPUT_MT_DIRECT);
 874
 875        input_set_drvdata(ts->input, ts);
 876
 877        init_completion(&ts->command_done);
 878
 879        /*
 880         * The zforce pulls the interrupt low when it has data ready.
 881         * After it is triggered the isr thread runs until all the available
 882         * packets have been read and the interrupt is high again.
 883         * Therefore we can trigger the interrupt anytime it is low and do
 884         * not need to limit it to the interrupt edge.
 885         */
 886        ret = devm_request_threaded_irq(&client->dev, client->irq,
 887                                        zforce_irq, zforce_irq_thread,
 888                                        IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 889                                        input_dev->name, ts);
 890        if (ret) {
 891                dev_err(&client->dev, "irq %d request failed\n", client->irq);
 892                return ret;
 893        }
 894
 895        i2c_set_clientdata(client, ts);
 896
 897        /* let the controller boot */
 898        zforce_reset_deassert(ts);
 899
 900        ts->command_waiting = NOTIFICATION_BOOTCOMPLETE;
 901        if (wait_for_completion_timeout(&ts->command_done, WAIT_TIMEOUT) == 0)
 902                dev_warn(&client->dev, "bootcomplete timed out\n");
 903
 904        /* need to start device to get version information */
 905        ret = zforce_command_wait(ts, COMMAND_INITIALIZE);
 906        if (ret) {
 907                dev_err(&client->dev, "unable to initialize, %d\n", ret);
 908                return ret;
 909        }
 910
 911        /* this gets the firmware version among other information */
 912        ret = zforce_command_wait(ts, COMMAND_STATUS);
 913        if (ret < 0) {
 914                dev_err(&client->dev, "couldn't get status, %d\n", ret);
 915                zforce_stop(ts);
 916                return ret;
 917        }
 918
 919        /* stop device and put it into sleep until it is opened */
 920        ret = zforce_stop(ts);
 921        if (ret < 0)
 922                return ret;
 923
 924        device_set_wakeup_capable(&client->dev, true);
 925
 926        ret = input_register_device(input_dev);
 927        if (ret) {
 928                dev_err(&client->dev, "could not register input device, %d\n",
 929                        ret);
 930                return ret;
 931        }
 932
 933        return 0;
 934}
 935
 936static struct i2c_device_id zforce_idtable[] = {
 937        { "zforce-ts", 0 },
 938        { }
 939};
 940MODULE_DEVICE_TABLE(i2c, zforce_idtable);
 941
 942#ifdef CONFIG_OF
 943static const struct of_device_id zforce_dt_idtable[] = {
 944        { .compatible = "neonode,zforce" },
 945        {},
 946};
 947MODULE_DEVICE_TABLE(of, zforce_dt_idtable);
 948#endif
 949
 950static struct i2c_driver zforce_driver = {
 951        .driver = {
 952                .name   = "zforce-ts",
 953                .pm     = &zforce_pm_ops,
 954                .of_match_table = of_match_ptr(zforce_dt_idtable),
 955        },
 956        .probe          = zforce_probe,
 957        .id_table       = zforce_idtable,
 958};
 959
 960module_i2c_driver(zforce_driver);
 961
 962MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
 963MODULE_DESCRIPTION("zForce TouchScreen Driver");
 964MODULE_LICENSE("GPL");
 965
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.