From f74116e59942d9773459b1de0882901b21f60bbd Mon Sep 17 00:00:00 2001
From: Felix Fietkau <nbd@openwrt.org>
Date: Wed, 16 Sep 2015 07:56:33 +0000
Subject: omap24xx: remove obsolete kernel 3.3 patches

Signed-off-by: Felix Fietkau <nbd@openwrt.org>

SVN-Revision: 46947
---
 .../315-n800-touchscreen-and-keypad-drivers.patch  | 2791 --------------------
 1 file changed, 2791 deletions(-)
 delete mode 100644 target/linux/omap24xx/patches-3.3/315-n800-touchscreen-and-keypad-drivers.patch

(limited to 'target/linux/omap24xx/patches-3.3/315-n800-touchscreen-and-keypad-drivers.patch')

diff --git a/target/linux/omap24xx/patches-3.3/315-n800-touchscreen-and-keypad-drivers.patch b/target/linux/omap24xx/patches-3.3/315-n800-touchscreen-and-keypad-drivers.patch
deleted file mode 100644
index 106a5d80c8..0000000000
--- a/target/linux/omap24xx/patches-3.3/315-n800-touchscreen-and-keypad-drivers.patch
+++ /dev/null
@@ -1,2791 +0,0 @@
-From 63e56392b9024aceb610d7b4e1979e2d2cebd217 Mon Sep 17 00:00:00 2001
-From: Marat Radchenko <marat@slonopotamus.org>
-Date: Tue, 18 Oct 2011 21:48:23 +0400
-Subject: [PATCH 1/2] TSC2301 driver (touchscreen and keypad)
-
-This patch adds support for TSC2301 touchscreen/keypad/audio chip found on Nokia N800.
-Touchscreen and keypad are fully functional, audio part only provides power management.
----
- drivers/input/keyboard/Kconfig         |    6 +
- drivers/input/keyboard/Makefile        |    1 +
- drivers/input/keyboard/tsc2301_kp.c    |  475 +++++++++++++++
- drivers/input/touchscreen/Kconfig      |    6 +
- drivers/input/touchscreen/Makefile     |    1 +
- drivers/input/touchscreen/tsc2301_ts.c |  676 +++++++++++++++++++++
- drivers/spi/Kconfig                    |   22 +
- drivers/spi/Makefile                   |    3 +
- drivers/spi/tsc2301-core.c             |  297 ++++++++++
- drivers/spi/tsc2301-mixer.c            | 1003 ++++++++++++++++++++++++++++++++
- include/linux/spi/tsc2301.h            |  208 +++++++
- 11 files changed, 2698 insertions(+), 0 deletions(-)
- create mode 100644 drivers/input/keyboard/tsc2301_kp.c
- create mode 100644 drivers/input/touchscreen/tsc2301_ts.c
- create mode 100644 drivers/spi/tsc2301-core.c
- create mode 100644 drivers/spi/tsc2301-mixer.c
- create mode 100644 include/linux/spi/tsc2301.h
-
---- a/drivers/input/keyboard/Kconfig
-+++ b/drivers/input/keyboard/Kconfig
-@@ -547,6 +547,12 @@ config KEYBOARD_TNETV107X
- 	  To compile this driver as a module, choose M here: the
- 	  module will be called tnetv107x-keypad.
- 
-+config KEYBOARD_TSC2301
-+	tristate "TSC2301 keypad support"
-+	depends on SPI_TSC2301
-+	help
-+	  Say Y here for if you are using the keypad features of TSC2301.
-+
- config KEYBOARD_TWL4030
- 	tristate "TI TWL4030/TWL5030/TPS659x0 keypad support"
- 	depends on TWL4030_CORE
---- a/drivers/input/keyboard/Makefile
-+++ b/drivers/input/keyboard/Makefile
-@@ -49,6 +49,7 @@ obj-$(CONFIG_KEYBOARD_SUNKBD)		+= sunkbd
- obj-$(CONFIG_KEYBOARD_TC3589X)		+= tc3589x-keypad.o
- obj-$(CONFIG_KEYBOARD_TEGRA)		+= tegra-kbc.o
- obj-$(CONFIG_KEYBOARD_TNETV107X)	+= tnetv107x-keypad.o
-+obj-$(CONFIG_KEYBOARD_TSC2301)		+= tsc2301_kp.o
- obj-$(CONFIG_KEYBOARD_TWL4030)		+= twl4030_keypad.o
- obj-$(CONFIG_KEYBOARD_XTKBD)		+= xtkbd.o
- obj-$(CONFIG_KEYBOARD_W90P910)		+= w90p910_keypad.o
---- /dev/null
-+++ b/drivers/input/keyboard/tsc2301_kp.c
-@@ -0,0 +1,475 @@
-+/*
-+ * TSC2301 keypad driver
-+ *
-+ * Copyright (C) 2005-2006 Nokia Corporation
-+ *
-+ * Written by Jarkko Oikarinen
-+ * Rewritten by Juha Yrjola <juha.yrjola@nokia.com>
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation; either version 2 of the License, or
-+ * (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-+ *
-+ */
-+
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/input.h>
-+#include <linux/interrupt.h>
-+#include <linux/irq.h>
-+#include <linux/delay.h>
-+#include <linux/spi/spi.h>
-+
-+#include <linux/spi/tsc2301.h>
-+
-+#define TSC2301_KEYBOARD_PRODUCT_ID      0x0051
-+#define TSC2301_KEYBOARD_PRODUCT_VERSION 0x0001
-+#define TSC2301_DEBOUNCE_TIME_2MS        0x0000
-+#define TSC2301_DEBOUNCE_TIME_10MS       0x0800
-+#define TSC2301_DEBOUNCE_TIME_20MS       0x1000
-+#define TSC2301_DEBOUNCE_TIME_50MS       0x1800
-+#define TSC2301_DEBOUNCE_TIME_60MS       0x2000
-+#define TSC2301_DEBOUNCE_TIME_80MS       0x2800
-+#define TSC2301_DEBOUNCE_TIME_100MS      0x3000
-+#define TSC2301_DEBOUNCE_TIME_120MS      0x3800
-+
-+#define TSC2301_DEBOUNCE_TIME		TSC2301_DEBOUNCE_TIME_20MS
-+
-+#define TSC2301_RELEASE_TIMEOUT		50
-+
-+struct tsc2301_kp {
-+	struct input_dev	*idev;
-+	char			phys[32];
-+	spinlock_t		lock;
-+	struct mutex		mutex;
-+	struct timer_list	timer;
-+	u16			keys_pressed;
-+	unsigned		pending:1;
-+	unsigned		user_disabled:1;
-+	unsigned		disable_depth;
-+
-+	struct spi_transfer	read_xfer[4];
-+	struct spi_message	read_msg;
-+
-+	u16			data;
-+	u16			mask;
-+
-+	int			irq;
-+	s16			keymap[16];
-+};
-+
-+static inline int tsc2301_kp_disabled(struct tsc2301 *tsc)
-+{
-+	return tsc->kp->disable_depth != 0;
-+}
-+
-+static void tsc2301_kp_send_key_events(struct tsc2301 *tsc,
-+				       u16 prev_state,
-+				       u16 new_state)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+	u16 common, released, pressed;
-+	int i;
-+
-+	common = prev_state & new_state;
-+	released = common ^ prev_state;
-+	pressed = common ^ new_state;
-+	if (!released && !pressed)
-+		return;
-+	for (i = 0; i < 16 && (released || pressed); i++) {
-+		if (released & 1) {
-+			dev_dbg(&tsc->spi->dev, "key %d released\n", i);
-+			input_report_key(kp->idev, kp->keymap[i], 0);
-+		}
-+		released >>= 1;
-+		if (pressed & 1) {
-+			dev_dbg(&tsc->spi->dev, "key %d pressed\n", i);
-+			input_report_key(kp->idev, kp->keymap[i], 1);
-+		}
-+		pressed >>= 1;
-+	}
-+	input_sync(kp->idev);
-+}
-+
-+static inline void _filter_out(struct tsc2301 *tsc, u16 prev_state,
-+			       u16 *new_state, int row1, int row2, u8 rect_pat)
-+{
-+	u16 mask;
-+
-+	mask = (rect_pat << (row1 * 4)) | (rect_pat << (row2 * 4));
-+	mask &= ~prev_state;
-+	*new_state &= ~mask;
-+	dev_dbg(&tsc->spi->dev, "filtering ghost keys %02x\n", mask);
-+}
-+
-+static void tsc2301_filter_ghost_keys(struct tsc2301 *tsc, u16 prev_state,
-+				      u16 *new_state)
-+{
-+	int row1, row2;
-+	u16 key_map;
-+	u16 row1_map;
-+	static const u8 rect_pat[] = {
-+		0x3, 0x5, 0x9, 0x6, 0xa, 0xc, 0,
-+	};
-+
-+	key_map = *new_state;
-+	for (row1 = 0; row1 < 4; row1++) {
-+		row1_map = (key_map >> (row1 * 4)) & 0xf;
-+		if (!row1_map)
-+			continue;
-+		for (row2 = row1 + 1; row2 < 4; row2++) {
-+			u16 rect_map = (key_map >> (row2 * 4)) & 0xf;
-+			const u8 *rp;
-+
-+			rect_map &= row1_map;
-+			if (!rect_map)
-+				continue;
-+			for (rp = rect_pat; *rp; rp++)
-+				if ((rect_map & *rp) == *rp)
-+					_filter_out(tsc, prev_state, new_state,
-+						    row1, row2, *rp);
-+		}
-+	}
-+}
-+
-+static void tsc2301_kp_timer(unsigned long arg)
-+{
-+	struct tsc2301 *tsc = (void *) arg;
-+	struct tsc2301_kp *kp = tsc->kp;
-+	unsigned long flags;
-+
-+	tsc2301_kp_send_key_events(tsc, kp->keys_pressed, 0);
-+	spin_lock_irqsave(&kp->lock, flags);
-+	kp->keys_pressed = 0;
-+	spin_unlock_irqrestore(&kp->lock, flags);
-+}
-+
-+static void tsc2301_kp_rx(void *arg)
-+{
-+	struct tsc2301 *tsc = arg;
-+	struct tsc2301_kp *kp = tsc->kp;
-+	unsigned long flags;
-+	u16 kp_data;
-+
-+	kp_data = kp->data;
-+	dev_dbg(&tsc->spi->dev, "KP data %04x\n", kp_data);
-+
-+	tsc2301_filter_ghost_keys(tsc, kp->keys_pressed, &kp_data);
-+	tsc2301_kp_send_key_events(tsc, kp->keys_pressed, kp_data);
-+	spin_lock_irqsave(&kp->lock, flags);
-+	kp->keys_pressed = kp_data;
-+	kp->pending = 0;
-+	spin_unlock_irqrestore(&kp->lock, flags);
-+}
-+
-+static irqreturn_t tsc2301_kp_irq_handler(int irq, void *dev_id)
-+{
-+	struct tsc2301 *tsc = dev_id;
-+	struct tsc2301_kp *kp = tsc->kp;
-+	unsigned long flags;
-+	int r;
-+
-+	spin_lock_irqsave(&kp->lock, flags);
-+	if (tsc2301_kp_disabled(tsc)) {
-+		spin_unlock_irqrestore(&kp->lock, flags);
-+		return IRQ_HANDLED;
-+	}
-+	kp->pending = 1;
-+	spin_unlock_irqrestore(&kp->lock, flags);
-+	mod_timer(&kp->timer,
-+		 jiffies + msecs_to_jiffies(TSC2301_RELEASE_TIMEOUT));
-+	r = spi_async(tsc->spi, &tsc->kp->read_msg);
-+	if (r)
-+		dev_err(&tsc->spi->dev, "kp: spi_async() failed");
-+	return IRQ_HANDLED;
-+}
-+
-+static void tsc2301_kp_start_scan(struct tsc2301 *tsc)
-+{
-+	tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, tsc->kp->mask);
-+	tsc2301_write_reg(tsc, TSC2301_REG_KEY, TSC2301_DEBOUNCE_TIME);
-+}
-+
-+static void tsc2301_kp_stop_scan(struct tsc2301 *tsc)
-+{
-+	tsc2301_write_reg(tsc, TSC2301_REG_KEY, 1 << 14);
-+}
-+
-+/* Must be called with the mutex held */
-+static void tsc2301_kp_enable(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+	unsigned long flags;
-+
-+	spin_lock_irqsave(&kp->lock, flags);
-+	BUG_ON(!tsc2301_kp_disabled(tsc));
-+	if (--kp->disable_depth != 0) {
-+		spin_unlock_irqrestore(&kp->lock, flags);
-+		return;
-+	}
-+	spin_unlock_irqrestore(&kp->lock, flags);
-+
-+	irq_set_irq_type(kp->irq, IRQ_TYPE_EDGE_FALLING);
-+	tsc2301_kp_start_scan(tsc);
-+	enable_irq(kp->irq);
-+}
-+
-+/* Must be called with the mutex held */
-+static int tsc2301_kp_disable(struct tsc2301 *tsc, int release_keys)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+	unsigned long flags;
-+
-+	spin_lock_irqsave(&kp->lock, flags);
-+	if (kp->disable_depth++ != 0) {
-+		spin_unlock_irqrestore(&kp->lock, flags);
-+		goto out;
-+	}
-+	disable_irq_nosync(kp->irq);
-+	irq_set_irq_type(kp->irq, IRQ_TYPE_NONE);
-+	spin_unlock_irqrestore(&kp->lock, flags);
-+
-+	while (kp->pending) {
-+		msleep(1);
-+	}
-+
-+	tsc2301_kp_stop_scan(tsc);
-+out:
-+	if (!release_keys)
-+		del_timer(&kp->timer); /* let timeout release keys */
-+
-+	return 0;
-+}
-+
-+/* The following workaround is needed for a HW bug triggered by the
-+ * following:
-+ * 1. keep any key pressed
-+ * 2. disable keypad
-+ * 3. release all keys
-+ * 4. reenable keypad
-+ * 5. disable touch screen controller
-+ *
-+ * After this the keypad scanner will get stuck in busy state and won't
-+ * report any interrupts for further keypresses. One way to recover is to
-+ * restart the keypad scanner whenever we enable / disable the
-+ * touchscreen controller.
-+ */
-+void tsc2301_kp_restart(struct tsc2301 *tsc)
-+{
-+	if (!tsc2301_kp_disabled(tsc)) {
-+		tsc2301_kp_start_scan(tsc);
-+	}
-+}
-+
-+static ssize_t tsc2301_kp_disable_show(struct device *dev,
-+				       struct device_attribute *attr, char *buf)
-+{
-+	struct tsc2301		*tsc = dev_get_drvdata(dev);
-+
-+	return sprintf(buf, "%u\n", tsc2301_kp_disabled(tsc) ? 1 : 0);
-+}
-+
-+static ssize_t tsc2301_kp_disable_store(struct device *dev,
-+					struct device_attribute *attr,
-+					const char *buf, size_t count)
-+{
-+	struct tsc2301		*tsc = dev_get_drvdata(dev);
-+	struct tsc2301_kp	*kp = tsc->kp;
-+	char *endp;
-+	int i;
-+
-+	i = simple_strtoul(buf, &endp, 10);
-+	i = i ? 1 : 0;
-+
-+	mutex_lock(&kp->mutex);
-+	if (i == kp->user_disabled) {
-+		mutex_unlock(&kp->mutex);
-+		return count;
-+	}
-+	kp->user_disabled = i;
-+
-+	if (i)
-+		tsc2301_kp_disable(tsc, 1);
-+	else
-+		tsc2301_kp_enable(tsc);
-+	mutex_unlock(&kp->mutex);
-+
-+	return count;
-+}
-+
-+static DEVICE_ATTR(disable_kp, 0664, tsc2301_kp_disable_show,
-+		   tsc2301_kp_disable_store);
-+
-+static const u16 tsc2301_kp_read_data = 0x8000 | TSC2301_REG_KPDATA;
-+
-+static void tsc2301_kp_setup_spi_xfer(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+	struct spi_message *m = &kp->read_msg;
-+	struct spi_transfer *x = &kp->read_xfer[0];
-+
-+	spi_message_init(&kp->read_msg);
-+
-+	x->tx_buf = &tsc2301_kp_read_data;
-+	x->len = 2;
-+	spi_message_add_tail(x, m);
-+	x++;
-+
-+	x->rx_buf = &kp->data;
-+	x->len = 2;
-+	spi_message_add_tail(x, m);
-+
-+	m->complete = tsc2301_kp_rx;
-+	m->context = tsc;
-+}
-+
-+#ifdef CONFIG_PM
-+int tsc2301_kp_suspend(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+
-+	mutex_lock(&kp->mutex);
-+	tsc2301_kp_disable(tsc, 1);
-+	mutex_unlock(&kp->mutex);
-+	return 0;
-+}
-+
-+void tsc2301_kp_resume(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+
-+	mutex_lock(&kp->mutex);
-+	tsc2301_kp_enable(tsc);
-+	mutex_unlock(&kp->mutex);
-+}
-+#endif
-+
-+int __devinit tsc2301_kp_init(struct tsc2301 *tsc,
-+			      struct tsc2301_platform_data *pdata)
-+{
-+	struct input_dev *idev;
-+	struct tsc2301_kp *kp;
-+	int r, i;
-+	u16 mask;
-+
-+	if (pdata->keyb_int < 0) {
-+		dev_err(&tsc->spi->dev, "need kbirq");
-+		return -EINVAL;
-+	}
-+
-+	kp = kzalloc(sizeof(*kp), GFP_KERNEL);
-+	if (kp == NULL)
-+		return -ENOMEM;
-+	tsc->kp = kp;
-+
-+	kp->irq = pdata->keyb_int;
-+	spin_lock_init(&kp->lock);
-+	mutex_init(&kp->mutex);
-+
-+	init_timer(&kp->timer);
-+	kp->timer.data = (unsigned long) tsc;
-+	kp->timer.function = tsc2301_kp_timer;
-+
-+	idev = input_allocate_device();
-+	if (idev == NULL) {
-+		r = -ENOMEM;
-+		goto err1;
-+	}
-+	if (pdata->keyb_name)
-+		idev->name = pdata->keyb_name;
-+	else
-+		idev->name = "TSC2301 keypad";
-+	snprintf(kp->phys, sizeof(kp->phys), "%s/input-kp", dev_name(&tsc->spi->dev));
-+	idev->phys = kp->phys;
-+
-+	mask = 0;
-+	idev->evbit[0] = BIT(EV_KEY);
-+	for (i = 0; i < 16; i++) {
-+		if (pdata->keymap[i] > 0) {
-+			set_bit(pdata->keymap[i], idev->keybit);
-+			kp->keymap[i] = pdata->keymap[i];
-+		} else {
-+			kp->keymap[i] = -1;
-+			mask |= 1 << i;
-+		}
-+	}
-+
-+	if (pdata->kp_rep)
-+		set_bit(EV_REP, idev->evbit);
-+
-+	kp->idev = idev;
-+
-+	tsc2301_kp_setup_spi_xfer(tsc);
-+
-+	r = device_create_file(&tsc->spi->dev, &dev_attr_disable_kp);
-+	if (r < 0)
-+		goto err2;
-+
-+	tsc2301_kp_start_scan(tsc);
-+
-+	/* IRQ mode 0 is faulty, it can cause the KBIRQ to get stuck.
-+	 * Mode 2 deasserts the IRQ at:
-+	 * - HW or SW reset
-+	 * - Setting SCS flag in REG_KEY register
-+	 * - Releasing all keys
-+	 * - Reading the REG_KPDATA
-+	 */
-+	tsc2301_write_kbc(tsc, 2);
-+
-+	tsc2301_write_reg(tsc, TSC2301_REG_KPMASK, mask);
-+	kp->mask = mask;
-+
-+	irq_set_irq_type(kp->irq, IRQ_TYPE_EDGE_FALLING);
-+
-+	r = request_irq(kp->irq, tsc2301_kp_irq_handler, 0,
-+			"tsc2301-kp", tsc);
-+	if (r < 0) {
-+		dev_err(&tsc->spi->dev, "unable to get kbirq IRQ");
-+		goto err3;
-+	}
-+	irq_set_irq_wake(kp->irq, 1);
-+
-+	/* We need to read the register once..? */
-+	tsc2301_read_reg(tsc, TSC2301_REG_KPDATA);
-+
-+	r = input_register_device(idev);
-+	if (r < 0) {
-+		dev_err(&tsc->spi->dev, "can't register keypad device\n");
-+		goto err4;
-+	}
-+
-+	return 0;
-+
-+err4:
-+	free_irq(kp->irq, tsc);
-+err3:
-+	tsc2301_kp_stop_scan(tsc);
-+	device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);
-+err2:
-+	input_free_device(kp->idev);
-+err1:
-+	kfree(kp);
-+	return r;
-+}
-+
-+void __devexit tsc2301_kp_exit(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_kp *kp = tsc->kp;
-+
-+	tsc2301_kp_disable(tsc, 1);
-+	input_unregister_device(kp->idev);
-+	free_irq(kp->irq, tsc);
-+	device_remove_file(&tsc->spi->dev, &dev_attr_disable_kp);
-+
-+	kfree(kp);
-+}
---- a/drivers/input/touchscreen/Kconfig
-+++ b/drivers/input/touchscreen/Kconfig
-@@ -726,6 +726,12 @@ config TOUCHSCREEN_TSC2007
- 	  To compile this driver as a module, choose M here: the
- 	  module will be called tsc2007.
- 
-+config TOUCHSCREEN_TSC2301
-+	tristate "TSC2301 touchscreen support"
-+	depends on SPI_TSC2301
-+	help
-+	  Say Y here for if you are using the touchscreen features of TSC2301.
-+
- config TOUCHSCREEN_W90X900
- 	tristate "W90P910 touchscreen driver"
- 	depends on HAVE_CLK
---- a/drivers/input/touchscreen/Makefile
-+++ b/drivers/input/touchscreen/Makefile
-@@ -52,6 +52,7 @@ obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)	+= to
- obj-$(CONFIG_TOUCHSCREEN_TSC_SERIO)	+= tsc40.o
- obj-$(CONFIG_TOUCHSCREEN_TSC2005)	+= tsc2005.o
- obj-$(CONFIG_TOUCHSCREEN_TSC2007)	+= tsc2007.o
-+obj-$(CONFIG_TOUCHSCREEN_TSC2301)	+= tsc2301_ts.o
- obj-$(CONFIG_TOUCHSCREEN_UCB1400)	+= ucb1400_ts.o
- obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)	+= wacom_w8001.o
- obj-$(CONFIG_TOUCHSCREEN_WM831X)	+= wm831x-ts.o
---- /dev/null
-+++ b/drivers/input/touchscreen/tsc2301_ts.c
-@@ -0,0 +1,676 @@
-+/*
-+ * TSC2301 touchscreen driver
-+ *
-+ * Copyright (C) 2005-2008 Nokia Corporation
-+ *
-+ * Written by Jarkko Oikarinen, Imre Deak and Juha Yrjola
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation; either version 2 of the License, or
-+ * (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-+ *
-+ */
-+
-+#include <linux/kernel.h>
-+#include <linux/module.h>
-+#include <linux/input.h>
-+#include <linux/interrupt.h>
-+#include <linux/delay.h>
-+#include <linux/spi/spi.h>
-+
-+#include <linux/spi/tsc2301.h>
-+
-+/**
-+ * The touchscreen interface operates as follows:
-+ *
-+ * Initialize:
-+ *    Request access to GPIO103 (DAV)
-+ *    tsc2301_ts_irq_handler will trigger when DAV line goes down
-+ *
-+ *  1) Pen is pressed against touchscreeen
-+ *  2) TSC2301 performs AD conversion
-+ *  3) After the conversion is done TSC2301 drives DAV line down
-+ *  4) GPIO IRQ is received and tsc2301_ts_irq_handler is called
-+ *  5) tsc2301_ts_irq_handler queues up an spi transfer to fetch
-+ *     the x, y, z1, z2 values
-+ *  6) SPI framework calls tsc2301_ts_rx after the coordinates are read
-+ *  7) When the penup_timer expires, there have not been DAV interrupts
-+ *     during the last 20ms which means the pen has been lifted.
-+ */
-+
-+
-+#define TSC2301_TOUCHSCREEN_PRODUCT_ID      		0x0052
-+#define TSC2301_TOUCHSCREEN_PRODUCT_VERSION 		0x0001
-+
-+#define TSC2301_TS_PENUP_TIME		     		20
-+
-+#define TSC2301_ADCREG_CONVERSION_CTRL_BY_TSC2301	0x8000
-+#define TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST		0x0000
-+
-+#define TSC2301_ADCREG_FUNCTION_NONE			0x0000
-+#define TSC2301_ADCREG_FUNCTION_XY			0x0400
-+#define TSC2301_ADCREG_FUNCTION_XYZ			0x0800
-+#define TSC2301_ADCREG_FUNCTION_X			0x0C00
-+#define TSC2301_ADCREG_FUNCTION_Y			0x1000
-+#define TSC2301_ADCREG_FUNCTION_Z			0x1400
-+#define TSC2301_ADCREG_FUNCTION_DAT1			0x1800
-+#define TSC2301_ADCREG_FUNCTION_DAT2			0x1C00
-+#define TSC2301_ADCREG_FUNCTION_AUX1			0x2000
-+#define TSC2301_ADCREG_FUNCTION_AUX2			0x2400
-+#define TSC2301_ADCREG_FUNCTION_TEMP			0x2800
-+
-+#define TSC2301_ADCREG_RESOLUTION_8BIT			0x0100
-+#define TSC2301_ADCREG_RESOLUTION_10BIT			0x0200
-+#define TSC2301_ADCREG_RESOLUTION_12BIT			0x0300
-+
-+#define TSC2301_ADCREG_AVERAGING_NONE			0x0000
-+#define TSC2301_ADCREG_AVERAGING_4AVG			0x0040
-+#define TSC2301_ADCREG_AVERAGING_8AVG			0x0080
-+#define TSC2301_ADCREG_AVERAGING_16AVG			0x00C0
-+
-+#define TSC2301_ADCREG_CLOCK_8MHZ			0x0000
-+#define TSC2301_ADCREG_CLOCK_4MHZ			0x0010
-+#define TSC2301_ADCREG_CLOCK_2MHZ			0x0020
-+#define TSC2301_ADCREG_CLOCK_1MHZ			0x0030
-+
-+#define TSC2301_ADCREG_VOLTAGE_STAB_0US			0x0000
-+#define TSC2301_ADCREG_VOLTAGE_STAB_100US		0x0002
-+#define TSC2301_ADCREG_VOLTAGE_STAB_500US		0x0004
-+#define TSC2301_ADCREG_VOLTAGE_STAB_1MS			0x0006
-+#define TSC2301_ADCREG_VOLTAGE_STAB_5MS			0x0008
-+#define TSC2301_ADCREG_VOLTAGE_STAB_10MS		0x000A
-+#define TSC2301_ADCREG_VOLTAGE_STAB_50MS		0x000C
-+#define TSC2301_ADCREG_VOLTAGE_STAB_100MS		0x000E
-+
-+#define TSC2301_ADCREG_STOP_CONVERSION			0x4000
-+
-+#define MAX_12BIT					((1 << 12) - 1)
-+
-+#define TS_RECT_SIZE					8
-+#define TSF_MIN_Z1					100
-+#define TSF_MAX_Z2					4000
-+
-+#define TSF_SAMPLES					4
-+
-+struct ts_filter {
-+	int			sample_cnt;
-+
-+	int 			avg_x;
-+	int 			avg_y;
-+	int 			avg_z1;
-+	int 			avg_z2;
-+};
-+
-+struct ts_coords {
-+	u16 			x;
-+	u16 			y;
-+	u16 			z1;
-+	u16 			z2;
-+};
-+
-+struct tsc2301_ts {
-+	struct input_dev	*idev;
-+	char			phys[32];
-+	struct timer_list	penup_timer;
-+	struct mutex		mutex;
-+
-+	struct spi_transfer	read_xfer[2];
-+	struct spi_message	read_msg;
-+	struct ts_coords	*coords;
-+
-+	struct ts_filter	filter;
-+
-+	int			hw_avg_max;
-+	u16			x;
-+	u16			y;
-+	u16			p;
-+
-+	u16			x_plate_ohm;
-+	int			stab_time;
-+	int			max_pressure;
-+	int			touch_pressure;
-+
-+	u8			event_sent;
-+	u8			pen_down;
-+	u8			disabled;
-+	u8			disable_depth;
-+
-+	int			hw_flags;
-+	int			irq;
-+};
-+
-+
-+static const u16 tsc2301_ts_read_data = 0x8000 | TSC2301_REG_X;
-+
-+static int tsc2301_ts_check_config(struct tsc2301_ts *ts, int *hw_flags)
-+{
-+	int flags;
-+
-+	flags = 0;
-+	switch (ts->hw_avg_max) {
-+	case 0:
-+		flags |= TSC2301_ADCREG_AVERAGING_NONE;
-+		break;
-+	case 4:
-+		flags |= TSC2301_ADCREG_AVERAGING_4AVG;
-+		break;
-+	case 8:
-+		flags |= TSC2301_ADCREG_AVERAGING_8AVG;
-+		break;
-+	case 16:
-+		flags |= TSC2301_ADCREG_AVERAGING_16AVG;
-+		break;
-+	default:
-+		return -EINVAL;
-+	}
-+
-+	switch (ts->stab_time) {
-+	case 0:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_0US;
-+		break;
-+	case 100:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_100US;
-+		break;
-+	case 500:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_500US;
-+		break;
-+	case 1000:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_1MS;
-+		break;
-+	case 5000:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_5MS;
-+		break;
-+	case 10000:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_10MS;
-+		break;
-+	case 50000:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_50MS;
-+		break;
-+	case 100000:
-+		flags |= TSC2301_ADCREG_VOLTAGE_STAB_100MS;
-+		break;
-+	default:
-+		return -EINVAL;
-+	}
-+
-+	*hw_flags = flags;
-+	return 0;
-+}
-+
-+/*
-+ * This odd three-time initialization is to work around a bug in TSC2301.
-+ * See TSC2301 errata for details.
-+ */
-+static int tsc2301_ts_configure(struct tsc2301 *tsc, int flags)
-+{
-+	struct spi_transfer xfer[5];
-+	struct spi_transfer *x;
-+	struct spi_message m;
-+	int i;
-+	u16 val1, val2, val3;
-+	u16 data[10];
-+
-+	val1 = TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST |
-+		TSC2301_ADCREG_STOP_CONVERSION |
-+		TSC2301_ADCREG_FUNCTION_NONE |
-+		TSC2301_ADCREG_RESOLUTION_12BIT |
-+		TSC2301_ADCREG_AVERAGING_NONE |
-+		TSC2301_ADCREG_CLOCK_2MHZ |
-+		TSC2301_ADCREG_VOLTAGE_STAB_100MS;
-+
-+	val2 = TSC2301_ADCREG_CONVERSION_CTRL_BY_HOST |
-+		TSC2301_ADCREG_FUNCTION_XYZ |
-+		TSC2301_ADCREG_RESOLUTION_12BIT |
-+		TSC2301_ADCREG_AVERAGING_16AVG |
-+		TSC2301_ADCREG_CLOCK_1MHZ |
-+		TSC2301_ADCREG_VOLTAGE_STAB_100MS;
-+
-+	/* Averaging and voltage stabilization settings in flags */
-+	val3 = TSC2301_ADCREG_CONVERSION_CTRL_BY_TSC2301 |
-+		TSC2301_ADCREG_FUNCTION_XYZ |
-+		TSC2301_ADCREG_RESOLUTION_12BIT |
-+		TSC2301_ADCREG_CLOCK_2MHZ |
-+		flags;
-+
-+	/* Now we prepare the command for transferring */
-+	data[0] = TSC2301_REG_ADC;
-+	data[1] = val1;
-+	data[2] = TSC2301_REG_ADC;
-+	data[3] = val2;
-+	data[4] = TSC2301_REG_ADC;
-+	data[5] = val3;
-+	data[6] = TSC2301_REG_REF;
-+	data[7] = 1 << 4 | 1 << 2 | 1; /* intref, 100uS settl, 2.5V ref */
-+	data[8] = TSC2301_REG_CONFIG;
-+	data[9] = 3 << 3 | 2 << 0; /* 340uS pre-chrg, 544us delay */
-+
-+	spi_message_init(&m);
-+	m.spi = tsc->spi;
-+
-+	memset(xfer, 0, sizeof(xfer));
-+	x = &xfer[0];
-+
-+	for (i = 0; i < 10; i += 2) {
-+		x->tx_buf = &data[i];
-+		x->len = 4;
-+		if (i != 8)
-+			x->cs_change = 1;
-+		spi_message_add_tail(x, &m);
-+		x++;
-+	}
-+	spi_sync(m.spi, &m);
-+
-+	return 0;
-+}
-+
-+static void tsc2301_ts_start_scan(struct tsc2301 *tsc)
-+{
-+	tsc2301_ts_configure(tsc, tsc->ts->hw_flags);
-+	tsc2301_kp_restart(tsc);
-+}
-+
-+static void tsc2301_ts_stop_scan(struct tsc2301 *tsc)
-+{
-+	tsc2301_write_reg(tsc, TSC2301_REG_ADC, TSC2301_ADCREG_STOP_CONVERSION);
-+	tsc2301_kp_restart(tsc);
-+}
-+
-+static void update_pen_state(struct tsc2301_ts *ts, int x, int y, int pressure)
-+{
-+	if (pressure) {
-+		input_report_abs(ts->idev, ABS_X, x);
-+		input_report_abs(ts->idev, ABS_Y, y);
-+		input_report_abs(ts->idev, ABS_PRESSURE, pressure);
-+		if (!ts->pen_down)
-+			input_report_key(ts->idev, BTN_TOUCH, 1);
-+		ts->pen_down = 1;
-+	} else {
-+		input_report_abs(ts->idev, ABS_PRESSURE, 0);
-+		if (ts->pen_down)
-+			input_report_key(ts->idev, BTN_TOUCH, 0);
-+		ts->pen_down = 0;
-+	}
-+
-+	input_sync(ts->idev);
-+
-+#ifdef VERBOSE
-+	dev_dbg(&tsc->spi->dev, "x %4d y %4d p %4d\n", x, y, pressure);
-+#endif
-+}
-+
-+static int filter(struct tsc2301_ts *ts, int x, int y, int z1, int z2)
-+{
-+	int inside_rect, pressure_limit, Rt;
-+	struct ts_filter *tsf = &ts->filter;
-+
-+	/* validate pressure and position */
-+	if (x > MAX_12BIT || y > MAX_12BIT)
-+		return 0;
-+
-+	/* skip coords if the pressure-components are out of range */
-+	if (z1 < TSF_MIN_Z1 || z2 > TSF_MAX_Z2)
-+		return 0;
-+
-+	/* Use the x,y,z1,z2 directly on the first "pen down" event */
-+	if (ts->event_sent) {
-+		tsf->avg_x  += x;
-+		tsf->avg_y  += y;
-+		tsf->avg_z1 += z1;
-+		tsf->avg_z2 += z2;
-+
-+		if (++tsf->sample_cnt < TSF_SAMPLES)
-+			return 0;
-+		x = tsf->avg_x / TSF_SAMPLES;
-+		y = tsf->avg_y / TSF_SAMPLES;
-+		z1 = tsf->avg_z1 / TSF_SAMPLES;
-+		z2 = tsf->avg_z2 / TSF_SAMPLES;
-+	}
-+	tsf->sample_cnt = 0;
-+	tsf->avg_x  = 0;
-+	tsf->avg_y  = 0;
-+	tsf->avg_z1 = 0;
-+	tsf->avg_z2 = 0;
-+
-+	pressure_limit = ts->event_sent? ts->max_pressure: ts->touch_pressure;
-+
-+	/* z1 is always at least 100: */
-+	Rt = x * (z2 - z1) / z1;
-+	Rt = Rt * ts->x_plate_ohm / 4096;
-+	if (Rt > pressure_limit)
-+		return 0;
-+
-+	/* discard the event if it still is within the previous rect - unless
-+	 * if the pressure is harder, but then use previous x,y position */
-+	inside_rect = (
-+	    x > (int)ts->x - TS_RECT_SIZE && x < (int)ts->x + TS_RECT_SIZE &&
-+	    y > (int)ts->y - TS_RECT_SIZE && y < (int)ts->y + TS_RECT_SIZE);
-+
-+	if (!ts->event_sent || !inside_rect) {
-+		ts->x = x;
-+		ts->y = y;
-+		ts->p = Rt;
-+		return 1;
-+	} else if (Rt < ts->p) {
-+		ts->p = Rt;
-+		return 1;
-+	}
-+	return 0;
-+}
-+
-+/*
-+ * This procedure is called by the SPI framework after the coordinates
-+ * have been read from TSC2301
-+ */
-+static void tsc2301_ts_rx(void *arg)
-+{
-+	struct tsc2301 *tsc = arg;
-+	struct tsc2301_ts *ts = tsc->ts;
-+	int send_event;
-+	int x, y, z1, z2;
-+
-+	x  = ts->coords->x;
-+	y  = ts->coords->y;
-+	z1 = ts->coords->z1;
-+	z2 = ts->coords->z2;
-+
-+	send_event = filter(ts, x, y, z1, z2);
-+	if (send_event) {
-+		update_pen_state(ts, ts->x, ts->y, ts->p);
-+		ts->event_sent = 1;
-+	}
-+
-+	mod_timer(&ts->penup_timer,
-+		  jiffies + msecs_to_jiffies(TSC2301_TS_PENUP_TIME));
-+}
-+
-+/*
-+ * Timer is called TSC2301_TS_PENUP_TIME after pen is up
-+ */
-+static void tsc2301_ts_timer_handler(unsigned long data)
-+{
-+	struct tsc2301 *tsc = (struct tsc2301 *)data;
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	if (ts->event_sent) {
-+		ts->event_sent = 0;
-+		update_pen_state(ts, 0, 0, 0);
-+	}
-+}
-+
-+/*
-+ * This interrupt is called when pen is down and coordinates are
-+ * available. That is indicated by a falling edge on DEV line.
-+ */
-+static irqreturn_t tsc2301_ts_irq_handler(int irq, void *dev_id)
-+{
-+	struct tsc2301 *tsc = dev_id;
-+	struct tsc2301_ts *ts = tsc->ts;
-+	int r;
-+
-+	r = spi_async(tsc->spi, &ts->read_msg);
-+	if (r)
-+		dev_err(&tsc->spi->dev, "ts: spi_async() failed");
-+
-+	mod_timer(&ts->penup_timer,
-+		  jiffies + msecs_to_jiffies(TSC2301_TS_PENUP_TIME));
-+
-+	return IRQ_HANDLED;
-+}
-+
-+static void tsc2301_ts_disable(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	if (ts->disable_depth++ != 0)
-+		return;
-+
-+	disable_irq(ts->irq);
-+
-+	/* wait until penup timer expire normally */
-+	do {
-+		msleep(1);
-+	} while (ts->event_sent);
-+
-+	tsc2301_ts_stop_scan(tsc);
-+}
-+
-+static void tsc2301_ts_enable(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	if (--ts->disable_depth != 0)
-+		return;
-+
-+	enable_irq(ts->irq);
-+
-+	tsc2301_ts_start_scan(tsc);
-+}
-+
-+#ifdef CONFIG_PM
-+int tsc2301_ts_suspend(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	mutex_lock(&ts->mutex);
-+	tsc2301_ts_disable(tsc);
-+	mutex_unlock(&ts->mutex);
-+
-+	return 0;
-+}
-+
-+void tsc2301_ts_resume(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	mutex_lock(&ts->mutex);
-+	tsc2301_ts_enable(tsc);
-+	mutex_unlock(&ts->mutex);
-+}
-+#endif
-+
-+static void tsc2301_ts_setup_spi_xfer(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+	struct spi_message *m = &ts->read_msg;
-+	struct spi_transfer *x = &ts->read_xfer[0];
-+
-+	spi_message_init(m);
-+
-+	x->tx_buf = &tsc2301_ts_read_data;
-+	x->len = 2;
-+	spi_message_add_tail(x, m);
-+
-+	x++;
-+	x->rx_buf = ts->coords;
-+	x->len = 8;
-+	spi_message_add_tail(x, m);
-+
-+	m->complete = tsc2301_ts_rx;
-+	m->context = tsc;
-+}
-+
-+static ssize_t tsc2301_ts_pen_down_show(struct device *dev,
-+					struct device_attribute *attr,
-+					char *buf)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(dev);
-+
-+	return sprintf(buf, "%u\n", tsc->ts->pen_down);
-+}
-+
-+static DEVICE_ATTR(pen_down, S_IRUGO, tsc2301_ts_pen_down_show, NULL);
-+
-+static ssize_t tsc2301_ts_disable_show(struct device *dev,
-+				       struct device_attribute *attr, char *buf)
-+{
-+	struct tsc2301		*tsc = dev_get_drvdata(dev);
-+	struct tsc2301_ts	*ts = tsc->ts;
-+
-+	return sprintf(buf, "%u\n", ts->disabled);
-+}
-+
-+static ssize_t tsc2301_ts_disable_store(struct device *dev,
-+					struct device_attribute *attr,
-+					const char *buf, size_t count)
-+{
-+	struct tsc2301		*tsc = dev_get_drvdata(dev);
-+	struct tsc2301_ts	*ts = tsc->ts;
-+	char *endp;
-+	int i;
-+
-+	i = simple_strtoul(buf, &endp, 10);
-+	i = i ? 1 : 0;
-+	mutex_lock(&ts->mutex);
-+	if (i == ts->disabled) goto out;
-+	ts->disabled = i;
-+
-+	if (i)
-+		tsc2301_ts_disable(tsc);
-+	else
-+		tsc2301_ts_enable(tsc);
-+out:
-+	mutex_unlock(&ts->mutex);
-+	return count;
-+}
-+
-+static DEVICE_ATTR(disable_ts, 0664, tsc2301_ts_disable_show,
-+		   tsc2301_ts_disable_store);
-+
-+int __devinit tsc2301_ts_init(struct tsc2301 *tsc,
-+			      struct tsc2301_platform_data *pdata)
-+{
-+	struct tsc2301_ts *ts;
-+	struct input_dev *idev;
-+	int r;
-+	int x_max, y_max;
-+	int x_fudge, y_fudge, p_fudge;
-+
-+	if (pdata->dav_int <= 0) {
-+		dev_err(&tsc->spi->dev, "need DAV IRQ");
-+		return -EINVAL;
-+	}
-+
-+	ts = kzalloc(sizeof(*ts), GFP_KERNEL);
-+	if (ts == NULL)
-+		return -ENOMEM;
-+	tsc->ts = ts;
-+
-+	ts->coords = kzalloc(sizeof(*ts->coords), GFP_KERNEL);
-+	if (ts->coords == NULL) {
-+		kfree(ts);
-+		return -ENOMEM;
-+	}
-+
-+	ts->irq = pdata->dav_int;
-+
-+	init_timer(&ts->penup_timer);
-+	setup_timer(&ts->penup_timer, tsc2301_ts_timer_handler,
-+			(unsigned long)tsc);
-+
-+	mutex_init(&ts->mutex);
-+
-+	ts->x_plate_ohm	= pdata->ts_x_plate_ohm ? : 280;
-+	ts->hw_avg_max	= pdata->ts_hw_avg;
-+	ts->max_pressure = pdata->ts_max_pressure ? : MAX_12BIT;
-+	ts->touch_pressure = pdata->ts_touch_pressure ? : ts->max_pressure;
-+	ts->stab_time	= pdata->ts_stab_time;
-+
-+	x_max		= pdata->ts_x_max ? : 4096;
-+	y_max		= pdata->ts_y_max ? : 4096;
-+	x_fudge		= pdata->ts_x_fudge ? : 4;
-+	y_fudge		= pdata->ts_y_fudge ? : 8;
-+	p_fudge		= pdata->ts_pressure_fudge ? : 2;
-+
-+	if ((r = tsc2301_ts_check_config(ts, &ts->hw_flags))) {
-+		dev_err(&tsc->spi->dev, "invalid configuration\n");
-+		goto err2;
-+	}
-+
-+	idev = input_allocate_device();
-+	if (idev == NULL) {
-+		r = -ENOMEM;
-+		goto err2;
-+	}
-+	idev->name = "TSC2301 touchscreen";
-+	snprintf(ts->phys, sizeof(ts->phys),
-+		 "%s/input-ts", dev_name(&tsc->spi->dev));
-+	idev->phys = ts->phys;
-+	idev->dev.parent = &tsc->spi->dev;
-+
-+	idev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY);
-+	idev->absbit[0] = BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_PRESSURE);
-+	ts->idev = idev;
-+
-+	tsc2301_ts_setup_spi_xfer(tsc);
-+
-+	/* These parameters should perhaps be configurable? */
-+	input_set_abs_params(idev, ABS_X, 0, x_max, x_fudge, 0);
-+	input_set_abs_params(idev, ABS_Y, 0, y_max, y_fudge, 0);
-+	input_set_abs_params(idev, ABS_PRESSURE, 0, ts->max_pressure,
-+			     p_fudge, 0);
-+
-+	tsc2301_ts_start_scan(tsc);
-+
-+	r = request_irq(ts->irq, tsc2301_ts_irq_handler,
-+			IRQF_TRIGGER_FALLING,
-+			"tsc2301-ts", tsc);
-+	if (r < 0) {
-+		dev_err(&tsc->spi->dev, "unable to get DAV IRQ");
-+		goto err3;
-+	}
-+	irq_set_irq_wake(ts->irq, 1);
-+
-+	if (device_create_file(&tsc->spi->dev, &dev_attr_pen_down) < 0)
-+		goto err4;
-+	if (device_create_file(&tsc->spi->dev, &dev_attr_disable_ts) < 0)
-+		goto err5;
-+
-+	r = input_register_device(idev);
-+	if (r < 0) {
-+		dev_err(&tsc->spi->dev, "can't register touchscreen device\n");
-+		goto err6;
-+	}
-+
-+	return 0;
-+err6:
-+	device_remove_file(&tsc->spi->dev, &dev_attr_disable_ts);
-+err5:
-+	device_remove_file(&tsc->spi->dev, &dev_attr_pen_down);
-+err4:
-+	free_irq(ts->irq, tsc);
-+err3:
-+	tsc2301_ts_stop_scan(tsc);
-+	input_free_device(idev);
-+err2:
-+	kfree(ts->coords);
-+	kfree(ts);
-+	return r;
-+}
-+
-+void __devexit tsc2301_ts_exit(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_ts *ts = tsc->ts;
-+
-+	tsc2301_ts_disable(tsc);
-+
-+	device_remove_file(&tsc->spi->dev, &dev_attr_disable_ts);
-+	device_remove_file(&tsc->spi->dev, &dev_attr_pen_down);
-+
-+	free_irq(ts->irq, tsc);
-+	input_unregister_device(ts->idev);
-+
-+	kfree(ts->coords);
-+	kfree(ts);
-+}
-+MODULE_AUTHOR("Jarkko Oikarinen <jarkko.oikarinen@nokia.com>");
-+MODULE_LICENSE("GPL");
---- a/drivers/spi/Kconfig
-+++ b/drivers/spi/Kconfig
-@@ -433,6 +433,28 @@ config SPI_TLE62X0
- 	  sysfs interface, with each line presented as a kind of GPIO
- 	  exposing both switch control and diagnostic feedback.
- 
-+config SPI_TSC2301
-+	tristate "TSC2301 driver"
-+	depends on SPI_MASTER
-+	help
-+	  Say Y here if you have a TSC2301 chip connected to an SPI
-+	  bus on your board.
-+
-+	  The TSC2301 is a highly integrated PDA analog interface circuit.
-+	  It contains a complete 12-bit A/D resistive touch screen
-+	  converter (ADC) including drivers, touch pressure measurement
-+	  capability, keypad controller, and 8-bit D/A converter (DAC) output
-+	  for LCD contrast control.
-+
-+	  To compile this driver as a module, choose M here: the
-+	  module will be called tsc2301.
-+
-+config SPI_TSC2301_AUDIO
-+	boolean "TSC2301 audio support"
-+	depends on SPI_TSC2301 && SND
-+	help
-+	  Say Y here for if you are using the audio features of TSC2301.
-+
- #
- # Add new SPI protocol masters in alphabetical order above this line
- #
---- a/drivers/spi/Makefile
-+++ b/drivers/spi/Makefile
-@@ -59,4 +59,6 @@ obj-$(CONFIG_SPI_TLE62X0)		+= spi-tle62x
- obj-$(CONFIG_SPI_TOPCLIFF_PCH)		+= spi-topcliff-pch.o
- obj-$(CONFIG_SPI_TXX9)			+= spi-txx9.o
- obj-$(CONFIG_SPI_XILINX)		+= spi-xilinx.o
--
-+obj-$(CONFIG_SPI_TSC2301)		+= tsc2301.o
-+tsc2301-objs				:= tsc2301-core.o
-+tsc2301-$(CONFIG_SPI_TSC2301_AUDIO)	+= tsc2301-mixer.o
---- /dev/null
-+++ b/drivers/spi/tsc2301-core.c
-@@ -0,0 +1,297 @@
-+/*
-+ * TSC2301 driver
-+ *
-+ * Copyright (C) 2005, 2006 Nokia Corporation
-+ *
-+ * This program is free software; you can redistribute it and/or modify
-+ * it under the terms of the GNU General Public License as published by
-+ * the Free Software Foundation; either version 2 of the License, or
-+ * (at your option) any later version.
-+ *
-+ * This program is distributed in the hope that it will be useful,
-+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-+ * GNU General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-+ *
-+ */
-+
-+#include <linux/module.h>
-+#include <linux/device.h>
-+#include <linux/delay.h>
-+#include <linux/gpio.h>
-+#include <linux/spi/spi.h>
-+#include <linux/spi/tsc2301.h>
-+
-+u16 tsc2301_read_reg(struct tsc2301 *tsc, int reg)
-+{
-+	struct spi_transfer t[2];
-+	struct spi_message m;
-+	u16 data = 0, cmd;
-+
-+	cmd = reg;
-+	cmd |= 0x8000;
-+
-+	memset(t, 0, sizeof(t));
-+	spi_message_init(&m);
-+	m.spi = tsc->spi;
-+
-+	t[0].tx_buf = &cmd;
-+	t[0].rx_buf = NULL;
-+	t[0].len = 2;
-+	spi_message_add_tail(&t[0], &m);
-+
-+	t[1].tx_buf = NULL;
-+	t[1].rx_buf = &data;
-+	t[1].len = 2;
-+	spi_message_add_tail(&t[1], &m);
-+
-+	spi_sync(m.spi, &m);
-+
-+	return data;
-+}
-+
-+void tsc2301_write_reg(struct tsc2301 *tsc, int reg, u16 val)
-+{
-+	struct spi_transfer t;
-+	struct spi_message m;
-+	u16 data[2];
-+
-+	/* Now we prepare the command for transferring */
-+	data[0] = reg;
-+	data[1] = val;
-+
-+	spi_message_init(&m);
-+	m.spi = tsc->spi;
-+
-+	memset(&t, 0, sizeof(t));
-+	t.tx_buf = data;
-+	t.rx_buf = NULL;
-+	t.len = 4;
-+	spi_message_add_tail(&t, &m);
-+
-+	spi_sync(m.spi, &m);
-+}
-+
-+void tsc2301_write_kbc(struct tsc2301 *tsc, int val)
-+{
-+	u16 w;
-+
-+	w = tsc->config2_shadow;
-+	w &= ~(0x03 << 14);
-+	w |= (val & 0x03) << 14;
-+	tsc2301_write_reg(tsc, TSC2301_REG_CONFIG2, w);
-+	tsc->config2_shadow = w;
-+}
-+
-+void tsc2301_write_pll(struct tsc2301 *tsc,
-+		       int pll_n, int pll_a, int pll_pdc, int pct_e, int pll_o)
-+{
-+	u16 w;
-+
-+	w = tsc->config2_shadow;
-+	w &= ~0x3fff;
-+	w |= (pll_n & 0x0f) | ((pll_a & 0x0f) << 4) | ((pll_pdc & 0x0f) << 8);
-+	w |= pct_e ? (1 << 12) : 0;
-+	w |= pll_o ? (1 << 13) : 0;
-+	tsc2301_write_reg(tsc, TSC2301_REG_CONFIG2, w);
-+	tsc->config2_shadow = w;
-+}
-+
-+void tsc2301_read_buf(struct tsc2301 *tsc, int reg, u16 *rx_buf, int len)
-+{
-+	struct spi_transfer t[2];
-+	struct spi_message m;
-+	u16 cmd, i;
-+
-+	cmd = reg;
-+	cmd |= 0x8000;
-+
-+	spi_message_init(&m);
-+	m.spi = tsc->spi;
-+
-+	memset(t, 0, sizeof(t));
-+	t[0].tx_buf = &cmd;
-+	t[0].rx_buf = NULL;
-+	t[0].len = 2;
-+	spi_message_add_tail(&t[0], &m);
-+
-+	t[1].tx_buf = NULL;
-+	t[1].rx_buf = rx_buf;
-+	t[1].len = 2 * len;
-+	spi_message_add_tail(&t[1], &m);
-+
-+	spi_sync(m.spi, &m);
-+
-+	for (i = 0; i < len; i++)
-+		printk(KERN_DEBUG "rx_buf[%d]: %04x\n", i, rx_buf[i]);
-+}
-+
-+static int __devinit tsc2301_probe(struct spi_device *spi)
-+{
-+	struct tsc2301			*tsc;
-+	struct tsc2301_platform_data	*pdata = spi->dev.platform_data;
-+	int r;
-+	u16 w;
-+
-+	if (!pdata) {
-+		dev_dbg(&spi->dev, "no platform data?\n");
-+		return -ENODEV;
-+	}
-+
-+	tsc = kzalloc(sizeof(*tsc), GFP_KERNEL);
-+	if (tsc == NULL)
-+		return -ENOMEM;
-+
-+	dev_set_drvdata(&spi->dev, tsc);
-+	tsc->spi = spi;
-+
-+	tsc->enable_clock = pdata->enable_clock;
-+	tsc->disable_clock = pdata->disable_clock;
-+
-+	if (pdata->reset_gpio >= 0) {
-+		tsc->reset_gpio = pdata->reset_gpio;
-+		r = gpio_request(tsc->reset_gpio, "TSC2301 reset");
-+		if (r < 0)
-+			goto err1;
-+		gpio_direction_output(tsc->reset_gpio, 1);
-+		mdelay(1);
-+		gpio_set_value(tsc->reset_gpio, 0);
-+	} else
-+		tsc->reset_gpio = -1;
-+
-+	spi->mode = SPI_MODE_1;
-+	spi->bits_per_word = 16;
-+	/* The max speed might've been defined by the board-specific
-+	 * struct */
-+	if (!spi->max_speed_hz)
-+		spi->max_speed_hz = TSC2301_HZ;
-+	spi_setup(spi);
-+
-+	/* Soft reset */
-+	tsc2301_write_reg(tsc, TSC2301_REG_RESET, 0xbb00);
-+	msleep(1);
-+
-+	w = tsc2301_read_reg(tsc, TSC2301_REG_ADC);
-+	if (!(w & (1 << 14))) {
-+		dev_err(&spi->dev, "invalid ADC reg value: %04x\n", w);
-+		r = -ENODEV;
-+		goto err1;
-+	}
-+
-+	w = tsc2301_read_reg(tsc, TSC2301_REG_DAC);
-+	if (!(w & (1 << 15))) {
-+		dev_err(&spi->dev, "invalid DAC reg value: %04x\n", w);
-+		r = -ENODEV;
-+		goto err1;
-+	}
-+
-+	/* Stop keypad scanning */
-+	tsc2301_write_reg(tsc, TSC2301_REG_KEY, 0x4000);
-+
-+	/* We have to cache this for read-modify-write, since we can't
-+	 * read back BIT15 */
-+	w = tsc2301_read_reg(tsc, TSC2301_REG_CONFIG2);
-+	/* By default BIT15 is set */
-+	w |= 1 << 15;
-+	tsc->config2_shadow = w;
-+
-+	r = tsc2301_kp_init(tsc, pdata);
-+	if (r)
-+		goto err1;
-+	r = tsc2301_ts_init(tsc, pdata);
-+	if (r)
-+		goto err2;
-+	r = tsc2301_mixer_init(tsc, pdata);
-+	if (r)
-+		goto err3;
-+	return 0;
-+
-+err3:
-+	tsc2301_ts_exit(tsc);
-+err2:
-+	tsc2301_kp_exit(tsc);
-+err1:
-+	kfree(tsc);
-+	return r;
-+}
-+
-+static int __devexit tsc2301_remove(struct spi_device *spi)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
-+
-+	tsc2301_mixer_exit(tsc);
-+	tsc2301_ts_exit(tsc);
-+	tsc2301_kp_exit(tsc);
-+	if (tsc->reset_gpio >= 0)
-+		gpio_free(tsc->reset_gpio);
-+	kfree(tsc);
-+
-+	return 0;
-+}
-+
-+#ifdef CONFIG_PM
-+static int tsc2301_suspend(struct spi_device *spi, pm_message_t mesg)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
-+	int r;
-+
-+	if ((r = tsc2301_mixer_suspend(tsc)) < 0)
-+		return r;
-+	if ((r = tsc2301_kp_suspend(tsc)) < 0)
-+		goto err1;
-+	if ((r = tsc2301_ts_suspend(tsc)) < 0)
-+		goto err2;
-+
-+	return 0;
-+err2:
-+	tsc2301_kp_resume(tsc);
-+err1:
-+	tsc2301_mixer_resume(tsc);
-+	return r;
-+}
-+
-+static int tsc2301_resume(struct spi_device *spi)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(&spi->dev);
-+
-+	tsc2301_ts_resume(tsc);
-+	tsc2301_kp_resume(tsc);
-+	tsc2301_mixer_resume(tsc);
-+	return 0;
-+}
-+#endif
-+
-+static struct spi_driver tsc2301_driver = {
-+	.driver = {
-+		   .name = "tsc2301",
-+		   .bus = &spi_bus_type,
-+		   .owner = THIS_MODULE,
-+	},
-+#ifdef CONFIG_PM
-+	.suspend = tsc2301_suspend,
-+	.resume = tsc2301_resume,
-+#endif
-+	.probe = tsc2301_probe,
-+	.remove = __devexit_p(tsc2301_remove),
-+};
-+
-+static int __init tsc2301_init(void)
-+{
-+	printk("TSC2301 driver initializing\n");
-+
-+	return spi_register_driver(&tsc2301_driver);
-+}
-+module_init(tsc2301_init);
-+
-+static void __exit tsc2301_exit(void)
-+{
-+	spi_unregister_driver(&tsc2301_driver);
-+}
-+module_exit(tsc2301_exit);
-+
-+MODULE_AUTHOR("Juha Yrj�l� <juha.yrjola@nokia.com>");
-+MODULE_LICENSE("GPL");
---- /dev/null
-+++ b/drivers/spi/tsc2301-mixer.c
-@@ -0,0 +1,1003 @@
-+/*
-+ * ALSA Mixer implementation for TSC2301
-+ *
-+ * Copyright (C) 2006 Nokia Corporation.
-+ *
-+ * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
-+ *          Juha Yrjola
-+ *
-+ * Some notes about TSC2301:
-+ * - PLL will stop when DAC and ADC's are powered down.
-+ * - Touchscreen will stop working when audio part is powered up and if audio
-+ *   MCLK is stopped. Problem is avoided if audio is powered down before
-+ *   stopping MCLK.
-+ * - Audio DAC or audio outputs will activate only after 100 msec from the
-+ *   chip power-up. Reason seems to be VCM since there is no this delay if the
-+ *   chip and VCM (bit AVPD on PD/MISC) were not powered down. The chip will
-+ *   consume about 1 mA if all other audio blocks are powered down except the
-+ *   chip itself and VCM. Full power down consumes only about few uA.
-+ * - Power-down transition could happen earliest about 100 msec after the chip
-+ *   power-up. Otherwise power-down will fail if there is no that 100 msec
-+ *   on time before it. It's not obvious why is that since chip reports
-+ *   power-up to be completed and also PLL output on GPIO_0 is active in few
-+ *   milliseconds.
-+ *
-+ * This program is free software; you can redistribute it and/or
-+ * modify it under the terms of the GNU General Public License
-+ * version 2 as published by the Free Software Foundation.
-+ *
-+ * This program is distributed in the hope that it will be useful, but
-+ * WITHOUT ANY WARRANTY; without even the implied warranty of
-+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-+ * General Public License for more details.
-+ *
-+ * You should have received a copy of the GNU General Public License
-+ * along with this program; if not, write to the Free Software
-+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
-+ * 02110-1301 USA
-+ *
-+ */
-+
-+#include <linux/module.h>
-+#include <linux/device.h>
-+#include <linux/errno.h>
-+#include <linux/delay.h>
-+#include <linux/slab.h>
-+#include <linux/spi/spi.h>
-+#include <linux/spi/tsc2301.h>
-+
-+#include <sound/core.h>
-+#include <sound/control.h>
-+
-+/* shadow register indexes */
-+enum {
-+	/* audio control and volume registers */
-+	AUDCNTL_INDEX,
-+	ADCVOL_INDEX,
-+	DACVOL_INDEX,
-+	BPVOL_INDEX,
-+	/* keyclick control register (not needed here) */
-+	/* audio power control register */
-+	PD_MISC_INDEX,
-+	/* TSC2301 GPIO control register */
-+	GPIO_INDEX,
-+
-+	SHADOW_REG_COUNT,
-+};
-+
-+/* structure for driver private data */
-+struct tsc2301_mixer {
-+	struct tsc2301 *tsc;
-+	struct mutex mutex;
-+
-+	/* shadow registers holding TSC2301 audio registers. Used to hold
-+	 * their states during the sleep and also to reduce communication with
-+	 * the chip since get callback functions could get register values
-+	 * directly from these shadow registers without needing to read them
-+	 * from the chip */
-+	u16 shadow_regs[SHADOW_REG_COUNT];
-+
-+	/* audio controller driver usage of the ADC and DAC */
-+	unsigned adc_enabled:1, dac_enabled:1;
-+	unsigned pll_output:1;
-+	unsigned mclk_enabled;
-+
-+	/* latest audio power-up timestamp */
-+	unsigned long pu_jiffies;
-+
-+	/* these are used when upper layer(s) are going to power-down TSC2301
-+	 * before 100 msec is passed from power-up */
-+	struct delayed_work delayed_power_down;
-+	unsigned delayed_pd_active:1;
-+
-+	int (* platform_init)(struct device *);
-+	void (* platform_cleanup)(struct device *);
-+
-+	struct tsc2301_mixer_gpio *mixer_gpios;
-+	int n_mixer_gpios;
-+};
-+
-+#define TSC2301_DAC_DELAY		msecs_to_jiffies(100)
-+#define TSC2301_MIN_PU_PERIOD		msecs_to_jiffies(100)
-+
-+#define TSC2301_REG_TO_PVAL(reg)	\
-+	(TSC2301_REG_TO_PAGE(reg) << 6 | TSC2301_REG_TO_ADDR(reg))
-+#define  TSC2301_PVAL_TO_REG(v)		\
-+	(TSC2301_REG((((v) >> 6) & 3),((v) & 0x1f)))
-+
-+#define TSC2301_VOLUME_MASK		0x7f
-+#define TSC2301_MIN_ADCVOL		6
-+#define TSC2301_MIN_DACVOL		0
-+#define TSC2301_MIN_BPVOL		31
-+#define TSC2301_MUTE_LEFT_SHIFT		15
-+#define TSC2301_VOL_LEFT_SHIFT		8
-+#define TSC2301_MUTE_RIGHT_SHIFT	7
-+#define TSC2301_VOL_RIGHT_SHIFT		0
-+
-+#define TSC2301_INM_MASK		3
-+#define TSC2301_INML_SHIFT		12
-+#define TSC2301_INMR_SHIFT		10
-+
-+#define TSC2301_MICG_MASK		3
-+#define TSC2301_MICG_MIN		1 /* values 0 & 1 both mean 0 dB */
-+#define TSC2301_MICG_SHIFT		8
-+
-+#define TSC2301_REG_AUDCNTL_MCLK(v)	(((v) & 3) << 6)
-+#define TSC2301_REG_AUDCNTL_I2SFS(v)	(((v) & 0xf) << 2)
-+#define TSC2301_REG_AUDCNTL_I2SFM(v)	(((v) & 3) << 0)
-+
-+#define TSC2301_SINGLE(xname, xindex, reg, shadow_index, shift, mask, min) \
-+{\
-+	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-+	.name = xname, \
-+	.index = xindex, \
-+	.info = snd_tsc2301_info_single, \
-+	.get = snd_tsc2301_get_single, \
-+	.put = snd_tsc2301_put_single, \
-+	.private_value = TSC2301_REG_TO_PVAL(reg) | \
-+		(shadow_index << 8) | (shift << 16) | (mask << 24) | \
-+		(min << 28) \
-+}
-+#define TSC2301_SINGLE_MINVAL(v)	(((v) >> 28) & 15)
-+#define TSC2301_SINGLE_SHIFT(v)		(((v) >> 16) & 15)
-+#define TSC2301_SINGLE_MASK(v)		(((v) >> 24) & 15)
-+
-+#define TSC2301_DOUBLE(xname, xindex, reg, shadow_index, ls, rs, mask, min) \
-+{\
-+	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-+	.name = xname, \
-+	.index = xindex, \
-+	.info = snd_tsc2301_info_double, \
-+	.get = snd_tsc2301_get_double, \
-+	.put = snd_tsc2301_put_double, \
-+	.private_value = TSC2301_REG_TO_PVAL(reg) | \
-+		(shadow_index << 8) | (min << 11) | \
-+		(ls << 16) | (rs << 20) | (mask << 24) \
-+}
-+#define TSC2301_DOUBLE_MINVAL(v)	(((v) >> 11) & 0x1f)
-+#define TSC2301_DOUBLE_LEFT_SHIFT(v)	(((v) >> 16) & 15)
-+#define TSC2301_DOUBLE_RIGHT_SHIFT(v)	(((v) >> 20) & 15)
-+#define TSC2301_DOUBLE_MASK(v)		(((v) >> 24) & TSC2301_VOLUME_MASK)
-+
-+#define TSC2301_MUX(xname, xindex, reg, shadow_index, ls, rs, mask) \
-+{\
-+	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-+	.name = xname, \
-+	.index = xindex, \
-+	.info = snd_tsc2301_info_mux, \
-+	.get = snd_tsc2301_get_mux, \
-+	.put = snd_tsc2301_put_mux, \
-+	.private_value = TSC2301_REG_TO_PVAL(reg) | \
-+		(shadow_index << 8) | (ls << 16) | (rs << 20) | (mask << 24) \
-+}
-+#define TSC2301_MUX_LEFT_SHIFT(v)	(((v) >> 16) & 15)
-+#define TSC2301_MUX_RIGHT_SHIFT(v)	(((v) >> 20) & 15)
-+#define TSC2301_MUX_MASK(v)		(((v) >> 24) & TSC2301_VOLUME_MASK)
-+
-+#define TSC2301_BOOL(xname, xindex, reg, shadow_index, shift, invert, state) \
-+{ \
-+	.iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
-+	.name = xname, \
-+	.index = xindex, \
-+	.info = snd_tsc2301_info_bool, \
-+	.get = snd_tsc2301_get_bool, \
-+	.put = snd_tsc2301_put_bool, \
-+	.private_value = TSC2301_REG_TO_PVAL(reg) | \
-+		(shadow_index << 8) | (shift << 16) | \
-+		(invert << 24) | (state << 25) \
-+}
-+#define TSC2301_BOOL_SHIFT(v)		(((v) >> 16) & 7)
-+#define TSC2301_BOOL_INVERT(v)		(((v) >> 24) & 1)
-+#define TSC2301_BOOL_STATE(v)		(((v) >> 25) & 1)
-+
-+#define TSC2301_SHADOW_INDEX(v)		(((v) >> 8) & 7)
-+
-+/*
-+ * Power-down handler for additional GPIO mixer controls. GPIO state of GPIO
-+ * controls whose power-down flag is enabled are set to their false/deactivate
-+ * state
-+ *
-+ * Must be called tsc->mixer->mutex locked
-+ */
-+static void tsc2301_gpio_power_down(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_mixer *mix = tsc->mixer;
-+	u16 temp;
-+	int i;
-+
-+	temp = mix->shadow_regs[GPIO_INDEX];
-+	for (i = 0; i < mix->n_mixer_gpios; i++) {
-+		const struct tsc2301_mixer_gpio *mg;
-+
-+		mg = mix->mixer_gpios + i;
-+		if (mg->deactivate_on_pd) {
-+			int gpio = mg->gpio;
-+
-+			temp &= ~(1 << gpio);
-+			temp |= mg->inverted << gpio;
-+		}
-+	}
-+	tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
-+}
-+
-+/*
-+ * Powers down/up audio blocks which are muted or become unused.
-+ * shadow_index >= 0, changes power state of single audio block
-+ * shadow_index < 0, changes power state of all blocks
-+ *
-+ * Must be called tsc->mixer->mutex locked
-+ */
-+#define TSC2301_MUTE_MASK \
-+	((1 << TSC2301_MUTE_LEFT_SHIFT) | (1 << TSC2301_MUTE_RIGHT_SHIFT))
-+static void tsc2301_power_ctrl(struct tsc2301 *tsc, int shadow_index,
-+			       int poll_pdsts)
-+{
-+	struct tsc2301_mixer *mix = tsc->mixer;
-+	u16 pd_ctrl, pd_ctrl_old, w;
-+	unsigned long timeout;
-+	int power_up = 0;
-+
-+	if (mix->delayed_pd_active) {
-+		mix->delayed_pd_active = 0;
-+		mix->mclk_enabled--;
-+		cancel_delayed_work(&mix->delayed_power_down);
-+	}
-+
-+	pd_ctrl = pd_ctrl_old = mix->shadow_regs[PD_MISC_INDEX];
-+	/* power control helper based on used space mixer selections. See
-+	 * actual power control decisions below */
-+	if (shadow_index < 0 || shadow_index == ADCVOL_INDEX) {
-+		/* ADC left and right power down control */
-+		if (mix->shadow_regs[ADCVOL_INDEX] &
-+		    (1 << TSC2301_MUTE_LEFT_SHIFT))
-+			/* left ADC muted. Power down the left ADC */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
-+		else
-+			pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDL;
-+		if (mix->shadow_regs[ADCVOL_INDEX] &
-+		    (1 << TSC2301_MUTE_LEFT_SHIFT))
-+			/* right ADC muted. Power down the right ADC */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
-+		else
-+			pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDR;
-+	}
-+	if (shadow_index < 0 || shadow_index == DACVOL_INDEX) {
-+		/* DAC power down control */
-+		if ((mix->shadow_regs[DACVOL_INDEX] &
-+		     TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
-+			/* both DACs muted. Power down the DAC */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
-+		else
-+			pd_ctrl &= ~TSC2301_REG_PD_MISC_DAPD;
-+	}
-+	if (shadow_index < 0 || shadow_index == BPVOL_INDEX) {
-+		/* line bypass power down control */
-+		if ((mix->shadow_regs[BPVOL_INDEX] &
-+		     TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
-+			/* both line bypasses muted. Power down the bypass
-+			 * path */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_ABPD;
-+		else
-+			pd_ctrl &= ~TSC2301_REG_PD_MISC_ABPD;
-+	}
-+	if (shadow_index < 0 || shadow_index == AUDCNTL_INDEX) {
-+		/* mic bias power down control */
-+		if ((mix->shadow_regs[AUDCNTL_INDEX] &
-+		     (3 << TSC2301_INML_SHIFT)) &&
-+		    (mix->shadow_regs[AUDCNTL_INDEX] &
-+		     (3 << TSC2301_INMR_SHIFT)))
-+			/* both ADC channels use other than mic input. Power
-+			 * down the mic bias output */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
-+		else
-+			pd_ctrl &= ~TSC2301_REG_PD_MISC_MIBPD;
-+	}
-+
-+	/* power control decisions based on codec usage and user space mixer
-+	 * selections detected above */
-+	pd_ctrl &= ~TSC2301_REG_PD_MISC_APD; /* audio not powered down */
-+	if (mix->mclk_enabled) {
-+		if (!mix->adc_enabled) {
-+			/* ADC not used, power down both ADC's and mic bias
-+			 * output independently of user space mixer
-+			 * selections */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
-+			pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
-+			pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
-+		}
-+		if (!mix->dac_enabled) {
-+			/* DAC not used, power down DAC independently of user
-+			 * space mixer selections */
-+			pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
-+		}
-+
-+		if (mix->pll_output) {
-+			/* GPIO_0 is configured as PLL output so audio
-+			 * controller is expecting clock from TSC2301. Either
-+			 * ADC or DAC must be active in order to keep PLL on */
-+			if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
-+			    (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
-+			    (pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
-+				/* neither ADC or DAC used. Force ADC on in
-+				 * order to keep PLL active */
-+				pd_ctrl &= ~(TSC2301_REG_PD_MISC_ADPDL |
-+					     TSC2301_REG_PD_MISC_ADPDR);
-+			}
-+		}
-+	} else {
-+		/* audio input clock is not enabled so power down DAC and ADC
-+		 * in order to shutdown PLL and to keep touchscreen and keypad
-+		 * parts working. Touchscreen and keypad use audio clock when
-+		 * PLL is on and internal clock otherwise */
-+		pd_ctrl |= TSC2301_REG_PD_MISC_DAPD |
-+			   TSC2301_REG_PD_MISC_ADPDL |
-+			   TSC2301_REG_PD_MISC_ADPDR;
-+	}
-+
-+	if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
-+	    (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
-+	    (pd_ctrl & TSC2301_REG_PD_MISC_DAPD) &&
-+	    (pd_ctrl & TSC2301_REG_PD_MISC_ABPD)) {
-+		/* all ADC, DAC and line bypass path unused. Power down the
-+		 * whole audio part of the TSC2301 */
-+		pd_ctrl |= TSC2301_REG_PD_MISC_APD;
-+	}
-+
-+	if (pd_ctrl == pd_ctrl_old)
-+		return;
-+
-+	/* power down control changed. Update into TSC2301 */
-+	if ((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_APD) {
-+		/* whole audio power state changed. Update GPIO states */
-+		if (pd_ctrl & TSC2301_REG_PD_MISC_APD) {
-+			/* power down GPIO controls before powering down
-+			 * the codec */
-+			tsc2301_gpio_power_down(tsc);
-+			/* we must really ensure that codec has been on no less
-+			 * than 100 msec before doing power-down */
-+			timeout = mix->pu_jiffies + TSC2301_MIN_PU_PERIOD -
-+				  jiffies;
-+			if (timeout <= TSC2301_MIN_PU_PERIOD) {
-+				mix->delayed_pd_active = 1;
-+				mix->mclk_enabled++;
-+				schedule_delayed_work(&mix->delayed_power_down,
-+						      timeout + 1);
-+				return;
-+			}
-+		} else
-+			/* restore GPIOs after codec is powered up */
-+			power_up = 1;
-+	}
-+	mix->shadow_regs[PD_MISC_INDEX] = pd_ctrl;
-+	tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC, pd_ctrl);
-+	if (power_up)
-+		mix->pu_jiffies = jiffies;
-+	if (!poll_pdsts) {
-+		if (power_up)
-+			tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
-+					  mix->shadow_regs[GPIO_INDEX]);
-+		return;
-+	}
-+
-+	/* wait until power-up/-down is completed */
-+	timeout = jiffies + msecs_to_jiffies(100);
-+	w = 0;
-+	do {
-+		if (time_after(jiffies, timeout)) {
-+			/* Print a warning only if the I2S clock is not
-+			 * present / out of sync. This can happen during
-+			 * init time, when that clock will be turned on
-+			 * by another driver like in the OMAP EAC with
-+			 * external clock case.
-+			 */
-+			if (w & TSC2301_REG_PD_MISC_OTSYN) {
-+				dev_warn(&tsc->spi->dev,
-+				   "I2S clock not in sync or off.\n");
-+			} else {
-+				dev_err(&tsc->spi->dev,
-+				   "power-up/-down timed out "
-+				   "(0x%04x, 0x%04x -> 0x%04x)\n",
-+				   w, pd_ctrl_old, pd_ctrl);
-+			}
-+			goto out;
-+		}
-+		w = tsc2301_read_reg(tsc, TSC2301_REG_PD_MISC);
-+	} while (!(w & TSC2301_REG_PD_MISC_PDSTS));
-+
-+out:
-+	if (((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_DAPD) &&
-+	    !(pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
-+		/* DAC powered up now. Ensure that DAC and audio outputs are
-+		 * activated. They are up 100 msec after the chip power-up
-+		 * command */
-+		timeout = mix->pu_jiffies + TSC2301_DAC_DELAY - jiffies;
-+		if (timeout <= TSC2301_DAC_DELAY)
-+			schedule_timeout_interruptible(timeout);
-+		/* FIXME: This is lazy. We restore GPIOs only after activating
-+		 * the DAC. It would be better to do some kind of delayed GPIO
-+		 * restore. That ensures that we restore them also if only ADC
-+		 * path is activated. But this is required only if there is
-+		 * some input amplifier, bias control, etc. and their power
-+		 * state is under TSC GPIO control */
-+		tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
-+				  mix->shadow_regs[GPIO_INDEX]);
-+	}
-+}
-+
-+static int snd_tsc2301_info_single(struct snd_kcontrol *kcontrol,
-+				   struct snd_ctl_elem_info *uinfo)
-+{
-+	int mask = TSC2301_SINGLE_MASK(kcontrol->private_value);
-+	int minval = TSC2301_SINGLE_MINVAL(kcontrol->private_value);
-+
-+	uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
-+	uinfo->count = 1;
-+	uinfo->value.integer.min = minval;
-+	uinfo->value.integer.max = mask;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_get_single(struct snd_kcontrol *kcontrol,
-+				  struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int mask = TSC2301_SINGLE_MASK(priv);
-+	int shift = TSC2301_SINGLE_SHIFT(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg;
-+
-+	shadow_reg = tsc->mixer->shadow_regs[shadow_index];
-+
-+	ucontrol->value.integer.value[0] = (shadow_reg >> shift) & mask;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_put_single(struct snd_kcontrol *kcontrol,
-+				  struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int mask = TSC2301_SINGLE_MASK(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg, shadow_reg_old;
-+	int shift = TSC2301_SINGLE_SHIFT(priv);
-+	int reg = TSC2301_PVAL_TO_REG(priv);
-+	int changed;
-+
-+	mutex_lock(&tsc->mixer->mutex);
-+	shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
-+
-+	/* zero bits to be modified */
-+	shadow_reg &= ~(mask << shift);
-+	/* modify with new value */
-+	shadow_reg |= ((ucontrol->value.integer.value[0] & mask) << shift);
-+
-+	changed = (shadow_reg != shadow_reg_old);
-+	tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
-+
-+	/* update into TSC2301 if necessary */
-+	if (changed)
-+		tsc2301_write_reg(tsc, reg, shadow_reg);
-+	mutex_unlock(&tsc->mixer->mutex);
-+
-+	return changed;
-+}
-+
-+static int snd_tsc2301_info_double(struct snd_kcontrol *kcontrol,
-+				   struct snd_ctl_elem_info *uinfo)
-+{
-+	/* mask == 1 : Switch
-+	 * mask > 1 : Max volume */
-+	int mask = TSC2301_DOUBLE_MASK(kcontrol->private_value);
-+	int minval = TSC2301_DOUBLE_MINVAL(kcontrol->private_value);
-+
-+	uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
-+		SNDRV_CTL_ELEM_TYPE_INTEGER;
-+	uinfo->count = 2;
-+	uinfo->value.integer.min = minval;
-+	uinfo->value.integer.max = mask;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_get_double(struct snd_kcontrol *kcontrol,
-+				  struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	/* mask == 1 : Switch
-+	 * mask > 1 : Volume */
-+	int mask = TSC2301_DOUBLE_MASK(priv);
-+	int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
-+	int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg;
-+
-+	shadow_reg = tsc->mixer->shadow_regs[shadow_index];
-+
-+	/* invert mute bits for the switches */
-+	if (mask == 1)
-+		shadow_reg = ~shadow_reg;
-+
-+	ucontrol->value.integer.value[0] = (shadow_reg >> ls) & mask;
-+	ucontrol->value.integer.value[1] = (shadow_reg >> rs) & mask;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_put_double(struct snd_kcontrol *kcontrol,
-+				  struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	/* mask == 1 : Switch
-+	 * mask > 1 : Volume */
-+	int mask = TSC2301_DOUBLE_MASK(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg, shadow_reg_old;
-+	int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
-+	int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
-+	int reg = TSC2301_PVAL_TO_REG(priv);
-+	int changed;
-+
-+	mutex_lock(&tsc->mixer->mutex);
-+	shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
-+
-+	/* zero bits to be modified */
-+	shadow_reg &= ~((mask << ls) | (mask << rs));
-+	/* modify with new value */
-+	if (mask == 1) {
-+		/* switch. Invert switch values for the mute bits */
-+		shadow_reg |=
-+			((~ucontrol->value.integer.value[0] & mask) << ls) |
-+			((~ucontrol->value.integer.value[1] & mask) << rs);
-+	} else {
-+		/* volume */
-+		shadow_reg |=
-+			(ucontrol->value.integer.value[0] << ls) |
-+			(ucontrol->value.integer.value[1] << rs);
-+	}
-+
-+	changed = (shadow_reg != shadow_reg_old);
-+	tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
-+
-+	/* update into TSC2301 if necessary */
-+	if (changed)
-+		tsc2301_write_reg(tsc, reg, shadow_reg);
-+
-+	if (mask == 1)
-+		/* check is need to power down/up audio blocks in case of
-+		 * muted state change */
-+		tsc2301_power_ctrl(tsc, shadow_index, 0);
-+	mutex_unlock(&tsc->mixer->mutex);
-+
-+	return changed;
-+}
-+
-+static int snd_tsc2301_info_mux(struct snd_kcontrol *kcontrol,
-+				struct snd_ctl_elem_info *uinfo)
-+{
-+	static char *texts[4] = {"Mic", "Line", "Line swapped", "Line mono"};
-+
-+	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
-+	uinfo->count = 2;
-+	uinfo->value.enumerated.items = 4;
-+	if (uinfo->value.enumerated.item > 3)
-+		uinfo->value.enumerated.item = 3;
-+	strcpy(uinfo->value.enumerated.name,
-+	       texts[uinfo->value.enumerated.item]);
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_get_mux(struct snd_kcontrol *kcontrol,
-+			       struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int mask = TSC2301_MUX_MASK(priv);
-+	int ls = TSC2301_MUX_LEFT_SHIFT(priv);
-+	int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg;
-+
-+	shadow_reg = tsc->mixer->shadow_regs[shadow_index];
-+	ucontrol->value.enumerated.item[0] = (shadow_reg >> ls) & mask;
-+	ucontrol->value.enumerated.item[1] = (shadow_reg >> rs) & mask;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_put_mux(struct snd_kcontrol *kcontrol,
-+			       struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int mask = TSC2301_MUX_MASK(priv);
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	u16 shadow_reg, shadow_reg_old;
-+	int ls = TSC2301_MUX_LEFT_SHIFT(priv);
-+	int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
-+	int reg = TSC2301_PVAL_TO_REG(priv);
-+	int changed;
-+
-+	mutex_lock(&tsc->mixer->mutex);
-+	shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
-+
-+	/* zero bits to be modified */
-+	shadow_reg &= ~((mask << ls) | (mask << rs));
-+	/* modify with new value */
-+	shadow_reg |= (ucontrol->value.enumerated.item[0] << ls);
-+	shadow_reg |= (ucontrol->value.enumerated.item[1] << rs);
-+
-+	changed = (shadow_reg != shadow_reg_old);
-+
-+	/* update into TSC2301 if necessary */
-+	if (changed) {
-+		tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
-+		tsc2301_write_reg(tsc, reg, shadow_reg);
-+	}
-+
-+	/* check is need to power up/down audio blocks in case of ADC input
-+	 * change */
-+	tsc2301_power_ctrl(tsc, shadow_index, 0);
-+	mutex_unlock(&tsc->mixer->mutex);
-+
-+	return changed;
-+}
-+
-+static int snd_tsc2301_info_bool(struct snd_kcontrol *kcontrol,
-+				 struct snd_ctl_elem_info *uinfo)
-+{
-+	uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
-+	uinfo->count = 1;
-+	uinfo->value.integer.min = 0;
-+	uinfo->value.integer.max = 1;
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_get_bool(struct snd_kcontrol *kcontrol,
-+				struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	int shift = TSC2301_BOOL_SHIFT(priv);
-+	int invert = TSC2301_BOOL_INVERT(priv);
-+	u16 shadow_reg;
-+
-+	shadow_reg = tsc->mixer->shadow_regs[shadow_index];
-+	ucontrol->value.integer.value[0] =
-+		invert ^ ((shadow_reg >> shift) & 1);
-+
-+	return 0;
-+}
-+
-+static int snd_tsc2301_put_bool(struct snd_kcontrol *kcontrol,
-+				struct snd_ctl_elem_value *ucontrol)
-+{
-+	struct tsc2301 *tsc = kcontrol->private_data;
-+	unsigned long priv = kcontrol->private_value;
-+	int shadow_index = TSC2301_SHADOW_INDEX(priv);
-+	int shift = TSC2301_BOOL_SHIFT(priv);
-+	int invert = TSC2301_BOOL_INVERT(priv);
-+	int reg = TSC2301_PVAL_TO_REG(priv);
-+	u16 shadow_reg, shadow_reg_old;
-+	int changed;
-+
-+	mutex_lock(&tsc->mixer->mutex);
-+	shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
-+
-+	/* zero bit to be modified */
-+	shadow_reg &= ~(1 << shift);
-+	/* modify with new value */
-+	shadow_reg |=
-+		(invert ^ (ucontrol->value.integer.value[0] & 1)) << shift;
-+
-+	changed = (shadow_reg != shadow_reg_old);
-+
-+	/* update into TSC2301 if necessary */
-+	if (changed) {
-+		tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
-+		if ((shadow_index == GPIO_INDEX) &&
-+		    (tsc->mixer->shadow_regs[PD_MISC_INDEX] &
-+		     TSC2301_REG_PD_MISC_APD)) {
-+			/* changing GPIO control and audio is powered down.
-+			 * Update GPIO states according to their power-down
-+			 * flag */
-+			tsc2301_gpio_power_down(tsc);
-+		} else
-+			tsc2301_write_reg(tsc, reg, shadow_reg);
-+	}
-+	mutex_unlock(&tsc->mixer->mutex);
-+
-+	return changed;
-+}
-+
-+/* TSC2301 internal mixer controls */
-+static struct snd_kcontrol_new snd_tsc2301_controls[] = {
-+	/* stereo ADC input switches and volumes */
-+	TSC2301_DOUBLE("Capture Switch", 0,
-+		TSC2301_REG_ADCVOL, ADCVOL_INDEX,
-+		TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
-+		1, 0),
-+	TSC2301_DOUBLE("Capture Volume", 0,
-+		TSC2301_REG_ADCVOL, ADCVOL_INDEX,
-+		TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
-+		TSC2301_VOLUME_MASK, TSC2301_MIN_ADCVOL),
-+
-+	/* stereo DAC output switches and volumes */
-+	TSC2301_DOUBLE("PCM Playback Switch", 0,
-+		TSC2301_REG_DACVOL, DACVOL_INDEX,
-+		TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
-+		1, 0),
-+	TSC2301_DOUBLE("PCM Playback Volume", 0,
-+		TSC2301_REG_DACVOL, DACVOL_INDEX,
-+		TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
-+		TSC2301_VOLUME_MASK, TSC2301_MIN_DACVOL),
-+
-+	/* stereo line input bypass switches and volumes */
-+	TSC2301_DOUBLE("Line Playback Switch", 0,
-+		TSC2301_REG_BPVOL, BPVOL_INDEX,
-+		TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
-+		1, 0),
-+	TSC2301_DOUBLE("Line Playback Volume", 0,
-+		TSC2301_REG_BPVOL, BPVOL_INDEX,
-+		TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
-+		TSC2301_VOLUME_MASK, TSC2301_MIN_BPVOL),
-+
-+	/* mono microphone input gain */
-+	TSC2301_SINGLE("Mic Boost", 0,
-+		TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
-+		TSC2301_MICG_SHIFT,
-+		TSC2301_MICG_MASK, TSC2301_MICG_MIN),
-+
-+	/* ADC input sources. Both channels could be selected separately */
-+	TSC2301_MUX("Capture Source", 0,
-+		TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
-+		TSC2301_INML_SHIFT, TSC2301_INMR_SHIFT,
-+		TSC2301_INM_MASK),
-+};
-+
-+/* must be called tsc->mixer->mutex locked */
-+static void tsc2301_flush_shadow_regs(struct tsc2301 *tsc)
-+{
-+	int i, page, addr;
-+	u16 temp;
-+
-+	page = TSC2301_REG_TO_PAGE(TSC2301_REG_AUDCNTL);
-+	addr = TSC2301_REG_TO_ADDR(TSC2301_REG_AUDCNTL);
-+
-+	for (i = 0; i < 4; i++) {
-+		temp = tsc->mixer->shadow_regs[i];
-+		tsc2301_write_reg(tsc, TSC2301_REG(page, addr + i), temp);
-+	}
-+	temp = tsc->mixer->shadow_regs[GPIO_INDEX];
-+	tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
-+
-+	/* Update power state of all audio blocks depending are they
-+	 * muted or unused. */
-+	tsc2301_power_ctrl(tsc, -1, 0);
-+}
-+
-+#ifdef CONFIG_PM
-+int tsc2301_mixer_suspend(struct tsc2301 *tsc)
-+{
-+	/* power down entire audio section inside TSC2301 in case the
-+	 * chip is still powered during the system sleep. However this driver
-+	 * doesn't require that chip is powered because registers are restored
-+	 * in function tsc2301_mixer_resume */
-+	mutex_lock(&tsc->mixer->mutex);
-+	tsc2301_gpio_power_down(tsc);
-+	tsc->mixer->shadow_regs[PD_MISC_INDEX] |= TSC2301_REG_PD_MISC_APD;
-+	tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC,
-+			  tsc->mixer->shadow_regs[PD_MISC_INDEX]);
-+	mutex_unlock(&tsc->mixer->mutex);
-+	return 0;
-+}
-+
-+void tsc2301_mixer_resume(struct tsc2301 *tsc)
-+{
-+	/* power up the TSC2301 audio section and restore registers */
-+	mutex_lock(&tsc->mixer->mutex);
-+	tsc->mixer->shadow_regs[PD_MISC_INDEX] &= ~TSC2301_REG_PD_MISC_APD;
-+	tsc2301_flush_shadow_regs(tsc);
-+	mutex_unlock(&tsc->mixer->mutex);
-+}
-+#endif
-+
-+void tsc2301_mixer_enable_mclk(struct device *dev)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(dev);
-+	struct tsc2301_mixer *mix = tsc->mixer;
-+
-+	mutex_lock(&mix->mutex);
-+	if (!mix->mclk_enabled++ && tsc->enable_clock != NULL) {
-+		tsc->enable_clock(dev);
-+	}
-+	tsc2301_power_ctrl(tsc, -1, 1);
-+	mutex_unlock(&mix->mutex);
-+}
-+
-+void tsc2301_mixer_disable_mclk(struct device *dev)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(dev);
-+	struct tsc2301_mixer *mix = tsc->mixer;
-+
-+	mutex_lock(&mix->mutex);
-+	mix->mclk_enabled--;
-+	tsc2301_power_ctrl(tsc, -1, 1);
-+	if (!mix->mclk_enabled && tsc->disable_clock != NULL) {
-+		tsc->disable_clock(dev);
-+	}
-+	mutex_unlock(&mix->mutex);
-+}
-+
-+static void tsc2301_mixer_delayed_power_down(struct work_struct *work)
-+{
-+	struct tsc2301_mixer *mix = container_of(work, struct tsc2301_mixer,
-+						 delayed_power_down.work);
-+	struct tsc2301 *tsc = mix->tsc;
-+
-+	mutex_lock(&mix->mutex);
-+	if (!mix->delayed_pd_active) {
-+		mutex_unlock(&mix->mutex);
-+		return;
-+	}
-+	mix->delayed_pd_active = 0;
-+	mutex_unlock(&mix->mutex);
-+	tsc2301_mixer_disable_mclk(&tsc->spi->dev);
-+}
-+
-+/*
-+ * Allows audio controller driver to notify its usage of ADC and DAC
-+ */
-+void tsc2301_mixer_set_power(struct device *dev, int dac, int adc)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(dev);
-+
-+	mutex_lock(&tsc->mixer->mutex);
-+	tsc->mixer->adc_enabled = adc;
-+	tsc->mixer->dac_enabled = dac;
-+
-+	/* update power state of all audio blocks */
-+	tsc2301_power_ctrl(tsc, -1, 1);
-+	mutex_unlock(&tsc->mixer->mutex);
-+}
-+
-+/*
-+ * Registers TSC2301 ALSA Mixer controls for the given sound card
-+ */
-+int tsc2301_mixer_register_controls(struct device *dev, struct snd_card *card)
-+{
-+	struct tsc2301 *tsc = dev_get_drvdata(dev);
-+	struct tsc2301_mixer *mix = tsc->mixer;
-+	int i, err;
-+
-+	/* Register ALSA mixer controls */
-+	for (i = 0; i < ARRAY_SIZE(snd_tsc2301_controls); i++) {
-+		err = snd_ctl_add(card,
-+				  snd_ctl_new1(&snd_tsc2301_controls[i], tsc));
-+		if (err < 0)
-+			return err;
-+	}
-+
-+	if (!mix->n_mixer_gpios)
-+		return 0;
-+
-+	/* Register additional GPIO controls if defined */
-+	for (i = 0; i < mix->n_mixer_gpios; i++) {
-+		const struct tsc2301_mixer_gpio *mg = mix->mixer_gpios + i;
-+		struct snd_kcontrol *ctrlp;
-+		struct snd_kcontrol_new ctrl =
-+			TSC2301_BOOL((char *)mg->name, 0,
-+				     TSC2301_REG_GPIO, GPIO_INDEX,
-+				     mg->gpio, mg->inverted, mg->def_enable);
-+
-+		ctrlp = snd_ctl_new1(&ctrl, tsc);
-+		err = snd_ctl_add(card, ctrlp);
-+		if (err < 0)
-+			return err;
-+	}
-+
-+	return 0;
-+}
-+
-+int tsc2301_mixer_init(struct tsc2301 *tsc,
-+		       struct tsc2301_platform_data *pdata)
-+{
-+	struct tsc2301_mixer *mix;
-+	int err = 0;
-+	u16 w;
-+
-+	mix = kzalloc(sizeof(*mix), GFP_KERNEL);
-+	if (mix == NULL)
-+		return -ENOMEM;
-+	tsc->mixer = mix;
-+
-+	mix->tsc = tsc;
-+	mutex_init(&mix->mutex);
-+	mix->platform_init = pdata->codec_init;
-+	mix->platform_cleanup = pdata->codec_cleanup;
-+	mix->pll_output = pdata->pll_output;
-+
-+	INIT_DELAYED_WORK(&mix->delayed_power_down,
-+			  tsc2301_mixer_delayed_power_down);
-+
-+	/* initialize shadow register default values */
-+	w = 0xc000;
-+	w |= (pdata->mclk_ratio << 6) | (pdata->i2s_sample_rate << 2);
-+	w |= pdata->i2s_format;
-+	mix->shadow_regs[AUDCNTL_INDEX] = w;
-+	mix->shadow_regs[ADCVOL_INDEX] = 0xd7d7;
-+	mix->shadow_regs[DACVOL_INDEX] = 0xffff;
-+	mix->shadow_regs[BPVOL_INDEX] = 0xe7e7;
-+	mix->shadow_regs[PD_MISC_INDEX] = pdata->power_down_blocks;
-+
-+	/* if extra mixer controls configured, then configure associated
-+	 * GPIOs as output and drive their default state */
-+	if (pdata->n_mixer_gpios) {
-+		int i;
-+
-+		w = 0;
-+		for (i = 0; i < pdata->n_mixer_gpios; i++) {
-+			const struct tsc2301_mixer_gpio *mg;
-+			int gpio;
-+
-+			mg = pdata->mixer_gpios + i;
-+			gpio = mg->gpio;
-+			w |= (1 << gpio) << 8;
-+			w |= (mg->inverted ^ mg->def_enable) << gpio;
-+		}
-+		mix->shadow_regs[GPIO_INDEX] = w;
-+
-+		mix->mixer_gpios = kmalloc(sizeof(*pdata->mixer_gpios) *
-+					   pdata->n_mixer_gpios,
-+					   GFP_KERNEL);
-+		if (mix->mixer_gpios == NULL) {
-+			err = -ENOMEM;
-+			goto err1;
-+		}
-+		memcpy(mix->mixer_gpios, pdata->mixer_gpios,
-+		       sizeof(*pdata->mixer_gpios) * pdata->n_mixer_gpios);
-+		mix->n_mixer_gpios = pdata->n_mixer_gpios;
-+	}
-+
-+	/* PLL control */
-+	tsc2301_write_pll(tsc, pdata->pll_n, pdata->pll_a, pdata->pll_pdc,
-+			  0, mix->pll_output ? 0 : 1);
-+
-+	tsc2301_flush_shadow_regs(tsc);
-+
-+	if (mix->platform_init != NULL) {
-+		err = mix->platform_init(&tsc->spi->dev);
-+		if (err < 0)
-+			goto err2;
-+	}
-+
-+	return 0;
-+err2:
-+	if (mix->mixer_gpios != NULL)
-+		kfree(mix->mixer_gpios);
-+err1:
-+	kfree(mix);
-+	return err;
-+}
-+
-+void tsc2301_mixer_exit(struct tsc2301 *tsc)
-+{
-+	struct tsc2301_mixer *mixer = tsc->mixer;
-+
-+	if (mixer->platform_cleanup != NULL)
-+		mixer->platform_cleanup(&tsc->spi->dev);
-+
-+	if (mixer->mixer_gpios != NULL)
-+		kfree(mixer->mixer_gpios);
-+}
-+
-+MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
-+MODULE_LICENSE("GPL");
---- /dev/null
-+++ b/include/linux/spi/tsc2301.h
-@@ -0,0 +1,208 @@
-+#ifndef _LINUX_SPI_TSC2301_H
-+#define _LINUX_SPI_TSC2301_H
-+
-+#include <linux/types.h>
-+#include <linux/timer.h>
-+
-+struct tsc2301_platform_data {
-+	/*
-+	 * Keypad
-+	 */
-+	s16	reset_gpio;
-+	s16	keyb_int;
-+	s16	keymap[16];	/* Set a key to a negative value if not used */
-+	unsigned kp_rep:1;	/* Enable keypad repeating */
-+	char    *keyb_name;     /* Keyboard device name */
-+
-+	/*
-+	 * Touchscreen
-+	 */
-+	s16	dav_int;
-+	u16	ts_x_plate_ohm;
-+	u32	ts_stab_time;	/* voltage settling time */
-+	u8	ts_hw_avg;	/* HW assiseted averaging. Can be
-+				   0, 4, 8, 16 samples per reading */
-+	u32	ts_max_pressure;/* Samples with bigger pressure value will
-+				   be ignored, since the corresponding X, Y
-+				   values are unreliable */
-+	u32	ts_touch_pressure;	/* Pressure limit until we report a
-+					   touch event. After that we switch
-+					   to ts_max_pressure. */
-+	u32	ts_pressure_fudge;
-+	u32	ts_x_max;
-+	u32	ts_x_fudge;
-+	u32	ts_y_max;
-+	u32	ts_y_fudge;
-+
-+	/*
-+	 * Audio
-+	 */
-+	unsigned	pll_pdc:4;
-+	unsigned	pll_a:4;
-+	unsigned	pll_n:4;
-+	unsigned	pll_output:1; /* Output PLL on GPIO_0 */
-+
-+	unsigned	mclk_ratio:2;
-+	unsigned	i2s_sample_rate:4;
-+	unsigned	i2s_format:2;
-+	/* Mask for audio blocks to be powered down */
-+	u16		power_down_blocks;
-+
-+	/* Called after codec has been initialized, can be NULL */
-+	int (* codec_init)(struct device *tsc2301_dev);
-+	/* Called when codec is being removed, can be NULL */
-+	void (* codec_cleanup)(struct device *tsc2301_dev);
-+	int	(*enable_clock)(struct device *dev);
-+	void	(*disable_clock)(struct device *dev);
-+
-+	const struct tsc2301_mixer_gpio {
-+		const char	*name;
-+		unsigned	gpio:4;
-+		unsigned	inverted:1;
-+		unsigned	def_enable:1; /* enable by default */
-+		unsigned	deactivate_on_pd:1; /* power-down flag */
-+	} *mixer_gpios;
-+	int	n_mixer_gpios;
-+};
-+
-+struct tsc2301_kp;
-+struct tsc2301_ts;
-+struct tsc2301_mixer;
-+
-+struct tsc2301 {
-+	struct spi_device	*spi;
-+
-+	s16			reset_gpio;
-+	u16			config2_shadow;
-+
-+        struct tsc2301_kp	*kp;
-+	struct tsc2301_ts	*ts;
-+	struct tsc2301_mixer	*mixer;
-+
-+	int			(*enable_clock)(struct device *dev);
-+	void			(*disable_clock)(struct device *dev);
-+};
-+
-+
-+#define TSC2301_HZ	33000000
-+
-+#define TSC2301_REG(page, addr)  (((page) << 11) | ((addr) << 5))
-+#define TSC2301_REG_TO_PAGE(reg) (((reg) >> 11) & 0x03)
-+#define TSC2301_REG_TO_ADDR(reg) (((reg) >> 5)  & 0x1f)
-+
-+#define TSC2301_REG_X		TSC2301_REG(0, 0)
-+#define TSC2301_REG_Y		TSC2301_REG(0, 1)
-+#define TSC2301_REG_Z1		TSC2301_REG(0, 2)
-+#define TSC2301_REG_Z2		TSC2301_REG(0, 3)
-+#define TSC2301_REG_KPDATA	TSC2301_REG(0, 4)
-+#define TSC2301_REG_ADC		TSC2301_REG(1, 0)
-+#define TSC2301_REG_KEY		TSC2301_REG(1, 1)
-+#define TSC2301_REG_DAC		TSC2301_REG(1, 2)
-+#define TSC2301_REG_REF		TSC2301_REG(1, 3)
-+#define TSC2301_REG_RESET	TSC2301_REG(1, 4)
-+#define TSC2301_REG_CONFIG	TSC2301_REG(1, 5)
-+#define TSC2301_REG_CONFIG2	TSC2301_REG(1, 6)
-+#define TSC2301_REG_KPMASK	TSC2301_REG(1, 16)
-+#define TSC2301_REG_AUDCNTL	TSC2301_REG(2, 0)
-+#define TSC2301_REG_ADCVOL	TSC2301_REG(2, 1)
-+#define TSC2301_REG_DACVOL	TSC2301_REG(2, 2)
-+#define TSC2301_REG_BPVOL	TSC2301_REG(2, 3)
-+#define TSC2301_REG_KEYCTL	TSC2301_REG(2, 4)
-+#define TSC2301_REG_PD_MISC	TSC2301_REG(2, 5)
-+#define TSC2301_REG_GPIO	TSC2301_REG(2, 6)
-+#define TSC2301_REG_ADCLKCFG	TSC2301_REG(2, 27)
-+
-+#define TSC2301_REG_PD_MISC_APD		(1 << 15)
-+#define TSC2301_REG_PD_MISC_AVPD	(1 << 14)
-+#define TSC2301_REG_PD_MISC_ABPD	(1 << 13)
-+#define TSC2301_REG_PD_MISC_HAPD	(1 << 12)
-+#define TSC2301_REG_PD_MISC_MOPD	(1 << 11)
-+#define TSC2301_REG_PD_MISC_DAPD	(1 << 10)
-+#define TSC2301_REG_PD_MISC_ADPDL	(1 << 9)
-+#define TSC2301_REG_PD_MISC_ADPDR	(1 << 8)
-+#define TSC2301_REG_PD_MISC_PDSTS	(1 << 7)
-+#define TSC2301_REG_PD_MISC_MIBPD	(1 << 6)
-+#define TSC2301_REG_PD_MISC_OTSYN	(1 << 2)
-+
-+/* I2S sample rate */
-+#define TSC2301_I2S_SR_48000	0x00
-+#define TSC2301_I2S_SR_44100	0x01
-+#define TSC2301_I2S_SR_32000	0x02
-+#define TSC2301_I2S_SR_24000	0x03
-+#define TSC2301_I2S_SR_22050	0x04
-+#define TSC2301_I2S_SR_16000	0x05
-+#define TSC2301_I2S_SR_12000	0x06
-+#define TSC2301_I2S_SR_11050	0x07
-+#define TSC2301_I2S_SR_8000	0x08
-+
-+/* 16-bit, MSB-first. DAC Right-Justified, ADC Left-Justified */
-+#define TSC2301_I2S_FORMAT0	0x00
-+/* 20-bit, MSB-first. DAC Right-Justified, ADC Left-Justified */
-+#define TSC2301_I2S_FORMAT1	0x01
-+/* 20-bit, MSB-first. DAC Left-Justified, ADC Left-Justified */
-+#define TSC2301_I2S_FORMAT2	0x02
-+/* 20-bit, MSB-first */
-+#define TSC2301_I2S_FORMAT3	0x03
-+
-+/* Master Clock Ratio */
-+#define TSC2301_MCLK_256xFS	0x00 /* default */
-+#define TSC2301_MCLK_384xFS	0x01
-+#define TSC2301_MCLK_512xFS	0x02
-+
-+
-+extern u16 tsc2301_read_reg(struct tsc2301 *tsc, int reg);
-+extern void tsc2301_write_reg(struct tsc2301 *tsc, int reg, u16 val);
-+extern void tsc2301_write_kbc(struct tsc2301 *tsc, int val);
-+extern void tsc2301_write_pll(struct tsc2301 *tsc, int pll_n, int pll_a,
-+			      int pll_pdc, int pct_e, int pll_o);
-+extern void tsc2301_read_buf(struct tsc2301 *tsc, int reg, u16 *buf, int len);
-+
-+#define TSC2301_DECL_MOD(module)					\
-+extern int  tsc2301_##module##_init(struct tsc2301 *tsc,		\
-+			   struct tsc2301_platform_data *pdata);	\
-+extern void tsc2301_##module##_exit(struct tsc2301 *tsc);		\
-+extern int  tsc2301_##module##_suspend(struct tsc2301 *tsc);		\
-+extern void tsc2301_##module##_resume(struct tsc2301 *tsc);
-+
-+#define TSC2301_DECL_EMPTY_MOD(module)					\
-+static inline int tsc2301_##module##_init(struct tsc2301 *tsc,		\
-+			   struct tsc2301_platform_data *pdata)		\
-+{									\
-+	return 0;							\
-+}									\
-+static inline void tsc2301_##module##_exit(struct tsc2301 *tsc) {}	\
-+static inline int  tsc2301_##module##_suspend(struct tsc2301 *tsc)	\
-+{									\
-+	return 0;							\
-+}									\
-+static inline void tsc2301_##module##_resume(struct tsc2301 *tsc) {}
-+
-+#ifdef CONFIG_KEYBOARD_TSC2301
-+TSC2301_DECL_MOD(kp)
-+void tsc2301_kp_restart(struct tsc2301 *tsc);
-+#else
-+TSC2301_DECL_EMPTY_MOD(kp)
-+static inline void tsc2301_kp_restart(struct tsc2301 *tsc) {}
-+#endif
-+
-+#ifdef CONFIG_TOUCHSCREEN_TSC2301
-+TSC2301_DECL_MOD(ts)
-+#else
-+TSC2301_DECL_EMPTY_MOD(ts)
-+#endif
-+
-+#ifdef CONFIG_SPI_TSC2301_AUDIO
-+TSC2301_DECL_MOD(mixer)
-+extern void tsc2301_mixer_set_power(struct device *tsc_dev, int dac, int adc);
-+
-+struct snd_card;
-+extern int tsc2301_mixer_register_controls(struct device *tsc_dev,
-+					   struct snd_card *card);
-+#else
-+TSC2301_DECL_EMPTY_MOD(mixer)
-+#endif
-+
-+extern void tsc2301_mixer_enable_mclk(struct device *tsc_dev);
-+extern void tsc2301_mixer_disable_mclk(struct device *tsc_dev);
-+
-+#endif
-- 
cgit v1.2.3