linux/drivers/input/touchscreen/wm97xx-core.c
<<
>>
Prefs
   1/*
   2 * wm97xx-core.c  --  Touch screen driver core for Wolfson WM9705, WM9712
   3 *                    and WM9713 AC97 Codecs.
   4 *
   5 * Copyright 2003, 2004, 2005, 2006, 2007, 2008 Wolfson Microelectronics PLC.
   6 * Author: Liam Girdwood <lrg@slimlogic.co.uk>
   7 * Parts Copyright : Ian Molton <spyro@f2s.com>
   8 *                   Andrew Zabolotny <zap@homelink.ru>
   9 *                   Russell King <rmk@arm.linux.org.uk>
  10 *
  11 *  This program is free software; you can redistribute  it and/or modify it
  12 *  under  the terms of  the GNU General  Public License as published by the
  13 *  Free Software Foundation;  either version 2 of the  License, or (at your
  14 *  option) any later version.
  15 *
  16 * Notes:
  17 *
  18 *  Features:
  19 *       - supports WM9705, WM9712, WM9713
  20 *       - polling mode
  21 *       - continuous mode (arch-dependent)
  22 *       - adjustable rpu/dpp settings
  23 *       - adjustable pressure current
  24 *       - adjustable sample settle delay
  25 *       - 4 and 5 wire touchscreens (5 wire is WM9712 only)
  26 *       - pen down detection
  27 *       - battery monitor
  28 *       - sample AUX adcs
  29 *       - power management
  30 *       - codec GPIO
  31 *       - codec event notification
  32 * Todo
  33 *       - Support for async sampling control for noisy LCDs.
  34 *
  35 */
  36
  37#include <linux/module.h>
  38#include <linux/moduleparam.h>
  39#include <linux/kernel.h>
  40#include <linux/init.h>
  41#include <linux/delay.h>
  42#include <linux/string.h>
  43#include <linux/proc_fs.h>
  44#include <linux/pm.h>
  45#include <linux/interrupt.h>
  46#include <linux/bitops.h>
  47#include <linux/mfd/wm97xx.h>
  48#include <linux/workqueue.h>
  49#include <linux/wm97xx.h>
  50#include <linux/uaccess.h>
  51#include <linux/io.h>
  52#include <linux/slab.h>
  53
  54#define TS_NAME                 "wm97xx"
  55#define WM_CORE_VERSION         "1.00"
  56#define DEFAULT_PRESSURE        0xb0c0
  57
  58
  59/*
  60 * Touchscreen absolute values
  61 *
  62 * These parameters are used to help the input layer discard out of
  63 * range readings and reduce jitter etc.
  64 *
  65 *   o min, max:- indicate the min and max values your touch screen returns
  66 *   o fuzz:- use a higher number to reduce jitter
  67 *
  68 * The default values correspond to Mainstone II in QVGA mode
  69 *
  70 * Please read
  71 * Documentation/input/input-programming.rst for more details.
  72 */
  73
  74static int abs_x[3] = {150, 4000, 5};
  75module_param_array(abs_x, int, NULL, 0);
  76MODULE_PARM_DESC(abs_x, "Touchscreen absolute X min, max, fuzz");
  77
  78static int abs_y[3] = {200, 4000, 40};
  79module_param_array(abs_y, int, NULL, 0);
  80MODULE_PARM_DESC(abs_y, "Touchscreen absolute Y min, max, fuzz");
  81
  82static int abs_p[3] = {0, 150, 4};
  83module_param_array(abs_p, int, NULL, 0);
  84MODULE_PARM_DESC(abs_p, "Touchscreen absolute Pressure min, max, fuzz");
  85
  86/*
  87 * wm97xx IO access, all IO locking done by AC97 layer
  88 */
  89int wm97xx_reg_read(struct wm97xx *wm, u16 reg)
  90{
  91        if (wm->ac97)
  92                return wm->ac97->bus->ops->read(wm->ac97, reg);
  93        else
  94                return -1;
  95}
  96EXPORT_SYMBOL_GPL(wm97xx_reg_read);
  97
  98void wm97xx_reg_write(struct wm97xx *wm, u16 reg, u16 val)
  99{
 100        /* cache digitiser registers */
 101        if (reg >= AC97_WM9713_DIG1 && reg <= AC97_WM9713_DIG3)
 102                wm->dig[(reg - AC97_WM9713_DIG1) >> 1] = val;
 103
 104        /* cache gpio regs */
 105        if (reg >= AC97_GPIO_CFG && reg <= AC97_MISC_AFE)
 106                wm->gpio[(reg - AC97_GPIO_CFG) >> 1] = val;
 107
 108        /* wm9713 irq reg */
 109        if (reg == 0x5a)
 110                wm->misc = val;
 111
 112        if (wm->ac97)
 113                wm->ac97->bus->ops->write(wm->ac97, reg, val);
 114}
 115EXPORT_SYMBOL_GPL(wm97xx_reg_write);
 116
 117/**
 118 * wm97xx_read_aux_adc - Read the aux adc.
 119 * @wm: wm97xx device.
 120 * @adcsel: codec ADC to be read
 121 *
 122 * Reads the selected AUX ADC.
 123 */
 124
 125int wm97xx_read_aux_adc(struct wm97xx *wm, u16 adcsel)
 126{
 127        int power_adc = 0, auxval;
 128        u16 power = 0;
 129        int rc = 0;
 130        int timeout = 0;
 131
 132        /* get codec */
 133        mutex_lock(&wm->codec_mutex);
 134
 135        /* When the touchscreen is not in use, we may have to power up
 136         * the AUX ADC before we can use sample the AUX inputs->
 137         */
 138        if (wm->id == WM9713_ID2 &&
 139            (power = wm97xx_reg_read(wm, AC97_EXTENDED_MID)) & 0x8000) {
 140                power_adc = 1;
 141                wm97xx_reg_write(wm, AC97_EXTENDED_MID, power & 0x7fff);
 142        }
 143
 144        /* Prepare the codec for AUX reading */
 145        wm->codec->aux_prepare(wm);
 146
 147        /* Turn polling mode on to read AUX ADC */
 148        wm->pen_probably_down = 1;
 149
 150        while (rc != RC_VALID && timeout++ < 5)
 151                rc = wm->codec->poll_sample(wm, adcsel, &auxval);
 152
 153        if (power_adc)
 154                wm97xx_reg_write(wm, AC97_EXTENDED_MID, power | 0x8000);
 155
 156        wm->codec->dig_restore(wm);
 157
 158        wm->pen_probably_down = 0;
 159
 160        if (timeout >= 5) {
 161                dev_err(wm->dev,
 162                        "timeout reading auxadc %d, disabling digitiser\n",
 163                        adcsel);
 164                wm->codec->dig_enable(wm, false);
 165        }
 166
 167        mutex_unlock(&wm->codec_mutex);
 168        return (rc == RC_VALID ? auxval & 0xfff : -EBUSY);
 169}
 170EXPORT_SYMBOL_GPL(wm97xx_read_aux_adc);
 171
 172/**
 173 * wm97xx_get_gpio - Get the status of a codec GPIO.
 174 * @wm: wm97xx device.
 175 * @gpio: gpio
 176 *
 177 * Get the status of a codec GPIO pin
 178 */
 179
 180enum wm97xx_gpio_status wm97xx_get_gpio(struct wm97xx *wm, u32 gpio)
 181{
 182        u16 status;
 183        enum wm97xx_gpio_status ret;
 184
 185        mutex_lock(&wm->codec_mutex);
 186        status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
 187
 188        if (status & gpio)
 189                ret = WM97XX_GPIO_HIGH;
 190        else
 191                ret = WM97XX_GPIO_LOW;
 192
 193        mutex_unlock(&wm->codec_mutex);
 194        return ret;
 195}
 196EXPORT_SYMBOL_GPL(wm97xx_get_gpio);
 197
 198/**
 199 * wm97xx_set_gpio - Set the status of a codec GPIO.
 200 * @wm: wm97xx device.
 201 * @gpio: gpio
 202 *
 203 *
 204 * Set the status of a codec GPIO pin
 205 */
 206
 207void wm97xx_set_gpio(struct wm97xx *wm, u32 gpio,
 208                                enum wm97xx_gpio_status status)
 209{
 210        u16 reg;
 211
 212        mutex_lock(&wm->codec_mutex);
 213        reg = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
 214
 215        if (status == WM97XX_GPIO_HIGH)
 216                reg |= gpio;
 217        else
 218                reg &= ~gpio;
 219
 220        if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
 221                wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg << 1);
 222        else
 223                wm97xx_reg_write(wm, AC97_GPIO_STATUS, reg);
 224        mutex_unlock(&wm->codec_mutex);
 225}
 226EXPORT_SYMBOL_GPL(wm97xx_set_gpio);
 227
 228/*
 229 * Codec GPIO pin configuration, this sets pin direction, polarity,
 230 * stickyness and wake up.
 231 */
 232void wm97xx_config_gpio(struct wm97xx *wm, u32 gpio, enum wm97xx_gpio_dir dir,
 233                   enum wm97xx_gpio_pol pol, enum wm97xx_gpio_sticky sticky,
 234                   enum wm97xx_gpio_wake wake)
 235{
 236        u16 reg;
 237
 238        mutex_lock(&wm->codec_mutex);
 239        reg = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
 240
 241        if (pol == WM97XX_GPIO_POL_HIGH)
 242                reg |= gpio;
 243        else
 244                reg &= ~gpio;
 245
 246        wm97xx_reg_write(wm, AC97_GPIO_POLARITY, reg);
 247        reg = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
 248
 249        if (sticky == WM97XX_GPIO_STICKY)
 250                reg |= gpio;
 251        else
 252                reg &= ~gpio;
 253
 254        wm97xx_reg_write(wm, AC97_GPIO_STICKY, reg);
 255        reg = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
 256
 257        if (wake == WM97XX_GPIO_WAKE)
 258                reg |= gpio;
 259        else
 260                reg &= ~gpio;
 261
 262        wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, reg);
 263        reg = wm97xx_reg_read(wm, AC97_GPIO_CFG);
 264
 265        if (dir == WM97XX_GPIO_IN)
 266                reg |= gpio;
 267        else
 268                reg &= ~gpio;
 269
 270        wm97xx_reg_write(wm, AC97_GPIO_CFG, reg);
 271        mutex_unlock(&wm->codec_mutex);
 272}
 273EXPORT_SYMBOL_GPL(wm97xx_config_gpio);
 274
 275/*
 276 * Configure the WM97XX_PRP value to use while system is suspended.
 277 * If a value other than 0 is set then WM97xx pen detection will be
 278 * left enabled in the configured mode while the system is in suspend,
 279 * the device has users and suspend has not been disabled via the
 280 * wakeup sysfs entries.
 281 *
 282 * @wm:   WM97xx device to configure
 283 * @mode: WM97XX_PRP value to configure while suspended
 284 */
 285void wm97xx_set_suspend_mode(struct wm97xx *wm, u16 mode)
 286{
 287        wm->suspend_mode = mode;
 288        device_init_wakeup(&wm->input_dev->dev, mode != 0);
 289}
 290EXPORT_SYMBOL_GPL(wm97xx_set_suspend_mode);
 291
 292/*
 293 * Handle a pen down interrupt.
 294 */
 295static void wm97xx_pen_irq_worker(struct work_struct *work)
 296{
 297        struct wm97xx *wm = container_of(work, struct wm97xx, pen_event_work);
 298        int pen_was_down = wm->pen_is_down;
 299
 300        /* do we need to enable the touch panel reader */
 301        if (wm->id == WM9705_ID2) {
 302                if (wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER_RD) &
 303                                        WM97XX_PEN_DOWN)
 304                        wm->pen_is_down = 1;
 305                else
 306                        wm->pen_is_down = 0;
 307        } else {
 308                u16 status, pol;
 309                mutex_lock(&wm->codec_mutex);
 310                status = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
 311                pol = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
 312
 313                if (WM97XX_GPIO_13 & pol & status) {
 314                        wm->pen_is_down = 1;
 315                        wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol &
 316                                                ~WM97XX_GPIO_13);
 317                } else {
 318                        wm->pen_is_down = 0;
 319                        wm97xx_reg_write(wm, AC97_GPIO_POLARITY, pol |
 320                                         WM97XX_GPIO_13);
 321                }
 322
 323                if (wm->id == WM9712_ID2 && wm->variant != WM97xx_WM1613)
 324                        wm97xx_reg_write(wm, AC97_GPIO_STATUS, (status &
 325                                                ~WM97XX_GPIO_13) << 1);
 326                else
 327                        wm97xx_reg_write(wm, AC97_GPIO_STATUS, status &
 328                                                ~WM97XX_GPIO_13);
 329                mutex_unlock(&wm->codec_mutex);
 330        }
 331
 332        /* If the system is not using continuous mode or it provides a
 333         * pen down operation then we need to schedule polls while the
 334         * pen is down.  Otherwise the machine driver is responsible
 335         * for scheduling reads.
 336         */
 337        if (!wm->mach_ops->acc_enabled || wm->mach_ops->acc_pen_down) {
 338                if (wm->pen_is_down && !pen_was_down) {
 339                        /* Data is not available immediately on pen down */
 340                        queue_delayed_work(wm->ts_workq, &wm->ts_reader, 1);
 341                }
 342
 343                /* Let ts_reader report the pen up for debounce. */
 344                if (!wm->pen_is_down && pen_was_down)
 345                        wm->pen_is_down = 1;
 346        }
 347
 348        if (!wm->pen_is_down && wm->mach_ops->acc_enabled)
 349                wm->mach_ops->acc_pen_up(wm);
 350
 351        wm->mach_ops->irq_enable(wm, 1);
 352}
 353
 354/*
 355 * Codec PENDOWN irq handler
 356 *
 357 * We have to disable the codec interrupt in the handler because it
 358 * can take up to 1ms to clear the interrupt source. We schedule a task
 359 * in a work queue to do the actual interaction with the chip.  The
 360 * interrupt is then enabled again in the slow handler when the source
 361 * has been cleared.
 362 */
 363static irqreturn_t wm97xx_pen_interrupt(int irq, void *dev_id)
 364{
 365        struct wm97xx *wm = dev_id;
 366
 367        if (!work_pending(&wm->pen_event_work)) {
 368                wm->mach_ops->irq_enable(wm, 0);
 369                queue_work(wm->ts_workq, &wm->pen_event_work);
 370        }
 371
 372        return IRQ_HANDLED;
 373}
 374
 375/*
 376 * initialise pen IRQ handler and workqueue
 377 */
 378static int wm97xx_init_pen_irq(struct wm97xx *wm)
 379{
 380        u16 reg;
 381
 382        /* If an interrupt is supplied an IRQ enable operation must also be
 383         * provided. */
 384        BUG_ON(!wm->mach_ops->irq_enable);
 385
 386        if (request_irq(wm->pen_irq, wm97xx_pen_interrupt, IRQF_SHARED,
 387                        "wm97xx-pen", wm)) {
 388                dev_err(wm->dev,
 389                        "Failed to register pen down interrupt, polling");
 390                wm->pen_irq = 0;
 391                return -EINVAL;
 392        }
 393
 394        /* Configure GPIO as interrupt source on WM971x */
 395        if (wm->id != WM9705_ID2) {
 396                BUG_ON(!wm->mach_ops->irq_gpio);
 397                reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
 398                wm97xx_reg_write(wm, AC97_MISC_AFE,
 399                                reg & ~(wm->mach_ops->irq_gpio));
 400                reg = wm97xx_reg_read(wm, 0x5a);
 401                wm97xx_reg_write(wm, 0x5a, reg & ~0x0001);
 402        }
 403
 404        return 0;
 405}
 406
 407static int wm97xx_read_samples(struct wm97xx *wm)
 408{
 409        struct wm97xx_data data;
 410        int rc;
 411
 412        mutex_lock(&wm->codec_mutex);
 413
 414        if (wm->mach_ops && wm->mach_ops->acc_enabled)
 415                rc = wm->mach_ops->acc_pen_down(wm);
 416        else
 417                rc = wm->codec->poll_touch(wm, &data);
 418
 419        if (rc & RC_PENUP) {
 420                if (wm->pen_is_down) {
 421                        wm->pen_is_down = 0;
 422                        dev_dbg(wm->dev, "pen up\n");
 423                        input_report_abs(wm->input_dev, ABS_PRESSURE, 0);
 424                        input_report_key(wm->input_dev, BTN_TOUCH, 0);
 425                        input_sync(wm->input_dev);
 426                } else if (!(rc & RC_AGAIN)) {
 427                        /* We need high frequency updates only while
 428                        * pen is down, the user never will be able to
 429                        * touch screen faster than a few times per
 430                        * second... On the other hand, when the user
 431                        * is actively working with the touchscreen we
 432                        * don't want to lose the quick response. So we
 433                        * will slowly increase sleep time after the
 434                        * pen is up and quicky restore it to ~one task
 435                        * switch when pen is down again.
 436                        */
 437                        if (wm->ts_reader_interval < HZ / 10)
 438                                wm->ts_reader_interval++;
 439                }
 440
 441        } else if (rc & RC_VALID) {
 442                dev_dbg(wm->dev,
 443                        "pen down: x=%x:%d, y=%x:%d, pressure=%x:%d\n",
 444                        data.x >> 12, data.x & 0xfff, data.y >> 12,
 445                        data.y & 0xfff, data.p >> 12, data.p & 0xfff);
 446
 447                if (abs_x[0] > (data.x & 0xfff) ||
 448                    abs_x[1] < (data.x & 0xfff) ||
 449                    abs_y[0] > (data.y & 0xfff) ||
 450                    abs_y[1] < (data.y & 0xfff)) {
 451                        dev_dbg(wm->dev, "Measurement out of range, dropping it\n");
 452                        rc = RC_AGAIN;
 453                        goto out;
 454                }
 455
 456                input_report_abs(wm->input_dev, ABS_X, data.x & 0xfff);
 457                input_report_abs(wm->input_dev, ABS_Y, data.y & 0xfff);
 458                input_report_abs(wm->input_dev, ABS_PRESSURE, data.p & 0xfff);
 459                input_report_key(wm->input_dev, BTN_TOUCH, 1);
 460                input_sync(wm->input_dev);
 461                wm->pen_is_down = 1;
 462                wm->ts_reader_interval = wm->ts_reader_min_interval;
 463        } else if (rc & RC_PENDOWN) {
 464                dev_dbg(wm->dev, "pen down\n");
 465                wm->pen_is_down = 1;
 466                wm->ts_reader_interval = wm->ts_reader_min_interval;
 467        }
 468
 469out:
 470        mutex_unlock(&wm->codec_mutex);
 471        return rc;
 472}
 473
 474/*
 475* The touchscreen sample reader.
 476*/
 477static void wm97xx_ts_reader(struct work_struct *work)
 478{
 479        int rc;
 480        struct wm97xx *wm = container_of(work, struct wm97xx, ts_reader.work);
 481
 482        BUG_ON(!wm->codec);
 483
 484        do {
 485                rc = wm97xx_read_samples(wm);
 486        } while (rc & RC_AGAIN);
 487
 488        if (wm->pen_is_down || !wm->pen_irq)
 489                queue_delayed_work(wm->ts_workq, &wm->ts_reader,
 490                                   wm->ts_reader_interval);
 491}
 492
 493/**
 494 * wm97xx_ts_input_open - Open the touch screen input device.
 495 * @idev:       Input device to be opened.
 496 *
 497 * Called by the input sub system to open a wm97xx touchscreen device.
 498 * Starts the touchscreen thread and touch digitiser.
 499 */
 500static int wm97xx_ts_input_open(struct input_dev *idev)
 501{
 502        struct wm97xx *wm = input_get_drvdata(idev);
 503
 504        wm->ts_workq = alloc_ordered_workqueue("kwm97xx", 0);
 505        if (wm->ts_workq == NULL) {
 506                dev_err(wm->dev,
 507                        "Failed to create workqueue\n");
 508                return -EINVAL;
 509        }
 510
 511        /* start digitiser */
 512        if (wm->mach_ops && wm->mach_ops->acc_enabled)
 513                wm->codec->acc_enable(wm, 1);
 514        wm->codec->dig_enable(wm, 1);
 515
 516        INIT_DELAYED_WORK(&wm->ts_reader, wm97xx_ts_reader);
 517        INIT_WORK(&wm->pen_event_work, wm97xx_pen_irq_worker);
 518
 519        wm->ts_reader_min_interval = HZ >= 100 ? HZ / 100 : 1;
 520        if (wm->ts_reader_min_interval < 1)
 521                wm->ts_reader_min_interval = 1;
 522        wm->ts_reader_interval = wm->ts_reader_min_interval;
 523
 524        wm->pen_is_down = 0;
 525        if (wm->pen_irq)
 526                wm97xx_init_pen_irq(wm);
 527        else
 528                dev_err(wm->dev, "No IRQ specified\n");
 529
 530        /* If we either don't have an interrupt for pen down events or
 531         * failed to acquire it then we need to poll.
 532         */
 533        if (wm->pen_irq == 0)
 534                queue_delayed_work(wm->ts_workq, &wm->ts_reader,
 535                                   wm->ts_reader_interval);
 536
 537        return 0;
 538}
 539
 540/**
 541 * wm97xx_ts_input_close - Close the touch screen input device.
 542 * @idev:       Input device to be closed.
 543 *
 544 * Called by the input sub system to close a wm97xx touchscreen
 545 * device.  Kills the touchscreen thread and stops the touch
 546 * digitiser.
 547 */
 548
 549static void wm97xx_ts_input_close(struct input_dev *idev)
 550{
 551        struct wm97xx *wm = input_get_drvdata(idev);
 552        u16 reg;
 553
 554        if (wm->pen_irq) {
 555                /* Return the interrupt to GPIO usage (disabling it) */
 556                if (wm->id != WM9705_ID2) {
 557                        BUG_ON(!wm->mach_ops->irq_gpio);
 558                        reg = wm97xx_reg_read(wm, AC97_MISC_AFE);
 559                        wm97xx_reg_write(wm, AC97_MISC_AFE,
 560                                         reg | wm->mach_ops->irq_gpio);
 561                }
 562
 563                free_irq(wm->pen_irq, wm);
 564        }
 565
 566        wm->pen_is_down = 0;
 567
 568        /* Balance out interrupt disables/enables */
 569        if (cancel_work_sync(&wm->pen_event_work))
 570                wm->mach_ops->irq_enable(wm, 1);
 571
 572        /* ts_reader rearms itself so we need to explicitly stop it
 573         * before we destroy the workqueue.
 574         */
 575        cancel_delayed_work_sync(&wm->ts_reader);
 576
 577        destroy_workqueue(wm->ts_workq);
 578
 579        /* stop digitiser */
 580        wm->codec->dig_enable(wm, 0);
 581        if (wm->mach_ops && wm->mach_ops->acc_enabled)
 582                wm->codec->acc_enable(wm, 0);
 583}
 584
 585static int wm97xx_register_touch(struct wm97xx *wm)
 586{
 587        struct wm97xx_pdata *pdata = dev_get_platdata(wm->dev);
 588        int ret;
 589
 590        wm->input_dev = devm_input_allocate_device(wm->dev);
 591        if (wm->input_dev == NULL)
 592                return -ENOMEM;
 593
 594        /* set up touch configuration */
 595        wm->input_dev->name = "wm97xx touchscreen";
 596        wm->input_dev->phys = "wm97xx";
 597        wm->input_dev->open = wm97xx_ts_input_open;
 598        wm->input_dev->close = wm97xx_ts_input_close;
 599
 600        __set_bit(EV_ABS, wm->input_dev->evbit);
 601        __set_bit(EV_KEY, wm->input_dev->evbit);
 602        __set_bit(BTN_TOUCH, wm->input_dev->keybit);
 603
 604        input_set_abs_params(wm->input_dev, ABS_X, abs_x[0], abs_x[1],
 605                             abs_x[2], 0);
 606        input_set_abs_params(wm->input_dev, ABS_Y, abs_y[0], abs_y[1],
 607                             abs_y[2], 0);
 608        input_set_abs_params(wm->input_dev, ABS_PRESSURE, abs_p[0], abs_p[1],
 609                             abs_p[2], 0);
 610
 611        input_set_drvdata(wm->input_dev, wm);
 612        wm->input_dev->dev.parent = wm->dev;
 613
 614        ret = input_register_device(wm->input_dev);
 615        if (ret)
 616                return ret;
 617
 618        /*
 619         * register our extended touch device (for machine specific
 620         * extensions)
 621         */
 622        wm->touch_dev = platform_device_alloc("wm97xx-touch", -1);
 623        if (!wm->touch_dev) {
 624                ret = -ENOMEM;
 625                goto touch_err;
 626        }
 627        platform_set_drvdata(wm->touch_dev, wm);
 628        wm->touch_dev->dev.parent = wm->dev;
 629        wm->touch_dev->dev.platform_data = pdata;
 630        ret = platform_device_add(wm->touch_dev);
 631        if (ret < 0)
 632                goto touch_reg_err;
 633
 634        return 0;
 635touch_reg_err:
 636        platform_device_put(wm->touch_dev);
 637touch_err:
 638        input_unregister_device(wm->input_dev);
 639        wm->input_dev = NULL;
 640
 641        return ret;
 642}
 643
 644static void wm97xx_unregister_touch(struct wm97xx *wm)
 645{
 646        platform_device_unregister(wm->touch_dev);
 647        input_unregister_device(wm->input_dev);
 648        wm->input_dev = NULL;
 649}
 650
 651static int _wm97xx_probe(struct wm97xx *wm)
 652{
 653        int id = 0;
 654
 655        mutex_init(&wm->codec_mutex);
 656        dev_set_drvdata(wm->dev, wm);
 657
 658        /* check that we have a supported codec */
 659        id = wm97xx_reg_read(wm, AC97_VENDOR_ID1);
 660        if (id != WM97XX_ID1) {
 661                dev_err(wm->dev,
 662                        "Device with vendor %04x is not a wm97xx\n", id);
 663                return -ENODEV;
 664        }
 665
 666        wm->id = wm97xx_reg_read(wm, AC97_VENDOR_ID2);
 667
 668        wm->variant = WM97xx_GENERIC;
 669
 670        dev_info(wm->dev, "detected a wm97%02x codec\n", wm->id & 0xff);
 671
 672        switch (wm->id & 0xff) {
 673#ifdef CONFIG_TOUCHSCREEN_WM9705
 674        case 0x05:
 675                wm->codec = &wm9705_codec;
 676                break;
 677#endif
 678#ifdef CONFIG_TOUCHSCREEN_WM9712
 679        case 0x12:
 680                wm->codec = &wm9712_codec;
 681                break;
 682#endif
 683#ifdef CONFIG_TOUCHSCREEN_WM9713
 684        case 0x13:
 685                wm->codec = &wm9713_codec;
 686                break;
 687#endif
 688        default:
 689                dev_err(wm->dev, "Support for wm97%02x not compiled in.\n",
 690                        wm->id & 0xff);
 691                return -ENODEV;
 692        }
 693
 694        /* set up physical characteristics */
 695        wm->codec->phy_init(wm);
 696
 697        /* load gpio cache */
 698        wm->gpio[0] = wm97xx_reg_read(wm, AC97_GPIO_CFG);
 699        wm->gpio[1] = wm97xx_reg_read(wm, AC97_GPIO_POLARITY);
 700        wm->gpio[2] = wm97xx_reg_read(wm, AC97_GPIO_STICKY);
 701        wm->gpio[3] = wm97xx_reg_read(wm, AC97_GPIO_WAKEUP);
 702        wm->gpio[4] = wm97xx_reg_read(wm, AC97_GPIO_STATUS);
 703        wm->gpio[5] = wm97xx_reg_read(wm, AC97_MISC_AFE);
 704
 705        return wm97xx_register_touch(wm);
 706}
 707
 708static void wm97xx_remove_battery(struct wm97xx *wm)
 709{
 710        platform_device_unregister(wm->battery_dev);
 711}
 712
 713static int wm97xx_add_battery(struct wm97xx *wm,
 714                              struct wm97xx_batt_pdata *pdata)
 715{
 716        int ret;
 717
 718        wm->battery_dev = platform_device_alloc("wm97xx-battery", -1);
 719        if (!wm->battery_dev)
 720                return -ENOMEM;
 721
 722        platform_set_drvdata(wm->battery_dev, wm);
 723        wm->battery_dev->dev.parent = wm->dev;
 724        wm->battery_dev->dev.platform_data = pdata;
 725        ret = platform_device_add(wm->battery_dev);
 726        if (ret)
 727                platform_device_put(wm->battery_dev);
 728
 729        return ret;
 730}
 731
 732static int wm97xx_probe(struct device *dev)
 733{
 734        struct wm97xx *wm;
 735        int ret;
 736        struct wm97xx_pdata *pdata = dev_get_platdata(dev);
 737
 738        wm = devm_kzalloc(dev, sizeof(struct wm97xx), GFP_KERNEL);
 739        if (!wm)
 740                return -ENOMEM;
 741
 742        wm->dev = dev;
 743        wm->ac97 = to_ac97_t(dev);
 744
 745        ret =  _wm97xx_probe(wm);
 746        if (ret)
 747                return ret;
 748
 749        ret = wm97xx_add_battery(wm, pdata ? pdata->batt_pdata : NULL);
 750        if (ret < 0)
 751                goto batt_err;
 752
 753        return ret;
 754
 755batt_err:
 756        wm97xx_unregister_touch(wm);
 757        return ret;
 758}
 759
 760static int wm97xx_remove(struct device *dev)
 761{
 762        struct wm97xx *wm = dev_get_drvdata(dev);
 763
 764        wm97xx_remove_battery(wm);
 765        wm97xx_unregister_touch(wm);
 766
 767        return 0;
 768}
 769
 770static int wm97xx_mfd_probe(struct platform_device *pdev)
 771{
 772        struct wm97xx *wm;
 773        struct wm97xx_platform_data *mfd_pdata = dev_get_platdata(&pdev->dev);
 774        int ret;
 775
 776        wm = devm_kzalloc(&pdev->dev, sizeof(struct wm97xx), GFP_KERNEL);
 777        if (!wm)
 778                return -ENOMEM;
 779
 780        wm->dev = &pdev->dev;
 781        wm->ac97 = mfd_pdata->ac97;
 782
 783        ret =  _wm97xx_probe(wm);
 784        if (ret)
 785                return ret;
 786
 787        ret = wm97xx_add_battery(wm, mfd_pdata->batt_pdata);
 788        if (ret < 0)
 789                goto batt_err;
 790
 791        return ret;
 792
 793batt_err:
 794        wm97xx_unregister_touch(wm);
 795        return ret;
 796}
 797
 798static int wm97xx_mfd_remove(struct platform_device *pdev)
 799{
 800        return wm97xx_remove(&pdev->dev);
 801}
 802
 803static int __maybe_unused wm97xx_suspend(struct device *dev)
 804{
 805        struct wm97xx *wm = dev_get_drvdata(dev);
 806        u16 reg;
 807        int suspend_mode;
 808
 809        if (device_may_wakeup(&wm->input_dev->dev))
 810                suspend_mode = wm->suspend_mode;
 811        else
 812                suspend_mode = 0;
 813
 814        if (wm->input_dev->users)
 815                cancel_delayed_work_sync(&wm->ts_reader);
 816
 817        /* Power down the digitiser (bypassing the cache for resume) */
 818        reg = wm97xx_reg_read(wm, AC97_WM97XX_DIGITISER2);
 819        reg &= ~WM97XX_PRP_DET_DIG;
 820        if (wm->input_dev->users)
 821                reg |= suspend_mode;
 822        wm->ac97->bus->ops->write(wm->ac97, AC97_WM97XX_DIGITISER2, reg);
 823
 824        /* WM9713 has an additional power bit - turn it off if there
 825         * are no users or if suspend mode is zero. */
 826        if (wm->id == WM9713_ID2 &&
 827            (!wm->input_dev->users || !suspend_mode)) {
 828                reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) | 0x8000;
 829                wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
 830        }
 831
 832        return 0;
 833}
 834
 835static int __maybe_unused wm97xx_resume(struct device *dev)
 836{
 837        struct wm97xx *wm = dev_get_drvdata(dev);
 838
 839        /* restore digitiser and gpios */
 840        if (wm->id == WM9713_ID2) {
 841                wm97xx_reg_write(wm, AC97_WM9713_DIG1, wm->dig[0]);
 842                wm97xx_reg_write(wm, 0x5a, wm->misc);
 843                if (wm->input_dev->users) {
 844                        u16 reg;
 845                        reg = wm97xx_reg_read(wm, AC97_EXTENDED_MID) & 0x7fff;
 846                        wm97xx_reg_write(wm, AC97_EXTENDED_MID, reg);
 847                }
 848        }
 849
 850        wm97xx_reg_write(wm, AC97_WM9713_DIG2, wm->dig[1]);
 851        wm97xx_reg_write(wm, AC97_WM9713_DIG3, wm->dig[2]);
 852
 853        wm97xx_reg_write(wm, AC97_GPIO_CFG, wm->gpio[0]);
 854        wm97xx_reg_write(wm, AC97_GPIO_POLARITY, wm->gpio[1]);
 855        wm97xx_reg_write(wm, AC97_GPIO_STICKY, wm->gpio[2]);
 856        wm97xx_reg_write(wm, AC97_GPIO_WAKEUP, wm->gpio[3]);
 857        wm97xx_reg_write(wm, AC97_GPIO_STATUS, wm->gpio[4]);
 858        wm97xx_reg_write(wm, AC97_MISC_AFE, wm->gpio[5]);
 859
 860        if (wm->input_dev->users && !wm->pen_irq) {
 861                wm->ts_reader_interval = wm->ts_reader_min_interval;
 862                queue_delayed_work(wm->ts_workq, &wm->ts_reader,
 863                                   wm->ts_reader_interval);
 864        }
 865
 866        return 0;
 867}
 868
 869static SIMPLE_DEV_PM_OPS(wm97xx_pm_ops, wm97xx_suspend, wm97xx_resume);
 870
 871/*
 872 * Machine specific operations
 873 */
 874int wm97xx_register_mach_ops(struct wm97xx *wm,
 875                             struct wm97xx_mach_ops *mach_ops)
 876{
 877        mutex_lock(&wm->codec_mutex);
 878        if (wm->mach_ops) {
 879                mutex_unlock(&wm->codec_mutex);
 880                return -EINVAL;
 881        }
 882        wm->mach_ops = mach_ops;
 883        mutex_unlock(&wm->codec_mutex);
 884
 885        return 0;
 886}
 887EXPORT_SYMBOL_GPL(wm97xx_register_mach_ops);
 888
 889void wm97xx_unregister_mach_ops(struct wm97xx *wm)
 890{
 891        mutex_lock(&wm->codec_mutex);
 892        wm->mach_ops = NULL;
 893        mutex_unlock(&wm->codec_mutex);
 894}
 895EXPORT_SYMBOL_GPL(wm97xx_unregister_mach_ops);
 896
 897static struct device_driver wm97xx_driver = {
 898        .name =         "wm97xx-ts",
 899#ifdef CONFIG_AC97_BUS
 900        .bus =          &ac97_bus_type,
 901#endif
 902        .owner =        THIS_MODULE,
 903        .probe =        wm97xx_probe,
 904        .remove =       wm97xx_remove,
 905        .pm =           &wm97xx_pm_ops,
 906};
 907
 908static struct platform_driver wm97xx_mfd_driver = {
 909        .driver = {
 910                .name =         "wm97xx-ts",
 911                .pm =           &wm97xx_pm_ops,
 912        },
 913        .probe =        wm97xx_mfd_probe,
 914        .remove =       wm97xx_mfd_remove,
 915};
 916
 917static int __init wm97xx_init(void)
 918{
 919        int ret;
 920
 921        ret = platform_driver_register(&wm97xx_mfd_driver);
 922        if (ret)
 923                return ret;
 924
 925        if (IS_BUILTIN(CONFIG_AC97_BUS))
 926                ret =  driver_register(&wm97xx_driver);
 927        return ret;
 928}
 929
 930static void __exit wm97xx_exit(void)
 931{
 932        driver_unregister(&wm97xx_driver);
 933        platform_driver_unregister(&wm97xx_mfd_driver);
 934}
 935
 936module_init(wm97xx_init);
 937module_exit(wm97xx_exit);
 938
 939/* Module information */
 940MODULE_AUTHOR("Liam Girdwood <lrg@slimlogic.co.uk>");
 941MODULE_DESCRIPTION("WM97xx Core - Touch Screen / AUX ADC / GPIO Driver");
 942MODULE_LICENSE("GPL");
 943