path: root/meta-moblin/packages/linux/linux-moblin-2.6.29.1/linux-2.6.29-timberdale.patch

Patch provided by Mocean in order to enable the timberdale subsystem of the Russelville board. 
  
Signed-off-by: Joel Clark <joel.clark@intel.com>
Acked-by: Arjan van de Ven <arjan@infradead.org>
Signed-off-by: Todd Brandt todd.e.brandt@intel.com


diff -uNr linux-2.6.29-clean/drivers/gpio/Kconfig linux-2.6.29/drivers/gpio/Kconfig
--- linux-2.6.29-clean/drivers/gpio/Kconfig	2009-04-01 09:20:23.000000000 -0700
+++ linux-2.6.29/drivers/gpio/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -161,6 +161,12 @@
 
 	  If unsure, say N.
 
+config GPIO_TIMBERDALE
+	tristate "Support for timberdale GPIO"
+	depends on MFD_TIMBERDALE && GPIOLIB
+	---help---
+	Add support for GPIO usage of some pins of the timberdale FPGA.
+
 comment "SPI GPIO expanders:"
 
 config GPIO_MAX7301
diff -uNr linux-2.6.29-clean/drivers/gpio/Makefile linux-2.6.29/drivers/gpio/Makefile
--- linux-2.6.29-clean/drivers/gpio/Makefile	2009-04-01 09:20:23.000000000 -0700
+++ linux-2.6.29/drivers/gpio/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -12,3 +12,4 @@
 obj-$(CONFIG_GPIO_TWL4030)	+= twl4030-gpio.o
 obj-$(CONFIG_GPIO_XILINX)	+= xilinx_gpio.o
 obj-$(CONFIG_GPIO_BT8XX)	+= bt8xxgpio.o
+obj-$(CONFIG_GPIO_TIMBERDALE)	+= timbgpio.o
diff -uNr linux-2.6.29-clean/drivers/gpio/timbgpio.c linux-2.6.29/drivers/gpio/timbgpio.c
--- linux-2.6.29-clean/drivers/gpio/timbgpio.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/gpio/timbgpio.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,275 @@
+/*
+ * timbgpio.c timberdale FPGA GPIO driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA GPIO
+ */
+
+#include <linux/module.h>
+#include <linux/gpio.h>
+#include <linux/pci.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+
+#include "timbgpio.h"
+
+static u32 timbgpio_configure(struct gpio_chip *gpio, unsigned nr,
+						unsigned off, unsigned val)
+{
+	struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio);
+
+	u32 config, oldconfig, wconfig;
+
+	mutex_lock(&tgpio->lock);
+	config = ioread32(tgpio->membase + off);
+	oldconfig = config;
+
+	if (val)
+		config |= (1 << nr);
+	else
+		config &= ~(1 << nr);
+
+	iowrite32(config, tgpio->membase + off);
+	wconfig = ioread32(tgpio->membase + off);
+	mutex_unlock(&tgpio->lock);
+
+	return oldconfig;
+}
+
+static int timbgpio_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
+{
+	timbgpio_configure(gpio, nr, TGPIODIR, 1);
+	return 0;
+}
+
+static int timbgpio_gpio_get(struct gpio_chip *gpio, unsigned nr)
+{
+	struct timbgpio *tgpio = container_of(gpio, struct timbgpio, gpio);
+	u32 value;
+
+	value = ioread32(tgpio->membase + TGPIOVAL);
+	return (value & (1 << nr)) ? 1 : 0;
+}
+
+static int timbgpio_gpio_direction_output(struct gpio_chip *gpio,
+						unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIODIR, 0);
+	return 0;
+}
+
+
+
+static void timbgpio_gpio_set(struct gpio_chip *gpio,
+				unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIOVAL, val);
+}
+
+/*
+ * Function to control flank or level triggered GPIO pin
+ * @nr - pin
+ * @ val - 1: flank, 0: level
+ *
+ */
+static void timbgpio_gpio_flnk_lvl_ctrl(struct gpio_chip *gpio,
+						unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIOFLK, val);
+}
+EXPORT_SYMBOL(timbgpio_gpio_flnk_lvl_ctrl);
+
+/*
+ * Enable or disable interrupt
+ *
+ */
+static void timbgpio_gpio_int_ctrl(struct gpio_chip *gpio,
+					unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIOINT, val);
+}
+EXPORT_SYMBOL(timbgpio_gpio_int_ctrl);
+
+/*
+ * @val - 1: Asserted high or on positive flank, 0: Asserted low or on negative flank
+ *
+ */
+static void timbgpio_gpio_lvl_ctrl(struct gpio_chip *gpio,
+					unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIOLVL, val);
+}
+EXPORT_SYMBOL(timbgpio_gpio_lvl_ctrl);
+
+static void timbgpio_gpio_int_clr(struct gpio_chip *gpio,
+					unsigned nr, int val)
+{
+	timbgpio_configure(gpio, nr, TGPIOINT_CLR, val);
+}
+EXPORT_SYMBOL(timbgpio_gpio_int_clr);
+
+
+static irqreturn_t timbgpio_handleinterrupt(int irq, void *devid)
+{
+	struct timbgpio *tgpio = (struct timbgpio *)devid;
+
+	iowrite32(0xffffffff, tgpio->membase + TGPIOINT_CLR);
+
+	return IRQ_HANDLED;
+}
+
+static int timbgpio_probe(struct platform_device *dev)
+{
+	int err, irq;
+	struct gpio_chip *gc;
+	struct timbgpio *tgpio;
+	struct resource *iomem, *rscr;
+
+	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (!iomem) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	tgpio = kzalloc(sizeof(*tgpio), GFP_KERNEL);
+	if (!tgpio) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	mutex_init(&tgpio->lock);
+
+	rscr = &tgpio->rscr;
+	rscr->name = "timb-gpio";
+	rscr->start = iomem->start;
+	rscr->end = iomem->end;
+	rscr->flags = IORESOURCE_MEM;
+
+	err = request_resource(iomem, rscr);
+	if (err)
+		goto err_request;
+
+	tgpio->membase = ioremap(rscr->start, resource_size(rscr));
+	if (!tgpio->membase) {
+		err = -ENOMEM;
+		goto err_ioremap;
+	}
+
+	gc = &tgpio->gpio;
+
+	gc->label = "timbgpio";
+	gc->owner = THIS_MODULE;
+	gc->direction_input = timbgpio_gpio_direction_input;
+	gc->get = timbgpio_gpio_get;
+	gc->direction_output = timbgpio_gpio_direction_output;
+	gc->set = timbgpio_gpio_set;
+	gc->dbg_show = NULL;
+	gc->base = 0;
+	gc->ngpio = TIMB_NR_GPIOS;
+	gc->can_sleep = 0;
+
+	err = gpiochip_add(gc);
+	if (err)
+		goto err_chipadd;
+
+	platform_set_drvdata(dev, tgpio);
+
+	/* register interrupt */
+	irq = platform_get_irq(dev, 0);
+	if (irq < 0)
+		goto err_get_irq;
+
+	/* clear pending interrupts */
+	iowrite32(0xffffffff, tgpio->membase + TGPIOINT_CLR);
+	iowrite32(0x0, tgpio->membase + TGPIOINT);
+
+	/* request IRQ */
+	err = request_irq(irq, timbgpio_handleinterrupt, IRQF_SHARED,
+			  "timb-gpio", tgpio);
+	if (err) {
+		printk(KERN_ERR "timbgpio: Failed to request IRQ\n");
+		goto err_get_irq;
+	}
+
+	return err;
+
+err_get_irq:
+	err = gpiochip_remove(&tgpio->gpio);
+	if (err)
+		printk(KERN_ERR "timbgpio: failed to remove gpio_chip\n");
+err_chipadd:
+	iounmap(tgpio->membase);
+err_ioremap:
+	release_resource(&tgpio->rscr);
+err_request:
+	kfree(tgpio);
+err_mem:
+	printk(KERN_ERR "timberdale: Failed to register GPIOs: %d\n", err);
+
+	return err;
+}
+
+static int timbgpio_remove(struct platform_device *dev)
+{
+	int err;
+	struct timbgpio *tgpio = platform_get_drvdata(dev);
+
+	/* disable interrupts */
+	iowrite32(0x0, tgpio->membase + TGPIOINT);
+
+	free_irq(platform_get_irq(dev, 0), tgpio);
+	err = gpiochip_remove(&tgpio->gpio);
+	if (err)
+		printk(KERN_ERR "timbgpio: failed to remove gpio_chip\n");
+
+	iounmap(tgpio->membase);
+	release_resource(&tgpio->rscr);
+	kfree(tgpio);
+
+	return 0;
+}
+
+static struct platform_driver timbgpio_platform_driver = {
+	.driver = {
+		.name	= "timb-gpio",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= timbgpio_probe,
+	.remove		= timbgpio_remove,
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timbgpio_init(void)
+{
+	return platform_driver_register(&timbgpio_platform_driver);
+}
+
+static void __exit timbgpio_exit(void)
+{
+	platform_driver_unregister(&timbgpio_platform_driver);
+}
+
+module_init(timbgpio_init);
+module_exit(timbgpio_exit);
+
+MODULE_DESCRIPTION("Timberdale GPIO driver");
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Mocean Laboratories");
+MODULE_ALIAS("platform:timb-gpio");
+
diff -uNr linux-2.6.29-clean/drivers/gpio/timbgpio.h linux-2.6.29/drivers/gpio/timbgpio.h
--- linux-2.6.29-clean/drivers/gpio/timbgpio.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/gpio/timbgpio.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,48 @@
+/*
+ * timbgpio.h timberdale FPGA GPIO driver defines
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA GPIO
+ */
+
+#ifndef _TIMBGPIO_H_
+#define _TIMBGPIO_H_
+
+#include <linux/mutex.h>
+#include <linux/gpio.h>
+
+#define TIMB_NR_GPIOS 16
+
+#define TGPIOVAL 	0
+#define TGPIODIR 	0x04
+#define TGPIOINT 	0x08
+#define TGPIOINT_STATUS	0x0c
+#define TGPIOINT_PENDING 0x10
+#define TGPIOINT_CLR	0x14
+#define TGPIOFLK 	0x18
+#define TGPIOLVL 	0x1c
+
+struct timbgpio {
+	void __iomem		*membase;
+	struct resource		rscr;
+	struct mutex		lock; /* mutual exclusion */
+	struct pci_dev		*pdev;
+	struct gpio_chip	gpio;
+};
+
+#endif
diff -uNr linux-2.6.29-clean/drivers/i2c/busses/i2c-ocores.c linux-2.6.29/drivers/i2c/busses/i2c-ocores.c
--- linux-2.6.29-clean/drivers/i2c/busses/i2c-ocores.c	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/i2c/busses/i2c-ocores.c	2009-04-06 13:51:47.000000000 -0700
@@ -216,6 +216,7 @@
 	struct ocores_i2c_platform_data *pdata;
 	struct resource *res, *res2;
 	int ret;
+	u8 i;
 
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res)
@@ -271,6 +272,10 @@
 		goto add_adapter_failed;
 	}
 
+	/* add in known devices to the bus */
+	for (i = 0; i < pdata->num_devices; i++)
+		i2c_new_device(&i2c->adap, pdata->devices + i);
+
 	return 0;
 
 add_adapter_failed:
diff -uNr linux-2.6.29-clean/drivers/input/touchscreen/Kconfig linux-2.6.29/drivers/input/touchscreen/Kconfig
--- linux-2.6.29-clean/drivers/input/touchscreen/Kconfig	2009-04-01 09:20:23.000000000 -0700
+++ linux-2.6.29/drivers/input/touchscreen/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -397,6 +397,17 @@
 	  To compile this driver as a module, choose M here: the
 	  module will be called touchit213.
 
+config TOUCHSCREEN_TSC2003
+	tristate "TSC2003 based touchscreens"
+	depends on I2C
+	help
+	  Say Y here if you have a TSC2003 based touchscreen.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called tsc2003.
+
 config TOUCHSCREEN_TSC2007
 	tristate "TSC2007 based touchscreens"
 	depends on I2C
diff -uNr linux-2.6.29-clean/drivers/input/touchscreen/Makefile linux-2.6.29/drivers/input/touchscreen/Makefile
--- linux-2.6.29-clean/drivers/input/touchscreen/Makefile	2009-04-01 09:20:23.000000000 -0700
+++ linux-2.6.29/drivers/input/touchscreen/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -25,6 +25,7 @@
 obj-$(CONFIG_TOUCHSCREEN_TOUCHIT213)	+= touchit213.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHRIGHT)	+= touchright.o
 obj-$(CONFIG_TOUCHSCREEN_TOUCHWIN)	+= touchwin.o
+obj-$(CONFIG_TOUCHSCREEN_TSC2003)	+= tsc2003.o
 obj-$(CONFIG_TOUCHSCREEN_TSC2007)	+= tsc2007.o
 obj-$(CONFIG_TOUCHSCREEN_UCB1400)	+= ucb1400_ts.o
 obj-$(CONFIG_TOUCHSCREEN_WACOM_W8001)	+= wacom_w8001.o
diff -uNr linux-2.6.29-clean/drivers/input/touchscreen/tsc2003.c linux-2.6.29/drivers/input/touchscreen/tsc2003.c
--- linux-2.6.29-clean/drivers/input/touchscreen/tsc2003.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/input/touchscreen/tsc2003.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,387 @@
+/*
+ * tsc2003.c Driver for TI TSC2003 touch screen controller
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * TI TSC2003
+ *
+ * Inspired by tsc2007, Copyright (c) 2008 MtekVision Co., Ltd.
+ */
+#include <linux/module.h>
+#include <linux/input.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/i2c/tsc2007.h>
+#include <linux/kthread.h>
+#include <linux/semaphore.h>
+
+#define TSC2003_DRIVER_NAME		"tsc2003"
+
+#define TS_POLL_PERIOD	20		/* ms delay between samples */
+
+#define TSC2003_MEASURE_TEMP0		(0x0 << 4)
+#define TSC2003_MEASURE_AUX		(0x2 << 4)
+#define TSC2003_MEASURE_TEMP1		(0x4 << 4)
+#define TSC2003_ACTIVATE_XN		(0x8 << 4)
+#define TSC2003_ACTIVATE_YN		(0x9 << 4)
+#define TSC2003_ACTIVATE_YP_XN		(0xa << 4)
+#define TSC2003_SETUP			(0xb << 4)
+#define TSC2003_MEASURE_X		(0xc << 4)
+#define TSC2003_MEASURE_Y		(0xd << 4)
+#define TSC2003_MEASURE_Z1		(0xe << 4)
+#define TSC2003_MEASURE_Z2		(0xf << 4)
+
+#define TSC2003_POWER_OFF_IRQ_EN	(0x0 << 2)
+#define TSC2003_ADC_ON_IRQ_DIS0		(0x1 << 2)
+#define TSC2003_ADC_OFF_IRQ_EN		(0x2 << 2)
+#define TSC2003_ADC_ON_IRQ_DIS1		(0x3 << 2)
+
+#define TSC2003_12BIT			(0x0 << 1)
+#define TSC2003_8BIT			(0x1 << 1)
+
+#define	MAX_12BIT			((1 << 12) - 1)
+
+#define ADC_ON_12BIT	(TSC2003_12BIT | TSC2003_ADC_ON_IRQ_DIS0)
+
+#define READ_Y		(ADC_ON_12BIT | TSC2003_MEASURE_Y)
+#define READ_Z1		(ADC_ON_12BIT | TSC2003_MEASURE_Z1)
+#define READ_Z2		(ADC_ON_12BIT | TSC2003_MEASURE_Z2)
+#define READ_X		(ADC_ON_12BIT | TSC2003_MEASURE_X)
+#define PWRDOWN		(TSC2003_12BIT | TSC2003_POWER_OFF_IRQ_EN)
+
+struct ts_event {
+	int	x;
+	int	y;
+	int	z1, z2;
+};
+
+struct tsc2003 {
+	struct input_dev	*input;
+	char			phys[32];
+	struct task_struct	*task;
+	struct ts_event		tc;
+	struct completion 	penirq_completion;
+
+	struct i2c_client	*client;
+
+	u16			model;
+	u16			x_plate_ohms;
+
+	unsigned		pendown;
+};
+
+static inline int tsc2003_xfer(struct tsc2003 *tsc, u8 cmd)
+{
+	s32 data;
+	u16 val;
+
+	data = i2c_smbus_read_word_data(tsc->client, cmd);
+	if (data < 0) {
+		dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
+		return data;
+	}
+
+	/* The protocol and raw data format from i2c interface:
+	 * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
+	 * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
+	 */
+	val = swab16(data) >> 4;
+
+	dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);
+
+	return val;
+}
+
+static void tsc2003_send_event(void *tsc)
+{
+	struct tsc2003	*ts = tsc;
+	struct input_dev *input = ts->input;
+	u32		rt = 0;
+	u16		x, y, z1, z2;
+
+	x = ts->tc.x;
+	y = ts->tc.y;
+	z1 = ts->tc.z1;
+	z2 = ts->tc.z2;
+
+	/* range filtering */
+	if (x == MAX_12BIT)
+		x = 0;
+
+	if (likely(x && z1)) {
+		/* compute touch pressure resistance using equation #1 */
+		rt = z2;
+		rt -= z1;
+		rt *= x;
+		rt *= ts->x_plate_ohms;
+		rt /= z1;
+		rt = (rt + 2047) >> 12;
+	}
+
+	/* Sample found inconsistent by debouncing or pressure is beyond
+	 * the maximum. Don't report it to user space, repeat at least
+	 * once more the measurement
+	 */
+	if (rt > MAX_12BIT)
+		return;
+
+	/* NOTE: We can't rely on the pressure to determine the pen down
+	 * state, even this controller has a pressure sensor.  The pressure
+	 * value can fluctuate for quite a while after lifting the pen and
+	 * in some cases may not even settle at the expected value.
+	 *
+	 * The only safe way to check for the pen up condition is in the
+	 * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
+	 */
+	if (rt) {
+		if (!ts->pendown) {
+			dev_dbg(&ts->client->dev, "DOWN\n");
+
+			input_report_key(input, BTN_TOUCH, 1);
+			ts->pendown = 1;
+		}
+
+		input_report_abs(input, ABS_X, x);
+		input_report_abs(input, ABS_Y, y);
+		input_report_abs(input, ABS_PRESSURE, rt);
+
+		input_sync(input);
+
+		dev_dbg(&ts->client->dev, "point(%4d,%4d), pressure (%4u)\n",
+			x, y, rt);
+	} else if (ts->pendown) {
+		/* pen up */
+		dev_dbg(&ts->client->dev, "UP\n");
+		input_report_key(input, BTN_TOUCH, 0);
+		input_report_abs(input, ABS_PRESSURE, 0);
+		input_sync(input);
+
+		ts->pendown = 0;
+	}
+}
+
+static int tsc2003_power_off_irq_en(struct tsc2003 *tsc)
+{
+	/* power down */
+	return tsc2003_xfer(tsc, PWRDOWN);
+}
+
+static int tsc2003_read_values(struct tsc2003 *tsc)
+{
+	/* y- still on; turn on only y+ (and ADC) */
+	tsc->tc.y = tsc2003_xfer(tsc, READ_Y);
+	if (tsc->tc.y < 0)
+		return tsc->tc.y;
+
+	/* turn y- off, x+ on, then leave in lowpower */
+	tsc->tc.x = tsc2003_xfer(tsc, READ_X);
+	if (tsc->tc.x < 0)
+		return tsc->tc.x;
+
+	/* turn y+ off, x- on; we'll use formula #1 */
+	tsc->tc.z1 = tsc2003_xfer(tsc, READ_Z1);
+	if (tsc->tc.z1 < 0)
+		return tsc->tc.z1;
+
+	tsc->tc.z2 = tsc2003_xfer(tsc, READ_Z2);
+	if (tsc->tc.z2 < 0)
+		return tsc->tc.z2;
+
+	return 0;
+}
+
+
+static irqreturn_t tsc2003_irq(int irq, void *handle)
+{
+	struct tsc2003 *ts = handle;
+
+	/* do not call the synced version -> deadlock */
+	disable_irq_nosync(irq);
+	/* signal the thread to continue */
+	complete(&ts->penirq_completion);
+
+	return IRQ_HANDLED;
+}
+
+static int tsc2003_thread(void *d)
+{
+	struct tsc2003 *ts = (struct tsc2003 *)d;
+	int ret;
+
+	allow_signal(SIGKILL);
+
+	while (!signal_pending(current)) {
+		/* power down and wait for interrupt */
+		do {
+			/* loop because the I2C bus might be busy */
+			ret = msleep_interruptible(TS_POLL_PERIOD);
+			if (!ret)
+				ret = tsc2003_power_off_irq_en(ts);
+		} while (ret == -EAGAIN && !signal_pending(current));
+
+		if (signal_pending(current))
+			break;
+
+		ret = wait_for_completion_interruptible(&ts->penirq_completion);
+		if (!ret) {
+			int first = 1;
+			/* got IRQ, start poll, until pen is up */
+			while (!ret && !signal_pending(current)
+				&& (first || ts->pendown)) {
+				ret = tsc2003_read_values(ts);
+				if (!ret)
+					tsc2003_send_event(ts);
+				ret = msleep_interruptible(TS_POLL_PERIOD);
+				first = 0;
+			}
+
+			/* we re enable the interrupt */
+			if (!signal_pending(current))
+				enable_irq(ts->client->irq);
+		}
+	}
+
+	return 0;
+}
+
+static int tsc2003_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	struct tsc2003 *ts;
+	struct tsc2007_platform_data *pdata = client->dev.platform_data;
+	struct input_dev *input_dev;
+	int err;
+
+	if (!pdata) {
+		dev_err(&client->dev, "platform data is required!\n");
+		return -EINVAL;
+	}
+
+	if (!i2c_check_functionality(client->adapter,
+				     I2C_FUNC_SMBUS_READ_WORD_DATA))
+		return -EIO;
+
+	ts = kzalloc(sizeof(struct tsc2003), GFP_KERNEL);
+	input_dev = input_allocate_device();
+	if (!ts || !input_dev) {
+		err = -ENOMEM;
+		goto err_free_mem;
+	}
+
+	ts->client = client;
+	i2c_set_clientdata(client, ts);
+
+	ts->input = input_dev;
+
+	ts->model             = pdata->model;
+	ts->x_plate_ohms      = pdata->x_plate_ohms;
+
+	snprintf(ts->phys, sizeof(ts->phys),
+		 "%s/input0", dev_name(&client->dev));
+
+	input_dev->name = TSC2003_DRIVER_NAME" Touchscreen";
+	input_dev->phys = ts->phys;
+	input_dev->id.bustype = BUS_I2C;
+
+	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
+
+	input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
+	input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
+	input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);
+
+	init_completion(&ts->penirq_completion);
+
+	ts->task = kthread_run(tsc2003_thread, ts, TSC2003_DRIVER_NAME);
+	if (IS_ERR(ts->task)) {
+		err = PTR_ERR(ts->task);
+		goto err_free_mem;
+	}
+
+	err = request_irq(client->irq, tsc2003_irq, 0,
+			client->dev.driver->name, ts);
+	if (err < 0) {
+		dev_err(&client->dev, "irq %d busy?\n", client->irq);
+		goto err_free_thread;
+	}
+
+	err = input_register_device(input_dev);
+	if (err)
+		goto err_free_irq;
+
+	dev_info(&client->dev, "registered with irq (%d)\n", client->irq);
+
+	return 0;
+
+ err_free_irq:
+	free_irq(client->irq, ts);
+ err_free_thread:
+	kthread_stop(ts->task);
+ err_free_mem:
+	input_free_device(input_dev);
+	kfree(ts);
+	return err;
+}
+
+static int tsc2003_remove(struct i2c_client *client)
+{
+	struct tsc2003 *ts = i2c_get_clientdata(client);
+
+	free_irq(client->irq, ts);
+	send_sig(SIGKILL, ts->task, 1);
+	kthread_stop(ts->task);
+	input_unregister_device(ts->input);
+	kfree(ts);
+
+	return 0;
+}
+
+static struct i2c_device_id tsc2003_idtable[] = {
+	{ TSC2003_DRIVER_NAME, 0 },
+	{ }
+};
+
+MODULE_DEVICE_TABLE(i2c, tsc2003_idtable);
+
+static struct i2c_driver tsc2003_driver = {
+	.driver = {
+		.owner	= THIS_MODULE,
+		.name	= TSC2003_DRIVER_NAME,
+		.bus = &i2c_bus_type,
+	},
+	.id_table	= tsc2003_idtable,
+	.probe		= tsc2003_probe,
+	.remove		= tsc2003_remove,
+};
+
+static int __init tsc2003_init(void)
+{
+	return i2c_add_driver(&tsc2003_driver);
+}
+
+static void __exit tsc2003_exit(void)
+{
+	i2c_del_driver(&tsc2003_driver);
+}
+
+module_init(tsc2003_init);
+module_exit(tsc2003_exit);
+
+MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
+MODULE_DESCRIPTION("TSC2003 TouchScreen Driver");
+MODULE_LICENSE("GPL v2");
+
diff -uNr linux-2.6.29-clean/drivers/media/video/adv7180.c linux-2.6.29/drivers/media/video/adv7180.c
--- linux-2.6.29-clean/drivers/media/video/adv7180.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/media/video/adv7180.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,361 @@
+/*
+ * adv7180.c Analog Devices ADV7180 video decoder driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/fs.h>
+#include <linux/kernel.h>
+#include <linux/major.h>
+#include <linux/slab.h>
+#include <linux/mm.h>
+#include <linux/signal.h>
+#include <linux/types.h>
+#include <linux/io.h>
+#include <asm/pgtable.h>
+#include <asm/page.h>
+#include <linux/uaccess.h>
+
+#include <linux/i2c-ocores.h>
+#include <linux/platform_device.h>
+#include <linux/i2c.h>
+#include <linux/i2c-id.h>
+#include <linux/videodev.h>
+#include <linux/video_decoder.h>
+#include <media/v4l2-ioctl.h>
+#include <media/adv7180.h>
+
+
+MODULE_DESCRIPTION("Analog Devices ADV7180 video decoder driver");
+MODULE_AUTHOR("Mocean Laboratories");
+MODULE_LICENSE("GPL v2");
+
+static inline int adv7180_write(struct i2c_client *client,
+						u8 reg, u8 value)
+{
+	struct adv7180 *decoder = i2c_get_clientdata(client);
+
+	decoder->reg[reg] = value;
+	return i2c_smbus_write_byte_data(client, reg, value);
+}
+
+static inline int adv7180_read(struct i2c_client *client, u8 reg)
+{
+	return i2c_smbus_read_byte_data(client, reg);
+}
+
+static int adv7180_write_block(struct i2c_client *client,
+			const u8 *data, unsigned int len)
+{
+	int ret = -1;
+	u8 reg;
+
+	/* the adv7180 has an autoincrement function, use it if
+	 * the adapter understands raw I2C */
+	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+		/* do raw I2C, not smbus compatible */
+		struct adv7180 *decoder = i2c_get_clientdata(client);
+		u8 block_data[32];
+		int block_len;
+
+		while (len >= 2) {
+			block_len = 0;
+			reg = data[0];
+			block_data[block_len++] = reg;
+			do {
+				block_data[block_len++] =
+					decoder->reg[reg++] = data[1];
+				len -= 2;
+				data += 2;
+			} while (len >= 2 && data[0] == reg &&
+					block_len < 32);
+
+			ret = i2c_master_send(client, block_data, block_len);
+			if (ret < 0)
+				break;
+		}
+	} else {
+		/* do some slow I2C emulation kind of thing */
+		while (len >= 2) {
+			reg = *data++;
+			ret = adv7180_write(client, reg, *data++);
+			if (ret < 0)
+				break;
+
+			len -= 2;
+		}
+	}
+
+	return ret;
+}
+#ifdef CONFIG_MFD_TIMBERDALE
+static irqreturn_t adv7180_irq(int irq, void *dev_id)
+{
+	struct adv7180 *decoder = (struct adv7180 *) dev_id;
+
+	/* Activate access to sub-regs */
+	adv7180_write(decoder->client, ADV7180_ADI_CTRL, ADI_ENABLE);
+
+	/* TODO: implement a real interrupt handler
+	 * for now just
+	 * clear all four regs
+	 */
+	adv7180_write_block(decoder->client, reset_icr, sizeof(reset_icr));
+
+	return IRQ_HANDLED;
+}
+#endif
+static int adv7180_command(struct i2c_client *client,
+					unsigned int cmd, void *arg)
+{
+	struct adv7180 *decoder = i2c_get_clientdata(client);
+	int *iarg = (int *)arg;
+	int status;
+
+	switch (cmd) {
+
+	case DECODER_INIT:
+		adv7180_write(client, 0x0f, 0x80); /* Reset */
+		break;
+
+	case DECODER_GET_CAPABILITIES:
+	{
+		struct video_decoder_capability *cap = arg;
+		cap->flags = VIDEO_DECODER_PAL |
+				VIDEO_DECODER_NTSC |
+				VIDEO_DECODER_SECAM |
+				VIDEO_DECODER_AUTO;
+		cap->inputs = 3;
+		cap->outputs = 1;
+	}
+	break;
+
+	case DECODER_GET_STATUS:
+	{
+		*iarg = 0;
+		status = adv7180_read(client, ADV7180_SR);
+		if ((status & ADV7180_STATUS_PAL))
+			*iarg = (*iarg | DECODER_STATUS_PAL);
+
+		if ((status & ADV7180_STATUS_NTSC))
+			*iarg = (*iarg | DECODER_STATUS_NTSC);
+
+		if ((status & ADV7180_STATUS_SECAM))
+			*iarg = (*iarg | DECODER_STATUS_SECAM);
+	}
+	break;
+
+	case DECODER_SET_NORM:
+	{
+		int v = *(int *) arg;
+		if (decoder->norm != v) {
+			decoder->norm = v;
+			switch (v) {
+			case VIDEO_MODE_NTSC:
+				adv7180_write(client, ADV7180_IN_CTRL, 0x40);
+				break;
+			case VIDEO_MODE_PAL:
+				adv7180_write(client, ADV7180_IN_CTRL, 0x70);
+				break;
+			case VIDEO_MODE_SECAM:
+				adv7180_write(client, ADV7180_IN_CTRL, 0x90);
+				break;
+			case VIDEO_MODE_AUTO:
+				adv7180_write(client, ADV7180_IN_CTRL, 0x00);
+				break;
+			default:
+				return -EPERM;
+			}
+		}
+	}
+	break;
+
+	case DECODER_SET_INPUT:
+	{
+		int v = *(int *) arg;
+		if (decoder->input != v) {
+			decoder->input = v;
+
+			switch (v) {
+			case CVBS:
+				adv7180_write_block(client, init_cvbs_64,
+							sizeof(init_cvbs_64));
+				break;
+			case SVIDEO:
+				adv7180_write_block(client, init_svideo_64,
+							sizeof(init_svideo_64));
+				break;
+			case YPbPr:
+				adv7180_write_block(client, init_ypbpr_64,
+							sizeof(init_ypbpr_64));
+				break;
+			default:
+				return -EINVAL;
+			}
+		}
+	}
+	break;
+
+	case DECODER_SET_OUTPUT:
+	{
+	}
+	break;
+
+	case DECODER_ENABLE_OUTPUT:
+	{
+	}
+	break;
+
+	case DECODER_SET_PICTURE:
+	{
+	}
+	break;
+
+	case DECODER_DUMP:
+	{
+		adv7180_write(client, 1, 0x88);
+	}
+	break;
+
+	default:
+		return -EINVAL;
+	}
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+/*
+ * Generic i2c probe
+ * concerning the addresses: i2c wants 7 bit (without the r/w bit), so '>>1'
+ */
+static unsigned short normal_i2c[] = {
+	0x40 >> 1, 0x41 >> 1,
+	I2C_ADV7180 >> 1, 0x43 >> 1,
+	I2C_CLIENT_END
+};
+
+I2C_CLIENT_INSMOD;
+
+static int adv7180_detect(struct i2c_client *client, int kind,
+			  struct i2c_board_info *info)
+{
+	struct i2c_adapter *adapter = client->adapter;
+
+	if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE
+				     | I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
+		return -ENODEV;
+
+	/* Is chip alive ? */
+	if (adv7180_read(client, 0x11) != 0x1b)
+		return -ENODEV;
+
+	strlcpy(info->type, DRIVER_NAME, I2C_NAME_SIZE);
+
+	return 0;
+}
+
+static int adv7180_probe(struct i2c_client *client,
+			const struct i2c_device_id *id)
+{
+	int err = 0;
+	struct adv7180 *decoder;
+
+	printk(KERN_INFO DRIVER_NAME" chip found @ 0x%x (%s)\n",
+		client->addr << 1, client->adapter->name);
+
+	decoder = kzalloc(sizeof(struct adv7180), GFP_KERNEL);
+	if (decoder == NULL)
+		return -ENOMEM;
+
+	decoder->norm = VIDEO_MODE_PAL | VIDEO_MODE_NTSC |
+			VIDEO_MODE_SECAM |
+			VIDEO_MODE_AUTO;
+	decoder->input = CVBS;
+	decoder->enable = 1;
+	decoder->client = client;
+	i2c_set_clientdata(client, decoder);
+#ifdef CONFIG_MFD_TIMBERDALE
+	err = request_irq(client->irq, adv7180_irq, 0,
+				client->dev.driver->name, decoder);
+	if (err < 0) {
+		dev_err(&client->dev, "irq %d busy?\n", client->irq);
+		goto err_free_dec;
+	}
+	dev_info(&client->dev, "registered with irq (%d)\n", client->irq);
+#endif
+	adv7180_command(client, DECODER_INIT, NULL); /* Reset */
+
+	return 0;
+#ifdef CONFIG_MFD_TIMBERDALE
+err_free_dec:
+	kfree(decoder);
+
+	return err;
+#endif
+}
+
+static int adv7180_remove(struct i2c_client *client)
+{
+	struct adv7180 *decoder = i2c_get_clientdata(client);
+#ifdef CONFIG_MFD_TIMBERDALE
+	free_irq(client->irq, decoder);
+#endif
+	kfree(decoder);
+	return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+static const struct i2c_device_id adv7180_id[] = {
+	{ DRIVER_NAME, 0 },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, adv7180_id);
+
+static struct i2c_driver i2c_driver_adv7180 = {
+	.driver = {
+		.owner = THIS_MODULE,
+		.name = DRIVER_NAME,
+		.bus = &i2c_bus_type,
+	},
+
+	.id_table = adv7180_id,
+	.probe = adv7180_probe,
+	.remove = adv7180_remove,
+
+	.class = 0xffffffff,
+	.detect = adv7180_detect,
+	.address_data	= &addr_data,
+
+	.command = adv7180_command,
+};
+
+static int __init adv7180_init(void)
+{
+	return i2c_add_driver(&i2c_driver_adv7180);
+}
+
+static void __exit adv7180_exit(void)
+{
+	i2c_del_driver(&i2c_driver_adv7180);
+}
+
+module_init(adv7180_init);
+module_exit(adv7180_exit);
diff -uNr linux-2.6.29-clean/drivers/media/video/Kconfig linux-2.6.29/drivers/media/video/Kconfig
--- linux-2.6.29-clean/drivers/media/video/Kconfig	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/media/video/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -251,6 +251,15 @@
 
 comment "Video decoders"
 
+config VIDEO_ADV7180
+	tristate "Analog Devices ADV7180 decoder"
+	depends on VIDEO_V4L1 && I2C
+	---help---
+	  Support for the Analog Devices ADV7180 video decoder.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called adv7180.
+
 config VIDEO_BT819
 	tristate "BT819A VideoStream decoder"
 	depends on VIDEO_V4L1 && I2C
@@ -800,6 +809,12 @@
 	---help---
 	  This is a v4l2 driver for the TI OMAP2 camera capture interface
 
+config VIDEO_TIMBERDALE
+	tristate "Support for timberdale Video In/LogiWIN"
+	depends on VIDEO_V4L2 && MFD_TIMBERDALE_DMA
+	---help---
+	Add support for the Video In peripherial of the timberdale FPGA.
+
 #
 # USB Multimedia device configuration
 #
diff -uNr linux-2.6.29-clean/drivers/media/video/Makefile linux-2.6.29/drivers/media/video/Makefile
--- linux-2.6.29-clean/drivers/media/video/Makefile	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/media/video/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -52,6 +52,7 @@
 obj-$(CONFIG_VIDEO_SAA7191) += saa7191.o
 obj-$(CONFIG_VIDEO_ADV7170) += adv7170.o
 obj-$(CONFIG_VIDEO_ADV7175) += adv7175.o
+obj-$(CONFIG_VIDEO_ADV7180) += adv7180.o
 obj-$(CONFIG_VIDEO_VPX3220) += vpx3220.o
 obj-$(CONFIG_VIDEO_BT819) += bt819.o
 obj-$(CONFIG_VIDEO_BT856) += bt856.o
@@ -148,6 +149,8 @@
 
 obj-$(CONFIG_VIDEO_AU0828) += au0828/
 
+obj-$(CONFIG_VIDEO_TIMBERDALE)	+= timblogiw.o
+
 obj-$(CONFIG_USB_VIDEO_CLASS)	+= uvc/
 
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
diff -uNr linux-2.6.29-clean/drivers/media/video/timblogiw.c linux-2.6.29/drivers/media/video/timblogiw.c
--- linux-2.6.29-clean/drivers/media/video/timblogiw.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/media/video/timblogiw.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,930 @@
+/*
+ * timblogiw.c timberdale FPGA LogiWin Video In driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA LogiWin Video In
+ */
+
+#include <linux/list.h>
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/dma-mapping.h>
+#include <media/v4l2-common.h>
+#include <media/v4l2-ioctl.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include "timblogiw.h"
+#include <linux/mfd/timbdma.h>
+
+
+#define TIMBLOGIW_CTRL 0x40
+
+#define TIMBLOGIW_H_SCALE 0x20
+#define TIMBLOGIW_V_SCALE 0x28
+
+#define TIMBLOGIW_X_CROP 0x58
+#define TIMBLOGIW_Y_CROP 0x60
+
+#define TIMBLOGIW_W_CROP 0x00
+#define TIMBLOGIW_H_CROP 0x08
+
+#define TIMBLOGIW_VERSION_CODE 0x02
+
+#define TIMBLOGIW_FRAME		0x10
+#define TIMBLOGIW_DROP		0x20
+
+#define TIMBLOGIW_BUF	0x04
+#define TIMBLOGIW_TBI	0x2c
+#define TIMBLOGIW_BPL	0x30
+
+#define dbg(...)
+
+const struct timblogiw_tvnorm timblogiw_tvnorms[] = {
+	{
+		.v4l2_id		= V4L2_STD_PAL,
+		.name			= "PAL",
+		.swidth			= 720,
+		.sheight		= 576
+	},
+	{
+		.v4l2_id		= V4L2_STD_NTSC_M,
+		.name			= "NTSC",
+		.swidth			= 720,
+		.sheight		= 480
+	}
+};
+
+static void timblogiw_handleframe(unsigned long arg)
+{
+	struct timblogiw_frame *f;
+	struct timblogiw *lw = (struct timblogiw *)arg;
+
+	spin_lock_bh(&lw->queue_lock);
+	if (!list_empty(&lw->inqueue)) {
+		/* put the entry in the outqueue */
+		f = list_entry(lw->inqueue.next, struct timblogiw_frame, frame);
+
+		/* copy data from the DMA buffer */
+		memcpy(f->bufmem, lw->dma.filled->buf, f->buf.length);
+		/* buffer consumed */
+		lw->dma.filled = NULL;
+
+		do_gettimeofday(&f->buf.timestamp);
+		f->buf.sequence = ++lw->frame_count;
+		f->buf.field = V4L2_FIELD_NONE;
+		f->state = F_DONE;
+		f->buf.bytesused = lw->frame_size;
+		list_move_tail(&f->frame, &lw->outqueue);
+		/* wake up any waiter */
+		wake_up(&lw->wait_frame);
+	}
+	spin_unlock_bh(&lw->queue_lock);
+}
+
+static int timblogiw_isr(u32 flag, void *pdev)
+{
+	struct timblogiw *lw = (struct timblogiw *)pdev;
+
+	if (!lw->dma.filled) {
+		/* no stored transfer so far, store this, and flip to next */
+		lw->dma.filled = lw->dma.transfer + lw->dma.curr;
+		lw->dma.curr = !lw->dma.curr;
+	}
+
+	if (lw->stream == STREAM_ON)
+		timb_start_dma(DMA_IRQ_VIDEO_RX,
+			lw->dma.transfer[lw->dma.curr].handle, lw->frame_size,
+			lw->bytesperline);
+
+	if (flag & DMA_IRQ_VIDEO_DROP)
+		dbg("%s: frame dropped\n", __func__);
+	if (flag & DMA_IRQ_VIDEO_RX) {
+		dbg("%s: frame RX\n", __func__);
+		tasklet_schedule(&lw->tasklet);
+	}
+	return 0;
+}
+
+static void timblogiw_empty_framequeues(struct timblogiw *lw)
+{
+	u32 i;
+
+	dbg("%s\n", __func__);
+
+	INIT_LIST_HEAD(&lw->inqueue);
+	INIT_LIST_HEAD(&lw->outqueue);
+
+	for (i = 0; i < lw->num_frames; i++) {
+		lw->frame[i].state = F_UNUSED;
+		lw->frame[i].buf.bytesused = 0;
+	}
+}
+
+u32 timblogiw_request_buffers(struct timblogiw *lw, u32 count)
+{
+	/* needs to be page aligned cause the */
+	/* buffers can be mapped individually! */
+	const size_t imagesize = PAGE_ALIGN(lw->frame_size);
+	void *buff = NULL;
+	u32 i;
+
+	dbg("%s - request of %i buffers of size %zi\n",
+		__func__, count, lw->frame_size);
+
+	lw->dma.transfer[0].buf = pci_alloc_consistent(lw->dev, imagesize,
+		&lw->dma.transfer[0].handle);
+	lw->dma.transfer[1].buf = pci_alloc_consistent(lw->dev, imagesize,
+		&lw->dma.transfer[1].handle);
+	if ((lw->dma.transfer[0].buf == NULL) ||
+		(lw->dma.transfer[1].buf == NULL)) {
+		printk(KERN_ALERT "alloc failed\n");
+		if (lw->dma.transfer[0].buf != NULL)
+			pci_free_consistent(lw->dev, imagesize,
+				lw->dma.transfer[0].buf,
+				lw->dma.transfer[0].handle);
+		if (lw->dma.transfer[1].buf != NULL)
+			pci_free_consistent(lw->dev, imagesize,
+				lw->dma.transfer[1].buf,
+				lw->dma.transfer[1].handle);
+		return 0;
+	}
+
+	if (count > TIMBLOGIW_NUM_FRAMES)
+		count = TIMBLOGIW_NUM_FRAMES;
+
+	lw->num_frames = count;
+	while (lw->num_frames > 0) {
+		buff = vmalloc_32(lw->num_frames * imagesize);
+		if (buff) {
+			memset(buff, 0, lw->num_frames * imagesize);
+			break;
+		}
+		lw->num_frames--;
+	}
+
+	for (i = 0; i < lw->num_frames; i++) {
+		lw->frame[i].bufmem = buff + i * imagesize;
+		lw->frame[i].buf.index = i;
+		lw->frame[i].buf.m.offset = i * imagesize;
+		lw->frame[i].buf.length = lw->frame_size;
+		lw->frame[i].buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+		lw->frame[i].buf.sequence = 0;
+		lw->frame[i].buf.field = V4L2_FIELD_NONE;
+		lw->frame[i].buf.memory = V4L2_MEMORY_MMAP;
+		lw->frame[i].buf.flags = 0;
+	}
+
+	lw->dma.curr = 0;
+	lw->dma.filled = NULL;
+	return lw->num_frames;
+}
+
+void timblogiw_release_buffers(struct timblogiw *lw)
+{
+	dbg("%s\n", __func__);
+
+	if (lw->frame[0].bufmem != NULL) {
+		vfree(lw->frame[0].bufmem);
+		lw->frame[0].bufmem = NULL;
+		lw->num_frames = TIMBLOGIW_NUM_FRAMES;
+		pci_free_consistent(lw->dev, lw->frame_size,
+			lw->dma.transfer[0].buf, lw->dma.transfer[0].handle);
+		pci_free_consistent(lw->dev, lw->frame_size,
+			lw->dma.transfer[1].buf, lw->dma.transfer[1].handle);
+	}
+}
+
+/* IOCTL functions */
+
+static int timblogiw_g_fmt(struct timblogiw *lw, struct v4l2_format *format)
+{
+	dbg("%s -\n",  __func__);
+
+	if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		return -EINVAL;
+
+	format->fmt.pix.width = lw->width;
+	format->fmt.pix.height = lw->height;
+	format->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
+	format->fmt.pix.bytesperline = lw->bytesperline;
+	format->fmt.pix.sizeimage = lw->frame_size;
+	format->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
+	format->fmt.pix.field = V4L2_FIELD_NONE;
+	return 0;
+}
+
+static int timblogiw_s_fmt(struct timblogiw *lw, struct v4l2_format *format)
+{
+	struct v4l2_pix_format *pix = &format->fmt.pix;
+	dbg("%s - type: %d\n", __func__, format->type);
+
+	if (format->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		return -EINVAL;
+
+	if ((lw->height != pix->height) || (lw->width != lw->width))
+		return -EINVAL;
+
+	if (format->fmt.pix.field != V4L2_FIELD_NONE)
+		return -EINVAL;
+
+	dbg("%s - width=%d, height=%d, pixelformat=%d, field=%d\n"
+		"bytes per line %d, size image: %d, colorspace: %d\n",
+		__func__,
+		pix->width, pix->height, pix->pixelformat, pix->field,
+		pix->bytesperline, pix->sizeimage, pix->colorspace);
+
+	return 0;
+}
+
+static int timblogiw_querycap(struct timblogiw *lw,
+	struct v4l2_capability *cap)
+{
+	memset(cap, 0, sizeof(*cap));
+	strncpy(cap->card, "Timberdale Video", sizeof(cap->card)-1);
+	strncpy(cap->driver, "Timblogiw", sizeof(cap->card)-1);
+	cap->version = TIMBLOGIW_VERSION_CODE;
+	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
+		V4L2_CAP_STREAMING;
+
+	return 0;
+}
+
+static int timblogiw_enum_fmt(struct timblogiw *lw, struct v4l2_fmtdesc *fmt)
+{
+	dbg("%s - VIDIOC_ENUM_FMT\n", __func__);
+
+	if (fmt->index != 0)
+		return -EINVAL;
+	memset(fmt, 0, sizeof(*fmt));
+	fmt->index = 0;
+	fmt->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+	strncpy(fmt->description, "4:2:2, packed, YUYV",
+		sizeof(fmt->description)-1);
+	fmt->pixelformat = V4L2_PIX_FMT_YUYV;
+	memset(fmt->reserved, 0, sizeof(fmt->reserved));
+
+	return 0;
+}
+
+static int timblogiw_reqbufs(struct timblogiw *lw,
+	struct v4l2_requestbuffers *rb)
+{
+	if (rb->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+		rb->memory != V4L2_MEMORY_MMAP)
+		return -EINVAL;
+
+	timblogiw_empty_framequeues(lw);
+
+	timblogiw_release_buffers(lw);
+	if (rb->count)
+		rb->count = timblogiw_request_buffers(lw, rb->count);
+
+	dbg("%s - VIDIOC_REQBUFS: io method is mmap. num bufs %i\n",
+		__func__, rb->count);
+
+	return 0;
+}
+
+static int timblogiw_querybuf(struct timblogiw *lw, struct v4l2_buffer *b)
+{
+	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+		b->index >= lw->num_frames)
+		return -EINVAL;
+
+	memcpy(b, &lw->frame[b->index].buf, sizeof(*b));
+
+	if (lw->frame[b->index].vma_use_count)
+		b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+	if (lw->frame[b->index].state == F_DONE)
+		b->flags |= V4L2_BUF_FLAG_DONE;
+	else if (lw->frame[b->index].state != F_UNUSED)
+		b->flags |= V4L2_BUF_FLAG_QUEUED;
+
+	return 0;
+}
+
+static int timblogiw_qbuf(struct timblogiw *lw, struct v4l2_buffer *b)
+{
+	unsigned long lock_flags;
+
+	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
+		b->index >= lw->num_frames)
+		return -EINVAL;
+
+	if (lw->frame[b->index].state != F_UNUSED)
+		return -EAGAIN;
+
+	if (b->memory != V4L2_MEMORY_MMAP)
+		return -EINVAL;
+
+	lw->frame[b->index].state = F_QUEUED;
+
+	spin_lock_irqsave(&lw->queue_lock, lock_flags);
+	list_add_tail(&lw->frame[b->index].frame, &lw->inqueue);
+	spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+
+	return 0;
+}
+
+static int timblogiw_dqbuf(struct timblogiw *lw, struct file *file,
+	struct v4l2_buffer *b)
+{
+	struct timblogiw_frame *f;
+	unsigned long lock_flags;
+	int ret = 0;
+
+	if (b->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+		dbg("%s - VIDIOC_DQBUF, illegal buf type!\n",
+			__func__);
+		return -EINVAL;
+	}
+
+	if (list_empty(&lw->outqueue)) {
+		if (file->f_flags & O_NONBLOCK)
+			return -EAGAIN;
+
+		ret = wait_event_interruptible(lw->wait_frame,
+			!list_empty(&lw->outqueue));
+		if (ret)
+			return ret;
+	}
+
+	spin_lock_irqsave(&lw->queue_lock, lock_flags);
+	f = list_entry(lw->outqueue.next,
+			struct timblogiw_frame, frame);
+	list_del(lw->outqueue.next);
+	spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+
+	f->state = F_UNUSED;
+	memcpy(b, &f->buf, sizeof(*b));
+
+	if (f->vma_use_count)
+		b->flags |= V4L2_BUF_FLAG_MAPPED;
+
+	return 0;
+}
+
+static int timblogiw_enumstd(struct timblogiw *lw, struct v4l2_standard *std)
+{
+	if (std->index != 0)
+		return -EINVAL;
+
+	memset(std, 0, sizeof(*std));
+	std->index = 0;
+
+	std->id = V4L2_STD_PAL;
+	strncpy(std->name, "PAL", sizeof(std->name)-1);
+
+	return 0;
+}
+
+static int timblogiw_g_std(struct timblogiw *lw, v4l2_std_id *std)
+{
+	*std = V4L2_STD_PAL;
+	return 0;
+}
+
+static int timblogiw_s_std(struct timblogiw *lw, v4l2_std_id *std)
+{
+	if (!(*std & V4L2_STD_PAL))
+		return -EINVAL;
+	return 0;
+}
+
+static int timblogiw_enuminput(struct timblogiw *lw, struct v4l2_input *inp)
+{
+	if (inp->index != 0)
+		return -EINVAL;
+
+	memset(inp, 0, sizeof(*inp));
+	inp->index = 0;
+
+	strncpy(inp->name, "Timb input 1", sizeof(inp->name) - 1);
+	inp->type = V4L2_INPUT_TYPE_CAMERA;
+	inp->std = V4L2_STD_ALL;
+
+	return 0;
+}
+
+static int timblogiw_g_input(struct timblogiw *lw, int *input)
+{
+	*input = 0;
+
+	return 0;
+}
+
+static int timblogiw_s_input(struct timblogiw *lw, int *input)
+{
+	if (*input != 0)
+		return -EINVAL;
+	return 0;
+}
+
+static int timblogiw_streamon(struct timblogiw *lw, int *type)
+{
+	struct timblogiw_frame *f;
+
+	if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
+		dbg("%s - No capture device\n", __func__);
+		return -EINVAL;
+	}
+
+	if (list_empty(&lw->inqueue)) {
+		dbg("%s - inqueue is empty\n", __func__);
+		return -EINVAL;
+	}
+
+	if (lw->stream == STREAM_ON)
+		return 0;
+
+	lw->stream = STREAM_ON;
+
+	f = list_entry(lw->inqueue.next,
+		struct timblogiw_frame, frame);
+
+	dbg("%s - f size: %d, bpr: %d, dma addr: %x\n", __func__,
+		lw->frame_size, lw->bytesperline,
+		(unsigned int)lw->dma.transfer[lw->dma.curr].handle);
+	timb_start_dma(DMA_IRQ_VIDEO_RX,
+		lw->dma.transfer[lw->dma.curr].handle,
+		lw->frame_size, lw->bytesperline);
+
+	return 0;
+}
+
+static int timblogiw_streamoff(struct timblogiw *lw, int *type)
+{
+	if (*type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		return -EINVAL;
+
+	if (lw->stream == STREAM_ON) {
+		unsigned long lock_flags;
+		spin_lock_irqsave(&lw->queue_lock, lock_flags);
+		timb_stop_dma(DMA_IRQ_VIDEO_RX);
+		lw->stream = STREAM_OFF;
+		spin_unlock_irqrestore(&lw->queue_lock, lock_flags);
+	}
+	timblogiw_empty_framequeues(lw);
+
+	return 0;
+}
+
+static int timblogiw_querystd(struct timblogiw *lw, v4l2_std_id *std)
+{
+	/* TODO: Ask encoder */
+	*std = V4L2_STD_PAL;
+	return 0;
+}
+
+static int timblogiw_enum_framsizes(struct timblogiw *lw,
+	struct v4l2_frmsizeenum *fsize)
+{
+	if ((fsize->index != 0) ||
+		(fsize->pixel_format != V4L2_PIX_FMT_YUYV))
+		return -EINVAL;
+
+	fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
+	fsize->discrete.width = lw->width;
+	fsize->discrete.height = lw->height;
+
+	return 0;
+}
+
+static int timblogiw_g_parm(struct timblogiw *lw, struct v4l2_streamparm *sp)
+{
+	if (sp->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
+		return -EINVAL;
+
+	sp->parm.capture.extendedmode = 0;
+	sp->parm.capture.readbuffers = lw->num_frames;
+	return 0;
+}
+
+/*******************************
+ * Device Operations functions *
+ *******************************/
+
+static int timblogiw_open(struct file *file)
+{
+	struct video_device *vdev = video_devdata(file);
+	struct timblogiw *lw = video_get_drvdata(vdev);
+
+	dbg("%s -\n", __func__);
+
+	mutex_init(&lw->fileop_lock);
+	spin_lock_init(&lw->queue_lock);
+	init_waitqueue_head(&lw->wait_frame);
+
+	mutex_lock(&lw->lock);
+
+	lw->width = 720; /* TODO: Should depend on tv norm */
+	lw->height = 576;
+	lw->frame_size = lw->width * lw->height * 2;
+	lw->bytesperline = lw->width * 2;
+
+	file->private_data = lw;
+	lw->stream = STREAM_OFF;
+	lw->num_frames = TIMBLOGIW_NUM_FRAMES;
+
+	timblogiw_empty_framequeues(lw);
+
+	timb_set_dma_interruptcb(DMA_IRQ_VIDEO_RX | DMA_IRQ_VIDEO_DROP,
+		timblogiw_isr, (void *)lw);
+
+	mutex_unlock(&lw->lock);
+
+	return 0;
+}
+
+static int timblogiw_close(struct file *file)
+{
+	struct timblogiw *lw = file->private_data;
+
+	dbg("%s - entry\n", __func__);
+
+	mutex_lock(&lw->lock);
+
+	timb_stop_dma(DMA_IRQ_VIDEO_RX);
+	timb_set_dma_interruptcb(DMA_IRQ_VIDEO_RX | DMA_IRQ_VIDEO_DROP, NULL,
+		NULL);
+	timblogiw_release_buffers(lw);
+
+	mutex_unlock(&lw->lock);
+	return 0;
+}
+
+static ssize_t timblogiw_read(struct file *file, char __user *data,
+	size_t count, loff_t *ppos)
+{
+	dbg("%s - read request\n", __func__);
+	return -EINVAL;
+}
+
+static void timblogiw_vm_open(struct vm_area_struct *vma)
+{
+	struct timblogiw_frame *f = vma->vm_private_data;
+	f->vma_use_count++;
+}
+
+static void timblogiw_vm_close(struct vm_area_struct *vma)
+{
+	struct timblogiw_frame *f = vma->vm_private_data;
+	f->vma_use_count--;
+}
+
+static struct vm_operations_struct timblogiw_vm_ops = {
+	.open = timblogiw_vm_open,
+	.close = timblogiw_vm_close,
+};
+
+static int timblogiw_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+	unsigned long size = vma->vm_end - vma->vm_start, start = vma->vm_start;
+	void *pos;
+	u32 i;
+	int ret = -EINVAL;
+
+	struct timblogiw *lw = filp->private_data;
+	dbg("%s\n", __func__);
+
+	if (mutex_lock_interruptible(&lw->fileop_lock))
+		return -ERESTARTSYS;
+
+	if (!(vma->vm_flags & VM_WRITE) ||
+		size != PAGE_ALIGN(lw->frame[0].buf.length))
+		goto error_unlock;
+
+	for (i = 0; i < lw->num_frames; i++)
+		if ((lw->frame[i].buf.m.offset >> PAGE_SHIFT) == vma->vm_pgoff)
+			break;
+
+	if (i == lw->num_frames) {
+		dbg("%s - user supplied mapping address is out of range\n",
+			__func__);
+		goto error_unlock;
+	}
+
+	vma->vm_flags |= VM_IO;
+	vma->vm_flags |= VM_RESERVED;	/* Do not swap out this VMA */
+
+	pos = lw->frame[i].bufmem;
+	while (size > 0) {		/* size is page-aligned */
+		if (vm_insert_page(vma, start, vmalloc_to_page(pos))) {
+			dbg("%s - vm_insert_page failed\n", __func__);
+			ret = -EAGAIN;
+			goto error_unlock;
+		}
+		start += PAGE_SIZE;
+		pos += PAGE_SIZE;
+		size -= PAGE_SIZE;
+	}
+
+	vma->vm_ops = &timblogiw_vm_ops;
+	vma->vm_private_data = &lw->frame[i];
+	timblogiw_vm_open(vma);
+	ret = 0;
+
+error_unlock:
+	mutex_unlock(&lw->fileop_lock);
+	return ret;
+}
+
+static long
+timblogiw_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	struct timblogiw *lw = file->private_data;
+
+	switch (cmd) {
+
+	case VIDIOC_QUERYCAP:
+	{
+		dbg("%s - VIDIOC_QUERYCAP\n", __func__);
+		return timblogiw_querycap(lw, (struct v4l2_capability *)arg);
+	}
+
+	case VIDIOC_ENUM_FMT:
+	{
+		dbg("%s - VIDIOC_ENUM_FMT\n", __func__);
+		return timblogiw_enum_fmt(lw, (struct v4l2_fmtdesc *)arg);
+	}
+
+	case VIDIOC_G_FMT:
+	{
+		dbg("%s - VIDIOC_G_FMT\n", __func__);
+		return timblogiw_g_fmt(lw, (struct v4l2_format *) arg);
+	}
+
+	case VIDIOC_TRY_FMT:
+	case VIDIOC_S_FMT:
+	{
+		dbg("%s - VIDIOC_S_FMT\n", __func__);
+		return timblogiw_s_fmt(lw, (struct v4l2_format *)arg);
+	}
+
+	case VIDIOC_REQBUFS:
+	{
+		dbg("%s - VIDIOC_REQBUFS\n", __func__);
+		return timblogiw_reqbufs(lw, (struct v4l2_requestbuffers *)arg);
+	}
+
+	case VIDIOC_QUERYBUF:
+	{
+		dbg("%s - VIDIOC_QUERYBUF\n", __func__);
+		return timblogiw_querybuf(lw, (struct v4l2_buffer *)arg);
+	}
+
+	case VIDIOC_QBUF:
+	{
+		return timblogiw_qbuf(lw, (struct v4l2_buffer *)arg);
+	}
+
+	case VIDIOC_DQBUF:
+	{
+		return timblogiw_dqbuf(lw, file, (struct v4l2_buffer *)arg);
+	}
+
+	case VIDIOC_ENUMSTD:
+	{
+		dbg("%s - VIDIOC_ENUMSTD\n", __func__);
+		return timblogiw_enumstd(lw, (struct v4l2_standard *)arg);
+	}
+
+	case VIDIOC_G_STD:
+	{
+		dbg("%s - VIDIOC_G_STD\n", __func__);
+		return timblogiw_g_std(lw, (v4l2_std_id *)arg);
+	}
+
+	case VIDIOC_S_STD:
+	{
+		dbg("%s - VIDIOC_S_STD\n", __func__);
+		return timblogiw_s_std(lw, (v4l2_std_id *)arg);
+	}
+
+	case VIDIOC_ENUMINPUT:
+	{
+		dbg("%s - VIDIOC_ENUMINPUT\n", __func__);
+		return timblogiw_enuminput(lw, (struct v4l2_input *)arg);
+	}
+
+	case VIDIOC_G_INPUT:
+	{
+		dbg("%s - VIDIOC_G_INPUT\n", __func__);
+		return timblogiw_g_input(lw, (int *)arg);
+	}
+
+	case VIDIOC_S_INPUT:
+	{
+		dbg("%s - VIDIOC_S_INPUT\n", __func__);
+		return timblogiw_s_input(lw, (int *)arg);
+	}
+
+	case VIDIOC_STREAMON:
+	{
+		dbg("%s - VIDIOC_STREAMON\n", __func__);
+		return timblogiw_streamon(lw, (int *)arg);
+	}
+
+	case VIDIOC_STREAMOFF:
+	{
+		dbg("%s - VIDIOC_STREAMOFF\n", __func__);
+		return timblogiw_streamoff(lw, (int *)arg);
+	}
+
+	case VIDIOC_QUERYSTD:
+	{
+		dbg("%s - VIDIOC_QUERYSTD\n", __func__);
+		return timblogiw_querystd(lw, (v4l2_std_id *)arg);
+	}
+
+	case VIDIOC_ENUM_FRAMESIZES:
+	{
+		dbg("%s - VIDIOC_ENUM_FRAMESIZES\n", __func__);
+		return timblogiw_enum_framsizes(lw,
+			(struct v4l2_frmsizeenum *)arg);
+	}
+
+	case VIDIOC_G_PARM:
+	{
+		dbg("%s - VIDIOC_G_PARM\n", __func__);
+		return timblogiw_g_parm(lw, (struct v4l2_streamparm *)arg);
+	}
+
+	default:
+	{
+		dbg("%s Unknown command, dir: %x, type: %x, nr: %x, size: %x\n",
+			__func__,
+			_IOC_DIR(cmd),
+			_IOC_TYPE(cmd),
+			_IOC_NR(cmd),
+			_IOC_SIZE(cmd));
+		break;
+	}
+	}
+
+	return -EINVAL;
+}
+
+void timblogiw_vdev_release(struct video_device *vdev)
+{
+	kfree(vdev);
+}
+
+static const struct v4l2_file_operations timblogiw_fops = {
+	.owner		= THIS_MODULE,
+	.open	 	= timblogiw_open,
+	.release	= timblogiw_close,
+	.ioctl		= timblogiw_ioctl,
+	.mmap		= timblogiw_mmap,
+	.read		= timblogiw_read,
+};
+
+static const struct video_device timblogiw_template = {
+	.name		= TIMBLOGIWIN_NAME,
+	.fops		= &timblogiw_fops,
+	.release	= &timblogiw_vdev_release,
+	.minor		= -1
+};
+
+static int timblogiw_probe(struct platform_device *dev)
+{
+	int err;
+	struct timblogiw *lw;
+	struct resource *iomem;
+
+	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (!iomem) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	lw = kzalloc(sizeof(*lw), GFP_KERNEL);
+	if (!lw) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	/* find the PCI device from the parent... */
+	if (!dev->dev.parent) {
+		printk(KERN_ERR "timblogwi: No parent device found??\n");
+		err = -ENODEV;
+		goto err_mem;
+	}
+
+	lw->dev = container_of(dev->dev.parent, struct pci_dev, dev);
+
+	mutex_init(&lw->lock);
+
+	lw->video_dev = video_device_alloc();
+	if (!lw->video_dev) {
+		err = -ENOMEM;
+		goto err_video_req;
+	}
+	*lw->video_dev = timblogiw_template;
+
+	err = video_register_device(lw->video_dev, VFL_TYPE_GRABBER, 0);
+	if (err) {
+		video_device_release(lw->video_dev);
+		printk(KERN_ALERT "Error reg video\n");
+		goto err_video_req;
+	}
+
+	tasklet_init(&lw->tasklet, timblogiw_handleframe, (unsigned long)lw);
+
+	if (!request_mem_region(iomem->start, resource_size(iomem),
+		"timb-video")) {
+		err = -EBUSY;
+		goto err_request;
+	}
+
+	lw->membase = ioremap(iomem->start, resource_size(iomem));
+	if (!lw->membase) {
+		err = -ENOMEM;
+		goto err_ioremap;
+	}
+
+	platform_set_drvdata(dev, lw);
+	video_set_drvdata(lw->video_dev, lw);
+
+	return 0;
+
+err_ioremap:
+	release_mem_region(iomem->start, resource_size(iomem));
+err_request:
+	if (-1 != lw->video_dev->minor)
+		video_unregister_device(lw->video_dev);
+	else
+		video_device_release(lw->video_dev);
+err_video_req:
+	kfree(lw);
+err_mem:
+	printk(KERN_ERR
+		"timberdale: Failed to register Timberdale Video In: %d\n",
+		err);
+
+	return err;
+}
+
+static int timblogiw_remove(struct platform_device *dev)
+{
+	struct timblogiw *lw = platform_get_drvdata(dev);
+	struct resource *iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+	if (-1 != lw->video_dev->minor)
+		video_unregister_device(lw->video_dev);
+	else
+		video_device_release(lw->video_dev);
+
+	tasklet_kill(&lw->tasklet);
+	iounmap(lw->membase);
+	release_mem_region(iomem->start, resource_size(iomem));
+	kfree(lw);
+
+	return 0;
+}
+
+static struct platform_driver timblogiw_platform_driver = {
+	.driver = {
+		.name	= "timb-video",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= timblogiw_probe,
+	.remove		= timblogiw_remove,
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timblogiw_init(void)
+{
+	return platform_driver_register(&timblogiw_platform_driver);
+}
+
+static void __exit timblogiw_exit(void)
+{
+	platform_driver_unregister(&timblogiw_platform_driver);
+}
+
+module_init(timblogiw_init);
+module_exit(timblogiw_exit);
+
+MODULE_DESCRIPTION("Timberdale Video In driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:timb-video");
+
diff -uNr linux-2.6.29-clean/drivers/media/video/timblogiw.h linux-2.6.29/drivers/media/video/timblogiw.h
--- linux-2.6.29-clean/drivers/media/video/timblogiw.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/media/video/timblogiw.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,95 @@
+/*
+ * timblogiw.h timberdale FPGA LogiWin Video In driver defines
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA LogiWin Video In
+ */
+
+#ifndef _TIMBLOGIW_H
+#define _TIMBLOGIW_H
+
+#include <linux/interrupt.h>
+
+#define TIMBLOGIWIN_NAME    "Timberdale Video-In"
+
+#define TIMBLOGIW_NUM_FRAMES	10
+
+
+enum timblogiw_stream_state {
+	STREAM_OFF,
+	STREAM_ON,
+};
+
+enum timblogiw_frame_state {
+	F_UNUSED = 0,
+	F_QUEUED,
+	F_GRABBING,
+	F_DONE,
+	F_ERROR,
+};
+
+struct timblogiw_frame {
+	void				*bufmem;
+	struct v4l2_buffer		buf;
+	enum timblogiw_frame_state	state;
+	struct list_head		frame;
+	unsigned long			vma_use_count;
+};
+
+struct timblogiw_tvnorm {
+	int     v4l2_id;
+	char    *name;
+	u16     swidth;
+	u16     sheight;
+};
+
+
+struct timbdma_transfer {
+	dma_addr_t	handle;
+	void		*buf;
+};
+
+struct timbdma_control {
+	struct timbdma_transfer	transfer[2];
+	struct timbdma_transfer *filled;
+	int curr;
+};
+
+struct timblogiw {
+	struct i2c_client		*decoder;
+	struct timblogiw_frame		frame[TIMBLOGIW_NUM_FRAMES];
+	int				num_frames;
+	unsigned int			frame_count;
+	struct list_head		inqueue, outqueue;
+	spinlock_t			queue_lock; /* mutual exclusion */
+	enum timblogiw_stream_state	stream;
+	struct video_device		*video_dev;
+	struct mutex			lock, fileop_lock;
+	wait_queue_head_t		wait_frame;
+	int				width;
+	int				height;
+	u32				frame_size;
+	int				bytesperline;
+	struct pci_dev			*dev;
+	struct timbdma_control		dma;
+	void __iomem			*membase;
+	struct tasklet_struct		tasklet;
+};
+
+#endif /* _TIMBLOGIW_H */
+
diff -uNr linux-2.6.29-clean/drivers/mfd/Kconfig linux-2.6.29/drivers/mfd/Kconfig
--- linux-2.6.29-clean/drivers/mfd/Kconfig	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/mfd/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -240,6 +240,27 @@
 	 Say yes here if you want to include support GPIO for pins on
 	 the PCF50633 chip.
 
+config MFD_TIMBERDALE
+	bool "Support for Timberdale"
+	select MFD_CORE
+	---help---
+	This is the core driver for the timberdale FPGA. This device is a
+	multifunctioanl device which may provide numerous interfaces.
+
+config MFD_TIMBERDALE_DMA
+	tristate "Support for timberdale DMA"
+	depends on MFD_TIMBERDALE
+	---help---
+	Add support the DMA block inside the timberdale FPGA. This to be able
+	to do DMA transfers directly to some of the blocks inside the FPGA
+
+config MFD_TIMBERDALE_I2S
+	tristate "Support for timberdale I2S bus"
+	depends on MFD_TIMBERDALE
+	---help---
+	Add support for the I2S bus handled by timberdale FPGA.
+	I2S RX and TX instances are then available for other devices to make use of.
+
 endmenu
 
 menu "Multimedia Capabilities Port drivers"
diff -uNr linux-2.6.29-clean/drivers/mfd/Makefile linux-2.6.29/drivers/mfd/Makefile
--- linux-2.6.29-clean/drivers/mfd/Makefile	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/mfd/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -40,4 +40,8 @@
 
 obj-$(CONFIG_MFD_PCF50633)	+= pcf50633-core.o
 obj-$(CONFIG_PCF50633_ADC)	+= pcf50633-adc.o
-obj-$(CONFIG_PCF50633_GPIO)	+= pcf50633-gpio.o
\ No newline at end of file
+obj-$(CONFIG_PCF50633_GPIO)	+= pcf50633-gpio.o
+
+obj-$(CONFIG_MFD_TIMBERDALE)		+= timberdale.o
+obj-$(CONFIG_MFD_TIMBERDALE_DMA)	+= timbdma.o
+obj-$(CONFIG_MFD_TIMBERDALE_I2S)	+= timbi2s.o
diff -uNr linux-2.6.29-clean/drivers/mfd/timbdma.c linux-2.6.29/drivers/mfd/timbdma.c
--- linux-2.6.29-clean/drivers/mfd/timbdma.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/mfd/timbdma.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,301 @@
+/*
+ * timbdma.c timberdale FPGA DMA driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA DMA engine
+ */
+
+#include <linux/version.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+
+#include <linux/mfd/timbdma.h>
+
+static struct timbdma_dev *self_g;
+
+static irqreturn_t timbdma_handleinterrupt(int irq, void *devid)
+{
+	struct timbdma_dev *dev = (struct timbdma_dev *)devid;
+	int ipr;
+	int i;
+
+	ipr = ioread32(dev->membase + timbdma_ctrlmap_TIMBPEND);
+
+	/* ack */
+	iowrite32(ipr, dev->membase + timbdma_ctrlmap_TIMBSTATUS);
+
+	/* call the callbacks */
+	for (i = 0; i < DMA_IRQS; i++) {
+		int mask = 1 << i;
+		if ((ipr & mask) && dev->callbacks[i])
+			dev->callbacks[i](mask, dev->callback_data[i]);
+	}
+
+	if (ipr)
+		return IRQ_HANDLED;
+	else
+		return IRQ_NONE;
+}
+
+
+void timb_start_dma(u32 flag, unsigned long buf, int len, int bytes_per_row)
+{
+	int i;
+	unsigned long irqflags;
+	struct timbdma_dev *dev = self_g;
+
+	spin_lock_irqsave(&dev->lock, irqflags);
+
+	/* now enable the DMA transfer */
+	for (i = 0; i < DMA_IRQS; i++)
+		if (flag & (1 << i)) {
+			u32 offset = i / 2 * 0x40;
+
+			if (!(i % 2)) {
+				/* RX */
+				/* bytes per row */
+				iowrite32(bytes_per_row, dev->membase + offset +
+					timbdma_dmacfg_BPERROW);
+				/* address high */
+				iowrite32(0, dev->membase + offset +
+					timbdma_dmacfg_RXSTARTH);
+				/* address low */
+				iowrite32(buf, dev->membase + offset +
+					timbdma_dmacfg_RXSTARTL);
+				/* Length */
+				iowrite32(len, dev->membase + offset +
+					timbdma_dmacfg_RXLENGTH);
+				/* Clear rx sw read pointer */
+				iowrite32(0, dev->membase + offset +
+					timbdma_dmacfg_RXSWRP);
+				/* enable the transfer */
+				iowrite32(1, dev->membase + offset +
+					timbdma_dmacfg_RXENABLE);
+			} else {
+				/* TX */
+				/* address high */
+				iowrite32(0, dev->membase + offset +
+					timbdma_dmacfg_TXSTARTH);
+				/* address low */
+				iowrite32(buf, dev->membase + offset +
+					timbdma_dmacfg_TXSTARTL);
+				/* Length */
+				iowrite32(len, dev->membase + offset +
+					timbdma_dmacfg_TXLENGTH);
+				/* Set tx sw write pointer */
+				iowrite32(len, dev->membase + offset +
+					timbdma_dmacfg_TXSWWP);
+			}
+
+			/* only allow one bit in the flag field */
+			break;
+		}
+	spin_unlock_irqrestore(&dev->lock, irqflags);
+}
+EXPORT_SYMBOL(timb_start_dma);
+
+void *timb_stop_dma(u32 flags)
+{
+	int i;
+	unsigned long irqflags;
+	struct timbdma_dev *dev = self_g;
+	void *result = 0;
+
+	spin_lock_irqsave(&dev->lock, irqflags);
+
+	/* now disable the DMA transfers */
+	for (i = 0; i < DMA_IRQS; i++)
+		if (flags & (1 << i)) {
+			/*
+				RX enable registers are located at:
+				0x14
+				0x54
+				0x94
+
+				TX SW pointer registers are located at:
+				0x24
+				0x64
+			*/
+			u32 offset = i / 2 * 0x40;
+			u32 result_offset = offset;
+			if (!(i % 2)) {
+				/* even -> RX enable */
+				offset += timbdma_dmacfg_RXENABLE;
+				result_offset += timbdma_dmacfg_RXFPGAWP;
+			} else {
+				/* odd -> TX SW pointer reg */
+				offset += timbdma_dmacfg_TXSWWP;
+				result_offset = timbdma_dmacfg_TXFPGARP;
+			}
+
+			iowrite32(0, dev->membase + offset);
+			/* check how far the FPGA has written/read */
+			result = (void *)ioread32(dev->membase + result_offset);
+		}
+
+	/* ack any pending IRQs */
+	iowrite32(flags, dev->membase + timbdma_ctrlmap_TIMBSTATUS);
+
+	spin_unlock_irqrestore(&dev->lock, irqflags);
+
+	return result;
+}
+EXPORT_SYMBOL(timb_stop_dma);
+
+void timb_set_dma_interruptcb(u32 flags, timbdma_interruptcb icb, void *data)
+{
+	int i;
+	unsigned long irqflags;
+	struct timbdma_dev *dev = self_g;
+	u32 ier;
+
+	spin_lock_irqsave(&dev->lock, irqflags);
+
+	for (i = 0; i < DMA_IRQS; i++)
+		if (flags & (1 << i)) {
+			dev->callbacks[i] = icb;
+			dev->callback_data[i] = data;
+		}
+
+	/* Ack any pending IRQ */
+	iowrite32(flags, dev->membase + timbdma_ctrlmap_TIMBSTATUS);
+
+	/* if a null callback is given -> clear interrupt, else -> enable */
+	ier = ioread32(dev->membase + timbdma_ctrlmap_TIMBENABLE);
+	if (icb != NULL)
+		ier |= flags;
+	else
+		ier &= ~flags;
+	iowrite32(ier, dev->membase + timbdma_ctrlmap_TIMBENABLE);
+
+	spin_unlock_irqrestore(&dev->lock, irqflags);
+}
+EXPORT_SYMBOL(timb_set_dma_interruptcb);
+
+static int timbdma_probe(struct platform_device *dev)
+{
+	int err, irq;
+	struct timbdma_dev *self;
+	struct resource *iomem;
+
+	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (!iomem) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	self = kzalloc(sizeof(*self), GFP_KERNEL);
+	if (!self) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	spin_lock_init(&self->lock);
+
+	if (!request_mem_region(iomem->start,
+		resource_size(iomem), "timb-dma")) {
+		err = -EBUSY;
+		goto err_request;
+	}
+
+	self->membase = ioremap(iomem->start, resource_size(iomem));
+	if (!self->membase) {
+		printk(KERN_ERR "timbdma: Failed to remap I/O memory\n");
+		err = -ENOMEM;
+		goto err_ioremap;
+	}
+
+	/* register interrupt */
+	irq = platform_get_irq(dev, 0);
+	if (irq < 0) {
+		err = irq;
+		goto err_get_irq;
+	}
+
+	/* request IRQ */
+	err = request_irq(irq, timbdma_handleinterrupt, IRQF_SHARED,
+			  "timb-dma", self);
+	if (err) {
+		printk(KERN_ERR "timbdma: Failed to request IRQ\n");
+		goto err_get_irq;
+	}
+
+	platform_set_drvdata(dev, self);
+
+	/* assign the global pointer */
+	self_g = self;
+
+	return 0;
+
+err_get_irq:
+	iounmap(self->membase);
+err_ioremap:
+	release_mem_region(iomem->start, resource_size(iomem));
+err_request:
+	kfree(self);
+err_mem:
+	printk(KERN_ERR "timberdale: Failed to register Timberdale DMA: %d\n",
+		err);
+
+	return err;
+}
+
+static int timbdma_remove(struct platform_device *dev)
+{
+	struct timbdma_dev *self = platform_get_drvdata(dev);
+	struct resource *iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+	free_irq(platform_get_irq(dev, 0), self);
+	iounmap(self->membase);
+	release_mem_region(iomem->start, resource_size(iomem));
+	kfree(self);
+	self_g = NULL;
+	return 0;
+}
+
+static struct platform_driver timbdma_platform_driver = {
+	.driver = {
+		.name	= "timb-dma",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= timbdma_probe,
+	.remove		= timbdma_remove,
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timbdma_init(void)
+{
+	self_g = NULL;
+	return platform_driver_register(&timbdma_platform_driver);
+}
+
+static void __exit timbdma_exit(void)
+{
+	platform_driver_unregister(&timbdma_platform_driver);
+}
+
+module_init(timbdma_init);
+module_exit(timbdma_exit);
+
+MODULE_DESCRIPTION("Timberdale DMA driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:timb-dma");
+
diff -uNr linux-2.6.29-clean/drivers/mfd/timberdale.c linux-2.6.29/drivers/mfd/timberdale.c
--- linux-2.6.29-clean/drivers/mfd/timberdale.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/mfd/timberdale.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,599 @@
+/*
+ * timberdale.c timberdale FPGA mfd shim driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pci.h>
+#include <linux/msi.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/core.h>
+#include <linux/irq.h>
+
+#include <linux/i2c.h>
+#include <linux/i2c-ocores.h>
+#include <linux/i2c/tsc2007.h>
+#include <linux/spi/xilinx_spi.h>
+#include "timberdale.h"
+
+struct timberdale_device {
+	resource_size_t		intc_mapbase;
+	resource_size_t		ctl_mapbase;
+	unsigned char __iomem   *intc_membase;
+	unsigned char __iomem   *ctl_membase;
+	int			irq_base;
+	u32			irq_ack_mask;
+	/* locking from interrupts while modifiying registers */
+	spinlock_t		lock;
+};
+
+/*--------------------------------------------------------------------------*/
+
+struct tsc2007_platform_data timberdale_tsc2007_platform_data = {
+	.model = 2003,
+	.x_plate_ohms = 100
+};
+
+struct i2c_board_info timberdale_i2c_board_info[] = {
+	{
+		I2C_BOARD_INFO("tsc2003", 0x48),
+		.platform_data = &timberdale_tsc2007_platform_data,
+		.irq = IRQ_TIMBERDALE_TSC_INT
+	},
+	{
+		I2C_BOARD_INFO("adv7180", 0x42 >> 1),
+		.irq = IRQ_TIMBERDALE_ADV7180
+	}
+};
+
+static __devinitdata struct ocores_i2c_platform_data
+timberdale_i2c_platform_data = {
+	.regstep = 4,
+	.clock_khz = 62500,
+	.devices = timberdale_i2c_board_info,
+	.num_devices = ARRAY_SIZE(timberdale_i2c_board_info)
+};
+
+const static __devinitconst struct resource timberdale_i2c_resources[] = {
+	{
+		.start	= I2COFFSET,
+		.end	= I2CEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start 	= IRQ_TIMBERDALE_I2C,
+		.end	= IRQ_TIMBERDALE_I2C,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+static __devinitdata struct xspi_platform_data timberdale_xspi_platorm_data = {
+	.bus_num = -1,
+	/* according to spec. we can have up to 32 slaves however,
+	 * as of current(2009-03-06) revision of
+	 * Timberdale we can only handle 3 right now
+	 */
+	.num_chipselect = 3,
+	.speed_hz = 1953125, /* hardcoded value in IP, for now */
+	.cr_offset = 0x60,
+	.sr_offset = 0x64,
+	.txd_offset = 0x68,
+	.rxd_offset = 0x6c,
+	.ssr_offset = 0x70
+};
+
+const static __devinitconst struct resource timberdale_spi_resources[] = {
+	{
+		.start 	= SPIOFFSET,
+		.end	= SPIEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_SPI,
+		.end	= IRQ_TIMBERDALE_SPI,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+const static __devinitconst struct resource timberdale_eth_resources[] = {
+	{
+		.start	= ETHOFFSET,
+		.end	= ETHEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_ETHSW_IF,
+		.end	= IRQ_TIMBERDALE_ETHSW_IF,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+const static __devinitconst struct resource timberdale_gpio_resources[] = {
+	{
+		.start	= GPIOOFFSET,
+		.end	= GPIOEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_GPIO,
+		.end	= IRQ_TIMBERDALE_GPIO,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+
+const static __devinitconst struct resource timberdale_most_resources[] = {
+	{
+		.start	= MOSTOFFSET,
+		.end	= MOSTEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_MLB,
+		.end	= IRQ_TIMBERDALE_MLB,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+const static __devinitconst struct resource timberdale_uart_resources[] = {
+	{
+		.start	= UARTOFFSET,
+		.end	= UARTEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_UART,
+		.end	= IRQ_TIMBERDALE_UART,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+const static __devinitconst struct resource timberdale_i2s_resources[] = {
+	{
+		.start	= I2SOFFSET,
+		.end	= I2SEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_I2S,
+		.end	= IRQ_TIMBERDALE_I2S,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+const static __devinitconst struct resource timberdale_video_resources[] = {
+	{
+		.start	= LOGIWOFFSET,
+		.end	= LOGIWEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	/*
+	note that the "frame buffer" is located in DMA area
+	starting at 0x1200000
+	*/
+};
+
+const static __devinitconst struct resource timberdale_dma_resources[] = {
+	{
+		.start	= DMAOFFSET,
+		.end	= DMAEND,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_DMA,
+		.end	= IRQ_TIMBERDALE_DMA,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+static __devinitdata struct mfd_cell timberdale_cells_bar0[] = {
+	{
+		.name = "timb-uart",
+		.num_resources = ARRAY_SIZE(timberdale_uart_resources),
+		.resources = timberdale_uart_resources,
+	},
+	{
+		.name = "ocores-i2c",
+		.num_resources = ARRAY_SIZE(timberdale_i2c_resources),
+		.resources = timberdale_i2c_resources,
+		.platform_data = &timberdale_i2c_platform_data,
+		.data_size = sizeof(timberdale_i2c_platform_data),
+	},
+	{
+		.name = "timb-gpio",
+		.num_resources = ARRAY_SIZE(timberdale_gpio_resources),
+		.resources = timberdale_gpio_resources,
+	},
+	{
+		.name = "timb-i2s",
+		.num_resources = ARRAY_SIZE(timberdale_i2s_resources),
+		.resources = timberdale_i2s_resources,
+	},
+	{
+		.name = "timb-most",
+		.num_resources = ARRAY_SIZE(timberdale_most_resources),
+		.resources = timberdale_most_resources,
+	},
+	{
+		.name = "timb-video",
+		.num_resources = ARRAY_SIZE(timberdale_video_resources),
+		.resources = timberdale_video_resources,
+	},
+	{
+		.name = "xilinx_spi",
+		.num_resources = ARRAY_SIZE(timberdale_spi_resources),
+		.resources = timberdale_spi_resources,
+		.platform_data = &timberdale_xspi_platorm_data,
+		.data_size = sizeof(timberdale_xspi_platorm_data),
+	},
+	{
+		.name = "ks884x",
+		.num_resources = ARRAY_SIZE(timberdale_eth_resources),
+		.resources = timberdale_eth_resources,
+	},
+	{
+		.name = "timb-dma",
+		.num_resources = ARRAY_SIZE(timberdale_dma_resources),
+		.resources = timberdale_dma_resources,
+	},
+};
+
+static const __devinitconst struct resource timberdale_sdhc_resources_bar1[] = {
+	{
+		.start	= SDHC0OFFSET,
+		.end	= SDHC0END,
+		.flags	= IORESOURCE_MEM,
+	},
+	{
+		.start	= IRQ_TIMBERDALE_SDHC,
+		.end	= IRQ_TIMBERDALE_SDHC,
+		.flags	= IORESOURCE_IRQ,
+	},
+};
+
+static __devinitdata struct mfd_cell timberdale_cells_bar1[] = {
+	{
+		.name = "sdhci",
+		.num_resources = ARRAY_SIZE(timberdale_sdhc_resources_bar1),
+		.resources = timberdale_sdhc_resources_bar1,
+	},
+};
+
+/*--------------------------------------------------------------------------*/
+
+
+/* Handle the timberdale interrupt mux */
+static void timberdale_irq(unsigned int irq, struct irq_desc *desc)
+{
+	struct timberdale_device *priv = get_irq_data(irq);
+	unsigned int i, ipr;
+
+	desc->chip->ack(irq);
+
+	while ((ipr = ioread32(priv->intc_membase + IPR))) {
+		priv->irq_ack_mask = 0;
+		for (i = 0; i < TIMBERDALE_NR_IRQS; i++)
+			if (ipr & (1 << i))
+				generic_handle_irq(priv->irq_base + i);
+		if (priv->irq_ack_mask)
+			iowrite32(priv->irq_ack_mask, priv->intc_membase + IAR);
+	}
+}
+
+static void timberdale_irq_mask(unsigned int irq)
+{
+	struct timberdale_device *priv = get_irq_chip_data(irq);
+	unsigned long flags;
+
+	spin_lock_irqsave(&priv->lock, flags);
+	iowrite32(1 << (irq - priv->irq_base), priv->intc_membase + CIE);
+	spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static void timberdale_irq_unmask(unsigned int irq)
+{
+	struct timberdale_device *priv = get_irq_chip_data(irq);
+	unsigned long flags;
+
+	spin_lock_irqsave(&priv->lock, flags);
+	iowrite32(1 << (irq - priv->irq_base), priv->intc_membase + SIE);
+	spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static void timberdale_irq_ack(unsigned int irq)
+{
+	struct timberdale_device *priv = get_irq_chip_data(irq);
+	unsigned long flags;
+	u32 ack_mask = 1 << (irq - priv->irq_base);
+
+	spin_lock_irqsave(&priv->lock, flags);
+	/* if edge triggered, ack directly. Otherwhise ack in the end of
+	 * irq handler
+	 */
+	if (ack_mask & IRQ_TIMBERDALE_EDGE_MASK)
+		iowrite32(ack_mask, priv->intc_membase + IAR);
+	else
+		priv->irq_ack_mask |= ack_mask;
+	spin_unlock_irqrestore(&priv->lock, flags);
+}
+
+static struct irq_chip timberdale_chip = {
+	.name		= "timberdale",
+	.ack		= timberdale_irq_ack,
+	.mask		= timberdale_irq_mask,
+	.unmask		= timberdale_irq_unmask,
+	.disable	= timberdale_irq_mask,
+	.enable		= timberdale_irq_unmask,
+};
+
+/*--------------------------------------------------------------------------*/
+
+/* Install the IRQ handler */
+static void timberdale_attach_irq(struct pci_dev *dev)
+{
+	struct timberdale_device *priv = pci_get_drvdata(dev);
+	unsigned int irq, irq_base;
+
+	irq_base = priv->irq_base;
+	for (irq = irq_base; irq < irq_base + TIMBERDALE_NR_IRQS; irq++) {
+		set_irq_chip_and_handler_name(irq, &timberdale_chip,
+			handle_edge_irq, "mux");
+
+		set_irq_chip_data(irq, priv);
+
+#ifdef CONFIG_ARM
+		set_irq_flags(irq, IRQF_VALID | IRQF_PROBE);
+#endif
+	}
+
+	set_irq_data(dev->irq, priv);
+	set_irq_chained_handler(dev->irq, timberdale_irq);
+}
+
+static void timberdale_detach_irq(struct pci_dev *dev)
+{
+	struct timberdale_device *priv = pci_get_drvdata(dev);
+	unsigned int irq, irq_base;
+
+	irq_base = priv->irq_base;
+
+	set_irq_chained_handler(dev->irq, NULL);
+	set_irq_data(dev->irq, NULL);
+
+	for (irq = irq_base; irq < irq_base + TIMBERDALE_NR_IRQS; irq++) {
+#ifdef CONFIG_ARM
+		set_irq_flags(irq, 0);
+#endif
+		set_irq_chip(irq, NULL);
+		set_irq_chip_data(irq, NULL);
+	}
+}
+
+static int __devinit timb_probe(struct pci_dev *dev,
+	const struct pci_device_id *id)
+{
+	struct timberdale_device *priv;
+	int err, i;
+	u16 ver;
+	resource_size_t mapbase;
+
+	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+	if (!priv)
+		return -ENOMEM;
+
+	spin_lock_init(&priv->lock);
+	pci_set_drvdata(dev, priv);
+
+	err = pci_enable_device(dev);
+	if (err)
+		goto err_enable;
+
+	mapbase = pci_resource_start(dev, 0);
+	if (!mapbase) {
+		printk(KERN_ERR "timberdale: No resource\n");
+		goto err_start;
+	}
+
+	/* create a resource for the Interrupt controller registers */
+	priv->intc_mapbase = mapbase + INTCOFFSET;
+	if (!request_mem_region(priv->intc_mapbase, INTCSIZE, "timb-intc")) {
+		printk(KERN_ERR "timberdale: Failed to request intc mem\n");
+		goto err_request;
+	}
+
+	/* create a resource for the PCI master register */
+	priv->ctl_mapbase = mapbase + CHIPCTLOFFSET;
+	if (!request_mem_region(priv->ctl_mapbase, CHIPCTLSIZE, "timb-intc")) {
+		printk(KERN_ERR "timberdale: Failed to request ctl mem\n");
+		goto err_request_ctl;
+	}
+
+	priv->intc_membase = ioremap(priv->intc_mapbase, INTCSIZE);
+	if (!priv->intc_membase) {
+		printk(KERN_ALERT "timberdale: Map error, intc\n");
+		goto err_ioremap;
+	}
+
+	priv->ctl_membase = ioremap(priv->ctl_mapbase, CHIPCTLSIZE);
+	if (!priv->ctl_membase) {
+		printk(KERN_ALERT "timberdale: Map error, ctl\n");
+		goto err_ioremap_ctl;
+	}
+
+	err = pci_enable_msi(dev);
+	if (err) {
+		printk(KERN_WARNING "timberdale: MSI init failed: %d\n", err);
+		goto err_msi;
+	}
+
+	/* Reset all FPGA PLB peripherals */
+	iowrite32(0x1, priv->ctl_membase + MAYSVILLERST);
+
+	/* at this stage the FPGA does not generate a
+	 * unique interrupt per function, to emulate real interrupts
+	 * we assign them a faked interrupt which we issue in the
+	 * interrupt handler. For now just hard code a base number
+	 */
+	priv->irq_base = NR_IRQS - TIMBERDALE_NR_IRQS - 1;
+	if (priv->irq_base < dev->irq)
+		/* ops the device itself got the IRQ in the end... */
+		priv->irq_base = 400;
+
+	timberdale_attach_irq(dev);
+
+	/* update IRQ offsets in I2C board info */
+	for (i = 0; i < ARRAY_SIZE(timberdale_i2c_board_info); i++)
+		timberdale_i2c_board_info[i].irq += priv->irq_base;
+
+	/* don't leave platform_data empty on any device */
+	for (i = 0; i < ARRAY_SIZE(timberdale_cells_bar0); i++)
+		if (timberdale_cells_bar0[i].platform_data == NULL) {
+			timberdale_cells_bar0[i].platform_data =
+				timberdale_cells_bar0 + i;
+			timberdale_cells_bar0[i].data_size =
+				sizeof(timberdale_cells_bar0[i]);
+		}
+
+	err = mfd_add_devices(&dev->dev, -1,
+		timberdale_cells_bar0, ARRAY_SIZE(timberdale_cells_bar0),
+		&dev->resource[0], priv->irq_base);
+	if (err)
+		printk(KERN_WARNING
+			"timberdale: mfd_add_devices failed: %d\n", err);
+	else {
+		err = mfd_add_devices(&dev->dev, -1,
+			timberdale_cells_bar1,
+			ARRAY_SIZE(timberdale_cells_bar1),
+			&dev->resource[1], priv->irq_base);
+
+		if (err)
+			printk(KERN_WARNING
+				"timberdale: timb_add_sdhci failed: %d\n", err);
+	}
+
+	if (err)
+		goto err_mfd;
+
+	ver = ioread16(priv->ctl_membase + TIMB_REV);
+
+	printk(KERN_INFO "Found Maysville Card. Rev: %d\n", ver);
+
+	/* Enable interrupts and wire the hardware interrupts */
+	iowrite32(0x3, priv->intc_membase + MER);
+
+	return 0;
+err_mfd:
+	timberdale_detach_irq(dev);
+	pci_disable_msi(dev);
+err_msi:
+	iounmap(priv->ctl_membase);
+err_ioremap_ctl:
+	iounmap(priv->intc_membase);
+err_ioremap:
+	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
+err_request_ctl:
+	release_mem_region(priv->intc_mapbase, INTCSIZE);
+err_request:
+	pci_set_drvdata(dev, NULL);
+err_start:
+	pci_disable_device(dev);
+err_enable:
+	kfree(priv);
+	pci_set_drvdata(dev, NULL);
+	return -ENODEV;
+}
+
+static void __devexit timb_remove(struct pci_dev *dev)
+{
+	/* clean up any allocated resources and stuff here.
+	 * like call release_region();
+	 */
+	struct timberdale_device *priv;
+
+	priv = pci_get_drvdata(dev);
+
+	mfd_remove_devices(&dev->dev);
+
+	timberdale_detach_irq(dev);
+
+	iowrite32(0xffffffff, priv->intc_membase + IAR);
+	iowrite32(0, priv->intc_membase + MER);
+	iowrite32(0, priv->intc_membase + IER);
+
+	iounmap(priv->ctl_membase);
+	iounmap(priv->intc_membase);
+	release_mem_region(priv->ctl_mapbase, CHIPCTLSIZE);
+	release_mem_region(priv->intc_mapbase, INTCSIZE);
+
+	pci_disable_msi(dev);
+	pci_disable_device(dev);
+	pci_set_drvdata(dev, NULL);
+	kfree(priv);
+}
+
+static struct pci_device_id timberdale_pci_tbl[] = {
+	{ PCI_DEVICE(PCI_VENDOR_ID_TIMB, PCI_DEVICE_ID_TIMB) },
+	{ 0 }
+};
+MODULE_DEVICE_TABLE(pci, timberdale_pci_tbl);
+
+static struct pci_driver timberdale_pci_driver = {
+	.name = "timberdale",
+	.id_table = timberdale_pci_tbl,
+	.probe = timb_probe,
+	.remove = timb_remove,
+};
+
+static int __init timberdale_init(void)
+{
+	int err;
+
+	err = pci_register_driver(&timberdale_pci_driver);
+	if (err < 0) {
+		printk(KERN_ERR
+			"Failed to register PCI driver for %s device.\n",
+			timberdale_pci_driver.name);
+		return -ENODEV;
+	}
+
+	printk(KERN_INFO "Driver for %s has been successfully registered.\n",
+		timberdale_pci_driver.name);
+
+	return 0;
+}
+
+static void __exit timberdale_exit(void)
+{
+	pci_unregister_driver(&timberdale_pci_driver);
+
+	printk(KERN_INFO "Driver for %s has been successfully unregistered.\n",
+				timberdale_pci_driver.name);
+}
+
+MODULE_LICENSE("GPL v2");
+MODULE_VERSION(DRV_VERSION);
+MODULE_AUTHOR("Richard Rojfors");
+
+module_init(timberdale_init);
+module_exit(timberdale_exit);
+
diff -uNr linux-2.6.29-clean/drivers/mfd/timberdale.h linux-2.6.29/drivers/mfd/timberdale.h
--- linux-2.6.29-clean/drivers/mfd/timberdale.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/mfd/timberdale.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,114 @@
+/*
+ * timberdale.h timberdale FPGA mfd shim driver defines
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA
+ */
+
+#ifndef MFD_TIMBERDALE_H
+#define MFD_TIMBERDALE_H
+
+/* Registers of the interrupt controller */
+#define ISR		0x00
+#define IPR		0x04
+#define IER		0x08
+#define IAR		0x0c
+#define SIE		0x10
+#define CIE		0x14
+#define MER		0x1c
+
+/* Registers of the control area */
+#define TIMB_REV	0x00
+#define MAYSVILLERST	0x40
+
+
+#define I2COFFSET	0x0
+#define I2CEND		0x1f
+
+#define SPIOFFSET	0x80
+#define SPIEND		0xff
+
+#define ETHOFFSET	0x300
+#define ETHEND		0x30f
+
+#define GPIOOFFSET	0x400
+#define GPIOEND		0x7ff
+
+#define CHIPCTLOFFSET	0x800
+#define CHIPCTLEND	0x8ff
+#define CHIPCTLSIZE	(CHIPCTLEND - CHIPCTLOFFSET)
+
+#define INTCOFFSET	0xc00
+#define INTCEND		0xfff
+#define INTCSIZE	(INTCEND - INTCOFFSET)
+
+#define MOSTOFFSET	0x1000
+#define MOSTEND		0x13ff
+
+#define UARTOFFSET	0x1400
+#define UARTEND		0x17ff
+
+#define I2SOFFSET	0x1C00
+#define I2SEND		0x1fff
+
+#define LOGIWOFFSET	0x30000
+#define LOGIWEND	0x37fff
+
+#define DMAOFFSET	0x01000000
+#define DMAEND		0x013fffff
+
+/* SDHC0 is placed in PCI bar 1 */
+#define SDHC0OFFSET	0x00
+#define SDHC0END	0xff
+
+/* SDHC1 is placed in PCI bar 2 */
+#define SDHC1OFFSET	0x00
+#define SDHC1END	0xff
+
+#define PCI_VENDOR_ID_TIMB	0x10ee
+#define PCI_DEVICE_ID_TIMB	0xa123
+#define DRV_VERSION		"0.1"
+
+
+#define IRQ_TIMBERDALE_INIC	0
+#define IRQ_TIMBERDALE_MLB	1
+#define IRQ_TIMBERDALE_GPIO	2
+#define IRQ_TIMBERDALE_I2C	3
+#define IRQ_TIMBERDALE_UART	4
+#define IRQ_TIMBERDALE_DMA	5
+#define IRQ_TIMBERDALE_I2S	6
+#define IRQ_TIMBERDALE_TSC_INT	7
+#define IRQ_TIMBERDALE_SDHC	8
+#define IRQ_TIMBERDALE_ADV7180	9
+#define IRQ_TIMBERDALE_ETHSW_IF	10
+#define IRQ_TIMBERDALE_SPI	11
+
+#define TIMBERDALE_NR_IRQS	12
+
+/* Some of the interrupts are level triggered, some are edge triggered */
+#define IRQ_TIMBERDALE_EDGE_MASK ((1 << IRQ_TIMBERDALE_ADV7180) | \
+	(1 << IRQ_TIMBERDALE_TSC_INT) | (1 << IRQ_TIMBERDALE_DMA) | \
+	(1 << IRQ_TIMBERDALE_MLB) | (1 << IRQ_TIMBERDALE_INIC))
+
+#define IRQ_TIMBERDALE_LEVEL_MASK ((1 << IRQ_TIMBERDALE_SPI) | \
+	(1 << IRQ_TIMBERDALE_ETHSW_IF) | (1 << IRQ_TIMBERDALE_SDHC) | \
+	(1 << IRQ_TIMBERDALE_I2S) | (1 << IRQ_TIMBERDALE_UART) | \
+	(1 << IRQ_TIMBERDALE_I2C) | (1 << IRQ_TIMBERDALE_GPIO))
+
+#endif
+
diff -uNr linux-2.6.29-clean/drivers/mfd/timbi2s.c linux-2.6.29/drivers/mfd/timbi2s.c
--- linux-2.6.29-clean/drivers/mfd/timbi2s.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/mfd/timbi2s.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,597 @@
+/*
+ * timbi2s.c timberdale FPGA I2S driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA I2S
+ *
+ * As of 2009-03-23 I2S instances
+ * are not configured as masters
+ *
+ * TODO: implement switching between master and slave
+ */
+
+#include <linux/io.h>
+#include <linux/fs.h>
+#include <linux/module.h>
+#include <linux/circ_buf.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
+#include <linux/interrupt.h>
+#include <linux/platform_device.h>
+
+#include <linux/mfd/timbi2s.h>
+
+#define DRIVER_NAME "timb-i2s"
+
+#define I2S_CLOCK_SPEED 62500000 /* 62,5MHz */
+
+#define FIFO_FILL_SIZE 127
+#define I2S_BUFFER_SIZE PAGE_SIZE
+
+#define ALMOST_FULL 170
+#define ALMOST_EMPTY 85
+
+/* As of 2009-03-16, IP can instanciate max. 4 RX and 4 TX */
+#define MAX_TX_NR 4
+#define MAX_RX_NR 4
+/* and actually up and running only 4.
+ * 1 TX and 3 RX
+ */
+#define IP_I2S_NR 4
+#define REGSTEP 0x04
+
+#define VERSION		0x00
+#define I2S_UIR		0x04 /* Unit Interrupt Register */
+
+/* Registers for all possible I2S IP instances
+ * are the same as for first one (from 0x08 to 0x20)
+ */
+#define I2S_PRESCALE	0x08 /* Holds prescale value, if clock master */
+#define I2S_ICR		0x0c /* Interrupt Clear Register */
+#	define ICR_F	0x01 /* Full */
+#	define ICR_AF	0x02 /* Almost full */
+#	define ICR_AE	0x04 /* Almost empty */
+#	define ICR_RX_D	0x08 /* Data present, RX only */
+#	define ICR_TX_E	0x08 /* Epmty, TX only */
+
+#define I2S_IPR		0x10 /* Interrupt Pending Register */
+#define I2S_ISR		0x14 /* Interrupt Status Register */
+
+#define I2S_IER		0x18 /* Interrupt Enable Register */
+#	define IER_FF		0x01 /* RX/TX FIFO Full */
+#	define IER_FAF		0x02 /* RX/TX FIFO Almost Full */
+#	define IER_FAE		0x04 /* RX/TX FIFO Almost Empty */
+#	define IER_RX_DATA	0x08 /* RX. Data Present */
+#	define IER_TX_FE	0x08 /* TX. FIFO Empty */
+
+#define I2S_CTRL	0x1c /* Control Register */
+#	define CTRL_TX_ENABLE	0x01 /* Enable TX */
+#	define CTRL_RX_ENABLE	0x02 /* Enable RX */
+#	define CTRL_NONE	0x04 /* Not used */
+#	define CTRL_FIFO_CLR	0x08 /* FIFO Clear */
+#	define CTRL_SWR 	0x10 /* Soft reset */
+#	define CTRL_CLKMASTER	0x1000 /* IP I2S instance is master */
+#	define CTRL_IS_TX	0x40000000 /* IP I2S is an TX-instance */
+#	define CTRL_IS_RX	0x20000000 /* IP I2S is an RX-instance */
+
+#define I2S_FIFO 0x20 /* read/write FIFO */
+
+#define INC_HEAD(buf, size) \
+	(buf->head = (buf->head + 1) & (size-1))
+
+#define INC_TAIL(buf, size) \
+	(buf->tail = (buf->tail + 1) & (size-1))
+
+
+/* circular buffer */
+static struct circ_buf *timbi2s_buf_alloc(void);
+static void timbi2s_buf_free(struct circ_buf *cb);
+static void timbi2s_buf_clear(struct circ_buf *cb);
+
+static int timbi2s_fifo_read(struct circ_buf *cb, ssize_t count, long add);
+static int timbi2s_fifo_write(struct circ_buf *cb, ssize_t count, long add);
+
+static int timbi2s_ioctrl(struct timbi2s_dev *);
+
+static struct timbi2s_bus *bus_p;
+
+static int timbi2s_is_tx(struct timbi2s_dev *i2sdev)
+{
+	return (ioread32(i2sdev->membase + i2sdev->ctrl_offset)
+				& CTRL_IS_TX) ? 1 : 0;
+}
+
+static int timbi2s_is_rx(struct timbi2s_dev *i2sdev)
+{
+	return (ioread32(i2sdev->membase + i2sdev->ctrl_offset)
+				& CTRL_IS_RX) ? 1 : 0;
+}
+
+/* Return unused TX-instance */
+static struct timbi2s_dev *timbi2s_get_tx(void)
+{
+	struct timbi2s_dev *tdev, *tmp;
+
+	if (bus_p == NULL)
+		return NULL;
+
+	list_for_each_entry_safe(tdev, tmp, &bus_p->control->list, item) {
+		if (!tdev->in_use && timbi2s_is_tx(tdev)) {
+			tdev->in_use = 1;
+			return tdev;
+		}
+
+	}
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(timbi2s_get_tx);
+
+/* Return unused RX-instance */
+static struct timbi2s_dev *timbi2s_get_rx(void)
+{
+	struct timbi2s_dev *tdev, *tmp;
+
+	if (bus_p == NULL)
+		return NULL;
+
+	list_for_each_entry_safe(tdev, tmp, &bus_p->control->list, item) {
+		if (!tdev->in_use && timbi2s_is_rx(tdev)) {
+			tdev->in_use = 1;
+			return tdev;
+		}
+
+	}
+	return NULL;
+}
+EXPORT_SYMBOL_GPL(timbi2s_get_rx);
+
+/* Flag TX/RX as unused and reset it */
+static void timbi2s_put(struct timbi2s_dev *tdev)
+{
+	if (tdev->in_use) {
+		tdev->in_use = 0;
+		timbi2s_ioctrl(tdev);
+	}
+}
+EXPORT_SYMBOL_GPL(timbi2s_put);
+
+/*
+ * Write data to the FIFO
+ */
+static void timbi2s_tx_handler(struct timbi2s_dev *i2sdev)
+{
+	u32 pend;
+
+	pend = ioread32(i2sdev->membase + i2sdev->ipr_offset);
+
+	if (pend & IER_FAE) {
+		timbi2s_fifo_write(i2sdev->buffer,
+				ALMOST_FULL - ALMOST_EMPTY,
+				  (unsigned long)i2sdev->membase +
+							i2sdev->fifo);
+		/* clear interrupt */
+		iowrite32(ICR_AE, i2sdev->membase + i2sdev->icr_offset);
+	}
+}
+
+/*
+ * Read data from the FIFO
+ */
+static void timbi2s_rx_handler(struct timbi2s_dev *i2sdev)
+{
+	u32 pend;
+	pend = ioread32(i2sdev->membase + i2sdev->ipr_offset);
+
+	if (pend & IER_FAE) {
+		timbi2s_fifo_read(i2sdev->buffer,
+				ALMOST_EMPTY,
+				(unsigned long)i2sdev->membase +
+							i2sdev->fifo);
+
+		/* clear interrupt */
+		iowrite32(ICR_AE | ICR_AF,
+					i2sdev->membase + i2sdev->icr_offset);
+	}
+}
+
+void timbi2s_int_handler(struct work_struct *workp)
+{
+	u32 pend, stat, i2stype;
+	unsigned long flags;
+	struct timbi2s_dev *i2sdev = container_of(workp,
+							struct timbi2s_dev,
+									work);
+
+	pend = ioread32(i2sdev->membase + i2sdev->ipr_offset);
+	stat = ioread32(i2sdev->membase + i2sdev->isr_offset);
+	i2stype = ioread32(i2sdev->membase + i2sdev->ctrl_offset);
+
+	spin_lock_irqsave(&i2sdev->lock, flags);
+
+	if (i2stype & CTRL_IS_RX) {
+		/* Enable Almost Empty Almost Full interrupt */
+		iowrite32(IER_FAE | IER_FAF,
+				i2sdev->membase + i2sdev->ier_offset);
+		/* Enable RX */
+		iowrite32(CTRL_RX_ENABLE,
+				i2sdev->membase + i2sdev->ctrl_offset);
+		timbi2s_rx_handler(i2sdev);
+	} else if (i2stype & CTRL_IS_TX) {
+		/* Enable Almost Empty interrupt */
+		iowrite32(IER_FAE, i2sdev->membase + i2sdev->ier_offset);
+		/* Enable TX */
+		iowrite32(CTRL_TX_ENABLE,
+				i2sdev->membase + i2sdev->ctrl_offset);
+		timbi2s_tx_handler(i2sdev);
+	}
+
+	spin_unlock_irqrestore(&i2sdev->lock, flags);
+}
+
+static int timbi2s_ioctrl(struct timbi2s_dev *i2sdev)
+{
+	u32 i2stype;
+
+	/* Reset */
+	iowrite8(CTRL_SWR, i2sdev->membase + i2sdev->ctrl_offset);
+	/* Clear IER */
+	iowrite32(0x00000000, i2sdev->membase + i2sdev->ier_offset);
+	/* Clear ICR */
+	iowrite32(0xffffffff, i2sdev->membase + i2sdev->icr_offset);
+
+	i2stype = ioread32(i2sdev->membase + i2sdev->ctrl_offset);
+
+	if (i2stype & CTRL_IS_TX)
+		printk(KERN_INFO DRIVER_NAME": found active I2S Transmitter\n");
+	else if (i2stype & CTRL_IS_RX)
+		printk(KERN_INFO DRIVER_NAME": found active I2S Receiver\n");
+
+	return 1;
+}
+EXPORT_SYMBOL_GPL(timbi2s_ioctrl);
+
+static struct circ_buf *timbi2s_buf_alloc(void)
+{
+	struct circ_buf *cb;
+
+	cb = kzalloc(sizeof(*cb), GFP_KERNEL);
+	if (cb == NULL)
+		return NULL;
+
+	cb->buf = kzalloc(I2S_BUFFER_SIZE, GFP_KERNEL);
+	if (cb->buf == NULL) {
+		kfree(cb);
+		return NULL;
+	}
+
+	timbi2s_buf_clear(cb);
+
+	return cb;
+}
+
+static void timbi2s_buf_free(struct circ_buf *cb)
+{
+	kfree(cb->buf);
+	kfree(cb);
+}
+
+static void timbi2s_buf_clear(struct circ_buf *cb)
+{
+	cb->head = 0;
+	cb->tail = cb->head;
+}
+
+/*
+ * Read data from the FIFO and write it to the given circular buffer
+ */
+static int timbi2s_fifo_read(struct circ_buf *cb, ssize_t count, long add)
+{
+	int c, ret = 0;
+
+	unsigned char *hi = (unsigned char *)ioread32((void *)(add >> 16));
+	unsigned char *lo = (unsigned char *)ioread32((void *)(add & 0xFFFF));
+
+	c = CIRC_SPACE_TO_END(cb->head, cb->tail, I2S_BUFFER_SIZE);
+	if (count < c)
+		c = count;
+
+	if (c <= 0)
+		return 1;
+
+	while (c >= 0) {
+		memcpy(cb->buf + cb->head, hi, 2);
+		INC_HEAD(cb, I2S_BUFFER_SIZE);
+
+		memcpy(cb->buf + cb->head, lo, 2);
+		INC_HEAD(cb, I2S_BUFFER_SIZE);
+		count -= 4;
+	}
+	return ret;
+}
+
+/*
+ * Get data from the circular buffer and write it to the given FIFO address
+ */
+static int timbi2s_fifo_write(struct circ_buf *cb, ssize_t count, long add)
+{
+	int c, ret = 0;
+
+	c = CIRC_CNT_TO_END(cb->head, cb->tail, I2S_BUFFER_SIZE);
+	if (count < c)
+		c = count;
+
+	if (c <= 0)
+		return 1;
+
+	while (c >= 0) {
+		iowrite32(*(s16 *)(cb->buf + cb->tail), (void *)(add >> 16));
+		INC_TAIL(cb, I2S_BUFFER_SIZE);
+
+		iowrite32(*(s16 *)(cb->buf + cb->tail), (void *)(add & 0xFFFF));
+		INC_TAIL(cb, I2S_BUFFER_SIZE);
+		count -= 4;
+	}
+
+	return ret;
+}
+
+static void timbi2s_control_destroy(struct timbi2s_bus_control *control)
+{
+	kfree(control);
+	control = NULL;
+}
+
+static void timbi2s_control_add_dev(struct timbi2s_dev *i2sdev)
+{
+	list_add(&i2sdev->item, &i2sdev->bus->control->list);
+}
+
+static void timbi2s_control_del_dev(struct timbi2s_dev *i2sdev)
+{
+	list_del(&i2sdev->item);
+	if (list_empty(&i2sdev->bus->control->list))
+		timbi2s_control_destroy(i2sdev->bus->control);
+}
+
+static irqreturn_t timbi2s_irq(int irq, void *dev_id)
+{
+	u8 pend;
+	u32 iunit;
+	int i;
+
+	struct timbi2s_bus *tbus = dev_id;
+	queue_work(tbus->workqueue, &tbus->work);
+
+	iunit = ioread32(tbus->membase + I2S_UIR);
+	/* Find out which I2S instance is interrupting */
+	for (i = 0; i < 32; i++) {
+		if ((1 << i) & iunit) {
+			pend = ioread8(tbus->membase +
+						(I2S_IPR + (i * REGSTEP * 7)));
+			iowrite8(pend, tbus->membase +
+						(I2S_ICR + (i * REGSTEP * 7)));
+		}
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int __init timbi2s_probe(struct platform_device *dev)
+{
+	int err = 0;
+	struct timbi2s_dev *tdev, *tmp;
+	struct timbi2s_bus *tbus;
+	struct resource *iomem;
+	int i;
+
+	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (!iomem) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	tbus = kzalloc(sizeof(*tbus), GFP_KERNEL);
+	if (!tbus) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	/* Init bus_control */
+	tbus->control = kzalloc(sizeof(struct timbi2s_bus_control), GFP_KERNEL);
+	if (!tbus->control) {
+		printk(KERN_ERR DRIVER_NAME
+				": Failed to allocate timbi2s_bus_control.\n");
+		err = -ENOMEM;
+		goto err_free;
+	}
+	INIT_LIST_HEAD(&tbus->control->list);
+
+	/* Init workqueue */
+	tbus->workqueue = create_singlethread_workqueue("timbi2s");
+	if (tbus->workqueue == NULL) {
+		printk(KERN_ERR DRIVER_NAME
+				": unable to create workqueue\n");
+		err = -ENOMEM;
+		goto err_control;
+	}
+	INIT_WORK(&tbus->work, timbi2s_int_handler);
+
+	if (!request_mem_region(iomem->start,
+				resource_size(iomem), DRIVER_NAME)) {
+		printk(KERN_EMERG DRIVER_NAME
+				": Mem region is already in use\n");
+		err = -ENXIO;
+		goto err_control;
+	}
+
+	tbus->membase = ioremap(iomem->start, resource_size(iomem));
+	if (tbus->membase == NULL) {
+		err = -ENOMEM;
+		goto err_request;
+	}
+
+	bus_p = tbus;
+
+
+
+	/* For now we have only 4 I2S instances in IP : 3 RX and 1 TX */
+	/* Note: TX'es are always on top */
+	/* TODO: auto-check how many are alive and bring them into control */
+	for (i = 0; i < IP_I2S_NR; i++) {
+		tdev = kzalloc(sizeof(*tdev), GFP_KERNEL);
+		if (!tdev) {
+			err = -EINVAL;
+			goto clean_list;
+		}
+
+		/* Allocate circ_buf */
+		tdev->buffer = timbi2s_buf_alloc();
+		if (tdev->buffer == NULL) {
+			printk(KERN_ERR "timbi2s: unable to allocate buffer\n");
+			goto clean_list;
+		}
+
+		INIT_LIST_HEAD(&tdev->item);
+		spin_lock_init(&tdev->lock);
+
+		/* set up offsets for each instance of I2S */
+		tdev->bus = tbus; /* ptr to our bus */
+		tdev->membase = tbus->membase;
+		tdev->in_use = 0;
+		tdev->pscale_offset = I2S_PRESCALE + (i * REGSTEP * 7);
+		tdev->icr_offset = I2S_ICR + (i * REGSTEP * 7);
+		tdev->isr_offset = I2S_ISR + (i * REGSTEP * 7);
+		tdev->ipr_offset = I2S_IPR + (i * REGSTEP * 7);
+		tdev->ier_offset = I2S_IER + (i * REGSTEP * 7);
+		tdev->ctrl_offset = I2S_CTRL + (i * REGSTEP * 7);
+		tdev->fifo = I2S_FIFO + (i * REGSTEP * 7);
+
+		/* Try to check and reset hardware */
+		if (timbi2s_ioctrl(tdev))
+			timbi2s_control_add_dev(tdev);
+
+		tdev = NULL;
+	}
+
+	tbus->irq = platform_get_irq(dev, 0);
+	if (tbus->irq < 0) {
+		err = -EINVAL;
+		goto clean_list;
+	}
+
+	err = request_irq(tbus->irq, timbi2s_irq, 0, DRIVER_NAME, tbus);
+	if (err != 0)
+		goto clean_list;
+
+	platform_set_drvdata(dev, tbus);
+
+	dev_info(&dev->dev, "Driver for Timberdale I2S (ver: %d)"
+				" has been successfully registered.\n",
+				ioread32(tbus->membase + 0x00));
+	return 0;
+
+clean_list:
+	list_for_each_entry_safe(tdev, tmp, &tbus->control->list, item) {
+		if (tdev->workqueue != NULL) {
+			flush_workqueue(tdev->workqueue);
+			destroy_workqueue(tdev->workqueue);
+		}
+
+		if (tdev->buffer != NULL)
+			timbi2s_buf_free(tdev->buffer);
+
+		timbi2s_control_del_dev(tdev);
+		kfree(tdev);
+	}
+	free_irq(tbus->irq, tbus);
+	iounmap(tbus->membase);
+err_request:
+	release_mem_region(iomem->start, resource_size(iomem));
+err_control:
+	if (tbus->control != NULL)
+		timbi2s_control_destroy(tbus->control);
+err_free:
+	kfree(tbus);
+err_mem:
+	printk(KERN_ERR
+		DRIVER_NAME": Failed to register Timberdale I2S: %d\n", err);
+
+	return err;
+}
+
+static int __devexit timbi2s_remove(struct platform_device *dev)
+{
+	struct timbi2s_bus *tbus;
+	struct timbi2s_dev *tdev, *tmp;
+	struct resource *r;
+
+	tbus = platform_get_drvdata(dev);
+	free_irq(tbus->irq, tbus);
+
+	r = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+	list_for_each_entry_safe(tdev, tmp, &tbus->control->list, item) {
+		if (tdev->workqueue != NULL) {
+			flush_workqueue(tdev->workqueue);
+			destroy_workqueue(tdev->workqueue);
+		}
+
+		if (tdev->buffer != NULL)
+			timbi2s_buf_free(tdev->buffer);
+
+		kfree(tdev);
+	}
+
+	iounmap(tdev->membase);
+	if (r)
+		release_mem_region(r->start, resource_size(r));
+
+	dev_info(&dev->dev, "Driver for Timberdale I2S has been"
+				" successfully unregistered.\n");
+
+	platform_set_drvdata(dev, 0);
+	return 0;
+}
+
+static struct platform_driver timbi2s_platform_driver = {
+	.driver = {
+		.name	= DRIVER_NAME,
+		.owner	= THIS_MODULE,
+	},
+	.probe		= timbi2s_probe,
+	.remove		= __devexit_p(timbi2s_remove),
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timbi2s_init(void)
+{
+	return platform_driver_register(&timbi2s_platform_driver);
+}
+
+static void __exit timbi2s_exit(void)
+{
+	platform_driver_unregister(&timbi2s_platform_driver);
+}
+
+module_init(timbi2s_init);
+module_exit(timbi2s_exit);
+
+MODULE_AUTHOR("Mocean Laboratories");
+MODULE_DESCRIPTION("Timberdale I2S bus driver");
+MODULE_LICENSE("GPL v2");
diff -uNr linux-2.6.29-clean/drivers/mmc/host/Kconfig linux-2.6.29/drivers/mmc/host/Kconfig
--- linux-2.6.29-clean/drivers/mmc/host/Kconfig	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/mmc/host/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -65,6 +65,16 @@
 
 	  If unsure, say Y.
 
+config MMC_SDHCI_PLTFM
+	tristate "SDHCI support on platform devices"
+	depends on MMC_SDHCI
+	help
+	  This selects the Secure Digital Host Controller Interface.
+
+	  If you have a controller with this interface, say Y or M here.
+
+	  If unsure, say N.
+
 config MMC_OMAP
 	tristate "TI OMAP Multimedia Card Interface support"
 	depends on ARCH_OMAP
diff -uNr linux-2.6.29-clean/drivers/mmc/host/Makefile linux-2.6.29/drivers/mmc/host/Makefile
--- linux-2.6.29-clean/drivers/mmc/host/Makefile	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/mmc/host/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -13,6 +13,7 @@
 obj-$(CONFIG_MMC_SDHCI)		+= sdhci.o
 obj-$(CONFIG_MMC_SDHCI_PCI)	+= sdhci-pci.o
 obj-$(CONFIG_MMC_RICOH_MMC)	+= ricoh_mmc.o
+obj-$(CONFIG_MMC_SDHCI_PLTFM)	+= sdhci-pltfm.o
 obj-$(CONFIG_MMC_WBSD)		+= wbsd.o
 obj-$(CONFIG_MMC_AU1X)		+= au1xmmc.o
 obj-$(CONFIG_MMC_OMAP)		+= omap.o
diff -uNr linux-2.6.29-clean/drivers/mmc/host/sdhci-pltfm.c linux-2.6.29/drivers/mmc/host/sdhci-pltfm.c
--- linux-2.6.29-clean/drivers/mmc/host/sdhci-pltfm.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/mmc/host/sdhci-pltfm.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,262 @@
+/*
+ * sdhci-pltfm.c Support for SDHCI platform devices
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * SDHCI platform devices
+ *
+ * Inspired by sdhci-pci.c, by Pierre Ossman
+ */
+
+#include <linux/delay.h>
+#include <linux/highmem.h>
+#include <linux/platform_device.h>
+
+#include <linux/mmc/host.h>
+
+#include <linux/io.h>
+
+#include "sdhci.h"
+
+
+#define MAX_SLOTS	8
+
+struct sdhci_pltfm_chip;
+
+struct sdhci_pltfm_slot {
+	struct sdhci_pltfm_chip	*chip;
+	struct sdhci_host	*host;
+
+	int			pltfm_resource;
+};
+
+struct sdhci_pltfm_chip {
+	struct platform_device	*pdev;
+
+	unsigned int		quirks;
+
+	int			num_slots;	/* Slots on controller */
+	struct sdhci_pltfm_slot	*slots[MAX_SLOTS]; /* Pointers to host slots */
+};
+
+
+/*****************************************************************************\
+ *                                                                           *
+ * SDHCI core callbacks                                                      *
+ *                                                                           *
+\*****************************************************************************/
+
+static struct sdhci_ops sdhci_pltfm_ops = {
+};
+
+/*****************************************************************************\
+ *                                                                           *
+ * Device probing/removal                                                    *
+ *                                                                           *
+\*****************************************************************************/
+
+
+static struct sdhci_pltfm_slot * __devinit sdhci_pltfm_probe_slot(
+	struct platform_device *pdev, struct sdhci_pltfm_chip *chip,
+	int resource)
+{
+	struct sdhci_pltfm_slot *slot;
+	struct sdhci_host *host;
+	struct resource *iomem;
+	int ret;
+
+	iomem = platform_get_resource(pdev, IORESOURCE_MEM, resource);
+	if (!iomem)
+		return ERR_PTR(-ENODEV);
+
+	if (resource_size(iomem) != 0x100) {
+		dev_err(&pdev->dev, "Invalid iomem size. You may "
+			"experience problems.\n");
+	}
+
+	if (!pdev->dev.parent) {
+		dev_err(&pdev->dev, "The parent device be a PCI device\n");
+		return ERR_PTR(-ENODEV);
+	}
+
+	host = sdhci_alloc_host(pdev->dev.parent,
+		sizeof(struct sdhci_pltfm_slot));
+	if (IS_ERR(host))
+		return ERR_PTR(PTR_ERR(host));
+
+	slot = sdhci_priv(host);
+
+	slot->chip = chip;
+	slot->host = host;
+	slot->pltfm_resource = resource;
+
+	host->hw_name = "PLTFM";
+	host->ops = &sdhci_pltfm_ops;
+	host->quirks = chip->quirks;
+
+	host->irq = platform_get_irq(pdev, 0);
+
+	if (!request_mem_region(iomem->start, resource_size(iomem),
+		mmc_hostname(host->mmc))) {
+		dev_err(&pdev->dev, "cannot request region\n");
+		ret = -EBUSY;
+		goto free;
+	}
+
+	host->ioaddr = ioremap(iomem->start, resource_size(iomem));
+	if (!host->ioaddr) {
+		dev_err(&pdev->dev, "failed to remap registers\n");
+		goto release;
+	}
+
+	ret = sdhci_add_host(host);
+	if (ret)
+		goto unmap;
+
+	return slot;
+
+unmap:
+	iounmap(host->ioaddr);
+release:
+	release_mem_region(iomem->start, resource_size(iomem));
+free:
+	sdhci_free_host(host);
+
+	return ERR_PTR(ret);
+}
+
+static void sdhci_pltfm_remove_slot(struct sdhci_pltfm_slot *slot)
+{
+	int dead;
+	u32 scratch;
+	struct resource *iomem;
+
+	dead = 0;
+	scratch = readl(slot->host->ioaddr + SDHCI_INT_STATUS);
+	if (scratch == (u32)-1)
+		dead = 1;
+
+	sdhci_remove_host(slot->host, dead);
+
+	iounmap(slot->host->ioaddr);
+
+	iomem = platform_get_resource(slot->chip->pdev, IORESOURCE_MEM,
+		slot->pltfm_resource);
+	release_mem_region(iomem->start, resource_size(iomem));
+
+	sdhci_free_host(slot->host);
+}
+
+static int __devinit sdhci_pltfm_probe(struct platform_device *pdev)
+{
+	struct sdhci_pltfm_chip *chip;
+	struct sdhci_pltfm_slot *slot;
+	u8 slots;
+	int ret, i;
+
+	BUG_ON(pdev == NULL);
+
+	for (slots = 0; slots <= MAX_SLOTS; slots++)
+		if (!platform_get_resource(pdev, IORESOURCE_MEM, slots))
+			break;
+
+	BUG_ON(slots > MAX_SLOTS || slots == 0);
+
+	chip = kzalloc(sizeof(struct sdhci_pltfm_chip), GFP_KERNEL);
+	if (!chip) {
+		ret = -ENOMEM;
+		goto err;
+	}
+
+	chip->pdev = pdev;
+	chip->num_slots = slots;
+	platform_set_drvdata(pdev, chip);
+
+	for (i = 0; i < slots; i++) {
+		slot = sdhci_pltfm_probe_slot(pdev, chip, i);
+		if (IS_ERR(slot)) {
+			for (i--; i >= 0; i--)
+				sdhci_pltfm_remove_slot(chip->slots[i]);
+			ret = PTR_ERR(slot);
+			goto free;
+		}
+
+		chip->slots[i] = slot;
+	}
+
+	return 0;
+
+free:
+	platform_set_drvdata(pdev, NULL);
+	kfree(chip);
+
+err:
+	printk(KERN_ERR"Probing of sdhci-pltfm failed: %d\n", ret);
+	return ret;
+}
+
+static int __devexit sdhci_pltfm_remove(struct platform_device *pdev)
+{
+	int i;
+	struct sdhci_pltfm_chip *chip;
+
+	chip = platform_get_drvdata(pdev);
+
+	if (chip) {
+		for (i = 0; i < chip->num_slots; i++)
+			sdhci_pltfm_remove_slot(chip->slots[i]);
+
+		platform_set_drvdata(pdev, NULL);
+		kfree(chip);
+	}
+
+	return 0;
+}
+
+static struct platform_driver sdhci_pltfm_driver = {
+	.driver = {
+		.name	= "sdhci",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= sdhci_pltfm_probe,
+	.remove		= __devexit_p(sdhci_pltfm_remove),
+};
+
+/*****************************************************************************\
+ *                                                                           *
+ * Driver init/exit                                                          *
+ *                                                                           *
+\*****************************************************************************/
+
+static int __init sdhci_drv_init(void)
+{
+	return platform_driver_register(&sdhci_pltfm_driver);
+}
+
+static void __exit sdhci_drv_exit(void)
+{
+	platform_driver_unregister(&sdhci_pltfm_driver);
+}
+
+module_init(sdhci_drv_init);
+module_exit(sdhci_drv_exit);
+
+MODULE_DESCRIPTION("Secure Digital Host Controller Interface platform driver");
+MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:sdhci");
+
diff -uNr linux-2.6.29-clean/drivers/serial/Kconfig linux-2.6.29/drivers/serial/Kconfig
--- linux-2.6.29-clean/drivers/serial/Kconfig	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/serial/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -1412,4 +1412,11 @@
 	default 19200 if (SERIAL_SPORT_BAUD_RATE_19200)
 	default 9600 if (SERIAL_SPORT_BAUD_RATE_9600)
 
+config SERIAL_TIMBERDALE
+	tristate "Support for timberdale UART"
+	depends on MFD_TIMBERDALE
+	select SERIAL_CORE
+	---help---
+	Add support for UART controller on timberdale.
+
 endmenu
diff -uNr linux-2.6.29-clean/drivers/serial/Makefile linux-2.6.29/drivers/serial/Makefile
--- linux-2.6.29-clean/drivers/serial/Makefile	2009-04-01 09:20:24.000000000 -0700
+++ linux-2.6.29/drivers/serial/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -76,3 +76,4 @@
 obj-$(CONFIG_SERIAL_KS8695) += serial_ks8695.o
 obj-$(CONFIG_KGDB_SERIAL_CONSOLE) += kgdboc.o
 obj-$(CONFIG_SERIAL_QE) += ucc_uart.o
+obj-$(CONFIG_SERIAL_TIMBERDALE)	+= timbuart.o
diff -uNr linux-2.6.29-clean/drivers/serial/timbuart.c linux-2.6.29/drivers/serial/timbuart.c
--- linux-2.6.29-clean/drivers/serial/timbuart.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/serial/timbuart.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,519 @@
+/*
+ * timbuart.c timberdale FPGA UART driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA UART
+ */
+
+#include <linux/pci.h>
+#include <linux/interrupt.h>
+#include <linux/serial_core.h>
+#include <linux/kernel.h>
+#include <linux/platform_device.h>
+#include <linux/ioport.h>
+
+#include "timbuart.h"
+
+struct timbuart_port {
+	struct uart_port	port;
+	struct tasklet_struct	tasklet;
+	int			usedma;
+	u8			last_ier;
+	struct platform_device  *dev;
+};
+
+static int baudrates[] = {9600, 19200, 38400, 57600, 115200, 230400, 460800,
+	921600, 1843200, 3250000};
+
+static void timbuart_mctrl_check(struct uart_port *port, u8 isr, u8 *ier);
+
+static irqreturn_t timbuart_handleinterrupt(int irq, void *devid);
+
+static void timbuart_stop_rx(struct uart_port *port)
+{
+	/* spin lock held by upper layer, disable all RX interrupts */
+	u8 ier = ioread8(port->membase + TIMBUART_IER) & ~RXFLAGS;
+	iowrite8(ier, port->membase + TIMBUART_IER);
+}
+
+static void timbuart_stop_tx(struct uart_port *port)
+{
+	/* spinlock held by upper layer, disable TX interrupt */
+	u8 ier = ioread8(port->membase + TIMBUART_IER) & ~TXBAE;
+	iowrite8(ier, port->membase + TIMBUART_IER);
+}
+
+static void timbuart_start_tx(struct uart_port *port)
+{
+	struct timbuart_port *uart =
+		container_of(port, struct timbuart_port, port);
+
+	/* do not transfer anything here -> fire off the tasklet */
+	tasklet_schedule(&uart->tasklet);
+}
+
+static void timbuart_flush_buffer(struct uart_port *port)
+{
+	u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | TIMBUART_CTRL_FLSHTX;
+
+	iowrite8(ctl, port->membase + TIMBUART_CTRL);
+	iowrite8(TXBF, port->membase + TIMBUART_ISR);
+}
+
+static void timbuart_rx_chars(struct uart_port *port)
+{
+	struct tty_struct *tty = port->info->port.tty;
+
+	while (ioread8(port->membase + TIMBUART_ISR) & RXDP) {
+		u8 ch = ioread8(port->membase + TIMBUART_RXFIFO);
+		/* ack */
+		iowrite8(RXDP, port->membase + TIMBUART_ISR);
+		port->icount.rx++;
+		tty_insert_flip_char(tty, ch, TTY_NORMAL);
+	}
+
+	spin_unlock(&port->lock);
+	tty_flip_buffer_push(port->info->port.tty);
+	spin_lock(&port->lock);
+
+	dev_dbg(port->dev, "%s - total read %d bytes\n",
+		__func__, port->icount.rx);
+}
+
+static void timbuart_tx_chars(struct uart_port *port)
+{
+	struct circ_buf *xmit = &port->info->xmit;
+
+	while (!(ioread8(port->membase + TIMBUART_ISR) & TXBF) &&
+		!uart_circ_empty(xmit)) {
+		iowrite8(xmit->buf[xmit->tail],
+			port->membase + TIMBUART_TXFIFO);
+		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+		port->icount.tx++;
+	}
+
+	dev_dbg(port->dev,
+		"%s - total written %d bytes, CTL: %x, RTS: %x, baud: %x\n",
+		 __func__,
+		port->icount.tx,
+		ioread8(port->membase + TIMBUART_CTRL),
+		port->mctrl & TIOCM_RTS,
+		ioread8(port->membase + TIMBUART_BAUDRATE));
+}
+
+static void timbuart_handle_tx_port(struct uart_port *port, u8 isr, u8 *ier)
+{
+	struct timbuart_port *uart =
+		container_of(port, struct timbuart_port, port);
+	struct circ_buf *xmit = &port->info->xmit;
+
+	if (uart_circ_empty(xmit) || uart_tx_stopped(port))
+		return;
+
+	if (port->x_char)
+		return;
+
+	if (isr & TXFLAGS) {
+		timbuart_tx_chars(port);
+		/* clear all TX interrupts */
+		iowrite8(TXFLAGS, port->membase + TIMBUART_ISR);
+
+		if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
+			uart_write_wakeup(port);
+	} else
+		/* Re-enable any tx interrupt */
+		*ier |= uart->last_ier & TXFLAGS;
+
+	/* enable interrupts if there are chars in the transmit buffer,
+	 * Or if we delivered some bytes and want the almost empty interrupt
+	 * we wake up the upper layer later when we got the interrupt
+	 * to give it some time to go out...
+	 */
+	if (!uart_circ_empty(xmit))
+		*ier |= TXBAE;
+
+	dev_dbg(port->dev, "%s - leaving\n", __func__);
+}
+
+void timbuart_handle_rx_port(struct uart_port *port, u8 isr, u8 *ier)
+{
+	if (isr & RXFLAGS) {
+		/* Some RX status is set */
+		if (isr & RXBF) {
+			u8 ctl = ioread8(port->membase + TIMBUART_CTRL) |
+				TIMBUART_CTRL_FLSHRX;
+			iowrite8(ctl, port->membase + TIMBUART_CTRL);
+			port->icount.overrun++;
+		} else if (isr & (RXDP))
+			timbuart_rx_chars(port);
+
+		/* ack all RX interrupts */
+		iowrite8(RXFLAGS, port->membase + TIMBUART_ISR);
+	}
+
+	/* always have the RX interrupts enabled */
+	*ier |= RXBAF | RXBF | RXTT;
+
+	dev_dbg(port->dev, "%s - leaving\n", __func__);
+}
+
+void timbuart_tasklet(unsigned long arg)
+{
+	struct timbuart_port *uart = (struct timbuart_port *)arg;
+	u8 isr, ier = 0;
+
+	spin_lock(&uart->port.lock);
+
+	isr = ioread8(uart->port.membase + TIMBUART_ISR);
+	dev_dbg(uart->port.dev, "%s ISR: %x\n", __func__, isr);
+
+	if (!uart->usedma)
+		timbuart_handle_tx_port(&uart->port, isr, &ier);
+
+	timbuart_mctrl_check(&uart->port, isr, &ier);
+
+	if (!uart->usedma)
+		timbuart_handle_rx_port(&uart->port, isr, &ier);
+
+	iowrite8(ier, uart->port.membase + TIMBUART_IER);
+
+	spin_unlock(&uart->port.lock);
+	dev_dbg(uart->port.dev, "%s leaving\n", __func__);
+}
+
+static unsigned int timbuart_tx_empty(struct uart_port *port)
+{
+	u8 isr = ioread8(port->membase + TIMBUART_ISR);
+
+	return (isr & TXBAE) ? TIOCSER_TEMT : 0;
+}
+
+static unsigned int timbuart_get_mctrl(struct uart_port *port)
+{
+	u8 cts = ioread8(port->membase + TIMBUART_CTRL);
+	dev_dbg(port->dev, "%s - cts %x\n", __func__, cts);
+
+	if (cts & TIMBUART_CTRL_CTS)
+		return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
+	else
+		return TIOCM_DSR | TIOCM_CAR;
+}
+
+static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
+{
+	dev_dbg(port->dev, "%s - %x\n", __func__, mctrl);
+
+	if (mctrl & TIOCM_RTS)
+		iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
+	else
+		iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL);
+}
+
+static void timbuart_mctrl_check(struct uart_port *port, u8 isr, u8 *ier)
+{
+	unsigned int cts;
+
+	if (isr & CTS_DELTA) {
+		/* ack */
+		iowrite8(CTS_DELTA, port->membase + TIMBUART_ISR);
+		cts = timbuart_get_mctrl(port);
+		uart_handle_cts_change(port, cts & TIOCM_CTS);
+		wake_up_interruptible(&port->info->delta_msr_wait);
+	}
+
+	*ier |= CTS_DELTA;
+}
+
+static void timbuart_enable_ms(struct uart_port *port)
+{
+	/* N/A */
+}
+
+static void timbuart_break_ctl(struct uart_port *port, int ctl)
+{
+	/* N/A */
+}
+
+static int timbuart_startup(struct uart_port *port)
+{
+	struct timbuart_port *uart =
+		container_of(port, struct timbuart_port, port);
+
+	dev_dbg(port->dev, "%s\n", __func__);
+
+	iowrite8(TIMBUART_CTRL_FLSHRX, port->membase + TIMBUART_CTRL);
+	iowrite8(0xff, port->membase + TIMBUART_ISR);
+	/* Enable all but TX interrupts */
+	iowrite8(RXBAF | RXBF | RXTT | CTS_DELTA,
+		port->membase + TIMBUART_IER);
+
+	return request_irq(port->irq, timbuart_handleinterrupt, IRQF_SHARED,
+		"timb-uart", uart);
+}
+
+static void timbuart_shutdown(struct uart_port *port)
+{
+	struct timbuart_port *uart =
+		container_of(port, struct timbuart_port, port);
+	dev_dbg(port->dev, "%s\n", __func__);
+	free_irq(port->irq, uart);
+	iowrite8(0, port->membase + TIMBUART_IER);
+}
+
+static int get_bindex(int baud)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(baudrates); i++)
+		if (baud == baudrates[i])
+			return i;
+
+	return -1;
+}
+
+static void timbuart_set_termios(struct uart_port *port,
+	struct ktermios *termios,
+	struct ktermios *old)
+{
+	unsigned int baud;
+	short bindex;
+	unsigned long flags;
+
+	baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16);
+	bindex = get_bindex(baud);
+	dev_dbg(port->dev, "%s - bindex %d\n", __func__, bindex);
+
+	if (bindex < 0) {
+		printk(KERN_ALERT "timbuart: Unsupported baud rate\n");
+	} else {
+		spin_lock_irqsave(&port->lock, flags);
+		iowrite8((u8)bindex, port->membase + TIMBUART_BAUDRATE);
+		uart_update_timeout(port, termios->c_cflag, baud);
+		spin_unlock_irqrestore(&port->lock, flags);
+	}
+}
+
+static const char *timbuart_type(struct uart_port *port)
+{
+	return port->type == PORT_UNKNOWN ? "timbuart" : NULL;
+}
+
+/* We do not request/release mappings of the registers here,
+ * currently it's done in the proble function.
+ */
+static void timbuart_release_port(struct uart_port *port)
+{
+	struct platform_device *pdev = to_platform_device(port->dev);
+	int size =
+		resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
+
+	if (port->flags & UPF_IOREMAP) {
+		iounmap(port->membase);
+		port->membase = NULL;
+	}
+
+	release_mem_region(port->mapbase, size);
+}
+
+static int timbuart_request_port(struct uart_port *port)
+{
+	struct platform_device *pdev = to_platform_device(port->dev);
+	int size =
+		resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0));
+
+	if (!request_mem_region(port->mapbase, size, "timb-uart"))
+		return -EBUSY;
+
+	if (port->flags & UPF_IOREMAP) {
+		port->membase = ioremap(port->mapbase, size);
+		if (port->membase == NULL) {
+			release_mem_region(port->mapbase, size);
+			return -ENOMEM;
+		}
+	}
+
+	return 0;
+}
+
+static irqreturn_t timbuart_handleinterrupt(int irq, void *devid)
+{
+	struct timbuart_port *uart = (struct timbuart_port *)devid;
+
+	uart->last_ier = ioread8(uart->port.membase + TIMBUART_IER);
+
+	/* disable interrupts, let the tasklet enable them again if needed */
+	iowrite8(0, uart->port.membase + TIMBUART_IER);
+
+	/* fire off bottom half */
+	tasklet_schedule(&uart->tasklet);
+
+	return IRQ_HANDLED;
+}
+
+/*
+ * Configure/autoconfigure the port.
+ */
+static void timbuart_config_port(struct uart_port *port, int flags)
+{
+	if (flags & UART_CONFIG_TYPE) {
+		port->type = PORT_TIMBUART;
+		timbuart_request_port(port);
+	}
+}
+
+static int timbuart_verify_port(struct uart_port *port,
+	struct serial_struct *ser)
+{
+	/* we don't want the core code to modify any port params */
+	return -EINVAL;
+}
+
+static struct uart_ops timbuart_ops = {
+	.tx_empty = timbuart_tx_empty,
+	.set_mctrl = timbuart_set_mctrl,
+	.get_mctrl = timbuart_get_mctrl,
+	.stop_tx = timbuart_stop_tx,
+	.start_tx = timbuart_start_tx,
+	.flush_buffer = timbuart_flush_buffer,
+	.stop_rx = timbuart_stop_rx,
+	.enable_ms = timbuart_enable_ms,
+	.break_ctl = timbuart_break_ctl,
+	.startup = timbuart_startup,
+	.shutdown = timbuart_shutdown,
+	.set_termios = timbuart_set_termios,
+	.type = timbuart_type,
+	.release_port = timbuart_release_port,
+	.request_port = timbuart_request_port,
+	.config_port = timbuart_config_port,
+	.verify_port = timbuart_verify_port
+};
+
+static struct uart_driver timbuart_driver = {
+	.owner = THIS_MODULE,
+	.driver_name = "timberdale_uart",
+	.dev_name = "ttyTU",
+	.major = TIMBUART_MAJOR,
+	.minor = TIMBUART_MINOR,
+	.nr = 1
+};
+
+static int timbuart_probe(struct platform_device *dev)
+{
+	int err;
+	struct timbuart_port *uart;
+	struct resource *iomem;
+
+	dev_dbg(&dev->dev, "%s\n", __func__);
+
+	uart = kzalloc(sizeof(*uart), GFP_KERNEL);
+	if (!uart) {
+		err = -EINVAL;
+		goto err_mem;
+	}
+
+	uart->usedma = 0;
+
+	uart->port.uartclk = 3250000 * 16;
+	uart->port.fifosize  = TIMBUART_FIFO_SIZE;
+	uart->port.regshift  = 2;
+	uart->port.iotype  = UPIO_MEM;
+	uart->port.ops = &timbuart_ops;
+	uart->port.irq = 0;
+	uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP;
+	uart->port.line  = 0;
+	uart->port.dev	= &dev->dev;
+
+	iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (!iomem) {
+		err = -ENOMEM;
+		goto err_register;
+	}
+	uart->port.mapbase = iomem->start;
+	uart->port.membase = NULL;
+
+	uart->port.irq = platform_get_irq(dev, 0);
+	if (uart->port.irq < 0) {
+		err = -EINVAL;
+		goto err_register;
+	}
+
+	tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart);
+
+	err = uart_register_driver(&timbuart_driver);
+	if (err)
+		goto err_register;
+
+	err = uart_add_one_port(&timbuart_driver, &uart->port);
+	if (err)
+		goto err_add_port;
+
+	platform_set_drvdata(dev, uart);
+
+	return 0;
+
+err_add_port:
+	uart_unregister_driver(&timbuart_driver);
+err_register:
+	kfree(uart);
+err_mem:
+	printk(KERN_ERR "timberdale: Failed to register Timberdale UART: %d\n",
+		err);
+
+	return err;
+}
+
+static int timbuart_remove(struct platform_device *dev)
+{
+	struct timbuart_port *uart = platform_get_drvdata(dev);
+
+	tasklet_kill(&uart->tasklet);
+	uart_remove_one_port(&timbuart_driver, &uart->port);
+	uart_unregister_driver(&timbuart_driver);
+	kfree(uart);
+
+	return 0;
+}
+
+static struct platform_driver timbuart_platform_driver = {
+	.driver = {
+		.name	= "timb-uart",
+		.owner	= THIS_MODULE,
+	},
+	.probe		= timbuart_probe,
+	.remove		= timbuart_remove,
+};
+
+/*--------------------------------------------------------------------------*/
+
+static int __init timbuart_init(void)
+{
+	return platform_driver_register(&timbuart_platform_driver);
+}
+
+static void __exit timbuart_exit(void)
+{
+	platform_driver_unregister(&timbuart_platform_driver);
+}
+
+module_init(timbuart_init);
+module_exit(timbuart_exit);
+
+MODULE_DESCRIPTION("Timberdale UART driver");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:timb-uart");
+
diff -uNr linux-2.6.29-clean/drivers/serial/timbuart.h linux-2.6.29/drivers/serial/timbuart.h
--- linux-2.6.29-clean/drivers/serial/timbuart.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/serial/timbuart.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,57 @@
+/*
+ * timbuart.c timberdale FPGA GPIO driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA UART
+ */
+
+#ifndef _TIMBUART_H
+#define _TIMBUART_H
+
+#define TIMBUART_FIFO_SIZE	2048
+
+#define TIMBUART_RXFIFO		0x08
+#define TIMBUART_TXFIFO		0x0c
+#define TIMBUART_IER		0x10
+#define TIMBUART_IPR		0x14
+#define TIMBUART_ISR		0x18
+#define TIMBUART_CTRL		0x1c
+#define TIMBUART_BAUDRATE	0x20
+
+#define TIMBUART_CTRL_RTS	0x01
+#define TIMBUART_CTRL_CTS	0x02
+#define TIMBUART_CTRL_FLSHTX	0x40
+#define TIMBUART_CTRL_FLSHRX	0x80
+
+#define TXBF		0x01
+#define TXBAE		0x02
+#define CTS_DELTA	0x04
+#define RXDP		0x08
+#define RXBAF		0x10
+#define RXBF		0x20
+#define RXTT		0x40
+#define RXBNAE		0x80
+
+#define RXFLAGS (RXDP | RXBAF | RXBF | RXTT | RXBNAE)
+#define TXFLAGS (TXBF | TXBAE)
+
+#define TIMBUART_MAJOR 204
+#define TIMBUART_MINOR 192
+
+#endif /* _TIMBUART_H */
+
diff -uNr linux-2.6.29-clean/drivers/spi/Kconfig linux-2.6.29/drivers/spi/Kconfig
--- linux-2.6.29-clean/drivers/spi/Kconfig	2009-04-01 09:20:25.000000000 -0700
+++ linux-2.6.29/drivers/spi/Kconfig	2009-04-06 13:51:47.000000000 -0700
@@ -211,8 +211,8 @@
 	  SPI driver for Toshiba TXx9 MIPS SoCs
 
 config SPI_XILINX
-	tristate "Xilinx SPI controller"
-	depends on XILINX_VIRTEX && EXPERIMENTAL
+	tristate "Xilinx SPI controller common module"
+	depends on EXPERIMENTAL
 	select SPI_BITBANG
 	help
 	  This exposes the SPI controller IP from the Xilinx EDK.
@@ -220,6 +220,25 @@
 	  See the "OPB Serial Peripheral Interface (SPI) (v1.00e)"
 	  Product Specification document (DS464) for hardware details.
 
+config SPI_XILINX_OF
+	tristate "Xilinx SPI controller OF device"
+	depends on SPI_XILINX && XILINX_VIRTEX
+	help
+	  This exposes the SPI controller IP from the Xilinx EDK.
+
+	  See the "OPB Serial Peripheral Interface (SPI) (v1.00e)"
+	  Product Specification document (DS464) for hardware details.
+
+config SPI_XILINX_PLTFM
+	tristate "Xilinx SPI controller platform device"
+	depends on SPI_XILINX
+	help
+	  This exposes the SPI controller IP from the Xilinx EDK.
+
+	  See the "OPB Serial Peripheral Interface (SPI) (v1.00e)"
+	  Product Specification document (DS464) for hardware details.
+
+
 #
 # Add new SPI master controllers in alphabetical order above this line
 #
diff -uNr linux-2.6.29-clean/drivers/spi/Makefile linux-2.6.29/drivers/spi/Makefile
--- linux-2.6.29-clean/drivers/spi/Makefile	2009-04-01 09:20:25.000000000 -0700
+++ linux-2.6.29/drivers/spi/Makefile	2009-04-06 13:51:47.000000000 -0700
@@ -29,6 +29,8 @@
 obj-$(CONFIG_SPI_S3C24XX)		+= spi_s3c24xx.o
 obj-$(CONFIG_SPI_TXX9)			+= spi_txx9.o
 obj-$(CONFIG_SPI_XILINX)		+= xilinx_spi.o
+obj-$(CONFIG_SPI_XILINX_OF)		+= xilinx_spi_of.o
+obj-$(CONFIG_SPI_XILINX_PLTFM)		+= xilinx_spi_pltfm.o
 obj-$(CONFIG_SPI_SH_SCI)		+= spi_sh_sci.o
 # 	... add above this line ...
 
diff -uNr linux-2.6.29-clean/drivers/spi/xilinx_spi.c linux-2.6.29/drivers/spi/xilinx_spi.c
--- linux-2.6.29-clean/drivers/spi/xilinx_spi.c	2009-04-01 09:20:25.000000000 -0700
+++ linux-2.6.29/drivers/spi/xilinx_spi.c	2009-04-06 13:51:47.000000000 -0700
@@ -14,22 +14,28 @@
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/interrupt.h>
-#include <linux/platform_device.h>
-
-#include <linux/of_platform.h>
-#include <linux/of_device.h>
-#include <linux/of_spi.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 #include <linux/io.h>
 
-#define XILINX_SPI_NAME "xilinx_spi"
+#include "xilinx_spi.h"
+
+#ifndef CONFIG_PPC
+#define in_8(addr) ioread8(addr)
+#define in_be16(addr) ioread16(addr)
+#define in_be32(addr) ioread32(addr)
+
+#define out_8(addr, b) iowrite8(b, addr)
+#define out_be16(addr, w) iowrite16(w, addr)
+#define out_be32(addr, l) iowrite32(l, addr)
+#endif
+
 
 /* Register definitions as per "OPB Serial Peripheral Interface (SPI) (v1.00e)
  * Product Specification", DS464
  */
-#define XSPI_CR_OFFSET		0x62	/* 16-bit Control Register */
+#define XSPI_CR_OFFSET_DEF	0x62	/* 16-bit Control Register */
 
 #define XSPI_CR_ENABLE		0x02
 #define XSPI_CR_MASTER_MODE	0x04
@@ -41,7 +47,7 @@
 #define XSPI_CR_MANUAL_SSELECT	0x80
 #define XSPI_CR_TRANS_INHIBIT	0x100
 
-#define XSPI_SR_OFFSET		0x67	/* 8-bit Status Register */
+#define XSPI_SR_OFFSET_DEF	0x67	/* 8-bit Status Register */
 
 #define XSPI_SR_RX_EMPTY_MASK	0x01	/* Receive FIFO is empty */
 #define XSPI_SR_RX_FULL_MASK	0x02	/* Receive FIFO is full */
@@ -49,10 +55,10 @@
 #define XSPI_SR_TX_FULL_MASK	0x08	/* Transmit FIFO is full */
 #define XSPI_SR_MODE_FAULT_MASK	0x10	/* Mode fault error */
 
-#define XSPI_TXD_OFFSET		0x6b	/* 8-bit Data Transmit Register */
-#define XSPI_RXD_OFFSET		0x6f	/* 8-bit Data Receive Register */
+#define XSPI_TXD_OFFSET_DEF	0x6b	/* 8-bit Data Transmit Register */
+#define XSPI_RXD_OFFSET_DEF	0x6f	/* 8-bit Data Receive Register */
 
-#define XSPI_SSR_OFFSET		0x70	/* 32-bit Slave Select Register */
+#define XSPI_SSR_OFFSET_DEF	0x70	/* 32-bit Slave Select Register */
 
 /* Register definitions as per "OPB IPIF (v3.01c) Product Specification", DS414
  * IPIF registers are 32 bit
@@ -74,24 +80,10 @@
 #define XIPIF_V123B_RESETR_OFFSET	0x40	/* IPIF reset register */
 #define XIPIF_V123B_RESET_MASK		0x0a	/* the value to write */
 
-struct xilinx_spi {
-	/* bitbang has to be first */
-	struct spi_bitbang bitbang;
-	struct completion done;
-
-	void __iomem	*regs;	/* virt. address of the control registers */
-
-	u32		irq;
-
-	u32		speed_hz; /* SCK has a fixed frequency of speed_hz Hz */
-
-	u8 *rx_ptr;		/* pointer in the Tx buffer */
-	const u8 *tx_ptr;	/* pointer in the Rx buffer */
-	int remaining_bytes;	/* the number of bytes left to transfer */
-};
 
-static void xspi_init_hw(void __iomem *regs_base)
+void xspi_init_hw(struct xilinx_spi *xspi)
 {
+	void __iomem *regs_base = xspi->regs;
 	/* Reset the SPI device */
 	out_be32(regs_base + XIPIF_V123B_RESETR_OFFSET,
 		 XIPIF_V123B_RESET_MASK);
@@ -101,30 +93,31 @@
 	out_be32(regs_base + XIPIF_V123B_DGIER_OFFSET,
 		 XIPIF_V123B_GINTR_ENABLE);
 	/* Deselect the slave on the SPI bus */
-	out_be32(regs_base + XSPI_SSR_OFFSET, 0xffff);
+	out_be32(regs_base + xspi->ssr_offset, 0xffff);
 	/* Disable the transmitter, enable Manual Slave Select Assertion,
 	 * put SPI controller into master mode, and enable it */
-	out_be16(regs_base + XSPI_CR_OFFSET,
+	out_be16(regs_base + xspi->cr_offset,
 		 XSPI_CR_TRANS_INHIBIT | XSPI_CR_MANUAL_SSELECT
 		 | XSPI_CR_MASTER_MODE | XSPI_CR_ENABLE);
 }
+EXPORT_SYMBOL(xspi_init_hw);
 
-static void xilinx_spi_chipselect(struct spi_device *spi, int is_on)
+void xilinx_spi_chipselect(struct spi_device *spi, int is_on)
 {
 	struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
 
 	if (is_on == BITBANG_CS_INACTIVE) {
 		/* Deselect the slave on the SPI bus */
-		out_be32(xspi->regs + XSPI_SSR_OFFSET, 0xffff);
+		out_be32(xspi->regs + xspi->ssr_offset, 0xffff);
 	} else if (is_on == BITBANG_CS_ACTIVE) {
 		/* Set the SPI clock phase and polarity */
-		u16 cr = in_be16(xspi->regs + XSPI_CR_OFFSET)
+		u16 cr = in_be16(xspi->regs + xspi->cr_offset)
 			 & ~XSPI_CR_MODE_MASK;
 		if (spi->mode & SPI_CPHA)
 			cr |= XSPI_CR_CPHA;
 		if (spi->mode & SPI_CPOL)
 			cr |= XSPI_CR_CPOL;
-		out_be16(xspi->regs + XSPI_CR_OFFSET, cr);
+		out_be16(xspi->regs + xspi->cr_offset, cr);
 
 		/* We do not check spi->max_speed_hz here as the SPI clock
 		 * frequency is not software programmable (the IP block design
@@ -132,10 +125,11 @@
 		 */
 
 		/* Activate the chip select */
-		out_be32(xspi->regs + XSPI_SSR_OFFSET,
+		out_be32(xspi->regs + xspi->ssr_offset,
 			 ~(0x0001 << spi->chip_select));
 	}
 }
+EXPORT_SYMBOL(xilinx_spi_chipselect);
 
 /* spi_bitbang requires custom setup_transfer() to be defined if there is a
  * custom txrx_bufs(). We have nothing to setup here as the SPI IP block
@@ -143,8 +137,7 @@
  * Check for 8 bits per word. Chip select delay calculations could be
  * added here as soon as bitbang_work() can be made aware of the delay value.
  */
-static int xilinx_spi_setup_transfer(struct spi_device *spi,
-		struct spi_transfer *t)
+int xilinx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
 {
 	u8 bits_per_word;
 
@@ -157,11 +150,12 @@
 
 	return 0;
 }
+EXPORT_SYMBOL(xilinx_spi_setup_transfer);
 
 /* the spi->mode bits understood by this driver: */
 #define MODEBITS (SPI_CPOL | SPI_CPHA)
 
-static int xilinx_spi_setup(struct spi_device *spi)
+int xilinx_spi_setup(struct spi_device *spi)
 {
 	struct spi_bitbang *bitbang;
 	struct xilinx_spi *xspi;
@@ -188,25 +182,25 @@
 
 	return 0;
 }
+EXPORT_SYMBOL(xilinx_spi_setup);
 
 static void xilinx_spi_fill_tx_fifo(struct xilinx_spi *xspi)
 {
 	u8 sr;
 
 	/* Fill the Tx FIFO with as many bytes as possible */
-	sr = in_8(xspi->regs + XSPI_SR_OFFSET);
+	sr = in_8(xspi->regs + xspi->sr_offset);
 	while ((sr & XSPI_SR_TX_FULL_MASK) == 0 && xspi->remaining_bytes > 0) {
-		if (xspi->tx_ptr) {
-			out_8(xspi->regs + XSPI_TXD_OFFSET, *xspi->tx_ptr++);
-		} else {
-			out_8(xspi->regs + XSPI_TXD_OFFSET, 0);
-		}
+		if (xspi->tx_ptr)
+			out_8(xspi->regs + xspi->txd_offset, *xspi->tx_ptr++);
+		else
+			out_8(xspi->regs + xspi->txd_offset, 0);
 		xspi->remaining_bytes--;
-		sr = in_8(xspi->regs + XSPI_SR_OFFSET);
+		sr = in_8(xspi->regs + xspi->sr_offset);
 	}
 }
 
-static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
+int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
 {
 	struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
 	u32 ipif_ier;
@@ -229,8 +223,8 @@
 		 ipif_ier | XSPI_INTR_TX_EMPTY);
 
 	/* Start the transfer by not inhibiting the transmitter any longer */
-	cr = in_be16(xspi->regs + XSPI_CR_OFFSET) & ~XSPI_CR_TRANS_INHIBIT;
-	out_be16(xspi->regs + XSPI_CR_OFFSET, cr);
+	cr = in_be16(xspi->regs + xspi->cr_offset) & ~XSPI_CR_TRANS_INHIBIT;
+	out_be16(xspi->regs + xspi->cr_offset, cr);
 
 	wait_for_completion(&xspi->done);
 
@@ -239,14 +233,14 @@
 
 	return t->len - xspi->remaining_bytes;
 }
-
+EXPORT_SYMBOL(xilinx_spi_txrx_bufs);
 
 /* This driver supports single master mode only. Hence Tx FIFO Empty
  * is the only interrupt we care about.
  * Receive FIFO Overrun, Transmit FIFO Underrun, Mode Fault, and Slave Mode
  * Fault are not to happen.
  */
-static irqreturn_t xilinx_spi_irq(int irq, void *dev_id)
+irqreturn_t xilinx_spi_irq(int irq, void *dev_id)
 {
 	struct xilinx_spi *xspi = dev_id;
 	u32 ipif_isr;
@@ -264,20 +258,19 @@
 		 * transmitter while the Isr refills the transmit register/FIFO,
 		 * or make sure it is stopped if we're done.
 		 */
-		cr = in_be16(xspi->regs + XSPI_CR_OFFSET);
-		out_be16(xspi->regs + XSPI_CR_OFFSET,
+		cr = in_be16(xspi->regs + xspi->cr_offset);
+		out_be16(xspi->regs + xspi->cr_offset,
 			 cr | XSPI_CR_TRANS_INHIBIT);
 
 		/* Read out all the data from the Rx FIFO */
-		sr = in_8(xspi->regs + XSPI_SR_OFFSET);
+		sr = in_8(xspi->regs + xspi->sr_offset);
 		while ((sr & XSPI_SR_RX_EMPTY_MASK) == 0) {
 			u8 data;
 
-			data = in_8(xspi->regs + XSPI_RXD_OFFSET);
-			if (xspi->rx_ptr) {
+			data = in_8(xspi->regs + xspi->rxd_offset);
+			if (xspi->rx_ptr)
 				*xspi->rx_ptr++ = data;
-			}
-			sr = in_8(xspi->regs + XSPI_SR_OFFSET);
+			sr = in_8(xspi->regs + xspi->sr_offset);
 		}
 
 		/* See if there is more data to send */
@@ -286,7 +279,7 @@
 			/* Start the transfer by not inhibiting the
 			 * transmitter any longer
 			 */
-			out_be16(xspi->regs + XSPI_CR_OFFSET, cr);
+			out_be16(xspi->regs + xspi->cr_offset, cr);
 		} else {
 			/* No more data to send.
 			 * Indicate the transfer is completed.
@@ -297,167 +290,18 @@
 
 	return IRQ_HANDLED;
 }
+EXPORT_SYMBOL(xilinx_spi_irq);
 
-static int __init xilinx_spi_of_probe(struct of_device *ofdev,
-					const struct of_device_id *match)
-{
-	struct spi_master *master;
-	struct xilinx_spi *xspi;
-	struct resource r_irq_struct;
-	struct resource r_mem_struct;
-
-	struct resource *r_irq = &r_irq_struct;
-	struct resource *r_mem = &r_mem_struct;
-	int rc = 0;
-	const u32 *prop;
-	int len;
-
-	/* Get resources(memory, IRQ) associated with the device */
-	master = spi_alloc_master(&ofdev->dev, sizeof(struct xilinx_spi));
-
-	if (master == NULL) {
-		return -ENOMEM;
-	}
-
-	dev_set_drvdata(&ofdev->dev, master);
-
-	rc = of_address_to_resource(ofdev->node, 0, r_mem);
-	if (rc) {
-		dev_warn(&ofdev->dev, "invalid address\n");
-		goto put_master;
-	}
-
-	rc = of_irq_to_resource(ofdev->node, 0, r_irq);
-	if (rc == NO_IRQ) {
-		dev_warn(&ofdev->dev, "no IRQ found\n");
-		goto put_master;
-	}
-
-	xspi = spi_master_get_devdata(master);
-	xspi->bitbang.master = spi_master_get(master);
-	xspi->bitbang.chipselect = xilinx_spi_chipselect;
-	xspi->bitbang.setup_transfer = xilinx_spi_setup_transfer;
-	xspi->bitbang.txrx_bufs = xilinx_spi_txrx_bufs;
-	xspi->bitbang.master->setup = xilinx_spi_setup;
-	init_completion(&xspi->done);
-
-	xspi->irq = r_irq->start;
-
-	if (!request_mem_region(r_mem->start,
-			r_mem->end - r_mem->start + 1, XILINX_SPI_NAME)) {
-		rc = -ENXIO;
-		dev_warn(&ofdev->dev, "memory request failure\n");
-		goto put_master;
-	}
-
-	xspi->regs = ioremap(r_mem->start, r_mem->end - r_mem->start + 1);
-	if (xspi->regs == NULL) {
-		rc = -ENOMEM;
-		dev_warn(&ofdev->dev, "ioremap failure\n");
-		goto put_master;
-	}
-	xspi->irq = r_irq->start;
-
-	/* dynamic bus assignment */
-	master->bus_num = -1;
-
-	/* number of slave select bits is required */
-	prop = of_get_property(ofdev->node, "xlnx,num-ss-bits", &len);
-	if (!prop || len < sizeof(*prop)) {
-		dev_warn(&ofdev->dev, "no 'xlnx,num-ss-bits' property\n");
-		goto put_master;
-	}
-	master->num_chipselect = *prop;
-
-	/* SPI controller initializations */
-	xspi_init_hw(xspi->regs);
-
-	/* Register for SPI Interrupt */
-	rc = request_irq(xspi->irq, xilinx_spi_irq, 0, XILINX_SPI_NAME, xspi);
-	if (rc != 0) {
-		dev_warn(&ofdev->dev, "irq request failure: %d\n", xspi->irq);
-		goto unmap_io;
-	}
-
-	rc = spi_bitbang_start(&xspi->bitbang);
-	if (rc != 0) {
-		dev_err(&ofdev->dev, "spi_bitbang_start FAILED\n");
-		goto free_irq;
-	}
-
-	dev_info(&ofdev->dev, "at 0x%08X mapped to 0x%08X, irq=%d\n",
-			(unsigned int)r_mem->start, (u32)xspi->regs, xspi->irq);
-
-	/* Add any subnodes on the SPI bus */
-	of_register_spi_devices(master, ofdev->node);
-
-	return rc;
-
-free_irq:
-	free_irq(xspi->irq, xspi);
-unmap_io:
-	iounmap(xspi->regs);
-put_master:
-	spi_master_put(master);
-	return rc;
-}
-
-static int __devexit xilinx_spi_remove(struct of_device *ofdev)
+void xilinx_spi_set_default_reg_offsets(struct xilinx_spi *xspi)
 {
-	struct xilinx_spi *xspi;
-	struct spi_master *master;
-
-	master = platform_get_drvdata(ofdev);
-	xspi = spi_master_get_devdata(master);
-
-	spi_bitbang_stop(&xspi->bitbang);
-	free_irq(xspi->irq, xspi);
-	iounmap(xspi->regs);
-	dev_set_drvdata(&ofdev->dev, 0);
-	spi_master_put(xspi->bitbang.master);
-
-	return 0;
-}
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:" XILINX_SPI_NAME);
-
-static int __exit xilinx_spi_of_remove(struct of_device *op)
-{
-	return xilinx_spi_remove(op);
+	xspi->cr_offset = XSPI_CR_OFFSET_DEF;
+	xspi->sr_offset = XSPI_SR_OFFSET_DEF;
+	xspi->txd_offset = XSPI_TXD_OFFSET_DEF;
+	xspi->rxd_offset = XSPI_RXD_OFFSET_DEF;
+	xspi->ssr_offset = XSPI_SSR_OFFSET_DEF;
 }
+EXPORT_SYMBOL(xilinx_spi_set_default_reg_offsets);
 
-static struct of_device_id xilinx_spi_of_match[] = {
-	{ .compatible = "xlnx,xps-spi-2.00.a", },
-	{ .compatible = "xlnx,xps-spi-2.00.b", },
-	{}
-};
-
-MODULE_DEVICE_TABLE(of, xilinx_spi_of_match);
-
-static struct of_platform_driver xilinx_spi_of_driver = {
-	.owner = THIS_MODULE,
-	.name = "xilinx-xps-spi",
-	.match_table = xilinx_spi_of_match,
-	.probe = xilinx_spi_of_probe,
-	.remove = __exit_p(xilinx_spi_of_remove),
-	.driver = {
-		.name = "xilinx-xps-spi",
-		.owner = THIS_MODULE,
-	},
-};
-
-static int __init xilinx_spi_init(void)
-{
-	return of_register_platform_driver(&xilinx_spi_of_driver);
-}
-module_init(xilinx_spi_init);
-
-static void __exit xilinx_spi_exit(void)
-{
-	of_unregister_platform_driver(&xilinx_spi_of_driver);
-}
-module_exit(xilinx_spi_exit);
 MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
 MODULE_DESCRIPTION("Xilinx SPI driver");
 MODULE_LICENSE("GPL");
diff -uNr linux-2.6.29-clean/drivers/spi/xilinx_spi.h linux-2.6.29/drivers/spi/xilinx_spi.h
--- linux-2.6.29-clean/drivers/spi/xilinx_spi.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/spi/xilinx_spi.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,52 @@
+/*
+ * xilinx_spi.c
+ *
+ * Xilinx SPI controller driver (master mode only)
+ *
+ * Author: MontaVista Software, Inc.
+ *	source@mvista.com
+ *
+ * 2002-2007 (c) MontaVista Software, Inc.  This file is licensed under the
+ * terms of the GNU General Public License version 2.  This program is licensed
+ * "as is" without any warranty of any kind, whether express or implied.
+ */
+
+#ifndef _XILINX_SPI_H_
+#define _XILINX_SPI_H_ 1
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+
+#define XILINX_SPI_NAME "xilinx_spi"
+
+
+struct xilinx_spi {
+	/* bitbang has to be first */
+	struct spi_bitbang bitbang;
+	struct completion done;
+
+	void __iomem	*regs;	/* virt. address of the control registers */
+
+	u32		irq;
+
+	u32		speed_hz; /* SCK has a fixed frequency of speed_hz Hz */
+
+	u8 *rx_ptr;		/* pointer in the Tx buffer */
+	const u8 *tx_ptr;	/* pointer in the Rx buffer */
+	int remaining_bytes;	/* the number of bytes left to transfer */
+	/* offset to the XSPI regs, these might vary... */
+	u8 cr_offset;
+	u8 sr_offset;
+	u8 txd_offset;
+	u8 rxd_offset;
+	u8 ssr_offset;
+};
+
+void xspi_init_hw(struct xilinx_spi *xspi);
+void xilinx_spi_set_default_reg_offsets(struct xilinx_spi *xspi);
+void xilinx_spi_chipselect(struct spi_device *spi, int is_on);
+int xilinx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t);
+int xilinx_spi_setup(struct spi_device *spi);
+int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t);
+irqreturn_t xilinx_spi_irq(int irq, void *dev_id);
+#endif
diff -uNr linux-2.6.29-clean/drivers/spi/xilinx_spi_of.c linux-2.6.29/drivers/spi/xilinx_spi_of.c
--- linux-2.6.29-clean/drivers/spi/xilinx_spi_of.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/spi/xilinx_spi_of.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,193 @@
+/*
+ * xilinx_spi.c
+ *
+ * Xilinx SPI controller driver (master mode only)
+ *
+ * Author: MontaVista Software, Inc.
+ *	source@mvista.com
+ *
+ * 2002-2007 (c) MontaVista Software, Inc.  This file is licensed under the
+ * terms of the GNU General Public License version 2.  This program is licensed
+ * "as is" without any warranty of any kind, whether express or implied.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include <linux/of_platform.h>
+#include <linux/of_device.h>
+#include <linux/of_spi.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+
+#include "xilinx_spi.h"
+
+
+static int __init xilinx_spi_of_probe(struct of_device *ofdev,
+					const struct of_device_id *match)
+{
+	struct spi_master *master;
+	struct xilinx_spi *xspi;
+	struct resource r_irq_struct;
+	struct resource r_mem_struct;
+
+	struct resource *r_irq = &r_irq_struct;
+	struct resource *r_mem = &r_mem_struct;
+	int rc = 0;
+	const u32 *prop;
+	int len;
+
+	/* Get resources(memory, IRQ) associated with the device */
+	master = spi_alloc_master(&ofdev->dev, sizeof(struct xilinx_spi));
+
+	if (master == NULL)
+		return -ENOMEM;
+
+	dev_set_drvdata(&ofdev->dev, master);
+
+	rc = of_address_to_resource(ofdev->node, 0, r_mem);
+	if (rc) {
+		dev_warn(&ofdev->dev, "invalid address\n");
+		goto put_master;
+	}
+
+	rc = of_irq_to_resource(ofdev->node, 0, r_irq);
+	if (rc == NO_IRQ) {
+		dev_warn(&ofdev->dev, "no IRQ found\n");
+		goto put_master;
+	}
+
+	xspi = spi_master_get_devdata(master);
+	xspi->bitbang.master = spi_master_get(master);
+	xspi->bitbang.chipselect = xilinx_spi_chipselect;
+	xspi->bitbang.setup_transfer = xilinx_spi_setup_transfer;
+	xspi->bitbang.txrx_bufs = xilinx_spi_txrx_bufs;
+	xspi->bitbang.master->setup = xilinx_spi_setup;
+	init_completion(&xspi->done);
+
+	xspi->irq = r_irq->start;
+
+	if (!request_mem_region(r_mem->start,
+			r_mem->end - r_mem->start + 1, XILINX_SPI_NAME)) {
+		rc = -ENXIO;
+		dev_warn(&ofdev->dev, "memory request failure\n");
+		goto put_master;
+	}
+
+	xspi->regs = ioremap(r_mem->start, r_mem->end - r_mem->start + 1);
+	if (xspi->regs == NULL) {
+		rc = -ENOMEM;
+		dev_warn(&ofdev->dev, "ioremap failure\n");
+		goto put_master;
+	}
+	xspi->irq = r_irq->start;
+
+	/* dynamic bus assignment */
+	master->bus_num = -1;
+
+	/* number of slave select bits is required */
+	prop = of_get_property(ofdev->node, "xlnx,num-ss-bits", &len);
+	if (!prop || len < sizeof(*prop)) {
+		dev_warn(&ofdev->dev, "no 'xlnx,num-ss-bits' property\n");
+		goto put_master;
+	}
+	master->num_chipselect = *prop;
+
+	xilinx_spi_set_default_reg_offsets(xspi);
+
+	/* SPI controller initializations */
+	xspi_init_hw(xspi->regs);
+
+	/* Register for SPI Interrupt */
+	rc = request_irq(xspi->irq, xilinx_spi_irq, 0, XILINX_SPI_NAME, xspi);
+	if (rc != 0) {
+		dev_warn(&ofdev->dev, "irq request failure: %d\n", xspi->irq);
+		goto unmap_io;
+	}
+
+	rc = spi_bitbang_start(&xspi->bitbang);
+	if (rc != 0) {
+		dev_err(&ofdev->dev, "spi_bitbang_start FAILED\n");
+		goto free_irq;
+	}
+
+	dev_info(&ofdev->dev, "at 0x%08X mapped to 0x%08X, irq=%d\n",
+			(unsigned int)r_mem->start, (u32)xspi->regs, xspi->irq);
+
+	/* Add any subnodes on the SPI bus */
+	of_register_spi_devices(master, ofdev->node);
+
+	return rc;
+
+free_irq:
+	free_irq(xspi->irq, xspi);
+unmap_io:
+	iounmap(xspi->regs);
+put_master:
+	spi_master_put(master);
+	return rc;
+}
+
+static int __devexit xilinx_spi_remove(struct of_device *ofdev)
+{
+	struct xilinx_spi *xspi;
+	struct spi_master *master;
+
+	master = platform_get_drvdata(ofdev);
+	xspi = spi_master_get_devdata(master);
+
+	spi_bitbang_stop(&xspi->bitbang);
+	free_irq(xspi->irq, xspi);
+	iounmap(xspi->regs);
+	dev_set_drvdata(&ofdev->dev, 0);
+	spi_master_put(xspi->bitbang.master);
+
+	return 0;
+}
+
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:" XILINX_SPI_NAME);
+
+static int __exit xilinx_spi_of_remove(struct of_device *op)
+{
+	return xilinx_spi_remove(op);
+}
+
+static struct of_device_id xilinx_spi_of_match[] = {
+	{ .compatible = "xlnx,xps-spi-2.00.a", },
+	{ .compatible = "xlnx,xps-spi-2.00.b", },
+	{}
+};
+
+MODULE_DEVICE_TABLE(of, xilinx_spi_of_match);
+
+static struct of_platform_driver xilinx_spi_of_driver = {
+	.owner = THIS_MODULE,
+	.name = "xilinx-xps-spi",
+	.match_table = xilinx_spi_of_match,
+	.probe = xilinx_spi_of_probe,
+	.remove = __exit_p(xilinx_spi_of_remove),
+	.driver = {
+		.name = "xilinx-xps-spi",
+		.owner = THIS_MODULE,
+	},
+};
+
+static int __init xilinx_spi_init(void)
+{
+	return of_register_platform_driver(&xilinx_spi_of_driver);
+}
+module_init(xilinx_spi_init);
+
+static void __exit xilinx_spi_exit(void)
+{
+	of_unregister_platform_driver(&xilinx_spi_of_driver);
+}
+module_exit(xilinx_spi_exit);
+MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
+MODULE_DESCRIPTION("Xilinx SPI driver");
+MODULE_LICENSE("GPL");
diff -uNr linux-2.6.29-clean/drivers/spi/xilinx_spi_pltfm.c linux-2.6.29/drivers/spi/xilinx_spi_pltfm.c
--- linux-2.6.29-clean/drivers/spi/xilinx_spi_pltfm.c	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/drivers/spi/xilinx_spi_pltfm.c	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,184 @@
+/*
+ * xilinx_spi_pltfm.c Support for Xilinx SPI platform devices
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Xilinx SPI devices as platform devices
+ *
+ * Inspired by xilinx_spi.c, 2002-2007 (c) MontaVista Software, Inc.
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/platform_device.h>
+
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+#include <linux/spi/xilinx_spi.h>
+
+#include "xilinx_spi.h"
+
+static int __init xilinx_spi_probe(struct platform_device *dev)
+{
+	int ret = 0;
+	struct spi_master *master;
+	struct xilinx_spi *xspi;
+	struct xspi_platform_data *pdata;
+	struct resource *r;
+
+	master = spi_alloc_master(&dev->dev, sizeof(struct xilinx_spi));
+
+	if (master == NULL)
+		return -ENOMEM;
+
+
+	platform_set_drvdata(dev, master);
+	pdata = dev->dev.platform_data;
+	if (pdata == NULL) {
+		ret = -ENODEV;
+		goto put_master;
+	}
+
+	r = platform_get_resource(dev, IORESOURCE_MEM, 0);
+	if (r == NULL) {
+		ret = -ENODEV;
+		goto put_master;
+	}
+
+	xspi = spi_master_get_devdata(master);
+	xspi->bitbang.master = spi_master_get(master);
+	xspi->bitbang.chipselect = xilinx_spi_chipselect;
+	xspi->bitbang.setup_transfer = xilinx_spi_setup_transfer;
+	xspi->bitbang.txrx_bufs = xilinx_spi_txrx_bufs;
+	xspi->bitbang.master->setup = xilinx_spi_setup;
+	init_completion(&xspi->done);
+
+	if (!request_mem_region(r->start, resource_size(r), XILINX_SPI_NAME)) {
+		ret = -ENXIO;
+		goto put_master;
+	}
+
+	xspi->regs = ioremap(r->start, resource_size(r));
+	if (xspi->regs == NULL) {
+		ret = -ENOMEM;
+		goto map_failed;
+	}
+
+	ret = platform_get_irq(dev, 0);
+	if (ret < 0) {
+		ret = -ENXIO;
+		goto unmap_io;
+	}
+	xspi->irq = ret;
+
+	master->bus_num = pdata->bus_num;
+	master->num_chipselect = pdata->num_chipselect;
+	xspi->speed_hz = pdata->speed_hz;
+	xilinx_spi_set_default_reg_offsets(xspi);
+	if (pdata->cr_offset)
+		xspi->cr_offset = pdata->cr_offset;
+	if (pdata->sr_offset)
+		xspi->sr_offset = pdata->sr_offset;
+	if (pdata->txd_offset)
+		xspi->txd_offset = pdata->txd_offset;
+	if (pdata->rxd_offset)
+		xspi->rxd_offset = pdata->rxd_offset;
+	if (pdata->ssr_offset)
+		xspi->ssr_offset = pdata->ssr_offset;
+
+	/* SPI controller initializations */
+	xspi_init_hw(xspi);
+
+	/* Register for SPI Interrupt */
+	ret = request_irq(xspi->irq, xilinx_spi_irq, 0, XILINX_SPI_NAME, xspi);
+	if (ret != 0)
+		goto unmap_io;
+
+	ret = spi_bitbang_start(&xspi->bitbang);
+	if (ret != 0) {
+		dev_err(&dev->dev, "spi_bitbang_start FAILED\n");
+		goto free_irq;
+	}
+
+	dev_info(&dev->dev, "at 0x%08X mapped to 0x%08X, irq=%d\n",
+			(u32)r->start, (u32)xspi->regs, xspi->irq);
+	return ret;
+
+free_irq:
+	free_irq(xspi->irq, xspi);
+unmap_io:
+	iounmap(xspi->regs);
+map_failed:
+	release_mem_region(r->start, resource_size(r));
+put_master:
+	spi_master_put(master);
+	return ret;
+}
+
+static int __devexit xilinx_spi_remove(struct platform_device *dev)
+{
+	struct xilinx_spi *xspi;
+	struct spi_master *master;
+	struct resource *r;
+
+	master = platform_get_drvdata(dev);
+	xspi = spi_master_get_devdata(master);
+	r = platform_get_resource(dev, IORESOURCE_MEM, 0);
+
+	spi_bitbang_stop(&xspi->bitbang);
+	free_irq(xspi->irq, xspi);
+	iounmap(xspi->regs);
+
+	if (r)
+		release_mem_region(r->start, resource_size(r));
+
+	platform_set_drvdata(dev, 0);
+	spi_master_put(xspi->bitbang.master);
+
+	return 0;
+}
+
+/* work with hotplug and coldplug */
+MODULE_ALIAS("platform:" XILINX_SPI_NAME);
+
+static struct platform_driver xilinx_spi_driver = {
+	.probe	= xilinx_spi_probe,
+	.remove	= __devexit_p(xilinx_spi_remove),
+	.driver = {
+		.name = XILINX_SPI_NAME,
+		.owner = THIS_MODULE,
+	},
+};
+
+static int __init xilinx_spi_init(void)
+{
+	return platform_driver_register(&xilinx_spi_driver);
+}
+module_init(xilinx_spi_init);
+
+static void __exit xilinx_spi_exit(void)
+{
+	platform_driver_unregister(&xilinx_spi_driver);
+}
+module_exit(xilinx_spi_exit);
+
+MODULE_AUTHOR("Mocean Laboratories <info@mocean-labs.com>");
+MODULE_DESCRIPTION("Xilinx SPI platform driver");
+MODULE_LICENSE("GPL v2");
+
diff -uNr linux-2.6.29-clean/include/linux/i2c-ocores.h linux-2.6.29/include/linux/i2c-ocores.h
--- linux-2.6.29-clean/include/linux/i2c-ocores.h	2009-04-01 09:20:20.000000000 -0700
+++ linux-2.6.29/include/linux/i2c-ocores.h	2009-04-06 13:51:47.000000000 -0700
@@ -14,6 +14,8 @@
 struct ocores_i2c_platform_data {
 	u32 regstep;   /* distance between registers */
 	u32 clock_khz; /* input clock in kHz */
+	u8 num_devices; /* number of devices in the devices list */
+	struct i2c_board_info const *devices; /* devices connected to the bus */
 };
 
 #endif /* _LINUX_I2C_OCORES_H */
diff -uNr linux-2.6.29-clean/include/linux/mfd/timbdma.h linux-2.6.29/include/linux/mfd/timbdma.h
--- linux-2.6.29-clean/include/linux/mfd/timbdma.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/include/linux/mfd/timbdma.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,80 @@
+/*
+ * timbdma.h timberdale FPGA DMA driver defines
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA DMA engine
+ */
+
+#ifndef _TIMBDMA_H
+#define _TIMBDMA_H
+
+#include <linux/spinlock.h>
+
+
+#define DMA_IRQ_UART_RX		0x01
+#define DMA_IRQ_UART_TX		0x02
+#define DMA_IRQ_MLB_RX		0x04
+#define DMA_IRQ_MLB_TX		0x08
+#define DMA_IRQ_VIDEO_RX	0x10
+#define DMA_IRQ_VIDEO_DROP	0x20
+#define DMA_IRQS		6
+
+
+typedef int (*timbdma_interruptcb)(u32 flag, void *data);
+
+enum timbdma_ctrlmap {
+	timbdma_ctrlmap_DMACFGBTUART = 0x000000,
+	timbdma_ctrlmap_DMACFGMLBSY  = 0x000040,
+	timbdma_ctrlmap_DMACFGVIDEO  = 0x000080,
+	timbdma_ctrlmap_TIMBSTATUS   = 0x080000,
+	timbdma_ctrlmap_TIMBPEND     = 0x080004,
+	timbdma_ctrlmap_TIMBENABLE   = 0x080008,
+	timbdma_ctrlmap_VIDEOBUFFER  = 0x200000
+};
+
+enum timbdma_dmacfg {
+	timbdma_dmacfg_RXSTARTH  = 0x00,
+	timbdma_dmacfg_RXSTARTL  = 0x04,
+	timbdma_dmacfg_RXLENGTH  = 0x08,
+	timbdma_dmacfg_RXFPGAWP  = 0x0C,
+	timbdma_dmacfg_RXSWRP    = 0x10,
+	timbdma_dmacfg_RXENABLE  = 0x14,
+	timbdma_dmacfg_TXSTARTH  = 0x18,
+	timbdma_dmacfg_TXSTARTL  = 0x1C,
+	timbdma_dmacfg_TXLENGTH  = 0x20,
+	timbdma_dmacfg_TXSWWP    = 0x24,
+	timbdma_dmacfg_TXFPGARP  = 0x28,
+	timbdma_dmacfg_TXBEFINT  = 0x2C,
+	timbdma_dmacfg_BPERROW   = 0x30
+};
+
+struct timbdma_dev {
+	void __iomem		*membase;
+	timbdma_interruptcb	callbacks[DMA_IRQS];
+	void			*callback_data[DMA_IRQS];
+	spinlock_t		lock; /* mutual exclusion */
+};
+
+void timb_start_dma(u32 flag, unsigned long buf, int len, int bytes_per_row);
+
+void *timb_stop_dma(u32 flags);
+
+void timb_set_dma_interruptcb(u32 flags, timbdma_interruptcb icb, void *data);
+
+#endif /* _TIMBDMA_H */
+
diff -uNr linux-2.6.29-clean/include/linux/mfd/timbi2s.h linux-2.6.29/include/linux/mfd/timbi2s.h
--- linux-2.6.29-clean/include/linux/mfd/timbi2s.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/include/linux/mfd/timbi2s.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,66 @@
+/*
+ * timbi2s.h timberdale FPGA I2S driver
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+/* Supports:
+ * Timberdale FPGA I2S
+ */
+
+struct timbi2s_bus_control {
+	struct list_head list;
+};
+
+struct timbi2s_bus {
+	void __iomem			*membase;
+	u32				irq;
+	struct timbi2s_bus_control	*control;
+	struct workqueue_struct		*workqueue;
+	struct work_struct		work;
+};
+
+struct timbi2s_dev {
+	void __iomem			*membase;
+	u32				irq;
+	struct timbi2s_bus		*bus;
+	struct workqueue_struct		*workqueue;
+	struct work_struct		work;
+	u32				ioctrl;
+	u32				devid;
+	u8				timbi2s_rx;
+	u8				timbi2s_tx;
+	struct circ_buf			*buffer;
+	/* Register access */
+	spinlock_t			lock;
+
+	int in_use;
+	u8 pscale_offset; /* Prescale */
+	u8 icr_offset; /* Clear register */
+	u8 isr_offset; /* Status */
+	u8 ipr_offset; /* Pending register */
+	u8 ier_offset; /* Interrupt Enable register */
+	u8 ctrl_offset;
+	u8 fifo;
+
+	struct list_head item;
+};
+
+static struct timbi2s_dev *timbi2s_get_tx(void);
+static struct timbi2s_dev *timbi2s_get_rx(void);
+static void timbi2s_put(struct timbi2s_dev *tdev);
+
+static int timbi2s_ioctrl(struct timbi2s_dev *i2sdev);
+
diff -uNr linux-2.6.29-clean/include/linux/serial_core.h linux-2.6.29/include/linux/serial_core.h
--- linux-2.6.29-clean/include/linux/serial_core.h	2009-04-01 09:20:20.000000000 -0700
+++ linux-2.6.29/include/linux/serial_core.h	2009-04-06 13:51:47.000000000 -0700
@@ -164,6 +164,9 @@
 /* NWPSERIAL */
 #define PORT_NWPSERIAL	85
 
+/* Timberdale UART */
+#define PORT_TIMBUART	86
+
 #ifdef __KERNEL__
 
 #include <linux/compiler.h>
diff -uNr linux-2.6.29-clean/include/linux/spi/xilinx_spi.h linux-2.6.29/include/linux/spi/xilinx_spi.h
--- linux-2.6.29-clean/include/linux/spi/xilinx_spi.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/include/linux/spi/xilinx_spi.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,17 @@
+#ifndef __LINUX_SPI_XILINX_SPI_H
+#define __LINUX_SPI_XILINX_SPI_H
+
+/* SPI Controller IP */
+struct xspi_platform_data {
+	s16 bus_num;
+	u16 num_chipselect;
+	u32 speed_hz;
+	u8 cr_offset;
+	u8 sr_offset;
+	u8 txd_offset;
+	u8 rxd_offset;
+	u8 ssr_offset;
+};
+
+#endif /* __LINUX_SPI_XILINX_SPI_H */
+
diff -uNr linux-2.6.29-clean/include/media/adv7180.h linux-2.6.29/include/media/adv7180.h
--- linux-2.6.29-clean/include/media/adv7180.h	1969-12-31 16:00:00.000000000 -0800
+++ linux-2.6.29/include/media/adv7180.h	2009-04-06 13:51:47.000000000 -0700
@@ -0,0 +1,127 @@
+/*
+ * adv7180.h Analog Devices ADV7180 video decoder driver defines
+ * Copyright (c) 2009 Intel Corporation
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define DRIVER_NAME "adv7180"
+
+#define I2C_ADV7180	0x42
+#define ADV7180_NR_REG	0xfc
+
+#define ADV7180_IN_CTRL		0x00 /* Input CR */
+#define ADV7180_OUT_CTRL	0x03 /* Output CR */
+#define ADV7180_EXT_OUT_CTRL	0x04 /* Extended Output CR */
+
+#define ADV7180_ADI_CTRL	0x0e /* ADI CR */
+#	define ADI_ENABLE	0x20 /* Enable access to sub-regs */
+
+#define ADV7180_SR_1	0x10	/* Status Register 1 */
+#define ADV7180_SR_2	0x12
+#define ADV7180_SR_3	0x13
+
+/* Interrupt and VDP sub-registers */
+#define ADV7180_ISR_1	0x42	/* Interrupt Status Register 1 */
+#define ADV7180_ICR_1	0x43	/* Interrupt Clear Register 1 */
+
+#define ADV7180_ISR_2	0x46
+#define ADV7180_ICR_2	0x47
+
+#define ADV7180_ISR_3	0x4a
+#define ADV7180_ICR_3	0x4b
+
+#define ADV7180_ISR_4	0x4e
+#define ADV7180_ICR_4	0x4f
+/* */
+
+#define ADV7180_SR			0x10
+#define ADV7180_STATUS_NTSM		0x00 /* NTSM M/J */
+#define ADV7180_STATUS_NTSC		0x10 /* NTSC 4.43 */
+#define ADV7180_STATUS_PAL_M		0x20 /* PAL M */
+#define ADV7180_STATUS_PAL_60		0x30 /* PAL 60 */
+#define ADV7180_STATUS_PAL		0x40 /* PAL B/G/H/I/D */
+#define ADV7180_STATUS_SECAM		0x50 /* SECAM */
+#define ADV7180_STATUS_PAL_N		0x60 /* PAL Combination N */
+#define ADV7180_STATUS_SECAM_525	0x70 /* SECAM 525 */
+
+enum input_mode {
+	CVBS,   /* Composite */
+	SVIDEO, /* S-video */
+	YPbPr,  /* Component */
+};
+
+struct adv7180 {
+	unsigned char reg[ADV7180_NR_REG];
+	int norm;
+	enum input_mode input;
+	int enable;
+	struct i2c_client *client;
+};
+
+static const unsigned char reset_icr[] = {
+	ADV7180_ICR_1, 0x00,
+	ADV7180_ICR_2, 0x00,
+	ADV7180_ICR_3, 0x00,
+	ADV7180_ICR_4, 0x00,
+};
+
+/* ADV7180 LQFP-64. ADV7180.pdf, page 104 */
+static const unsigned char init_cvbs_64[] = {
+	0x00, 0x01, /* INSEL = CVBS in on Ain2 */
+	0x04, 0x57, /* Enable SFL */
+	0x17, 0x41, /* Select SH1 */
+
+	0x31, 0x02, /* Clear NEWAV_MODE, SAV/EAV to
+		     * suit ADV video encoders
+		     */
+	0x3d, 0xa2, /* MWE enable manual window,
+		     * color kill threshold to 2
+		     */
+	0x3e, 0x6a, /* BLM optimization */
+	0x3f, 0xa0, /* BGB optimization */
+	0x0e, 0x80, /* Hidden space */
+	0x55, 0x81, /* ADC configuration */
+	0x0e, 0x00, /* User space */
+};
+
+static const unsigned char init_svideo_64[] = {
+	0x00, 0x08, /* Insel = Y/C, Y = AIN3, C = AIN6 */
+	0x04, 0x57, /* Enable SFL */
+	0x31, 0x02, /* Clear NEWAV_MODE, SAV/EAV to
+		     * suit ADV video encoders
+		     */
+	0x3d, 0xa2, /* MWE enable manual window,
+		     * color kill threshold to 2
+		     */
+	0x3e, 0x6a, /* BLM optimization */
+	0x3f, 0xa0, /* BGB optimization */
+	0x58, 0x04, /* Mandatory write. This must be
+		     * performed for correct operation.
+		     */
+	0x0e, 0x80, /* Hidden space */
+	0x55, 0x81, /* ADC configuration */
+	0x0e, 0x00, /* User space */
+};
+
+static const unsigned char init_ypbpr_64[] = {
+	0x00, 0x09, /* INSEL = YPrPb, Y = AIN1, Pr = AIN4, Pb = AIN5 */
+	0x31, 0x02, /* Clear NEWAV_MODE, SAV/EAV to suit ADV video encoders */
+	0x3d, 0xa2, /* MWE enable manual window */
+	0x3e, 0x6a, /* BLM optimization */
+	0x3f, 0xa0, /* ADI recommended */
+	0x0e, 0x80, /* Hidden space */
+	0x55, 0x81, /* ADC configuration */
+	0x0e, 0x00, /* User space */
+};