linux/drivers/input/touchscreen/pixcir_i2c_ts.c
<<
>>
Prefs
   1/*
   2 * Driver for Pixcir I2C touchscreen controllers.
   3 *
   4 * Copyright (C) 2010-2011 Pixcir, Inc.
   5 *
   6 * This software is licensed under the terms of the GNU General Public
   7 * License version 2, as published by the Free Software Foundation, and
   8 * may be copied, distributed, and modified under those terms.
   9 *
  10 * This program is distributed in the hope that it will be useful,
  11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 * GNU General Public License for more details.
  14 *
  15 * You should have received a copy of the GNU General Public
  16 * License along with this library; if not, write to the Free Software
  17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  18 */
  19
  20#include <linux/delay.h>
  21#include <linux/module.h>
  22#include <linux/interrupt.h>
  23#include <linux/slab.h>
  24#include <linux/i2c.h>
  25#include <linux/input.h>
  26#include <linux/input/mt.h>
  27#include <linux/input/pixcir_ts.h>
  28#include <linux/gpio.h>
  29#include <linux/of.h>
  30#include <linux/of_gpio.h>
  31#include <linux/of_device.h>
  32
  33#define PIXCIR_MAX_SLOTS       5 /* Max fingers supported by driver */
  34
  35struct pixcir_i2c_ts_data {
  36        struct i2c_client *client;
  37        struct input_dev *input;
  38        const struct pixcir_ts_platform_data *pdata;
  39        bool running;
  40        int max_fingers;        /* Max fingers supported in this instance */
  41};
  42
  43struct pixcir_touch {
  44        int x;
  45        int y;
  46        int id;
  47};
  48
  49struct pixcir_report_data {
  50        int num_touches;
  51        struct pixcir_touch touches[PIXCIR_MAX_SLOTS];
  52};
  53
  54static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata,
  55                            struct pixcir_report_data *report)
  56{
  57        u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5];
  58        u8 wrbuf[1] = { 0 };
  59        u8 *bufptr;
  60        u8 touch;
  61        int ret, i;
  62        int readsize;
  63        const struct pixcir_i2c_chip_data *chip = &tsdata->pdata->chip;
  64
  65        memset(report, 0, sizeof(struct pixcir_report_data));
  66
  67        i = chip->has_hw_ids ? 1 : 0;
  68        readsize = 2 + tsdata->max_fingers * (4 + i);
  69        if (readsize > sizeof(rdbuf))
  70                readsize = sizeof(rdbuf);
  71
  72        ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf));
  73        if (ret != sizeof(wrbuf)) {
  74                dev_err(&tsdata->client->dev,
  75                        "%s: i2c_master_send failed(), ret=%d\n",
  76                        __func__, ret);
  77                return;
  78        }
  79
  80        ret = i2c_master_recv(tsdata->client, rdbuf, readsize);
  81        if (ret != sizeof(rdbuf)) {
  82                dev_err(&tsdata->client->dev,
  83                        "%s: i2c_master_recv failed(), ret=%d\n",
  84                        __func__, ret);
  85                return;
  86        }
  87
  88        touch = rdbuf[0] & 0x7;
  89        if (touch > tsdata->max_fingers)
  90                touch = tsdata->max_fingers;
  91
  92        report->num_touches = touch;
  93        bufptr = &rdbuf[2];
  94
  95        for (i = 0; i < touch; i++) {
  96                report->touches[i].x = (bufptr[1] << 8) | bufptr[0];
  97                report->touches[i].y = (bufptr[3] << 8) | bufptr[2];
  98
  99                if (chip->has_hw_ids) {
 100                        report->touches[i].id = bufptr[4];
 101                        bufptr = bufptr + 5;
 102                } else {
 103                        bufptr = bufptr + 4;
 104                }
 105        }
 106}
 107
 108static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts,
 109                             struct pixcir_report_data *report)
 110{
 111        struct input_mt_pos pos[PIXCIR_MAX_SLOTS];
 112        int slots[PIXCIR_MAX_SLOTS];
 113        struct pixcir_touch *touch;
 114        int n, i, slot;
 115        struct device *dev = &ts->client->dev;
 116        const struct pixcir_i2c_chip_data *chip = &ts->pdata->chip;
 117
 118        n = report->num_touches;
 119        if (n > PIXCIR_MAX_SLOTS)
 120                n = PIXCIR_MAX_SLOTS;
 121
 122        if (!chip->has_hw_ids) {
 123                for (i = 0; i < n; i++) {
 124                        touch = &report->touches[i];
 125                        pos[i].x = touch->x;
 126                        pos[i].y = touch->y;
 127                }
 128
 129                input_mt_assign_slots(ts->input, slots, pos, n);
 130        }
 131
 132        for (i = 0; i < n; i++) {
 133                touch = &report->touches[i];
 134
 135                if (chip->has_hw_ids) {
 136                        slot = input_mt_get_slot_by_key(ts->input, touch->id);
 137                        if (slot < 0) {
 138                                dev_dbg(dev, "no free slot for id 0x%x\n",
 139                                        touch->id);
 140                                continue;
 141                        }
 142                } else {
 143                        slot = slots[i];
 144                }
 145
 146                input_mt_slot(ts->input, slot);
 147                input_mt_report_slot_state(ts->input,
 148                                           MT_TOOL_FINGER, true);
 149
 150                input_event(ts->input, EV_ABS, ABS_MT_POSITION_X, touch->x);
 151                input_event(ts->input, EV_ABS, ABS_MT_POSITION_Y, touch->y);
 152
 153                dev_dbg(dev, "%d: slot %d, x %d, y %d\n",
 154                        i, slot, touch->x, touch->y);
 155        }
 156
 157        input_mt_sync_frame(ts->input);
 158        input_sync(ts->input);
 159}
 160
 161static irqreturn_t pixcir_ts_isr(int irq, void *dev_id)
 162{
 163        struct pixcir_i2c_ts_data *tsdata = dev_id;
 164        const struct pixcir_ts_platform_data *pdata = tsdata->pdata;
 165        struct pixcir_report_data report;
 166
 167        while (tsdata->running) {
 168                /* parse packet */
 169                pixcir_ts_parse(tsdata, &report);
 170
 171                /* report it */
 172                pixcir_ts_report(tsdata, &report);
 173
 174                if (gpio_get_value(pdata->gpio_attb)) {
 175                        if (report.num_touches) {
 176                                /*
 177                                 * Last report with no finger up?
 178                                 * Do it now then.
 179                                 */
 180                                input_mt_sync_frame(tsdata->input);
 181                                input_sync(tsdata->input);
 182                        }
 183                        break;
 184                }
 185
 186                msleep(20);
 187        }
 188
 189        return IRQ_HANDLED;
 190}
 191
 192static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts,
 193                                 enum pixcir_power_mode mode)
 194{
 195        struct device *dev = &ts->client->dev;
 196        int ret;
 197
 198        ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE);
 199        if (ret < 0) {
 200                dev_err(dev, "%s: can't read reg 0x%x : %d\n",
 201                        __func__, PIXCIR_REG_POWER_MODE, ret);
 202                return ret;
 203        }
 204
 205        ret &= ~PIXCIR_POWER_MODE_MASK;
 206        ret |= mode;
 207
 208        /* Always AUTO_IDLE */
 209        ret |= PIXCIR_POWER_ALLOW_IDLE;
 210
 211        ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret);
 212        if (ret < 0) {
 213                dev_err(dev, "%s: can't write reg 0x%x : %d\n",
 214                        __func__, PIXCIR_REG_POWER_MODE, ret);
 215                return ret;
 216        }
 217
 218        return 0;
 219}
 220
 221/*
 222 * Set the interrupt mode for the device i.e. ATTB line behaviour
 223 *
 224 * @polarity : 1 for active high, 0 for active low.
 225 */
 226static int pixcir_set_int_mode(struct pixcir_i2c_ts_data *ts,
 227                               enum pixcir_int_mode mode, bool polarity)
 228{
 229        struct device *dev = &ts->client->dev;
 230        int ret;
 231
 232        ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE);
 233        if (ret < 0) {
 234                dev_err(dev, "%s: can't read reg 0x%x : %d\n",
 235                        __func__, PIXCIR_REG_INT_MODE, ret);
 236                return ret;
 237        }
 238
 239        ret &= ~PIXCIR_INT_MODE_MASK;
 240        ret |= mode;
 241
 242        if (polarity)
 243                ret |= PIXCIR_INT_POL_HIGH;
 244        else
 245                ret &= ~PIXCIR_INT_POL_HIGH;
 246
 247        ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret);
 248        if (ret < 0) {
 249                dev_err(dev, "%s: can't write reg 0x%x : %d\n",
 250                        __func__, PIXCIR_REG_INT_MODE, ret);
 251                return ret;
 252        }
 253
 254        return 0;
 255}
 256
 257/*
 258 * Enable/disable interrupt generation
 259 */
 260static int pixcir_int_enable(struct pixcir_i2c_ts_data *ts, bool enable)
 261{
 262        struct device *dev = &ts->client->dev;
 263        int ret;
 264
 265        ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE);
 266        if (ret < 0) {
 267                dev_err(dev, "%s: can't read reg 0x%x : %d\n",
 268                        __func__, PIXCIR_REG_INT_MODE, ret);
 269                return ret;
 270        }
 271
 272        if (enable)
 273                ret |= PIXCIR_INT_ENABLE;
 274        else
 275                ret &= ~PIXCIR_INT_ENABLE;
 276
 277        ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret);
 278        if (ret < 0) {
 279                dev_err(dev, "%s: can't write reg 0x%x : %d\n",
 280                        __func__, PIXCIR_REG_INT_MODE, ret);
 281                return ret;
 282        }
 283
 284        return 0;
 285}
 286
 287static int pixcir_start(struct pixcir_i2c_ts_data *ts)
 288{
 289        struct device *dev = &ts->client->dev;
 290        int error;
 291
 292        /* LEVEL_TOUCH interrupt with active low polarity */
 293        error = pixcir_set_int_mode(ts, PIXCIR_INT_LEVEL_TOUCH, 0);
 294        if (error) {
 295                dev_err(dev, "Failed to set interrupt mode: %d\n", error);
 296                return error;
 297        }
 298
 299        ts->running = true;
 300        mb();   /* Update status before IRQ can fire */
 301
 302        /* enable interrupt generation */
 303        error = pixcir_int_enable(ts, true);
 304        if (error) {
 305                dev_err(dev, "Failed to enable interrupt generation: %d\n",
 306                        error);
 307                return error;
 308        }
 309
 310        return 0;
 311}
 312
 313static int pixcir_stop(struct pixcir_i2c_ts_data *ts)
 314{
 315        int error;
 316
 317        /* Disable interrupt generation */
 318        error = pixcir_int_enable(ts, false);
 319        if (error) {
 320                dev_err(&ts->client->dev,
 321                        "Failed to disable interrupt generation: %d\n",
 322                        error);
 323                return error;
 324        }
 325
 326        /* Exit ISR if running, no more report parsing */
 327        ts->running = false;
 328        mb();   /* update status before we synchronize irq */
 329
 330        /* Wait till running ISR is complete */
 331        synchronize_irq(ts->client->irq);
 332
 333        return 0;
 334}
 335
 336static int pixcir_input_open(struct input_dev *dev)
 337{
 338        struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev);
 339
 340        return pixcir_start(ts);
 341}
 342
 343static void pixcir_input_close(struct input_dev *dev)
 344{
 345        struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev);
 346
 347        pixcir_stop(ts);
 348}
 349
 350static int __maybe_unused pixcir_i2c_ts_suspend(struct device *dev)
 351{
 352        struct i2c_client *client = to_i2c_client(dev);
 353        struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client);
 354        struct input_dev *input = ts->input;
 355        int ret = 0;
 356
 357        mutex_lock(&input->mutex);
 358
 359        if (device_may_wakeup(&client->dev)) {
 360                if (!input->users) {
 361                        ret = pixcir_start(ts);
 362                        if (ret) {
 363                                dev_err(dev, "Failed to start\n");
 364                                goto unlock;
 365                        }
 366                }
 367
 368                enable_irq_wake(client->irq);
 369        } else if (input->users) {
 370                ret = pixcir_stop(ts);
 371        }
 372
 373unlock:
 374        mutex_unlock(&input->mutex);
 375
 376        return ret;
 377}
 378
 379static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev)
 380{
 381        struct i2c_client *client = to_i2c_client(dev);
 382        struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client);
 383        struct input_dev *input = ts->input;
 384        int ret = 0;
 385
 386        mutex_lock(&input->mutex);
 387
 388        if (device_may_wakeup(&client->dev)) {
 389                disable_irq_wake(client->irq);
 390
 391                if (!input->users) {
 392                        ret = pixcir_stop(ts);
 393                        if (ret) {
 394                                dev_err(dev, "Failed to stop\n");
 395                                goto unlock;
 396                        }
 397                }
 398        } else if (input->users) {
 399                ret = pixcir_start(ts);
 400        }
 401
 402unlock:
 403        mutex_unlock(&input->mutex);
 404
 405        return ret;
 406}
 407
 408static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops,
 409                         pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume);
 410
 411#ifdef CONFIG_OF
 412static const struct of_device_id pixcir_of_match[];
 413
 414static struct pixcir_ts_platform_data *pixcir_parse_dt(struct device *dev)
 415{
 416        struct pixcir_ts_platform_data *pdata;
 417        struct device_node *np = dev->of_node;
 418        const struct of_device_id *match;
 419
 420        match = of_match_device(of_match_ptr(pixcir_of_match), dev);
 421        if (!match)
 422                return ERR_PTR(-EINVAL);
 423
 424        pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 425        if (!pdata)
 426                return ERR_PTR(-ENOMEM);
 427
 428        pdata->chip = *(const struct pixcir_i2c_chip_data *)match->data;
 429
 430        pdata->gpio_attb = of_get_named_gpio(np, "attb-gpio", 0);
 431        /* gpio_attb validity is checked in probe */
 432
 433        if (of_property_read_u32(np, "touchscreen-size-x", &pdata->x_max)) {
 434                dev_err(dev, "Failed to get touchscreen-size-x property\n");
 435                return ERR_PTR(-EINVAL);
 436        }
 437        pdata->x_max -= 1;
 438
 439        if (of_property_read_u32(np, "touchscreen-size-y", &pdata->y_max)) {
 440                dev_err(dev, "Failed to get touchscreen-size-y property\n");
 441                return ERR_PTR(-EINVAL);
 442        }
 443        pdata->y_max -= 1;
 444
 445        dev_dbg(dev, "%s: x %d, y %d, gpio %d\n", __func__,
 446                pdata->x_max + 1, pdata->y_max + 1, pdata->gpio_attb);
 447
 448        return pdata;
 449}
 450#else
 451static struct pixcir_ts_platform_data *pixcir_parse_dt(struct device *dev)
 452{
 453        return ERR_PTR(-EINVAL);
 454}
 455#endif
 456
 457static int pixcir_i2c_ts_probe(struct i2c_client *client,
 458                                         const struct i2c_device_id *id)
 459{
 460        const struct pixcir_ts_platform_data *pdata =
 461                        dev_get_platdata(&client->dev);
 462        struct device *dev = &client->dev;
 463        struct device_node *np = dev->of_node;
 464        struct pixcir_i2c_ts_data *tsdata;
 465        struct input_dev *input;
 466        int error;
 467
 468        if (np && !pdata) {
 469                pdata = pixcir_parse_dt(dev);
 470                if (IS_ERR(pdata))
 471                        return PTR_ERR(pdata);
 472        }
 473
 474        if (!pdata) {
 475                dev_err(&client->dev, "platform data not defined\n");
 476                return -EINVAL;
 477        }
 478
 479        if (!gpio_is_valid(pdata->gpio_attb)) {
 480                dev_err(dev, "Invalid gpio_attb in pdata\n");
 481                return -EINVAL;
 482        }
 483
 484        if (!pdata->chip.max_fingers) {
 485                dev_err(dev, "Invalid max_fingers in pdata\n");
 486                return -EINVAL;
 487        }
 488
 489        tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL);
 490        if (!tsdata)
 491                return -ENOMEM;
 492
 493        input = devm_input_allocate_device(dev);
 494        if (!input) {
 495                dev_err(dev, "Failed to allocate input device\n");
 496                return -ENOMEM;
 497        }
 498
 499        tsdata->client = client;
 500        tsdata->input = input;
 501        tsdata->pdata = pdata;
 502
 503        input->name = client->name;
 504        input->id.bustype = BUS_I2C;
 505        input->open = pixcir_input_open;
 506        input->close = pixcir_input_close;
 507        input->dev.parent = &client->dev;
 508
 509        __set_bit(EV_KEY, input->evbit);
 510        __set_bit(EV_ABS, input->evbit);
 511        __set_bit(BTN_TOUCH, input->keybit);
 512        input_set_abs_params(input, ABS_X, 0, pdata->x_max, 0, 0);
 513        input_set_abs_params(input, ABS_Y, 0, pdata->y_max, 0, 0);
 514        input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0);
 515        input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0);
 516
 517        tsdata->max_fingers = tsdata->pdata->chip.max_fingers;
 518        if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) {
 519                tsdata->max_fingers = PIXCIR_MAX_SLOTS;
 520                dev_info(dev, "Limiting maximum fingers to %d\n",
 521                         tsdata->max_fingers);
 522        }
 523
 524        error = input_mt_init_slots(input, tsdata->max_fingers,
 525                                    INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 526        if (error) {
 527                dev_err(dev, "Error initializing Multi-Touch slots\n");
 528                return error;
 529        }
 530
 531        input_set_drvdata(input, tsdata);
 532
 533        error = devm_gpio_request_one(dev, pdata->gpio_attb,
 534                                      GPIOF_DIR_IN, "pixcir_i2c_attb");
 535        if (error) {
 536                dev_err(dev, "Failed to request ATTB gpio\n");
 537                return error;
 538        }
 539
 540        error = devm_request_threaded_irq(dev, client->irq, NULL, pixcir_ts_isr,
 541                                          IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 542                                          client->name, tsdata);
 543        if (error) {
 544                dev_err(dev, "failed to request irq %d\n", client->irq);
 545                return error;
 546        }
 547
 548        /* Always be in IDLE mode to save power, device supports auto wake */
 549        error = pixcir_set_power_mode(tsdata, PIXCIR_POWER_IDLE);
 550        if (error) {
 551                dev_err(dev, "Failed to set IDLE mode\n");
 552                return error;
 553        }
 554
 555        /* Stop device till opened */
 556        error = pixcir_stop(tsdata);
 557        if (error)
 558                return error;
 559
 560        error = input_register_device(input);
 561        if (error)
 562                return error;
 563
 564        i2c_set_clientdata(client, tsdata);
 565        device_init_wakeup(&client->dev, 1);
 566
 567        return 0;
 568}
 569
 570static int pixcir_i2c_ts_remove(struct i2c_client *client)
 571{
 572        device_init_wakeup(&client->dev, 0);
 573
 574        return 0;
 575}
 576
 577static const struct i2c_device_id pixcir_i2c_ts_id[] = {
 578        { "pixcir_ts", 0 },
 579        { "pixcir_tangoc", 0 },
 580        { }
 581};
 582MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id);
 583
 584#ifdef CONFIG_OF
 585static const struct pixcir_i2c_chip_data pixcir_ts_data = {
 586        .max_fingers = 2,
 587        /* no hw id support */
 588};
 589
 590static const struct pixcir_i2c_chip_data pixcir_tangoc_data = {
 591        .max_fingers = 5,
 592        .has_hw_ids = true,
 593};
 594
 595static const struct of_device_id pixcir_of_match[] = {
 596        { .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data },
 597        { .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data },
 598        { }
 599};
 600MODULE_DEVICE_TABLE(of, pixcir_of_match);
 601#endif
 602
 603static struct i2c_driver pixcir_i2c_ts_driver = {
 604        .driver = {
 605                .owner  = THIS_MODULE,
 606                .name   = "pixcir_ts",
 607                .pm     = &pixcir_dev_pm_ops,
 608                .of_match_table = of_match_ptr(pixcir_of_match),
 609        },
 610        .probe          = pixcir_i2c_ts_probe,
 611        .remove         = pixcir_i2c_ts_remove,
 612        .id_table       = pixcir_i2c_ts_id,
 613};
 614
 615module_i2c_driver(pixcir_i2c_ts_driver);
 616
 617MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>");
 618MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver");
 619MODULE_LICENSE("GPL");
 620
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.