changed Makefile and profiles, added patches for kernel 2.6.24

(stable-branch of Openmoko)


git-svn-id: svn://svn.openwrt.org/openwrt/trunk@13613 3c298f89-4303-0410-b956-a3cf2f4a3e73

1 files changed, 1184 insertions, 0 deletions

diff --git a/target/linux/s3c24xx/patches-2.6.24/1303-fix-lid302dl-bitbang-all-the-way-baby.patch.patch b/target/linux/s3c24xx/patches-2.6.24/1303-fix-lid302dl-bitbang-all-the-way-baby.patch.patch
new file mode 100644
index 0000000000..852faaeb42
--- /dev/null
+++ b/target/linux/s3c24xx/patches-2.6.24/1303-fix-lid302dl-bitbang-all-the-way-baby.patch.patch
@@ -0,0 +1,1184 @@
+From 1c6f5a92c816db43128444606c26507ebe6e5a43 Mon Sep 17 00:00:00 2001
+From: Andy Green <andy@openmoko.com>
+Date: Mon, 13 Oct 2008 12:01:05 +0100
+Subject: [PATCH] fix-lid302dl-bitbang-all-the-way-baby.patch
+
+This large patch removes motion sensor from Linux SPI bitbang driver.
+Previously, some access was done through Linux SPI protected
+by a mutex, and the ISR access was done by platform bitbang code due
+to inability of Linux SPI driver to work in the interrupt context.
+
+Now all access is done by bitbang callbacks in mach_gta02.c and are
+protected by single scheme of interrupt lockout for the duration --
+I line-by-line'd the driver to confirm that best I could, adding
+protection and taking more care on several /sys related paths.
+
+Because this is no longer a Linux SPI bus driver, the path for various
+/sys things have changed.  They can now be found down, eg,
+
+/sys/devices/platform/lis302dl.1/sample_rate
+
+lis302dl.1 is the top sensor and .2 the bottom.  The names of the input
+susbsytem paths remain the same as before.
+
+Signed-off-by: Andy Green <andy@openmoko.com>
+---
+ arch/arm/mach-s3c2440/mach-gta02.c |  233 +++++++++----------
+ drivers/input/misc/lis302dl.c      |  437 ++++++++++++++++--------------------
+ include/linux/lis302dl.h           |    9 +-
+ 3 files changed, 315 insertions(+), 364 deletions(-)
+
+diff --git a/arch/arm/mach-s3c2440/mach-gta02.c b/arch/arm/mach-s3c2440/mach-gta02.c
+index 467c417..b19632c 100644
+--- a/arch/arm/mach-s3c2440/mach-gta02.c
++++ b/arch/arm/mach-s3c2440/mach-gta02.c
+@@ -1052,20 +1052,21 @@ static struct platform_device gta02_vibrator_dev = {
+ /* #define DEBUG_SPEW_MS */
+ #define MG_PER_SAMPLE 18
+ 
+-struct lis302dl_platform_data lis302_pdata[];
++struct lis302dl_platform_data lis302_pdata_top;
++struct lis302dl_platform_data lis302_pdata_bottom;
+ 
+-void gta02_lis302dl_bitbang_read(struct lis302dl_info *lis)
++/*
++ * generic SPI RX and TX bitbang
++ * only call with interrupts off!
++ */
++
++static void __gta02_lis302dl_bitbang(struct lis302dl_info *lis, u8 *tx,
++					     int tx_bytes, u8 *rx, int rx_bytes)
+ {
+ 	struct lis302dl_platform_data *pdata = lis->pdata;
+-	u8 shifter = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */
+-	int n, n1;
++	int n;
++	u8 shifter = 0;
+ 	unsigned long other_cs;
+-	unsigned long flags;
+-#ifdef DEBUG_SPEW_MS
+-	s8 x, y, z;
+-#endif
+-
+-	local_irq_save(flags);
+ 
+ 	/*
+ 	 * Huh.. "quirk"... CS on this device is not really "CS" like you can
+@@ -1073,20 +1074,25 @@ void gta02_lis302dl_bitbang_read(struct lis302dl_info *lis)
+ 	 * have 2 devices on one interface, the "disabled" device when we talk
+ 	 * to an "enabled" device sees the clocks as I2C clocks, creating
+ 	 * havoc.
++	 *
+ 	 * I2C sees MOSI going LOW while CLK HIGH as a START action, we must
+ 	 * ensure this is never issued.
+ 	 */
+ 
+-	if (&lis302_pdata[0] == pdata)
+-		other_cs = lis302_pdata[1].pin_chip_select;
++	if (&lis302_pdata_top == pdata)
++		other_cs = lis302_pdata_bottom.pin_chip_select;
+ 	else
+-		other_cs = lis302_pdata[0].pin_chip_select;
++		other_cs = lis302_pdata_top.pin_chip_select;
+ 
+ 	s3c2410_gpio_setpin(other_cs, 1);
+ 	s3c2410_gpio_setpin(pdata->pin_chip_select, 1);
+ 	s3c2410_gpio_setpin(pdata->pin_clk, 1);
+ 	s3c2410_gpio_setpin(pdata->pin_chip_select, 0);
+-	for (n = 0; n < 8; n++) { /* write the r/w, inc and address */
++
++	/* send the register index, r/w and autoinc bits */
++	for (n = 0; n < (tx_bytes << 3); n++) {
++		if (!(n & 7))
++			shifter = tx[n >> 3];
+ 		s3c2410_gpio_setpin(pdata->pin_clk, 0);
+ 		s3c2410_gpio_setpin(pdata->pin_mosi, (shifter >> 7) & 1);
+ 		s3c2410_gpio_setpin(pdata->pin_clk, 0);
+@@ -1095,44 +1101,71 @@ void gta02_lis302dl_bitbang_read(struct lis302dl_info *lis)
+ 		shifter <<= 1;
+ 	}
+ 
+-	for (n = 0; n < 5; n++) { /* 5 consequetive registers */
+-		for (n1 = 0; n1 < 8; n1++) { /* 8 bits each */
+-			s3c2410_gpio_setpin(pdata->pin_clk, 0);
+-			s3c2410_gpio_setpin(pdata->pin_clk, 0);
+-			shifter <<= 1;
+-			if (s3c2410_gpio_getpin(pdata->pin_miso))
+-				shifter |= 1;
+-			s3c2410_gpio_setpin(pdata->pin_clk, 1);
+-			s3c2410_gpio_setpin(pdata->pin_clk, 1);
+-		}
+-		switch (n) {
+-		case 0:
+-#ifdef DEBUG_SPEW_MS
+-			x = shifter;
+-#endif
+-			input_report_rel(lis->input_dev, REL_X, MG_PER_SAMPLE * (s8)shifter);
+-			break;
+-		case 2:
+-#ifdef DEBUG_SPEW_MS
+-			y = shifter;
+-#endif
+-			input_report_rel(lis->input_dev, REL_Y, MG_PER_SAMPLE * (s8)shifter);
+-			break;
+-		case 4:
+-#ifdef DEBUG_SPEW_MS
+-			z = shifter;
+-#endif
+-			input_report_rel(lis->input_dev, REL_Z, MG_PER_SAMPLE * (s8)shifter);
+-			break;
+-		}
++	for (n = 0; n < (rx_bytes << 3); n++) { /* 8 bits each */
++		s3c2410_gpio_setpin(pdata->pin_clk, 0);
++		s3c2410_gpio_setpin(pdata->pin_clk, 0);
++		shifter <<= 1;
++		if (s3c2410_gpio_getpin(pdata->pin_miso))
++			shifter |= 1;
++		if ((n & 7) == 7)
++			rx[n >> 3] = shifter;
++		s3c2410_gpio_setpin(pdata->pin_clk, 1);
++		s3c2410_gpio_setpin(pdata->pin_clk, 1);
+ 	}
+ 	s3c2410_gpio_setpin(pdata->pin_chip_select, 1);
+ 	s3c2410_gpio_setpin(other_cs, 1);
++}
++
++
++static int gta02_lis302dl_bitbang_read_reg(struct lis302dl_info *lis, u8 reg)
++{
++	u8 data = 0xc0 | reg; /* read, autoincrement */
++	unsigned long flags;
++
++	local_irq_save(flags);
++
++	__gta02_lis302dl_bitbang(lis, &data, 1, &data, 1);
++
++	local_irq_restore(flags);
++
++	return data;
++}
++
++static void gta02_lis302dl_bitbang_write_reg(struct lis302dl_info *lis, u8 reg,
++									 u8 val)
++{
++	u8 data[2] = { 0x00 | reg, val }; /* write, no autoincrement */
++	unsigned long flags;
++
++	local_irq_save(flags);
++
++	__gta02_lis302dl_bitbang(lis, &data[0], 2, NULL, 0);
++
+ 	local_irq_restore(flags);
+ 
++}
++
++
++static void gta02_lis302dl_bitbang_sample(struct lis302dl_info *lis)
++{
++	u8 data = 0xc0 | LIS302DL_REG_OUT_X; /* read, autoincrement */
++	u8 read[5];
++	unsigned long flags;
++
++	local_irq_save(flags);
++
++	__gta02_lis302dl_bitbang(lis, &data, 1, &read[0], 5);
++
++	local_irq_restore(flags);
++
++	input_report_rel(lis->input_dev, REL_X, MG_PER_SAMPLE * (s8)read[0]);
++	input_report_rel(lis->input_dev, REL_Y, MG_PER_SAMPLE * (s8)read[2]);
++	input_report_rel(lis->input_dev, REL_Z, MG_PER_SAMPLE * (s8)read[4]);
++
+ 	input_sync(lis->input_dev);
+ #ifdef DEBUG_SPEW_MS
+-	printk("%s: %d %d %d\n", pdata->name, x, y, z);
++	printk(KERN_INFO "%s: %d %d %d\n", pdata->name, read[0], read[2],
++								       read[4]);
+ #endif
+ }
+ 
+@@ -1159,103 +1192,58 @@ void gta02_lis302dl_suspend_io(struct lis302dl_info *lis, int resume)
+ 	s3c2410_gpio_setpin(pdata->pin_clk, 1);
+ 	/* misnomer: it is a pullDOWN in 2442 */
+ 	s3c2410_gpio_pullup(pdata->pin_miso, 0);
++
++	s3c2410_gpio_cfgpin(pdata->pin_chip_select, S3C2410_GPIO_OUTPUT);
++	s3c2410_gpio_cfgpin(pdata->pin_clk, S3C2410_GPIO_OUTPUT);
++	s3c2410_gpio_cfgpin(pdata->pin_mosi, S3C2410_GPIO_OUTPUT);
++	s3c2410_gpio_cfgpin(pdata->pin_miso, S3C2410_GPIO_INPUT);
++
+ }
+ 
+-struct lis302dl_platform_data lis302_pdata[] = {
+-	{
++
++
++struct lis302dl_platform_data lis302_pdata_top = {
+ 		.name		= "lis302-1 (top)",
+ 		.pin_chip_select= S3C2410_GPD12,
+ 		.pin_clk	= S3C2410_GPG7,
+ 		.pin_mosi	= S3C2410_GPG6,
+ 		.pin_miso	= S3C2410_GPG5,
++		.interrupt	= GTA02_IRQ_GSENSOR_1,
+ 		.open_drain	= 1, /* altered at runtime by PCB rev */
+-		.lis302dl_bitbang_read = gta02_lis302dl_bitbang_read,
++		.lis302dl_bitbang_read_sample = gta02_lis302dl_bitbang_sample,
++		.lis302dl_bitbang_reg_read = gta02_lis302dl_bitbang_read_reg,
++		.lis302dl_bitbang_reg_write = gta02_lis302dl_bitbang_write_reg,
+ 		.lis302dl_suspend_io = gta02_lis302dl_suspend_io,
+-	}, {
++};
++
++struct lis302dl_platform_data lis302_pdata_bottom = {
+ 		.name		= "lis302-2 (bottom)",
+ 		.pin_chip_select= S3C2410_GPD13,
+ 		.pin_clk	= S3C2410_GPG7,
+ 		.pin_mosi	= S3C2410_GPG6,
+ 		.pin_miso	= S3C2410_GPG5,
++		.interrupt	= GTA02_IRQ_GSENSOR_2,
+ 		.open_drain	= 1, /* altered at runtime by PCB rev */
+-		.lis302dl_bitbang_read = gta02_lis302dl_bitbang_read,
++		.lis302dl_bitbang_read_sample = gta02_lis302dl_bitbang_sample,
++		.lis302dl_bitbang_reg_read = gta02_lis302dl_bitbang_read_reg,
++		.lis302dl_bitbang_reg_write = gta02_lis302dl_bitbang_write_reg,
+ 		.lis302dl_suspend_io = gta02_lis302dl_suspend_io,
+-	},
+ };
+ 
+-static struct spi_board_info gta02_spi_acc_bdinfo[] = {
+-	{
+-		.modalias	= "lis302dl",
+-		.platform_data	= &lis302_pdata[0],
+-		.irq		= GTA02_IRQ_GSENSOR_1,
+-		.max_speed_hz	= 10 * 1000 * 1000,
+-		.bus_num	= 1,
+-		.chip_select	= 0,
+-		.mode		= SPI_MODE_3,
+-	},
+-	{
+-		.modalias	= "lis302dl",
+-		.platform_data	= &lis302_pdata[1],
+-		.irq		= GTA02_IRQ_GSENSOR_2,
+-		.max_speed_hz	= 10 * 1000 * 1000,
+-		.bus_num	= 1,
+-		.chip_select	= 1,
+-		.mode		= SPI_MODE_3,
+-	},
+-};
+-
+-static void spi_acc_cs(struct s3c2410_spigpio_info *spigpio_info,
+-		       int csid, int cs)
+-{
+-	struct lis302dl_platform_data * plat_data =
+-				(struct lis302dl_platform_data *)spigpio_info->
+-						     board_info->platform_data;
+-	switch (cs) {
+-	case BITBANG_CS_ACTIVE:
+-		s3c2410_gpio_setpin(plat_data[csid].pin_chip_select, 0);
+-		break;
+-	case BITBANG_CS_INACTIVE:
+-		s3c2410_gpio_setpin(plat_data[csid].pin_chip_select, 1);
+-		break;
+-	}
+-}
+ 
+-static struct s3c2410_spigpio_info spi_gpio_cfg = {
+-	.pin_clk	= S3C2410_GPG7,
+-	.pin_mosi	= S3C2410_GPG6,
+-	.pin_miso	= S3C2410_GPG5,
+-	.board_size	= ARRAY_SIZE(gta02_spi_acc_bdinfo),
+-	.board_info	= gta02_spi_acc_bdinfo,
+-	.chip_select	= &spi_acc_cs,
+-	.num_chipselect = 2,
+-};
+-
+-static struct resource s3c_spi_acc_resource[] = {
+-	[0] = {
+-		.start = S3C2410_GPG3,
+-		.end   = S3C2410_GPG3,
+-	},
+-	[1] = {
+-		.start = S3C2410_GPG5,
+-		.end   = S3C2410_GPG5,
+-	},
+-	[2] = {
+-		.start = S3C2410_GPG6,
+-		.end   = S3C2410_GPG6,
+-	},
+-	[3] = {
+-		.start = S3C2410_GPG7,
+-		.end   = S3C2410_GPG7,
++static struct platform_device s3c_device_spi_acc1 = {
++	.name		  = "lis302dl",
++	.id		  = 1,
++	.dev = {
++		.platform_data = &lis302_pdata_top,
+ 	},
+ };
+ 
+-static struct platform_device s3c_device_spi_acc = {
+-	.name		  = "spi_s3c24xx_gpio",
+-	.id		  = 1,
+-	.num_resources	  = ARRAY_SIZE(s3c_spi_acc_resource),
+-	.resource	  = s3c_spi_acc_resource,
++static struct platform_device s3c_device_spi_acc2 = {
++	.name		  = "lis302dl",
++	.id		  = 2,
+ 	.dev = {
+-		.platform_data = &spi_gpio_cfg,
++		.platform_data = &lis302_pdata_bottom,
+ 	},
+ };
+ 
+@@ -1573,8 +1561,8 @@ static void __init gta02_machine_init(void)
+ 	switch (system_rev) {
+ 	case GTA02v6_SYSTEM_REV:
+ 		/* we need push-pull interrupt from motion sensors */
+-		lis302_pdata[0].open_drain = 0;
+-		lis302_pdata[1].open_drain = 0;
++		lis302_pdata_top.open_drain = 0;
++		lis302_pdata_bottom.open_drain = 0;
+ 		break;
+ 	default:
+ 		break;
+@@ -1635,7 +1623,8 @@ static void __init gta02_machine_init(void)
+ 	mangle_glamo_res_by_system_rev();
+ 	platform_device_register(&gta02_glamo_dev);
+ 
+-	platform_device_register(&s3c_device_spi_acc);
++	platform_device_register(&s3c_device_spi_acc1);
++	platform_device_register(&s3c_device_spi_acc2);
+ 	platform_device_register(&gta02_button_dev);
+ 	platform_device_register(&gta02_pm_gsm_dev);
+ 	platform_device_register(&gta02_pm_usbhost_dev);
+diff --git a/drivers/input/misc/lis302dl.c b/drivers/input/misc/lis302dl.c
+index b01ca04..1d5781d 100644
+--- a/drivers/input/misc/lis302dl.c
++++ b/drivers/input/misc/lis302dl.c
+@@ -1,7 +1,9 @@
+ /* Linux kernel driver for the ST LIS302D 3-axis accelerometer
+  *
+- * Copyright (C) 2007 by Openmoko, Inc.
++ * Copyright (C) 2007-2008 by Openmoko, Inc.
+  * Author: Harald Welte <laforge@openmoko.org>
++ *         converted to private bitbang by:
++ *         Andy Green <andy@openmoko.com>
+  * All rights reserved.
+  *
+  * This program is free software; you can redistribute it and/or
+@@ -39,78 +41,19 @@
+ 
+ #include <linux/lis302dl.h>
+ 
+-/* lowlevel register access functions */
+ 
+-#define READ_BIT		0x80
+-#define READ_BIT_INC_ADS	0xc0
+-#define	ADDR_MASK		0x3f
+ 
+-static u_int8_t __reg_read(struct lis302dl_info *lis, u_int8_t reg)
++static void __reg_set_bit_mask(struct lis302dl_info *lis, u8 reg, u8 mask,
++									 u8 val)
+ {
+-	int rc;
+-	u_int8_t cmd;
+-
+-	BUG_ON(reg & ~ADDR_MASK);
+-
+-	cmd = reg | READ_BIT;
+-
+-	rc = spi_w8r8(lis->spi_dev, cmd);
+-
+-	return rc;
+-}
+-
+-static u_int8_t reg_read(struct lis302dl_info *lis, u_int8_t reg)
+-{
+-	u_int8_t ret;
+-
+-	mutex_lock(&lis->lock);
+-	ret = __reg_read(lis, reg);
+-	mutex_unlock(&lis->lock);
+-
+-	return ret;
+-}
+-
+-static int __reg_write(struct lis302dl_info *lis, u_int8_t reg, u_int8_t val)
+-{
+-	u_int8_t buf[2];
+-
+-	BUG_ON(reg & ~ADDR_MASK);
+-
+-	buf[0] = reg;
+-	buf[1] = val;
+-
+-	return spi_write(lis->spi_dev, buf, sizeof(buf));
+-}
+-
+-static int reg_write(struct lis302dl_info *lis, u_int8_t reg, u_int8_t val)
+-{
+-	int ret;
+-
+-	mutex_lock(&lis->lock);
+-	ret = __reg_write(lis, reg, val);
+-	mutex_unlock(&lis->lock);
+-
+-	return ret;
+-}
+-
+-static int reg_set_bit_mask(struct lis302dl_info *lis,
+-			    u_int8_t reg, u_int8_t mask, u_int8_t val)
+-{
+-	int ret;
+ 	u_int8_t tmp;
+ 
+ 	val &= mask;
+ 
+-	mutex_lock(&lis->lock);
+-
+-	tmp = __reg_read(lis, reg);
++	tmp = (lis->pdata->lis302dl_bitbang_reg_read)(lis, reg);
+ 	tmp &= ~mask;
+ 	tmp |= val;
+-	ret = __reg_write(lis, reg, tmp);
+-
+-	mutex_unlock(&lis->lock);
+-
+-	return ret;
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, reg, tmp);
+ }
+ 
+ /* interrupt handling related */
+@@ -124,17 +67,17 @@ enum lis302dl_intmode {
+ 	LIS302DL_INTMODE_CLICK		= 0x07,
+ };
+ 
+-static void lis302dl_int_mode(struct spi_device *spi, int int_pin,
++static void __lis302dl_int_mode(struct device *dev, int int_pin,
+ 			      enum lis302dl_intmode mode)
+ {
+-	struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
++	struct lis302dl_info *lis = dev_get_drvdata(dev);
+ 
+ 	switch (int_pin) {
+ 	case 1:
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x07, mode);
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x07, mode);
+ 		break;
+ 	case 2:
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x38, mode << 3);
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL3, 0x38, mode << 3);
+ 		break;
+ 	default:
+ 		BUG();
+@@ -165,7 +108,7 @@ static irqreturn_t lis302dl_interrupt(int irq, void *_lis)
+ {
+ 	struct lis302dl_info *lis = _lis;
+ 
+-	(lis->pdata->lis302dl_bitbang_read)(lis);
++	(lis->pdata->lis302dl_bitbang_read_sample)(lis);
+ 	return IRQ_HANDLED;
+ }
+ 
+@@ -175,7 +118,13 @@ static ssize_t show_rate(struct device *dev, struct device_attribute *attr,
+ 			 char *buf)
+ {
+ 	struct lis302dl_info *lis = dev_get_drvdata(dev);
+-	u_int8_t ctrl1 = reg_read(lis, LIS302DL_REG_CTRL1);
++	u8 ctrl1;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	ctrl1 = (lis->pdata->lis302dl_bitbang_reg_read)
++						      (lis, LIS302DL_REG_CTRL1);
++	local_irq_restore(flags);
+ 
+ 	return sprintf(buf, "%d\n", ctrl1 & LIS302DL_CTRL1_DR ? 400 : 100);
+ }
+@@ -184,12 +133,17 @@ static ssize_t set_rate(struct device *dev, struct device_attribute *attr,
+ 			const char *buf, size_t count)
+ {
+ 	struct lis302dl_info *lis = dev_get_drvdata(dev);
++	unsigned long flags;
++
++	local_irq_save(flags);
+ 
+ 	if (!strcmp(buf, "400\n"))
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
+ 				 LIS302DL_CTRL1_DR);
+ 	else
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR, 0);
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_DR,
++									     0);
++	local_irq_restore(flags);
+ 
+ 	return count;
+ }
+@@ -200,7 +154,13 @@ static ssize_t show_scale(struct device *dev, struct device_attribute *attr,
+ 			  char *buf)
+ {
+ 	struct lis302dl_info *lis = dev_get_drvdata(dev);
+-	u_int8_t ctrl1 = reg_read(lis, LIS302DL_REG_CTRL1);
++	u_int8_t ctrl1;
++	unsigned long flags;
++
++	local_irq_save(flags);
++	ctrl1 = (lis->pdata->lis302dl_bitbang_reg_read)(lis,
++							    LIS302DL_REG_CTRL1);
++	local_irq_restore(flags);
+ 
+ 	return sprintf(buf, "%s\n", ctrl1 & LIS302DL_CTRL1_FS ? "9.2" : "2.3");
+ }
+@@ -209,12 +169,18 @@ static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
+ 			 const char *buf, size_t count)
+ {
+ 	struct lis302dl_info *lis = dev_get_drvdata(dev);
++	unsigned long flags;
++
++	local_irq_save(flags);
+ 
+ 	if (!strcmp(buf, "9.2\n"))
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
+ 				 LIS302DL_CTRL1_FS);
+ 	else
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS, 0);
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_FS,
++									     0);
++
++	local_irq_restore(flags);
+ 
+ 	return count;
+ }
+@@ -222,7 +188,7 @@ static ssize_t set_scale(struct device *dev, struct device_attribute *attr,
+ static DEVICE_ATTR(full_scale, S_IRUGO | S_IWUSR, show_scale, set_scale);
+ 
+ static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
+-			  char *buf)
++								      char *buf)
+ {
+ 	struct lis302dl_info *lis = dev_get_drvdata(dev);
+ 	int n = 0;
+@@ -233,7 +199,7 @@ static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
+ 	local_irq_save(flags);
+ 
+ 	for (n = 0; n < sizeof(reg); n++)
+-		reg[n] = reg_read(lis, n);
++		reg[n] = (lis->pdata->lis302dl_bitbang_reg_read)(lis, n);
+ 
+ 	local_irq_restore(flags);
+ 
+@@ -248,9 +214,9 @@ static ssize_t lis302dl_dump(struct device *dev, struct device_attribute *attr,
+ }
+ static DEVICE_ATTR(dump, S_IRUGO, lis302dl_dump, NULL);
+ 
+-static int freefall_ms_to_duration(struct lis302dl_info *lis, int ms)
++static int __freefall_ms_to_duration(struct lis302dl_info *lis, int ms)
+ {
+-	u_int8_t r = reg_read(lis, LIS302DL_REG_CTRL1);
++	u8 r = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1);
+ 
+ 	/* If we have 400 ms sampling rate, the stepping is 2.5 ms,
+ 	 * on 100 ms the stepping is 10ms */
+@@ -268,9 +234,9 @@ static int freefall_ms_to_duration(struct lis302dl_info *lis, int ms)
+ 	return ms / 10;
+ }
+ 
+-static int freefall_duration_to_ms(struct lis302dl_info *lis, int duration)
++static int __freefall_duration_to_ms(struct lis302dl_info *lis, int duration)
+ {
+-	u_int8_t r = reg_read(lis, LIS302DL_REG_CTRL1);
++	u8 r = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1);
+ 
+ 	if (r & LIS302DL_CTRL1_DR)
+ 		return (duration * 25) / 10;
+@@ -314,18 +280,18 @@ static ssize_t set_freefall_common(int which, struct device *dev,
+ 		/* Turn off the interrupt */
+ 		local_irq_save(flags);
+ 		if (lis->flags & LIS302DL_F_IRQ_WAKE)
+-			disable_irq_wake(lis->spi_dev->irq);
+-		lis302dl_int_mode(lis->spi_dev, which,
++			disable_irq_wake(lis->pdata->interrupt);
++		__lis302dl_int_mode(lis->dev, which,
+ 						   LIS302DL_INTMODE_DATA_READY);
+ 		lis->flags &= ~(flag_mask | LIS302DL_F_IRQ_WAKE);
+ 
+-		reg_write(lis, r_cfg, 0);
+-		reg_write(lis, r_ths, 0);
+-		reg_write(lis, r_duration, 0);
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg, 0);
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_ths, 0);
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_duration, 0);
+ 
+ 		/* Power off unless the input subsystem is using the device */
+ 		if (!(lis->flags & LIS302DL_F_INPUT_OPEN))
+-			reg_set_bit_mask(lis, LIS302DL_REG_CTRL1,
++			__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1,
+ 							  LIS302DL_CTRL1_PD, 0);
+ 
+ 		local_irq_restore(flags);
+@@ -337,7 +303,10 @@ static ssize_t set_freefall_common(int which, struct device *dev,
+ 							      &and_events) != 6)
+ 		return -EINVAL;
+ 
+-	duration = freefall_ms_to_duration(lis, ms);
++	local_irq_save(flags);
++	duration = __freefall_ms_to_duration(lis, ms);
++	local_irq_save(flags);
++
+ 	if (duration < 0)
+ 		return -ERANGE;
+ 
+@@ -355,23 +324,25 @@ static ssize_t set_freefall_common(int which, struct device *dev,
+ 
+ 	/* Setup the configuration registers */
+ 	local_irq_save(flags);
+-	reg_write(lis, r_cfg, 0); /* First zero to get to a known state */
+-	reg_write(lis, r_cfg,
++	/* First zero to get to a known state */
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg, 0);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_cfg,
+ 		(and_events ? LIS302DL_FFWUCFG_AOI : 0) |
+ 		x_lo | x_hi | y_lo | y_hi | z_lo | z_hi);
+-	reg_write(lis, r_ths, threshold & ~LIS302DL_FFWUTHS_DCRM);
+-	reg_write(lis, r_duration, duration);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_ths,
++					    threshold & ~LIS302DL_FFWUTHS_DCRM);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, r_duration, duration);
+ 
+ 	/* Route the interrupt for wakeup */
+-	lis302dl_int_mode(lis->spi_dev, which, intmode);
++	__lis302dl_int_mode(lis->dev, which, intmode);
+ 
+ 	/* Power up the device and note that we want to wake up from
+ 	 * this interrupt */
+ 	if (!(lis->flags & LIS302DL_F_IRQ_WAKE))
+-		enable_irq_wake(lis->spi_dev->irq);
++		enable_irq_wake(lis->pdata->interrupt);
+ 
+ 	lis->flags |= flag_mask | LIS302DL_F_IRQ_WAKE;
+-	reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
++	__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
+ 			LIS302DL_CTRL1_PD);
+ 	local_irq_restore(flags);
+ 
+@@ -403,6 +374,8 @@ static ssize_t show_freefall_common(int which, struct device *dev,
+ 	int r_duration = LIS302DL_REG_FF_WU_DURATION_1;
+ 	int r_cfg = LIS302DL_REG_FF_WU_CFG_1;
+ 	int r_src = LIS302DL_REG_FF_WU_SRC_1;
++	unsigned long flags;
++	int ms;
+ 
+ 	/* Configure second freefall/wakeup pin */
+ 	if (which == 2) {
+@@ -411,11 +384,15 @@ static ssize_t show_freefall_common(int which, struct device *dev,
+ 		r_cfg = LIS302DL_REG_FF_WU_CFG_2;
+ 		r_src = LIS302DL_REG_FF_WU_SRC_2;
+ 	}
+-	config = reg_read(lis, r_cfg);
+-	threshold = reg_read(lis, r_ths);
+-	duration = reg_read(lis, r_duration);
+-	r4 = reg_read(lis, r_src);
+-	r5 = reg_read(lis, LIS302DL_REG_CTRL3);
++
++	local_irq_save(flags);
++	config = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_cfg);
++	threshold = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_ths);
++	duration = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_duration);
++	r4 = (lis->pdata->lis302dl_bitbang_reg_read)(lis, r_src);
++	r5 = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL3);
++	ms = __freefall_duration_to_ms(lis, duration);
++	local_irq_restore(flags);
+ 
+ 	/* All events off? */
+ 	if ((config & (LIS302DL_FFWUCFG_XLIE | LIS302DL_FFWUCFG_XHIE |
+@@ -423,13 +400,14 @@ static ssize_t show_freefall_common(int which, struct device *dev,
+ 			LIS302DL_FFWUCFG_ZLIE | LIS302DL_FFWUCFG_ZHIE)) == 0)
+ 		return sprintf(buf, "off\n");
+ 
++
+ 	return sprintf(buf,
+ 			"%s events, %s interrupt, duration %d, threshold %d, "
+ 			"enabled: %s %s %s %s %s %s\n",
+ 			(config & LIS302DL_FFWUCFG_AOI) == 0 ? "or" : "and",
+ 			(config & LIS302DL_FFWUCFG_LIR) == 0 ?
+ 							"don't latch" : "latch",
+-			freefall_duration_to_ms(lis, duration), threshold,
++			ms, threshold,
+ 			(config & LIS302DL_FFWUCFG_XLIE) == 0 ? "---" : "xlo",
+ 			(config & LIS302DL_FFWUCFG_XHIE) == 0 ? "---" : "xhi",
+ 			(config & LIS302DL_FFWUCFG_YLIE) == 0 ? "---" : "ylo",
+@@ -480,14 +458,15 @@ static int lis302dl_input_open(struct input_dev *inp)
+ 
+ 	local_irq_save(flags);
+ 	/* make sure we're powered up and generate data ready */
+-	reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1);
+-	local_irq_restore(flags);
++	__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, ctrl1);
+ 
+ 	lis->flags |= LIS302DL_F_INPUT_OPEN;
+ 
+ 	/* kick it off -- since we are edge triggered, if we missed the edge
+ 	 * permanent low interrupt is death for us */
+-	(lis->pdata->lis302dl_bitbang_read)(lis);
++	(lis->pdata->lis302dl_bitbang_read_sample)(lis);
++
++	local_irq_restore(flags);
+ 
+ 	return 0;
+ }
+@@ -504,13 +483,13 @@ static void lis302dl_input_close(struct input_dev *inp)
+ 	/* since the input core already serializes access and makes sure we
+ 	 * only see close() for the close of the last user, we can safely
+ 	 * disable the data ready events */
+-	reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, 0x00);
++	__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, ctrl1, 0x00);
+ 	lis->flags &= ~LIS302DL_F_INPUT_OPEN;
+ 
+ 	/* however, don't power down the whole device if still needed */
+ 	if (!(lis->flags & LIS302DL_F_WUP_FF ||
+ 	      lis->flags & LIS302DL_F_WUP_CLICK)) {
+-		reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
++		__reg_set_bit_mask(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD,
+ 				 0x00);
+ 	}
+ 	local_irq_restore(flags);
+@@ -524,23 +503,23 @@ static int __lis302dl_reset_device(struct lis302dl_info *lis)
+ {
+ 	int timeout = 10;
+ 
+-	reg_write(lis, LIS302DL_REG_CTRL2, LIS302DL_CTRL2_BOOT |
+-							    LIS302DL_CTRL2_FDS);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2,
++				      LIS302DL_CTRL2_BOOT | LIS302DL_CTRL2_FDS);
+ 
+-	while ((reg_read(lis, LIS302DL_REG_CTRL2) & LIS302DL_CTRL2_BOOT) &&
+-								    (timeout--))
++	while (((lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL2)
++					  & LIS302DL_CTRL2_BOOT) && (timeout--))
+ 		mdelay(1);
+ 
+ 	return !!(timeout < 0);
+ }
+ 
+-static int __devinit lis302dl_probe(struct spi_device *spi)
++static int __devinit lis302dl_probe(struct platform_device *pdev)
+ {
+ 	int rc;
+ 	struct lis302dl_info *lis;
+ 	u_int8_t wai;
+ 	unsigned long flags;
+-	struct lis302dl_platform_data *pdata;
++	struct lis302dl_platform_data *pdata = pdev->dev.platform_data;
+ 
+ 	lis = kzalloc(sizeof(*lis), GFP_KERNEL);
+ 	if (!lis)
+@@ -548,38 +527,34 @@ static int __devinit lis302dl_probe(struct spi_device *spi)
+ 
+ 	local_irq_save(flags);
+ 
+-	mutex_init(&lis->lock);
+-	lis->spi_dev = spi;
++	lis->dev = &pdev->dev;
+ 
+-	spi_set_drvdata(spi, lis);
++	dev_set_drvdata(lis->dev, lis);
+ 
+-	pdata = spi->dev.platform_data;
++	lis->pdata = pdata;
+ 
+-	rc = spi_setup(spi);
+-	if (rc < 0) {
+-		dev_err(&spi->dev, "error during spi_setup\n");
+-		dev_set_drvdata(&spi->dev, NULL);
+-		goto bail_free_lis;
+-	}
++	/* Configure our IO */
++	(lis->pdata->lis302dl_suspend_io)(lis, 1);
+ 
+-	wai = reg_read(lis, LIS302DL_REG_WHO_AM_I);
++	wai = (lis->pdata->lis302dl_bitbang_reg_read)(lis,
++							 LIS302DL_REG_WHO_AM_I);
+ 	if (wai != LIS302DL_WHO_AM_I_MAGIC) {
+-		dev_err(&spi->dev, "unknown who_am_i signature 0x%02x\n", wai);
+-		dev_set_drvdata(&spi->dev, NULL);
++		dev_err(lis->dev, "unknown who_am_i signature 0x%02x\n", wai);
++		dev_set_drvdata(lis->dev, NULL);
+ 		rc = -ENODEV;
+ 		goto bail_free_lis;
+ 	}
+ 
+-	rc = sysfs_create_group(&spi->dev.kobj, &lis302dl_attr_group);
++	rc = sysfs_create_group(&lis->dev->kobj, &lis302dl_attr_group);
+ 	if (rc) {
+-		dev_err(&spi->dev, "error creating sysfs group\n");
++		dev_err(lis->dev, "error creating sysfs group\n");
+ 		goto bail_free_lis;
+ 	}
+ 
+ 	/* initialize input layer details */
+ 	lis->input_dev = input_allocate_device();
+ 	if (!lis->input_dev) {
+-		dev_err(&spi->dev, "Unable to allocate input device\n");
++		dev_err(lis->dev, "Unable to allocate input device\n");
+ 		goto bail_sysfs;
+ 	}
+ 
+@@ -601,57 +576,64 @@ static int __devinit lis302dl_probe(struct spi_device *spi)
+ 
+ 	rc = input_register_device(lis->input_dev);
+ 	if (rc) {
+-		dev_err(&spi->dev, "error %d registering input device\n", rc);
++		dev_err(lis->dev, "error %d registering input device\n", rc);
+ 		goto bail_inp_dev;
+ 	}
+ 
+ 	if (__lis302dl_reset_device(lis))
+-		dev_err(&spi->dev, "device BOOT reload failed\n");
++		dev_err(lis->dev, "device BOOT reload failed\n");
+ 
+ 	/* force us powered */
+-	reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD |
+-					   LIS302DL_CTRL1_Xen |
+-					   LIS302DL_CTRL1_Yen |
+-					   LIS302DL_CTRL1_Zen);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1,
++						      LIS302DL_CTRL1_PD |
++						      LIS302DL_CTRL1_Xen |
++						      LIS302DL_CTRL1_Yen |
++						      LIS302DL_CTRL1_Zen);
+ 	mdelay(1);
+ 
+-	reg_write(lis, LIS302DL_REG_CTRL2, 0);
+-	reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_PP_OD |
+-							    LIS302DL_CTRL3_IHL);
+-	reg_write(lis, LIS302DL_REG_FF_WU_THS_1, 0x0);
+-	reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1, 0x00);
+-	reg_write(lis, LIS302DL_REG_FF_WU_CFG_1, 0x0);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, 0);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL3,
++				     LIS302DL_CTRL3_PP_OD | LIS302DL_CTRL3_IHL);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++						 LIS302DL_REG_FF_WU_THS_1, 0x0);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++					   LIS302DL_REG_FF_WU_DURATION_1, 0x00);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++						 LIS302DL_REG_FF_WU_CFG_1, 0x0);
+ 
+ 	/* start off in powered down mode; we power up when someone opens us */
+-	reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_Xen |
+-					   LIS302DL_CTRL1_Yen |
+-					   LIS302DL_CTRL1_Zen);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1,
++							LIS302DL_CTRL1_Xen |
++							LIS302DL_CTRL1_Yen |
++							LIS302DL_CTRL1_Zen);
+ 
+ 	if (pdata->open_drain)
+ 		/* switch interrupt to open collector, active-low */
+-		reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_PP_OD |
+-						   LIS302DL_CTRL3_IHL);
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++			LIS302DL_REG_CTRL3, LIS302DL_CTRL3_PP_OD |
++					    LIS302DL_CTRL3_IHL);
+ 	else
+ 		/* push-pull, active-low */
+-		reg_write(lis, LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL);
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++					LIS302DL_REG_CTRL3, LIS302DL_CTRL3_IHL);
+ 
+-	lis302dl_int_mode(spi, 1, LIS302DL_INTMODE_DATA_READY);
+-	lis302dl_int_mode(spi, 2, LIS302DL_INTMODE_DATA_READY);
++	__lis302dl_int_mode(lis->dev, 1, LIS302DL_INTMODE_DATA_READY);
++	__lis302dl_int_mode(lis->dev, 2, LIS302DL_INTMODE_DATA_READY);
+ 
+-	reg_read(lis, LIS302DL_REG_STATUS);
+-	reg_read(lis, LIS302DL_REG_FF_WU_SRC_1);
+-	reg_read(lis, LIS302DL_REG_FF_WU_SRC_2);
+-	reg_read(lis, LIS302DL_REG_CLICK_SRC);
++	(lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_STATUS);
++	(lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_FF_WU_SRC_1);
++	(lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_FF_WU_SRC_2);
++	(lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CLICK_SRC);
+ 
+-	dev_info(&spi->dev, "Found %s\n", pdata->name);
++	dev_info(lis->dev, "Found %s\n", pdata->name);
+ 
+ 	lis->pdata = pdata;
+ 
+-	rc = request_irq(lis->spi_dev->irq, lis302dl_interrupt,
++	rc = request_irq(pdata->interrupt, lis302dl_interrupt,
+ 			 IRQF_TRIGGER_FALLING, "lis302dl", lis);
+ 	if (rc < 0) {
+-		dev_err(&spi->dev, "error requesting IRQ %d\n",
+-			lis->spi_dev->irq);
++		dev_err(lis->dev, "error requesting IRQ %d\n",
++			lis->pdata->interrupt);
+ 		goto bail_inp_reg;
+ 	}
+ 	local_irq_restore(flags);
+@@ -662,50 +644,71 @@ bail_inp_reg:
+ bail_inp_dev:
+ 	input_free_device(lis->input_dev);
+ bail_sysfs:
+-	sysfs_remove_group(&spi->dev.kobj, &lis302dl_attr_group);
++	sysfs_remove_group(&lis->dev->kobj, &lis302dl_attr_group);
+ bail_free_lis:
+ 	kfree(lis);
+ 	local_irq_restore(flags);
+ 	return rc;
+ }
+ 
+-static int __devexit lis302dl_remove(struct spi_device *spi)
++static int __devexit lis302dl_remove(struct platform_device *pdev)
+ {
+-	struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
++	struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
+ 	unsigned long flags;
+ 
+ 	/* Reset and power down the device */
+ 	local_irq_save(flags);
+-	reg_write(lis, LIS302DL_REG_CTRL3, 0x00);
+-	reg_write(lis, LIS302DL_REG_CTRL2, 0x00);
+-	reg_write(lis, LIS302DL_REG_CTRL1, 0x00);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL3, 0x00);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL2, 0x00);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, 0x00);
+ 	local_irq_restore(flags);
+ 
+ 	/* Cleanup resources */
+-	free_irq(lis->spi_dev->irq, lis);
+-	sysfs_remove_group(&spi->dev.kobj, &lis302dl_attr_group);
++	free_irq(lis->pdata->interrupt, lis);
++	sysfs_remove_group(&pdev->dev.kobj, &lis302dl_attr_group);
+ 	input_unregister_device(lis->input_dev);
+ 	if (lis->input_dev)
+ 		input_free_device(lis->input_dev);
+-	dev_set_drvdata(&spi->dev, NULL);
++	dev_set_drvdata(lis->dev, NULL);
+ 	kfree(lis);
+ 
+ 	return 0;
+ }
+ 
+ #ifdef CONFIG_PM
+-static int lis302dl_suspend(struct spi_device *spi, pm_message_t state)
++
++static u8 regs_to_save[] = {
++	LIS302DL_REG_CTRL1,
++	LIS302DL_REG_CTRL2,
++	LIS302DL_REG_CTRL3,
++	LIS302DL_REG_FF_WU_CFG_1,
++	LIS302DL_REG_FF_WU_THS_1,
++	LIS302DL_REG_FF_WU_DURATION_1,
++	LIS302DL_REG_FF_WU_CFG_2,
++	LIS302DL_REG_FF_WU_THS_2,
++	LIS302DL_REG_FF_WU_DURATION_2,
++	LIS302DL_REG_CLICK_CFG,
++	LIS302DL_REG_CLICK_THSY_X,
++	LIS302DL_REG_CLICK_THSZ,
++	LIS302DL_REG_CLICK_TIME_LIMIT,
++	LIS302DL_REG_CLICK_LATENCY,
++	LIS302DL_REG_CLICK_WINDOW,
++
++};
++
++static int lis302dl_suspend(struct platform_device *pdev, pm_message_t state)
+ {
+-	struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
++	struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
+ 	unsigned long flags;
+ 	u_int8_t tmp;
++	int n;
+ 
+ 	/* determine if we want to wake up from the accel. */
+ 	if (lis->flags & LIS302DL_F_WUP_FF ||
+ 		lis->flags & LIS302DL_F_WUP_CLICK)
+ 		return 0;
+ 
+-	disable_irq(lis->spi_dev->irq);
++	disable_irq(lis->pdata->interrupt);
+ 	local_irq_save(flags);
+ 
+ 	/*
+@@ -718,38 +721,15 @@ static int lis302dl_suspend(struct spi_device *spi, pm_message_t state)
+ 	(lis->pdata->lis302dl_suspend_io)(lis, 1);
+ 
+ 	/* save registers */
+-	lis->regs[LIS302DL_REG_CTRL1] = reg_read(lis, LIS302DL_REG_CTRL1);
+-	lis->regs[LIS302DL_REG_CTRL2] = reg_read(lis, LIS302DL_REG_CTRL2);
+-	lis->regs[LIS302DL_REG_CTRL3] = reg_read(lis, LIS302DL_REG_CTRL3);
+-	lis->regs[LIS302DL_REG_FF_WU_CFG_1] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_CFG_1);
+-	lis->regs[LIS302DL_REG_FF_WU_THS_1] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_THS_1);
+-	lis->regs[LIS302DL_REG_FF_WU_DURATION_1] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_DURATION_1);
+-	lis->regs[LIS302DL_REG_FF_WU_CFG_2] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_CFG_2);
+-	lis->regs[LIS302DL_REG_FF_WU_THS_2] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_THS_2);
+-	lis->regs[LIS302DL_REG_FF_WU_DURATION_2] =
+-				reg_read(lis, LIS302DL_REG_FF_WU_DURATION_2);
+-	lis->regs[LIS302DL_REG_CLICK_CFG] =
+-				reg_read(lis, LIS302DL_REG_CLICK_CFG);
+-	lis->regs[LIS302DL_REG_CLICK_THSY_X] =
+-				reg_read(lis, LIS302DL_REG_CLICK_THSY_X);
+-	lis->regs[LIS302DL_REG_CLICK_THSZ] =
+-				reg_read(lis, LIS302DL_REG_CLICK_THSZ);
+-	lis->regs[LIS302DL_REG_CLICK_TIME_LIMIT] =
+-				reg_read(lis, LIS302DL_REG_CLICK_TIME_LIMIT);
+-	lis->regs[LIS302DL_REG_CLICK_LATENCY] =
+-				reg_read(lis, LIS302DL_REG_CLICK_LATENCY);
+-	lis->regs[LIS302DL_REG_CLICK_WINDOW] =
+-				reg_read(lis, LIS302DL_REG_CLICK_WINDOW);
++	for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
++		lis->regs[regs_to_save[n]] =
++			(lis->pdata->lis302dl_bitbang_reg_read)(lis,
++							       regs_to_save[n]);
+ 
+ 	/* power down */
+-	tmp = reg_read(lis, LIS302DL_REG_CTRL1);
++	tmp = (lis->pdata->lis302dl_bitbang_reg_read)(lis, LIS302DL_REG_CTRL1);
+ 	tmp &= ~LIS302DL_CTRL1_PD;
+-	reg_write(lis, LIS302DL_REG_CTRL1, tmp);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1, tmp);
+ 
+ 	/* place our IO to the device in sleep-compatible states */
+ 	(lis->pdata->lis302dl_suspend_io)(lis, 0);
+@@ -759,10 +739,11 @@ static int lis302dl_suspend(struct spi_device *spi, pm_message_t state)
+ 	return 0;
+ }
+ 
+-static int lis302dl_resume(struct spi_device *spi)
++static int lis302dl_resume(struct platform_device *pdev)
+ {
+-	struct lis302dl_info *lis = dev_get_drvdata(&spi->dev);
++	struct lis302dl_info *lis = dev_get_drvdata(&pdev->dev);
+ 	unsigned long flags;
++	int n;
+ 
+ 	if (lis->flags & LIS302DL_F_WUP_FF ||
+ 		lis->flags & LIS302DL_F_WUP_CLICK)
+@@ -774,50 +755,28 @@ static int lis302dl_resume(struct spi_device *spi)
+ 	(lis->pdata->lis302dl_suspend_io)(lis, 1);
+ 
+ 	/* resume from powerdown first! */
+-	reg_write(lis, LIS302DL_REG_CTRL1, LIS302DL_CTRL1_PD |
+-					   LIS302DL_CTRL1_Xen |
+-					   LIS302DL_CTRL1_Yen |
+-					   LIS302DL_CTRL1_Zen);
++	(lis->pdata->lis302dl_bitbang_reg_write)(lis, LIS302DL_REG_CTRL1,
++						      LIS302DL_CTRL1_PD |
++						      LIS302DL_CTRL1_Xen |
++						      LIS302DL_CTRL1_Yen |
++						      LIS302DL_CTRL1_Zen);
+ 	mdelay(1);
+ 
+ 	if (__lis302dl_reset_device(lis))
+-		dev_err(&spi->dev, "device BOOT reload failed\n");
++		dev_err(&pdev->dev, "device BOOT reload failed\n");
+ 
+-	/* restore registers after resume */
+-	reg_write(lis, LIS302DL_REG_CTRL1, lis->regs[LIS302DL_REG_CTRL1] |
+-						LIS302DL_CTRL1_PD |
++	lis->regs[LIS302DL_REG_CTRL1] |=	LIS302DL_CTRL1_PD |
+ 						LIS302DL_CTRL1_Xen |
+ 						LIS302DL_CTRL1_Yen |
+-						LIS302DL_CTRL1_Zen);
+-	reg_write(lis, LIS302DL_REG_CTRL2, lis->regs[LIS302DL_REG_CTRL2]);
+-	reg_write(lis, LIS302DL_REG_CTRL3, lis->regs[LIS302DL_REG_CTRL3]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_CFG_1,
+-		  lis->regs[LIS302DL_REG_FF_WU_CFG_1]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_THS_1,
+-		  lis->regs[LIS302DL_REG_FF_WU_THS_1]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_DURATION_1,
+-		  lis->regs[LIS302DL_REG_FF_WU_DURATION_1]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_CFG_2,
+-		  lis->regs[LIS302DL_REG_FF_WU_CFG_2]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_THS_2,
+-		  lis->regs[LIS302DL_REG_FF_WU_THS_2]);
+-	reg_write(lis, LIS302DL_REG_FF_WU_DURATION_2,
+-		  lis->regs[LIS302DL_REG_FF_WU_DURATION_2]);
+-	reg_write(lis, LIS302DL_REG_CLICK_CFG,
+-		  lis->regs[LIS302DL_REG_CLICK_CFG]);
+-	reg_write(lis, LIS302DL_REG_CLICK_THSY_X,
+-		  lis->regs[LIS302DL_REG_CLICK_THSY_X]);
+-	reg_write(lis, LIS302DL_REG_CLICK_THSZ,
+-		  lis->regs[LIS302DL_REG_CLICK_THSZ]);
+-	reg_write(lis, LIS302DL_REG_CLICK_TIME_LIMIT,
+-		  lis->regs[LIS302DL_REG_CLICK_TIME_LIMIT]);
+-	reg_write(lis, LIS302DL_REG_CLICK_LATENCY,
+-		  lis->regs[LIS302DL_REG_CLICK_LATENCY]);
+-	reg_write(lis, LIS302DL_REG_CLICK_WINDOW,
+-		  lis->regs[LIS302DL_REG_CLICK_WINDOW]);
++						LIS302DL_CTRL1_Zen;
++
++	/* restore registers after resume */
++	for (n = 0; n < ARRAY_SIZE(regs_to_save); n++)
++		(lis->pdata->lis302dl_bitbang_reg_write)(lis,
++				   regs_to_save[n], lis->regs[regs_to_save[n]]);
+ 
+ 	local_irq_restore(flags);
+-	enable_irq(lis->spi_dev->irq);
++	enable_irq(lis->pdata->interrupt);
+ 
+ 	return 0;
+ }
+@@ -826,7 +785,7 @@ static int lis302dl_resume(struct spi_device *spi)
+ #define lis302dl_resume		NULL
+ #endif
+ 
+-static struct spi_driver lis302dl_driver = {
++static struct platform_driver lis302dl_driver = {
+ 	.driver = {
+ 		.name	= "lis302dl",
+ 		.owner	= THIS_MODULE,
+@@ -838,14 +797,14 @@ static struct spi_driver lis302dl_driver = {
+ 	.resume	 = lis302dl_resume,
+ };
+ 
+-static int __init lis302dl_init(void)
++static int __devinit lis302dl_init(void)
+ {
+-	return spi_register_driver(&lis302dl_driver);
++	return platform_driver_register(&lis302dl_driver);
+ }
+ 
+ static void __exit lis302dl_exit(void)
+ {
+-	spi_unregister_driver(&lis302dl_driver);
++	platform_driver_unregister(&lis302dl_driver);
+ }
+ 
+ MODULE_AUTHOR("Harald Welte <laforge@openmoko.org>");
+diff --git a/include/linux/lis302dl.h b/include/linux/lis302dl.h
+index 7daa8b3..4578db4 100644
+--- a/include/linux/lis302dl.h
++++ b/include/linux/lis302dl.h
+@@ -15,15 +15,18 @@ struct lis302dl_platform_data {
+ 	unsigned long pin_mosi;
+ 	unsigned long pin_miso;
+ 	int open_drain;
+-	void (*lis302dl_bitbang_read)(struct lis302dl_info *);
++	int interrupt;
++	void (*lis302dl_bitbang_read_sample)(struct lis302dl_info *);
+ 	void (*lis302dl_suspend_io)(struct lis302dl_info *, int resuming);
++	int (*lis302dl_bitbang_reg_read)(struct lis302dl_info *, u8 reg);
++	void (*lis302dl_bitbang_reg_write)(struct lis302dl_info *, u8 reg,
++									u8 val);
+ };
+ 
+ struct lis302dl_info {
+ 	struct lis302dl_platform_data *pdata;
+-	struct spi_device *spi_dev;
++	struct device *dev;
+ 	struct input_dev *input_dev;
+-	struct mutex lock;
+ 	unsigned int flags;
+ 	u_int8_t regs[0x40];
+ };
+-- 
+1.5.6.5
+