target/linux/omap24xx/patches-3.1/315-n800-touchscreen-and-keypad-drivers.patch

   1 From 63e56392b9024aceb610d7b4e1979e2d2cebd217 Mon Sep 17 00:00:00 2001
   2 From: Marat Radchenko <marat@slonopotamus.org>
   3 Date: Tue, 18 Oct 2011 21:48:23 +0400
   4 Subject: [PATCH 1/2] TSC2301 driver (touchscreen and keypad)
   5
   6 This patch adds support for TSC2301 touchscreen/keypad/audio chip found on Nokia N800.
   7 Touchscreen and keypad are fully functional, audio part only provides power management.
   8 ---
   9  drivers/input/keyboard/Kconfig         |    6 +
  10  drivers/input/keyboard/Makefile        |    1 +
  11  drivers/input/keyboard/tsc2301_kp.c    |  475 +++++++++++++++
  12  drivers/input/touchscreen/Kconfig      |    6 +
  13  drivers/input/touchscreen/Makefile     |    1 +
  14  drivers/input/touchscreen/tsc2301_ts.c |  676 +++++++++++++++++++++
  15  drivers/spi/Kconfig                    |   22 +
  16  drivers/spi/Makefile                   |    3 +
  17  drivers/spi/tsc2301-core.c             |  297 ++++++++++
  18  drivers/spi/tsc2301-mixer.c            | 1003 ++++++++++++++++++++++++++++++++
  19  include/linux/spi/tsc2301.h            |  208 +++++++
  20  11 files changed, 2698 insertions(+), 0 deletions(-)
  21  create mode 100644 drivers/input/keyboard/tsc2301_kp.c
  22  create mode 100644 drivers/input/touchscreen/tsc2301_ts.c
  23  create mode 100644 drivers/spi/tsc2301-core.c
  24  create mode 100644 drivers/spi/tsc2301-mixer.c
  25  create mode 100644 include/linux/spi/tsc2301.h
  26
  27 Index: linux-3.1/drivers/input/keyboard/Kconfig
  28 ===================================================================
  29 --- linux-3.1.orig/drivers/input/keyboard/Kconfig       2011-10-30 00:48:29.357056963 +0200
  30 +++ linux-3.1/drivers/input/keyboard/Kconfig    2011-10-30 00:48:48.989043470 +0200
  31 @@ -530,6 +530,12 @@ config KEYBOARD_TNETV107X
  32           To compile this driver as a module, choose M here: the
  33           module will be called tnetv107x-keypad.
  34
  35 +config KEYBOARD_TSC2301
  36 +       tristate "TSC2301 keypad support"
  37 +       depends on SPI_TSC2301
  38 +       help
  39 +         Say Y here for if you are using the keypad features of TSC2301.
  40 +
  41  config KEYBOARD_TWL4030
  42         tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"
  43         depends on TWL4030_CORE
  44 Index: linux-3.1/drivers/input/keyboard/Makefile
  45 ===================================================================
  46 --- linux-3.1.orig/drivers/input/keyboard/Makefile      2011-10-30 00:48:29.365056957 +0200
  47 +++ linux-3.1/drivers/input/keyboard/Makefile   2011-10-30 00:48:48.989043470 +0200
  48 @@ -48,6 +48,7 @@ obj-$(CONFIG_KEYBOARD_SUNKBD)         += sunkbd
  49  obj-$(CONFIG_KEYBOARD_TC3589X)         += tc3589x-keypad.o
  50  obj-$(CONFIG_KEYBOARD_TEGRA)           += tegra-kbc.o
  51  obj-$(CONFIG_KEYBOARD_TNETV107X)       += tnetv107x-keypad.o
  52 +obj-$(CONFIG_KEYBOARD_TSC2301)         += tsc2301_kp.o
  53  obj-$(CONFIG_KEYBOARD_TWL4030)         += twl4030_keypad.o
  54  obj-$(CONFIG_KEYBOARD_XTKBD)           += xtkbd.o
  55  obj-$(CONFIG_KEYBOARD_W90P910)         += w90p910_keypad.o
  56 Index: linux-3.1/drivers/input/keyboard/tsc2301_kp.c
  57 ===================================================================
  58 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
  59 +++ linux-3.1/drivers/input/keyboard/tsc2301_kp.c       2011-10-30 00:48:48.989043470 +0200
  60 @@ -0,0 +1,475 @@
  61 +/*
  62 + * TSC2301 keypad driver
  63 + *
  64 + * Copyright (C) 2005-2006 Nokia Corporation
  65 + *
  66 + * Written by Jarkko Oikarinen
  67 + * Rewritten by Juha Yrjola <juha.yrjola@nokia.com>
  68 + *
  69 + * This program is free software; you can redistribute it and/or modify
  70 + * it under the terms of the GNU General Public License as published by
  71 + * the Free Software Foundation; either version 2 of the License, or
  72 + * (at your option) any later version.
  73 + *
  74 + * This program is distributed in the hope that it will be useful,
  75 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  76 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  77 + * GNU General Public License for more details.
  78 + *
  79 + * You should have received a copy of the GNU General Public License
  80 + * along with this program; if not, write to the Free Software
  81 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  82 + *
  83 + */
  84 +
  85 +#include <linux/kernel.h>
  86 +#include <linux/module.h>
  87 +#include <linux/input.h>
  88 +#include <linux/interrupt.h>
  89 +#include <linux/irq.h>
  90 +#include <linux/delay.h>
  91 +#include <linux/spi/spi.h>
  92 +
  93 +#include <linux/spi/tsc2301.h>
  94 +
  95 +#define TSC2301_KEYBOARD_PRODUCT_ID      0x0051
  96 +#define TSC2301_KEYBOARD_PRODUCT_VERSION 0x0001
  97 +#define TSC2301_DEBOUNCE_TIME_2MS        0x0000
  98 +#define TSC2301_DEBOUNCE_TIME_10MS       0x0800
  99 +#define TSC2301_DEBOUNCE_TIME_20MS       0x1000
 100 +#define TSC2301_DEBOUNCE_TIME_50MS       0x1800
 101 +#define TSC2301_DEBOUNCE_TIME_60MS       0x2000
 102 +#define TSC2301_DEBOUNCE_TIME_80MS       0x2800
 103 +#define TSC2301_DEBOUNCE_TIME_100MS      0x3000
 104 +#define TSC2301_DEBOUNCE_TIME_120MS      0x3800
 105 +
 106 +#define TSC2301_DEBOUNCE_TIME          TSC2301_DEBOUNCE_TIME_20MS
 107 +
 108 +#define TSC2301_RELEASE_TIMEOUT                50
 109 +
 110 +struct tsc2301_kp {
 111 +       struct input_dev        *idev;
 112 +       char                    phys[32];
 113 +       spinlock_t              lock;
 114 +       struct mutex            mutex;
 115 +       struct timer_list       timer;
 116 +       u16                     keys_pressed;
 117 +       unsigned                pending:1;
 118 +       unsigned                user_disabled:1;
 119 +       unsigned                disable_depth;
 120 +
 121 +       struct spi_transfer     read_xfer[4];
 122 +       struct spi_message      read_msg;
 123 +
 124 +       u16                     data;
 125 +       u16                     mask;
 126 +
 127 +       int                     irq;
 128 +       s16                     keymap[16];
 129 +};
 130 +
 131 +static inline int tsc2301_kp_disabled(struct tsc2301 *tsc)
 132 +{
 133 +       return tsc->kp->disable_depth != 0;
 134 +}
 135 +
 136 +static void tsc2301_kp_send_key_events(struct tsc2301 *tsc,
 137 +                                      u16 prev_state,
 138 +                                      u16 new_state)
 139 +{
 140 +       struct tsc2301_kp *kp = tsc->kp;
 141 +       u16 common, released, pressed;
 142 +       int i;
 143 +
 144 +       common = prev_state & new_state;
 145 +       released = common ^ prev_state;
 146 +       pressed = common ^ new_state;
 147 +       if (!released && !pressed)
 148 +               return;
 149 +       for (i = 0; i < 16 && (released || pressed); i++) {
 150 +               if (released & 1) {
 151 +                       dev_dbg(&tsc->spi->dev, "key %d released\n", i);
 152 +                       input_report_key(kp->idev, kp->keymap[i], 0);
 153 +               }
 154 +               released >>= 1;
 155 +               if (pressed & 1) {
 156 +                       dev_dbg(&tsc->spi->dev, "key %d pressed\n", i);
 157 +                       input_report_key(kp->idev, kp->keymap[i], 1);
 158 +               }
 159 +               pressed >>= 1;
 160 +       }
 161 +       input_sync(kp->idev);
 162 +}
 163 +
 164 +static inline void _filter_out(struct tsc2301 *tsc, u16 prev_state,
 165 +                              u16 *new_state, int row1, int row2, u8 rect_pat)
 166 +{
 167 +       u16 mask;
 168 +
 169 +       mask = (rect_pat << (row1 * 4)) | (rect_pat << (row2 * 4));
 170 +       mask &= ~prev_state;
 171 +       *new_state &= ~mask;
 172 +       dev_dbg(&tsc->spi->dev, "filtering ghost keys %02x\n", mask);
 173 +}
 174 +
 175 +static void tsc2301_filter_ghost_keys(struct tsc2301 *tsc, u16 prev_state,
 176 +                                     u16 *new_state)
 177 +{
 178 +       int row1, row2;
 179 +       u16 key_map;
 180 +       u16 row1_map;
 181 +       static const u8 rect_pat[] = {
 182 +               0x3, 0x5, 0x9, 0x6, 0xa, 0xc, 0,
 183 +       };
 184 +
 185 +       key_map = *new_state;
 186 +       for (row1 = 0; row1 < 4; row1++) {
 187 +               row1_map = (key_map >> (row1 * 4)) & 0xf;
 188 +               if (!row1_map)
 189 +                       continue;
 190 +               for (row2 = row1 + 1; row2 < 4; row2++) {
 191 +                       u16 rect_map = (key_map >> (row2 * 4)) & 0xf;
 192 +                       const u8 *rp;
 193 +
 194 +                       rect_map &= row1_map;
 195 +                       if (!rect_map)
 196 +                               continue;
 197 +                       for (rp = rect_pat; *rp; rp++)
 198 +                               if ((rect_map & *rp) == *rp)
 199 +                                       _filter_out(tsc, prev_state, new_state,
 200 +                                                   row1, row2, *rp);
 201 +               }
 202 +       }
 203 +}
 204 +
 205 +static void tsc2301_kp_timer(unsigned long arg)
 206 +{
 207 +       struct tsc2301 *tsc = (void *) arg;
 208 +       struct tsc2301_kp *kp = tsc->kp;
 209 +       unsigned long flags;
 210 +
 211 +       tsc2301_kp_send_key_events(tsc, kp->keys_pressed, 0);
 212 +       spin_lock_irqsave(&kp->lock, flags);
 213 +       kp->keys_pressed = 0;
 214 +       spin_unlock_irqrestore(&kp->lock, flags);
 215 +}
 216 +
 217 +static void tsc2301_kp_rx(void *arg)
 218 +{
 219 +       struct tsc2301 *tsc = arg;
 220 +       struct tsc2301_kp *kp = tsc->kp;
 221 +       unsigned long flags;
 222 +       u16 kp_data;
 223 +
 224 +       kp_data = kp->data;
 225 +       dev_dbg(&tsc->spi->dev, "KP data %04x\n", kp_data);
 226 +
 227 +       tsc2301_filter_ghost_keys(tsc, kp->keys_pressed, &kp_data);
 228 +       tsc2301_kp_send_key_events(tsc, kp->keys_pressed, kp_data);
 229 +       spin_lock_irqsave(&kp->lock, flags);
 230 +       kp->keys_pressed = kp_data;
 231 +       kp->pending = 0;
 232 +       spin_unlock_irqrestore(&kp->lock, flags);
 233 +}
 234 +
 235 +static irqreturn_t tsc2301_kp_irq_handler(int irq, void *dev_id)
 236 +{
 237 +       struct tsc2301 *tsc = dev_id;
 238 +       struct tsc2301_kp *kp = tsc->kp;
 239 +       unsigned long flags;
 240 +       int r;
 241 +
 242 +       spin_lock_irqsave(&kp->lock, flags);
 243 +       if (tsc2301_kp_disabled(tsc)) {
 244 +               spin_unlock_irqrestore(&kp->lock, flags);
 245 +               return IRQ_HANDLED;
 246 +       }
 247 +       kp->pending = 1;
 248 +       spin_unlock_irqrestore(&kp->lock, flags);
 249 +       mod_timer(&kp->timer,
 250 +                jiffies + msecs_to_jiffies(TSC2301_RELEASE_TIMEOUT));
 251 +       r = spi_async(tsc->spi, &tsc->kp->read_msg);
 252 +       if (r)
 253 +               dev_err(&tsc->spi->dev, "kp: spi_async() failed");
 254 +       return IRQ_HANDLED;
 255 +}
 256 +
 257 +static void tsc2301_kp_start_scan(struct tsc2301 *tsc)
 258 +{
 259 +       tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, tsc->kp->mask);
 260 +       tsc2301_write_reg(tsc, TSC2301_REG_KEY, TSC2301_DEBOUNCE_TIME);
 261 +}
 262 +
 263 +static void tsc2301_kp_stop_scan(struct tsc2301 *tsc)
 264 +{
 265 +       tsc2301_write_reg(tsc, TSC2301_REG_KEY, 1 << 14);
 266 +}
 267 +
 268 +/* Must be called with the mutex held */
 269 +static void tsc2301_kp_enable(struct tsc2301 *tsc)
 270 +{
 271 +       struct tsc2301_kp *kp = tsc->kp;
 272 +       unsigned long flags;
 273 +
 274 +       spin_lock_irqsave(&kp->lock, flags);
 275 +       BUG_ON(!tsc2301_kp_disabled(tsc));
 276 +       if (--kp->disable_depth != 0) {
 277 +               spin_unlock_irqrestore(&kp->lock, flags);
 278 +               return;
 279 +       }
 280 +       spin_unlock_irqrestore(&kp->lock, flags);
 281 +
 282 +       irq_set_irq_type(kp->irq, IRQ_TYPE_EDGE_FALLING);
 283 +       tsc2301_kp_start_scan(tsc);
 284 +       enable_irq(kp->irq);
 285 +}
 286 +
 287 +/* Must be called with the mutex held */
 288 +static int tsc2301_kp_disable(struct tsc2301 *tsc, int release_keys)
 289 +{
 290 +       struct tsc2301_kp *kp = tsc->kp;
 291 +       unsigned long flags;
 292 +
 293 +       spin_lock_irqsave(&kp->lock, flags);
 294 +       if (kp->disable_depth++ != 0) {
 295 +               spin_unlock_irqrestore(&kp->lock, flags);
 296 +               goto out;
 297 +       }
 298 +       disable_irq_nosync(kp->irq);
 299 +       irq_set_irq_type(kp->irq, IRQ_TYPE_NONE);
 300 +       spin_unlock_irqrestore(&kp->lock, flags);
 301 +
 302 +       while (kp->pending) {
 303 +               msleep(1);
 304 +       }
 305 +
 306 +       tsc2301_kp_stop_scan(tsc);
 307 +out:
 308 +       if (!release_keys)
 309 +               del_timer(&kp->timer); /* let timeout release keys */
 310 +
 311 +       return 0;
 312 +}
 313 +
 314 +/* The following workaround is needed for a HW bug triggered by the
 315 + * following:
 316 + * 1. keep any key pressed
 317 + * 2. disable keypad
 318 + * 3. release all keys
 319 + * 4. reenable keypad
 320 + * 5. disable touch screen controller
 321 + *
 322 + * After this the keypad scanner will get stuck in busy state and won't
 323 + * report any interrupts for further keypresses. One way to recover is to
 324 + * restart the keypad scanner whenever we enable / disable the
 325 + * touchscreen controller.
 326 + */
 327 +void tsc2301_kp_restart(struct tsc2301 *tsc)
 328 +{
 329 +       if (!tsc2301_kp_disabled(tsc)) {
 330 +               tsc2301_kp_start_scan(tsc);
 331 +       }
 332 +}
 333 +
 334 +static ssize_t tsc2301_kp_disable_show(struct device *dev,
 335 +                                      struct device_attribute *attr, char *buf)
 336 +{
 337 +       struct tsc2301          *tsc = dev_get_drvdata(dev);
 338 +
 339 +       return sprintf(buf, "%u\n", tsc2301_kp_disabled(tsc) ? 1 : 0);
 340 +}
 341 +
 342 +static ssize_t tsc2301_kp_disable_store(struct device *dev,
 343 +                                       struct device_attribute *attr,
 344 +                                       const char *buf, size_t count)
 345 +{
 346 +       struct tsc2301          *tsc = dev_get_drvdata(dev);
 347 +       struct tsc2301_kp       *kp = tsc->kp;
 348 +       char *endp;
 349 +       int i;
 350 +
 351 +       i = simple_strtoul(buf, &endp, 10);
 352 +       i = i ? 1 : 0;
 353 +
 354 +       mutex_lock(&kp->mutex);
 355 +       if (i == kp->user_disabled) {
 356 +               mutex_unlock(&kp->mutex);
 357 +               return count;
 358 +       }
 359 +       kp->user_disabled = i;
 360 +
 361 +       if (i)
 362 +               tsc2301_kp_disable(tsc, 1);
 363 +       else
 364 +               tsc2301_kp_enable(tsc);
 365 +       mutex_unlock(&kp->mutex);
 366 +
 367 +       return count;
 368 +}
 369 +
 370 +static DEVICE_ATTR(disable_kp, 0664, tsc2301_kp_disable_show,
 371 +                  tsc2301_kp_disable_store);
 372 +
 373 +static const u16 tsc2301_kp_read_data = 0x8000 | TSC2301_REG_KPDATA;
 374 +
 375 +static void tsc2301_kp_setup_spi_xfer(struct tsc2301 *tsc)
 376 +{
 377 +       struct tsc2301_kp *kp = tsc->kp;
 378 +       struct spi_message *m = &kp->read_msg;
 379 +       struct spi_transfer *x = &kp->read_xfer[0];
 380 +
 381 +       spi_message_init(&kp->read_msg);
 382 +
 383 +       x->tx_buf = &tsc2301_kp_read_data;
 384 +       x->len = 2;
 385 +       spi_message_add_tail(x, m);
 386 +       x++;
 387 +
 388 +       x->rx_buf = &kp->data;
 389 +       x->len = 2;
 390 +       spi_message_add_tail(x, m);
 391 +
 392 +       m->complete = tsc2301_kp_rx;
 393 +       m->context = tsc;
 394 +}
 395 +
 396 +#ifdef CONFIG_PM
 397 +int tsc2301_kp_suspend(struct tsc2301 *tsc)
 398 +{
 399 +       struct tsc2301_kp *kp = tsc->kp;
 400 +
 401 +       mutex_lock(&kp->mutex);
 402 +       tsc2301_kp_disable(tsc, 1);
 403 +       mutex_unlock(&kp->mutex);
 404 +       return 0;
 405 +}
 406 +
 407 +void tsc2301_kp_resume(struct tsc2301 *tsc)
 408 +{
 409 +       struct tsc2301_kp *kp = tsc->kp;
 410 +
 411 +       mutex_lock(&kp->mutex);
 412 +       tsc2301_kp_enable(tsc);
 413 +       mutex_unlock(&kp->mutex);
 414 +}
 415 +#endif
 416 +
 417 +int __devinit tsc2301_kp_init(struct tsc2301 *tsc,
 418 +                             struct tsc2301_platform_data *pdata)
 419 +{
 420 +       struct input_dev *idev;
 421 +       struct tsc2301_kp *kp;
 422 +       int r, i;
 423 +       u16 mask;
 424 +
 425 +       if (pdata->keyb_int < 0) {
 426 +               dev_err(&tsc->spi->dev, "need kbirq");
 427 +               return -EINVAL;
 428 +       }
 429 +
 430 +       kp = kzalloc(sizeof(*kp), GFP_KERNEL);
 431 +       if (kp == NULL)
 432 +               return -ENOMEM;
 433 +       tsc->kp = kp;
 434 +
 435 +       kp->irq = pdata->keyb_int;
 436 +       spin_lock_init(&kp->lock);
 437 +       mutex_init(&kp->mutex);
 438 +
 439 +       init_timer(&kp->timer);
 440 +       kp->timer.data = (unsigned long) tsc;
 441 +       kp->timer.function = tsc2301_kp_timer;
 442 +
 443 +       idev = input_allocate_device();
 444 +       if (idev == NULL) {
 445 +               r = -ENOMEM;
 446 +               goto err1;
 447 +       }
 448 +       if (pdata->keyb_name)
 449 +               idev->name = pdata->keyb_name;
 450 +       else
 451 +               idev->name = "TSC2301 keypad";
 452 +       snprintf(kp->phys, sizeof(kp->phys), "%s/input-kp", dev_name(&tsc->spi->dev));
 453 +       idev->phys = kp->phys;
 454 +
 455 +       mask = 0;
 456 +       idev->evbit[0] = BIT(EV_KEY);
 457 +       for (i = 0; i < 16; i++) {
 458 +               if (pdata->keymap[i] > 0) {
 459 +                       set_bit(pdata->keymap[i], idev->keybit);
 460 +                       kp->keymap[i] = pdata->keymap[i];
 461 +               } else {
 462 +                       kp->keymap[i] = -1;
 463 +                       mask |= 1 << i;
 464 +               }
 465 +       }
 466 +
 467 +       if (pdata->kp_rep)
 468 +               set_bit(EV_REP, idev->evbit);
 469 +
 470 +       kp->idev = idev;
 471 +
 472 +       tsc2301_kp_setup_spi_xfer(tsc);
 473 +
 474 +       r = device_create_file(&tsc->spi->dev, &dev_attr_disable_kp);
 475 +       if (r < 0)
 476 +               goto err2;
 477 +
 478 +       tsc2301_kp_start_scan(tsc);
 479 +
 480 +       /* IRQ mode 0 is faulty, it can cause the KBIRQ to get stuck.
 481 +        * Mode 2 deasserts the IRQ at:
 482 +        * - HW or SW reset
 483 +        * - Setting SCS flag in REG_KEY register
 484 +        * - Releasing all keys
 485 +        * - Reading the REG_KPDATA
 486 +        */
 487 +       tsc2301_write_kbc(tsc, 2);
 488 +
 489 +       tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, mask);
 490 +       kp->mask = mask;
 491 +
 492 +       irq_set_irq_type(kp->irq, IRQ_TYPE_EDGE_FALLING);
 493 +
 494 +       r = request_irq(kp->irq, tsc2301_kp_irq_handler, IRQF_SAMPLE_RANDOM,
 495 +                       "tsc2301-kp", tsc);
 496 +       if (r < 0) {
 497 +               dev_err(&tsc->spi->dev, "unable to get kbirq IRQ");
 498 +               goto err3;
 499 +       }
 500 +       irq_set_irq_wake(kp->irq, 1);
 501 +
 502 +       /* We need to read the register once..? */
 503 +       tsc2301_read_reg(tsc, TSC2301_REG_KPDATA);
 504 +
 505 +       r = input_register_device(idev);
 506 +       if (r < 0) {
 507 +               dev_err(&tsc->spi->dev, "can't register keypad device\n");
 508 +               goto err4;
 509 +       }
 510 +
 511 +       return 0;
 512 +
 513 +err4:
 514 +       free_irq(kp->irq, tsc);
 515 +err3:
 516 +       tsc2301_kp_stop_scan(tsc);
 517 +       device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);
 518 +err2:
 519 +       input_free_device(kp->idev);
 520 +err1:
 521 +       kfree(kp);
 522 +       return r;
 523 +}
 524 +
 525 +void __devexit tsc2301_kp_exit(struct tsc2301 *tsc)
 526 +{
 527 +       struct tsc2301_kp *kp = tsc->kp;
 528 +
 529 +       tsc2301_kp_disable(tsc, 1);
 530 +       input_unregister_device(kp->idev);
 531 +       free_irq(kp->irq, tsc);
 532 +       device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);
 533 +
 534 +       kfree(kp);
 535 +}
 536 Index: linux-3.1/drivers/input/touchscreen/Kconfig
 537 ===================================================================
 538 --- linux-3.1.orig/drivers/input/touchscreen/Kconfig    2011-10-30 00:48:29.341056972 +0200
 539 +++ linux-3.1/drivers/input/touchscreen/Kconfig 2011-10-30 00:48:48.989043470 +0200
 540 @@ -673,6 +673,12 @@ config TOUCHSCREEN_TSC2007
 541           To compile this driver as a module, choose M here: the
 542           module will be called tsc2007.
 543
 544 +config TOUCHSCREEN_TSC2301
 545 +       tristate "TSC2301 touchscreen support"
 546 +       depends on SPI_TSC2301
 547 +       help
 548 +         Say Y here for if you are using the touchscreen features of TSC2301.
 549 +
 550  config TOUCHSCREEN_W90X900
 551         tristate "W90P910 touchscreen driver"
 552         depends on HAVE_CLK
 553 Index: linux-3.1/drivers/input/touchscreen/Makefile
 554 ===================================================================
 555 --- linux-3.1.orig/drivers/input/touchscreen/Makefile   2011-10-30 00:48:29.349056969 +0200
 556 +++ linux-3.1/drivers/input/touchscreen/Makefile        2011-10-30 00:48:48.989043470 +0200
 557 @@ -48,6 +48,7 @@ obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)  +=
 558  obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)     += touchwin.o
 559  obj-$(CONFIG_TOUCHSCREEN_TSC2005)      += tsc2005.o
 560  obj-$(CONFIG_TOUCHSCREEN_TSC2007)      += tsc2007.o
 561 +obj-$(CONFIG_TOUCHSCREEN_TSC2301)      += tsc2301_ts.o
 562  obj-$(CONFIG_TOUCHSCREEN_UCB1400)      += ucb1400_ts.o
 563  obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)  += wacom_w8001.o
 564  obj-$(CONFIG_TOUCHSCREEN_WM831X)       += wm831x-ts.o
 565 Index: linux-3.1/drivers/input/touchscreen/tsc2301_ts.c
 566 ===================================================================
 567 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
 568 +++ linux-3.1/drivers/input/touchscreen/tsc2301_ts.c    2011-10-30 00:48:48.989043470 +0200
 569 @@ -0,0 +1,676 @@
 570 +/*
 571 + * TSC2301 touchscreen driver
 572 + *
 573 + * Copyright (C) 2005-2008 Nokia Corporation
 574 + *
 575 + * Written by Jarkko Oikarinen, Imre Deak and Juha Yrjola
 576 + *
 577 + * This program is free software; you can redistribute it and/or modify
 578 + * it under the terms of the GNU General Public License as published by
 579 + * the Free Software Foundation; either version 2 of the License, or
 580 + * (at your option) any later version.
 581 + *
 582 + * This program is distributed in the hope that it will be useful,
 583 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 584 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 585 + * GNU General Public License for more details.
 586 + *
 587 + * You should have received a copy of the GNU General Public License
 588 + * along with this program; if not, write to the Free Software
 589 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 590 + *
 591 + */
 592 +
 593 +#include <linux/kernel.h>
 594 +#include <linux/module.h>
 595 +#include <linux/input.h>
 596 +#include <linux/interrupt.h>
 597 +#include <linux/delay.h>
 598 +#include <linux/spi/spi.h>
 599 +
 600 +#include <linux/spi/tsc2301.h>
 601 +
 602 +/**
 603 + * The touchscreen interface operates as follows:
 604 + *
 605 + * Initialize:
 606 + *    Request access to GPIO103 (DAV)
 607 + *    tsc2301_ts_irq_handler will trigger when DAV line goes down
 608 + *
 609 + *  1) Pen is pressed against touchscreeen
 610 + *  2) TSC2301 performs AD conversion
 611 + *  3) After the conversion is done TSC2301 drives DAV line down
 612 + *  4) GPIO IRQ is received and tsc2301_ts_irq_handler is called
 613 + *  5) tsc2301_ts_irq_handler queues up an spi transfer to fetch
 614 + *     the x, y, z1, z2 values
 615 + *  6) SPI framework calls tsc2301_ts_rx after the coordinates are read
 616 + *  7) When the penup_timer expires, there have not been DAV interrupts
 617 + *     during the last 20ms which means the pen has been lifted.
 618 + */
 619 +
 620 +
 621 +#define TSC2301_TOUCHSCREEN_PRODUCT_ID                 0x0052
 622 +#define TSC2301_TOUCHSCREEN_PRODUCT_VERSION            0x0001
 623 +
 624 +#define TSC2301_TS_PENUP_TIME                          20
 625 +
 626 +#define TSC2301_ADCREG_CONVERSION_CTRL_BY_TSC2301      0x8000
 627 +#define TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST         0x0000
 628 +
 629 +#define TSC2301_ADCREG_FUNCTION_NONE                   0x0000
 630 +#define TSC2301_ADCREG_FUNCTION_XY                     0x0400
 631 +#define TSC2301_ADCREG_FUNCTION_XYZ                    0x0800
 632 +#define TSC2301_ADCREG_FUNCTION_X                      0x0C00
 633 +#define TSC2301_ADCREG_FUNCTION_Y                      0x1000
 634 +#define TSC2301_ADCREG_FUNCTION_Z                      0x1400
 635 +#define TSC2301_ADCREG_FUNCTION_DAT1                   0x1800
 636 +#define TSC2301_ADCREG_FUNCTION_DAT2                   0x1C00
 637 +#define TSC2301_ADCREG_FUNCTION_AUX1                   0x2000
 638 +#define TSC2301_ADCREG_FUNCTION_AUX2                   0x2400
 639 +#define TSC2301_ADCREG_FUNCTION_TEMP                   0x2800
 640 +
 641 +#define TSC2301_ADCREG_RESOLUTION_8BIT                 0x0100
 642 +#define TSC2301_ADCREG_RESOLUTION_10BIT                        0x0200
 643 +#define TSC2301_ADCREG_RESOLUTION_12BIT                        0x0300
 644 +
 645 +#define TSC2301_ADCREG_AVERAGING_NONE                  0x0000
 646 +#define TSC2301_ADCREG_AVERAGING_4AVG                  0x0040
 647 +#define TSC2301_ADCREG_AVERAGING_8AVG                  0x0080
 648 +#define TSC2301_ADCREG_AVERAGING_16AVG                 0x00C0
 649 +
 650 +#define TSC2301_ADCREG_CLOCK_8MHZ                      0x0000
 651 +#define TSC2301_ADCREG_CLOCK_4MHZ                      0x0010
 652 +#define TSC2301_ADCREG_CLOCK_2MHZ                      0x0020
 653 +#define TSC2301_ADCREG_CLOCK_1MHZ                      0x0030
 654 +
 655 +#define TSC2301_ADCREG_VOLTAGE_STAB_0US                        0x0000
 656 +#define TSC2301_ADCREG_VOLTAGE_STAB_100US              0x0002
 657 +#define TSC2301_ADCREG_VOLTAGE_STAB_500US              0x0004
 658 +#define TSC2301_ADCREG_VOLTAGE_STAB_1MS                        0x0006
 659 +#define TSC2301_ADCREG_VOLTAGE_STAB_5MS                        0x0008
 660 +#define TSC2301_ADCREG_VOLTAGE_STAB_10MS               0x000A
 661 +#define TSC2301_ADCREG_VOLTAGE_STAB_50MS               0x000C
 662 +#define TSC2301_ADCREG_VOLTAGE_STAB_100MS              0x000E
 663 +
 664 +#define TSC2301_ADCREG_STOP_CONVERSION                 0x4000
 665 +
 666 +#define MAX_12BIT                                      ((1 << 12) - 1)
 667 +
 668 +#define TS_RECT_SIZE                                   8
 669 +#define TSF_MIN_Z1                                     100
 670 +#define TSF_MAX_Z2                                     4000
 671 +
 672 +#define TSF_SAMPLES                                    4
 673 +
 674 +struct ts_filter {
 675 +       int                     sample_cnt;
 676 +
 677 +       int                     avg_x;
 678 +       int                     avg_y;
 679 +       int                     avg_z1;
 680 +       int                     avg_z2;
 681 +};
 682 +
 683 +struct ts_coords {
 684 +       u16                     x;
 685 +       u16                     y;
 686 +       u16                     z1;
 687 +       u16                     z2;
 688 +};
 689 +
 690 +struct tsc2301_ts {
 691 +       struct input_dev        *idev;
 692 +       char                    phys[32];
 693 +       struct timer_list       penup_timer;
 694 +       struct mutex            mutex;
 695 +
 696 +       struct spi_transfer     read_xfer[2];
 697 +       struct spi_message      read_msg;
 698 +       struct ts_coords        *coords;
 699 +
 700 +       struct ts_filter        filter;
 701 +
 702 +       int                     hw_avg_max;
 703 +       u16                     x;
 704 +       u16                     y;
 705 +       u16                     p;
 706 +
 707 +       u16                     x_plate_ohm;
 708 +       int                     stab_time;
 709 +       int                     max_pressure;
 710 +       int                     touch_pressure;
 711 +
 712 +       u8                      event_sent;
 713 +       u8                      pen_down;
 714 +       u8                      disabled;
 715 +       u8                      disable_depth;
 716 +
 717 +       int                     hw_flags;
 718 +       int                     irq;
 719 +};
 720 +
 721 +
 722 +static const u16 tsc2301_ts_read_data = 0x8000 | TSC2301_REG_X;
 723 +
 724 +static int tsc2301_ts_check_config(struct tsc2301_ts *ts, int *hw_flags)
 725 +{
 726 +       int flags;
 727 +
 728 +       flags = 0;
 729 +       switch (ts->hw_avg_max) {
 730 +       case 0:
 731 +               flags |= TSC2301_ADCREG_AVERAGING_NONE;
 732 +               break;
 733 +       case 4:
 734 +               flags |= TSC2301_ADCREG_AVERAGING_4AVG;
 735 +               break;
 736 +       case 8:
 737 +               flags |= TSC2301_ADCREG_AVERAGING_8AVG;
 738 +               break;
 739 +       case 16:
 740 +               flags |= TSC2301_ADCREG_AVERAGING_16AVG;
 741 +               break;
 742 +       default:
 743 +               return -EINVAL;
 744 +       }
 745 +
 746 +       switch (ts->stab_time) {
 747 +       case 0:
 748 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_0US;
 749 +               break;
 750 +       case 100:
 751 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_100US;
 752 +               break;
 753 +       case 500:
 754 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_500US;
 755 +               break;
 756 +       case 1000:
 757 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_1MS;
 758 +               break;
 759 +       case 5000:
 760 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_5MS;
 761 +               break;
 762 +       case 10000:
 763 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_10MS;
 764 +               break;
 765 +       case 50000:
 766 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_50MS;
 767 +               break;
 768 +       case 100000:
 769 +               flags |= TSC2301_ADCREG_VOLTAGE_STAB_100MS;
 770 +               break;
 771 +       default:
 772 +               return -EINVAL;
 773 +       }
 774 +
 775 +       *hw_flags = flags;
 776 +       return 0;
 777 +}
 778 +
 779 +/*
 780 + * This odd three-time initialization is to work around a bug in TSC2301.
 781 + * See TSC2301 errata for details.
 782 + */
 783 +static int tsc2301_ts_configure(struct tsc2301 *tsc, int flags)
 784 +{
 785 +       struct spi_transfer xfer[5];
 786 +       struct spi_transfer *x;
 787 +       struct spi_message m;
 788 +       int i;
 789 +       u16 val1, val2, val3;
 790 +       u16 data[10];
 791 +
 792 +       val1 = TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST |
 793 +               TSC2301_ADCREG_STOP_CONVERSION |
 794 +               TSC2301_ADCREG_FUNCTION_NONE |
 795 +               TSC2301_ADCREG_RESOLUTION_12BIT |
 796 +               TSC2301_ADCREG_AVERAGING_NONE |
 797 +               TSC2301_ADCREG_CLOCK_2MHZ |
 798 +               TSC2301_ADCREG_VOLTAGE_STAB_100MS;
 799 +
 800 +       val2 = TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST |
 801 +               TSC2301_ADCREG_FUNCTION_XYZ |
 802 +               TSC2301_ADCREG_RESOLUTION_12BIT |
 803 +               TSC2301_ADCREG_AVERAGING_16AVG |
 804 +               TSC2301_ADCREG_CLOCK_1MHZ |
 805 +               TSC2301_ADCREG_VOLTAGE_STAB_100MS;
 806 +
 807 +       /* Averaging and voltage stabilization settings in flags */
 808 +       val3 = TSC2301_ADCREG_CONVERSION_CTRL_BY_TSC2301 |
 809 +               TSC2301_ADCREG_FUNCTION_XYZ |
 810 +               TSC2301_ADCREG_RESOLUTION_12BIT |
 811 +               TSC2301_ADCREG_CLOCK_2MHZ |
 812 +               flags;
 813 +
 814 +       /* Now we prepare the command for transferring */
 815 +       data[0] = TSC2301_REG_ADC;
 816 +       data[1] = val1;
 817 +       data[2] = TSC2301_REG_ADC;
 818 +       data[3] = val2;
 819 +       data[4] = TSC2301_REG_ADC;
 820 +       data[5] = val3;
 821 +       data[6] = TSC2301_REG_REF;
 822 +       data[7] = 1 << 4 | 1 << 2 | 1; /* intref, 100uS settl, 2.5V ref */
 823 +       data[8] = TSC2301_REG_CONFIG;
 824 +       data[9] = 3 << 3 | 2 << 0; /* 340uS pre-chrg, 544us delay */
 825 +
 826 +       spi_message_init(&m);
 827 +       m.spi = tsc->spi;
 828 +
 829 +       memset(xfer, 0, sizeof(xfer));
 830 +       x = &xfer[0];
 831 +
 832 +       for (i = 0; i < 10; i += 2) {
 833 +               x->tx_buf = &data[i];
 834 +               x->len = 4;
 835 +               if (i != 8)
 836 +                       x->cs_change = 1;
 837 +               spi_message_add_tail(x, &m);
 838 +               x++;
 839 +       }
 840 +       spi_sync(m.spi, &m);
 841 +
 842 +       return 0;
 843 +}
 844 +
 845 +static void tsc2301_ts_start_scan(struct tsc2301 *tsc)
 846 +{
 847 +       tsc2301_ts_configure(tsc, tsc->ts->hw_flags);
 848 +       tsc2301_kp_restart(tsc);
 849 +}
 850 +
 851 +static void tsc2301_ts_stop_scan(struct tsc2301 *tsc)
 852 +{
 853 +       tsc2301_write_reg(tsc, TSC2301_REG_ADC, TSC2301_ADCREG_STOP_CONVERSION);
 854 +       tsc2301_kp_restart(tsc);
 855 +}
 856 +
 857 +static void update_pen_state(struct tsc2301_ts *ts, int x, int y, int pressure)
 858 +{
 859 +       if (pressure) {
 860 +               input_report_abs(ts->idev, ABS_X, x);
 861 +               input_report_abs(ts->idev, ABS_Y, y);
 862 +               input_report_abs(ts->idev, ABS_PRESSURE, pressure);
 863 +               if (!ts->pen_down)
 864 +                       input_report_key(ts->idev, BTN_TOUCH, 1);
 865 +               ts->pen_down = 1;
 866 +       } else {
 867 +               input_report_abs(ts->idev, ABS_PRESSURE, 0);
 868 +               if (ts->pen_down)
 869 +                       input_report_key(ts->idev, BTN_TOUCH, 0);
 870 +               ts->pen_down = 0;
 871 +       }
 872 +
 873 +       input_sync(ts->idev);
 874 +
 875 +#ifdef VERBOSE
 876 +       dev_dbg(&tsc->spi->dev, "x %4d y %4d p %4d\n", x, y, pressure);
 877 +#endif
 878 +}
 879 +
 880 +static int filter(struct tsc2301_ts *ts, int x, int y, int z1, int z2)
 881 +{
 882 +       int inside_rect, pressure_limit, Rt;
 883 +       struct ts_filter *tsf = &ts->filter;
 884 +
 885 +       /* validate pressure and position */
 886 +       if (x > MAX_12BIT || y > MAX_12BIT)
 887 +               return 0;
 888 +
 889 +       /* skip coords if the pressure-components are out of range */
 890 +       if (z1 < TSF_MIN_Z1 || z2 > TSF_MAX_Z2)
 891 +               return 0;
 892 +
 893 +       /* Use the x,y,z1,z2 directly on the first "pen down" event */
 894 +       if (ts->event_sent) {
 895 +               tsf->avg_x  += x;
 896 +               tsf->avg_y  += y;
 897 +               tsf->avg_z1 += z1;
 898 +               tsf->avg_z2 += z2;
 899 +
 900 +               if (++tsf->sample_cnt < TSF_SAMPLES)
 901 +                       return 0;
 902 +               x = tsf->avg_x / TSF_SAMPLES;
 903 +               y = tsf->avg_y / TSF_SAMPLES;
 904 +               z1 = tsf->avg_z1 / TSF_SAMPLES;
 905 +               z2 = tsf->avg_z2 / TSF_SAMPLES;
 906 +       }
 907 +       tsf->sample_cnt = 0;
 908 +       tsf->avg_x  = 0;
 909 +       tsf->avg_y  = 0;
 910 +       tsf->avg_z1 = 0;
 911 +       tsf->avg_z2 = 0;
 912 +
 913 +       pressure_limit = ts->event_sent? ts->max_pressure: ts->touch_pressure;
 914 +
 915 +       /* z1 is always at least 100: */
 916 +       Rt = x * (z2 - z1) / z1;
 917 +       Rt = Rt * ts->x_plate_ohm / 4096;
 918 +       if (Rt > pressure_limit)
 919 +               return 0;
 920 +
 921 +       /* discard the event if it still is within the previous rect - unless
 922 +        * if the pressure is harder, but then use previous x,y position */
 923 +       inside_rect = (
 924 +           x > (int)ts->x - TS_RECT_SIZE && x < (int)ts->x + TS_RECT_SIZE &&
 925 +           y > (int)ts->y - TS_RECT_SIZE && y < (int)ts->y + TS_RECT_SIZE);
 926 +
 927 +       if (!ts->event_sent || !inside_rect) {
 928 +               ts->x = x;
 929 +               ts->y = y;
 930 +               ts->p = Rt;
 931 +               return 1;
 932 +       } else if (Rt < ts->p) {
 933 +               ts->p = Rt;
 934 +               return 1;
 935 +       }
 936 +       return 0;
 937 +}
 938 +
 939 +/*
 940 + * This procedure is called by the SPI framework after the coordinates
 941 + * have been read from TSC2301
 942 + */
 943 +static void tsc2301_ts_rx(void *arg)
 944 +{
 945 +       struct tsc2301 *tsc = arg;
 946 +       struct tsc2301_ts *ts = tsc->ts;
 947 +       int send_event;
 948 +       int x, y, z1, z2;
 949 +
 950 +       x  = ts->coords->x;
 951 +       y  = ts->coords->y;
 952 +       z1 = ts->coords->z1;
 953 +       z2 = ts->coords->z2;
 954 +
 955 +       send_event = filter(ts, x, y, z1, z2);
 956 +       if (send_event) {
 957 +               update_pen_state(ts, ts->x, ts->y, ts->p);
 958 +               ts->event_sent = 1;
 959 +       }
 960 +
 961 +       mod_timer(&ts->penup_timer,
 962 +                 jiffies + msecs_to_jiffies(TSC2301_TS_PENUP_TIME));
 963 +}
 964 +
 965 +/*
 966 + * Timer is called TSC2301_TS_PENUP_TIME after pen is up
 967 + */
 968 +static void tsc2301_ts_timer_handler(unsigned long data)
 969 +{
 970 +       struct tsc2301 *tsc = (struct tsc2301 *)data;
 971 +       struct tsc2301_ts *ts = tsc->ts;
 972 +
 973 +       if (ts->event_sent) {
 974 +               ts->event_sent = 0;
 975 +               update_pen_state(ts, 0, 0, 0);
 976 +       }
 977 +}
 978 +
 979 +/*
 980 + * This interrupt is called when pen is down and coordinates are
 981 + * available. That is indicated by a falling edge on DEV line.
 982 + */
 983 +static irqreturn_t tsc2301_ts_irq_handler(int irq, void *dev_id)
 984 +{
 985 +       struct tsc2301 *tsc = dev_id;
 986 +       struct tsc2301_ts *ts = tsc->ts;
 987 +       int r;
 988 +
 989 +       r = spi_async(tsc->spi, &ts->read_msg);
 990 +       if (r)
 991 +               dev_err(&tsc->spi->dev, "ts: spi_async() failed");
 992 +
 993 +       mod_timer(&ts->penup_timer,
 994 +                 jiffies + msecs_to_jiffies(TSC2301_TS_PENUP_TIME));
 995 +
 996 +       return IRQ_HANDLED;
 997 +}
 998 +
 999 +static void tsc2301_ts_disable(struct tsc2301 *tsc)
1000 +{
1001 +       struct tsc2301_ts *ts = tsc->ts;
1002 +
1003 +       if (ts->disable_depth++ != 0)
1004 +               return;
1005 +
1006 +       disable_irq(ts->irq);
1007 +
1008 +       /* wait until penup timer expire normally */
1009 +       do {
1010 +               msleep(1);
1011 +       } while (ts->event_sent);
1012 +
1013 +       tsc2301_ts_stop_scan(tsc);
1014 +}
1015 +
1016 +static void tsc2301_ts_enable(struct tsc2301 *tsc)
1017 +{
1018 +       struct tsc2301_ts *ts = tsc->ts;
1019 +
1020 +       if (--ts->disable_depth != 0)
1021 +               return;
1022 +
1023 +       enable_irq(ts->irq);
1024 +
1025 +       tsc2301_ts_start_scan(tsc);
1026 +}
1027 +
1028 +#ifdef CONFIG_PM
1029 +int tsc2301_ts_suspend(struct tsc2301 *tsc)
1030 +{
1031 +       struct tsc2301_ts *ts = tsc->ts;
1032 +
1033 +       mutex_lock(&ts->mutex);
1034 +       tsc2301_ts_disable(tsc);
1035 +       mutex_unlock(&ts->mutex);
1036 +
1037 +       return 0;
1038 +}
1039 +
1040 +void tsc2301_ts_resume(struct tsc2301 *tsc)
1041 +{
1042 +       struct tsc2301_ts *ts = tsc->ts;
1043 +
1044 +       mutex_lock(&ts->mutex);
1045 +       tsc2301_ts_enable(tsc);
1046 +       mutex_unlock(&ts->mutex);
1047 +}
1048 +#endif
1049 +
1050 +static void tsc2301_ts_setup_spi_xfer(struct tsc2301 *tsc)
1051 +{
1052 +       struct tsc2301_ts *ts = tsc->ts;
1053 +       struct spi_message *m = &ts->read_msg;
1054 +       struct spi_transfer *x = &ts->read_xfer[0];
1055 +
1056 +       spi_message_init(m);
1057 +
1058 +       x->tx_buf = &tsc2301_ts_read_data;
1059 +       x->len = 2;
1060 +       spi_message_add_tail(x, m);
1061 +
1062 +       x++;
1063 +       x->rx_buf = ts->coords;
1064 +       x->len = 8;
1065 +       spi_message_add_tail(x, m);
1066 +
1067 +       m->complete = tsc2301_ts_rx;
1068 +       m->context = tsc;
1069 +}
1070 +
1071 +static ssize_t tsc2301_ts_pen_down_show(struct device *dev,
1072 +                                       struct device_attribute *attr,
1073 +                                       char *buf)
1074 +{
1075 +       struct tsc2301 *tsc = dev_get_drvdata(dev);
1076 +
1077 +       return sprintf(buf, "%u\n", tsc->ts->pen_down);
1078 +}
1079 +
1080 +static DEVICE_ATTR(pen_down, S_IRUGO, tsc2301_ts_pen_down_show, NULL);
1081 +
1082 +static ssize_t tsc2301_ts_disable_show(struct device *dev,
1083 +                                      struct device_attribute *attr, char *buf)
1084 +{
1085 +       struct tsc2301          *tsc = dev_get_drvdata(dev);
1086 +       struct tsc2301_ts       *ts = tsc->ts;
1087 +
1088 +       return sprintf(buf, "%u\n", ts->disabled);
1089 +}
1090 +
1091 +static ssize_t tsc2301_ts_disable_store(struct device *dev,
1092 +                                       struct device_attribute *attr,
1093 +                                       const char *buf, size_t count)
1094 +{
1095 +       struct tsc2301          *tsc = dev_get_drvdata(dev);
1096 +       struct tsc2301_ts       *ts = tsc->ts;
1097 +       char *endp;
1098 +       int i;
1099 +
1100 +       i = simple_strtoul(buf, &endp, 10);
1101 +       i = i ? 1 : 0;
1102 +       mutex_lock(&ts->mutex);
1103 +       if (i == ts->disabled) goto out;
1104 +       ts->disabled = i;
1105 +
1106 +       if (i)
1107 +               tsc2301_ts_disable(tsc);
1108 +       else
1109 +               tsc2301_ts_enable(tsc);
1110 +out:
1111 +       mutex_unlock(&ts->mutex);
1112 +       return count;
1113 +}
1114 +
1115 +static DEVICE_ATTR(disable_ts, 0664, tsc2301_ts_disable_show,
1116 +                  tsc2301_ts_disable_store);
1117 +
1118 +int __devinit tsc2301_ts_init(struct tsc2301 *tsc,
1119 +                             struct tsc2301_platform_data *pdata)
1120 +{
1121 +       struct tsc2301_ts *ts;
1122 +       struct input_dev *idev;
1123 +       int r;
1124 +       int x_max, y_max;
1125 +       int x_fudge, y_fudge, p_fudge;
1126 +
1127 +       if (pdata->dav_int <= 0) {
1128 +               dev_err(&tsc->spi->dev, "need DAV IRQ");
1129 +               return -EINVAL;
1130 +       }
1131 +
1132 +       ts = kzalloc(sizeof(*ts), GFP_KERNEL);
1133 +       if (ts == NULL)
1134 +               return -ENOMEM;
1135 +       tsc->ts = ts;
1136 +
1137 +       ts->coords = kzalloc(sizeof(*ts->coords), GFP_KERNEL);
1138 +       if (ts->coords == NULL) {
1139 +               kfree(ts);
1140 +               return -ENOMEM;
1141 +       }
1142 +
1143 +       ts->irq = pdata->dav_int;
1144 +
1145 +       init_timer(&ts->penup_timer);
1146 +       setup_timer(&ts->penup_timer, tsc2301_ts_timer_handler,
1147 +                       (unsigned long)tsc);
1148 +
1149 +       mutex_init(&ts->mutex);
1150 +
1151 +       ts->x_plate_ohm = pdata->ts_x_plate_ohm ? : 280;
1152 +       ts->hw_avg_max  = pdata->ts_hw_avg;
1153 +       ts->max_pressure = pdata->ts_max_pressure ? : MAX_12BIT;
1154 +       ts->touch_pressure = pdata->ts_touch_pressure ? : ts->max_pressure;
1155 +       ts->stab_time   = pdata->ts_stab_time;
1156 +
1157 +       x_max           = pdata->ts_x_max ? : 4096;
1158 +       y_max           = pdata->ts_y_max ? : 4096;
1159 +       x_fudge         = pdata->ts_x_fudge ? : 4;
1160 +       y_fudge         = pdata->ts_y_fudge ? : 8;
1161 +       p_fudge         = pdata->ts_pressure_fudge ? : 2;
1162 +
1163 +       if ((r = tsc2301_ts_check_config(ts, &ts->hw_flags))) {
1164 +               dev_err(&tsc->spi->dev, "invalid configuration\n");
1165 +               goto err2;
1166 +       }
1167 +
1168 +       idev = input_allocate_device();
1169 +       if (idev == NULL) {
1170 +               r = -ENOMEM;
1171 +               goto err2;
1172 +       }
1173 +       idev->name = "TSC2301 touchscreen";
1174 +       snprintf(ts->phys, sizeof(ts->phys),
1175 +                "%s/input-ts", dev_name(&tsc->spi->dev));
1176 +       idev->phys = ts->phys;
1177 +       idev->dev.parent = &tsc->spi->dev;
1178 +
1179 +       idev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
1180 +       idev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
1181 +       ts->idev = idev;
1182 +
1183 +       tsc2301_ts_setup_spi_xfer(tsc);
1184 +
1185 +       /* These parameters should perhaps be configurable? */
1186 +       input_set_abs_params(idev, ABS_X, 0, x_max, x_fudge, 0);
1187 +       input_set_abs_params(idev, ABS_Y, 0, y_max, y_fudge, 0);
1188 +       input_set_abs_params(idev, ABS_PRESSURE, 0, ts->max_pressure,
1189 +                            p_fudge, 0);
1190 +
1191 +       tsc2301_ts_start_scan(tsc);
1192 +
1193 +       r = request_irq(ts->irq, tsc2301_ts_irq_handler,
1194 +                       IRQF_SAMPLE_RANDOM | IRQF_TRIGGER_FALLING,
1195 +                       "tsc2301-ts", tsc);
1196 +       if (r < 0) {
1197 +               dev_err(&tsc->spi->dev, "unable to get DAV IRQ");
1198 +               goto err3;
1199 +       }
1200 +       irq_set_irq_wake(ts->irq, 1);
1201 +
1202 +       if (device_create_file(&tsc->spi->dev, &dev_attr_pen_down) < 0)
1203 +               goto err4;
1204 +       if (device_create_file(&tsc->spi->dev, &dev_attr_disable_ts) < 0)
1205 +               goto err5;
1206 +
1207 +       r = input_register_device(idev);
1208 +       if (r < 0) {
1209 +               dev_err(&tsc->spi->dev, "can't register touchscreen device\n");
1210 +               goto err6;
1211 +       }
1212 +
1213 +       return 0;
1214 +err6:
1215 +       device_remove_file(&tsc->spi->dev, &dev_attr_disable_ts);
1216 +err5:
1217 +       device_remove_file(&tsc->spi->dev, &dev_attr_pen_down);
1218 +err4:
1219 +       free_irq(ts->irq, tsc);
1220 +err3:
1221 +       tsc2301_ts_stop_scan(tsc);
1222 +       input_free_device(idev);
1223 +err2:
1224 +       kfree(ts->coords);
1225 +       kfree(ts);
1226 +       return r;
1227 +}
1228 +
1229 +void __devexit tsc2301_ts_exit(struct tsc2301 *tsc)
1230 +{
1231 +       struct tsc2301_ts *ts = tsc->ts;
1232 +
1233 +       tsc2301_ts_disable(tsc);
1234 +
1235 +       device_remove_file(&tsc->spi->dev, &dev_attr_disable_ts);
1236 +       device_remove_file(&tsc->spi->dev, &dev_attr_pen_down);
1237 +
1238 +       free_irq(ts->irq, tsc);
1239 +       input_unregister_device(ts->idev);
1240 +
1241 +       kfree(ts->coords);
1242 +       kfree(ts);
1243 +}
1244 +MODULE_AUTHOR("Jarkko Oikarinen <jarkko.oikarinen@nokia.com>");
1245 +MODULE_LICENSE("GPL");
1246 Index: linux-3.1/drivers/spi/Kconfig
1247 ===================================================================
1248 --- linux-3.1.orig/drivers/spi/Kconfig  2011-10-30 00:48:29.373056952 +0200
1249 +++ linux-3.1/drivers/spi/Kconfig       2011-10-30 00:48:48.989043470 +0200
1250 @@ -435,6 +435,28 @@ config SPI_TLE62X0
1251           sysfs interface, with each line presented as a kind of GPIO
1252           exposing both switch control and diagnostic feedback.
1253
1254 +config SPI_TSC2301
1255 +       tristate "TSC2301 driver"
1256 +       depends on SPI_MASTER
1257 +       help
1258 +         Say Y here if you have a TSC2301 chip connected to an SPI
1259 +         bus on your board.
1260 +
1261 +         The TSC2301 is a highly integrated PDA analog interface circuit.
1262 +         It contains a complete 12-bit A/D resistive touch screen
1263 +         converter (ADC) including drivers, touch pressure measurement
1264 +         capability, keypad controller, and 8-bit D/A converter (DAC) output
1265 +         for LCD contrast control.
1266 +
1267 +         To compile this driver as a module, choose M here: the
1268 +         module will be called tsc2301.
1269 +
1270 +config SPI_TSC2301_AUDIO
1271 +       boolean "TSC2301 audio support"
1272 +       depends on SPI_TSC2301 && SND
1273 +       help
1274 +         Say Y here for if you are using the audio features of TSC2301.
1275 +
1276  #
1277  # Add new SPI protocol masters in alphabetical order above this line
1278  #
1279 Index: linux-3.1/drivers/spi/Makefile
1280 ===================================================================
1281 --- linux-3.1.orig/drivers/spi/Makefile 2011-10-30 00:48:29.385056944 +0200
1282 +++ linux-3.1/drivers/spi/Makefile      2011-10-30 00:48:48.989043470 +0200
1283 @@ -59,4 +59,6 @@ obj-$(CONFIG_SPI_TLE62X0)             += spi-tle62x
1284  obj-$(CONFIG_SPI_TOPCLIFF_PCH)         += spi-topcliff-pch.o
1285  obj-$(CONFIG_SPI_TXX9)                 += spi-txx9.o
1286  obj-$(CONFIG_SPI_XILINX)               += spi-xilinx.o
1287 -
1288 +obj-$(CONFIG_SPI_TSC2301)              += tsc2301.o
1289 +tsc2301-objs                           := tsc2301-core.o
1290 +tsc2301-$(CONFIG_SPI_TSC2301_AUDIO)    += tsc2301-mixer.o
1291 Index: linux-3.1/drivers/spi/tsc2301-core.c
1292 ===================================================================
1293 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1294 +++ linux-3.1/drivers/spi/tsc2301-core.c        2011-10-30 00:48:48.989043470 +0200
1295 @@ -0,0 +1,297 @@
1296 +/*
1297 + * TSC2301 driver
1298 + *
1299 + * Copyright (C) 2005, 2006 Nokia Corporation
1300 + *
1301 + * This program is free software; you can redistribute it and/or modify
1302 + * it under the terms of the GNU General Public License as published by
1303 + * the Free Software Foundation; either version 2 of the License, or
1304 + * (at your option) any later version.
1305 + *
1306 + * This program is distributed in the hope that it will be useful,
1307 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
1308 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1309 + * GNU General Public License for more details.
1310 + *
1311 + * You should have received a copy of the GNU General Public License
1312 + * along with this program; if not, write to the Free Software
1313 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1314 + *
1315 + */
1316 +
1317 +#include <linux/module.h>
1318 +#include <linux/device.h>
1319 +#include <linux/delay.h>
1320 +#include <linux/gpio.h>
1321 +#include <linux/spi/spi.h>
1322 +#include <linux/spi/tsc2301.h>
1323 +
1324 +u16 tsc2301_read_reg(struct tsc2301 *tsc, int reg)
1325 +{
1326 +       struct spi_transfer t[2];
1327 +       struct spi_message m;
1328 +       u16 data = 0, cmd;
1329 +
1330 +       cmd = reg;
1331 +       cmd |= 0x8000;
1332 +
1333 +       memset(t, 0, sizeof(t));
1334 +       spi_message_init(&m);
1335 +       m.spi = tsc->spi;
1336 +
1337 +       t[0].tx_buf = &cmd;
1338 +       t[0].rx_buf = NULL;
1339 +       t[0].len = 2;
1340 +       spi_message_add_tail(&t[0], &m);
1341 +
1342 +       t[1].tx_buf = NULL;
1343 +       t[1].rx_buf = &data;
1344 +       t[1].len = 2;
1345 +       spi_message_add_tail(&t[1], &m);
1346 +
1347 +       spi_sync(m.spi, &m);
1348 +
1349 +       return data;
1350 +}
1351 +
1352 +void tsc2301_write_reg(struct tsc2301 *tsc, int reg, u16 val)
1353 +{
1354 +       struct spi_transfer t;
1355 +       struct spi_message m;
1356 +       u16 data[2];
1357 +
1358 +       /* Now we prepare the command for transferring */
1359 +       data[0] = reg;
1360 +       data[1] = val;
1361 +
1362 +       spi_message_init(&m);
1363 +       m.spi = tsc->spi;
1364 +
1365 +       memset(&t, 0, sizeof(t));
1366 +       t.tx_buf = data;
1367 +       t.rx_buf = NULL;
1368 +       t.len = 4;
1369 +       spi_message_add_tail(&t, &m);
1370 +
1371 +       spi_sync(m.spi, &m);
1372 +}
1373 +
1374 +void tsc2301_write_kbc(struct tsc2301 *tsc, int val)
1375 +{
1376 +       u16 w;
1377 +
1378 +       w = tsc->config2_shadow;
1379 +       w &= ~(0x03 << 14);
1380 +       w |= (val & 0x03) << 14;
1381 +       tsc2301_write_reg(tsc, TSC2301_REG_CONFIG2, w);
1382 +       tsc->config2_shadow = w;
1383 +}
1384 +
1385 +void tsc2301_write_pll(struct tsc2301 *tsc,
1386 +                      int pll_n, int pll_a, int pll_pdc, int pct_e, int pll_o)
1387 +{
1388 +       u16 w;
1389 +
1390 +       w = tsc->config2_shadow;
1391 +       w &= ~0x3fff;
1392 +       w |= (pll_n & 0x0f) | ((pll_a & 0x0f) << 4) | ((pll_pdc & 0x0f) << 8);
1393 +       w |= pct_e ? (1 << 12) : 0;
1394 +       w |= pll_o ? (1 << 13) : 0;
1395 +       tsc2301_write_reg(tsc, TSC2301_REG_CONFIG2, w);
1396 +       tsc->config2_shadow = w;
1397 +}
1398 +
1399 +void tsc2301_read_buf(struct tsc2301 *tsc, int reg, u16 *rx_buf, int len)
1400 +{
1401 +       struct spi_transfer t[2];
1402 +       struct spi_message m;
1403 +       u16 cmd, i;
1404 +
1405 +       cmd = reg;
1406 +       cmd |= 0x8000;
1407 +
1408 +       spi_message_init(&m);
1409 +       m.spi = tsc->spi;
1410 +
1411 +       memset(t, 0, sizeof(t));
1412 +       t[0].tx_buf = &cmd;
1413 +       t[0].rx_buf = NULL;
1414 +       t[0].len = 2;
1415 +       spi_message_add_tail(&t[0], &m);
1416 +
1417 +       t[1].tx_buf = NULL;
1418 +       t[1].rx_buf = rx_buf;
1419 +       t[1].len = 2 * len;
1420 +       spi_message_add_tail(&t[1], &m);
1421 +
1422 +       spi_sync(m.spi, &m);
1423 +
1424 +       for (i = 0; i < len; i++)
1425 +               printk(KERN_DEBUG "rx_buf[%d]: %04x\n", i, rx_buf[i]);
1426 +}
1427 +
1428 +static int __devinit tsc2301_probe(struct spi_device *spi)
1429 +{
1430 +       struct tsc2301                  *tsc;
1431 +       struct tsc2301_platform_data    *pdata = spi->dev.platform_data;
1432 +       int r;
1433 +       u16 w;
1434 +
1435 +       if (!pdata) {
1436 +               dev_dbg(&spi->dev, "no platform data?\n");
1437 +               return -ENODEV;
1438 +       }
1439 +
1440 +       tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
1441 +       if (tsc == NULL)
1442 +               return -ENOMEM;
1443 +
1444 +       dev_set_drvdata(&spi->dev, tsc);
1445 +       tsc->spi = spi;
1446 +
1447 +       tsc->enable_clock = pdata->enable_clock;
1448 +       tsc->disable_clock = pdata->disable_clock;
1449 +
1450 +       if (pdata->reset_gpio >= 0) {
1451 +               tsc->reset_gpio = pdata->reset_gpio;
1452 +               r = gpio_request(tsc->reset_gpio, "TSC2301 reset");
1453 +               if (r < 0)
1454 +                       goto err1;
1455 +               gpio_direction_output(tsc->reset_gpio, 1);
1456 +               mdelay(1);
1457 +               gpio_set_value(tsc->reset_gpio, 0);
1458 +       } else
1459 +               tsc->reset_gpio = -1;
1460 +
1461 +       spi->mode = SPI_MODE_1;
1462 +       spi->bits_per_word = 16;
1463 +       /* The max speed might've been defined by the board-specific
1464 +        * struct */
1465 +       if (!spi->max_speed_hz)
1466 +               spi->max_speed_hz = TSC2301_HZ;
1467 +       spi_setup(spi);
1468 +
1469 +       /* Soft reset */
1470 +       tsc2301_write_reg(tsc, TSC2301_REG_RESET, 0xbb00);
1471 +       msleep(1);
1472 +
1473 +       w = tsc2301_read_reg(tsc, TSC2301_REG_ADC);
1474 +       if (!(w & (1 << 14))) {
1475 +               dev_err(&spi->dev, "invalid ADC reg value: %04x\n", w);
1476 +               r = -ENODEV;
1477 +               goto err1;
1478 +       }
1479 +
1480 +       w = tsc2301_read_reg(tsc, TSC2301_REG_DAC);
1481 +       if (!(w & (1 << 15))) {
1482 +               dev_err(&spi->dev, "invalid DAC reg value: %04x\n", w);
1483 +               r = -ENODEV;
1484 +               goto err1;
1485 +       }
1486 +
1487 +       /* Stop keypad scanning */
1488 +       tsc2301_write_reg(tsc, TSC2301_REG_KEY, 0x4000);
1489 +
1490 +       /* We have to cache this for read-modify-write, since we can't
1491 +        * read back BIT15 */
1492 +       w = tsc2301_read_reg(tsc, TSC2301_REG_CONFIG2);
1493 +       /* By default BIT15 is set */
1494 +       w |= 1 << 15;
1495 +       tsc->config2_shadow = w;
1496 +
1497 +       r = tsc2301_kp_init(tsc, pdata);
1498 +       if (r)
1499 +               goto err1;
1500 +       r = tsc2301_ts_init(tsc, pdata);
1501 +       if (r)
1502 +               goto err2;
1503 +       r = tsc2301_mixer_init(tsc, pdata);
1504 +       if (r)
1505 +               goto err3;
1506 +       return 0;
1507 +
1508 +err3:
1509 +       tsc2301_ts_exit(tsc);
1510 +err2:
1511 +       tsc2301_kp_exit(tsc);
1512 +err1:
1513 +       kfree(tsc);
1514 +       return r;
1515 +}
1516 +
1517 +static int __devexit tsc2301_remove(struct spi_device *spi)
1518 +{
1519 +       struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
1520 +
1521 +       tsc2301_mixer_exit(tsc);
1522 +       tsc2301_ts_exit(tsc);
1523 +       tsc2301_kp_exit(tsc);
1524 +       if (tsc->reset_gpio >= 0)
1525 +               gpio_free(tsc->reset_gpio);
1526 +       kfree(tsc);
1527 +
1528 +       return 0;
1529 +}
1530 +
1531 +#ifdef CONFIG_PM
1532 +static int tsc2301_suspend(struct spi_device *spi, pm_message_t mesg)
1533 +{
1534 +       struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
1535 +       int r;
1536 +
1537 +       if ((r = tsc2301_mixer_suspend(tsc)) < 0)
1538 +               return r;
1539 +       if ((r = tsc2301_kp_suspend(tsc)) < 0)
1540 +               goto err1;
1541 +       if ((r = tsc2301_ts_suspend(tsc)) < 0)
1542 +               goto err2;
1543 +
1544 +       return 0;
1545 +err2:
1546 +       tsc2301_kp_resume(tsc);
1547 +err1:
1548 +       tsc2301_mixer_resume(tsc);
1549 +       return r;
1550 +}
1551 +
1552 +static int tsc2301_resume(struct spi_device *spi)
1553 +{
1554 +       struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
1555 +
1556 +       tsc2301_ts_resume(tsc);
1557 +       tsc2301_kp_resume(tsc);
1558 +       tsc2301_mixer_resume(tsc);
1559 +       return 0;
1560 +}
1561 +#endif
1562 +
1563 +static struct spi_driver tsc2301_driver = {
1564 +       .driver = {
1565 +                  .name = "tsc2301",
1566 +                  .bus = &spi_bus_type,
1567 +                  .owner = THIS_MODULE,
1568 +       },
1569 +#ifdef CONFIG_PM
1570 +       .suspend = tsc2301_suspend,
1571 +       .resume = tsc2301_resume,
1572 +#endif
1573 +       .probe = tsc2301_probe,
1574 +       .remove = __devexit_p(tsc2301_remove),
1575 +};
1576 +
1577 +static int __init tsc2301_init(void)
1578 +{
1579 +       printk("TSC2301 driver initializing\n");
1580 +
1581 +       return spi_register_driver(&tsc2301_driver);
1582 +}
1583 +module_init(tsc2301_init);
1584 +
1585 +static void __exit tsc2301_exit(void)
1586 +{
1587 +       spi_unregister_driver(&tsc2301_driver);
1588 +}
1589 +module_exit(tsc2301_exit);
1590 +
1591 +MODULE_AUTHOR("Juha Yrjölä <juha.yrjola@nokia.com>");
1592 +MODULE_LICENSE("GPL");
1593 Index: linux-3.1/drivers/spi/tsc2301-mixer.c
1594 ===================================================================
1595 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
1596 +++ linux-3.1/drivers/spi/tsc2301-mixer.c       2011-10-30 00:48:48.989043470 +0200
1597 @@ -0,0 +1,1003 @@
1598 +/*
1599 + * ALSA Mixer implementation for TSC2301
1600 + *
1601 + * Copyright (C) 2006 Nokia Corporation.
1602 + *
1603 + * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
1604 + *          Juha Yrjola
1605 + *
1606 + * Some notes about TSC2301:
1607 + * - PLL will stop when DAC and ADC's are powered down.
1608 + * - Touchscreen will stop working when audio part is powered up and if audio
1609 + *   MCLK is stopped. Problem is avoided if audio is powered down before
1610 + *   stopping MCLK.
1611 + * - Audio DAC or audio outputs will activate only after 100 msec from the
1612 + *   chip power-up. Reason seems to be VCM since there is no this delay if the
1613 + *   chip and VCM (bit AVPD on PD/MISC) were not powered down. The chip will
1614 + *   consume about 1 mA if all other audio blocks are powered down except the
1615 + *   chip itself and VCM. Full power down consumes only about few uA.
1616 + * - Power-down transition could happen earliest about 100 msec after the chip
1617 + *   power-up. Otherwise power-down will fail if there is no that 100 msec
1618 + *   on time before it. It's not obvious why is that since chip reports
1619 + *   power-up to be completed and also PLL output on GPIO_0 is active in few
1620 + *   milliseconds.
1621 + *
1622 + * This program is free software; you can redistribute it and/or
1623 + * modify it under the terms of the GNU General Public License
1624 + * version 2 as published by the Free Software Foundation.
1625 + *
1626 + * This program is distributed in the hope that it will be useful, but
1627 + * WITHOUT ANY WARRANTY; without even the implied warranty of
1628 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
1629 + * General Public License for more details.
1630 + *
1631 + * You should have received a copy of the GNU General Public License
1632 + * along with this program; if not, write to the Free Software
1633 + * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
1634 + * 02110-1301 USA
1635 + *
1636 + */
1637 +
1638 +#include <linux/module.h>
1639 +#include <linux/device.h>
1640 +#include <linux/errno.h>
1641 +#include <linux/delay.h>
1642 +#include <linux/slab.h>
1643 +#include <linux/spi/spi.h>
1644 +#include <linux/spi/tsc2301.h>
1645 +
1646 +#include <sound/core.h>
1647 +#include <sound/control.h>
1648 +
1649 +/* shadow register indexes */
1650 +enum {
1651 +       /* audio control and volume registers */
1652 +       AUDCNTL_INDEX,
1653 +       ADCVOL_INDEX,
1654 +       DACVOL_INDEX,
1655 +       BPVOL_INDEX,
1656 +       /* keyclick control register (not needed here) */
1657 +       /* audio power control register */
1658 +       PD_MISC_INDEX,
1659 +       /* TSC2301 GPIO control register */
1660 +       GPIO_INDEX,
1661 +
1662 +       SHADOW_REG_COUNT,
1663 +};
1664 +
1665 +/* structure for driver private data */
1666 +struct tsc2301_mixer {
1667 +       struct tsc2301 *tsc;
1668 +       struct mutex mutex;
1669 +
1670 +       /* shadow registers holding TSC2301 audio registers. Used to hold
1671 +        * their states during the sleep and also to reduce communication with
1672 +        * the chip since get callback functions could get register values
1673 +        * directly from these shadow registers without needing to read them
1674 +        * from the chip */
1675 +       u16 shadow_regs[SHADOW_REG_COUNT];
1676 +
1677 +       /* audio controller driver usage of the ADC and DAC */
1678 +       unsigned adc_enabled:1, dac_enabled:1;
1679 +       unsigned pll_output:1;
1680 +       unsigned mclk_enabled;
1681 +
1682 +       /* latest audio power-up timestamp */
1683 +       unsigned long pu_jiffies;
1684 +
1685 +       /* these are used when upper layer(s) are going to power-down TSC2301
1686 +        * before 100 msec is passed from power-up */
1687 +       struct delayed_work delayed_power_down;
1688 +       unsigned delayed_pd_active:1;
1689 +
1690 +       int (* platform_init)(struct device *);
1691 +       void (* platform_cleanup)(struct device *);
1692 +
1693 +       struct tsc2301_mixer_gpio *mixer_gpios;
1694 +       int n_mixer_gpios;
1695 +};
1696 +
1697 +#define TSC2301_DAC_DELAY              msecs_to_jiffies(100)
1698 +#define TSC2301_MIN_PU_PERIOD          msecs_to_jiffies(100)
1699 +
1700 +#define TSC2301_REG_TO_PVAL(reg)       \
1701 +       (TSC2301_REG_TO_PAGE(reg) << 6 | TSC2301_REG_TO_ADDR(reg))
1702 +#define  TSC2301_PVAL_TO_REG(v)                \
1703 +       (TSC2301_REG((((v) >> 6) & 3),((v) & 0x1f)))
1704 +
1705 +#define TSC2301_VOLUME_MASK            0x7f
1706 +#define TSC2301_MIN_ADCVOL             6
1707 +#define TSC2301_MIN_DACVOL             0
1708 +#define TSC2301_MIN_BPVOL              31
1709 +#define TSC2301_MUTE_LEFT_SHIFT                15
1710 +#define TSC2301_VOL_LEFT_SHIFT         8
1711 +#define TSC2301_MUTE_RIGHT_SHIFT       7
1712 +#define TSC2301_VOL_RIGHT_SHIFT                0
1713 +
1714 +#define TSC2301_INM_MASK               3
1715 +#define TSC2301_INML_SHIFT             12
1716 +#define TSC2301_INMR_SHIFT             10
1717 +
1718 +#define TSC2301_MICG_MASK              3
1719 +#define TSC2301_MICG_MIN               1 /* values 0 & 1 both mean 0 dB */
1720 +#define TSC2301_MICG_SHIFT             8
1721 +
1722 +#define TSC2301_REG_AUDCNTL_MCLK(v)    (((v) & 3) << 6)
1723 +#define TSC2301_REG_AUDCNTL_I2SFS(v)   (((v) & 0xf) << 2)
1724 +#define TSC2301_REG_AUDCNTL_I2SFM(v)   (((v) & 3) << 0)
1725 +
1726 +#define TSC2301_SINGLE(xname, xindex, reg, shadow_index, shift, mask, min) \
1727 +{\
1728 +       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1729 +       .name = xname, \
1730 +       .index = xindex, \
1731 +       .info = snd_tsc2301_info_single, \
1732 +       .get = snd_tsc2301_get_single, \
1733 +       .put = snd_tsc2301_put_single, \
1734 +       .private_value = TSC2301_REG_TO_PVAL(reg) | \
1735 +               (shadow_index << 8) | (shift << 16) | (mask << 24) | \
1736 +               (min << 28) \
1737 +}
1738 +#define TSC2301_SINGLE_MINVAL(v)       (((v) >> 28) & 15)
1739 +#define TSC2301_SINGLE_SHIFT(v)                (((v) >> 16) & 15)
1740 +#define TSC2301_SINGLE_MASK(v)         (((v) >> 24) & 15)
1741 +
1742 +#define TSC2301_DOUBLE(xname, xindex, reg, shadow_index, ls, rs, mask, min) \
1743 +{\
1744 +       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1745 +       .name = xname, \
1746 +       .index = xindex, \
1747 +       .info = snd_tsc2301_info_double, \
1748 +       .get = snd_tsc2301_get_double, \
1749 +       .put = snd_tsc2301_put_double, \
1750 +       .private_value = TSC2301_REG_TO_PVAL(reg) | \
1751 +               (shadow_index << 8) | (min << 11) | \
1752 +               (ls << 16) | (rs << 20) | (mask << 24) \
1753 +}
1754 +#define TSC2301_DOUBLE_MINVAL(v)       (((v) >> 11) & 0x1f)
1755 +#define TSC2301_DOUBLE_LEFT_SHIFT(v)   (((v) >> 16) & 15)
1756 +#define TSC2301_DOUBLE_RIGHT_SHIFT(v)  (((v) >> 20) & 15)
1757 +#define TSC2301_DOUBLE_MASK(v)         (((v) >> 24) & TSC2301_VOLUME_MASK)
1758 +
1759 +#define TSC2301_MUX(xname, xindex, reg, shadow_index, ls, rs, mask) \
1760 +{\
1761 +       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1762 +       .name = xname, \
1763 +       .index = xindex, \
1764 +       .info = snd_tsc2301_info_mux, \
1765 +       .get = snd_tsc2301_get_mux, \
1766 +       .put = snd_tsc2301_put_mux, \
1767 +       .private_value = TSC2301_REG_TO_PVAL(reg) | \
1768 +               (shadow_index << 8) | (ls << 16) | (rs << 20) | (mask << 24) \
1769 +}
1770 +#define TSC2301_MUX_LEFT_SHIFT(v)      (((v) >> 16) & 15)
1771 +#define TSC2301_MUX_RIGHT_SHIFT(v)     (((v) >> 20) & 15)
1772 +#define TSC2301_MUX_MASK(v)            (((v) >> 24) & TSC2301_VOLUME_MASK)
1773 +
1774 +#define TSC2301_BOOL(xname, xindex, reg, shadow_index, shift, invert, state) \
1775 +{ \
1776 +       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1777 +       .name = xname, \
1778 +       .index = xindex, \
1779 +       .info = snd_tsc2301_info_bool, \
1780 +       .get = snd_tsc2301_get_bool, \
1781 +       .put = snd_tsc2301_put_bool, \
1782 +       .private_value = TSC2301_REG_TO_PVAL(reg) | \
1783 +               (shadow_index << 8) | (shift << 16) | \
1784 +               (invert << 24) | (state << 25) \
1785 +}
1786 +#define TSC2301_BOOL_SHIFT(v)          (((v) >> 16) & 7)
1787 +#define TSC2301_BOOL_INVERT(v)         (((v) >> 24) & 1)
1788 +#define TSC2301_BOOL_STATE(v)          (((v) >> 25) & 1)
1789 +
1790 +#define TSC2301_SHADOW_INDEX(v)                (((v) >> 8) & 7)
1791 +
1792 +/*
1793 + * Power-down handler for additional GPIO mixer controls. GPIO state of GPIO
1794 + * controls whose power-down flag is enabled are set to their false/deactivate
1795 + * state
1796 + *
1797 + * Must be called tsc->mixer->mutex locked
1798 + */
1799 +static void tsc2301_gpio_power_down(struct tsc2301 *tsc)
1800 +{
1801 +       struct tsc2301_mixer *mix = tsc->mixer;
1802 +       u16 temp;
1803 +       int i;
1804 +
1805 +       temp = mix->shadow_regs[GPIO_INDEX];
1806 +       for (i = 0; i < mix->n_mixer_gpios; i++) {
1807 +               const struct tsc2301_mixer_gpio *mg;
1808 +
1809 +               mg = mix->mixer_gpios + i;
1810 +               if (mg->deactivate_on_pd) {
1811 +                       int gpio = mg->gpio;
1812 +
1813 +                       temp &= ~(1 << gpio);
1814 +                       temp |= mg->inverted << gpio;
1815 +               }
1816 +       }
1817 +       tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
1818 +}
1819 +
1820 +/*
1821 + * Powers down/up audio blocks which are muted or become unused.
1822 + * shadow_index >= 0, changes power state of single audio block
1823 + * shadow_index < 0, changes power state of all blocks
1824 + *
1825 + * Must be called tsc->mixer->mutex locked
1826 + */
1827 +#define TSC2301_MUTE_MASK \
1828 +       ((1 << TSC2301_MUTE_LEFT_SHIFT) | (1 << TSC2301_MUTE_RIGHT_SHIFT))
1829 +static void tsc2301_power_ctrl(struct tsc2301 *tsc, int shadow_index,
1830 +                              int poll_pdsts)
1831 +{
1832 +       struct tsc2301_mixer *mix = tsc->mixer;
1833 +       u16 pd_ctrl, pd_ctrl_old, w;
1834 +       unsigned long timeout;
1835 +       int power_up = 0;
1836 +
1837 +       if (mix->delayed_pd_active) {
1838 +               mix->delayed_pd_active = 0;
1839 +               mix->mclk_enabled--;
1840 +               cancel_delayed_work(&mix->delayed_power_down);
1841 +       }
1842 +
1843 +       pd_ctrl = pd_ctrl_old = mix->shadow_regs[PD_MISC_INDEX];
1844 +       /* power control helper based on used space mixer selections. See
1845 +        * actual power control decisions below */
1846 +       if (shadow_index < 0 || shadow_index == ADCVOL_INDEX) {
1847 +               /* ADC left and right power down control */
1848 +               if (mix->shadow_regs[ADCVOL_INDEX] &
1849 +                   (1 << TSC2301_MUTE_LEFT_SHIFT))
1850 +                       /* left ADC muted. Power down the left ADC */
1851 +                       pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
1852 +               else
1853 +                       pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDL;
1854 +               if (mix->shadow_regs[ADCVOL_INDEX] &
1855 +                   (1 << TSC2301_MUTE_LEFT_SHIFT))
1856 +                       /* right ADC muted. Power down the right ADC */
1857 +                       pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
1858 +               else
1859 +                       pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDR;
1860 +       }
1861 +       if (shadow_index < 0 || shadow_index == DACVOL_INDEX) {
1862 +               /* DAC power down control */
1863 +               if ((mix->shadow_regs[DACVOL_INDEX] &
1864 +                    TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
1865 +                       /* both DACs muted. Power down the DAC */
1866 +                       pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
1867 +               else
1868 +                       pd_ctrl &= ~TSC2301_REG_PD_MISC_DAPD;
1869 +       }
1870 +       if (shadow_index < 0 || shadow_index == BPVOL_INDEX) {
1871 +               /* line bypass power down control */
1872 +               if ((mix->shadow_regs[BPVOL_INDEX] &
1873 +                    TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
1874 +                       /* both line bypasses muted. Power down the bypass
1875 +                        * path */
1876 +                       pd_ctrl |= TSC2301_REG_PD_MISC_ABPD;
1877 +               else
1878 +                       pd_ctrl &= ~TSC2301_REG_PD_MISC_ABPD;
1879 +       }
1880 +       if (shadow_index < 0 || shadow_index == AUDCNTL_INDEX) {
1881 +               /* mic bias power down control */
1882 +               if ((mix->shadow_regs[AUDCNTL_INDEX] &
1883 +                    (3 << TSC2301_INML_SHIFT)) &&
1884 +                   (mix->shadow_regs[AUDCNTL_INDEX] &
1885 +                    (3 << TSC2301_INMR_SHIFT)))
1886 +                       /* both ADC channels use other than mic input. Power
1887 +                        * down the mic bias output */
1888 +                       pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
1889 +               else
1890 +                       pd_ctrl &= ~TSC2301_REG_PD_MISC_MIBPD;
1891 +       }
1892 +
1893 +       /* power control decisions based on codec usage and user space mixer
1894 +        * selections detected above */
1895 +       pd_ctrl &= ~TSC2301_REG_PD_MISC_APD; /* audio not powered down */
1896 +       if (mix->mclk_enabled) {
1897 +               if (!mix->adc_enabled) {
1898 +                       /* ADC not used, power down both ADC's and mic bias
1899 +                        * output independently of user space mixer
1900 +                        * selections */
1901 +                       pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
1902 +                       pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
1903 +                       pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
1904 +               }
1905 +               if (!mix->dac_enabled) {
1906 +                       /* DAC not used, power down DAC independently of user
1907 +                        * space mixer selections */
1908 +                       pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
1909 +               }
1910 +
1911 +               if (mix->pll_output) {
1912 +                       /* GPIO_0 is configured as PLL output so audio
1913 +                        * controller is expecting clock from TSC2301. Either
1914 +                        * ADC or DAC must be active in order to keep PLL on */
1915 +                       if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
1916 +                           (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
1917 +                           (pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
1918 +                               /* neither ADC or DAC used. Force ADC on in
1919 +                                * order to keep PLL active */
1920 +                               pd_ctrl &= ~(TSC2301_REG_PD_MISC_ADPDL |
1921 +                                            TSC2301_REG_PD_MISC_ADPDR);
1922 +                       }
1923 +               }
1924 +       } else {
1925 +               /* audio input clock is not enabled so power down DAC and ADC
1926 +                * in order to shutdown PLL and to keep touchscreen and keypad
1927 +                * parts working. Touchscreen and keypad use audio clock when
1928 +                * PLL is on and internal clock otherwise */
1929 +               pd_ctrl |= TSC2301_REG_PD_MISC_DAPD |
1930 +                          TSC2301_REG_PD_MISC_ADPDL |
1931 +                          TSC2301_REG_PD_MISC_ADPDR;
1932 +       }
1933 +
1934 +       if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
1935 +           (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
1936 +           (pd_ctrl & TSC2301_REG_PD_MISC_DAPD) &&
1937 +           (pd_ctrl & TSC2301_REG_PD_MISC_ABPD)) {
1938 +               /* all ADC, DAC and line bypass path unused. Power down the
1939 +                * whole audio part of the TSC2301 */
1940 +               pd_ctrl |= TSC2301_REG_PD_MISC_APD;
1941 +       }
1942 +
1943 +       if (pd_ctrl == pd_ctrl_old)
1944 +               return;
1945 +
1946 +       /* power down control changed. Update into TSC2301 */
1947 +       if ((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_APD) {
1948 +               /* whole audio power state changed. Update GPIO states */
1949 +               if (pd_ctrl & TSC2301_REG_PD_MISC_APD) {
1950 +                       /* power down GPIO controls before powering down
1951 +                        * the codec */
1952 +                       tsc2301_gpio_power_down(tsc);
1953 +                       /* we must really ensure that codec has been on no less
1954 +                        * than 100 msec before doing power-down */
1955 +                       timeout = mix->pu_jiffies + TSC2301_MIN_PU_PERIOD -
1956 +                                 jiffies;
1957 +                       if (timeout <= TSC2301_MIN_PU_PERIOD) {
1958 +                               mix->delayed_pd_active = 1;
1959 +                               mix->mclk_enabled++;
1960 +                               schedule_delayed_work(&mix->delayed_power_down,
1961 +                                                     timeout + 1);
1962 +                               return;
1963 +                       }
1964 +               } else
1965 +                       /* restore GPIOs after codec is powered up */
1966 +                       power_up = 1;
1967 +       }
1968 +       mix->shadow_regs[PD_MISC_INDEX] = pd_ctrl;
1969 +       tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC, pd_ctrl);
1970 +       if (power_up)
1971 +               mix->pu_jiffies = jiffies;
1972 +       if (!poll_pdsts) {
1973 +               if (power_up)
1974 +                       tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
1975 +                                         mix->shadow_regs[GPIO_INDEX]);
1976 +               return;
1977 +       }
1978 +
1979 +       /* wait until power-up/-down is completed */
1980 +       timeout = jiffies + msecs_to_jiffies(100);
1981 +       w = 0;
1982 +       do {
1983 +               if (time_after(jiffies, timeout)) {
1984 +                       /* Print a warning only if the I2S clock is not
1985 +                        * present / out of sync. This can happen during
1986 +                        * init time, when that clock will be turned on
1987 +                        * by another driver like in the OMAP EAC with
1988 +                        * external clock case.
1989 +                        */
1990 +                       if (w & TSC2301_REG_PD_MISC_OTSYN) {
1991 +                               dev_warn(&tsc->spi->dev,
1992 +                                  "I2S clock not in sync or off.\n");
1993 +                       } else {
1994 +                               dev_err(&tsc->spi->dev,
1995 +                                  "power-up/-down timed out "
1996 +                                  "(0x%04x, 0x%04x -> 0x%04x)\n",
1997 +                                  w, pd_ctrl_old, pd_ctrl);
1998 +                       }
1999 +                       goto out;
2000 +               }
2001 +               w = tsc2301_read_reg(tsc, TSC2301_REG_PD_MISC);
2002 +       } while (!(w & TSC2301_REG_PD_MISC_PDSTS));
2003 +
2004 +out:
2005 +       if (((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_DAPD) &&
2006 +           !(pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
2007 +               /* DAC powered up now. Ensure that DAC and audio outputs are
2008 +                * activated. They are up 100 msec after the chip power-up
2009 +                * command */
2010 +               timeout = mix->pu_jiffies + TSC2301_DAC_DELAY - jiffies;
2011 +               if (timeout <= TSC2301_DAC_DELAY)
2012 +                       schedule_timeout_interruptible(timeout);
2013 +               /* FIXME: This is lazy. We restore GPIOs only after activating
2014 +                * the DAC. It would be better to do some kind of delayed GPIO
2015 +                * restore. That ensures that we restore them also if only ADC
2016 +                * path is activated. But this is required only if there is
2017 +                * some input amplifier, bias control, etc. and their power
2018 +                * state is under TSC GPIO control */
2019 +               tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
2020 +                                 mix->shadow_regs[GPIO_INDEX]);
2021 +       }
2022 +}
2023 +
2024 +static int snd_tsc2301_info_single(struct snd_kcontrol *kcontrol,
2025 +                                  struct snd_ctl_elem_info *uinfo)
2026 +{
2027 +       int mask = TSC2301_SINGLE_MASK(kcontrol->private_value);
2028 +       int minval = TSC2301_SINGLE_MINVAL(kcontrol->private_value);
2029 +
2030 +       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
2031 +       uinfo->count = 1;
2032 +       uinfo->value.integer.min = minval;
2033 +       uinfo->value.integer.max = mask;
2034 +
2035 +       return 0;
2036 +}
2037 +
2038 +static int snd_tsc2301_get_single(struct snd_kcontrol *kcontrol,
2039 +                                 struct snd_ctl_elem_value *ucontrol)
2040 +{
2041 +       struct tsc2301 *tsc = kcontrol->private_data;
2042 +       unsigned long priv = kcontrol->private_value;
2043 +       int mask = TSC2301_SINGLE_MASK(priv);
2044 +       int shift = TSC2301_SINGLE_SHIFT(priv);
2045 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2046 +       u16 shadow_reg;
2047 +
2048 +       shadow_reg = tsc->mixer->shadow_regs[shadow_index];
2049 +
2050 +       ucontrol->value.integer.value[0] = (shadow_reg >> shift) & mask;
2051 +
2052 +       return 0;
2053 +}
2054 +
2055 +static int snd_tsc2301_put_single(struct snd_kcontrol *kcontrol,
2056 +                                 struct snd_ctl_elem_value *ucontrol)
2057 +{
2058 +       struct tsc2301 *tsc = kcontrol->private_data;
2059 +       unsigned long priv = kcontrol->private_value;
2060 +       int mask = TSC2301_SINGLE_MASK(priv);
2061 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2062 +       u16 shadow_reg, shadow_reg_old;
2063 +       int shift = TSC2301_SINGLE_SHIFT(priv);
2064 +       int reg = TSC2301_PVAL_TO_REG(priv);
2065 +       int changed;
2066 +
2067 +       mutex_lock(&tsc->mixer->mutex);
2068 +       shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
2069 +
2070 +       /* zero bits to be modified */
2071 +       shadow_reg &= ~(mask << shift);
2072 +       /* modify with new value */
2073 +       shadow_reg |= ((ucontrol->value.integer.value[0] & mask) << shift);
2074 +
2075 +       changed = (shadow_reg != shadow_reg_old);
2076 +       tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
2077 +
2078 +       /* update into TSC2301 if necessary */
2079 +       if (changed)
2080 +               tsc2301_write_reg(tsc, reg, shadow_reg);
2081 +       mutex_unlock(&tsc->mixer->mutex);
2082 +
2083 +       return changed;
2084 +}
2085 +
2086 +static int snd_tsc2301_info_double(struct snd_kcontrol *kcontrol,
2087 +                                  struct snd_ctl_elem_info *uinfo)
2088 +{
2089 +       /* mask == 1 : Switch
2090 +        * mask > 1 : Max volume */
2091 +       int mask = TSC2301_DOUBLE_MASK(kcontrol->private_value);
2092 +       int minval = TSC2301_DOUBLE_MINVAL(kcontrol->private_value);
2093 +
2094 +       uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
2095 +               SNDRV_CTL_ELEM_TYPE_INTEGER;
2096 +       uinfo->count = 2;
2097 +       uinfo->value.integer.min = minval;
2098 +       uinfo->value.integer.max = mask;
2099 +
2100 +       return 0;
2101 +}
2102 +
2103 +static int snd_tsc2301_get_double(struct snd_kcontrol *kcontrol,
2104 +                                 struct snd_ctl_elem_value *ucontrol)
2105 +{
2106 +       struct tsc2301 *tsc = kcontrol->private_data;
2107 +       unsigned long priv = kcontrol->private_value;
2108 +       /* mask == 1 : Switch
2109 +        * mask > 1 : Volume */
2110 +       int mask = TSC2301_DOUBLE_MASK(priv);
2111 +       int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
2112 +       int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
2113 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2114 +       u16 shadow_reg;
2115 +
2116 +       shadow_reg = tsc->mixer->shadow_regs[shadow_index];
2117 +
2118 +       /* invert mute bits for the switches */
2119 +       if (mask == 1)
2120 +               shadow_reg = ~shadow_reg;
2121 +
2122 +       ucontrol->value.integer.value[0] = (shadow_reg >> ls) & mask;
2123 +       ucontrol->value.integer.value[1] = (shadow_reg >> rs) & mask;
2124 +
2125 +       return 0;
2126 +}
2127 +
2128 +static int snd_tsc2301_put_double(struct snd_kcontrol *kcontrol,
2129 +                                 struct snd_ctl_elem_value *ucontrol)
2130 +{
2131 +       struct tsc2301 *tsc = kcontrol->private_data;
2132 +       unsigned long priv = kcontrol->private_value;
2133 +       /* mask == 1 : Switch
2134 +        * mask > 1 : Volume */
2135 +       int mask = TSC2301_DOUBLE_MASK(priv);
2136 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2137 +       u16 shadow_reg, shadow_reg_old;
2138 +       int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
2139 +       int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
2140 +       int reg = TSC2301_PVAL_TO_REG(priv);
2141 +       int changed;
2142 +
2143 +       mutex_lock(&tsc->mixer->mutex);
2144 +       shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
2145 +
2146 +       /* zero bits to be modified */
2147 +       shadow_reg &= ~((mask << ls) | (mask << rs));
2148 +       /* modify with new value */
2149 +       if (mask == 1) {
2150 +               /* switch. Invert switch values for the mute bits */
2151 +               shadow_reg |=
2152 +                       ((~ucontrol->value.integer.value[0] & mask) << ls) |
2153 +                       ((~ucontrol->value.integer.value[1] & mask) << rs);
2154 +       } else {
2155 +               /* volume */
2156 +               shadow_reg |=
2157 +                       (ucontrol->value.integer.value[0] << ls) |
2158 +                       (ucontrol->value.integer.value[1] << rs);
2159 +       }
2160 +
2161 +       changed = (shadow_reg != shadow_reg_old);
2162 +       tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
2163 +
2164 +       /* update into TSC2301 if necessary */
2165 +       if (changed)
2166 +               tsc2301_write_reg(tsc, reg, shadow_reg);
2167 +
2168 +       if (mask == 1)
2169 +               /* check is need to power down/up audio blocks in case of
2170 +                * muted state change */
2171 +               tsc2301_power_ctrl(tsc, shadow_index, 0);
2172 +       mutex_unlock(&tsc->mixer->mutex);
2173 +
2174 +       return changed;
2175 +}
2176 +
2177 +static int snd_tsc2301_info_mux(struct snd_kcontrol *kcontrol,
2178 +                               struct snd_ctl_elem_info *uinfo)
2179 +{
2180 +       static char *texts[4] = {"Mic", "Line", "Line swapped", "Line mono"};
2181 +
2182 +       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
2183 +       uinfo->count = 2;
2184 +       uinfo->value.enumerated.items = 4;
2185 +       if (uinfo->value.enumerated.item > 3)
2186 +               uinfo->value.enumerated.item = 3;
2187 +       strcpy(uinfo->value.enumerated.name,
2188 +              texts[uinfo->value.enumerated.item]);
2189 +
2190 +       return 0;
2191 +}
2192 +
2193 +static int snd_tsc2301_get_mux(struct snd_kcontrol *kcontrol,
2194 +                              struct snd_ctl_elem_value *ucontrol)
2195 +{
2196 +       struct tsc2301 *tsc = kcontrol->private_data;
2197 +       unsigned long priv = kcontrol->private_value;
2198 +       int mask = TSC2301_MUX_MASK(priv);
2199 +       int ls = TSC2301_MUX_LEFT_SHIFT(priv);
2200 +       int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
2201 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2202 +       u16 shadow_reg;
2203 +
2204 +       shadow_reg = tsc->mixer->shadow_regs[shadow_index];
2205 +       ucontrol->value.enumerated.item[0] = (shadow_reg >> ls) & mask;
2206 +       ucontrol->value.enumerated.item[1] = (shadow_reg >> rs) & mask;
2207 +
2208 +       return 0;
2209 +}
2210 +
2211 +static int snd_tsc2301_put_mux(struct snd_kcontrol *kcontrol,
2212 +                              struct snd_ctl_elem_value *ucontrol)
2213 +{
2214 +       struct tsc2301 *tsc = kcontrol->private_data;
2215 +       unsigned long priv = kcontrol->private_value;
2216 +       int mask = TSC2301_MUX_MASK(priv);
2217 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2218 +       u16 shadow_reg, shadow_reg_old;
2219 +       int ls = TSC2301_MUX_LEFT_SHIFT(priv);
2220 +       int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
2221 +       int reg = TSC2301_PVAL_TO_REG(priv);
2222 +       int changed;
2223 +
2224 +       mutex_lock(&tsc->mixer->mutex);
2225 +       shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
2226 +
2227 +       /* zero bits to be modified */
2228 +       shadow_reg &= ~((mask << ls) | (mask << rs));
2229 +       /* modify with new value */
2230 +       shadow_reg |= (ucontrol->value.enumerated.item[0] << ls);
2231 +       shadow_reg |= (ucontrol->value.enumerated.item[1] << rs);
2232 +
2233 +       changed = (shadow_reg != shadow_reg_old);
2234 +
2235 +       /* update into TSC2301 if necessary */
2236 +       if (changed) {
2237 +               tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
2238 +               tsc2301_write_reg(tsc, reg, shadow_reg);
2239 +       }
2240 +
2241 +       /* check is need to power up/down audio blocks in case of ADC input
2242 +        * change */
2243 +       tsc2301_power_ctrl(tsc, shadow_index, 0);
2244 +       mutex_unlock(&tsc->mixer->mutex);
2245 +
2246 +       return changed;
2247 +}
2248 +
2249 +static int snd_tsc2301_info_bool(struct snd_kcontrol *kcontrol,
2250 +                                struct snd_ctl_elem_info *uinfo)
2251 +{
2252 +       uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
2253 +       uinfo->count = 1;
2254 +       uinfo->value.integer.min = 0;
2255 +       uinfo->value.integer.max = 1;
2256 +
2257 +       return 0;
2258 +}
2259 +
2260 +static int snd_tsc2301_get_bool(struct snd_kcontrol *kcontrol,
2261 +                               struct snd_ctl_elem_value *ucontrol)
2262 +{
2263 +       struct tsc2301 *tsc = kcontrol->private_data;
2264 +       unsigned long priv = kcontrol->private_value;
2265 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2266 +       int shift = TSC2301_BOOL_SHIFT(priv);
2267 +       int invert = TSC2301_BOOL_INVERT(priv);
2268 +       u16 shadow_reg;
2269 +
2270 +       shadow_reg = tsc->mixer->shadow_regs[shadow_index];
2271 +       ucontrol->value.integer.value[0] =
2272 +               invert ^ ((shadow_reg >> shift) & 1);
2273 +
2274 +       return 0;
2275 +}
2276 +
2277 +static int snd_tsc2301_put_bool(struct snd_kcontrol *kcontrol,
2278 +                               struct snd_ctl_elem_value *ucontrol)
2279 +{
2280 +       struct tsc2301 *tsc = kcontrol->private_data;
2281 +       unsigned long priv = kcontrol->private_value;
2282 +       int shadow_index = TSC2301_SHADOW_INDEX(priv);
2283 +       int shift = TSC2301_BOOL_SHIFT(priv);
2284 +       int invert = TSC2301_BOOL_INVERT(priv);
2285 +       int reg = TSC2301_PVAL_TO_REG(priv);
2286 +       u16 shadow_reg, shadow_reg_old;
2287 +       int changed;
2288 +
2289 +       mutex_lock(&tsc->mixer->mutex);
2290 +       shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
2291 +
2292 +       /* zero bit to be modified */
2293 +       shadow_reg &= ~(1 << shift);
2294 +       /* modify with new value */
2295 +       shadow_reg |=
2296 +               (invert ^ (ucontrol->value.integer.value[0] & 1)) << shift;
2297 +
2298 +       changed = (shadow_reg != shadow_reg_old);
2299 +
2300 +       /* update into TSC2301 if necessary */
2301 +       if (changed) {
2302 +               tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
2303 +               if ((shadow_index == GPIO_INDEX) &&
2304 +                   (tsc->mixer->shadow_regs[PD_MISC_INDEX] &
2305 +                    TSC2301_REG_PD_MISC_APD)) {
2306 +                       /* changing GPIO control and audio is powered down.
2307 +                        * Update GPIO states according to their power-down
2308 +                        * flag */
2309 +                       tsc2301_gpio_power_down(tsc);
2310 +               } else
2311 +                       tsc2301_write_reg(tsc, reg, shadow_reg);
2312 +       }
2313 +       mutex_unlock(&tsc->mixer->mutex);
2314 +
2315 +       return changed;
2316 +}
2317 +
2318 +/* TSC2301 internal mixer controls */
2319 +static struct snd_kcontrol_new snd_tsc2301_controls[] = {
2320 +       /* stereo ADC input switches and volumes */
2321 +       TSC2301_DOUBLE("Capture Switch", 0,
2322 +               TSC2301_REG_ADCVOL, ADCVOL_INDEX,
2323 +               TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
2324 +               1, 0),
2325 +       TSC2301_DOUBLE("Capture Volume", 0,
2326 +               TSC2301_REG_ADCVOL, ADCVOL_INDEX,
2327 +               TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
2328 +               TSC2301_VOLUME_MASK, TSC2301_MIN_ADCVOL),
2329 +
2330 +       /* stereo DAC output switches and volumes */
2331 +       TSC2301_DOUBLE("PCM Playback Switch", 0,
2332 +               TSC2301_REG_DACVOL, DACVOL_INDEX,
2333 +               TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
2334 +               1, 0),
2335 +       TSC2301_DOUBLE("PCM Playback Volume", 0,
2336 +               TSC2301_REG_DACVOL, DACVOL_INDEX,
2337 +               TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
2338 +               TSC2301_VOLUME_MASK, TSC2301_MIN_DACVOL),
2339 +
2340 +       /* stereo line input bypass switches and volumes */
2341 +       TSC2301_DOUBLE("Line Playback Switch", 0,
2342 +               TSC2301_REG_BPVOL, BPVOL_INDEX,
2343 +               TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
2344 +               1, 0),
2345 +       TSC2301_DOUBLE("Line Playback Volume", 0,
2346 +               TSC2301_REG_BPVOL, BPVOL_INDEX,
2347 +               TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
2348 +               TSC2301_VOLUME_MASK, TSC2301_MIN_BPVOL),
2349 +
2350 +       /* mono microphone input gain */
2351 +       TSC2301_SINGLE("Mic Boost", 0,
2352 +               TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
2353 +               TSC2301_MICG_SHIFT,
2354 +               TSC2301_MICG_MASK, TSC2301_MICG_MIN),
2355 +
2356 +       /* ADC input sources. Both channels could be selected separately */
2357 +       TSC2301_MUX("Capture Source", 0,
2358 +               TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
2359 +               TSC2301_INML_SHIFT, TSC2301_INMR_SHIFT,
2360 +               TSC2301_INM_MASK),
2361 +};
2362 +
2363 +/* must be called tsc->mixer->mutex locked */
2364 +static void tsc2301_flush_shadow_regs(struct tsc2301 *tsc)
2365 +{
2366 +       int i, page, addr;
2367 +       u16 temp;
2368 +
2369 +       page = TSC2301_REG_TO_PAGE(TSC2301_REG_AUDCNTL);
2370 +       addr = TSC2301_REG_TO_ADDR(TSC2301_REG_AUDCNTL);
2371 +
2372 +       for (i = 0; i < 4; i++) {
2373 +               temp = tsc->mixer->shadow_regs[i];
2374 +               tsc2301_write_reg(tsc, TSC2301_REG(page, addr + i), temp);
2375 +       }
2376 +       temp = tsc->mixer->shadow_regs[GPIO_INDEX];
2377 +       tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
2378 +
2379 +       /* Update power state of all audio blocks depending are they
2380 +        * muted or unused. */
2381 +       tsc2301_power_ctrl(tsc, -1, 0);
2382 +}
2383 +
2384 +#ifdef CONFIG_PM
2385 +int tsc2301_mixer_suspend(struct tsc2301 *tsc)
2386 +{
2387 +       /* power down entire audio section inside TSC2301 in case the
2388 +        * chip is still powered during the system sleep. However this driver
2389 +        * doesn't require that chip is powered because registers are restored
2390 +        * in function tsc2301_mixer_resume */
2391 +       mutex_lock(&tsc->mixer->mutex);
2392 +       tsc2301_gpio_power_down(tsc);
2393 +       tsc->mixer->shadow_regs[PD_MISC_INDEX] |= TSC2301_REG_PD_MISC_APD;
2394 +       tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC,
2395 +                         tsc->mixer->shadow_regs[PD_MISC_INDEX]);
2396 +       mutex_unlock(&tsc->mixer->mutex);
2397 +       return 0;
2398 +}
2399 +
2400 +void tsc2301_mixer_resume(struct tsc2301 *tsc)
2401 +{
2402 +       /* power up the TSC2301 audio section and restore registers */
2403 +       mutex_lock(&tsc->mixer->mutex);
2404 +       tsc->mixer->shadow_regs[PD_MISC_INDEX] &= ~TSC2301_REG_PD_MISC_APD;
2405 +       tsc2301_flush_shadow_regs(tsc);
2406 +       mutex_unlock(&tsc->mixer->mutex);
2407 +}
2408 +#endif
2409 +
2410 +void tsc2301_mixer_enable_mclk(struct device *dev)
2411 +{
2412 +       struct tsc2301 *tsc = dev_get_drvdata(dev);
2413 +       struct tsc2301_mixer *mix = tsc->mixer;
2414 +
2415 +       mutex_lock(&mix->mutex);
2416 +       if (!mix->mclk_enabled++ && tsc->enable_clock != NULL) {
2417 +               tsc->enable_clock(dev);
2418 +       }
2419 +       tsc2301_power_ctrl(tsc, -1, 1);
2420 +       mutex_unlock(&mix->mutex);
2421 +}
2422 +
2423 +void tsc2301_mixer_disable_mclk(struct device *dev)
2424 +{
2425 +       struct tsc2301 *tsc = dev_get_drvdata(dev);
2426 +       struct tsc2301_mixer *mix = tsc->mixer;
2427 +
2428 +       mutex_lock(&mix->mutex);
2429 +       mix->mclk_enabled--;
2430 +       tsc2301_power_ctrl(tsc, -1, 1);
2431 +       if (!mix->mclk_enabled && tsc->disable_clock != NULL) {
2432 +               tsc->disable_clock(dev);
2433 +       }
2434 +       mutex_unlock(&mix->mutex);
2435 +}
2436 +
2437 +static void tsc2301_mixer_delayed_power_down(struct work_struct *work)
2438 +{
2439 +       struct tsc2301_mixer *mix = container_of(work, struct tsc2301_mixer,
2440 +                                                delayed_power_down.work);
2441 +       struct tsc2301 *tsc = mix->tsc;
2442 +
2443 +       mutex_lock(&mix->mutex);
2444 +       if (!mix->delayed_pd_active) {
2445 +               mutex_unlock(&mix->mutex);
2446 +               return;
2447 +       }
2448 +       mix->delayed_pd_active = 0;
2449 +       mutex_unlock(&mix->mutex);
2450 +       tsc2301_mixer_disable_mclk(&tsc->spi->dev);
2451 +}
2452 +
2453 +/*
2454 + * Allows audio controller driver to notify its usage of ADC and DAC
2455 + */
2456 +void tsc2301_mixer_set_power(struct device *dev, int dac, int adc)
2457 +{
2458 +       struct tsc2301 *tsc = dev_get_drvdata(dev);
2459 +
2460 +       mutex_lock(&tsc->mixer->mutex);
2461 +       tsc->mixer->adc_enabled = adc;
2462 +       tsc->mixer->dac_enabled = dac;
2463 +
2464 +       /* update power state of all audio blocks */
2465 +       tsc2301_power_ctrl(tsc, -1, 1);
2466 +       mutex_unlock(&tsc->mixer->mutex);
2467 +}
2468 +
2469 +/*
2470 + * Registers TSC2301 ALSA Mixer controls for the given sound card
2471 + */
2472 +int tsc2301_mixer_register_controls(struct device *dev, struct snd_card *card)
2473 +{
2474 +       struct tsc2301 *tsc = dev_get_drvdata(dev);
2475 +       struct tsc2301_mixer *mix = tsc->mixer;
2476 +       int i, err;
2477 +
2478 +       /* Register ALSA mixer controls */
2479 +       for (i = 0; i < ARRAY_SIZE(snd_tsc2301_controls); i++) {
2480 +               err = snd_ctl_add(card,
2481 +                                 snd_ctl_new1(&snd_tsc2301_controls[i], tsc));
2482 +               if (err < 0)
2483 +                       return err;
2484 +       }
2485 +
2486 +       if (!mix->n_mixer_gpios)
2487 +               return 0;
2488 +
2489 +       /* Register additional GPIO controls if defined */
2490 +       for (i = 0; i < mix->n_mixer_gpios; i++) {
2491 +               const struct tsc2301_mixer_gpio *mg = mix->mixer_gpios + i;
2492 +               struct snd_kcontrol *ctrlp;
2493 +               struct snd_kcontrol_new ctrl =
2494 +                       TSC2301_BOOL((char *)mg->name, 0,
2495 +                                    TSC2301_REG_GPIO, GPIO_INDEX,
2496 +                                    mg->gpio, mg->inverted, mg->def_enable);
2497 +
2498 +               ctrlp = snd_ctl_new1(&ctrl, tsc);
2499 +               err = snd_ctl_add(card, ctrlp);
2500 +               if (err < 0)
2501 +                       return err;
2502 +       }
2503 +
2504 +       return 0;
2505 +}
2506 +
2507 +int tsc2301_mixer_init(struct tsc2301 *tsc,
2508 +                      struct tsc2301_platform_data *pdata)
2509 +{
2510 +       struct tsc2301_mixer *mix;
2511 +       int err = 0;
2512 +       u16 w;
2513 +
2514 +       mix = kzalloc(sizeof(*mix), GFP_KERNEL);
2515 +       if (mix == NULL)
2516 +               return -ENOMEM;
2517 +       tsc->mixer = mix;
2518 +
2519 +       mix->tsc = tsc;
2520 +       mutex_init(&mix->mutex);
2521 +       mix->platform_init = pdata->codec_init;
2522 +       mix->platform_cleanup = pdata->codec_cleanup;
2523 +       mix->pll_output = pdata->pll_output;
2524 +
2525 +       INIT_DELAYED_WORK(&mix->delayed_power_down,
2526 +                         tsc2301_mixer_delayed_power_down);
2527 +
2528 +       /* initialize shadow register default values */
2529 +       w = 0xc000;
2530 +       w |= (pdata->mclk_ratio << 6) | (pdata->i2s_sample_rate << 2);
2531 +       w |= pdata->i2s_format;
2532 +       mix->shadow_regs[AUDCNTL_INDEX] = w;
2533 +       mix->shadow_regs[ADCVOL_INDEX] = 0xd7d7;
2534 +       mix->shadow_regs[DACVOL_INDEX] = 0xffff;
2535 +       mix->shadow_regs[BPVOL_INDEX] = 0xe7e7;
2536 +       mix->shadow_regs[PD_MISC_INDEX] = pdata->power_down_blocks;
2537 +
2538 +       /* if extra mixer controls configured, then configure associated
2539 +        * GPIOs as output and drive their default state */
2540 +       if (pdata->n_mixer_gpios) {
2541 +               int i;
2542 +
2543 +               w = 0;
2544 +               for (i = 0; i < pdata->n_mixer_gpios; i++) {
2545 +                       const struct tsc2301_mixer_gpio *mg;
2546 +                       int gpio;
2547 +
2548 +                       mg = pdata->mixer_gpios + i;
2549 +                       gpio = mg->gpio;
2550 +                       w |= (1 << gpio) << 8;
2551 +                       w |= (mg->inverted ^ mg->def_enable) << gpio;
2552 +               }
2553 +               mix->shadow_regs[GPIO_INDEX] = w;
2554 +
2555 +               mix->mixer_gpios = kmalloc(sizeof(*pdata->mixer_gpios) *
2556 +                                          pdata->n_mixer_gpios,
2557 +                                          GFP_KERNEL);
2558 +               if (mix->mixer_gpios == NULL) {
2559 +                       err = -ENOMEM;
2560 +                       goto err1;
2561 +               }
2562 +               memcpy(mix->mixer_gpios, pdata->mixer_gpios,
2563 +                      sizeof(*pdata->mixer_gpios) * pdata->n_mixer_gpios);
2564 +               mix->n_mixer_gpios = pdata->n_mixer_gpios;
2565 +       }
2566 +
2567 +       /* PLL control */
2568 +       tsc2301_write_pll(tsc, pdata->pll_n, pdata->pll_a, pdata->pll_pdc,
2569 +                         0, mix->pll_output ? 0 : 1);
2570 +
2571 +       tsc2301_flush_shadow_regs(tsc);
2572 +
2573 +       if (mix->platform_init != NULL) {
2574 +               err = mix->platform_init(&tsc->spi->dev);
2575 +               if (err < 0)
2576 +                       goto err2;
2577 +       }
2578 +
2579 +       return 0;
2580 +err2:
2581 +       if (mix->mixer_gpios != NULL)
2582 +               kfree(mix->mixer_gpios);
2583 +err1:
2584 +       kfree(mix);
2585 +       return err;
2586 +}
2587 +
2588 +void tsc2301_mixer_exit(struct tsc2301 *tsc)
2589 +{
2590 +       struct tsc2301_mixer *mixer = tsc->mixer;
2591 +
2592 +       if (mixer->platform_cleanup != NULL)
2593 +               mixer->platform_cleanup(&tsc->spi->dev);
2594 +
2595 +       if (mixer->mixer_gpios != NULL)
2596 +               kfree(mixer->mixer_gpios);
2597 +}
2598 +
2599 +MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
2600 +MODULE_LICENSE("GPL");
2601 Index: linux-3.1/include/linux/spi/tsc2301.h
2602 ===================================================================
2603 --- /dev/null   1970-01-01 00:00:00.000000000 +0000
2604 +++ linux-3.1/include/linux/spi/tsc2301.h       2011-10-30 00:48:48.989043470 +0200
2605 @@ -0,0 +1,208 @@
2606 +#ifndef _LINUX_SPI_TSC2301_H
2607 +#define _LINUX_SPI_TSC2301_H
2608 +
2609 +#include <linux/types.h>
2610 +#include <linux/timer.h>
2611 +
2612 +struct tsc2301_platform_data {
2613 +       /*
2614 +        * Keypad
2615 +        */
2616 +       s16     reset_gpio;
2617 +       s16     keyb_int;
2618 +       s16     keymap[16];     /* Set a key to a negative value if not used */
2619 +       unsigned kp_rep:1;      /* Enable keypad repeating */
2620 +       char    *keyb_name;     /* Keyboard device name */
2621 +
2622 +       /*
2623 +        * Touchscreen
2624 +        */
2625 +       s16     dav_int;
2626 +       u16     ts_x_plate_ohm;
2627 +       u32     ts_stab_time;   /* voltage settling time */
2628 +       u8      ts_hw_avg;      /* HW assiseted averaging. Can be
2629 +                                  0, 4, 8, 16 samples per reading */
2630 +       u32     ts_max_pressure;/* Samples with bigger pressure value will
2631 +                                  be ignored, since the corresponding X, Y
2632 +                                  values are unreliable */
2633 +       u32     ts_touch_pressure;      /* Pressure limit until we report a
2634 +                                          touch event. After that we switch
2635 +                                          to ts_max_pressure. */
2636 +       u32     ts_pressure_fudge;
2637 +       u32     ts_x_max;
2638 +       u32     ts_x_fudge;
2639 +       u32     ts_y_max;
2640 +       u32     ts_y_fudge;
2641 +
2642 +       /*
2643 +        * Audio
2644 +        */
2645 +       unsigned        pll_pdc:4;
2646 +       unsigned        pll_a:4;
2647 +       unsigned        pll_n:4;
2648 +       unsigned        pll_output:1; /* Output PLL on GPIO_0 */
2649 +
2650 +       unsigned        mclk_ratio:2;
2651 +       unsigned        i2s_sample_rate:4;
2652 +       unsigned        i2s_format:2;
2653 +       /* Mask for audio blocks to be powered down */
2654 +       u16             power_down_blocks;
2655 +
2656 +       /* Called after codec has been initialized, can be NULL */
2657 +       int (* codec_init)(struct device *tsc2301_dev);
2658 +       /* Called when codec is being removed, can be NULL */
2659 +       void (* codec_cleanup)(struct device *tsc2301_dev);
2660 +       int     (*enable_clock)(struct device *dev);
2661 +       void    (*disable_clock)(struct device *dev);
2662 +
2663 +       const struct tsc2301_mixer_gpio {
2664 +               const char      *name;
2665 +               unsigned        gpio:4;
2666 +               unsigned        inverted:1;
2667 +               unsigned        def_enable:1; /* enable by default */
2668 +               unsigned        deactivate_on_pd:1; /* power-down flag */
2669 +       } *mixer_gpios;
2670 +       int     n_mixer_gpios;
2671 +};
2672 +
2673 +struct tsc2301_kp;
2674 +struct tsc2301_ts;
2675 +struct tsc2301_mixer;
2676 +
2677 +struct tsc2301 {
2678 +       struct spi_device       *spi;
2679 +
2680 +       s16                     reset_gpio;
2681 +       u16                     config2_shadow;
2682 +
2683 +        struct tsc2301_kp      *kp;
2684 +       struct tsc2301_ts       *ts;
2685 +       struct tsc2301_mixer    *mixer;
2686 +
2687 +       int                     (*enable_clock)(struct device *dev);
2688 +       void                    (*disable_clock)(struct device *dev);
2689 +};
2690 +
2691 +
2692 +#define TSC2301_HZ     33000000
2693 +
2694 +#define TSC2301_REG(page, addr)  (((page) << 11) | ((addr) << 5))
2695 +#define TSC2301_REG_TO_PAGE(reg) (((reg) >> 11) & 0x03)
2696 +#define TSC2301_REG_TO_ADDR(reg) (((reg) >> 5)  & 0x1f)
2697 +
2698 +#define TSC2301_REG_X          TSC2301_REG(0, 0)
2699 +#define TSC2301_REG_Y          TSC2301_REG(0, 1)
2700 +#define TSC2301_REG_Z1         TSC2301_REG(0, 2)
2701 +#define TSC2301_REG_Z2         TSC2301_REG(0, 3)
2702 +#define TSC2301_REG_KPDATA     TSC2301_REG(0, 4)
2703 +#define TSC2301_REG_ADC                TSC2301_REG(1, 0)
2704 +#define TSC2301_REG_KEY                TSC2301_REG(1, 1)
2705 +#define TSC2301_REG_DAC                TSC2301_REG(1, 2)
2706 +#define TSC2301_REG_REF                TSC2301_REG(1, 3)
2707 +#define TSC2301_REG_RESET      TSC2301_REG(1, 4)
2708 +#define TSC2301_REG_CONFIG     TSC2301_REG(1, 5)
2709 +#define TSC2301_REG_CONFIG2    TSC2301_REG(1, 6)
2710 +#define TSC2301_REG_KPMASK     TSC2301_REG(1, 16)
2711 +#define TSC2301_REG_AUDCNTL    TSC2301_REG(2, 0)
2712 +#define TSC2301_REG_ADCVOL     TSC2301_REG(2, 1)
2713 +#define TSC2301_REG_DACVOL     TSC2301_REG(2, 2)
2714 +#define TSC2301_REG_BPVOL      TSC2301_REG(2, 3)
2715 +#define TSC2301_REG_KEYCTL     TSC2301_REG(2, 4)
2716 +#define TSC2301_REG_PD_MISC    TSC2301_REG(2, 5)
2717 +#define TSC2301_REG_GPIO       TSC2301_REG(2, 6)
2718 +#define TSC2301_REG_ADCLKCFG   TSC2301_REG(2, 27)
2719 +
2720 +#define TSC2301_REG_PD_MISC_APD                (1 << 15)
2721 +#define TSC2301_REG_PD_MISC_AVPD       (1 << 14)
2722 +#define TSC2301_REG_PD_MISC_ABPD       (1 << 13)
2723 +#define TSC2301_REG_PD_MISC_HAPD       (1 << 12)
2724 +#define TSC2301_REG_PD_MISC_MOPD       (1 << 11)
2725 +#define TSC2301_REG_PD_MISC_DAPD       (1 << 10)
2726 +#define TSC2301_REG_PD_MISC_ADPDL      (1 << 9)
2727 +#define TSC2301_REG_PD_MISC_ADPDR      (1 << 8)
2728 +#define TSC2301_REG_PD_MISC_PDSTS      (1 << 7)
2729 +#define TSC2301_REG_PD_MISC_MIBPD      (1 << 6)
2730 +#define TSC2301_REG_PD_MISC_OTSYN      (1 << 2)
2731 +
2732 +/* I2S sample rate */
2733 +#define TSC2301_I2S_SR_48000   0x00
2734 +#define TSC2301_I2S_SR_44100   0x01
2735 +#define TSC2301_I2S_SR_32000   0x02
2736 +#define TSC2301_I2S_SR_24000   0x03
2737 +#define TSC2301_I2S_SR_22050   0x04
2738 +#define TSC2301_I2S_SR_16000   0x05
2739 +#define TSC2301_I2S_SR_12000   0x06
2740 +#define TSC2301_I2S_SR_11050   0x07
2741 +#define TSC2301_I2S_SR_8000    0x08
2742 +
2743 +/* 16-bit, MSB-first. DAC Right-Justified, ADC Left-Justified */
2744 +#define TSC2301_I2S_FORMAT0    0x00
2745 +/* 20-bit, MSB-first. DAC Right-Justified, ADC Left-Justified */
2746 +#define TSC2301_I2S_FORMAT1    0x01
2747 +/* 20-bit, MSB-first. DAC Left-Justified, ADC Left-Justified */
2748 +#define TSC2301_I2S_FORMAT2    0x02
2749 +/* 20-bit, MSB-first */
2750 +#define TSC2301_I2S_FORMAT3    0x03
2751 +
2752 +/* Master Clock Ratio */
2753 +#define TSC2301_MCLK_256xFS    0x00 /* default */
2754 +#define TSC2301_MCLK_384xFS    0x01
2755 +#define TSC2301_MCLK_512xFS    0x02
2756 +
2757 +
2758 +extern u16 tsc2301_read_reg(struct tsc2301 *tsc, int reg);
2759 +extern void tsc2301_write_reg(struct tsc2301 *tsc, int reg, u16 val);
2760 +extern void tsc2301_write_kbc(struct tsc2301 *tsc, int val);
2761 +extern void tsc2301_write_pll(struct tsc2301 *tsc, int pll_n, int pll_a,
2762 +                             int pll_pdc, int pct_e, int pll_o);
2763 +extern void tsc2301_read_buf(struct tsc2301 *tsc, int reg, u16 *buf, int len);
2764 +
2765 +#define TSC2301_DECL_MOD(module)                                       \
2766 +extern int  tsc2301_##module##_init(struct tsc2301 *tsc,               \
2767 +                          struct tsc2301_platform_data *pdata);        \
2768 +extern void tsc2301_##module##_exit(struct tsc2301 *tsc);              \
2769 +extern int  tsc2301_##module##_suspend(struct tsc2301 *tsc);           \
2770 +extern void tsc2301_##module##_resume(struct tsc2301 *tsc);
2771 +
2772 +#define TSC2301_DECL_EMPTY_MOD(module)                                 \
2773 +static inline int tsc2301_##module##_init(struct tsc2301 *tsc,         \
2774 +                          struct tsc2301_platform_data *pdata)         \
2775 +{                                                                      \
2776 +       return 0;                                                       \
2777 +}                                                                      \
2778 +static inline void tsc2301_##module##_exit(struct tsc2301 *tsc) {}     \
2779 +static inline int  tsc2301_##module##_suspend(struct tsc2301 *tsc)     \
2780 +{                                                                      \
2781 +       return 0;                                                       \
2782 +}                                                                      \
2783 +static inline void tsc2301_##module##_resume(struct tsc2301 *tsc) {}
2784 +
2785 +#ifdef CONFIG_KEYBOARD_TSC2301
2786 +TSC2301_DECL_MOD(kp)
2787 +void tsc2301_kp_restart(struct tsc2301 *tsc);
2788 +#else
2789 +TSC2301_DECL_EMPTY_MOD(kp)
2790 +static inline void tsc2301_kp_restart(struct tsc2301 *tsc) {}
2791 +#endif
2792 +
2793 +#ifdef CONFIG_TOUCHSCREEN_TSC2301
2794 +TSC2301_DECL_MOD(ts)
2795 +#else
2796 +TSC2301_DECL_EMPTY_MOD(ts)
2797 +#endif
2798 +
2799 +#ifdef CONFIG_SPI_TSC2301_AUDIO
2800 +TSC2301_DECL_MOD(mixer)
2801 +extern void tsc2301_mixer_set_power(struct device *tsc_dev, int dac, int adc);
2802 +
2803 +struct snd_card;
2804 +extern int tsc2301_mixer_register_controls(struct device *tsc_dev,
2805 +                                          struct snd_card *card);
2806 +#else
2807 +TSC2301_DECL_EMPTY_MOD(mixer)
2808 +#endif
2809 +
2810 +extern void tsc2301_mixer_enable_mclk(struct device *tsc_dev);
2811 +extern void tsc2301_mixer_disable_mclk(struct device *tsc_dev);
2812 +
2813 +#endif