Patched in Tegra support.

61 files changed, 2427 insertions, 10261 deletions

diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 2e188e1127e..8f7ee0e1ee4 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -74,7 +74,7 @@ config SPI_ATMEL
           This selects a driver for the Atmel SPI Controller, present on
           many AT32 (AVR32) and AT91 (ARM) chips.
 
-config SPI_BFIN5XX
+config SPI_BFIN
         tristate "SPI controller driver for ADI Blackfin5xx"
         depends on BLACKFIN
         help
@@ -87,18 +87,12 @@ config SPI_BFIN_SPORT
           Enable support for a SPI bus via the Blackfin SPORT peripheral.
 
 config SPI_AU1550
-        tristate "Au1550/Au1200/Au1300 SPI Controller"
-        depends on MIPS_ALCHEMY && EXPERIMENTAL
+        tristate "Au1550/Au12x0 SPI Controller"
+        depends on (SOC_AU1550 || SOC_AU1200) && EXPERIMENTAL
         select SPI_BITBANG
         help
           If you say yes to this option, support will be included for the
-          PSC SPI controller found on Au1550, Au1200 and Au1300 series.
-
-config SPI_BCM63XX
-        tristate "Broadcom BCM63xx SPI controller"
-        depends on BCM63XX
-        help
-          Enable support for the SPI controller on the Broadcom BCM63xx SoCs.
+          Au1550 SPI controller (may also work with Au1200,Au1210,Au1250).
 
 config SPI_BITBANG
         tristate "Utilities for Bitbanging SPI masters"
@@ -123,25 +117,17 @@ config SPI_BUTTERFLY
           inexpensive battery powered microcontroller evaluation board.
           This same cable can be used to flash new firmware.
 
-config SPI_CLPS711X
-        tristate "CLPS711X host SPI controller"
-        depends on ARCH_CLPS711X
-        help
-          This enables dedicated general purpose SPI/Microwire1-compatible
-          master mode interface (SSI1) for CLPS711X-based CPUs.
-
 config SPI_COLDFIRE_QSPI
         tristate "Freescale Coldfire QSPI controller"
-        depends on (M520x || M523x || M5249 || M525x || M527x || M528x || M532x)
+        depends on (M520x || M523x || M5249 || M527x || M528x || M532x)
         help
           This enables support for the Coldfire QSPI controller in master
           mode.
 
 config SPI_DAVINCI
         tristate "Texas Instruments DaVinci/DA8x/OMAP-L/AM1x SoC SPI controller"
-        depends on ARCH_DAVINCI
+        depends on SPI_MASTER && ARCH_DAVINCI
         select SPI_BITBANG
-        select TI_EDMA
         help
           SPI master controller for DaVinci/DA8x/OMAP-L/AM1x SPI modules.
 
@@ -152,15 +138,6 @@ config SPI_EP93XX
           This enables using the Cirrus EP93xx SPI controller in master
           mode.
 
-config SPI_FALCON
-        tristate "Falcon SPI controller support"
-        depends on SOC_FALCON
-        help
-          The external bus unit (EBU) found on the FALC-ON SoC has SPI
-          emulation that is designed for serial flash access. This driver
-          has only been tested with m25p80 type chips. The hardware has no
-          support for other types of SPI peripherals.
-
 config SPI_GPIO
         tristate "GPIO-based bitbanging SPI Master"
         depends on GENERIC_GPIO
@@ -197,7 +174,8 @@ config SPI_LM70_LLP
 
 config SPI_MPC52xx
         tristate "Freescale MPC52xx SPI (non-PSC) controller support"
-        depends on PPC_MPC52xx
+        depends on PPC_MPC52xx && SPI
+        select SPI_MASTER_OF
         help
           This drivers supports the MPC52xx SPI controller in master SPI
           mode.
@@ -211,7 +189,7 @@ config SPI_MPC52xx_PSC
 
 config SPI_MPC512x_PSC
         tristate "Freescale MPC512x PSC SPI controller"
-        depends on PPC_MPC512x
+        depends on SPI_MASTER && PPC_MPC512x
         help
           This enables using the Freescale MPC5121 Programmable Serial
           Controller in SPI master mode.
@@ -221,7 +199,7 @@ config SPI_FSL_LIB
         depends on FSL_SOC
 
 config SPI_FSL_SPI
-        bool "Freescale SPI controller"
+        tristate "Freescale SPI controller"
         depends on FSL_SOC
         select SPI_FSL_LIB
         help
@@ -230,7 +208,7 @@ config SPI_FSL_SPI
           MPC8569 uses the controller in QE mode, MPC8610 in cpu mode.
 
 config SPI_FSL_ESPI
-        bool "Freescale eSPI controller"
+        tristate "Freescale eSPI controller"
         depends on FSL_SOC
         select SPI_FSL_LIB
         help
@@ -245,13 +223,6 @@ config SPI_OC_TINY
         help
           This is the driver for OpenCores tiny SPI master controller.
 
-config SPI_OCTEON
-        tristate "Cavium OCTEON SPI controller"
-        depends on CPU_CAVIUM_OCTEON
-        help
-          SPI host driver for the hardware found on some Cavium OCTEON
-          SOCs.
-
 config SPI_OMAP_UWIRE
         tristate "OMAP1 MicroWire"
         depends on ARCH_OMAP1
@@ -268,7 +239,7 @@ config SPI_OMAP24XX
 
 config SPI_OMAP_100K
         tristate "OMAP SPI 100K"
-        depends on ARCH_OMAP850 || ARCH_OMAP730
+        depends on SPI_MASTER && (ARCH_OMAP850 || ARCH_OMAP730)
         help
           OMAP SPI 100K master controller for omap7xx boards.
 
@@ -292,7 +263,7 @@ config SPI_PL022
 
 config SPI_PPC4xx
         tristate "PPC4xx SPI Controller"
-        depends on PPC32 && 4xx
+        depends on PPC32 && 4xx && SPI_MASTER
         select SPI_BITBANG
         help
           This selects a driver for the PPC4xx SPI Controller.
@@ -309,15 +280,9 @@ config SPI_PXA2XX
 config SPI_PXA2XX_PCI
         def_bool SPI_PXA2XX && X86_32 && PCI
 
-config SPI_RSPI
-        tristate "Renesas RSPI controller"
-        depends on SUPERH
-        help
-          SPI driver for Renesas RSPI blocks.
-
 config SPI_S3C24XX
         tristate "Samsung S3C24XX series SPI"
-        depends on ARCH_S3C24XX && EXPERIMENTAL
+        depends on ARCH_S3C2410 && EXPERIMENTAL
         select SPI_BITBANG
         help
           SPI driver for Samsung S3C24XX series ARM SoCs
@@ -335,23 +300,17 @@ config SPI_S3C24XX_FIQ
 
 config SPI_S3C64XX
         tristate "Samsung S3C64XX series type SPI"
-        depends on (ARCH_S3C24XX || ARCH_S3C64XX || ARCH_S5P64X0 || ARCH_EXYNOS)
+        depends on (ARCH_S3C64XX || ARCH_S5P64X0)
         select S3C64XX_DMA if ARCH_S3C64XX
         help
           SPI driver for Samsung S3C64XX and newer SoCs.
 
-config SPI_SC18IS602
-        tristate "NXP SC18IS602/602B/603 I2C to SPI bridge"
-        depends on I2C
-        help
-          SPI driver for NXP SC18IS602/602B/603 I2C to SPI bridge.
-
 config SPI_SH_MSIOF
         tristate "SuperH MSIOF SPI controller"
-        depends on (SUPERH || ARCH_SHMOBILE) && HAVE_CLK
+        depends on SUPERH && HAVE_CLK
         select SPI_BITBANG
         help
-          SPI driver for SuperH and SH Mobile MSIOF blocks.
+          SPI driver for SuperH MSIOF blocks.
 
 config SPI_SH
         tristate "SuperH SPI controller"
@@ -366,39 +325,28 @@ config SPI_SH_SCI
         help
           SPI driver for SuperH SCI blocks.
 
-config SPI_SH_HSPI
-        tristate "SuperH HSPI controller"
-        depends on ARCH_SHMOBILE
-        help
-          SPI driver for SuperH HSPI blocks.
-
-config SPI_SIRF
-        tristate "CSR SiRFprimaII SPI controller"
-        depends on ARCH_PRIMA2
-        select SPI_BITBANG
-        help
-          SPI driver for CSR SiRFprimaII SoCs
-
-config SPI_MXS
-        tristate "Freescale MXS SPI controller"
-        depends on ARCH_MXS
-        select STMP_DEVICE
+config SPI_STMP3XXX
+        tristate "Freescale STMP37xx/378x SPI/SSP controller"
+        depends on ARCH_STMP3XXX && SPI_MASTER
         help
-          SPI driver for Freescale MXS devices.
+          SPI driver for Freescale STMP37xx/378x SoC SSP interface
 
-config SPI_TEGRA20_SFLASH
-        tristate "Nvidia Tegra20 Serial flash Controller"
+config SPI_TEGRA
+        tristate "Nvidia Tegra SPI controller"
         depends on ARCH_TEGRA
+        select TEGRA_SYSTEM_DMA
         help
-          SPI driver for Nvidia Tegra20 Serial flash Controller interface.
-          The main usecase of this controller is to use spi flash as boot
-          device.
+          SPI driver for NVidia Tegra SoCs
 
-config SPI_TEGRA20_SLINK
-        tristate "Nvidia Tegra20/Tegra30 SLINK Controller"
-        depends on ARCH_TEGRA && TEGRA20_APB_DMA
+config SPI_SLAVE_TEGRA
+        tristate "Nvidia Tegra SPI slave controller"
+        depends on ARCH_TEGRA
+        select TEGRA_SYSTEM_DMA
+        default n
         help
-          SPI driver for Nvidia Tegra20/Tegra30 SLINK Controller interface.
+          SPI Slave driver for NVidia Tegra SoCs.
+          Say yes if slave spi functionality is required from the tegra spi controller.
+          The interface is same as the master spi.
 
 config SPI_TI_SSP
         tristate "TI Sequencer Serial Port - SPI Support"
@@ -408,14 +356,14 @@ config SPI_TI_SSP
           serial port.
 
 config SPI_TOPCLIFF_PCH
-        tristate "Intel EG20T PCH/LAPIS Semicon IOH(ML7213/ML7223/ML7831) SPI"
+        tristate "Intel EG20T PCH/OKI SEMICONDUCTOR ML7213 IOH SPI controller"
         depends on PCI
         help
           SPI driver for the Topcliff PCH (Platform Controller Hub) SPI bus
           used in some x86 embedded processors.
 
-          This driver also supports the ML7213/ML7223/ML7831, a companion chip
-          for the Atom E6xx series and compatible with the Intel EG20T PCH.
+          This driver also supports the ML7213, a companion chip for the
+          Atom E6xx series and compatible with the Intel EG20T PCH.
 
 config SPI_TXX9
         tristate "Toshiba TXx9 SPI controller"
@@ -423,13 +371,6 @@ config SPI_TXX9
         help
           SPI driver for Toshiba TXx9 MIPS SoCs
 
-config SPI_XCOMM
-        tristate "Analog Devices AD-FMCOMMS1-EBZ SPI-I2C-bridge driver"
-        depends on I2C
-        help
-          Support for the SPI-I2C bridge found on the Analog Devices
-          AD-FMCOMMS1-EBZ board.
-
 config SPI_XILINX
         tristate "Xilinx SPI controller common module"
         depends on HAS_IOMEM && EXPERIMENTAL
@@ -455,6 +396,7 @@ config SPI_NUC900
 
 config SPI_DESIGNWARE
         tristate "DesignWare SPI controller core support"
+        depends on SPI_MASTER
         help
           general driver for SPI controller core from DesignWare
 
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 64e970ba261..430f8200108 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -1,6 +1,7 @@
 #
 # Makefile for kernel SPI drivers.
 #
+GCOV_PROFILE := y
 
 ccflags-$(CONFIG_SPI_DEBUG) := -DDEBUG
 
@@ -14,12 +15,10 @@ obj-$(CONFIG_SPI_ALTERA)		+= spi-altera.o
 obj-$(CONFIG_SPI_ATMEL)                 += spi-atmel.o
 obj-$(CONFIG_SPI_ATH79)                 += spi-ath79.o
 obj-$(CONFIG_SPI_AU1550)                += spi-au1550.o
-obj-$(CONFIG_SPI_BCM63XX)               += spi-bcm63xx.o
-obj-$(CONFIG_SPI_BFIN5XX)               += spi-bfin5xx.o
+obj-$(CONFIG_SPI_BFIN)                  += spi-bfin5xx.o
 obj-$(CONFIG_SPI_BFIN_SPORT)            += spi-bfin-sport.o
 obj-$(CONFIG_SPI_BITBANG)               += spi-bitbang.o
 obj-$(CONFIG_SPI_BUTTERFLY)             += spi-butterfly.o
-obj-$(CONFIG_SPI_CLPS711X)              += spi-clps711x.o
 obj-$(CONFIG_SPI_COLDFIRE_QSPI)         += spi-coldfire-qspi.o
 obj-$(CONFIG_SPI_DAVINCI)               += spi-davinci.o
 obj-$(CONFIG_SPI_DESIGNWARE)            += spi-dw.o
@@ -27,7 +26,6 @@ obj-$(CONFIG_SPI_DW_MMIO)		+= spi-dw-mmio.o
 obj-$(CONFIG_SPI_DW_PCI)                += spi-dw-midpci.o
 spi-dw-midpci-objs                      := spi-dw-pci.o spi-dw-mid.o
 obj-$(CONFIG_SPI_EP93XX)                += spi-ep93xx.o
-obj-$(CONFIG_SPI_FALCON)                += spi-falcon.o
 obj-$(CONFIG_SPI_FSL_LIB)               += spi-fsl-lib.o
 obj-$(CONFIG_SPI_FSL_ESPI)              += spi-fsl-espi.o
 obj-$(CONFIG_SPI_FSL_SPI)               += spi-fsl-spi.o
@@ -37,10 +35,8 @@ obj-$(CONFIG_SPI_LM70_LLP)		+= spi-lm70llp.o
 obj-$(CONFIG_SPI_MPC512x_PSC)           += spi-mpc512x-psc.o
 obj-$(CONFIG_SPI_MPC52xx_PSC)           += spi-mpc52xx-psc.o
 obj-$(CONFIG_SPI_MPC52xx)               += spi-mpc52xx.o
-obj-$(CONFIG_SPI_MXS)                   += spi-mxs.o
 obj-$(CONFIG_SPI_NUC900)                += spi-nuc900.o
 obj-$(CONFIG_SPI_OC_TINY)               += spi-oc-tiny.o
-obj-$(CONFIG_SPI_OCTEON)                += spi-octeon.o
 obj-$(CONFIG_SPI_OMAP_UWIRE)            += spi-omap-uwire.o
 obj-$(CONFIG_SPI_OMAP_100K)             += spi-omap-100k.o
 obj-$(CONFIG_SPI_OMAP24XX)              += spi-omap2-mcspi.o
@@ -49,22 +45,19 @@ obj-$(CONFIG_SPI_PL022)			+= spi-pl022.o
 obj-$(CONFIG_SPI_PPC4xx)                += spi-ppc4xx.o
 obj-$(CONFIG_SPI_PXA2XX)                += spi-pxa2xx.o
 obj-$(CONFIG_SPI_PXA2XX_PCI)            += spi-pxa2xx-pci.o
-obj-$(CONFIG_SPI_RSPI)                  += spi-rspi.o
 obj-$(CONFIG_SPI_S3C24XX)               += spi-s3c24xx-hw.o
 spi-s3c24xx-hw-y                        := spi-s3c24xx.o
 spi-s3c24xx-hw-$(CONFIG_SPI_S3C24XX_FIQ) += spi-s3c24xx-fiq.o
 obj-$(CONFIG_SPI_S3C64XX)               += spi-s3c64xx.o
-obj-$(CONFIG_SPI_SC18IS602)             += spi-sc18is602.o
 obj-$(CONFIG_SPI_SH)                    += spi-sh.o
-obj-$(CONFIG_SPI_SH_HSPI)               += spi-sh-hspi.o
 obj-$(CONFIG_SPI_SH_MSIOF)              += spi-sh-msiof.o
 obj-$(CONFIG_SPI_SH_SCI)                += spi-sh-sci.o
-obj-$(CONFIG_SPI_SIRF)          += spi-sirf.o
-obj-$(CONFIG_SPI_TEGRA20_SFLASH)        += spi-tegra20-sflash.o
-obj-$(CONFIG_SPI_TEGRA20_SLINK)         += spi-tegra20-slink.o
+obj-$(CONFIG_SPI_STMP3XXX)              += spi-stmp.o
+obj-$(CONFIG_SPI_TEGRA)                 += spi-tegra.o
+obj-$(CONFIG_SPI_SLAVE_TEGRA)           += spi_slave_tegra.o
 obj-$(CONFIG_SPI_TI_SSP)                += spi-ti-ssp.o
 obj-$(CONFIG_SPI_TLE62X0)               += spi-tle62x0.o
 obj-$(CONFIG_SPI_TOPCLIFF_PCH)          += spi-topcliff-pch.o
 obj-$(CONFIG_SPI_TXX9)                  += spi-txx9.o
-obj-$(CONFIG_SPI_XCOMM)         += spi-xcomm.o
 obj-$(CONFIG_SPI_XILINX)                += spi-xilinx.o
+
diff --git a/drivers/spi/spi-altera.c b/drivers/spi/spi-altera.c
index 5e7314ac51e..4813a63ce6f 100644
--- a/drivers/spi/spi-altera.c
+++ b/drivers/spi/spi-altera.c
@@ -16,7 +16,6 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
@@ -215,7 +214,7 @@ static irqreturn_t altera_spi_irq(int irq, void *dev)
         return IRQ_HANDLED;
 }
 
-static int altera_spi_probe(struct platform_device *pdev)
+static int __devinit altera_spi_probe(struct platform_device *pdev)
 {
         struct altera_spi_platform_data *platp = pdev->dev.platform_data;
         struct altera_spi *hw;
@@ -290,7 +289,7 @@ exit:
         return err;
 }
 
-static int altera_spi_remove(struct platform_device *dev)
+static int __devexit altera_spi_remove(struct platform_device *dev)
 {
         struct altera_spi *hw = platform_get_drvdata(dev);
         struct spi_master *master = hw->bitbang.master;
@@ -307,19 +306,32 @@ static const struct of_device_id altera_spi_match[] = {
         {},
 };
 MODULE_DEVICE_TABLE(of, altera_spi_match);
+#else /* CONFIG_OF */
+#define altera_spi_match NULL
 #endif /* CONFIG_OF */
 
 static struct platform_driver altera_spi_driver = {
         .probe = altera_spi_probe,
-        .remove = altera_spi_remove,
+        .remove = __devexit_p(altera_spi_remove),
         .driver = {
                 .name = DRV_NAME,
                 .owner = THIS_MODULE,
                 .pm = NULL,
-                .of_match_table = of_match_ptr(altera_spi_match),
+                .of_match_table = altera_spi_match,
         },
 };
-module_platform_driver(altera_spi_driver);
+
+static int __init altera_spi_init(void)
+{
+        return platform_driver_register(&altera_spi_driver);
+}
+module_init(altera_spi_init);
+
+static void __exit altera_spi_exit(void)
+{
+        platform_driver_unregister(&altera_spi_driver);
+}
+module_exit(altera_spi_exit);
 
 MODULE_DESCRIPTION("Altera SPI driver");
 MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
diff --git a/drivers/spi/spi-ath79.c b/drivers/spi/spi-ath79.c
index 9a5d7791c5f..03019bf5a5e 100644
--- a/drivers/spi/spi-ath79.c
+++ b/drivers/spi/spi-ath79.c
@@ -13,7 +13,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/delay.h>
 #include <linux/spinlock.h>
@@ -192,7 +191,7 @@ static u32 ath79_spi_txrx_mode0(struct spi_device *spi, unsigned nsecs,
         return ath79_spi_rr(sp, AR71XX_SPI_REG_RDS);
 }
 
-static int ath79_spi_probe(struct platform_device *pdev)
+static __devinit int ath79_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct ath79_spi *sp;
@@ -216,6 +215,9 @@ static int ath79_spi_probe(struct platform_device *pdev)
         if (pdata) {
                 master->bus_num = pdata->bus_num;
                 master->num_chipselect = pdata->num_chipselect;
+        } else {
+                master->bus_num = -1;
+                master->num_chipselect = 1;
         }
 
         sp->bitbang.master = spi_master_get(master);
@@ -251,7 +253,7 @@ err_put_master:
         return ret;
 }
 
-static int ath79_spi_remove(struct platform_device *pdev)
+static __devexit int ath79_spi_remove(struct platform_device *pdev)
 {
         struct ath79_spi *sp = platform_get_drvdata(pdev);
 
@@ -265,13 +267,24 @@ static int ath79_spi_remove(struct platform_device *pdev)
 
 static struct platform_driver ath79_spi_driver = {
         .probe          = ath79_spi_probe,
-        .remove         = ath79_spi_remove,
+        .remove         = __devexit_p(ath79_spi_remove),
         .driver         = {
                 .name   = DRV_NAME,
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(ath79_spi_driver);
+
+static __init int ath79_spi_init(void)
+{
+        return platform_driver_register(&ath79_spi_driver);
+}
+module_init(ath79_spi_init);
+
+static __exit void ath79_spi_exit(void)
+{
+        platform_driver_unregister(&ath79_spi_driver);
+}
+module_exit(ath79_spi_exit);
 
 MODULE_DESCRIPTION("SPI controller driver for Atheros AR71XX/AR724X/AR913X");
 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index ab34497bcfe..82dee9a6c0d 100644
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -19,11 +19,10 @@
 #include <linux/interrupt.h>
 #include <linux/spi/spi.h>
 #include <linux/slab.h>
-#include <linux/platform_data/atmel.h>
-#include <linux/of.h>
 
 #include <asm/io.h>
-#include <asm/gpio.h>
+#include <mach/board.h>
+#include <mach/gpio.h>
 #include <mach/cpu.h>
 
 /* SPI register offsets */
@@ -769,10 +768,6 @@ static int atmel_spi_setup(struct spi_device *spi)
 
         /* chipselect must have been muxed as GPIO (e.g. in board setup) */
         npcs_pin = (unsigned int)spi->controller_data;
-
-        if (gpio_is_valid(spi->cs_gpio))
-                npcs_pin = spi->cs_gpio;
-
         asd = spi->controller_state;
         if (!asd) {
                 asd = kzalloc(sizeof(struct atmel_spi_device), GFP_KERNEL);
@@ -912,7 +907,7 @@ static void atmel_spi_cleanup(struct spi_device *spi)
 
 /*-------------------------------------------------------------------------*/
 
-static int atmel_spi_probe(struct platform_device *pdev)
+static int __init atmel_spi_probe(struct platform_device *pdev)
 {
         struct resource         *regs;
         int                     irq;
@@ -942,9 +937,8 @@ static int atmel_spi_probe(struct platform_device *pdev)
         /* the spi->mode bits understood by this driver: */
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 
-        master->dev.of_node = pdev->dev.of_node;
         master->bus_num = pdev->id;
-        master->num_chipselect = master->dev.of_node ? 0 : 4;
+        master->num_chipselect = 4;
         master->setup = atmel_spi_setup;
         master->transfer = atmel_spi_transfer;
         master->cleanup = atmel_spi_cleanup;
@@ -1009,7 +1003,7 @@ out_free:
         return ret;
 }
 
-static int atmel_spi_remove(struct platform_device *pdev)
+static int __exit atmel_spi_remove(struct platform_device *pdev)
 {
         struct spi_master       *master = platform_get_drvdata(pdev);
         struct atmel_spi        *as = spi_master_get_devdata(master);
@@ -1070,27 +1064,28 @@ static int atmel_spi_resume(struct platform_device *pdev)
 #define atmel_spi_resume        NULL
 #endif
 
-#if defined(CONFIG_OF)
-static const struct of_device_id atmel_spi_dt_ids[] = {
-        { .compatible = "atmel,at91rm9200-spi" },
-        { /* sentinel */ }
-};
-
-MODULE_DEVICE_TABLE(of, atmel_spi_dt_ids);
-#endif
 
 static struct platform_driver atmel_spi_driver = {
         .driver         = {
                 .name   = "atmel_spi",
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(atmel_spi_dt_ids),
         },
         .suspend        = atmel_spi_suspend,
         .resume         = atmel_spi_resume,
-        .probe          = atmel_spi_probe,
         .remove         = __exit_p(atmel_spi_remove),
 };
-module_platform_driver(atmel_spi_driver);
+
+static int __init atmel_spi_init(void)
+{
+        return platform_driver_probe(&atmel_spi_driver, atmel_spi_probe);
+}
+module_init(atmel_spi_init);
+
+static void __exit atmel_spi_exit(void)
+{
+        platform_driver_unregister(&atmel_spi_driver);
+}
+module_exit(atmel_spi_exit);
 
 MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
diff --git a/drivers/spi/spi-au1550.c b/drivers/spi/spi-au1550.c
index 4de66d1cfe5..bddee5f516b 100644
--- a/drivers/spi/spi-au1550.c
+++ b/drivers/spi/spi-au1550.c
@@ -25,7 +25,6 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/resource.h>
@@ -475,7 +474,7 @@ static irqreturn_t au1550_spi_dma_irq_callback(struct au1550_spi *hw)
                 /*
                  * due to an spi error we consider transfer as done,
                  * so mask all events until before next transfer start
-                 * and stop the possibly running dma immediately
+                 * and stop the possibly running dma immediatelly
                  */
                 au1550_spi_mask_ack_all(hw);
                 au1xxx_dbdma_stop(hw->dma_rx_ch);
diff --git a/drivers/spi/spi-bcm63xx.c b/drivers/spi/spi-bcm63xx.c
deleted file mode 100644
index f44ab550853..00000000000
--- a/drivers/spi/spi-bcm63xx.c
+++ /dev/null
@@ -1,526 +0,0 @@
-/*
- * Broadcom BCM63xx SPI controller support
- *
- * Copyright (C) 2009-2012 Florian Fainelli <florian@openwrt.org>
- * Copyright (C) 2010 Tanguy Bouzeloc <tanguy.bouzeloc@efixo.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version 2
- * of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the
- * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/clk.h>
-#include <linux/io.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/delay.h>
-#include <linux/interrupt.h>
-#include <linux/spi/spi.h>
-#include <linux/completion.h>
-#include <linux/err.h>
-#include <linux/workqueue.h>
-#include <linux/pm_runtime.h>
-
-#include <bcm63xx_dev_spi.h>
-
-#define PFX             KBUILD_MODNAME
-
-struct bcm63xx_spi {
-        struct completion       done;
-
-        void __iomem            *regs;
-        int                     irq;
-
-        /* Platform data */
-        u32                     speed_hz;
-        unsigned                fifo_size;
-        unsigned int            msg_type_shift;
-        unsigned int            msg_ctl_width;
-
-        /* Data buffers */
-        const unsigned char     *tx_ptr;
-        unsigned char           *rx_ptr;
-
-        /* data iomem */
-        u8 __iomem              *tx_io;
-        const u8 __iomem        *rx_io;
-
-        int                     remaining_bytes;
-
-        struct clk              *clk;
-        struct platform_device  *pdev;
-};
-
-static inline u8 bcm_spi_readb(struct bcm63xx_spi *bs,
-                                unsigned int offset)
-{
-        return bcm_readb(bs->regs + bcm63xx_spireg(offset));
-}
-
-static inline u16 bcm_spi_readw(struct bcm63xx_spi *bs,
-                                unsigned int offset)
-{
-        return bcm_readw(bs->regs + bcm63xx_spireg(offset));
-}
-
-static inline void bcm_spi_writeb(struct bcm63xx_spi *bs,
-                                  u8 value, unsigned int offset)
-{
-        bcm_writeb(value, bs->regs + bcm63xx_spireg(offset));
-}
-
-static inline void bcm_spi_writew(struct bcm63xx_spi *bs,
-                                  u16 value, unsigned int offset)
-{
-        bcm_writew(value, bs->regs + bcm63xx_spireg(offset));
-}
-
-static const unsigned bcm63xx_spi_freq_table[SPI_CLK_MASK][2] = {
-        { 20000000, SPI_CLK_20MHZ },
-        { 12500000, SPI_CLK_12_50MHZ },
-        {  6250000, SPI_CLK_6_250MHZ },
-        {  3125000, SPI_CLK_3_125MHZ },
-        {  1563000, SPI_CLK_1_563MHZ },
-        {   781000, SPI_CLK_0_781MHZ },
-        {   391000, SPI_CLK_0_391MHZ }
-};
-
-static int bcm63xx_spi_check_transfer(struct spi_device *spi,
-                                        struct spi_transfer *t)
-{
-        u8 bits_per_word;
-
-        bits_per_word = (t) ? t->bits_per_word : spi->bits_per_word;
-        if (bits_per_word != 8) {
-                dev_err(&spi->dev, "%s, unsupported bits_per_word=%d\n",
-                        __func__, bits_per_word);
-                return -EINVAL;
-        }
-
-        if (spi->chip_select > spi->master->num_chipselect) {
-                dev_err(&spi->dev, "%s, unsupported slave %d\n",
-                        __func__, spi->chip_select);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static void bcm63xx_spi_setup_transfer(struct spi_device *spi,
-                                      struct spi_transfer *t)
-{
-        struct bcm63xx_spi *bs = spi_master_get_devdata(spi->master);
-        u32 hz;
-        u8 clk_cfg, reg;
-        int i;
-
-        hz = (t) ? t->speed_hz : spi->max_speed_hz;
-
-        /* Find the closest clock configuration */
-        for (i = 0; i < SPI_CLK_MASK; i++) {
-                if (hz >= bcm63xx_spi_freq_table[i][0]) {
-                        clk_cfg = bcm63xx_spi_freq_table[i][1];
-                        break;
-                }
-        }
-
-        /* No matching configuration found, default to lowest */
-        if (i == SPI_CLK_MASK)
-                clk_cfg = SPI_CLK_0_391MHZ;
-
-        /* clear existing clock configuration bits of the register */
-        reg = bcm_spi_readb(bs, SPI_CLK_CFG);
-        reg &= ~SPI_CLK_MASK;
-        reg |= clk_cfg;
-
-        bcm_spi_writeb(bs, reg, SPI_CLK_CFG);
-        dev_dbg(&spi->dev, "Setting clock register to %02x (hz %d)\n",
-                clk_cfg, hz);
-}
-
-/* the spi->mode bits understood by this driver: */
-#define MODEBITS (SPI_CPOL | SPI_CPHA)
-
-static int bcm63xx_spi_setup(struct spi_device *spi)
-{
-        struct bcm63xx_spi *bs;
-        int ret;
-
-        bs = spi_master_get_devdata(spi->master);
-
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-
-        if (spi->mode & ~MODEBITS) {
-                dev_err(&spi->dev, "%s, unsupported mode bits %x\n",
-                        __func__, spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
-
-        dev_dbg(&spi->dev, "%s, mode %d, %u bits/w, %u nsec/bit\n",
-                __func__, spi->mode & MODEBITS, spi->bits_per_word, 0);
-
-        return 0;
-}
-
-/* Fill the TX FIFO with as many bytes as possible */
-static void bcm63xx_spi_fill_tx_fifo(struct bcm63xx_spi *bs)
-{
-        u8 size;
-
-        /* Fill the Tx FIFO with as many bytes as possible */
-        size = bs->remaining_bytes < bs->fifo_size ? bs->remaining_bytes :
-                bs->fifo_size;
-        memcpy_toio(bs->tx_io, bs->tx_ptr, size);
-        bs->remaining_bytes -= size;
-}
-
-static unsigned int bcm63xx_txrx_bufs(struct spi_device *spi,
-                                        struct spi_transfer *t)
-{
-        struct bcm63xx_spi *bs = spi_master_get_devdata(spi->master);
-        u16 msg_ctl;
-        u16 cmd;
-
-        /* Disable the CMD_DONE interrupt */
-        bcm_spi_writeb(bs, 0, SPI_INT_MASK);
-
-        dev_dbg(&spi->dev, "txrx: tx %p, rx %p, len %d\n",
-                t->tx_buf, t->rx_buf, t->len);
-
-        /* Transmitter is inhibited */
-        bs->tx_ptr = t->tx_buf;
-        bs->rx_ptr = t->rx_buf;
-
-        if (t->tx_buf) {
-                bs->remaining_bytes = t->len;
-                bcm63xx_spi_fill_tx_fifo(bs);
-        }
-
-        init_completion(&bs->done);
-
-        /* Fill in the Message control register */
-        msg_ctl = (t->len << SPI_BYTE_CNT_SHIFT);
-
-        if (t->rx_buf && t->tx_buf)
-                msg_ctl |= (SPI_FD_RW << bs->msg_type_shift);
-        else if (t->rx_buf)
-                msg_ctl |= (SPI_HD_R << bs->msg_type_shift);
-        else if (t->tx_buf)
-                msg_ctl |= (SPI_HD_W << bs->msg_type_shift);
-
-        switch (bs->msg_ctl_width) {
-        case 8:
-                bcm_spi_writeb(bs, msg_ctl, SPI_MSG_CTL);
-                break;
-        case 16:
-                bcm_spi_writew(bs, msg_ctl, SPI_MSG_CTL);
-                break;
-        }
-
-        /* Issue the transfer */
-        cmd = SPI_CMD_START_IMMEDIATE;
-        cmd |= (0 << SPI_CMD_PREPEND_BYTE_CNT_SHIFT);
-        cmd |= (spi->chip_select << SPI_CMD_DEVICE_ID_SHIFT);
-        bcm_spi_writew(bs, cmd, SPI_CMD);
-
-        /* Enable the CMD_DONE interrupt */
-        bcm_spi_writeb(bs, SPI_INTR_CMD_DONE, SPI_INT_MASK);
-
-        return t->len - bs->remaining_bytes;
-}
-
-static int bcm63xx_spi_prepare_transfer(struct spi_master *master)
-{
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-
-        pm_runtime_get_sync(&bs->pdev->dev);
-
-        return 0;
-}
-
-static int bcm63xx_spi_unprepare_transfer(struct spi_master *master)
-{
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-
-        pm_runtime_put(&bs->pdev->dev);
-
-        return 0;
-}
-
-static int bcm63xx_spi_transfer_one(struct spi_master *master,
-                                        struct spi_message *m)
-{
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-        struct spi_transfer *t;
-        struct spi_device *spi = m->spi;
-        int status = 0;
-        unsigned int timeout = 0;
-
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                unsigned int len = t->len;
-                u8 rx_tail;
-
-                status = bcm63xx_spi_check_transfer(spi, t);
-                if (status < 0)
-                        goto exit;
-
-                /* configure adapter for a new transfer */
-                bcm63xx_spi_setup_transfer(spi, t);
-
-                while (len) {
-                        /* send the data */
-                        len -= bcm63xx_txrx_bufs(spi, t);
-
-                        timeout = wait_for_completion_timeout(&bs->done, HZ);
-                        if (!timeout) {
-                                status = -ETIMEDOUT;
-                                goto exit;
-                        }
-
-                        /* read out all data */
-                        rx_tail = bcm_spi_readb(bs, SPI_RX_TAIL);
-
-                        /* Read out all the data */
-                        if (rx_tail)
-                                memcpy_fromio(bs->rx_ptr, bs->rx_io, rx_tail);
-                }
-
-                m->actual_length += t->len;
-        }
-exit:
-        m->status = status;
-        spi_finalize_current_message(master);
-
-        return 0;
-}
-
-/* This driver supports single master mode only. Hence
- * CMD_DONE is the only interrupt we care about
- */
-static irqreturn_t bcm63xx_spi_interrupt(int irq, void *dev_id)
-{
-        struct spi_master *master = (struct spi_master *)dev_id;
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-        u8 intr;
-
-        /* Read interupts and clear them immediately */
-        intr = bcm_spi_readb(bs, SPI_INT_STATUS);
-        bcm_spi_writeb(bs, SPI_INTR_CLEAR_ALL, SPI_INT_STATUS);
-        bcm_spi_writeb(bs, 0, SPI_INT_MASK);
-
-        /* A transfer completed */
-        if (intr & SPI_INTR_CMD_DONE)
-                complete(&bs->done);
-
-        return IRQ_HANDLED;
-}
-
-
-static int bcm63xx_spi_probe(struct platform_device *pdev)
-{
-        struct resource *r;
-        struct device *dev = &pdev->dev;
-        struct bcm63xx_spi_pdata *pdata = pdev->dev.platform_data;
-        int irq;
-        struct spi_master *master;
-        struct clk *clk;
-        struct bcm63xx_spi *bs;
-        int ret;
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r) {
-                dev_err(dev, "no iomem\n");
-                ret = -ENXIO;
-                goto out;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(dev, "no irq\n");
-                ret = -ENXIO;
-                goto out;
-        }
-
-        clk = clk_get(dev, "spi");
-        if (IS_ERR(clk)) {
-                dev_err(dev, "no clock for device\n");
-                ret = PTR_ERR(clk);
-                goto out;
-        }
-
-        master = spi_alloc_master(dev, sizeof(*bs));
-        if (!master) {
-                dev_err(dev, "out of memory\n");
-                ret = -ENOMEM;
-                goto out_clk;
-        }
-
-        bs = spi_master_get_devdata(master);
-
-        platform_set_drvdata(pdev, master);
-        bs->pdev = pdev;
-
-        if (!devm_request_mem_region(&pdev->dev, r->start,
-                                        resource_size(r), PFX)) {
-                dev_err(dev, "iomem request failed\n");
-                ret = -ENXIO;
-                goto out_err;
-        }
-
-        bs->regs = devm_ioremap_nocache(&pdev->dev, r->start,
-                                                        resource_size(r));
-        if (!bs->regs) {
-                dev_err(dev, "unable to ioremap regs\n");
-                ret = -ENOMEM;
-                goto out_err;
-        }
-
-        bs->irq = irq;
-        bs->clk = clk;
-        bs->fifo_size = pdata->fifo_size;
-
-        ret = devm_request_irq(&pdev->dev, irq, bcm63xx_spi_interrupt, 0,
-                                                        pdev->name, master);
-        if (ret) {
-                dev_err(dev, "unable to request irq\n");
-                goto out_err;
-        }
-
-        master->bus_num = pdata->bus_num;
-        master->num_chipselect = pdata->num_chipselect;
-        master->setup = bcm63xx_spi_setup;
-        master->prepare_transfer_hardware = bcm63xx_spi_prepare_transfer;
-        master->unprepare_transfer_hardware = bcm63xx_spi_unprepare_transfer;
-        master->transfer_one_message = bcm63xx_spi_transfer_one;
-        master->mode_bits = MODEBITS;
-        bs->speed_hz = pdata->speed_hz;
-        bs->msg_type_shift = pdata->msg_type_shift;
-        bs->msg_ctl_width = pdata->msg_ctl_width;
-        bs->tx_io = (u8 *)(bs->regs + bcm63xx_spireg(SPI_MSG_DATA));
-        bs->rx_io = (const u8 *)(bs->regs + bcm63xx_spireg(SPI_RX_DATA));
-
-        switch (bs->msg_ctl_width) {
-        case 8:
-        case 16:
-                break;
-        default:
-                dev_err(dev, "unsupported MSG_CTL width: %d\n",
-                         bs->msg_ctl_width);
-                goto out_clk_disable;
-        }
-
-        /* Initialize hardware */
-        clk_enable(bs->clk);
-        bcm_spi_writeb(bs, SPI_INTR_CLEAR_ALL, SPI_INT_STATUS);
-
-        /* register and we are done */
-        ret = spi_register_master(master);
-        if (ret) {
-                dev_err(dev, "spi register failed\n");
-                goto out_clk_disable;
-        }
-
-        dev_info(dev, "at 0x%08x (irq %d, FIFOs size %d)\n",
-                 r->start, irq, bs->fifo_size);
-
-        return 0;
-
-out_clk_disable:
-        clk_disable(clk);
-out_err:
-        platform_set_drvdata(pdev, NULL);
-        spi_master_put(master);
-out_clk:
-        clk_put(clk);
-out:
-        return ret;
-}
-
-static int bcm63xx_spi_remove(struct platform_device *pdev)
-{
-        struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-
-        spi_unregister_master(master);
-
-        /* reset spi block */
-        bcm_spi_writeb(bs, 0, SPI_INT_MASK);
-
-        /* HW shutdown */
-        clk_disable(bs->clk);
-        clk_put(bs->clk);
-
-        platform_set_drvdata(pdev, 0);
-
-        spi_master_put(master);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int bcm63xx_spi_suspend(struct device *dev)
-{
-        struct spi_master *master =
-                        platform_get_drvdata(to_platform_device(dev));
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-
-        spi_master_suspend(master);
-
-        clk_disable(bs->clk);
-
-        return 0;
-}
-
-static int bcm63xx_spi_resume(struct device *dev)
-{
-        struct spi_master *master =
-                        platform_get_drvdata(to_platform_device(dev));
-        struct bcm63xx_spi *bs = spi_master_get_devdata(master);
-
-        clk_enable(bs->clk);
-
-        spi_master_resume(master);
-
-        return 0;
-}
-
-static const struct dev_pm_ops bcm63xx_spi_pm_ops = {
-        .suspend        = bcm63xx_spi_suspend,
-        .resume         = bcm63xx_spi_resume,
-};
-
-#define BCM63XX_SPI_PM_OPS      (&bcm63xx_spi_pm_ops)
-#else
-#define BCM63XX_SPI_PM_OPS      NULL
-#endif
-
-static struct platform_driver bcm63xx_spi_driver = {
-        .driver = {
-                .name   = "bcm63xx-spi",
-                .owner  = THIS_MODULE,
-                .pm     = BCM63XX_SPI_PM_OPS,
-        },
-        .probe          = bcm63xx_spi_probe,
-        .remove         = bcm63xx_spi_remove,
-};
-
-module_platform_driver(bcm63xx_spi_driver);
-
-MODULE_ALIAS("platform:bcm63xx_spi");
-MODULE_AUTHOR("Florian Fainelli <florian@openwrt.org>");
-MODULE_AUTHOR("Tanguy Bouzeloc <tanguy.bouzeloc@efixo.com>");
-MODULE_DESCRIPTION("Broadcom BCM63xx SPI Controller driver");
-MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-bfin-sport.c b/drivers/spi/spi-bfin-sport.c
index ac7ffca7ba4..e557ff617b1 100644
--- a/drivers/spi/spi-bfin-sport.c
+++ b/drivers/spi/spi-bfin-sport.c
@@ -252,15 +252,19 @@ static void
 bfin_sport_spi_restore_state(struct bfin_sport_spi_master_data *drv_data)
 {
         struct bfin_sport_spi_slave_data *chip = drv_data->cur_chip;
+        unsigned int bits = (drv_data->ops == &bfin_sport_transfer_ops_u8 ? 7 : 15);
 
         bfin_sport_spi_disable(drv_data);
         dev_dbg(drv_data->dev, "restoring spi ctl state\n");
 
         bfin_write(&drv_data->regs->tcr1, chip->ctl_reg);
+        bfin_write(&drv_data->regs->tcr2, bits);
         bfin_write(&drv_data->regs->tclkdiv, chip->baud);
+        bfin_write(&drv_data->regs->tfsdiv, bits);
         SSYNC();
 
         bfin_write(&drv_data->regs->rcr1, chip->ctl_reg & ~(ITCLK | ITFS));
+        bfin_write(&drv_data->regs->rcr2, bits);
         SSYNC();
 
         bfin_sport_spi_cs_active(chip);
@@ -416,15 +420,11 @@ bfin_sport_spi_pump_transfers(unsigned long data)
         drv_data->cs_change = transfer->cs_change;
 
         /* Bits per word setup */
-        bits_per_word = transfer->bits_per_word ? :
-                message->spi->bits_per_word ? : 8;
-        if (bits_per_word % 16 == 0)
-                drv_data->ops = &bfin_sport_transfer_ops_u16;
-        else
+        bits_per_word = transfer->bits_per_word ? : message->spi->bits_per_word;
+        if (bits_per_word == 8)
                 drv_data->ops = &bfin_sport_transfer_ops_u8;
-        bfin_write(&drv_data->regs->tcr2, bits_per_word - 1);
-        bfin_write(&drv_data->regs->tfsdiv, bits_per_word - 1);
-        bfin_write(&drv_data->regs->rcr2, bits_per_word - 1);
+        else
+                drv_data->ops = &bfin_sport_transfer_ops_u16;
 
         drv_data->state = RUNNING_STATE;
 
@@ -467,7 +467,7 @@ bfin_sport_spi_pump_transfers(unsigned long data)
                 dev_dbg(drv_data->dev, "IO write error!\n");
                 drv_data->state = ERROR_STATE;
         } else {
-                /* Update total byte transferred */
+                /* Update total byte transfered */
                 message->actual_length += transfer->len;
                 /* Move to next transfer of this msg */
                 drv_data->state = bfin_sport_spi_next_transfer(drv_data);
@@ -598,12 +598,11 @@ bfin_sport_spi_setup(struct spi_device *spi)
                         }
                         chip->cs_chg_udelay = chip_info->cs_chg_udelay;
                         chip->idle_tx_val = chip_info->idle_tx_val;
+                        spi->bits_per_word = chip_info->bits_per_word;
                 }
         }
 
-        if (spi->bits_per_word % 8) {
-                dev_err(&spi->dev, "%d bits_per_word is not supported\n",
-                                spi->bits_per_word);
+        if (spi->bits_per_word != 8 && spi->bits_per_word != 16) {
                 ret = -EINVAL;
                 goto error;
         }
@@ -755,7 +754,8 @@ bfin_sport_spi_destroy_queue(struct bfin_sport_spi_master_data *drv_data)
         return 0;
 }
 
-static int bfin_sport_spi_probe(struct platform_device *pdev)
+static int __devinit
+bfin_sport_spi_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct bfin5xx_spi_master *platform_info;
@@ -862,7 +862,8 @@ static int bfin_sport_spi_probe(struct platform_device *pdev)
 }
 
 /* stop hardware and remove the driver */
-static int bfin_sport_spi_remove(struct platform_device *pdev)
+static int __devexit
+bfin_sport_spi_remove(struct platform_device *pdev)
 {
         struct bfin_sport_spi_master_data *drv_data = platform_get_drvdata(pdev);
         int status = 0;
@@ -933,8 +934,19 @@ static struct platform_driver bfin_sport_spi_driver = {
                 .owner = THIS_MODULE,
         },
         .probe   = bfin_sport_spi_probe,
-        .remove  = bfin_sport_spi_remove,
+        .remove  = __devexit_p(bfin_sport_spi_remove),
         .suspend = bfin_sport_spi_suspend,
         .resume  = bfin_sport_spi_resume,
 };
-module_platform_driver(bfin_sport_spi_driver);
+
+static int __init bfin_sport_spi_init(void)
+{
+        return platform_driver_register(&bfin_sport_spi_driver);
+}
+module_init(bfin_sport_spi_init);
+
+static void __exit bfin_sport_spi_exit(void)
+{
+        platform_driver_unregister(&bfin_sport_spi_driver);
+}
+module_exit(bfin_sport_spi_exit);
diff --git a/drivers/spi/spi-bfin5xx.c b/drivers/spi/spi-bfin5xx.c
index 0429d833f75..b8d25f2b703 100644
--- a/drivers/spi/spi-bfin5xx.c
+++ b/drivers/spi/spi-bfin5xx.c
@@ -396,7 +396,7 @@ static irqreturn_t bfin_spi_pio_irq_handler(int irq, void *dev_id)
                 /* last read */
                 if (drv_data->rx) {
                         dev_dbg(&drv_data->pdev->dev, "last read\n");
-                        if (!(n_bytes % 2)) {
+                        if (n_bytes % 2) {
                                 u16 *buf = (u16 *)drv_data->rx;
                                 for (loop = 0; loop < n_bytes / 2; loop++)
                                         *buf++ = bfin_read(&drv_data->regs->rdbr);
@@ -424,7 +424,7 @@ static irqreturn_t bfin_spi_pio_irq_handler(int irq, void *dev_id)
         if (drv_data->rx && drv_data->tx) {
                 /* duplex */
                 dev_dbg(&drv_data->pdev->dev, "duplex: write_TDBR\n");
-                if (!(n_bytes % 2)) {
+                if (n_bytes % 2) {
                         u16 *buf = (u16 *)drv_data->rx;
                         u16 *buf2 = (u16 *)drv_data->tx;
                         for (loop = 0; loop < n_bytes / 2; loop++) {
@@ -442,7 +442,7 @@ static irqreturn_t bfin_spi_pio_irq_handler(int irq, void *dev_id)
         } else if (drv_data->rx) {
                 /* read */
                 dev_dbg(&drv_data->pdev->dev, "read: write_TDBR\n");
-                if (!(n_bytes % 2)) {
+                if (n_bytes % 2) {
                         u16 *buf = (u16 *)drv_data->rx;
                         for (loop = 0; loop < n_bytes / 2; loop++) {
                                 *buf++ = bfin_read(&drv_data->regs->rdbr);
@@ -458,7 +458,7 @@ static irqreturn_t bfin_spi_pio_irq_handler(int irq, void *dev_id)
         } else if (drv_data->tx) {
                 /* write */
                 dev_dbg(&drv_data->pdev->dev, "write: write_TDBR\n");
-                if (!(n_bytes % 2)) {
+                if (n_bytes % 2) {
                         u16 *buf = (u16 *)drv_data->tx;
                         for (loop = 0; loop < n_bytes / 2; loop++) {
                                 bfin_read(&drv_data->regs->rdbr);
@@ -587,7 +587,6 @@ static void bfin_spi_pump_transfers(unsigned long data)
         if (message->state == DONE_STATE) {
                 dev_dbg(&drv_data->pdev->dev, "transfer: all done!\n");
                 message->status = 0;
-                bfin_spi_flush(drv_data);
                 bfin_spi_giveback(drv_data);
                 return;
         }
@@ -871,10 +870,8 @@ static void bfin_spi_pump_transfers(unsigned long data)
                 message->actual_length += drv_data->len_in_bytes;
                 /* Move to next transfer of this msg */
                 message->state = bfin_spi_next_transfer(drv_data);
-                if (drv_data->cs_change && message->state != DONE_STATE) {
-                        bfin_spi_flush(drv_data);
+                if (drv_data->cs_change)
                         bfin_spi_cs_deactive(drv_data, chip);
-                }
         }
 
         /* Schedule next transfer tasklet */
@@ -1029,6 +1026,7 @@ static int bfin_spi_setup(struct spi_device *spi)
                 chip->cs_chg_udelay = chip_info->cs_chg_udelay;
                 chip->idle_tx_val = chip_info->idle_tx_val;
                 chip->pio_interrupt = chip_info->pio_interrupt;
+                spi->bits_per_word = chip_info->bits_per_word;
         } else {
                 /* force a default base state */
                 chip->ctl_reg &= bfin_ctl_reg;
@@ -1100,7 +1098,7 @@ static int bfin_spi_setup(struct spi_device *spi)
 
         if (chip->pio_interrupt && !drv_data->irq_requested) {
                 ret = request_irq(drv_data->spi_irq, bfin_spi_pio_irq_handler,
-                        0, "BFIN_SPI", drv_data);
+                        IRQF_DISABLED, "BFIN_SPI", drv_data);
                 if (ret) {
                         dev_err(&spi->dev, "Unable to register spi IRQ\n");
                         goto error;
@@ -1387,7 +1385,7 @@ out_error_get_res:
 }
 
 /* stop hardware and remove the driver */
-static int bfin_spi_remove(struct platform_device *pdev)
+static int __devexit bfin_spi_remove(struct platform_device *pdev)
 {
         struct bfin_spi_master_data *drv_data = platform_get_drvdata(pdev);
         int status = 0;
@@ -1477,7 +1475,7 @@ static struct platform_driver bfin_spi_driver = {
         },
         .suspend        = bfin_spi_suspend,
         .resume         = bfin_spi_resume,
-        .remove         = bfin_spi_remove,
+        .remove         = __devexit_p(bfin_spi_remove),
 };
 
 static int __init bfin_spi_init(void)
diff --git a/drivers/spi/spi-bitbang.c b/drivers/spi/spi-bitbang.c
index 8b3d8efafd3..02d57fbba29 100644
--- a/drivers/spi/spi-bitbang.c
+++ b/drivers/spi/spi-bitbang.c
@@ -20,7 +20,6 @@
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/platform_device.h>
@@ -260,11 +259,11 @@ static void bitbang_work(struct work_struct *work)
         struct spi_bitbang      *bitbang =
                 container_of(work, struct spi_bitbang, work);
         unsigned long           flags;
-        struct spi_message      *m, *_m;
 
         spin_lock_irqsave(&bitbang->lock, flags);
         bitbang->busy = 1;
-        list_for_each_entry_safe(m, _m, &bitbang->queue, queue) {
+        while (!list_empty(&bitbang->queue)) {
+                struct spi_message      *m;
                 struct spi_device       *spi;
                 unsigned                nsecs;
                 struct spi_transfer     *t = NULL;
@@ -273,7 +272,9 @@ static void bitbang_work(struct work_struct *work)
                 int                     status;
                 int                     do_setup = -1;
 
-                list_del(&m->queue);
+                m = container_of(bitbang->queue.next, struct spi_message,
+                                queue);
+                list_del_init(&m->queue);
                 spin_unlock_irqrestore(&bitbang->lock, flags);
 
                 /* FIXME this is made-up ... the correct value is known to
@@ -344,14 +345,17 @@ static void bitbang_work(struct work_struct *work)
                         if (t->delay_usecs)
                                 udelay(t->delay_usecs);
 
-                        if (cs_change && !list_is_last(&t->transfer_list, &m->transfers)) {
-                                /* sometimes a short mid-message deselect of the chip
-                                 * may be needed to terminate a mode or command
-                                 */
-                                ndelay(nsecs);
-                                bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
-                                ndelay(nsecs);
-                        }
+                        if (!cs_change)
+                                continue;
+                        if (t->transfer_list.next == &m->transfers)
+                                break;
+
+                        /* sometimes a short mid-message deselect of the chip
+                         * may be needed to terminate a mode or command
+                         */
+                        ndelay(nsecs);
+                        bitbang->chipselect(spi, BITBANG_CS_INACTIVE);
+                        ndelay(nsecs);
                 }
 
                 m->status = status;
diff --git a/drivers/spi/spi-butterfly.c b/drivers/spi/spi-butterfly.c
index 5ed08e53743..9f907ec52de 100644
--- a/drivers/spi/spi-butterfly.c
+++ b/drivers/spi/spi-butterfly.c
@@ -20,7 +20,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/parport.h>
 
diff --git a/drivers/spi/spi-clps711x.c b/drivers/spi/spi-clps711x.c
deleted file mode 100644
index 1366c4620d5..00000000000
--- a/drivers/spi/spi-clps711x.c
+++ /dev/null
@@ -1,296 +0,0 @@
-/*
- *  CLPS711X SPI bus driver
- *
- *  Copyright (C) 2012 Alexander Shiyan <shc_work@mail.ru>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-
-#include <linux/io.h>
-#include <linux/clk.h>
-#include <linux/init.h>
-#include <linux/gpio.h>
-#include <linux/delay.h>
-#include <linux/module.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/spi/spi.h>
-#include <linux/platform_data/spi-clps711x.h>
-
-#include <mach/hardware.h>
-
-#define DRIVER_NAME     "spi-clps711x"
-
-struct spi_clps711x_data {
-        struct completion       done;
-
-        struct clk              *spi_clk;
-        u32                     max_speed_hz;
-
-        u8                      *tx_buf;
-        u8                      *rx_buf;
-        int                     count;
-        int                     len;
-
-        int                     chipselect[0];
-};
-
-static int spi_clps711x_setup(struct spi_device *spi)
-{
-        struct spi_clps711x_data *hw = spi_master_get_devdata(spi->master);
-
-        if (spi->bits_per_word != 8) {
-                dev_err(&spi->dev, "Unsupported master bus width %i\n",
-                        spi->bits_per_word);
-                return -EINVAL;
-        }
-
-        /* We are expect that SPI-device is not selected */
-        gpio_direction_output(hw->chipselect[spi->chip_select],
-                              !(spi->mode & SPI_CS_HIGH));
-
-        return 0;
-}
-
-static void spi_clps711x_setup_mode(struct spi_device *spi)
-{
-        /* Setup edge for transfer */
-        if (spi->mode & SPI_CPHA)
-                clps_writew(clps_readw(SYSCON3) | SYSCON3_ADCCKNSEN, SYSCON3);
-        else
-                clps_writew(clps_readw(SYSCON3) & ~SYSCON3_ADCCKNSEN, SYSCON3);
-}
-
-static int spi_clps711x_setup_xfer(struct spi_device *spi,
-                                   struct spi_transfer *xfer)
-{
-        u32 speed = xfer->speed_hz ? : spi->max_speed_hz;
-        u8 bpw = xfer->bits_per_word ? : spi->bits_per_word;
-        struct spi_clps711x_data *hw = spi_master_get_devdata(spi->master);
-
-        if (bpw != 8) {
-                dev_err(&spi->dev, "Unsupported master bus width %i\n", bpw);
-                return -EINVAL;
-        }
-
-        /* Setup SPI frequency divider */
-        if (!speed || (speed >= hw->max_speed_hz))
-                clps_writel((clps_readl(SYSCON1) & ~SYSCON1_ADCKSEL_MASK) |
-                            SYSCON1_ADCKSEL(3), SYSCON1);
-        else if (speed >= (hw->max_speed_hz / 2))
-                clps_writel((clps_readl(SYSCON1) & ~SYSCON1_ADCKSEL_MASK) |
-                            SYSCON1_ADCKSEL(2), SYSCON1);
-        else if (speed >= (hw->max_speed_hz / 8))
-                clps_writel((clps_readl(SYSCON1) & ~SYSCON1_ADCKSEL_MASK) |
-                            SYSCON1_ADCKSEL(1), SYSCON1);
-        else
-                clps_writel((clps_readl(SYSCON1) & ~SYSCON1_ADCKSEL_MASK) |
-                            SYSCON1_ADCKSEL(0), SYSCON1);
-
-        return 0;
-}
-
-static int spi_clps711x_transfer_one_message(struct spi_master *master,
-                                             struct spi_message *msg)
-{
-        struct spi_clps711x_data *hw = spi_master_get_devdata(master);
-        struct spi_transfer *xfer;
-        int status = 0, cs = hw->chipselect[msg->spi->chip_select];
-        u32 data;
-
-        spi_clps711x_setup_mode(msg->spi);
-
-        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                if (spi_clps711x_setup_xfer(msg->spi, xfer)) {
-                        status = -EINVAL;
-                        goto out_xfr;
-                }
-
-                gpio_set_value(cs, !!(msg->spi->mode & SPI_CS_HIGH));
-
-                INIT_COMPLETION(hw->done);
-
-                hw->count = 0;
-                hw->len = xfer->len;
-                hw->tx_buf = (u8 *)xfer->tx_buf;
-                hw->rx_buf = (u8 *)xfer->rx_buf;
-
-                /* Initiate transfer */
-                data = hw->tx_buf ? hw->tx_buf[hw->count] : 0;
-                clps_writel(data | SYNCIO_FRMLEN(8) | SYNCIO_TXFRMEN, SYNCIO);
-
-                wait_for_completion(&hw->done);
-
-                if (xfer->delay_usecs)
-                        udelay(xfer->delay_usecs);
-
-                if (xfer->cs_change ||
-                    list_is_last(&xfer->transfer_list, &msg->transfers))
-                        gpio_set_value(cs, !(msg->spi->mode & SPI_CS_HIGH));
-
-                msg->actual_length += xfer->len;
-        }
-
-out_xfr:
-        msg->status = status;
-        spi_finalize_current_message(master);
-
-        return 0;
-}
-
-static irqreturn_t spi_clps711x_isr(int irq, void *dev_id)
-{
-        struct spi_clps711x_data *hw = (struct spi_clps711x_data *)dev_id;
-        u32 data;
-
-        /* Handle RX */
-        data = clps_readb(SYNCIO);
-        if (hw->rx_buf)
-                hw->rx_buf[hw->count] = (u8)data;
-
-        hw->count++;
-
-        /* Handle TX */
-        if (hw->count < hw->len) {
-                data = hw->tx_buf ? hw->tx_buf[hw->count] : 0;
-                clps_writel(data | SYNCIO_FRMLEN(8) | SYNCIO_TXFRMEN, SYNCIO);
-        } else
-                complete(&hw->done);
-
-        return IRQ_HANDLED;
-}
-
-static int spi_clps711x_probe(struct platform_device *pdev)
-{
-        int i, ret;
-        struct spi_master *master;
-        struct spi_clps711x_data *hw;
-        struct spi_clps711x_pdata *pdata = dev_get_platdata(&pdev->dev);
-
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform data supplied\n");
-                return -EINVAL;
-        }
-
-        if (pdata->num_chipselect < 1) {
-                dev_err(&pdev->dev, "At least one CS must be defined\n");
-                return -EINVAL;
-        }
-
-        master = spi_alloc_master(&pdev->dev,
-                                  sizeof(struct spi_clps711x_data) +
-                                  sizeof(int) * pdata->num_chipselect);
-        if (!master) {
-                dev_err(&pdev->dev, "SPI allocating memory error\n");
-                return -ENOMEM;
-        }
-
-        master->bus_num = pdev->id;
-        master->mode_bits = SPI_CPHA | SPI_CS_HIGH;
-        master->num_chipselect = pdata->num_chipselect;
-        master->setup = spi_clps711x_setup;
-        master->transfer_one_message = spi_clps711x_transfer_one_message;
-
-        hw = spi_master_get_devdata(master);
-
-        for (i = 0; i < master->num_chipselect; i++) {
-                hw->chipselect[i] = pdata->chipselect[i];
-                if (!gpio_is_valid(hw->chipselect[i])) {
-                        dev_err(&pdev->dev, "Invalid CS GPIO %i\n", i);
-                        ret = -EINVAL;
-                        goto err_out;
-                }
-                if (gpio_request(hw->chipselect[i], DRIVER_NAME)) {
-                        dev_err(&pdev->dev, "Can't get CS GPIO %i\n", i);
-                        ret = -EINVAL;
-                        goto err_out;
-                }
-        }
-
-        hw->spi_clk = devm_clk_get(&pdev->dev, "spi");
-        if (IS_ERR(hw->spi_clk)) {
-                dev_err(&pdev->dev, "Can't get clocks\n");
-                ret = PTR_ERR(hw->spi_clk);
-                goto err_out;
-        }
-        hw->max_speed_hz = clk_get_rate(hw->spi_clk);
-
-        init_completion(&hw->done);
-        platform_set_drvdata(pdev, master);
-
-        /* Disable extended mode due hardware problems */
-        clps_writew(clps_readw(SYSCON3) & ~SYSCON3_ADCCON, SYSCON3);
-
-        /* Clear possible pending interrupt */
-        clps_readl(SYNCIO);
-
-        ret = devm_request_irq(&pdev->dev, IRQ_SSEOTI, spi_clps711x_isr, 0,
-                               dev_name(&pdev->dev), hw);
-        if (ret) {
-                dev_err(&pdev->dev, "Can't request IRQ\n");
-                clk_put(hw->spi_clk);
-                goto clk_out;
-        }
-
-        ret = spi_register_master(master);
-        if (!ret) {
-                dev_info(&pdev->dev,
-                         "SPI bus driver initialized. Master clock %u Hz\n",
-                         hw->max_speed_hz);
-                return 0;
-        }
-
-        dev_err(&pdev->dev, "Failed to register master\n");
-        devm_free_irq(&pdev->dev, IRQ_SSEOTI, hw);
-
-clk_out:
-        devm_clk_put(&pdev->dev, hw->spi_clk);
-
-err_out:
-        while (--i >= 0)
-                if (gpio_is_valid(hw->chipselect[i]))
-                        gpio_free(hw->chipselect[i]);
-
-        platform_set_drvdata(pdev, NULL);
-        spi_master_put(master);
-        kfree(master);
-
-        return ret;
-}
-
-static int spi_clps711x_remove(struct platform_device *pdev)
-{
-        int i;
-        struct spi_master *master = platform_get_drvdata(pdev);
-        struct spi_clps711x_data *hw = spi_master_get_devdata(master);
-
-        devm_free_irq(&pdev->dev, IRQ_SSEOTI, hw);
-
-        for (i = 0; i < master->num_chipselect; i++)
-                if (gpio_is_valid(hw->chipselect[i]))
-                        gpio_free(hw->chipselect[i]);
-
-        devm_clk_put(&pdev->dev, hw->spi_clk);
-        platform_set_drvdata(pdev, NULL);
-        spi_unregister_master(master);
-        kfree(master);
-
-        return 0;
-}
-
-static struct platform_driver clps711x_spi_driver = {
-        .driver = {
-                .name   = DRIVER_NAME,
-                .owner  = THIS_MODULE,
-        },
-        .probe  = spi_clps711x_probe,
-        .remove = spi_clps711x_remove,
-};
-module_platform_driver(clps711x_spi_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Alexander Shiyan <shc_work@mail.ru>");
-MODULE_DESCRIPTION("CLPS711X SPI bus driver");
diff --git a/drivers/spi/spi-coldfire-qspi.c b/drivers/spi/spi-coldfire-qspi.c
index 58466b810da..ae2cd1c1fda 100644
--- a/drivers/spi/spi-coldfire-qspi.c
+++ b/drivers/spi/spi-coldfire-qspi.c
@@ -25,12 +25,12 @@
 #include <linux/errno.h>
 #include <linux/platform_device.h>
 #include <linux/sched.h>
+#include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/spi/spi.h>
-#include <linux/pm_runtime.h>
 
 #include <asm/coldfire.h>
 #include <asm/mcfsim.h>
@@ -78,7 +78,10 @@ struct mcfqspi {
 
         wait_queue_head_t waitq;
 
-        struct device *dev;
+        struct work_struct work;
+        struct workqueue_struct *workq;
+        spinlock_t lock;
+        struct list_head msgq;
 };
 
 static void mcfqspi_wr_qmr(struct mcfqspi *mcfqspi, u16 val)
@@ -300,80 +303,120 @@ static void mcfqspi_transfer_msg16(struct mcfqspi *mcfqspi, unsigned count,
         }
 }
 
-static int mcfqspi_transfer_one_message(struct spi_master *master,
-                                         struct spi_message *msg)
+static void mcfqspi_work(struct work_struct *work)
 {
-        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
-        struct spi_device *spi = msg->spi;
-        struct spi_transfer *t;
-        int status = 0;
-
-        list_for_each_entry(t, &msg->transfers, transfer_list) {
-                bool cs_high = spi->mode & SPI_CS_HIGH;
-                u16 qmr = MCFQSPI_QMR_MSTR;
-
-                if (t->bits_per_word)
-                        qmr |= t->bits_per_word << 10;
-                else
-                        qmr |= spi->bits_per_word << 10;
-                if (spi->mode & SPI_CPHA)
-                        qmr |= MCFQSPI_QMR_CPHA;
-                if (spi->mode & SPI_CPOL)
-                        qmr |= MCFQSPI_QMR_CPOL;
-                if (t->speed_hz)
-                        qmr |= mcfqspi_qmr_baud(t->speed_hz);
-                else
-                        qmr |= mcfqspi_qmr_baud(spi->max_speed_hz);
-                mcfqspi_wr_qmr(mcfqspi, qmr);
-
-                mcfqspi_cs_select(mcfqspi, spi->chip_select, cs_high);
-
-                mcfqspi_wr_qir(mcfqspi, MCFQSPI_QIR_SPIFE);
-                if ((t->bits_per_word ? t->bits_per_word :
-                                        spi->bits_per_word) == 8)
-                        mcfqspi_transfer_msg8(mcfqspi, t->len, t->tx_buf,
-                                        t->rx_buf);
-                else
-                        mcfqspi_transfer_msg16(mcfqspi, t->len / 2, t->tx_buf,
-                                        t->rx_buf);
-                mcfqspi_wr_qir(mcfqspi, 0);
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
-                if (t->cs_change) {
-                        if (!list_is_last(&t->transfer_list, &msg->transfers))
-                                mcfqspi_cs_deselect(mcfqspi, spi->chip_select,
-                                                cs_high);
-                } else {
-                        if (list_is_last(&t->transfer_list, &msg->transfers))
-                                mcfqspi_cs_deselect(mcfqspi, spi->chip_select,
-                                                cs_high);
+        struct mcfqspi *mcfqspi = container_of(work, struct mcfqspi, work);
+        unsigned long flags;
+
+        spin_lock_irqsave(&mcfqspi->lock, flags);
+        while (!list_empty(&mcfqspi->msgq)) {
+                struct spi_message *msg;
+                struct spi_device *spi;
+                struct spi_transfer *xfer;
+                int status = 0;
+
+                msg = container_of(mcfqspi->msgq.next, struct spi_message,
+                                   queue);
+
+                list_del_init(&msg->queue);
+                spin_unlock_irqrestore(&mcfqspi->lock, flags);
+
+                spi = msg->spi;
+
+                list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+                        bool cs_high = spi->mode & SPI_CS_HIGH;
+                        u16 qmr = MCFQSPI_QMR_MSTR;
+
+                        if (xfer->bits_per_word)
+                                qmr |= xfer->bits_per_word << 10;
+                        else
+                                qmr |= spi->bits_per_word << 10;
+                        if (spi->mode & SPI_CPHA)
+                                qmr |= MCFQSPI_QMR_CPHA;
+                        if (spi->mode & SPI_CPOL)
+                                qmr |= MCFQSPI_QMR_CPOL;
+                        if (xfer->speed_hz)
+                                qmr |= mcfqspi_qmr_baud(xfer->speed_hz);
+                        else
+                                qmr |= mcfqspi_qmr_baud(spi->max_speed_hz);
+                        mcfqspi_wr_qmr(mcfqspi, qmr);
+
+                        mcfqspi_cs_select(mcfqspi, spi->chip_select, cs_high);
+
+                        mcfqspi_wr_qir(mcfqspi, MCFQSPI_QIR_SPIFE);
+                        if ((xfer->bits_per_word ? xfer->bits_per_word :
+                                                spi->bits_per_word) == 8)
+                                mcfqspi_transfer_msg8(mcfqspi, xfer->len,
+                                                      xfer->tx_buf,
+                                                      xfer->rx_buf);
+                        else
+                                mcfqspi_transfer_msg16(mcfqspi, xfer->len / 2,
+                                                       xfer->tx_buf,
+                                                       xfer->rx_buf);
+                        mcfqspi_wr_qir(mcfqspi, 0);
+
+                        if (xfer->delay_usecs)
+                                udelay(xfer->delay_usecs);
+                        if (xfer->cs_change) {
+                                if (!list_is_last(&xfer->transfer_list,
+                                                  &msg->transfers))
+                                        mcfqspi_cs_deselect(mcfqspi,
+                                                            spi->chip_select,
+                                                            cs_high);
+                        } else {
+                                if (list_is_last(&xfer->transfer_list,
+                                                 &msg->transfers))
+                                        mcfqspi_cs_deselect(mcfqspi,
+                                                            spi->chip_select,
+                                                            cs_high);
+                        }
+                        msg->actual_length += xfer->len;
                 }
-                msg->actual_length += t->len;
-        }
-        msg->status = status;
-        spi_finalize_current_message(master);
-
-        return status;
+                msg->status = status;
+                msg->complete(msg->context);
 
+                spin_lock_irqsave(&mcfqspi->lock, flags);
+        }
+        spin_unlock_irqrestore(&mcfqspi->lock, flags);
 }
 
-static int mcfqspi_prepare_transfer_hw(struct spi_master *master)
-{
-        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
-
-        pm_runtime_get_sync(mcfqspi->dev);
-
-        return 0;
-}
-
-static int mcfqspi_unprepare_transfer_hw(struct spi_master *master)
+static int mcfqspi_transfer(struct spi_device *spi, struct spi_message *msg)
 {
-        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
+        struct mcfqspi *mcfqspi;
+        struct spi_transfer *xfer;
+        unsigned long flags;
+
+        mcfqspi = spi_master_get_devdata(spi->master);
+
+        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+                if (xfer->bits_per_word && ((xfer->bits_per_word < 8)
+                                        || (xfer->bits_per_word > 16))) {
+                        dev_dbg(&spi->dev,
+                                "%d bits per word is not supported\n",
+                                xfer->bits_per_word);
+                        goto fail;
+                }
+                if (xfer->speed_hz) {
+                        u32 real_speed = MCFQSPI_BUSCLK /
+                                mcfqspi_qmr_baud(xfer->speed_hz);
+                        if (real_speed != xfer->speed_hz)
+                                dev_dbg(&spi->dev,
+                                        "using speed %d instead of %d\n",
+                                        real_speed, xfer->speed_hz);
+                }
+        }
+        msg->status = -EINPROGRESS;
+        msg->actual_length = 0;
 
-        pm_runtime_put_sync(mcfqspi->dev);
+        spin_lock_irqsave(&mcfqspi->lock, flags);
+        list_add_tail(&msg->queue, &mcfqspi->msgq);
+        queue_work(mcfqspi->workq, &mcfqspi->work);
+        spin_unlock_irqrestore(&mcfqspi->lock, flags);
 
         return 0;
+fail:
+        msg->status = -EINVAL;
+        return -EINVAL;
 }
 
 static int mcfqspi_setup(struct spi_device *spi)
@@ -401,7 +444,7 @@ static int mcfqspi_setup(struct spi_device *spi)
         return 0;
 }
 
-static int mcfqspi_probe(struct platform_device *pdev)
+static int __devinit mcfqspi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct mcfqspi *mcfqspi;
@@ -444,7 +487,7 @@ static int mcfqspi_probe(struct platform_device *pdev)
                 goto fail2;
         }
 
-        status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, 0,
+        status = request_irq(mcfqspi->irq, mcfqspi_irq_handler, IRQF_DISABLED,
                              pdev->name, mcfqspi);
         if (status) {
                 dev_dbg(&pdev->dev, "request_irq failed\n");
@@ -459,10 +502,21 @@ static int mcfqspi_probe(struct platform_device *pdev)
         }
         clk_enable(mcfqspi->clk);
 
+        mcfqspi->workq = create_singlethread_workqueue(dev_name(master->dev.parent));
+        if (!mcfqspi->workq) {
+                dev_dbg(&pdev->dev, "create_workqueue failed\n");
+                status = -ENOMEM;
+                goto fail4;
+        }
+        INIT_WORK(&mcfqspi->work, mcfqspi_work);
+        spin_lock_init(&mcfqspi->lock);
+        INIT_LIST_HEAD(&mcfqspi->msgq);
+        init_waitqueue_head(&mcfqspi->waitq);
+
         pdata = pdev->dev.platform_data;
         if (!pdata) {
                 dev_dbg(&pdev->dev, "platform data is missing\n");
-                goto fail4;
+                goto fail5;
         }
         master->bus_num = pdata->bus_num;
         master->num_chipselect = pdata->num_chipselect;
@@ -471,33 +525,28 @@ static int mcfqspi_probe(struct platform_device *pdev)
         status = mcfqspi_cs_setup(mcfqspi);
         if (status) {
                 dev_dbg(&pdev->dev, "error initializing cs_control\n");
-                goto fail4;
+                goto fail5;
         }
 
-        init_waitqueue_head(&mcfqspi->waitq);
-        mcfqspi->dev = &pdev->dev;
-
         master->mode_bits = SPI_CS_HIGH | SPI_CPOL | SPI_CPHA;
         master->setup = mcfqspi_setup;
-        master->transfer_one_message = mcfqspi_transfer_one_message;
-        master->prepare_transfer_hardware = mcfqspi_prepare_transfer_hw;
-        master->unprepare_transfer_hardware = mcfqspi_unprepare_transfer_hw;
+        master->transfer = mcfqspi_transfer;
 
         platform_set_drvdata(pdev, master);
 
         status = spi_register_master(master);
         if (status) {
                 dev_dbg(&pdev->dev, "spi_register_master failed\n");
-                goto fail5;
+                goto fail6;
         }
-        pm_runtime_enable(mcfqspi->dev);
-
         dev_info(&pdev->dev, "Coldfire QSPI bus driver\n");
 
         return 0;
 
-fail5:
+fail6:
         mcfqspi_cs_teardown(mcfqspi);
+fail5:
+        destroy_workqueue(mcfqspi->workq);
 fail4:
         clk_disable(mcfqspi->clk);
         clk_put(mcfqspi->clk);
@@ -515,56 +564,32 @@ fail0:
         return status;
 }
 
-static int mcfqspi_remove(struct platform_device *pdev)
+static int __devexit mcfqspi_remove(struct platform_device *pdev)
 {
         struct spi_master *master = platform_get_drvdata(pdev);
         struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 
-        pm_runtime_disable(mcfqspi->dev);
         /* disable the hardware (set the baud rate to 0) */
         mcfqspi_wr_qmr(mcfqspi, MCFQSPI_QMR_MSTR);
 
         platform_set_drvdata(pdev, NULL);
         mcfqspi_cs_teardown(mcfqspi);
+        destroy_workqueue(mcfqspi->workq);
         clk_disable(mcfqspi->clk);
         clk_put(mcfqspi->clk);
         free_irq(mcfqspi->irq, mcfqspi);
         iounmap(mcfqspi->iobase);
         release_mem_region(res->start, resource_size(res));
         spi_unregister_master(master);
+        spi_master_put(master);
 
         return 0;
 }
 
-#ifdef CONFIG_PM_SLEEP
-static int mcfqspi_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
-
-        spi_master_suspend(master);
-
-        clk_disable(mcfqspi->clk);
-
-        return 0;
-}
-
-static int mcfqspi_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct mcfqspi *mcfqspi = spi_master_get_devdata(master);
-
-        spi_master_resume(master);
-
-        clk_enable(mcfqspi->clk);
-
-        return 0;
-}
-#endif
+#ifdef CONFIG_PM
 
-#ifdef CONFIG_PM_RUNTIME
-static int mcfqspi_runtime_suspend(struct device *dev)
+static int mcfqspi_suspend(struct device *dev)
 {
         struct mcfqspi *mcfqspi = platform_get_drvdata(to_platform_device(dev));
 
@@ -573,7 +598,7 @@ static int mcfqspi_runtime_suspend(struct device *dev)
         return 0;
 }
 
-static int mcfqspi_runtime_resume(struct device *dev)
+static int mcfqspi_resume(struct device *dev)
 {
         struct mcfqspi *mcfqspi = platform_get_drvdata(to_platform_device(dev));
 
@@ -581,22 +606,35 @@ static int mcfqspi_runtime_resume(struct device *dev)
 
         return 0;
 }
-#endif
 
-static const struct dev_pm_ops mcfqspi_pm = {
-        SET_SYSTEM_SLEEP_PM_OPS(mcfqspi_suspend, mcfqspi_resume)
-        SET_RUNTIME_PM_OPS(mcfqspi_runtime_suspend, mcfqspi_runtime_resume,
-                        NULL)
+static struct dev_pm_ops mcfqspi_dev_pm_ops = {
+        .suspend        = mcfqspi_suspend,
+        .resume         = mcfqspi_resume,
 };
 
+#define MCFQSPI_DEV_PM_OPS      (&mcfqspi_dev_pm_ops)
+#else
+#define MCFQSPI_DEV_PM_OPS      NULL
+#endif
+
 static struct platform_driver mcfqspi_driver = {
         .driver.name    = DRIVER_NAME,
         .driver.owner   = THIS_MODULE,
-        .driver.pm      = &mcfqspi_pm,
-        .probe          = mcfqspi_probe,
-        .remove         = mcfqspi_remove,
+        .driver.pm      = MCFQSPI_DEV_PM_OPS,
+        .remove         = __devexit_p(mcfqspi_remove),
 };
-module_platform_driver(mcfqspi_driver);
+
+static int __init mcfqspi_init(void)
+{
+        return platform_driver_probe(&mcfqspi_driver, mcfqspi_probe);
+}
+module_init(mcfqspi_init);
+
+static void __exit mcfqspi_exit(void)
+{
+        platform_driver_unregister(&mcfqspi_driver);
+}
+module_exit(mcfqspi_exit);
 
 MODULE_AUTHOR("Steven King <sfking@fdwdc.com>");
 MODULE_DESCRIPTION("Coldfire QSPI Controller Driver");
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index 13661e129d9..1f0ed8005c9 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -25,14 +25,13 @@
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/clk.h>
-#include <linux/dmaengine.h>
 #include <linux/dma-mapping.h>
-#include <linux/edma.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 #include <linux/slab.h>
 
-#include <linux/platform_data/spi-davinci.h>
+#include <mach/spi.h>
+#include <mach/edma.h>
 
 #define SPI_NO_RESOURCE         ((resource_size_t)-1)
 
@@ -114,6 +113,14 @@
 #define SPIDEF          0x4c
 #define SPIFMT0         0x50
 
+/* We have 2 DMA channels per CS, one for RX and one for TX */
+struct davinci_spi_dma {
+        int                     tx_channel;
+        int                     rx_channel;
+        int                     dummy_param_slot;
+        enum dma_event_q        eventq;
+};
+
 /* SPI Controller driver's private data. */
 struct davinci_spi {
         struct spi_bitbang      bitbang;
@@ -127,14 +134,11 @@ struct davinci_spi {
 
         const void              *tx;
         void                    *rx;
+#define SPI_TMP_BUFSZ   (SMP_CACHE_BYTES + 1)
+        u8                      rx_tmp_buf[SPI_TMP_BUFSZ];
         int                     rcount;
         int                     wcount;
-
-        struct dma_chan         *dma_rx;
-        struct dma_chan         *dma_tx;
-        int                     dma_rx_chnum;
-        int                     dma_tx_chnum;
-
+        struct davinci_spi_dma  dma;
         struct davinci_spi_platform_data *pdata;
 
         void                    (*get_rx)(u32 rx_data, struct davinci_spi *);
@@ -492,23 +496,21 @@ out:
         return errors;
 }
 
-static void davinci_spi_dma_rx_callback(void *data)
+static void davinci_spi_dma_callback(unsigned lch, u16 status, void *data)
 {
-        struct davinci_spi *dspi = (struct davinci_spi *)data;
-
-        dspi->rcount = 0;
-
-        if (!dspi->wcount && !dspi->rcount)
-                complete(&dspi->done);
-}
+        struct davinci_spi *dspi = data;
+        struct davinci_spi_dma *dma = &dspi->dma;
 
-static void davinci_spi_dma_tx_callback(void *data)
-{
-        struct davinci_spi *dspi = (struct davinci_spi *)data;
+        edma_stop(lch);
 
-        dspi->wcount = 0;
+        if (status == DMA_COMPLETE) {
+                if (lch == dma->rx_channel)
+                        dspi->rcount = 0;
+                if (lch == dma->tx_channel)
+                        dspi->wcount = 0;
+        }
 
-        if (!dspi->wcount && !dspi->rcount)
+        if ((!dspi->wcount && !dspi->rcount) || (status != DMA_COMPLETE))
                 complete(&dspi->done);
 }
 
@@ -524,20 +526,20 @@ static void davinci_spi_dma_tx_callback(void *data)
 static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 {
         struct davinci_spi *dspi;
-        int data_type, ret = -ENOMEM;
+        int data_type, ret;
         u32 tx_data, spidat1;
         u32 errors = 0;
         struct davinci_spi_config *spicfg;
         struct davinci_spi_platform_data *pdata;
         unsigned uninitialized_var(rx_buf_count);
-        void *dummy_buf = NULL;
-        struct scatterlist sg_rx, sg_tx;
+        struct device *sdev;
 
         dspi = spi_master_get_devdata(spi->master);
         pdata = dspi->pdata;
         spicfg = (struct davinci_spi_config *)spi->controller_data;
         if (!spicfg)
                 spicfg = &davinci_spi_default_cfg;
+        sdev = dspi->bitbang.master->dev.parent;
 
         /* convert len to words based on bits_per_word */
         data_type = dspi->bytes_per_word[spi->chip_select];
@@ -565,83 +567,112 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
                 spidat1 |= tx_data & 0xFFFF;
                 iowrite32(spidat1, dspi->base + SPIDAT1);
         } else {
-                struct dma_slave_config dma_rx_conf = {
-                        .direction = DMA_DEV_TO_MEM,
-                        .src_addr = (unsigned long)dspi->pbase + SPIBUF,
-                        .src_addr_width = data_type,
-                        .src_maxburst = 1,
-                };
-                struct dma_slave_config dma_tx_conf = {
-                        .direction = DMA_MEM_TO_DEV,
-                        .dst_addr = (unsigned long)dspi->pbase + SPIDAT1,
-                        .dst_addr_width = data_type,
-                        .dst_maxburst = 1,
-                };
-                struct dma_async_tx_descriptor *rxdesc;
-                struct dma_async_tx_descriptor *txdesc;
-                void *buf;
-
-                dummy_buf = kzalloc(t->len, GFP_KERNEL);
-                if (!dummy_buf)
-                        goto err_alloc_dummy_buf;
-
-                dmaengine_slave_config(dspi->dma_rx, &dma_rx_conf);
-                dmaengine_slave_config(dspi->dma_tx, &dma_tx_conf);
-
-                sg_init_table(&sg_rx, 1);
-                if (!t->rx_buf)
-                        buf = dummy_buf;
-                else
-                        buf = t->rx_buf;
-                t->rx_dma = dma_map_single(&spi->dev, buf,
-                                t->len, DMA_FROM_DEVICE);
-                if (!t->rx_dma) {
-                        ret = -EFAULT;
-                        goto err_rx_map;
+                struct davinci_spi_dma *dma;
+                unsigned long tx_reg, rx_reg;
+                struct edmacc_param param;
+                void *rx_buf;
+                int b, c;
+
+                dma = &dspi->dma;
+
+                tx_reg = (unsigned long)dspi->pbase + SPIDAT1;
+                rx_reg = (unsigned long)dspi->pbase + SPIBUF;
+
+                /*
+                 * Transmit DMA setup
+                 *
+                 * If there is transmit data, map the transmit buffer, set it
+                 * as the source of data and set the source B index to data
+                 * size. If there is no transmit data, set the transmit register
+                 * as the source of data, and set the source B index to zero.
+                 *
+                 * The destination is always the transmit register itself. And
+                 * the destination never increments.
+                 */
+
+                if (t->tx_buf) {
+                        t->tx_dma = dma_map_single(&spi->dev, (void *)t->tx_buf,
+                                                t->len, DMA_TO_DEVICE);
+                        if (dma_mapping_error(&spi->dev, t->tx_dma)) {
+                                dev_dbg(sdev, "Unable to DMA map %d bytes"
+                                                "TX buffer\n", t->len);
+                                return -ENOMEM;
+                        }
                 }
-                sg_dma_address(&sg_rx) = t->rx_dma;
-                sg_dma_len(&sg_rx) = t->len;
 
-                sg_init_table(&sg_tx, 1);
-                if (!t->tx_buf)
-                        buf = dummy_buf;
+                /*
+                 * If number of words is greater than 65535, then we need
+                 * to configure a 3 dimension transfer.  Use the BCNTRLD
+                 * feature to allow for transfers that aren't even multiples
+                 * of 65535 (or any other possible b size) by first transferring
+                 * the remainder amount then grabbing the next N blocks of
+                 * 65535 words.
+                 */
+
+                c = dspi->wcount / (SZ_64K - 1);        /* N 65535 Blocks */
+                b = dspi->wcount - c * (SZ_64K - 1);    /* Remainder */
+                if (b)
+                        c++;
                 else
-                        buf = (void *)t->tx_buf;
-                t->tx_dma = dma_map_single(&spi->dev, buf,
-                                t->len, DMA_FROM_DEVICE);
-                if (!t->tx_dma) {
-                        ret = -EFAULT;
-                        goto err_tx_map;
+                        b = SZ_64K - 1;
+
+                param.opt = TCINTEN | EDMA_TCC(dma->tx_channel);
+                param.src = t->tx_buf ? t->tx_dma : tx_reg;
+                param.a_b_cnt = b << 16 | data_type;
+                param.dst = tx_reg;
+                param.src_dst_bidx = t->tx_buf ? data_type : 0;
+                param.link_bcntrld = 0xffffffff;
+                param.src_dst_cidx = t->tx_buf ? data_type : 0;
+                param.ccnt = c;
+                edma_write_slot(dma->tx_channel, &param);
+                edma_link(dma->tx_channel, dma->dummy_param_slot);
+
+                /*
+                 * Receive DMA setup
+                 *
+                 * If there is receive buffer, use it to receive data. If there
+                 * is none provided, use a temporary receive buffer. Set the
+                 * destination B index to 0 so effectively only one byte is used
+                 * in the temporary buffer (address does not increment).
+                 *
+                 * The source of receive data is the receive data register. The
+                 * source address never increments.
+                 */
+
+                if (t->rx_buf) {
+                        rx_buf = t->rx_buf;
+                        rx_buf_count = t->len;
+                } else {
+                        rx_buf = dspi->rx_tmp_buf;
+                        rx_buf_count = sizeof(dspi->rx_tmp_buf);
                 }
-                sg_dma_address(&sg_tx) = t->tx_dma;
-                sg_dma_len(&sg_tx) = t->len;
-
-                rxdesc = dmaengine_prep_slave_sg(dspi->dma_rx,
-                                &sg_rx, 1, DMA_DEV_TO_MEM,
-                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-                if (!rxdesc)
-                        goto err_desc;
-
-                txdesc = dmaengine_prep_slave_sg(dspi->dma_tx,
-                                &sg_tx, 1, DMA_MEM_TO_DEV,
-                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-                if (!txdesc)
-                        goto err_desc;
-
-                rxdesc->callback = davinci_spi_dma_rx_callback;
-                rxdesc->callback_param = (void *)dspi;
-                txdesc->callback = davinci_spi_dma_tx_callback;
-                txdesc->callback_param = (void *)dspi;
 
-                if (pdata->cshold_bug)
-                        iowrite16(spidat1 >> 16, dspi->base + SPIDAT1 + 2);
+                t->rx_dma = dma_map_single(&spi->dev, rx_buf, rx_buf_count,
+                                                        DMA_FROM_DEVICE);
+                if (dma_mapping_error(&spi->dev, t->rx_dma)) {
+                        dev_dbg(sdev, "Couldn't DMA map a %d bytes RX buffer\n",
+                                                                rx_buf_count);
+                        if (t->tx_buf)
+                                dma_unmap_single(NULL, t->tx_dma, t->len,
+                                                                DMA_TO_DEVICE);
+                        return -ENOMEM;
+                }
 
-                dmaengine_submit(rxdesc);
-                dmaengine_submit(txdesc);
+                param.opt = TCINTEN | EDMA_TCC(dma->rx_channel);
+                param.src = rx_reg;
+                param.a_b_cnt = b << 16 | data_type;
+                param.dst = t->rx_dma;
+                param.src_dst_bidx = (t->rx_buf ? data_type : 0) << 16;
+                param.link_bcntrld = 0xffffffff;
+                param.src_dst_cidx = (t->rx_buf ? data_type : 0) << 16;
+                param.ccnt = c;
+                edma_write_slot(dma->rx_channel, &param);
 
-                dma_async_issue_pending(dspi->dma_rx);
-                dma_async_issue_pending(dspi->dma_tx);
+                if (pdata->cshold_bug)
+                        iowrite16(spidat1 >> 16, dspi->base + SPIDAT1 + 2);
 
+                edma_start(dma->rx_channel);
+                edma_start(dma->tx_channel);
                 set_io_bits(dspi->base + SPIINT, SPIINT_DMA_REQ_EN);
         }
 
@@ -659,13 +690,15 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 
         clear_io_bits(dspi->base + SPIINT, SPIINT_MASKALL);
         if (spicfg->io_type == SPI_IO_TYPE_DMA) {
-                clear_io_bits(dspi->base + SPIINT, SPIINT_DMA_REQ_EN);
 
-                dma_unmap_single(&spi->dev, t->rx_dma,
-                                t->len, DMA_FROM_DEVICE);
-                dma_unmap_single(&spi->dev, t->tx_dma,
-                                t->len, DMA_TO_DEVICE);
-                kfree(dummy_buf);
+                if (t->tx_buf)
+                        dma_unmap_single(NULL, t->tx_dma, t->len,
+                                                                DMA_TO_DEVICE);
+
+                dma_unmap_single(NULL, t->rx_dma, rx_buf_count,
+                                                        DMA_FROM_DEVICE);
+
+                clear_io_bits(dspi->base + SPIINT, SPIINT_DMA_REQ_EN);
         }
 
         clear_io_bits(dspi->base + SPIGCR1, SPIGCR1_SPIENA_MASK);
@@ -683,20 +716,11 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
         }
 
         if (dspi->rcount != 0 || dspi->wcount != 0) {
-                dev_err(&spi->dev, "SPI data transfer error\n");
+                dev_err(sdev, "SPI data transfer error\n");
                 return -EIO;
         }
 
         return t->len;
-
-err_desc:
-        dma_unmap_single(&spi->dev, t->tx_dma, t->len, DMA_TO_DEVICE);
-err_tx_map:
-        dma_unmap_single(&spi->dev, t->rx_dma, t->len, DMA_FROM_DEVICE);
-err_rx_map:
-        kfree(dummy_buf);
-err_alloc_dummy_buf:
-        return ret;
 }
 
 /**
@@ -727,33 +751,39 @@ static irqreturn_t davinci_spi_irq(s32 irq, void *data)
 
 static int davinci_spi_request_dma(struct davinci_spi *dspi)
 {
-        dma_cap_mask_t mask;
-        struct device *sdev = dspi->bitbang.master->dev.parent;
         int r;
+        struct davinci_spi_dma *dma = &dspi->dma;
 
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-
-        dspi->dma_rx = dma_request_channel(mask, edma_filter_fn,
-                                           &dspi->dma_rx_chnum);
-        if (!dspi->dma_rx) {
-                dev_err(sdev, "request RX DMA channel failed\n");
-                r = -ENODEV;
+        r = edma_alloc_channel(dma->rx_channel, davinci_spi_dma_callback, dspi,
+                                                                dma->eventq);
+        if (r < 0) {
+                pr_err("Unable to request DMA channel for SPI RX\n");
+                r = -EAGAIN;
                 goto rx_dma_failed;
         }
 
-        dspi->dma_tx = dma_request_channel(mask, edma_filter_fn,
-                                           &dspi->dma_tx_chnum);
-        if (!dspi->dma_tx) {
-                dev_err(sdev, "request TX DMA channel failed\n");
-                r = -ENODEV;
+        r = edma_alloc_channel(dma->tx_channel, davinci_spi_dma_callback, dspi,
+                                                                dma->eventq);
+        if (r < 0) {
+                pr_err("Unable to request DMA channel for SPI TX\n");
+                r = -EAGAIN;
                 goto tx_dma_failed;
         }
 
-        return 0;
+        r = edma_alloc_slot(EDMA_CTLR(dma->tx_channel), EDMA_SLOT_ANY);
+        if (r < 0) {
+                pr_err("Unable to request SPI TX DMA param slot\n");
+                r = -EAGAIN;
+                goto param_failed;
+        }
+        dma->dummy_param_slot = r;
+        edma_link(dma->dummy_param_slot, dma->dummy_param_slot);
 
+        return 0;
+param_failed:
+        edma_free_channel(dma->tx_channel);
 tx_dma_failed:
-        dma_release_channel(dspi->dma_rx);
+        edma_free_channel(dma->rx_channel);
 rx_dma_failed:
         return r;
 }
@@ -868,8 +898,9 @@ static int davinci_spi_probe(struct platform_device *pdev)
         dspi->bitbang.txrx_bufs = davinci_spi_bufs;
         if (dma_rx_chan != SPI_NO_RESOURCE &&
             dma_tx_chan != SPI_NO_RESOURCE) {
-                dspi->dma_rx_chnum = dma_rx_chan;
-                dspi->dma_tx_chnum = dma_tx_chan;
+                dspi->dma.rx_channel = dma_rx_chan;
+                dspi->dma.tx_channel = dma_tx_chan;
+                dspi->dma.eventq = pdata->dma_event_q;
 
                 ret = davinci_spi_request_dma(dspi);
                 if (ret)
@@ -924,8 +955,9 @@ static int davinci_spi_probe(struct platform_device *pdev)
         return ret;
 
 free_dma:
-        dma_release_channel(dspi->dma_rx);
-        dma_release_channel(dspi->dma_tx);
+        edma_free_channel(dspi->dma.tx_channel);
+        edma_free_channel(dspi->dma.rx_channel);
+        edma_free_slot(dspi->dma.dummy_param_slot);
 free_clk:
         clk_disable(dspi->clk);
         clk_put(dspi->clk);
@@ -952,7 +984,7 @@ err:
  * It will also call spi_bitbang_stop to destroy the work queue which was
  * created by spi_bitbang_start.
  */
-static int davinci_spi_remove(struct platform_device *pdev)
+static int __exit davinci_spi_remove(struct platform_device *pdev)
 {
         struct davinci_spi *dspi;
         struct spi_master *master;
@@ -979,10 +1011,20 @@ static struct platform_driver davinci_spi_driver = {
                 .name = "spi_davinci",
                 .owner = THIS_MODULE,
         },
-        .probe = davinci_spi_probe,
-        .remove = davinci_spi_remove,
+        .remove = __exit_p(davinci_spi_remove),
 };
-module_platform_driver(davinci_spi_driver);
+
+static int __init davinci_spi_init(void)
+{
+        return platform_driver_probe(&davinci_spi_driver, davinci_spi_probe);
+}
+module_init(davinci_spi_init);
+
+static void __exit davinci_spi_exit(void)
+{
+        platform_driver_unregister(&davinci_spi_driver);
+}
+module_exit(davinci_spi_exit);
 
 MODULE_DESCRIPTION("TI DaVinci SPI Master Controller Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c
index b9f0192758d..130e55537db 100644
--- a/drivers/spi/spi-dw-mid.c
+++ b/drivers/spi/spi-dw-mid.c
@@ -22,7 +22,6 @@
 #include <linux/interrupt.h>
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
-#include <linux/types.h>
 
 #include "spi-dw.h"
 
@@ -117,13 +116,13 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
         /* 1. setup DMA related registers */
         if (cs_change) {
                 spi_enable_chip(dws, 0);
-                dw_writew(dws, DW_SPI_DMARDLR, 0xf);
-                dw_writew(dws, DW_SPI_DMATDLR, 0x10);
+                dw_writew(dws, dmardlr, 0xf);
+                dw_writew(dws, dmatdlr, 0x10);
                 if (dws->tx_dma)
                         dma_ctrl |= 0x2;
                 if (dws->rx_dma)
                         dma_ctrl |= 0x1;
-                dw_writew(dws, DW_SPI_DMACR, dma_ctrl);
+                dw_writew(dws, dmacr, dma_ctrl);
                 spi_enable_chip(dws, 1);
         }
 
@@ -132,12 +131,11 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
         rxchan = dws->rxchan;
 
         /* 2. Prepare the TX dma transfer */
-        txconf.direction = DMA_MEM_TO_DEV;
+        txconf.direction = DMA_TO_DEVICE;
         txconf.dst_addr = dws->dma_addr;
         txconf.dst_maxburst = LNW_DMA_MSIZE_16;
         txconf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
         txconf.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
-        txconf.device_fc = false;
 
         txchan->device->device_control(txchan, DMA_SLAVE_CONFIG,
                                        (unsigned long) &txconf);
@@ -146,21 +144,20 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
         dws->tx_sgl.dma_address = dws->tx_dma;
         dws->tx_sgl.length = dws->len;
 
-        txdesc = dmaengine_prep_slave_sg(txchan,
+        txdesc = txchan->device->device_prep_slave_sg(txchan,
                                 &dws->tx_sgl,
                                 1,
-                                DMA_MEM_TO_DEV,
+                                DMA_TO_DEVICE,
                                 DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_DEST_UNMAP);
         txdesc->callback = dw_spi_dma_done;
         txdesc->callback_param = dws;
 
         /* 3. Prepare the RX dma transfer */
-        rxconf.direction = DMA_DEV_TO_MEM;
+        rxconf.direction = DMA_FROM_DEVICE;
         rxconf.src_addr = dws->dma_addr;
         rxconf.src_maxburst = LNW_DMA_MSIZE_16;
         rxconf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
         rxconf.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
-        rxconf.device_fc = false;
 
         rxchan->device->device_control(rxchan, DMA_SLAVE_CONFIG,
                                        (unsigned long) &rxconf);
@@ -169,10 +166,10 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
         dws->rx_sgl.dma_address = dws->rx_dma;
         dws->rx_sgl.length = dws->len;
 
-        rxdesc = dmaengine_prep_slave_sg(rxchan,
+        rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
                                 &dws->rx_sgl,
                                 1,
-                                DMA_DEV_TO_MEM,
+                                DMA_FROM_DEVICE,
                                 DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_DEST_UNMAP);
         rxdesc->callback = dw_spi_dma_done;
         rxdesc->callback_param = dws;
@@ -203,8 +200,7 @@ static struct dw_spi_dma_ops mid_dma_ops = {
 
 int dw_spi_mid_init(struct dw_spi *dws)
 {
-        void __iomem *clk_reg;
-        u32 clk_cdiv;
+        u32 *clk_reg, clk_cdiv;
 
         clk_reg = ioremap_nocache(MRST_CLK_SPI0_REG, 16);
         if (!clk_reg)
diff --git a/drivers/spi/spi-dw-mmio.c b/drivers/spi/spi-dw-mmio.c
index 4a6d5c9057a..34eb66501db 100644
--- a/drivers/spi/spi-dw-mmio.c
+++ b/drivers/spi/spi-dw-mmio.c
@@ -15,7 +15,6 @@
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
 #include <linux/scatterlist.h>
-#include <linux/module.h>
 
 #include "spi-dw.h"
 
@@ -26,7 +25,7 @@ struct dw_spi_mmio {
         struct clk     *clk;
 };
 
-static int dw_spi_mmio_probe(struct platform_device *pdev)
+static int __devinit dw_spi_mmio_probe(struct platform_device *pdev)
 {
         struct dw_spi_mmio *dwsmmio;
         struct dw_spi *dws;
@@ -106,7 +105,7 @@ err_end:
         return ret;
 }
 
-static int dw_spi_mmio_remove(struct platform_device *pdev)
+static int __devexit dw_spi_mmio_remove(struct platform_device *pdev)
 {
         struct dw_spi_mmio *dwsmmio = platform_get_drvdata(pdev);
         struct resource *mem;
@@ -128,14 +127,24 @@ static int dw_spi_mmio_remove(struct platform_device *pdev)
 }
 
 static struct platform_driver dw_spi_mmio_driver = {
-        .probe          = dw_spi_mmio_probe,
-        .remove         = dw_spi_mmio_remove,
+        .remove         = __devexit_p(dw_spi_mmio_remove),
         .driver         = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(dw_spi_mmio_driver);
+
+static int __init dw_spi_mmio_init(void)
+{
+        return platform_driver_probe(&dw_spi_mmio_driver, dw_spi_mmio_probe);
+}
+module_init(dw_spi_mmio_init);
+
+static void __exit dw_spi_mmio_exit(void)
+{
+        platform_driver_unregister(&dw_spi_mmio_driver);
+}
+module_exit(dw_spi_mmio_exit);
 
 MODULE_AUTHOR("Jean-Hugues Deschenes <jean-hugues.deschenes@octasic.com>");
 MODULE_DESCRIPTION("Memory-mapped I/O interface driver for DW SPI Core");
diff --git a/drivers/spi/spi-dw-pci.c b/drivers/spi/spi-dw-pci.c
index 6055c8d9fdd..c5f37f03ac8 100644
--- a/drivers/spi/spi-dw-pci.c
+++ b/drivers/spi/spi-dw-pci.c
@@ -21,7 +21,6 @@
 #include <linux/pci.h>
 #include <linux/slab.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
 
 #include "spi-dw.h"
 
@@ -32,7 +31,7 @@ struct dw_spi_pci {
         struct dw_spi   dws;
 };
 
-static int spi_pci_probe(struct pci_dev *pdev,
+static int __devinit spi_pci_probe(struct pci_dev *pdev,
         const struct pci_device_id *ent)
 {
         struct dw_spi_pci *dwpci;
@@ -105,7 +104,7 @@ err_disable:
         return ret;
 }
 
-static void spi_pci_remove(struct pci_dev *pdev)
+static void __devexit spi_pci_remove(struct pci_dev *pdev)
 {
         struct dw_spi_pci *dwpci = pci_get_drvdata(pdev);
 
@@ -149,7 +148,7 @@ static int spi_resume(struct pci_dev *pdev)
 #define spi_resume      NULL
 #endif
 
-static DEFINE_PCI_DEVICE_TABLE(pci_ids) = {
+static const struct pci_device_id pci_ids[] __devinitdata = {
         /* Intel MID platform SPI controller 0 */
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x0800) },
         {},
@@ -159,12 +158,23 @@ static struct pci_driver dw_spi_driver = {
         .name =         DRIVER_NAME,
         .id_table =     pci_ids,
         .probe =        spi_pci_probe,
-        .remove =       spi_pci_remove,
+        .remove =       __devexit_p(spi_pci_remove),
         .suspend =      spi_suspend,
         .resume =       spi_resume,
 };
 
-module_pci_driver(dw_spi_driver);
+static int __init mrst_spi_init(void)
+{
+        return pci_register_driver(&dw_spi_driver);
+}
+
+static void __exit mrst_spi_exit(void)
+{
+        pci_unregister_driver(&dw_spi_driver);
+}
+
+module_init(mrst_spi_init);
+module_exit(mrst_spi_exit);
 
 MODULE_AUTHOR("Feng Tang <feng.tang@intel.com>");
 MODULE_DESCRIPTION("PCI interface driver for DW SPI Core");
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index c1abc06899e..857cd30b44b 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -19,7 +19,6 @@
 
 #include <linux/dma-mapping.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
 #include <linux/highmem.h>
 #include <linux/delay.h>
 #include <linux/slab.h>
@@ -63,6 +62,12 @@ struct chip_data {
 };
 
 #ifdef CONFIG_DEBUG_FS
+static int spi_show_regs_open(struct inode *inode, struct file *file)
+{
+        file->private_data = inode->i_private;
+        return 0;
+}
+
 #define SPI_REGS_BUFSIZE        1024
 static ssize_t  spi_show_regs(struct file *file, char __user *user_buf,
                                 size_t count, loff_t *ppos)
@@ -83,35 +88,35 @@ static ssize_t  spi_show_regs(struct file *file, char __user *user_buf,
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
                         "=================================\n");
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "CTRL0: \t\t0x%08x\n", dw_readl(dws, DW_SPI_CTRL0));
+                        "CTRL0: \t\t0x%08x\n", dw_readl(dws, ctrl0));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "CTRL1: \t\t0x%08x\n", dw_readl(dws, DW_SPI_CTRL1));
+                        "CTRL1: \t\t0x%08x\n", dw_readl(dws, ctrl1));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SSIENR: \t0x%08x\n", dw_readl(dws, DW_SPI_SSIENR));
+                        "SSIENR: \t0x%08x\n", dw_readl(dws, ssienr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SER: \t\t0x%08x\n", dw_readl(dws, DW_SPI_SER));
+                        "SER: \t\t0x%08x\n", dw_readl(dws, ser));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "BAUDR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_BAUDR));
+                        "BAUDR: \t\t0x%08x\n", dw_readl(dws, baudr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "TXFTLR: \t0x%08x\n", dw_readl(dws, DW_SPI_TXFLTR));
+                        "TXFTLR: \t0x%08x\n", dw_readl(dws, txfltr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "RXFTLR: \t0x%08x\n", dw_readl(dws, DW_SPI_RXFLTR));
+                        "RXFTLR: \t0x%08x\n", dw_readl(dws, rxfltr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "TXFLR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_TXFLR));
+                        "TXFLR: \t\t0x%08x\n", dw_readl(dws, txflr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "RXFLR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_RXFLR));
+                        "RXFLR: \t\t0x%08x\n", dw_readl(dws, rxflr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "SR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_SR));
+                        "SR: \t\t0x%08x\n", dw_readl(dws, sr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "IMR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_IMR));
+                        "IMR: \t\t0x%08x\n", dw_readl(dws, imr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "ISR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_ISR));
+                        "ISR: \t\t0x%08x\n", dw_readl(dws, isr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMACR: \t\t0x%08x\n", dw_readl(dws, DW_SPI_DMACR));
+                        "DMACR: \t\t0x%08x\n", dw_readl(dws, dmacr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMATDLR: \t0x%08x\n", dw_readl(dws, DW_SPI_DMATDLR));
+                        "DMATDLR: \t0x%08x\n", dw_readl(dws, dmatdlr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
-                        "DMARDLR: \t0x%08x\n", dw_readl(dws, DW_SPI_DMARDLR));
+                        "DMARDLR: \t0x%08x\n", dw_readl(dws, dmardlr));
         len += snprintf(buf + len, SPI_REGS_BUFSIZE - len,
                         "=================================\n");
 
@@ -122,7 +127,7 @@ static ssize_t  spi_show_regs(struct file *file, char __user *user_buf,
 
 static const struct file_operations mrst_spi_regs_ops = {
         .owner          = THIS_MODULE,
-        .open           = simple_open,
+        .open           = spi_show_regs_open,
         .read           = spi_show_regs,
         .llseek         = default_llseek,
 };
@@ -161,7 +166,7 @@ static inline u32 tx_max(struct dw_spi *dws)
         u32 tx_left, tx_room, rxtx_gap;
 
         tx_left = (dws->tx_end - dws->tx) / dws->n_bytes;
-        tx_room = dws->fifo_len - dw_readw(dws, DW_SPI_TXFLR);
+        tx_room = dws->fifo_len - dw_readw(dws, txflr);
 
         /*
          * Another concern is about the tx/rx mismatch, we
@@ -182,7 +187,7 @@ static inline u32 rx_max(struct dw_spi *dws)
 {
         u32 rx_left = (dws->rx_end - dws->rx) / dws->n_bytes;
 
-        return min(rx_left, (u32)dw_readw(dws, DW_SPI_RXFLR));
+        return min(rx_left, (u32)dw_readw(dws, rxflr));
 }
 
 static void dw_writer(struct dw_spi *dws)
@@ -198,7 +203,7 @@ static void dw_writer(struct dw_spi *dws)
                         else
                                 txw = *(u16 *)(dws->tx);
                 }
-                dw_writew(dws, DW_SPI_DR, txw);
+                dw_writew(dws, dr, txw);
                 dws->tx += dws->n_bytes;
         }
 }
@@ -209,7 +214,7 @@ static void dw_reader(struct dw_spi *dws)
         u16 rxw;
 
         while (max--) {
-                rxw = dw_readw(dws, DW_SPI_DR);
+                rxw = dw_readw(dws, dr);
                 /* Care rx only if the transfer's original "rx" is not null */
                 if (dws->rx_end - dws->len) {
                         if (dws->n_bytes == 1)
@@ -317,13 +322,13 @@ EXPORT_SYMBOL_GPL(dw_spi_xfer_done);
 
 static irqreturn_t interrupt_transfer(struct dw_spi *dws)
 {
-        u16 irq_status = dw_readw(dws, DW_SPI_ISR);
+        u16 irq_status = dw_readw(dws, isr);
 
         /* Error handling */
         if (irq_status & (SPI_INT_TXOI | SPI_INT_RXOI | SPI_INT_RXUI)) {
-                dw_readw(dws, DW_SPI_TXOICR);
-                dw_readw(dws, DW_SPI_RXOICR);
-                dw_readw(dws, DW_SPI_RXUICR);
+                dw_readw(dws, txoicr);
+                dw_readw(dws, rxoicr);
+                dw_readw(dws, rxuicr);
                 int_error_stop(dws, "interrupt_transfer: fifo overrun/underrun");
                 return IRQ_HANDLED;
         }
@@ -347,7 +352,7 @@ static irqreturn_t interrupt_transfer(struct dw_spi *dws)
 static irqreturn_t dw_spi_irq(int irq, void *dev_id)
 {
         struct dw_spi *dws = dev_id;
-        u16 irq_status = dw_readw(dws, DW_SPI_ISR) & 0x3f;
+        u16 irq_status = dw_readw(dws, isr) & 0x3f;
 
         if (!irq_status)
                 return IRQ_NONE;
@@ -515,11 +520,11 @@ static void pump_transfers(unsigned long data)
          *      2. clk_div is changed
          *      3. control value changes
          */
-        if (dw_readw(dws, DW_SPI_CTRL0) != cr0 || cs_change || clk_div || imask) {
+        if (dw_readw(dws, ctrl0) != cr0 || cs_change || clk_div || imask) {
                 spi_enable_chip(dws, 0);
 
-                if (dw_readw(dws, DW_SPI_CTRL0) != cr0)
-                        dw_writew(dws, DW_SPI_CTRL0, cr0);
+                if (dw_readw(dws, ctrl0) != cr0)
+                        dw_writew(dws, ctrl0, cr0);
 
                 spi_set_clk(dws, clk_div ? clk_div : chip->clk_div);
                 spi_chip_sel(dws, spi->chip_select);
@@ -529,7 +534,7 @@ static void pump_transfers(unsigned long data)
                 if (imask)
                         spi_umask_intr(dws, imask);
                 if (txint_level)
-                        dw_writew(dws, DW_SPI_TXFLTR, txint_level);
+                        dw_writew(dws, txfltr, txint_level);
 
                 spi_enable_chip(dws, 1);
                 if (cs_change)
@@ -696,7 +701,7 @@ static void dw_spi_cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
-static int init_queue(struct dw_spi *dws)
+static int __devinit init_queue(struct dw_spi *dws)
 {
         INIT_LIST_HEAD(&dws->queue);
         spin_lock_init(&dws->lock);
@@ -785,17 +790,17 @@ static void spi_hw_init(struct dw_spi *dws)
         if (!dws->fifo_len) {
                 u32 fifo;
                 for (fifo = 2; fifo <= 257; fifo++) {
-                        dw_writew(dws, DW_SPI_TXFLTR, fifo);
-                        if (fifo != dw_readw(dws, DW_SPI_TXFLTR))
+                        dw_writew(dws, txfltr, fifo);
+                        if (fifo != dw_readw(dws, txfltr))
                                 break;
                 }
 
                 dws->fifo_len = (fifo == 257) ? 0 : fifo;
-                dw_writew(dws, DW_SPI_TXFLTR, 0);
+                dw_writew(dws, txfltr, 0);
         }
 }
 
-int dw_spi_add_host(struct dw_spi *dws)
+int __devinit dw_spi_add_host(struct dw_spi *dws)
 {
         struct spi_master *master;
         int ret;
@@ -877,7 +882,7 @@ exit:
 }
 EXPORT_SYMBOL_GPL(dw_spi_add_host);
 
-void dw_spi_remove_host(struct dw_spi *dws)
+void __devexit dw_spi_remove_host(struct dw_spi *dws)
 {
         int status = 0;
 
diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h
index 9c57c078031..8b7b07bf6c3 100644
--- a/drivers/spi/spi-dw.h
+++ b/drivers/spi/spi-dw.h
@@ -4,33 +4,6 @@
 #include <linux/io.h>
 #include <linux/scatterlist.h>
 
-/* Register offsets */
-#define DW_SPI_CTRL0                    0x00
-#define DW_SPI_CTRL1                    0x04
-#define DW_SPI_SSIENR                   0x08
-#define DW_SPI_MWCR                     0x0c
-#define DW_SPI_SER                      0x10
-#define DW_SPI_BAUDR                    0x14
-#define DW_SPI_TXFLTR                   0x18
-#define DW_SPI_RXFLTR                   0x1c
-#define DW_SPI_TXFLR                    0x20
-#define DW_SPI_RXFLR                    0x24
-#define DW_SPI_SR                       0x28
-#define DW_SPI_IMR                      0x2c
-#define DW_SPI_ISR                      0x30
-#define DW_SPI_RISR                     0x34
-#define DW_SPI_TXOICR                   0x38
-#define DW_SPI_RXOICR                   0x3c
-#define DW_SPI_RXUICR                   0x40
-#define DW_SPI_MSTICR                   0x44
-#define DW_SPI_ICR                      0x48
-#define DW_SPI_DMACR                    0x4c
-#define DW_SPI_DMATDLR                  0x50
-#define DW_SPI_DMARDLR                  0x54
-#define DW_SPI_IDR                      0x58
-#define DW_SPI_VERSION                  0x5c
-#define DW_SPI_DR                       0x60
-
 /* Bit fields in CTRLR0 */
 #define SPI_DFS_OFFSET                  0
 
@@ -82,6 +55,35 @@ enum dw_ssi_type {
         SSI_NS_MICROWIRE,
 };
 
+struct dw_spi_reg {
+        u32     ctrl0;
+        u32     ctrl1;
+        u32     ssienr;
+        u32     mwcr;
+        u32     ser;
+        u32     baudr;
+        u32     txfltr;
+        u32     rxfltr;
+        u32     txflr;
+        u32     rxflr;
+        u32     sr;
+        u32     imr;
+        u32     isr;
+        u32     risr;
+        u32     txoicr;
+        u32     rxoicr;
+        u32     rxuicr;
+        u32     msticr;
+        u32     icr;
+        u32     dmacr;
+        u32     dmatdlr;
+        u32     dmardlr;
+        u32     idr;
+        u32     version;
+        u32     dr;             /* Currently oper as 32 bits,
+                                though only low 16 bits matters */
+} __packed;
+
 struct dw_spi;
 struct dw_spi_dma_ops {
         int (*dma_init)(struct dw_spi *dws);
@@ -159,34 +161,23 @@ struct dw_spi {
 #endif
 };
 
-static inline u32 dw_readl(struct dw_spi *dws, u32 offset)
-{
-        return __raw_readl(dws->regs + offset);
-}
-
-static inline void dw_writel(struct dw_spi *dws, u32 offset, u32 val)
-{
-        __raw_writel(val, dws->regs + offset);
-}
-
-static inline u16 dw_readw(struct dw_spi *dws, u32 offset)
-{
-        return __raw_readw(dws->regs + offset);
-}
-
-static inline void dw_writew(struct dw_spi *dws, u32 offset, u16 val)
-{
-        __raw_writew(val, dws->regs + offset);
-}
+#define dw_readl(dw, name) \
+        __raw_readl(&(((struct dw_spi_reg *)dw->regs)->name))
+#define dw_writel(dw, name, val) \
+        __raw_writel((val), &(((struct dw_spi_reg *)dw->regs)->name))
+#define dw_readw(dw, name) \
+        __raw_readw(&(((struct dw_spi_reg *)dw->regs)->name))
+#define dw_writew(dw, name, val) \
+        __raw_writew((val), &(((struct dw_spi_reg *)dw->regs)->name))
 
 static inline void spi_enable_chip(struct dw_spi *dws, int enable)
 {
-        dw_writel(dws, DW_SPI_SSIENR, (enable ? 1 : 0));
+        dw_writel(dws, ssienr, (enable ? 1 : 0));
 }
 
 static inline void spi_set_clk(struct dw_spi *dws, u16 div)
 {
-        dw_writel(dws, DW_SPI_BAUDR, div);
+        dw_writel(dws, baudr, div);
 }
 
 static inline void spi_chip_sel(struct dw_spi *dws, u16 cs)
@@ -197,7 +188,7 @@ static inline void spi_chip_sel(struct dw_spi *dws, u16 cs)
         if (dws->cs_control)
                 dws->cs_control(1);
 
-        dw_writel(dws, DW_SPI_SER, 1 << cs);
+        dw_writel(dws, ser, 1 << cs);
 }
 
 /* Disable IRQ bits */
@@ -205,8 +196,8 @@ static inline void spi_mask_intr(struct dw_spi *dws, u32 mask)
 {
         u32 new_mask;
 
-        new_mask = dw_readl(dws, DW_SPI_IMR) & ~mask;
-        dw_writel(dws, DW_SPI_IMR, new_mask);
+        new_mask = dw_readl(dws, imr) & ~mask;
+        dw_writel(dws, imr, new_mask);
 }
 
 /* Enable IRQ bits */
@@ -214,8 +205,8 @@ static inline void spi_umask_intr(struct dw_spi *dws, u32 mask)
 {
         u32 new_mask;
 
-        new_mask = dw_readl(dws, DW_SPI_IMR) | mask;
-        dw_writel(dws, DW_SPI_IMR, new_mask);
+        new_mask = dw_readl(dws, imr) | mask;
+        dw_writel(dws, imr, new_mask);
 }
 
 /*
diff --git a/drivers/spi/spi-ep93xx.c b/drivers/spi/spi-ep93xx.c
index acb1e1935c5..1cf645479bf 100644
--- a/drivers/spi/spi-ep93xx.c
+++ b/drivers/spi/spi-ep93xx.c
@@ -24,15 +24,14 @@
 #include <linux/dmaengine.h>
 #include <linux/bitops.h>
 #include <linux/interrupt.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/workqueue.h>
 #include <linux/sched.h>
 #include <linux/scatterlist.h>
 #include <linux/spi/spi.h>
 
-#include <linux/platform_data/dma-ep93xx.h>
-#include <linux/platform_data/spi-ep93xx.h>
+#include <mach/dma.h>
+#include <mach/ep93xx_spi.h>
 
 #define SSPCR0                  0x0000
 #define SSPCR0_MODE_SHIFT       6
@@ -76,6 +75,7 @@
  * @clk: clock for the controller
  * @regs_base: pointer to ioremap()'d registers
  * @sspdr_phys: physical address of the SSPDR register
+ * @irq: IRQ number used by the driver
  * @min_rate: minimum clock rate (in Hz) supported by the controller
  * @max_rate: maximum clock rate (in Hz) supported by the controller
  * @running: is the queue running
@@ -113,6 +113,7 @@ struct ep93xx_spi {
         struct clk                      *clk;
         void __iomem                    *regs_base;
         unsigned long                   sspdr_phys;
+        int                             irq;
         unsigned long                   min_rate;
         unsigned long                   max_rate;
         bool                            running;
@@ -543,7 +544,7 @@ static void ep93xx_spi_pio_transfer(struct ep93xx_spi *espi)
  * in case of failure.
  */
 static struct dma_async_tx_descriptor *
-ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_transfer_direction dir)
+ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_data_direction dir)
 {
         struct spi_transfer *t = espi->current_msg->state;
         struct dma_async_tx_descriptor *txd;
@@ -564,7 +565,7 @@ ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_transfer_direction dir)
         memset(&conf, 0, sizeof(conf));
         conf.direction = dir;
 
-        if (dir == DMA_DEV_TO_MEM) {
+        if (dir == DMA_FROM_DEVICE) {
                 chan = espi->dma_rx;
                 buf = t->rx_buf;
                 sgt = &espi->rx_sgt;
@@ -628,7 +629,8 @@ ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_transfer_direction dir)
         if (!nents)
                 return ERR_PTR(-ENOMEM);
 
-        txd = dmaengine_prep_slave_sg(chan, sgt->sgl, nents, dir, DMA_CTRL_ACK);
+        txd = chan->device->device_prep_slave_sg(chan, sgt->sgl, nents,
+                                                 dir, DMA_CTRL_ACK);
         if (!txd) {
                 dma_unmap_sg(chan->device->dev, sgt->sgl, sgt->nents, dir);
                 return ERR_PTR(-ENOMEM);
@@ -645,12 +647,12 @@ ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_transfer_direction dir)
  * unmapped.
  */
 static void ep93xx_spi_dma_finish(struct ep93xx_spi *espi,
-                                  enum dma_transfer_direction dir)
+                                  enum dma_data_direction dir)
 {
         struct dma_chan *chan;
         struct sg_table *sgt;
 
-        if (dir == DMA_DEV_TO_MEM) {
+        if (dir == DMA_FROM_DEVICE) {
                 chan = espi->dma_rx;
                 sgt = &espi->rx_sgt;
         } else {
@@ -671,16 +673,16 @@ static void ep93xx_spi_dma_transfer(struct ep93xx_spi *espi)
         struct spi_message *msg = espi->current_msg;
         struct dma_async_tx_descriptor *rxd, *txd;
 
-        rxd = ep93xx_spi_dma_prepare(espi, DMA_DEV_TO_MEM);
+        rxd = ep93xx_spi_dma_prepare(espi, DMA_FROM_DEVICE);
         if (IS_ERR(rxd)) {
                 dev_err(&espi->pdev->dev, "DMA RX failed: %ld\n", PTR_ERR(rxd));
                 msg->status = PTR_ERR(rxd);
                 return;
         }
 
-        txd = ep93xx_spi_dma_prepare(espi, DMA_MEM_TO_DEV);
+        txd = ep93xx_spi_dma_prepare(espi, DMA_TO_DEVICE);
         if (IS_ERR(txd)) {
-                ep93xx_spi_dma_finish(espi, DMA_DEV_TO_MEM);
+                ep93xx_spi_dma_finish(espi, DMA_FROM_DEVICE);
                 dev_err(&espi->pdev->dev, "DMA TX failed: %ld\n", PTR_ERR(rxd));
                 msg->status = PTR_ERR(txd);
                 return;
@@ -699,8 +701,8 @@ static void ep93xx_spi_dma_transfer(struct ep93xx_spi *espi)
 
         wait_for_completion(&espi->wait);
 
-        ep93xx_spi_dma_finish(espi, DMA_MEM_TO_DEV);
-        ep93xx_spi_dma_finish(espi, DMA_DEV_TO_MEM);
+        ep93xx_spi_dma_finish(espi, DMA_TO_DEVICE);
+        ep93xx_spi_dma_finish(espi, DMA_FROM_DEVICE);
 }
 
 /**
@@ -976,7 +978,7 @@ static int ep93xx_spi_setup_dma(struct ep93xx_spi *espi)
         dma_cap_set(DMA_SLAVE, mask);
 
         espi->dma_rx_data.port = EP93XX_DMA_SSP;
-        espi->dma_rx_data.direction = DMA_DEV_TO_MEM;
+        espi->dma_rx_data.direction = DMA_FROM_DEVICE;
         espi->dma_rx_data.name = "ep93xx-spi-rx";
 
         espi->dma_rx = dma_request_channel(mask, ep93xx_spi_dma_filter,
@@ -987,7 +989,7 @@ static int ep93xx_spi_setup_dma(struct ep93xx_spi *espi)
         }
 
         espi->dma_tx_data.port = EP93XX_DMA_SSP;
-        espi->dma_tx_data.direction = DMA_MEM_TO_DEV;
+        espi->dma_tx_data.direction = DMA_TO_DEVICE;
         espi->dma_tx_data.name = "ep93xx-spi-tx";
 
         espi->dma_tx = dma_request_channel(mask, ep93xx_spi_dma_filter,
@@ -1023,13 +1025,12 @@ static void ep93xx_spi_release_dma(struct ep93xx_spi *espi)
                 free_page((unsigned long)espi->zeropage);
 }
 
-static int ep93xx_spi_probe(struct platform_device *pdev)
+static int __init ep93xx_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct ep93xx_spi_info *info;
         struct ep93xx_spi *espi;
         struct resource *res;
-        int irq;
         int error;
 
         info = pdev->dev.platform_data;
@@ -1069,8 +1070,8 @@ static int ep93xx_spi_probe(struct platform_device *pdev)
         espi->min_rate = clk_get_rate(espi->clk) / (254 * 256);
         espi->pdev = pdev;
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
+        espi->irq = platform_get_irq(pdev, 0);
+        if (espi->irq < 0) {
                 error = -EBUSY;
                 dev_err(&pdev->dev, "failed to get irq resources\n");
                 goto fail_put_clock;
@@ -1083,20 +1084,26 @@ static int ep93xx_spi_probe(struct platform_device *pdev)
                 goto fail_put_clock;
         }
 
-        espi->sspdr_phys = res->start + SSPDR;
+        res = request_mem_region(res->start, resource_size(res), pdev->name);
+        if (!res) {
+                dev_err(&pdev->dev, "unable to request iomem resources\n");
+                error = -EBUSY;
+                goto fail_put_clock;
+        }
 
-        espi->regs_base = devm_request_and_ioremap(&pdev->dev, res);
+        espi->sspdr_phys = res->start + SSPDR;
+        espi->regs_base = ioremap(res->start, resource_size(res));
         if (!espi->regs_base) {
                 dev_err(&pdev->dev, "failed to map resources\n");
                 error = -ENODEV;
-                goto fail_put_clock;
+                goto fail_free_mem;
         }
 
-        error = devm_request_irq(&pdev->dev, irq, ep93xx_spi_interrupt,
-                                0, "ep93xx-spi", espi);
+        error = request_irq(espi->irq, ep93xx_spi_interrupt, 0,
+                            "ep93xx-spi", espi);
         if (error) {
                 dev_err(&pdev->dev, "failed to request irq\n");
-                goto fail_put_clock;
+                goto fail_unmap_regs;
         }
 
         if (info->use_dma && ep93xx_spi_setup_dma(espi))
@@ -1121,7 +1128,7 @@ static int ep93xx_spi_probe(struct platform_device *pdev)
         }
 
         dev_info(&pdev->dev, "EP93xx SPI Controller at 0x%08lx irq %d\n",
-                 (unsigned long)res->start, irq);
+                 (unsigned long)res->start, espi->irq);
 
         return 0;
 
@@ -1129,6 +1136,11 @@ fail_free_queue:
         destroy_workqueue(espi->wq);
 fail_free_dma:
         ep93xx_spi_release_dma(espi);
+        free_irq(espi->irq, espi);
+fail_unmap_regs:
+        iounmap(espi->regs_base);
+fail_free_mem:
+        release_mem_region(res->start, resource_size(res));
 fail_put_clock:
         clk_put(espi->clk);
 fail_release_master:
@@ -1138,10 +1150,11 @@ fail_release_master:
         return error;
 }
 
-static int ep93xx_spi_remove(struct platform_device *pdev)
+static int __exit ep93xx_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master = platform_get_drvdata(pdev);
         struct ep93xx_spi *espi = spi_master_get_devdata(master);
+        struct resource *res;
 
         spin_lock_irq(&espi->lock);
         espi->running = false;
@@ -1167,6 +1180,10 @@ static int ep93xx_spi_remove(struct platform_device *pdev)
         spin_unlock_irq(&espi->lock);
 
         ep93xx_spi_release_dma(espi);
+        free_irq(espi->irq, espi);
+        iounmap(espi->regs_base);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(res->start, resource_size(res));
         clk_put(espi->clk);
         platform_set_drvdata(pdev, NULL);
 
@@ -1179,10 +1196,20 @@ static struct platform_driver ep93xx_spi_driver = {
                 .name   = "ep93xx-spi",
                 .owner  = THIS_MODULE,
         },
-        .probe          = ep93xx_spi_probe,
-        .remove         = ep93xx_spi_remove,
+        .remove         = __exit_p(ep93xx_spi_remove),
 };
-module_platform_driver(ep93xx_spi_driver);
+
+static int __init ep93xx_spi_init(void)
+{
+        return platform_driver_probe(&ep93xx_spi_driver, ep93xx_spi_probe);
+}
+module_init(ep93xx_spi_init);
+
+static void __exit ep93xx_spi_exit(void)
+{
+        platform_driver_unregister(&ep93xx_spi_driver);
+}
+module_exit(ep93xx_spi_exit);
 
 MODULE_DESCRIPTION("EP93xx SPI Controller driver");
 MODULE_AUTHOR("Mika Westerberg <mika.westerberg@iki.fi>");
diff --git a/drivers/spi/spi-falcon.c b/drivers/spi/spi-falcon.c
deleted file mode 100644
index 6a6f62ec284..00000000000
--- a/drivers/spi/spi-falcon.c
+++ /dev/null
@@ -1,469 +0,0 @@
-/*
- *  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.
- *
- *  Copyright (C) 2012 Thomas Langer <thomas.langer@lantiq.com>
- */
-
-#include <linux/module.h>
-#include <linux/device.h>
-#include <linux/platform_device.h>
-#include <linux/spi/spi.h>
-#include <linux/delay.h>
-#include <linux/workqueue.h>
-#include <linux/of.h>
-#include <linux/of_platform.h>
-
-#include <lantiq_soc.h>
-
-#define DRV_NAME                "sflash-falcon"
-
-#define FALCON_SPI_XFER_BEGIN   (1 << 0)
-#define FALCON_SPI_XFER_END     (1 << 1)
-
-/* Bus Read Configuration Register0 */
-#define BUSRCON0                0x00000010
-/* Bus Write Configuration Register0 */
-#define BUSWCON0                0x00000018
-/* Serial Flash Configuration Register */
-#define SFCON                   0x00000080
-/* Serial Flash Time Register */
-#define SFTIME                  0x00000084
-/* Serial Flash Status Register */
-#define SFSTAT                  0x00000088
-/* Serial Flash Command Register */
-#define SFCMD                   0x0000008C
-/* Serial Flash Address Register */
-#define SFADDR                  0x00000090
-/* Serial Flash Data Register */
-#define SFDATA                  0x00000094
-/* Serial Flash I/O Control Register */
-#define SFIO                    0x00000098
-/* EBU Clock Control Register */
-#define EBUCC                   0x000000C4
-
-/* Dummy Phase Length */
-#define SFCMD_DUMLEN_OFFSET     16
-#define SFCMD_DUMLEN_MASK       0x000F0000
-/* Chip Select */
-#define SFCMD_CS_OFFSET         24
-#define SFCMD_CS_MASK           0x07000000
-/* field offset */
-#define SFCMD_ALEN_OFFSET       20
-#define SFCMD_ALEN_MASK         0x00700000
-/* SCK Rise-edge Position */
-#define SFTIME_SCKR_POS_OFFSET  8
-#define SFTIME_SCKR_POS_MASK    0x00000F00
-/* SCK Period */
-#define SFTIME_SCK_PER_OFFSET   0
-#define SFTIME_SCK_PER_MASK     0x0000000F
-/* SCK Fall-edge Position */
-#define SFTIME_SCKF_POS_OFFSET  12
-#define SFTIME_SCKF_POS_MASK    0x0000F000
-/* Device Size */
-#define SFCON_DEV_SIZE_A23_0    0x03000000
-#define SFCON_DEV_SIZE_MASK     0x0F000000
-/* Read Data Position */
-#define SFTIME_RD_POS_MASK      0x000F0000
-/* Data Output */
-#define SFIO_UNUSED_WD_MASK     0x0000000F
-/* Command Opcode mask */
-#define SFCMD_OPC_MASK          0x000000FF
-/* dlen bytes of data to write */
-#define SFCMD_DIR_WRITE         0x00000100
-/* Data Length offset */
-#define SFCMD_DLEN_OFFSET       9
-/* Command Error */
-#define SFSTAT_CMD_ERR          0x20000000
-/* Access Command Pending */
-#define SFSTAT_CMD_PEND         0x00400000
-/* Frequency set to 100MHz. */
-#define EBUCC_EBUDIV_SELF100    0x00000001
-/* Serial Flash */
-#define BUSRCON0_AGEN_SERIAL_FLASH      0xF0000000
-/* 8-bit multiplexed */
-#define BUSRCON0_PORTW_8_BIT_MUX        0x00000000
-/* Serial Flash */
-#define BUSWCON0_AGEN_SERIAL_FLASH      0xF0000000
-/* Chip Select after opcode */
-#define SFCMD_KEEP_CS_KEEP_SELECTED     0x00008000
-
-#define CLOCK_100M      100000000
-#define CLOCK_50M       50000000
-
-struct falcon_sflash {
-        u32 sfcmd; /* for caching of opcode, direction, ... */
-        struct spi_master *master;
-};
-
-int falcon_sflash_xfer(struct spi_device *spi, struct spi_transfer *t,
-                unsigned long flags)
-{
-        struct device *dev = &spi->dev;
-        struct falcon_sflash *priv = spi_master_get_devdata(spi->master);
-        const u8 *txp = t->tx_buf;
-        u8 *rxp = t->rx_buf;
-        unsigned int bytelen = ((8 * t->len + 7) / 8);
-        unsigned int len, alen, dumlen;
-        u32 val;
-        enum {
-                state_init,
-                state_command_prepare,
-                state_write,
-                state_read,
-                state_disable_cs,
-                state_end
-        } state = state_init;
-
-        do {
-                switch (state) {
-                case state_init: /* detect phase of upper layer sequence */
-                {
-                        /* initial write ? */
-                        if (flags & FALCON_SPI_XFER_BEGIN) {
-                                if (!txp) {
-                                        dev_err(dev,
-                                                "BEGIN without tx data!\n");
-                                        return -ENODATA;
-                                }
-                                /*
-                                 * Prepare the parts of the sfcmd register,
-                                 * which should not change during a sequence!
-                                 * Only exception are the length fields,
-                                 * especially alen and dumlen.
-                                 */
-
-                                priv->sfcmd = ((spi->chip_select
-                                                << SFCMD_CS_OFFSET)
-                                               & SFCMD_CS_MASK);
-                                priv->sfcmd |= SFCMD_KEEP_CS_KEEP_SELECTED;
-                                priv->sfcmd |= *txp;
-                                txp++;
-                                bytelen--;
-                                if (bytelen) {
-                                        /*
-                                         * more data:
-                                         * maybe address and/or dummy
-                                         */
-                                        state = state_command_prepare;
-                                        break;
-                                } else {
-                                        dev_dbg(dev, "write cmd %02X\n",
-                                                priv->sfcmd & SFCMD_OPC_MASK);
-                                }
-                        }
-                        /* continued write ? */
-                        if (txp && bytelen) {
-                                state = state_write;
-                                break;
-                        }
-                        /* read data? */
-                        if (rxp && bytelen) {
-                                state = state_read;
-                                break;
-                        }
-                        /* end of sequence? */
-                        if (flags & FALCON_SPI_XFER_END)
-                                state = state_disable_cs;
-                        else
-                                state = state_end;
-                        break;
-                }
-                /* collect tx data for address and dummy phase */
-                case state_command_prepare:
-                {
-                        /* txp is valid, already checked */
-                        val = 0;
-                        alen = 0;
-                        dumlen = 0;
-                        while (bytelen > 0) {
-                                if (alen < 3) {
-                                        val = (val << 8) | (*txp++);
-                                        alen++;
-                                } else if ((dumlen < 15) && (*txp == 0)) {
-                                        /*
-                                         * assume dummy bytes are set to 0
-                                         * from upper layer
-                                         */
-                                        dumlen++;
-                                        txp++;
-                                } else {
-                                        break;
-                                }
-                                bytelen--;
-                        }
-                        priv->sfcmd &= ~(SFCMD_ALEN_MASK | SFCMD_DUMLEN_MASK);
-                        priv->sfcmd |= (alen << SFCMD_ALEN_OFFSET) |
-                                         (dumlen << SFCMD_DUMLEN_OFFSET);
-                        if (alen > 0)
-                                ltq_ebu_w32(val, SFADDR);
-
-                        dev_dbg(dev, "wr %02X, alen=%d (addr=%06X) dlen=%d\n",
-                                priv->sfcmd & SFCMD_OPC_MASK,
-                                alen, val, dumlen);
-
-                        if (bytelen > 0) {
-                                /* continue with write */
-                                state = state_write;
-                        } else if (flags & FALCON_SPI_XFER_END) {
-                                /* end of sequence? */
-                                state = state_disable_cs;
-                        } else {
-                                /*
-                                 * go to end and expect another
-                                 * call (read or write)
-                                 */
-                                state = state_end;
-                        }
-                        break;
-                }
-                case state_write:
-                {
-                        /* txp still valid */
-                        priv->sfcmd |= SFCMD_DIR_WRITE;
-                        len = 0;
-                        val = 0;
-                        do {
-                                if (bytelen--)
-                                        val |= (*txp++) << (8 * len++);
-                                if ((flags & FALCON_SPI_XFER_END)
-                                    && (bytelen == 0)) {
-                                        priv->sfcmd &=
-                                                ~SFCMD_KEEP_CS_KEEP_SELECTED;
-                                }
-                                if ((len == 4) || (bytelen == 0)) {
-                                        ltq_ebu_w32(val, SFDATA);
-                                        ltq_ebu_w32(priv->sfcmd
-                                                | (len<<SFCMD_DLEN_OFFSET),
-                                                SFCMD);
-                                        len = 0;
-                                        val = 0;
-                                        priv->sfcmd &= ~(SFCMD_ALEN_MASK
-                                                         | SFCMD_DUMLEN_MASK);
-                                }
-                        } while (bytelen);
-                        state = state_end;
-                        break;
-                }
-                case state_read:
-                {
-                        /* read data */
-                        priv->sfcmd &= ~SFCMD_DIR_WRITE;
-                        do {
-                                if ((flags & FALCON_SPI_XFER_END)
-                                    && (bytelen <= 4)) {
-                                        priv->sfcmd &=
-                                                ~SFCMD_KEEP_CS_KEEP_SELECTED;
-                                }
-                                len = (bytelen > 4) ? 4 : bytelen;
-                                bytelen -= len;
-                                ltq_ebu_w32(priv->sfcmd
-                                        | (len << SFCMD_DLEN_OFFSET), SFCMD);
-                                priv->sfcmd &= ~(SFCMD_ALEN_MASK
-                                                 | SFCMD_DUMLEN_MASK);
-                                do {
-                                        val = ltq_ebu_r32(SFSTAT);
-                                        if (val & SFSTAT_CMD_ERR) {
-                                                /* reset error status */
-                                                dev_err(dev, "SFSTAT: CMD_ERR");
-                                                dev_err(dev, " (%x)\n", val);
-                                                ltq_ebu_w32(SFSTAT_CMD_ERR,
-                                                        SFSTAT);
-                                                return -EBADE;
-                                        }
-                                } while (val & SFSTAT_CMD_PEND);
-                                val = ltq_ebu_r32(SFDATA);
-                                do {
-                                        *rxp = (val & 0xFF);
-                                        rxp++;
-                                        val >>= 8;
-                                        len--;
-                                } while (len);
-                        } while (bytelen);
-                        state = state_end;
-                        break;
-                }
-                case state_disable_cs:
-                {
-                        priv->sfcmd &= ~SFCMD_KEEP_CS_KEEP_SELECTED;
-                        ltq_ebu_w32(priv->sfcmd | (0 << SFCMD_DLEN_OFFSET),
-                                SFCMD);
-                        val = ltq_ebu_r32(SFSTAT);
-                        if (val & SFSTAT_CMD_ERR) {
-                                /* reset error status */
-                                dev_err(dev, "SFSTAT: CMD_ERR (%x)\n", val);
-                                ltq_ebu_w32(SFSTAT_CMD_ERR, SFSTAT);
-                                return -EBADE;
-                        }
-                        state = state_end;
-                        break;
-                }
-                case state_end:
-                        break;
-                }
-        } while (state != state_end);
-
-        return 0;
-}
-
-static int falcon_sflash_setup(struct spi_device *spi)
-{
-        unsigned int i;
-        unsigned long flags;
-
-        if (spi->chip_select > 0)
-                return -ENODEV;
-
-        spin_lock_irqsave(&ebu_lock, flags);
-
-        if (spi->max_speed_hz >= CLOCK_100M) {
-                /* set EBU clock to 100 MHz */
-                ltq_sys1_w32_mask(0, EBUCC_EBUDIV_SELF100, EBUCC);
-                i = 1; /* divider */
-        } else {
-                /* set EBU clock to 50 MHz */
-                ltq_sys1_w32_mask(EBUCC_EBUDIV_SELF100, 0, EBUCC);
-
-                /* search for suitable divider */
-                for (i = 1; i < 7; i++) {
-                        if (CLOCK_50M / i <= spi->max_speed_hz)
-                                break;
-                }
-        }
-
-        /* setup period of serial clock */
-        ltq_ebu_w32_mask(SFTIME_SCKF_POS_MASK
-                     | SFTIME_SCKR_POS_MASK
-                     | SFTIME_SCK_PER_MASK,
-                     (i << SFTIME_SCKR_POS_OFFSET)
-                     | (i << (SFTIME_SCK_PER_OFFSET + 1)),
-                     SFTIME);
-
-        /*
-         * set some bits of unused_wd, to not trigger HOLD/WP
-         * signals on non QUAD flashes
-         */
-        ltq_ebu_w32((SFIO_UNUSED_WD_MASK & (0x8 | 0x4)), SFIO);
-
-        ltq_ebu_w32(BUSRCON0_AGEN_SERIAL_FLASH | BUSRCON0_PORTW_8_BIT_MUX,
-                        BUSRCON0);
-        ltq_ebu_w32(BUSWCON0_AGEN_SERIAL_FLASH, BUSWCON0);
-        /* set address wrap around to maximum for 24-bit addresses */
-        ltq_ebu_w32_mask(SFCON_DEV_SIZE_MASK, SFCON_DEV_SIZE_A23_0, SFCON);
-
-        spin_unlock_irqrestore(&ebu_lock, flags);
-
-        return 0;
-}
-
-static int falcon_sflash_prepare_xfer(struct spi_master *master)
-{
-        return 0;
-}
-
-static int falcon_sflash_unprepare_xfer(struct spi_master *master)
-{
-        return 0;
-}
-
-static int falcon_sflash_xfer_one(struct spi_master *master,
-                                        struct spi_message *m)
-{
-        struct falcon_sflash *priv = spi_master_get_devdata(master);
-        struct spi_transfer *t;
-        unsigned long spi_flags;
-        unsigned long flags;
-        int ret = 0;
-
-        priv->sfcmd = 0;
-        m->actual_length = 0;
-
-        spi_flags = FALCON_SPI_XFER_BEGIN;
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                if (list_is_last(&t->transfer_list, &m->transfers))
-                        spi_flags |= FALCON_SPI_XFER_END;
-
-                spin_lock_irqsave(&ebu_lock, flags);
-                ret = falcon_sflash_xfer(m->spi, t, spi_flags);
-                spin_unlock_irqrestore(&ebu_lock, flags);
-
-                if (ret)
-                        break;
-
-                m->actual_length += t->len;
-
-                WARN_ON(t->delay_usecs || t->cs_change);
-                spi_flags = 0;
-        }
-
-        m->status = ret;
-        m->complete(m->context);
-
-        return 0;
-}
-
-static int falcon_sflash_probe(struct platform_device *pdev)
-{
-        struct falcon_sflash *priv;
-        struct spi_master *master;
-        int ret;
-
-        if (ltq_boot_select() != BS_SPI) {
-                dev_err(&pdev->dev, "invalid bootstrap options\n");
-                return -ENODEV;
-        }
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*priv));
-        if (!master)
-                return -ENOMEM;
-
-        priv = spi_master_get_devdata(master);
-        priv->master = master;
-
-        master->mode_bits = SPI_MODE_3;
-        master->num_chipselect = 1;
-        master->bus_num = -1;
-        master->setup = falcon_sflash_setup;
-        master->prepare_transfer_hardware = falcon_sflash_prepare_xfer;
-        master->transfer_one_message = falcon_sflash_xfer_one;
-        master->unprepare_transfer_hardware = falcon_sflash_unprepare_xfer;
-        master->dev.of_node = pdev->dev.of_node;
-
-        platform_set_drvdata(pdev, priv);
-
-        ret = spi_register_master(master);
-        if (ret)
-                spi_master_put(master);
-        return ret;
-}
-
-static int falcon_sflash_remove(struct platform_device *pdev)
-{
-        struct falcon_sflash *priv = platform_get_drvdata(pdev);
-
-        spi_unregister_master(priv->master);
-
-        return 0;
-}
-
-static const struct of_device_id falcon_sflash_match[] = {
-        { .compatible = "lantiq,sflash-falcon" },
-        {},
-};
-MODULE_DEVICE_TABLE(of, falcon_sflash_match);
-
-static struct platform_driver falcon_sflash_driver = {
-        .probe  = falcon_sflash_probe,
-        .remove = falcon_sflash_remove,
-        .driver = {
-                .name   = DRV_NAME,
-                .owner  = THIS_MODULE,
-                .of_match_table = falcon_sflash_match,
-        }
-};
-
-module_platform_driver(falcon_sflash_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Lantiq Falcon SPI/SFLASH controller driver");
diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
index 24610ca8955..54e499d5f92 100644
--- a/drivers/spi/spi-fsl-espi.c
+++ b/drivers/spi/spi-fsl-espi.c
@@ -17,6 +17,7 @@
 #include <linux/mm.h>
 #include <linux/of.h>
 #include <linux/of_platform.h>
+#include <linux/of_spi.h>
 #include <linux/interrupt.h>
 #include <linux/err.h>
 #include <sysdev/fsl_soc.h>
@@ -179,20 +180,18 @@ static int fsl_espi_setup_transfer(struct spi_device *spi,
 
         if ((mpc8xxx_spi->spibrg / hz) > 64) {
                 cs->hw_mode |= CSMODE_DIV16;
-                pm = DIV_ROUND_UP(mpc8xxx_spi->spibrg, hz * 16 * 4);
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 64) + 1;
 
-                WARN_ONCE(pm > 33, "%s: Requested speed is too low: %d Hz. "
+                WARN_ONCE(pm > 16, "%s: Requested speed is too low: %d Hz. "
                           "Will use %d Hz instead.\n", dev_name(&spi->dev),
-                                hz, mpc8xxx_spi->spibrg / (4 * 16 * (32 + 1)));
-                if (pm > 33)
-                        pm = 33;
+                          hz, mpc8xxx_spi->spibrg / 1024);
+                if (pm > 16)
+                        pm = 16;
         } else {
-                pm = DIV_ROUND_UP(mpc8xxx_spi->spibrg, hz * 4);
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 4) + 1;
         }
         if (pm)
                 pm--;
-        if (pm < 2)
-                pm = 2;
 
         cs->hw_mode |= CSMODE_PM(pm);
 
@@ -587,7 +586,7 @@ static void fsl_espi_remove(struct mpc8xxx_spi *mspi)
         iounmap(mspi->reg_base);
 }
 
-static struct spi_master * fsl_espi_probe(struct device *dev,
+static struct spi_master * __devinit fsl_espi_probe(struct device *dev,
                 struct resource *mem, unsigned int irq)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
@@ -686,7 +685,7 @@ static int of_fsl_espi_get_chipselects(struct device *dev)
         return 0;
 }
 
-static int of_fsl_espi_probe(struct platform_device *ofdev)
+static int __devinit of_fsl_espi_probe(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
@@ -725,7 +724,7 @@ err:
         return ret;
 }
 
-static int of_fsl_espi_remove(struct platform_device *dev)
+static int __devexit of_fsl_espi_remove(struct platform_device *dev)
 {
         return mpc8xxx_spi_remove(&dev->dev);
 }
@@ -743,9 +742,20 @@ static struct platform_driver fsl_espi_driver = {
                 .of_match_table = of_fsl_espi_match,
         },
         .probe          = of_fsl_espi_probe,
-        .remove         = of_fsl_espi_remove,
+        .remove         = __devexit_p(of_fsl_espi_remove),
 };
-module_platform_driver(fsl_espi_driver);
+
+static int __init fsl_espi_init(void)
+{
+        return platform_driver_register(&fsl_espi_driver);
+}
+module_init(fsl_espi_init);
+
+static void __exit fsl_espi_exit(void)
+{
+        platform_driver_unregister(&fsl_espi_driver);
+}
+module_exit(fsl_espi_exit);
 
 MODULE_AUTHOR("Mingkai Hu");
 MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");
diff --git a/drivers/spi/spi-fsl-lib.c b/drivers/spi/spi-fsl-lib.c
index 8ade675a04f..2674fad7f68 100644
--- a/drivers/spi/spi-fsl-lib.c
+++ b/drivers/spi/spi-fsl-lib.c
@@ -22,7 +22,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/mm.h>
 #include <linux/of_platform.h>
-#include <linux/spi/spi.h>
+#include <linux/of_spi.h>
 #include <sysdev/fsl_soc.h>
 
 #include "spi-fsl-lib.h"
@@ -169,7 +169,7 @@ err:
         return ret;
 }
 
-int mpc8xxx_spi_remove(struct device *dev)
+int __devexit mpc8xxx_spi_remove(struct device *dev)
 {
         struct mpc8xxx_spi *mpc8xxx_spi;
         struct spi_master *master;
@@ -189,7 +189,7 @@ int mpc8xxx_spi_remove(struct device *dev)
         return 0;
 }
 
-int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
+int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c
index 1a7f6359d99..24cacff5778 100644
--- a/drivers/spi/spi-fsl-spi.c
+++ b/drivers/spi/spi-fsl-spi.c
@@ -139,12 +139,10 @@ static void fsl_spi_change_mode(struct spi_device *spi)
 static void fsl_spi_chipselect(struct spi_device *spi, int value)
 {
         struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
-        struct fsl_spi_platform_data *pdata;
+        struct fsl_spi_platform_data *pdata = spi->dev.parent->platform_data;
         bool pol = spi->mode & SPI_CS_HIGH;
         struct spi_mpc8xxx_cs   *cs = spi->controller_state;
 
-        pdata = spi->dev.parent->parent->platform_data;
-
         if (value == BITBANG_CS_INACTIVE) {
                 if (pdata->cs_control)
                         pdata->cs_control(spi, !pol);
@@ -843,7 +841,7 @@ static void fsl_spi_remove(struct mpc8xxx_spi *mspi)
         fsl_spi_cpm_free(mspi);
 }
 
-static struct spi_master * fsl_spi_probe(struct device *dev,
+static struct spi_master * __devinit fsl_spi_probe(struct device *dev,
                 struct resource *mem, unsigned int irq)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
@@ -933,7 +931,7 @@ err:
 
 static void fsl_spi_cs_control(struct spi_device *spi, bool on)
 {
-        struct device *dev = spi->dev.parent->parent;
+        struct device *dev = spi->dev.parent;
         struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(dev->platform_data);
         u16 cs = spi->chip_select;
         int gpio = pinfo->gpios[cs];
@@ -1041,7 +1039,7 @@ static int of_fsl_spi_free_chipselects(struct device *dev)
         return 0;
 }
 
-static int of_fsl_spi_probe(struct platform_device *ofdev)
+static int __devinit of_fsl_spi_probe(struct platform_device *ofdev)
 {
         struct device *dev = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
@@ -1081,7 +1079,7 @@ err:
         return ret;
 }
 
-static int of_fsl_spi_remove(struct platform_device *ofdev)
+static int __devexit of_fsl_spi_remove(struct platform_device *ofdev)
 {
         int ret;
 
@@ -1105,7 +1103,7 @@ static struct platform_driver of_fsl_spi_driver = {
                 .of_match_table = of_fsl_spi_match,
         },
         .probe          = of_fsl_spi_probe,
-        .remove         = of_fsl_spi_remove,
+        .remove         = __devexit_p(of_fsl_spi_remove),
 };
 
 #ifdef CONFIG_MPC832x_RDB
@@ -1116,7 +1114,7 @@ static struct platform_driver of_fsl_spi_driver = {
  * tree can work with OpenFirmware driver. But for now we support old trees
  * as well.
  */
-static int plat_mpc8xxx_spi_probe(struct platform_device *pdev)
+static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
 {
         struct resource *mem;
         int irq;
@@ -1139,7 +1137,7 @@ static int plat_mpc8xxx_spi_probe(struct platform_device *pdev)
         return 0;
 }
 
-static int plat_mpc8xxx_spi_remove(struct platform_device *pdev)
+static int __devexit plat_mpc8xxx_spi_remove(struct platform_device *pdev)
 {
         return mpc8xxx_spi_remove(&pdev->dev);
 }
@@ -1147,7 +1145,7 @@ static int plat_mpc8xxx_spi_remove(struct platform_device *pdev)
 MODULE_ALIAS("platform:mpc8xxx_spi");
 static struct platform_driver mpc8xxx_spi_driver = {
         .probe = plat_mpc8xxx_spi_probe,
-        .remove = plat_mpc8xxx_spi_remove,
+        .remove = __devexit_p(plat_mpc8xxx_spi_remove),
         .driver = {
                 .name = "mpc8xxx_spi",
                 .owner = THIS_MODULE,
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index c7cf0b7a069..0e88ab74549 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -18,12 +18,9 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/gpio.h>
-#include <linux/of_device.h>
-#include <linux/of_gpio.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
@@ -48,7 +45,6 @@ struct spi_gpio {
         struct spi_bitbang              bitbang;
         struct spi_gpio_platform_data   pdata;
         struct platform_device          *pdev;
-        int                             cs_gpios[0];
 };
 
 /*----------------------------------------------------------------------*/
@@ -92,21 +88,15 @@ struct spi_gpio {
 
 /*----------------------------------------------------------------------*/
 
-static inline struct spi_gpio * __pure
-spi_to_spi_gpio(const struct spi_device *spi)
+static inline const struct spi_gpio_platform_data * __pure
+spi_to_pdata(const struct spi_device *spi)
 {
         const struct spi_bitbang        *bang;
-        struct spi_gpio                 *spi_gpio;
+        const struct spi_gpio           *spi_gpio;
 
         bang = spi_master_get_devdata(spi->master);
         spi_gpio = container_of(bang, struct spi_gpio, bitbang);
-        return spi_gpio;
-}
-
-static inline struct spi_gpio_platform_data * __pure
-spi_to_pdata(const struct spi_device *spi)
-{
-        return &spi_to_spi_gpio(spi)->pdata;
+        return &spi_gpio->pdata;
 }
 
 /* this is #defined to avoid unused-variable warnings when inlining */
@@ -219,8 +209,7 @@ static u32 spi_gpio_spec_txrx_word_mode3(struct spi_device *spi,
 
 static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
 {
-        struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
-        unsigned int cs = spi_gpio->cs_gpios[spi->chip_select];
+        unsigned long cs = (unsigned long) spi->controller_data;
 
         /* set initial clock polarity */
         if (is_active)
@@ -234,42 +223,22 @@ static void spi_gpio_chipselect(struct spi_device *spi, int is_active)
 
 static int spi_gpio_setup(struct spi_device *spi)
 {
-        unsigned int            cs;
-        int                     status = 0;
-        struct spi_gpio         *spi_gpio = spi_to_spi_gpio(spi);
-        struct device_node      *np = spi->master->dev.of_node;
+        unsigned long   cs = (unsigned long) spi->controller_data;
+        int             status = 0;
 
         if (spi->bits_per_word > 32)
                 return -EINVAL;
 
-        if (np) {
-                /*
-                 * In DT environments, the CS GPIOs have already been
-                 * initialized from the "cs-gpios" property of the node.
-                 */
-                cs = spi_gpio->cs_gpios[spi->chip_select];
-        } else {
-                /*
-                 * ... otherwise, take it from spi->controller_data
-                 */
-                cs = (unsigned int) spi->controller_data;
-        }
-
         if (!spi->controller_state) {
                 if (cs != SPI_GPIO_NO_CHIPSELECT) {
                         status = gpio_request(cs, dev_name(&spi->dev));
                         if (status)
                                 return status;
-                        status = gpio_direction_output(cs,
-                                        !(spi->mode & SPI_CS_HIGH));
+                        status = gpio_direction_output(cs, spi->mode & SPI_CS_HIGH);
                 }
         }
-        if (!status) {
+        if (!status)
                 status = spi_bitbang_setup(spi);
-                /* in case it was initialized from static board data */
-                spi_gpio->cs_gpios[spi->chip_select] = cs;
-        }
-
         if (status) {
                 if (!spi->controller_state && cs != SPI_GPIO_NO_CHIPSELECT)
                         gpio_free(cs);
@@ -279,15 +248,14 @@ static int spi_gpio_setup(struct spi_device *spi)
 
 static void spi_gpio_cleanup(struct spi_device *spi)
 {
-        struct spi_gpio *spi_gpio = spi_to_spi_gpio(spi);
-        unsigned int cs = spi_gpio->cs_gpios[spi->chip_select];
+        unsigned long   cs = (unsigned long) spi->controller_data;
 
         if (cs != SPI_GPIO_NO_CHIPSELECT)
                 gpio_free(cs);
         spi_bitbang_cleanup(spi);
 }
 
-static int spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
+static int __init spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
 {
         int value;
 
@@ -301,8 +269,9 @@ static int spi_gpio_alloc(unsigned pin, const char *label, bool is_in)
         return value;
 }
 
-static int spi_gpio_request(struct spi_gpio_platform_data *pdata,
-                            const char *label, u16 *res_flags)
+static int __init
+spi_gpio_request(struct spi_gpio_platform_data *pdata, const char *label,
+        u16 *res_flags)
 {
         int value;
 
@@ -342,69 +311,13 @@ done:
         return value;
 }
 
-#ifdef CONFIG_OF
-static struct of_device_id spi_gpio_dt_ids[] = {
-        { .compatible = "spi-gpio" },
-        {}
-};
-MODULE_DEVICE_TABLE(of, spi_gpio_dt_ids);
-
-static int spi_gpio_probe_dt(struct platform_device *pdev)
-{
-        int ret;
-        u32 tmp;
-        struct spi_gpio_platform_data   *pdata;
-        struct device_node *np = pdev->dev.of_node;
-        const struct of_device_id *of_id =
-                        of_match_device(spi_gpio_dt_ids, &pdev->dev);
-
-        if (!of_id)
-                return 0;
-
-        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata)
-                return -ENOMEM;
-
-        pdata->sck = of_get_named_gpio(np, "gpio-sck", 0);
-        pdata->miso = of_get_named_gpio(np, "gpio-miso", 0);
-        pdata->mosi = of_get_named_gpio(np, "gpio-mosi", 0);
-
-        ret = of_property_read_u32(np, "num-chipselects", &tmp);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "num-chipselects property not found\n");
-                goto error_free;
-        }
-
-        pdata->num_chipselect = tmp;
-        pdev->dev.platform_data = pdata;
-
-        return 1;
-
-error_free:
-        devm_kfree(&pdev->dev, pdata);
-        return ret;
-}
-#else
-static inline int spi_gpio_probe_dt(struct platform_device *pdev)
-{
-        return 0;
-}
-#endif
-
-static int spi_gpio_probe(struct platform_device *pdev)
+static int __init spi_gpio_probe(struct platform_device *pdev)
 {
         int                             status;
         struct spi_master               *master;
         struct spi_gpio                 *spi_gpio;
         struct spi_gpio_platform_data   *pdata;
         u16 master_flags = 0;
-        bool use_of = 0;
-
-        status = spi_gpio_probe_dt(pdev);
-        if (status < 0)
-                return status;
-        if (status > 0)
-                use_of = 1;
 
         pdata = pdev->dev.platform_data;
 #ifdef GENERIC_BITBANG
@@ -416,8 +329,7 @@ static int spi_gpio_probe(struct platform_device *pdev)
         if (status < 0)
                 return status;
 
-        master = spi_alloc_master(&pdev->dev, sizeof(*spi_gpio) +
-                                        (sizeof(int) * SPI_N_CHIPSEL));
+        master = spi_alloc_master(&pdev->dev, sizeof *spi_gpio);
         if (!master) {
                 status = -ENOMEM;
                 goto gpio_free;
@@ -434,23 +346,6 @@ static int spi_gpio_probe(struct platform_device *pdev)
         master->num_chipselect = SPI_N_CHIPSEL;
         master->setup = spi_gpio_setup;
         master->cleanup = spi_gpio_cleanup;
-#ifdef CONFIG_OF
-        master->dev.of_node = pdev->dev.of_node;
-
-        if (use_of) {
-                int i;
-                struct device_node *np = pdev->dev.of_node;
-
-                /*
-                 * In DT environments, take the CS GPIO from the "cs-gpios"
-                 * property of the node.
-                 */
-
-                for (i = 0; i < SPI_N_CHIPSEL; i++)
-                        spi_gpio->cs_gpios[i] =
-                                of_get_named_gpio(np, "cs-gpios", i);
-        }
-#endif
 
         spi_gpio->bitbang.master = spi_master_get(master);
         spi_gpio->bitbang.chipselect = spi_gpio_chipselect;
@@ -484,7 +379,7 @@ gpio_free:
         return status;
 }
 
-static int spi_gpio_remove(struct platform_device *pdev)
+static int __exit spi_gpio_remove(struct platform_device *pdev)
 {
         struct spi_gpio                 *spi_gpio;
         struct spi_gpio_platform_data   *pdata;
@@ -511,15 +406,23 @@ static int spi_gpio_remove(struct platform_device *pdev)
 MODULE_ALIAS("platform:" DRIVER_NAME);
 
 static struct platform_driver spi_gpio_driver = {
-        .driver = {
-                .name   = DRIVER_NAME,
-                .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(spi_gpio_dt_ids),
-        },
-        .probe          = spi_gpio_probe,
-        .remove         = spi_gpio_remove,
+        .driver.name    = DRIVER_NAME,
+        .driver.owner   = THIS_MODULE,
+        .remove         = __exit_p(spi_gpio_remove),
 };
-module_platform_driver(spi_gpio_driver);
+
+static int __init spi_gpio_init(void)
+{
+        return platform_driver_probe(&spi_gpio_driver, spi_gpio_probe);
+}
+module_init(spi_gpio_init);
+
+static void __exit spi_gpio_exit(void)
+{
+        platform_driver_unregister(&spi_gpio_driver);
+}
+module_exit(spi_gpio_exit);
+
 
 MODULE_DESCRIPTION("SPI master driver using generic bitbanged GPIO ");
 MODULE_AUTHOR("David Brownell");
diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c
index 904913290aa..fa594d604ac 100644
--- a/drivers/spi/spi-imx.c
+++ b/drivers/spi/spi-imx.c
@@ -37,9 +37,8 @@
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
-#include <linux/pinctrl/consumer.h>
 
-#include <linux/platform_data/spi-imx.h>
+#include <mach/spi.h>
 
 #define DRIVER_NAME "spi_imx"
 
@@ -84,10 +83,9 @@ struct spi_imx_data {
         struct spi_bitbang bitbang;
 
         struct completion xfer_done;
-        void __iomem *base;
+        void *base;
         int irq;
-        struct clk *clk_per;
-        struct clk *clk_ipg;
+        struct clk *clk;
         unsigned long spi_clk;
 
         unsigned int count;
@@ -97,7 +95,7 @@ struct spi_imx_data {
         const void *tx_buf;
         unsigned int txfifo; /* number of words pushed in tx FIFO */
 
-        const struct spi_imx_devtype_data *devtype_data;
+        struct spi_imx_devtype_data *devtype_data;
         int chipselect[0];
 };
 
@@ -197,7 +195,6 @@ static unsigned int spi_imx_clkdiv_2(unsigned int fin,
 #define MX51_ECSPI_CONFIG_SCLKPOL(cs)   (1 << ((cs) +  4))
 #define MX51_ECSPI_CONFIG_SBBCTRL(cs)   (1 << ((cs) +  8))
 #define MX51_ECSPI_CONFIG_SSBPOL(cs)    (1 << ((cs) + 12))
-#define MX51_ECSPI_CONFIG_SCLKCTL(cs)   (1 << ((cs) + 20))
 
 #define MX51_ECSPI_INT          0x10
 #define MX51_ECSPI_INT_TEEN             (1 <<  0)
@@ -288,10 +285,9 @@ static int __maybe_unused mx51_ecspi_config(struct spi_imx_data *spi_imx,
         if (config->mode & SPI_CPHA)
                 cfg |= MX51_ECSPI_CONFIG_SCLKPHA(config->cs);
 
-        if (config->mode & SPI_CPOL) {
+        if (config->mode & SPI_CPOL)
                 cfg |= MX51_ECSPI_CONFIG_SCLKPOL(config->cs);
-                cfg |= MX51_ECSPI_CONFIG_SCLKCTL(config->cs);
-        }
+
         if (config->mode & SPI_CS_HIGH)
                 cfg |= MX51_ECSPI_CONFIG_SSBPOL(config->cs);
 
@@ -628,7 +624,7 @@ static void spi_imx_chipselect(struct spi_device *spi, int is_active)
         int active = is_active != BITBANG_CS_INACTIVE;
         int dev_is_lowactive = !(spi->mode & SPI_CS_HIGH);
 
-        if (!gpio_is_valid(gpio))
+        if (gpio < 0)
                 return;
 
         gpio_set_value(gpio, dev_is_lowactive ^ active);
@@ -690,6 +686,8 @@ static int spi_imx_setupxfer(struct spi_device *spi,
                 config.speed_hz = spi->max_speed_hz;
         if (!config.bpw)
                 config.bpw = spi->bits_per_word;
+        if (!config.speed_hz)
+                config.speed_hz = spi->max_speed_hz;
 
         /* Initialize the functions for transfer */
         if (config.bpw <= 8) {
@@ -738,7 +736,7 @@ static int spi_imx_setup(struct spi_device *spi)
         dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n", __func__,
                  spi->mode, spi->bits_per_word, spi->max_speed_hz);
 
-        if (gpio_is_valid(gpio))
+        if (gpio >= 0)
                 gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1);
 
         spi_imx_chipselect(spi, BITBANG_CS_INACTIVE);
@@ -750,7 +748,7 @@ static void spi_imx_cleanup(struct spi_device *spi)
 {
 }
 
-static int spi_imx_probe(struct platform_device *pdev)
+static int __devinit spi_imx_probe(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
         const struct of_device_id *of_id =
@@ -760,7 +758,6 @@ static int spi_imx_probe(struct platform_device *pdev)
         struct spi_master *master;
         struct spi_imx_data *spi_imx;
         struct resource *res;
-        struct pinctrl *pinctrl;
         int i, ret, num_cs;
 
         if (!np && !mxc_platform_info) {
@@ -769,12 +766,8 @@ static int spi_imx_probe(struct platform_device *pdev)
         }
 
         ret = of_property_read_u32(np, "fsl,spi-num-chipselects", &num_cs);
-        if (ret < 0) {
-                if (mxc_platform_info)
-                        num_cs = mxc_platform_info->num_chipselect;
-                else
-                        return ret;
-        }
+        if (ret < 0)
+                num_cs = mxc_platform_info->num_chipselect;
 
         master = spi_alloc_master(&pdev->dev,
                         sizeof(struct spi_imx_data) + sizeof(int) * num_cs);
@@ -791,17 +784,22 @@ static int spi_imx_probe(struct platform_device *pdev)
 
         for (i = 0; i < master->num_chipselect; i++) {
                 int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
-                if (!gpio_is_valid(cs_gpio) && mxc_platform_info)
+                if (cs_gpio < 0)
                         cs_gpio = mxc_platform_info->chipselect[i];
 
                 spi_imx->chipselect[i] = cs_gpio;
-                if (!gpio_is_valid(cs_gpio))
+                if (cs_gpio < 0)
                         continue;
 
                 ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME);
                 if (ret) {
+                        while (i > 0) {
+                                i--;
+                                if (spi_imx->chipselect[i] >= 0)
+                                        gpio_free(spi_imx->chipselect[i]);
+                        }
                         dev_err(&pdev->dev, "can't get cs gpios\n");
-                        goto out_gpio_free;
+                        goto out_master_put;
                 }
         }
 
@@ -848,28 +846,15 @@ static int spi_imx_probe(struct platform_device *pdev)
                 goto out_iounmap;
         }
 
-        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(pinctrl)) {
-                ret = PTR_ERR(pinctrl);
-                goto out_free_irq;
-        }
-
-        spi_imx->clk_ipg = devm_clk_get(&pdev->dev, "ipg");
-        if (IS_ERR(spi_imx->clk_ipg)) {
-                ret = PTR_ERR(spi_imx->clk_ipg);
-                goto out_free_irq;
-        }
-
-        spi_imx->clk_per = devm_clk_get(&pdev->dev, "per");
-        if (IS_ERR(spi_imx->clk_per)) {
-                ret = PTR_ERR(spi_imx->clk_per);
+        spi_imx->clk = clk_get(&pdev->dev, NULL);
+        if (IS_ERR(spi_imx->clk)) {
+                dev_err(&pdev->dev, "unable to get clock\n");
+                ret = PTR_ERR(spi_imx->clk);
                 goto out_free_irq;
         }
 
-        clk_prepare_enable(spi_imx->clk_per);
-        clk_prepare_enable(spi_imx->clk_ipg);
-
-        spi_imx->spi_clk = clk_get_rate(spi_imx->clk_per);
+        clk_enable(spi_imx->clk);
+        spi_imx->spi_clk = clk_get_rate(spi_imx->clk);
 
         spi_imx->devtype_data->reset(spi_imx);
 
@@ -887,8 +872,8 @@ static int spi_imx_probe(struct platform_device *pdev)
         return ret;
 
 out_clk_put:
-        clk_disable_unprepare(spi_imx->clk_per);
-        clk_disable_unprepare(spi_imx->clk_ipg);
+        clk_disable(spi_imx->clk);
+        clk_put(spi_imx->clk);
 out_free_irq:
         free_irq(spi_imx->irq, spi_imx);
 out_iounmap:
@@ -896,17 +881,17 @@ out_iounmap:
 out_release_mem:
         release_mem_region(res->start, resource_size(res));
 out_gpio_free:
-        while (--i >= 0) {
-                if (gpio_is_valid(spi_imx->chipselect[i]))
+        for (i = 0; i < master->num_chipselect; i++)
+                if (spi_imx->chipselect[i] >= 0)
                         gpio_free(spi_imx->chipselect[i]);
-        }
+out_master_put:
         spi_master_put(master);
         kfree(master);
         platform_set_drvdata(pdev, NULL);
         return ret;
 }
 
-static int spi_imx_remove(struct platform_device *pdev)
+static int __devexit spi_imx_remove(struct platform_device *pdev)
 {
         struct spi_master *master = platform_get_drvdata(pdev);
         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -916,13 +901,13 @@ static int spi_imx_remove(struct platform_device *pdev)
         spi_bitbang_stop(&spi_imx->bitbang);
 
         writel(0, spi_imx->base + MXC_CSPICTRL);
-        clk_disable_unprepare(spi_imx->clk_per);
-        clk_disable_unprepare(spi_imx->clk_ipg);
+        clk_disable(spi_imx->clk);
+        clk_put(spi_imx->clk);
         free_irq(spi_imx->irq, spi_imx);
         iounmap(spi_imx->base);
 
         for (i = 0; i < master->num_chipselect; i++)
-                if (gpio_is_valid(spi_imx->chipselect[i]))
+                if (spi_imx->chipselect[i] >= 0)
                         gpio_free(spi_imx->chipselect[i]);
 
         spi_master_put(master);
@@ -942,9 +927,21 @@ static struct platform_driver spi_imx_driver = {
                    },
         .id_table = spi_imx_devtype,
         .probe = spi_imx_probe,
-        .remove = spi_imx_remove,
+        .remove = __devexit_p(spi_imx_remove),
 };
-module_platform_driver(spi_imx_driver);
+
+static int __init spi_imx_init(void)
+{
+        return platform_driver_register(&spi_imx_driver);
+}
+
+static void __exit spi_imx_exit(void)
+{
+        platform_driver_unregister(&spi_imx_driver);
+}
+
+module_init(spi_imx_init);
+module_exit(spi_imx_exit);
 
 MODULE_DESCRIPTION("SPI Master Controller driver");
 MODULE_AUTHOR("Sascha Hauer, Pengutronix");
diff --git a/drivers/spi/spi-lm70llp.c b/drivers/spi/spi-lm70llp.c
index 0759b5db988..933eb9d9ddd 100644
--- a/drivers/spi/spi-lm70llp.c
+++ b/drivers/spi/spi-lm70llp.c
@@ -219,6 +219,9 @@ static void spi_lm70llp_attach(struct parport *p)
         }
         pp = spi_master_get_devdata(master);
 
+        master->bus_num = -1;   /* dynamic alloc of a bus number */
+        master->num_chipselect = 1;
+
         /*
          * SPI and bitbang hookup.
          */
diff --git a/drivers/spi/spi-mpc512x-psc.c b/drivers/spi/spi-mpc512x-psc.c
index cb3a3106bd4..6a5b4238fb6 100644
--- a/drivers/spi/spi-mpc512x-psc.c
+++ b/drivers/spi/spi-mpc512x-psc.c
@@ -406,7 +406,7 @@ static irqreturn_t mpc512x_psc_spi_isr(int irq, void *dev_id)
 }
 
 /* bus_num is used only for the case dev->platform_data == NULL */
-static int mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
+static int __devinit mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
                                               u32 size, unsigned int irq,
                                               s16 bus_num)
 {
@@ -492,9 +492,9 @@ free_master:
         return ret;
 }
 
-static int mpc512x_psc_spi_do_remove(struct device *dev)
+static int __devexit mpc512x_psc_spi_do_remove(struct device *dev)
 {
-        struct spi_master *master = spi_master_get(dev_get_drvdata(dev));
+        struct spi_master *master = dev_get_drvdata(dev);
         struct mpc512x_psc_spi *mps = spi_master_get_devdata(master);
 
         flush_workqueue(mps->workqueue);
@@ -503,12 +503,11 @@ static int mpc512x_psc_spi_do_remove(struct device *dev)
         free_irq(mps->irq, mps);
         if (mps->psc)
                 iounmap(mps->psc);
-        spi_master_put(master);
 
         return 0;
 }
 
-static int mpc512x_psc_spi_of_probe(struct platform_device *op)
+static int __devinit mpc512x_psc_spi_of_probe(struct platform_device *op)
 {
         const u32 *regaddr_p;
         u64 regaddr64, size64;
@@ -539,7 +538,7 @@ static int mpc512x_psc_spi_of_probe(struct platform_device *op)
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
 }
 
-static int mpc512x_psc_spi_of_remove(struct platform_device *op)
+static int __devexit mpc512x_psc_spi_of_remove(struct platform_device *op)
 {
         return mpc512x_psc_spi_do_remove(&op->dev);
 }
@@ -553,14 +552,25 @@ MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match);
 
 static struct platform_driver mpc512x_psc_spi_of_driver = {
         .probe = mpc512x_psc_spi_of_probe,
-        .remove = mpc512x_psc_spi_of_remove,
+        .remove = __devexit_p(mpc512x_psc_spi_of_remove),
         .driver = {
                 .name = "mpc512x-psc-spi",
                 .owner = THIS_MODULE,
                 .of_match_table = mpc512x_psc_spi_of_match,
         },
 };
-module_platform_driver(mpc512x_psc_spi_of_driver);
+
+static int __init mpc512x_psc_spi_init(void)
+{
+        return platform_driver_register(&mpc512x_psc_spi_of_driver);
+}
+module_init(mpc512x_psc_spi_init);
+
+static void __exit mpc512x_psc_spi_exit(void)
+{
+        platform_driver_unregister(&mpc512x_psc_spi_of_driver);
+}
+module_exit(mpc512x_psc_spi_exit);
 
 MODULE_AUTHOR("John Rigby");
 MODULE_DESCRIPTION("MPC512x PSC SPI Driver");
diff --git a/drivers/spi/spi-mpc52xx-psc.c b/drivers/spi/spi-mpc52xx-psc.c
index 291120b37db..e30baf0852a 100644
--- a/drivers/spi/spi-mpc52xx-psc.c
+++ b/drivers/spi/spi-mpc52xx-psc.c
@@ -363,7 +363,7 @@ static irqreturn_t mpc52xx_psc_spi_isr(int irq, void *dev_id)
 }
 
 /* bus_num is used only for the case dev->platform_data == NULL */
-static int mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
+static int __devinit mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
                                 u32 size, unsigned int irq, s16 bus_num)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
@@ -450,7 +450,7 @@ free_master:
         return ret;
 }
 
-static int mpc52xx_psc_spi_of_probe(struct platform_device *op)
+static int __devinit mpc52xx_psc_spi_of_probe(struct platform_device *op)
 {
         const u32 *regaddr_p;
         u64 regaddr64, size64;
@@ -479,9 +479,9 @@ static int mpc52xx_psc_spi_of_probe(struct platform_device *op)
                                 irq_of_parse_and_map(op->dev.of_node, 0), id);
 }
 
-static int mpc52xx_psc_spi_of_remove(struct platform_device *op)
+static int __devexit mpc52xx_psc_spi_of_remove(struct platform_device *op)
 {
-        struct spi_master *master = spi_master_get(dev_get_drvdata(&op->dev));
+        struct spi_master *master = dev_get_drvdata(&op->dev);
         struct mpc52xx_psc_spi *mps = spi_master_get_devdata(master);
 
         flush_workqueue(mps->workqueue);
@@ -490,7 +490,6 @@ static int mpc52xx_psc_spi_of_remove(struct platform_device *op)
         free_irq(mps->irq, mps);
         if (mps->psc)
                 iounmap(mps->psc);
-        spi_master_put(master);
 
         return 0;
 }
@@ -505,14 +504,25 @@ MODULE_DEVICE_TABLE(of, mpc52xx_psc_spi_of_match);
 
 static struct platform_driver mpc52xx_psc_spi_of_driver = {
         .probe = mpc52xx_psc_spi_of_probe,
-        .remove = mpc52xx_psc_spi_of_remove,
+        .remove = __devexit_p(mpc52xx_psc_spi_of_remove),
         .driver = {
                 .name = "mpc52xx-psc-spi",
                 .owner = THIS_MODULE,
                 .of_match_table = mpc52xx_psc_spi_of_match,
         },
 };
-module_platform_driver(mpc52xx_psc_spi_of_driver);
+
+static int __init mpc52xx_psc_spi_init(void)
+{
+        return platform_driver_register(&mpc52xx_psc_spi_of_driver);
+}
+module_init(mpc52xx_psc_spi_init);
+
+static void __exit mpc52xx_psc_spi_exit(void)
+{
+        platform_driver_unregister(&mpc52xx_psc_spi_of_driver);
+}
+module_exit(mpc52xx_psc_spi_exit);
 
 MODULE_AUTHOR("Dragos Carp");
 MODULE_DESCRIPTION("MPC52xx PSC SPI Driver");
diff --git a/drivers/spi/spi-mpc52xx.c b/drivers/spi/spi-mpc52xx.c
index 29f77056eed..015a974bed7 100644
--- a/drivers/spi/spi-mpc52xx.c
+++ b/drivers/spi/spi-mpc52xx.c
@@ -390,7 +390,7 @@ static int mpc52xx_spi_transfer(struct spi_device *spi, struct spi_message *m)
 /*
  * OF Platform Bus Binding
  */
-static int mpc52xx_spi_probe(struct platform_device *op)
+static int __devinit mpc52xx_spi_probe(struct platform_device *op)
 {
         struct spi_master *master;
         struct mpc52xx_spi *ms;
@@ -433,6 +433,7 @@ static int mpc52xx_spi_probe(struct platform_device *op)
                 goto err_alloc;
         }
 
+        master->bus_num = -1;
         master->setup = mpc52xx_spi_setup;
         master->transfer = mpc52xx_spi_transfer;
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
@@ -454,7 +455,7 @@ static int mpc52xx_spi_probe(struct platform_device *op)
                                 GFP_KERNEL);
                 if (!ms->gpio_cs) {
                         rc = -ENOMEM;
-                        goto err_alloc_gpio;
+                        goto err_alloc;
                 }
 
                 for (i = 0; i < ms->gpio_cs_count; i++) {
@@ -478,6 +479,8 @@ static int mpc52xx_spi_probe(struct platform_device *op)
                         gpio_direction_output(gpio_cs, 1);
                         ms->gpio_cs[i] = gpio_cs;
                 }
+        } else {
+                master->num_chipselect = 1;
         }
 
         spin_lock_init(&ms->lock);
@@ -514,22 +517,21 @@ static int mpc52xx_spi_probe(struct platform_device *op)
 
  err_register:
         dev_err(&ms->master->dev, "initialization failed\n");
+        spi_master_put(master);
  err_gpio:
         while (i-- > 0)
                 gpio_free(ms->gpio_cs[i]);
 
         kfree(ms->gpio_cs);
- err_alloc_gpio:
-        spi_master_put(master);
  err_alloc:
  err_init:
         iounmap(regs);
         return rc;
 }
 
-static int mpc52xx_spi_remove(struct platform_device *op)
+static int __devexit mpc52xx_spi_remove(struct platform_device *op)
 {
-        struct spi_master *master = spi_master_get(dev_get_drvdata(&op->dev));
+        struct spi_master *master = dev_get_drvdata(&op->dev);
         struct mpc52xx_spi *ms = spi_master_get_devdata(master);
         int i;
 
@@ -541,13 +543,13 @@ static int mpc52xx_spi_remove(struct platform_device *op)
 
         kfree(ms->gpio_cs);
         spi_unregister_master(master);
-        iounmap(ms->regs);
         spi_master_put(master);
+        iounmap(ms->regs);
 
         return 0;
 }
 
-static const struct of_device_id mpc52xx_spi_match[] = {
+static const struct of_device_id mpc52xx_spi_match[] __devinitconst = {
         { .compatible = "fsl,mpc5200-spi", },
         {}
 };
@@ -560,6 +562,18 @@ static struct platform_driver mpc52xx_spi_of_driver = {
                 .of_match_table = mpc52xx_spi_match,
         },
         .probe = mpc52xx_spi_probe,
-        .remove = mpc52xx_spi_remove,
+        .remove = __devexit_p(mpc52xx_spi_remove),
 };
-module_platform_driver(mpc52xx_spi_of_driver);
+
+static int __init mpc52xx_spi_init(void)
+{
+        return platform_driver_register(&mpc52xx_spi_of_driver);
+}
+module_init(mpc52xx_spi_init);
+
+static void __exit mpc52xx_spi_exit(void)
+{
+        platform_driver_unregister(&mpc52xx_spi_of_driver);
+}
+module_exit(mpc52xx_spi_exit);
+
diff --git a/drivers/spi/spi-mxs.c b/drivers/spi/spi-mxs.c
deleted file mode 100644
index a3ede249d05..00000000000
--- a/drivers/spi/spi-mxs.c
+++ /dev/null
@@ -1,675 +0,0 @@
-/*
- * Freescale MXS SPI master driver
- *
- * Copyright 2012 DENX Software Engineering, GmbH.
- * Copyright 2012 Freescale Semiconductor, Inc.
- * Copyright 2008 Embedded Alley Solutions, Inc All Rights Reserved.
- *
- * Rework and transition to new API by:
- * Marek Vasut <marex@denx.de>
- *
- * Based on previous attempt by:
- * Fabio Estevam <fabio.estevam@freescale.com>
- *
- * Based on code from U-Boot bootloader by:
- * Marek Vasut <marex@denx.de>
- *
- * Based on spi-stmp.c, which is:
- * Author: Dmitry Pervushin <dimka@embeddedalley.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/ioport.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/of_gpio.h>
-#include <linux/platform_device.h>
-#include <linux/delay.h>
-#include <linux/interrupt.h>
-#include <linux/dma-mapping.h>
-#include <linux/dmaengine.h>
-#include <linux/highmem.h>
-#include <linux/clk.h>
-#include <linux/err.h>
-#include <linux/completion.h>
-#include <linux/gpio.h>
-#include <linux/regulator/consumer.h>
-#include <linux/module.h>
-#include <linux/pinctrl/consumer.h>
-#include <linux/stmp_device.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/mxs-spi.h>
-
-#define DRIVER_NAME             "mxs-spi"
-
-/* Use 10S timeout for very long transfers, it should suffice. */
-#define SSP_TIMEOUT             10000
-
-#define SG_MAXLEN               0xff00
-
-struct mxs_spi {
-        struct mxs_ssp          ssp;
-        struct completion       c;
-};
-
-static int mxs_spi_setup_transfer(struct spi_device *dev,
-                                struct spi_transfer *t)
-{
-        struct mxs_spi *spi = spi_master_get_devdata(dev->master);
-        struct mxs_ssp *ssp = &spi->ssp;
-        uint8_t bits_per_word;
-        uint32_t hz = 0;
-
-        bits_per_word = dev->bits_per_word;
-        if (t && t->bits_per_word)
-                bits_per_word = t->bits_per_word;
-
-        if (bits_per_word != 8) {
-                dev_err(&dev->dev, "%s, unsupported bits_per_word=%d\n",
-                                        __func__, bits_per_word);
-                return -EINVAL;
-        }
-
-        hz = dev->max_speed_hz;
-        if (t && t->speed_hz)
-                hz = min(hz, t->speed_hz);
-        if (hz == 0) {
-                dev_err(&dev->dev, "Cannot continue with zero clock\n");
-                return -EINVAL;
-        }
-
-        mxs_ssp_set_clk_rate(ssp, hz);
-
-        writel(BF_SSP_CTRL1_SSP_MODE(BV_SSP_CTRL1_SSP_MODE__SPI) |
-                     BF_SSP_CTRL1_WORD_LENGTH
-                     (BV_SSP_CTRL1_WORD_LENGTH__EIGHT_BITS) |
-                     ((dev->mode & SPI_CPOL) ? BM_SSP_CTRL1_POLARITY : 0) |
-                     ((dev->mode & SPI_CPHA) ? BM_SSP_CTRL1_PHASE : 0),
-                     ssp->base + HW_SSP_CTRL1(ssp));
-
-        writel(0x0, ssp->base + HW_SSP_CMD0);
-        writel(0x0, ssp->base + HW_SSP_CMD1);
-
-        return 0;
-}
-
-static int mxs_spi_setup(struct spi_device *dev)
-{
-        int err = 0;
-
-        if (!dev->bits_per_word)
-                dev->bits_per_word = 8;
-
-        if (dev->mode & ~(SPI_CPOL | SPI_CPHA))
-                return -EINVAL;
-
-        err = mxs_spi_setup_transfer(dev, NULL);
-        if (err) {
-                dev_err(&dev->dev,
-                        "Failed to setup transfer, error = %d\n", err);
-        }
-
-        return err;
-}
-
-static uint32_t mxs_spi_cs_to_reg(unsigned cs)
-{
-        uint32_t select = 0;
-
-        /*
-         * i.MX28 Datasheet: 17.10.1: HW_SSP_CTRL0
-         *
-         * The bits BM_SSP_CTRL0_WAIT_FOR_CMD and BM_SSP_CTRL0_WAIT_FOR_IRQ
-         * in HW_SSP_CTRL0 register do have multiple usage, please refer to
-         * the datasheet for further details. In SPI mode, they are used to
-         * toggle the chip-select lines (nCS pins).
-         */
-        if (cs & 1)
-                select |= BM_SSP_CTRL0_WAIT_FOR_CMD;
-        if (cs & 2)
-                select |= BM_SSP_CTRL0_WAIT_FOR_IRQ;
-
-        return select;
-}
-
-static void mxs_spi_set_cs(struct mxs_spi *spi, unsigned cs)
-{
-        const uint32_t mask =
-                BM_SSP_CTRL0_WAIT_FOR_CMD | BM_SSP_CTRL0_WAIT_FOR_IRQ;
-        uint32_t select;
-        struct mxs_ssp *ssp = &spi->ssp;
-
-        writel(mask, ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
-        select = mxs_spi_cs_to_reg(cs);
-        writel(select, ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-}
-
-static inline void mxs_spi_enable(struct mxs_spi *spi)
-{
-        struct mxs_ssp *ssp = &spi->ssp;
-
-        writel(BM_SSP_CTRL0_LOCK_CS,
-                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-        writel(BM_SSP_CTRL0_IGNORE_CRC,
-                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
-}
-
-static inline void mxs_spi_disable(struct mxs_spi *spi)
-{
-        struct mxs_ssp *ssp = &spi->ssp;
-
-        writel(BM_SSP_CTRL0_LOCK_CS,
-                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
-        writel(BM_SSP_CTRL0_IGNORE_CRC,
-                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-}
-
-static int mxs_ssp_wait(struct mxs_spi *spi, int offset, int mask, bool set)
-{
-        const unsigned long timeout = jiffies + msecs_to_jiffies(SSP_TIMEOUT);
-        struct mxs_ssp *ssp = &spi->ssp;
-        uint32_t reg;
-
-        do {
-                reg = readl_relaxed(ssp->base + offset);
-
-                if (!set)
-                        reg = ~reg;
-
-                reg &= mask;
-
-                if (reg == mask)
-                        return 0;
-        } while (time_before(jiffies, timeout));
-
-        return -ETIMEDOUT;
-}
-
-static void mxs_ssp_dma_irq_callback(void *param)
-{
-        struct mxs_spi *spi = param;
-        complete(&spi->c);
-}
-
-static irqreturn_t mxs_ssp_irq_handler(int irq, void *dev_id)
-{
-        struct mxs_ssp *ssp = dev_id;
-        dev_err(ssp->dev, "%s[%i] CTRL1=%08x STATUS=%08x\n",
-                __func__, __LINE__,
-                readl(ssp->base + HW_SSP_CTRL1(ssp)),
-                readl(ssp->base + HW_SSP_STATUS(ssp)));
-        return IRQ_HANDLED;
-}
-
-static int mxs_spi_txrx_dma(struct mxs_spi *spi, int cs,
-                            unsigned char *buf, int len,
-                            int *first, int *last, int write)
-{
-        struct mxs_ssp *ssp = &spi->ssp;
-        struct dma_async_tx_descriptor *desc = NULL;
-        const bool vmalloced_buf = is_vmalloc_addr(buf);
-        const int desc_len = vmalloced_buf ? PAGE_SIZE : SG_MAXLEN;
-        const int sgs = DIV_ROUND_UP(len, desc_len);
-        int sg_count;
-        int min, ret;
-        uint32_t ctrl0;
-        struct page *vm_page;
-        void *sg_buf;
-        struct {
-                uint32_t                pio[4];
-                struct scatterlist      sg;
-        } *dma_xfer;
-
-        if (!len)
-                return -EINVAL;
-
-        dma_xfer = kzalloc(sizeof(*dma_xfer) * sgs, GFP_KERNEL);
-        if (!dma_xfer)
-                return -ENOMEM;
-
-        INIT_COMPLETION(spi->c);
-
-        ctrl0 = readl(ssp->base + HW_SSP_CTRL0);
-        ctrl0 |= BM_SSP_CTRL0_DATA_XFER | mxs_spi_cs_to_reg(cs);
-
-        if (*first)
-                ctrl0 |= BM_SSP_CTRL0_LOCK_CS;
-        if (!write)
-                ctrl0 |= BM_SSP_CTRL0_READ;
-
-        /* Queue the DMA data transfer. */
-        for (sg_count = 0; sg_count < sgs; sg_count++) {
-                min = min(len, desc_len);
-
-                /* Prepare the transfer descriptor. */
-                if ((sg_count + 1 == sgs) && *last)
-                        ctrl0 |= BM_SSP_CTRL0_IGNORE_CRC;
-
-                if (ssp->devid == IMX23_SSP)
-                        ctrl0 |= min;
-
-                dma_xfer[sg_count].pio[0] = ctrl0;
-                dma_xfer[sg_count].pio[3] = min;
-
-                if (vmalloced_buf) {
-                        vm_page = vmalloc_to_page(buf);
-                        if (!vm_page) {
-                                ret = -ENOMEM;
-                                goto err_vmalloc;
-                        }
-                        sg_buf = page_address(vm_page) +
-                                ((size_t)buf & ~PAGE_MASK);
-                } else {
-                        sg_buf = buf;
-                }
-
-                sg_init_one(&dma_xfer[sg_count].sg, sg_buf, min);
-                ret = dma_map_sg(ssp->dev, &dma_xfer[sg_count].sg, 1,
-                        write ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-
-                len -= min;
-                buf += min;
-
-                /* Queue the PIO register write transfer. */
-                desc = dmaengine_prep_slave_sg(ssp->dmach,
-                                (struct scatterlist *)dma_xfer[sg_count].pio,
-                                (ssp->devid == IMX23_SSP) ? 1 : 4,
-                                DMA_TRANS_NONE,
-                                sg_count ? DMA_PREP_INTERRUPT : 0);
-                if (!desc) {
-                        dev_err(ssp->dev,
-                                "Failed to get PIO reg. write descriptor.\n");
-                        ret = -EINVAL;
-                        goto err_mapped;
-                }
-
-                desc = dmaengine_prep_slave_sg(ssp->dmach,
-                                &dma_xfer[sg_count].sg, 1,
-                                write ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM,
-                                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-
-                if (!desc) {
-                        dev_err(ssp->dev,
-                                "Failed to get DMA data write descriptor.\n");
-                        ret = -EINVAL;
-                        goto err_mapped;
-                }
-        }
-
-        /*
-         * The last descriptor must have this callback,
-         * to finish the DMA transaction.
-         */
-        desc->callback = mxs_ssp_dma_irq_callback;
-        desc->callback_param = spi;
-
-        /* Start the transfer. */
-        dmaengine_submit(desc);
-        dma_async_issue_pending(ssp->dmach);
-
-        ret = wait_for_completion_timeout(&spi->c,
-                                msecs_to_jiffies(SSP_TIMEOUT));
-        if (!ret) {
-                dev_err(ssp->dev, "DMA transfer timeout\n");
-                ret = -ETIMEDOUT;
-                dmaengine_terminate_all(ssp->dmach);
-                goto err_vmalloc;
-        }
-
-        ret = 0;
-
-err_vmalloc:
-        while (--sg_count >= 0) {
-err_mapped:
-                dma_unmap_sg(ssp->dev, &dma_xfer[sg_count].sg, 1,
-                        write ? DMA_TO_DEVICE : DMA_FROM_DEVICE);
-        }
-
-        kfree(dma_xfer);
-
-        return ret;
-}
-
-static int mxs_spi_txrx_pio(struct mxs_spi *spi, int cs,
-                            unsigned char *buf, int len,
-                            int *first, int *last, int write)
-{
-        struct mxs_ssp *ssp = &spi->ssp;
-
-        if (*first)
-                mxs_spi_enable(spi);
-
-        mxs_spi_set_cs(spi, cs);
-
-        while (len--) {
-                if (*last && len == 0)
-                        mxs_spi_disable(spi);
-
-                if (ssp->devid == IMX23_SSP) {
-                        writel(BM_SSP_CTRL0_XFER_COUNT,
-                                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
-                        writel(1,
-                                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-                } else {
-                        writel(1, ssp->base + HW_SSP_XFER_SIZE);
-                }
-
-                if (write)
-                        writel(BM_SSP_CTRL0_READ,
-                                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_CLR);
-                else
-                        writel(BM_SSP_CTRL0_READ,
-                                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-
-                writel(BM_SSP_CTRL0_RUN,
-                                ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-
-                if (mxs_ssp_wait(spi, HW_SSP_CTRL0, BM_SSP_CTRL0_RUN, 1))
-                        return -ETIMEDOUT;
-
-                if (write)
-                        writel(*buf, ssp->base + HW_SSP_DATA(ssp));
-
-                writel(BM_SSP_CTRL0_DATA_XFER,
-                             ssp->base + HW_SSP_CTRL0 + STMP_OFFSET_REG_SET);
-
-                if (!write) {
-                        if (mxs_ssp_wait(spi, HW_SSP_STATUS(ssp),
-                                                BM_SSP_STATUS_FIFO_EMPTY, 0))
-                                return -ETIMEDOUT;
-
-                        *buf = (readl(ssp->base + HW_SSP_DATA(ssp)) & 0xff);
-                }
-
-                if (mxs_ssp_wait(spi, HW_SSP_CTRL0, BM_SSP_CTRL0_RUN, 0))
-                        return -ETIMEDOUT;
-
-                buf++;
-        }
-
-        if (len <= 0)
-                return 0;
-
-        return -ETIMEDOUT;
-}
-
-static int mxs_spi_transfer_one(struct spi_master *master,
-                                struct spi_message *m)
-{
-        struct mxs_spi *spi = spi_master_get_devdata(master);
-        struct mxs_ssp *ssp = &spi->ssp;
-        int first, last;
-        struct spi_transfer *t, *tmp_t;
-        int status = 0;
-        int cs;
-
-        first = last = 0;
-
-        cs = m->spi->chip_select;
-
-        list_for_each_entry_safe(t, tmp_t, &m->transfers, transfer_list) {
-
-                status = mxs_spi_setup_transfer(m->spi, t);
-                if (status)
-                        break;
-
-                if (&t->transfer_list == m->transfers.next)
-                        first = 1;
-                if (&t->transfer_list == m->transfers.prev)
-                        last = 1;
-                if ((t->rx_buf && t->tx_buf) || (t->rx_dma && t->tx_dma)) {
-                        dev_err(ssp->dev,
-                                "Cannot send and receive simultaneously\n");
-                        status = -EINVAL;
-                        break;
-                }
-
-                /*
-                 * Small blocks can be transfered via PIO.
-                 * Measured by empiric means:
-                 *
-                 * dd if=/dev/mtdblock0 of=/dev/null bs=1024k count=1
-                 *
-                 * DMA only: 2.164808 seconds, 473.0KB/s
-                 * Combined: 1.676276 seconds, 610.9KB/s
-                 */
-                if (t->len < 32) {
-                        writel(BM_SSP_CTRL1_DMA_ENABLE,
-                                ssp->base + HW_SSP_CTRL1(ssp) +
-                                STMP_OFFSET_REG_CLR);
-
-                        if (t->tx_buf)
-                                status = mxs_spi_txrx_pio(spi, cs,
-                                                (void *)t->tx_buf,
-                                                t->len, &first, &last, 1);
-                        if (t->rx_buf)
-                                status = mxs_spi_txrx_pio(spi, cs,
-                                                t->rx_buf, t->len,
-                                                &first, &last, 0);
-                } else {
-                        writel(BM_SSP_CTRL1_DMA_ENABLE,
-                                ssp->base + HW_SSP_CTRL1(ssp) +
-                                STMP_OFFSET_REG_SET);
-
-                        if (t->tx_buf)
-                                status = mxs_spi_txrx_dma(spi, cs,
-                                                (void *)t->tx_buf, t->len,
-                                                &first, &last, 1);
-                        if (t->rx_buf)
-                                status = mxs_spi_txrx_dma(spi, cs,
-                                                t->rx_buf, t->len,
-                                                &first, &last, 0);
-                }
-
-                if (status) {
-                        stmp_reset_block(ssp->base);
-                        break;
-                }
-
-                m->actual_length += t->len;
-                first = last = 0;
-        }
-
-        m->status = status;
-        spi_finalize_current_message(master);
-
-        return status;
-}
-
-static bool mxs_ssp_dma_filter(struct dma_chan *chan, void *param)
-{
-        struct mxs_ssp *ssp = param;
-
-        if (!mxs_dma_is_apbh(chan))
-                return false;
-
-        if (chan->chan_id != ssp->dma_channel)
-                return false;
-
-        chan->private = &ssp->dma_data;
-
-        return true;
-}
-
-static const struct of_device_id mxs_spi_dt_ids[] = {
-        { .compatible = "fsl,imx23-spi", .data = (void *) IMX23_SSP, },
-        { .compatible = "fsl,imx28-spi", .data = (void *) IMX28_SSP, },
-        { /* sentinel */ }
-};
-MODULE_DEVICE_TABLE(of, mxs_spi_dt_ids);
-
-static int mxs_spi_probe(struct platform_device *pdev)
-{
-        const struct of_device_id *of_id =
-                        of_match_device(mxs_spi_dt_ids, &pdev->dev);
-        struct device_node *np = pdev->dev.of_node;
-        struct spi_master *master;
-        struct mxs_spi *spi;
-        struct mxs_ssp *ssp;
-        struct resource *iores, *dmares;
-        struct pinctrl *pinctrl;
-        struct clk *clk;
-        void __iomem *base;
-        int devid, dma_channel, clk_freq;
-        int ret = 0, irq_err, irq_dma;
-        dma_cap_mask_t mask;
-
-        /*
-         * Default clock speed for the SPI core. 160MHz seems to
-         * work reasonably well with most SPI flashes, so use this
-         * as a default. Override with "clock-frequency" DT prop.
-         */
-        const int clk_freq_default = 160000000;
-
-        iores = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        irq_err = platform_get_irq(pdev, 0);
-        irq_dma = platform_get_irq(pdev, 1);
-        if (!iores || irq_err < 0 || irq_dma < 0)
-                return -EINVAL;
-
-        base = devm_request_and_ioremap(&pdev->dev, iores);
-        if (!base)
-                return -EADDRNOTAVAIL;
-
-        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(pinctrl))
-                return PTR_ERR(pinctrl);
-
-        clk = devm_clk_get(&pdev->dev, NULL);
-        if (IS_ERR(clk))
-                return PTR_ERR(clk);
-
-        if (np) {
-                devid = (enum mxs_ssp_id) of_id->data;
-                /*
-                 * TODO: This is a temporary solution and should be changed
-                 * to use generic DMA binding later when the helpers get in.
-                 */
-                ret = of_property_read_u32(np, "fsl,ssp-dma-channel",
-                                           &dma_channel);
-                if (ret) {
-                        dev_err(&pdev->dev,
-                                "Failed to get DMA channel\n");
-                        return -EINVAL;
-                }
-
-                ret = of_property_read_u32(np, "clock-frequency",
-                                           &clk_freq);
-                if (ret)
-                        clk_freq = clk_freq_default;
-        } else {
-                dmares = platform_get_resource(pdev, IORESOURCE_DMA, 0);
-                if (!dmares)
-                        return -EINVAL;
-                devid = pdev->id_entry->driver_data;
-                dma_channel = dmares->start;
-                clk_freq = clk_freq_default;
-        }
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*spi));
-        if (!master)
-                return -ENOMEM;
-
-        master->transfer_one_message = mxs_spi_transfer_one;
-        master->setup = mxs_spi_setup;
-        master->mode_bits = SPI_CPOL | SPI_CPHA;
-        master->num_chipselect = 3;
-        master->dev.of_node = np;
-        master->flags = SPI_MASTER_HALF_DUPLEX;
-
-        spi = spi_master_get_devdata(master);
-        ssp = &spi->ssp;
-        ssp->dev = &pdev->dev;
-        ssp->clk = clk;
-        ssp->base = base;
-        ssp->devid = devid;
-        ssp->dma_channel = dma_channel;
-
-        init_completion(&spi->c);
-
-        ret = devm_request_irq(&pdev->dev, irq_err, mxs_ssp_irq_handler, 0,
-                               DRIVER_NAME, ssp);
-        if (ret)
-                goto out_master_free;
-
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-        ssp->dma_data.chan_irq = irq_dma;
-        ssp->dmach = dma_request_channel(mask, mxs_ssp_dma_filter, ssp);
-        if (!ssp->dmach) {
-                dev_err(ssp->dev, "Failed to request DMA\n");
-                goto out_master_free;
-        }
-
-        clk_prepare_enable(ssp->clk);
-        clk_set_rate(ssp->clk, clk_freq);
-        ssp->clk_rate = clk_get_rate(ssp->clk) / 1000;
-
-        stmp_reset_block(ssp->base);
-
-        platform_set_drvdata(pdev, master);
-
-        ret = spi_register_master(master);
-        if (ret) {
-                dev_err(&pdev->dev, "Cannot register SPI master, %d\n", ret);
-                goto out_free_dma;
-        }
-
-        return 0;
-
-out_free_dma:
-        dma_release_channel(ssp->dmach);
-        clk_disable_unprepare(ssp->clk);
-out_master_free:
-        spi_master_put(master);
-        return ret;
-}
-
-static int mxs_spi_remove(struct platform_device *pdev)
-{
-        struct spi_master *master;
-        struct mxs_spi *spi;
-        struct mxs_ssp *ssp;
-
-        master = spi_master_get(platform_get_drvdata(pdev));
-        spi = spi_master_get_devdata(master);
-        ssp = &spi->ssp;
-
-        spi_unregister_master(master);
-
-        dma_release_channel(ssp->dmach);
-
-        clk_disable_unprepare(ssp->clk);
-
-        spi_master_put(master);
-
-        return 0;
-}
-
-static struct platform_driver mxs_spi_driver = {
-        .probe  = mxs_spi_probe,
-        .remove = mxs_spi_remove,
-        .driver = {
-                .name   = DRIVER_NAME,
-                .owner  = THIS_MODULE,
-                .of_match_table = mxs_spi_dt_ids,
-        },
-};
-
-module_platform_driver(mxs_spi_driver);
-
-MODULE_AUTHOR("Marek Vasut <marex@denx.de>");
-MODULE_DESCRIPTION("MXS SPI master driver");
-MODULE_LICENSE("GPL");
-MODULE_ALIAS("platform:mxs-spi");
diff --git a/drivers/spi/spi-nuc900.c b/drivers/spi/spi-nuc900.c
index b3f9ec83ef7..c0a6ce81f9c 100644
--- a/drivers/spi/spi-nuc900.c
+++ b/drivers/spi/spi-nuc900.c
@@ -8,7 +8,6 @@
  *
  */
 
-#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
@@ -26,7 +25,7 @@
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 
-#include <linux/platform_data/spi-nuc900.h>
+#include <mach/nuc900_spi.h>
 
 /* usi registers offset */
 #define USI_CNT         0x00
@@ -346,7 +345,7 @@ static void nuc900_init_spi(struct nuc900_spi *hw)
         nuc900_enable_int(hw);
 }
 
-static int nuc900_spi_probe(struct platform_device *pdev)
+static int __devinit nuc900_spi_probe(struct platform_device *pdev)
 {
         struct nuc900_spi *hw;
         struct spi_master *master;
@@ -360,6 +359,8 @@ static int nuc900_spi_probe(struct platform_device *pdev)
         }
 
         hw = spi_master_get_devdata(master);
+        memset(hw, 0, sizeof(struct nuc900_spi));
+
         hw->master = spi_master_get(master);
         hw->pdata  = pdev->dev.platform_data;
         hw->dev = &pdev->dev;
@@ -425,7 +426,7 @@ static int nuc900_spi_probe(struct platform_device *pdev)
                 goto err_clk;
         }
 
-        mfp_set_groupg(&pdev->dev, NULL);
+        mfp_set_groupg(&pdev->dev);
         nuc900_init_spi(hw);
 
         err = spi_bitbang_start(&hw->bitbang);
@@ -453,7 +454,7 @@ err_nomem:
         return err;
 }
 
-static int nuc900_spi_remove(struct platform_device *dev)
+static int __devexit nuc900_spi_remove(struct platform_device *dev)
 {
         struct nuc900_spi *hw = platform_get_drvdata(dev);
 
@@ -477,13 +478,25 @@ static int nuc900_spi_remove(struct platform_device *dev)
 
 static struct platform_driver nuc900_spi_driver = {
         .probe          = nuc900_spi_probe,
-        .remove         = nuc900_spi_remove,
+        .remove         = __devexit_p(nuc900_spi_remove),
         .driver         = {
                 .name   = "nuc900-spi",
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(nuc900_spi_driver);
+
+static int __init nuc900_spi_init(void)
+{
+        return platform_driver_register(&nuc900_spi_driver);
+}
+
+static void __exit nuc900_spi_exit(void)
+{
+        platform_driver_unregister(&nuc900_spi_driver);
+}
+
+module_init(nuc900_spi_init);
+module_exit(nuc900_spi_exit);
 
 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
 MODULE_DESCRIPTION("nuc900 spi driver!");
diff --git a/drivers/spi/spi-oc-tiny.c b/drivers/spi/spi-oc-tiny.c
index 432e66ec308..f1bde66cea1 100644
--- a/drivers/spi/spi-oc-tiny.c
+++ b/drivers/spi/spi-oc-tiny.c
@@ -18,7 +18,6 @@
 #include <linux/init.h>
 #include <linux/interrupt.h>
 #include <linux/errno.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
@@ -129,7 +128,7 @@ static int tiny_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
         unsigned int i;
 
         if (hw->irq >= 0) {
-                /* use interrupt driven data transfer */
+                /* use intrrupt driven data transfer */
                 hw->len = t->len;
                 hw->txp = t->tx_buf;
                 hw->rxp = t->rx_buf;
@@ -243,7 +242,7 @@ static irqreturn_t tiny_spi_irq(int irq, void *dev)
 #ifdef CONFIG_OF
 #include <linux/of_gpio.h>
 
-static int tiny_spi_of_probe(struct platform_device *pdev)
+static int __devinit tiny_spi_of_probe(struct platform_device *pdev)
 {
         struct tiny_spi *hw = platform_get_drvdata(pdev);
         struct device_node *np = pdev->dev.of_node;
@@ -277,13 +276,13 @@ static int tiny_spi_of_probe(struct platform_device *pdev)
         return 0;
 }
 #else /* !CONFIG_OF */
-static int tiny_spi_of_probe(struct platform_device *pdev)
+static int __devinit tiny_spi_of_probe(struct platform_device *pdev)
 {
         return 0;
 }
 #endif /* CONFIG_OF */
 
-static int tiny_spi_probe(struct platform_device *pdev)
+static int __devinit tiny_spi_probe(struct platform_device *pdev)
 {
         struct tiny_spi_platform_data *platp = pdev->dev.platform_data;
         struct tiny_spi *hw;
@@ -373,7 +372,7 @@ exit:
         return err;
 }
 
-static int tiny_spi_remove(struct platform_device *pdev)
+static int __devexit tiny_spi_remove(struct platform_device *pdev)
 {
         struct tiny_spi *hw = platform_get_drvdata(pdev);
         struct spi_master *master = hw->bitbang.master;
@@ -399,7 +398,7 @@ MODULE_DEVICE_TABLE(of, tiny_spi_match);
 
 static struct platform_driver tiny_spi_driver = {
         .probe = tiny_spi_probe,
-        .remove = tiny_spi_remove,
+        .remove = __devexit_p(tiny_spi_remove),
         .driver = {
                 .name = DRV_NAME,
                 .owner = THIS_MODULE,
@@ -407,7 +406,18 @@ static struct platform_driver tiny_spi_driver = {
                 .of_match_table = tiny_spi_match,
         },
 };
-module_platform_driver(tiny_spi_driver);
+
+static int __init tiny_spi_init(void)
+{
+        return platform_driver_register(&tiny_spi_driver);
+}
+module_init(tiny_spi_init);
+
+static void __exit tiny_spi_exit(void)
+{
+        platform_driver_unregister(&tiny_spi_driver);
+}
+module_exit(tiny_spi_exit);
 
 MODULE_DESCRIPTION("OpenCores tiny SPI driver");
 MODULE_AUTHOR("Thomas Chou <thomas@wytron.com.tw>");
diff --git a/drivers/spi/spi-octeon.c b/drivers/spi/spi-octeon.c
deleted file mode 100644
index 24daf964a40..00000000000
--- a/drivers/spi/spi-octeon.c
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * Copyright (C) 2011, 2012 Cavium, Inc.
- */
-
-#include <linux/platform_device.h>
-#include <linux/interrupt.h>
-#include <linux/spi/spi.h>
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/init.h>
-#include <linux/io.h>
-#include <linux/of.h>
-
-#include <asm/octeon/octeon.h>
-#include <asm/octeon/cvmx-mpi-defs.h>
-
-#define OCTEON_SPI_CFG 0
-#define OCTEON_SPI_STS 0x08
-#define OCTEON_SPI_TX 0x10
-#define OCTEON_SPI_DAT0 0x80
-
-#define OCTEON_SPI_MAX_BYTES 9
-
-#define OCTEON_SPI_MAX_CLOCK_HZ 16000000
-
-struct octeon_spi {
-        struct spi_master *my_master;
-        u64 register_base;
-        u64 last_cfg;
-        u64 cs_enax;
-};
-
-struct octeon_spi_setup {
-        u32 max_speed_hz;
-        u8 chip_select;
-        u8 mode;
-        u8 bits_per_word;
-};
-
-static void octeon_spi_wait_ready(struct octeon_spi *p)
-{
-        union cvmx_mpi_sts mpi_sts;
-        unsigned int loops = 0;
-
-        do {
-                if (loops++)
-                        __delay(500);
-                mpi_sts.u64 = cvmx_read_csr(p->register_base + OCTEON_SPI_STS);
-        } while (mpi_sts.s.busy);
-}
-
-static int octeon_spi_do_transfer(struct octeon_spi *p,
-                                  struct spi_message *msg,
-                                  struct spi_transfer *xfer,
-                                  bool last_xfer)
-{
-        union cvmx_mpi_cfg mpi_cfg;
-        union cvmx_mpi_tx mpi_tx;
-        unsigned int clkdiv;
-        unsigned int speed_hz;
-        int mode;
-        bool cpha, cpol;
-        int bits_per_word;
-        const u8 *tx_buf;
-        u8 *rx_buf;
-        int len;
-        int i;
-
-        struct octeon_spi_setup *msg_setup = spi_get_ctldata(msg->spi);
-
-        speed_hz = msg_setup->max_speed_hz;
-        mode = msg_setup->mode;
-        cpha = mode & SPI_CPHA;
-        cpol = mode & SPI_CPOL;
-        bits_per_word = msg_setup->bits_per_word;
-
-        if (xfer->speed_hz)
-                speed_hz = xfer->speed_hz;
-        if (xfer->bits_per_word)
-                bits_per_word = xfer->bits_per_word;
-
-        if (speed_hz > OCTEON_SPI_MAX_CLOCK_HZ)
-                speed_hz = OCTEON_SPI_MAX_CLOCK_HZ;
-
-        clkdiv = octeon_get_io_clock_rate() / (2 * speed_hz);
-
-        mpi_cfg.u64 = 0;
-
-        mpi_cfg.s.clkdiv = clkdiv;
-        mpi_cfg.s.cshi = (mode & SPI_CS_HIGH) ? 1 : 0;
-        mpi_cfg.s.lsbfirst = (mode & SPI_LSB_FIRST) ? 1 : 0;
-        mpi_cfg.s.wireor = (mode & SPI_3WIRE) ? 1 : 0;
-        mpi_cfg.s.idlelo = cpha != cpol;
-        mpi_cfg.s.cslate = cpha ? 1 : 0;
-        mpi_cfg.s.enable = 1;
-
-        if (msg_setup->chip_select < 4)
-                p->cs_enax |= 1ull << (12 + msg_setup->chip_select);
-        mpi_cfg.u64 |= p->cs_enax;
-
-        if (mpi_cfg.u64 != p->last_cfg) {
-                p->last_cfg = mpi_cfg.u64;
-                cvmx_write_csr(p->register_base + OCTEON_SPI_CFG, mpi_cfg.u64);
-        }
-        tx_buf = xfer->tx_buf;
-        rx_buf = xfer->rx_buf;
-        len = xfer->len;
-        while (len > OCTEON_SPI_MAX_BYTES) {
-                for (i = 0; i < OCTEON_SPI_MAX_BYTES; i++) {
-                        u8 d;
-                        if (tx_buf)
-                                d = *tx_buf++;
-                        else
-                                d = 0;
-                        cvmx_write_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i), d);
-                }
-                mpi_tx.u64 = 0;
-                mpi_tx.s.csid = msg_setup->chip_select;
-                mpi_tx.s.leavecs = 1;
-                mpi_tx.s.txnum = tx_buf ? OCTEON_SPI_MAX_BYTES : 0;
-                mpi_tx.s.totnum = OCTEON_SPI_MAX_BYTES;
-                cvmx_write_csr(p->register_base + OCTEON_SPI_TX, mpi_tx.u64);
-
-                octeon_spi_wait_ready(p);
-                if (rx_buf)
-                        for (i = 0; i < OCTEON_SPI_MAX_BYTES; i++) {
-                                u64 v = cvmx_read_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i));
-                                *rx_buf++ = (u8)v;
-                        }
-                len -= OCTEON_SPI_MAX_BYTES;
-        }
-
-        for (i = 0; i < len; i++) {
-                u8 d;
-                if (tx_buf)
-                        d = *tx_buf++;
-                else
-                        d = 0;
-                cvmx_write_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i), d);
-        }
-
-        mpi_tx.u64 = 0;
-        mpi_tx.s.csid = msg_setup->chip_select;
-        if (last_xfer)
-                mpi_tx.s.leavecs = xfer->cs_change;
-        else
-                mpi_tx.s.leavecs = !xfer->cs_change;
-        mpi_tx.s.txnum = tx_buf ? len : 0;
-        mpi_tx.s.totnum = len;
-        cvmx_write_csr(p->register_base + OCTEON_SPI_TX, mpi_tx.u64);
-
-        octeon_spi_wait_ready(p);
-        if (rx_buf)
-                for (i = 0; i < len; i++) {
-                        u64 v = cvmx_read_csr(p->register_base + OCTEON_SPI_DAT0 + (8 * i));
-                        *rx_buf++ = (u8)v;
-                }
-
-        if (xfer->delay_usecs)
-                udelay(xfer->delay_usecs);
-
-        return xfer->len;
-}
-
-static int octeon_spi_validate_bpw(struct spi_device *spi, u32 speed)
-{
-        switch (speed) {
-        case 8:
-                break;
-        default:
-                dev_err(&spi->dev, "Error: %d bits per word not supported\n",
-                        speed);
-                return -EINVAL;
-        }
-        return 0;
-}
-
-static int octeon_spi_transfer_one_message(struct spi_master *master,
-                                           struct spi_message *msg)
-{
-        struct octeon_spi *p = spi_master_get_devdata(master);
-        unsigned int total_len = 0;
-        int status = 0;
-        struct spi_transfer *xfer;
-
-        /*
-         * We better have set the configuration via a call to .setup
-         * before we get here.
-         */
-        if (spi_get_ctldata(msg->spi) == NULL) {
-                status = -EINVAL;
-                goto err;
-        }
-
-        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                if (xfer->bits_per_word) {
-                        status = octeon_spi_validate_bpw(msg->spi,
-                                                         xfer->bits_per_word);
-                        if (status)
-                                goto err;
-                }
-        }
-
-        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                bool last_xfer = &xfer->transfer_list == msg->transfers.prev;
-                int r = octeon_spi_do_transfer(p, msg, xfer, last_xfer);
-                if (r < 0) {
-                        status = r;
-                        goto err;
-                }
-                total_len += r;
-        }
-err:
-        msg->status = status;
-        msg->actual_length = total_len;
-        spi_finalize_current_message(master);
-        return status;
-}
-
-static struct octeon_spi_setup *octeon_spi_new_setup(struct spi_device *spi)
-{
-        struct octeon_spi_setup *setup = kzalloc(sizeof(*setup), GFP_KERNEL);
-        if (!setup)
-                return NULL;
-
-        setup->max_speed_hz = spi->max_speed_hz;
-        setup->chip_select = spi->chip_select;
-        setup->mode = spi->mode;
-        setup->bits_per_word = spi->bits_per_word;
-        return setup;
-}
-
-static int octeon_spi_setup(struct spi_device *spi)
-{
-        int r;
-        struct octeon_spi_setup *new_setup;
-        struct octeon_spi_setup *old_setup = spi_get_ctldata(spi);
-
-        r = octeon_spi_validate_bpw(spi, spi->bits_per_word);
-        if (r)
-                return r;
-
-        new_setup = octeon_spi_new_setup(spi);
-        if (!new_setup)
-                return -ENOMEM;
-
-        spi_set_ctldata(spi, new_setup);
-        kfree(old_setup);
-
-        return 0;
-}
-
-static void octeon_spi_cleanup(struct spi_device *spi)
-{
-        struct octeon_spi_setup *old_setup = spi_get_ctldata(spi);
-        spi_set_ctldata(spi, NULL);
-        kfree(old_setup);
-}
-
-static int octeon_spi_nop_transfer_hardware(struct spi_master *master)
-{
-        return 0;
-}
-
-static int octeon_spi_probe(struct platform_device *pdev)
-{
-
-        struct resource *res_mem;
-        struct spi_master *master;
-        struct octeon_spi *p;
-        int err = -ENOENT;
-
-        master = spi_alloc_master(&pdev->dev, sizeof(struct octeon_spi));
-        if (!master)
-                return -ENOMEM;
-        p = spi_master_get_devdata(master);
-        platform_set_drvdata(pdev, p);
-        p->my_master = master;
-
-        res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-
-        if (res_mem == NULL) {
-                dev_err(&pdev->dev, "found no memory resource\n");
-                err = -ENXIO;
-                goto fail;
-        }
-        if (!devm_request_mem_region(&pdev->dev, res_mem->start,
-                                     resource_size(res_mem), res_mem->name)) {
-                dev_err(&pdev->dev, "request_mem_region failed\n");
-                goto fail;
-        }
-        p->register_base = (u64)devm_ioremap(&pdev->dev, res_mem->start,
-                                             resource_size(res_mem));
-
-        /* Dynamic bus numbering */
-        master->bus_num = -1;
-        master->num_chipselect = 4;
-        master->mode_bits = SPI_CPHA |
-                            SPI_CPOL |
-                            SPI_CS_HIGH |
-                            SPI_LSB_FIRST |
-                            SPI_3WIRE;
-
-        master->setup = octeon_spi_setup;
-        master->cleanup = octeon_spi_cleanup;
-        master->prepare_transfer_hardware = octeon_spi_nop_transfer_hardware;
-        master->transfer_one_message = octeon_spi_transfer_one_message;
-        master->unprepare_transfer_hardware = octeon_spi_nop_transfer_hardware;
-
-        master->dev.of_node = pdev->dev.of_node;
-        err = spi_register_master(master);
-        if (err) {
-                dev_err(&pdev->dev, "register master failed: %d\n", err);
-                goto fail;
-        }
-
-        dev_info(&pdev->dev, "OCTEON SPI bus driver\n");
-
-        return 0;
-fail:
-        spi_master_put(master);
-        return err;
-}
-
-static int octeon_spi_remove(struct platform_device *pdev)
-{
-        struct octeon_spi *p = platform_get_drvdata(pdev);
-        u64 register_base = p->register_base;
-
-        spi_unregister_master(p->my_master);
-
-        /* Clear the CSENA* and put everything in a known state. */
-        cvmx_write_csr(register_base + OCTEON_SPI_CFG, 0);
-
-        return 0;
-}
-
-static struct of_device_id octeon_spi_match[] = {
-        { .compatible = "cavium,octeon-3010-spi", },
-        {},
-};
-MODULE_DEVICE_TABLE(of, octeon_spi_match);
-
-static struct platform_driver octeon_spi_driver = {
-        .driver = {
-                .name           = "spi-octeon",
-                .owner          = THIS_MODULE,
-                .of_match_table = octeon_spi_match,
-        },
-        .probe          = octeon_spi_probe,
-        .remove         = octeon_spi_remove,
-};
-
-module_platform_driver(octeon_spi_driver);
-
-MODULE_DESCRIPTION("Cavium, Inc. OCTEON SPI bus driver");
-MODULE_AUTHOR("David Daney");
-MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-omap-100k.c b/drivers/spi/spi-omap-100k.c
index 3aef7fa7d5b..9bd1c92ad96 100644
--- a/drivers/spi/spi-omap-100k.c
+++ b/drivers/spi/spi-omap-100k.c
@@ -37,6 +37,8 @@
 
 #include <linux/spi/spi.h>
 
+#include <plat/clock.h>
+
 #define OMAP1_SPI100K_MAX_FREQ          48000000
 
 #define ICR_SPITAS      (OMAP7XX_ICR_BASE + 0x12)
@@ -486,7 +488,7 @@ static int __init omap1_spi100k_reset(struct omap1_spi100k *spi100k)
         return 0;
 }
 
-static int omap1_spi100k_probe(struct platform_device *pdev)
+static int __devinit omap1_spi100k_probe(struct platform_device *pdev)
 {
         struct spi_master       *master;
         struct omap1_spi100k    *spi100k;
diff --git a/drivers/spi/spi-omap-uwire.c b/drivers/spi/spi-omap-uwire.c
index 0a94d9dc9c3..00a8e9d7dbe 100644
--- a/drivers/spi/spi-omap-uwire.c
+++ b/drivers/spi/spi-omap-uwire.c
@@ -45,16 +45,15 @@
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
-#include <linux/module.h>
 
+#include <asm/system.h>
 #include <asm/irq.h>
 #include <mach/hardware.h>
 #include <asm/io.h>
 #include <asm/mach-types.h>
 
-#include <mach/mux.h>
-
-#include <mach/omap7xx.h>       /* OMAP7XX_IO_CONF registers */
+#include <plat/mux.h>
+#include <plat/omap7xx.h>       /* OMAP7XX_IO_CONF registers */
 
 
 /* FIXME address is now a platform device resource,
diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index b610f522ca4..322be7aea8b 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -28,24 +28,23 @@
 #include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
-#include <linux/dmaengine.h>
-#include <linux/omap-dma.h>
 #include <linux/platform_device.h>
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/io.h>
 #include <linux/slab.h>
 #include <linux/pm_runtime.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/pinctrl/consumer.h>
 
 #include <linux/spi/spi.h>
 
-#include <linux/platform_data/spi-omap2-mcspi.h>
+#include <plat/dma.h>
+#include <plat/clock.h>
+#include <plat/mcspi.h>
 
 #define OMAP2_MCSPI_MAX_FREQ            48000000
-#define SPI_AUTOSUSPEND_TIMEOUT         2000
+
+/* OMAP2 has 3 SPI controllers, while OMAP3 has 4 */
+#define OMAP2_MCSPI_MAX_CTRL            4
 
 #define OMAP2_MCSPI_REVISION            0x00
 #define OMAP2_MCSPI_SYSSTATUS           0x14
@@ -94,8 +93,8 @@
 
 /* We have 2 DMA channels per CS, one for RX and one for TX */
 struct omap2_mcspi_dma {
-        struct dma_chan *dma_tx;
-        struct dma_chan *dma_rx;
+        int dma_tx_channel;
+        int dma_rx_channel;
 
         int dma_tx_sync_dev;
         int dma_rx_sync_dev;
@@ -110,26 +109,18 @@ struct omap2_mcspi_dma {
 #define DMA_MIN_BYTES                   160
 
 
-/*
- * Used for context save and restore, structure members to be updated whenever
- * corresponding registers are modified.
- */
-struct omap2_mcspi_regs {
-        u32 modulctrl;
-        u32 wakeupenable;
-        struct list_head cs;
-};
-
 struct omap2_mcspi {
+        struct work_struct      work;
+        /* lock protects queue and registers */
+        spinlock_t              lock;
+        struct list_head        msg_queue;
         struct spi_master       *master;
         /* Virtual base address of the controller */
         void __iomem            *base;
         unsigned long           phys;
         /* SPI1 has 4 channels, while SPI2 has 2 */
         struct omap2_mcspi_dma  *dma_channels;
-        struct device           *dev;
-        struct omap2_mcspi_regs ctx;
-        unsigned int            pin_dir:1;
+        struct  device          *dev;
 };
 
 struct omap2_mcspi_cs {
@@ -141,6 +132,26 @@ struct omap2_mcspi_cs {
         u32                     chconf0;
 };
 
+/* used for context save and restore, structure members to be updated whenever
+ * corresponding registers are modified.
+ */
+struct omap2_mcspi_regs {
+        u32 modulctrl;
+        u32 wakeupenable;
+        struct list_head cs;
+};
+
+static struct omap2_mcspi_regs omap2_mcspi_ctx[OMAP2_MCSPI_MAX_CTRL];
+
+static struct workqueue_struct *omap2_mcspi_wq;
+
+#define MOD_REG_BIT(val, mask, set) do { \
+        if (set) \
+                val |= mask; \
+        else \
+                val &= ~mask; \
+} while (0)
+
 static inline void mcspi_write_reg(struct spi_master *master,
                 int idx, u32 val)
 {
@@ -199,11 +210,7 @@ static void omap2_mcspi_set_dma_req(const struct spi_device *spi,
         else
                 rw = OMAP2_MCSPI_CHCONF_DMAW;
 
-        if (enable)
-                l |= rw;
-        else
-                l &= ~rw;
-
+        MOD_REG_BIT(l, rw, enable);
         mcspi_write_chconf0(spi, l);
 }
 
@@ -222,61 +229,51 @@ static void omap2_mcspi_force_cs(struct spi_device *spi, int cs_active)
         u32 l;
 
         l = mcspi_cached_chconf0(spi);
-        if (cs_active)
-                l |= OMAP2_MCSPI_CHCONF_FORCE;
-        else
-                l &= ~OMAP2_MCSPI_CHCONF_FORCE;
-
+        MOD_REG_BIT(l, OMAP2_MCSPI_CHCONF_FORCE, cs_active);
         mcspi_write_chconf0(spi, l);
 }
 
 static void omap2_mcspi_set_master_mode(struct spi_master *master)
 {
-        struct omap2_mcspi      *mcspi = spi_master_get_devdata(master);
-        struct omap2_mcspi_regs *ctx = &mcspi->ctx;
         u32 l;
 
-        /*
-         * Setup when switching from (reset default) slave mode
+        /* setup when switching from (reset default) slave mode
          * to single-channel master mode
          */
         l = mcspi_read_reg(master, OMAP2_MCSPI_MODULCTRL);
-        l &= ~(OMAP2_MCSPI_MODULCTRL_STEST | OMAP2_MCSPI_MODULCTRL_MS);
-        l |= OMAP2_MCSPI_MODULCTRL_SINGLE;
+        MOD_REG_BIT(l, OMAP2_MCSPI_MODULCTRL_STEST, 0);
+        MOD_REG_BIT(l, OMAP2_MCSPI_MODULCTRL_MS, 0);
+        MOD_REG_BIT(l, OMAP2_MCSPI_MODULCTRL_SINGLE, 1);
         mcspi_write_reg(master, OMAP2_MCSPI_MODULCTRL, l);
 
-        ctx->modulctrl = l;
+        omap2_mcspi_ctx[master->bus_num - 1].modulctrl = l;
 }
 
 static void omap2_mcspi_restore_ctx(struct omap2_mcspi *mcspi)
 {
-        struct spi_master       *spi_cntrl = mcspi->master;
-        struct omap2_mcspi_regs *ctx = &mcspi->ctx;
-        struct omap2_mcspi_cs   *cs;
+        struct spi_master *spi_cntrl;
+        struct omap2_mcspi_cs *cs;
+        spi_cntrl = mcspi->master;
 
         /* McSPI: context restore */
-        mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_MODULCTRL, ctx->modulctrl);
-        mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_WAKEUPENABLE, ctx->wakeupenable);
+        mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_MODULCTRL,
+                        omap2_mcspi_ctx[spi_cntrl->bus_num - 1].modulctrl);
+
+        mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_WAKEUPENABLE,
+                        omap2_mcspi_ctx[spi_cntrl->bus_num - 1].wakeupenable);
 
-        list_for_each_entry(cs, &ctx->cs, node)
+        list_for_each_entry(cs, &omap2_mcspi_ctx[spi_cntrl->bus_num - 1].cs,
+                        node)
                 __raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
 }
-
-static int omap2_prepare_transfer(struct spi_master *master)
+static void omap2_mcspi_disable_clocks(struct omap2_mcspi *mcspi)
 {
-        struct omap2_mcspi *mcspi = spi_master_get_devdata(master);
-
-        pm_runtime_get_sync(mcspi->dev);
-        return 0;
+        pm_runtime_put_sync(mcspi->dev);
 }
 
-static int omap2_unprepare_transfer(struct spi_master *master)
+static int omap2_mcspi_enable_clocks(struct omap2_mcspi *mcspi)
 {
-        struct omap2_mcspi *mcspi = spi_master_get_devdata(master);
-
-        pm_runtime_mark_last_busy(mcspi->dev);
-        pm_runtime_put_autosuspend(mcspi->dev);
-        return 0;
+        return pm_runtime_get_sync(mcspi->dev);
 }
 
 static int mcspi_wait_for_reg_bit(void __iomem *reg, unsigned long bit)
@@ -292,227 +289,95 @@ static int mcspi_wait_for_reg_bit(void __iomem *reg, unsigned long bit)
         return 0;
 }
 
-static void omap2_mcspi_rx_callback(void *data)
-{
-        struct spi_device *spi = data;
-        struct omap2_mcspi *mcspi = spi_master_get_devdata(spi->master);
-        struct omap2_mcspi_dma *mcspi_dma = &mcspi->dma_channels[spi->chip_select];
-
-        complete(&mcspi_dma->dma_rx_completion);
-
-        /* We must disable the DMA RX request */
-        omap2_mcspi_set_dma_req(spi, 1, 0);
-}
-
-static void omap2_mcspi_tx_callback(void *data)
-{
-        struct spi_device *spi = data;
-        struct omap2_mcspi *mcspi = spi_master_get_devdata(spi->master);
-        struct omap2_mcspi_dma *mcspi_dma = &mcspi->dma_channels[spi->chip_select];
-
-        complete(&mcspi_dma->dma_tx_completion);
-
-        /* We must disable the DMA TX request */
-        omap2_mcspi_set_dma_req(spi, 0, 0);
-}
-
-static void omap2_mcspi_tx_dma(struct spi_device *spi,
-                                struct spi_transfer *xfer,
-                                struct dma_slave_config cfg)
+static unsigned
+omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
 {
         struct omap2_mcspi      *mcspi;
+        struct omap2_mcspi_cs   *cs = spi->controller_state;
         struct omap2_mcspi_dma  *mcspi_dma;
-        unsigned int            count;
+        unsigned int            count, c;
+        unsigned long           base, tx_reg, rx_reg;
+        int                     word_len, data_type, element_count;
+        int                     elements = 0;
+        u32                     l;
+        u8                      * rx;
+        const u8                * tx;
+        void __iomem            *chstat_reg;
 
         mcspi = spi_master_get_devdata(spi->master);
         mcspi_dma = &mcspi->dma_channels[spi->chip_select];
-        count = xfer->len;
-
-        if (mcspi_dma->dma_tx) {
-                struct dma_async_tx_descriptor *tx;
-                struct scatterlist sg;
-
-                dmaengine_slave_config(mcspi_dma->dma_tx, &cfg);
-
-                sg_init_table(&sg, 1);
-                sg_dma_address(&sg) = xfer->tx_dma;
-                sg_dma_len(&sg) = xfer->len;
-
-                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_tx, &sg, 1,
-                DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-                if (tx) {
-                        tx->callback = omap2_mcspi_tx_callback;
-                        tx->callback_param = spi;
-                        dmaengine_submit(tx);
-                } else {
-                        /* FIXME: fall back to PIO? */
-                }
-        }
-        dma_async_issue_pending(mcspi_dma->dma_tx);
-        omap2_mcspi_set_dma_req(spi, 0, 1);
+        l = mcspi_cached_chconf0(spi);
 
-}
+        chstat_reg = cs->base + OMAP2_MCSPI_CHSTAT0;
 
-static unsigned
-omap2_mcspi_rx_dma(struct spi_device *spi, struct spi_transfer *xfer,
-                                struct dma_slave_config cfg,
-                                unsigned es)
-{
-        struct omap2_mcspi      *mcspi;
-        struct omap2_mcspi_dma  *mcspi_dma;
-        unsigned int            count;
-        u32                     l;
-        int                     elements = 0;
-        int                     word_len, element_count;
-        struct omap2_mcspi_cs   *cs = spi->controller_state;
-        mcspi = spi_master_get_devdata(spi->master);
-        mcspi_dma = &mcspi->dma_channels[spi->chip_select];
         count = xfer->len;
+        c = count;
         word_len = cs->word_len;
-        l = mcspi_cached_chconf0(spi);
 
-        if (word_len <= 8)
+        base = cs->phys;
+        tx_reg = base + OMAP2_MCSPI_TX0;
+        rx_reg = base + OMAP2_MCSPI_RX0;
+        rx = xfer->rx_buf;
+        tx = xfer->tx_buf;
+
+        if (word_len <= 8) {
+                data_type = OMAP_DMA_DATA_TYPE_S8;
                 element_count = count;
-        else if (word_len <= 16)
+        } else if (word_len <= 16) {
+                data_type = OMAP_DMA_DATA_TYPE_S16;
                 element_count = count >> 1;
-        else /* word_len <= 32 */
+        } else /* word_len <= 32 */ {
+                data_type = OMAP_DMA_DATA_TYPE_S32;
                 element_count = count >> 2;
-
-        if (mcspi_dma->dma_rx) {
-                struct dma_async_tx_descriptor *tx;
-                struct scatterlist sg;
-                size_t len = xfer->len - es;
-
-                dmaengine_slave_config(mcspi_dma->dma_rx, &cfg);
-
-                if (l & OMAP2_MCSPI_CHCONF_TURBO)
-                        len -= es;
-
-                sg_init_table(&sg, 1);
-                sg_dma_address(&sg) = xfer->rx_dma;
-                sg_dma_len(&sg) = len;
-
-                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_rx, &sg, 1,
-                                DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT |
-                                DMA_CTRL_ACK);
-                if (tx) {
-                        tx->callback = omap2_mcspi_rx_callback;
-                        tx->callback_param = spi;
-                        dmaengine_submit(tx);
-                } else {
-                                /* FIXME: fall back to PIO? */
-                }
         }
 
-        dma_async_issue_pending(mcspi_dma->dma_rx);
-        omap2_mcspi_set_dma_req(spi, 1, 1);
-
-        wait_for_completion(&mcspi_dma->dma_rx_completion);
-        dma_unmap_single(mcspi->dev, xfer->rx_dma, count,
-                         DMA_FROM_DEVICE);
-        omap2_mcspi_set_enable(spi, 0);
-
-        elements = element_count - 1;
-
-        if (l & OMAP2_MCSPI_CHCONF_TURBO) {
-                elements--;
-
-                if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
-                                   & OMAP2_MCSPI_CHSTAT_RXS)) {
-                        u32 w;
-
-                        w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
-                        if (word_len <= 8)
-                                ((u8 *)xfer->rx_buf)[elements++] = w;
-                        else if (word_len <= 16)
-                                ((u16 *)xfer->rx_buf)[elements++] = w;
-                        else /* word_len <= 32 */
-                                ((u32 *)xfer->rx_buf)[elements++] = w;
-                } else {
-                        dev_err(&spi->dev, "DMA RX penultimate word empty");
-                        count -= (word_len <= 8)  ? 2 :
-                                (word_len <= 16) ? 4 :
-                                /* word_len <= 32 */ 8;
-                        omap2_mcspi_set_enable(spi, 1);
-                        return count;
-                }
-        }
-        if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
-                                & OMAP2_MCSPI_CHSTAT_RXS)) {
-                u32 w;
-
-                w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
-                if (word_len <= 8)
-                        ((u8 *)xfer->rx_buf)[elements] = w;
-                else if (word_len <= 16)
-                        ((u16 *)xfer->rx_buf)[elements] = w;
-                else /* word_len <= 32 */
-                        ((u32 *)xfer->rx_buf)[elements] = w;
-        } else {
-                dev_err(&spi->dev, "DMA RX last word empty");
-                count -= (word_len <= 8)  ? 1 :
-                         (word_len <= 16) ? 2 :
-                       /* word_len <= 32 */ 4;
+        if (tx != NULL) {
+                omap_set_dma_transfer_params(mcspi_dma->dma_tx_channel,
+                                data_type, element_count, 1,
+                                OMAP_DMA_SYNC_ELEMENT,
+                                mcspi_dma->dma_tx_sync_dev, 0);
+
+                omap_set_dma_dest_params(mcspi_dma->dma_tx_channel, 0,
+                                OMAP_DMA_AMODE_CONSTANT,
+                                tx_reg, 0, 0);
+
+                omap_set_dma_src_params(mcspi_dma->dma_tx_channel, 0,
+                                OMAP_DMA_AMODE_POST_INC,
+                                xfer->tx_dma, 0, 0);
         }
-        omap2_mcspi_set_enable(spi, 1);
-        return count;
-}
 
-static unsigned
-omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
-{
-        struct omap2_mcspi      *mcspi;
-        struct omap2_mcspi_cs   *cs = spi->controller_state;
-        struct omap2_mcspi_dma  *mcspi_dma;
-        unsigned int            count;
-        u32                     l;
-        u8                      *rx;
-        const u8                *tx;
-        struct dma_slave_config cfg;
-        enum dma_slave_buswidth width;
-        unsigned es;
-        void __iomem            *chstat_reg;
+        if (rx != NULL) {
+                elements = element_count - 1;
+                if (l & OMAP2_MCSPI_CHCONF_TURBO)
+                        elements--;
 
-        mcspi = spi_master_get_devdata(spi->master);
-        mcspi_dma = &mcspi->dma_channels[spi->chip_select];
-        l = mcspi_cached_chconf0(spi);
+                omap_set_dma_transfer_params(mcspi_dma->dma_rx_channel,
+                                data_type, elements, 1,
+                                OMAP_DMA_SYNC_ELEMENT,
+                                mcspi_dma->dma_rx_sync_dev, 1);
 
+                omap_set_dma_src_params(mcspi_dma->dma_rx_channel, 0,
+                                OMAP_DMA_AMODE_CONSTANT,
+                                rx_reg, 0, 0);
 
-        if (cs->word_len <= 8) {
-                width = DMA_SLAVE_BUSWIDTH_1_BYTE;
-                es = 1;
-        } else if (cs->word_len <= 16) {
-                width = DMA_SLAVE_BUSWIDTH_2_BYTES;
-                es = 2;
-        } else {
-                width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-                es = 4;
+                omap_set_dma_dest_params(mcspi_dma->dma_rx_channel, 0,
+                                OMAP_DMA_AMODE_POST_INC,
+                                xfer->rx_dma, 0, 0);
         }
 
-        memset(&cfg, 0, sizeof(cfg));
-        cfg.src_addr = cs->phys + OMAP2_MCSPI_RX0;
-        cfg.dst_addr = cs->phys + OMAP2_MCSPI_TX0;
-        cfg.src_addr_width = width;
-        cfg.dst_addr_width = width;
-        cfg.src_maxburst = 1;
-        cfg.dst_maxburst = 1;
-
-        rx = xfer->rx_buf;
-        tx = xfer->tx_buf;
-
-        count = xfer->len;
-
-        if (tx != NULL)
-                omap2_mcspi_tx_dma(spi, xfer, cfg);
+        if (tx != NULL) {
+                omap_start_dma(mcspi_dma->dma_tx_channel);
+                omap2_mcspi_set_dma_req(spi, 0, 1);
+        }
 
-        if (rx != NULL)
-                count = omap2_mcspi_rx_dma(spi, xfer, cfg, es);
+        if (rx != NULL) {
+                omap_start_dma(mcspi_dma->dma_rx_channel);
+                omap2_mcspi_set_dma_req(spi, 1, 1);
+        }
 
         if (tx != NULL) {
-                chstat_reg = cs->base + OMAP2_MCSPI_CHSTAT0;
                 wait_for_completion(&mcspi_dma->dma_tx_completion);
-                dma_unmap_single(mcspi->dev, xfer->tx_dma, xfer->len,
-                                 DMA_TO_DEVICE);
+                dma_unmap_single(&spi->dev, xfer->tx_dma, count, DMA_TO_DEVICE);
 
                 /* for TX_ONLY mode, be sure all words have shifted out */
                 if (rx == NULL) {
@@ -524,6 +389,55 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
                                 dev_err(&spi->dev, "EOT timed out\n");
                 }
         }
+
+        if (rx != NULL) {
+                wait_for_completion(&mcspi_dma->dma_rx_completion);
+                dma_unmap_single(&spi->dev, xfer->rx_dma, count, DMA_FROM_DEVICE);
+                omap2_mcspi_set_enable(spi, 0);
+
+                if (l & OMAP2_MCSPI_CHCONF_TURBO) {
+
+                        if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
+                                   & OMAP2_MCSPI_CHSTAT_RXS)) {
+                                u32 w;
+
+                                w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
+                                if (word_len <= 8)
+                                        ((u8 *)xfer->rx_buf)[elements++] = w;
+                                else if (word_len <= 16)
+                                        ((u16 *)xfer->rx_buf)[elements++] = w;
+                                else /* word_len <= 32 */
+                                        ((u32 *)xfer->rx_buf)[elements++] = w;
+                        } else {
+                                dev_err(&spi->dev,
+                                        "DMA RX penultimate word empty");
+                                count -= (word_len <= 8)  ? 2 :
+                                        (word_len <= 16) ? 4 :
+                                        /* word_len <= 32 */ 8;
+                                omap2_mcspi_set_enable(spi, 1);
+                                return count;
+                        }
+                }
+
+                if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
+                                & OMAP2_MCSPI_CHSTAT_RXS)) {
+                        u32 w;
+
+                        w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
+                        if (word_len <= 8)
+                                ((u8 *)xfer->rx_buf)[elements] = w;
+                        else if (word_len <= 16)
+                                ((u16 *)xfer->rx_buf)[elements] = w;
+                        else /* word_len <= 32 */
+                                ((u32 *)xfer->rx_buf)[elements] = w;
+                } else {
+                        dev_err(&spi->dev, "DMA RX last word empty");
+                        count -= (word_len <= 8)  ? 1 :
+                                 (word_len <= 16) ? 2 :
+                               /* word_len <= 32 */ 4;
+                }
+                omap2_mcspi_set_enable(spi, 1);
+        }
         return count;
 }
 
@@ -761,15 +675,8 @@ static int omap2_mcspi_setup_transfer(struct spi_device *spi,
         /* standard 4-wire master mode:  SCK, MOSI/out, MISO/in, nCS
          * REVISIT: this controller could support SPI_3WIRE mode.
          */
-        if (mcspi->pin_dir == MCSPI_PINDIR_D0_IN_D1_OUT) {
-                l &= ~OMAP2_MCSPI_CHCONF_IS;
-                l &= ~OMAP2_MCSPI_CHCONF_DPE1;
-                l |= OMAP2_MCSPI_CHCONF_DPE0;
-        } else {
-                l |= OMAP2_MCSPI_CHCONF_IS;
-                l |= OMAP2_MCSPI_CHCONF_DPE1;
-                l &= ~OMAP2_MCSPI_CHCONF_DPE0;
-        }
+        l &= ~(OMAP2_MCSPI_CHCONF_IS|OMAP2_MCSPI_CHCONF_DPE1);
+        l |= OMAP2_MCSPI_CHCONF_DPE0;
 
         /* wordlength */
         l &= ~OMAP2_MCSPI_CHCONF_WL_MASK;
@@ -805,46 +712,71 @@ static int omap2_mcspi_setup_transfer(struct spi_device *spi,
         return 0;
 }
 
+static void omap2_mcspi_dma_rx_callback(int lch, u16 ch_status, void *data)
+{
+        struct spi_device       *spi = data;
+        struct omap2_mcspi      *mcspi;
+        struct omap2_mcspi_dma  *mcspi_dma;
+
+        mcspi = spi_master_get_devdata(spi->master);
+        mcspi_dma = &(mcspi->dma_channels[spi->chip_select]);
+
+        complete(&mcspi_dma->dma_rx_completion);
+
+        /* We must disable the DMA RX request */
+        omap2_mcspi_set_dma_req(spi, 1, 0);
+}
+
+static void omap2_mcspi_dma_tx_callback(int lch, u16 ch_status, void *data)
+{
+        struct spi_device       *spi = data;
+        struct omap2_mcspi      *mcspi;
+        struct omap2_mcspi_dma  *mcspi_dma;
+
+        mcspi = spi_master_get_devdata(spi->master);
+        mcspi_dma = &(mcspi->dma_channels[spi->chip_select]);
+
+        complete(&mcspi_dma->dma_tx_completion);
+
+        /* We must disable the DMA TX request */
+        omap2_mcspi_set_dma_req(spi, 0, 0);
+}
+
 static int omap2_mcspi_request_dma(struct spi_device *spi)
 {
         struct spi_master       *master = spi->master;
         struct omap2_mcspi      *mcspi;
         struct omap2_mcspi_dma  *mcspi_dma;
-        dma_cap_mask_t mask;
-        unsigned sig;
 
         mcspi = spi_master_get_devdata(master);
         mcspi_dma = mcspi->dma_channels + spi->chip_select;
 
-        init_completion(&mcspi_dma->dma_rx_completion);
-        init_completion(&mcspi_dma->dma_tx_completion);
-
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-        sig = mcspi_dma->dma_rx_sync_dev;
-        mcspi_dma->dma_rx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
-        if (!mcspi_dma->dma_rx) {
-                dev_err(&spi->dev, "no RX DMA engine channel for McSPI\n");
+        if (omap_request_dma(mcspi_dma->dma_rx_sync_dev, "McSPI RX",
+                        omap2_mcspi_dma_rx_callback, spi,
+                        &mcspi_dma->dma_rx_channel)) {
+                dev_err(&spi->dev, "no RX DMA channel for McSPI\n");
                 return -EAGAIN;
         }
 
-        sig = mcspi_dma->dma_tx_sync_dev;
-        mcspi_dma->dma_tx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
-        if (!mcspi_dma->dma_tx) {
-                dev_err(&spi->dev, "no TX DMA engine channel for McSPI\n");
-                dma_release_channel(mcspi_dma->dma_rx);
-                mcspi_dma->dma_rx = NULL;
+        if (omap_request_dma(mcspi_dma->dma_tx_sync_dev, "McSPI TX",
+                        omap2_mcspi_dma_tx_callback, spi,
+                        &mcspi_dma->dma_tx_channel)) {
+                omap_free_dma(mcspi_dma->dma_rx_channel);
+                mcspi_dma->dma_rx_channel = -1;
+                dev_err(&spi->dev, "no TX DMA channel for McSPI\n");
                 return -EAGAIN;
         }
 
+        init_completion(&mcspi_dma->dma_rx_completion);
+        init_completion(&mcspi_dma->dma_tx_completion);
+
         return 0;
 }
 
 static int omap2_mcspi_setup(struct spi_device *spi)
 {
         int                     ret;
-        struct omap2_mcspi      *mcspi = spi_master_get_devdata(spi->master);
-        struct omap2_mcspi_regs *ctx = &mcspi->ctx;
+        struct omap2_mcspi      *mcspi;
         struct omap2_mcspi_dma  *mcspi_dma;
         struct omap2_mcspi_cs   *cs = spi->controller_state;
 
@@ -854,6 +786,7 @@ static int omap2_mcspi_setup(struct spi_device *spi)
                 return -EINVAL;
         }
 
+        mcspi = spi_master_get_devdata(spi->master);
         mcspi_dma = &mcspi->dma_channels[spi->chip_select];
 
         if (!cs) {
@@ -865,22 +798,23 @@ static int omap2_mcspi_setup(struct spi_device *spi)
                 cs->chconf0 = 0;
                 spi->controller_state = cs;
                 /* Link this to context save list */
-                list_add_tail(&cs->node, &ctx->cs);
+                list_add_tail(&cs->node,
+                        &omap2_mcspi_ctx[mcspi->master->bus_num - 1].cs);
         }
 
-        if (!mcspi_dma->dma_rx || !mcspi_dma->dma_tx) {
+        if (mcspi_dma->dma_rx_channel == -1
+                        || mcspi_dma->dma_tx_channel == -1) {
                 ret = omap2_mcspi_request_dma(spi);
                 if (ret < 0)
                         return ret;
         }
 
-        ret = pm_runtime_get_sync(mcspi->dev);
+        ret = omap2_mcspi_enable_clocks(mcspi);
         if (ret < 0)
                 return ret;
 
         ret = omap2_mcspi_setup_transfer(spi, NULL);
-        pm_runtime_mark_last_busy(mcspi->dev);
-        pm_runtime_put_autosuspend(mcspi->dev);
+        omap2_mcspi_disable_clocks(mcspi);
 
         return ret;
 }
@@ -898,139 +832,161 @@ static void omap2_mcspi_cleanup(struct spi_device *spi)
                 cs = spi->controller_state;
                 list_del(&cs->node);
 
-                kfree(cs);
+                kfree(spi->controller_state);
         }
 
         if (spi->chip_select < spi->master->num_chipselect) {
                 mcspi_dma = &mcspi->dma_channels[spi->chip_select];
 
-                if (mcspi_dma->dma_rx) {
-                        dma_release_channel(mcspi_dma->dma_rx);
-                        mcspi_dma->dma_rx = NULL;
+                if (mcspi_dma->dma_rx_channel != -1) {
+                        omap_free_dma(mcspi_dma->dma_rx_channel);
+                        mcspi_dma->dma_rx_channel = -1;
                 }
-                if (mcspi_dma->dma_tx) {
-                        dma_release_channel(mcspi_dma->dma_tx);
-                        mcspi_dma->dma_tx = NULL;
+                if (mcspi_dma->dma_tx_channel != -1) {
+                        omap_free_dma(mcspi_dma->dma_tx_channel);
+                        mcspi_dma->dma_tx_channel = -1;
                 }
         }
 }
 
-static void omap2_mcspi_work(struct omap2_mcspi *mcspi, struct spi_message *m)
+static void omap2_mcspi_work(struct work_struct *work)
 {
+        struct omap2_mcspi      *mcspi;
+
+        mcspi = container_of(work, struct omap2_mcspi, work);
+
+        if (omap2_mcspi_enable_clocks(mcspi) < 0)
+                return;
+
+        spin_lock_irq(&mcspi->lock);
 
         /* We only enable one channel at a time -- the one whose message is
-         * -- although this controller would gladly
+         * at the head of the queue -- although this controller would gladly
          * arbitrate among multiple channels.  This corresponds to "single
          * channel" master mode.  As a side effect, we need to manage the
          * chipselect with the FORCE bit ... CS != channel enable.
          */
+        while (!list_empty(&mcspi->msg_queue)) {
+                struct spi_message              *m;
+                struct spi_device               *spi;
+                struct spi_transfer             *t = NULL;
+                int                             cs_active = 0;
+                struct omap2_mcspi_cs           *cs;
+                struct omap2_mcspi_device_config *cd;
+                int                             par_override = 0;
+                int                             status = 0;
+                u32                             chconf;
+
+                m = container_of(mcspi->msg_queue.next, struct spi_message,
+                                 queue);
+
+                list_del_init(&m->queue);
+                spin_unlock_irq(&mcspi->lock);
+
+                spi = m->spi;
+                cs = spi->controller_state;
+                cd = spi->controller_data;
 
-        struct spi_device               *spi;
-        struct spi_transfer             *t = NULL;
-        int                             cs_active = 0;
-        struct omap2_mcspi_cs           *cs;
-        struct omap2_mcspi_device_config *cd;
-        int                             par_override = 0;
-        int                             status = 0;
-        u32                             chconf;
-
-        spi = m->spi;
-        cs = spi->controller_state;
-        cd = spi->controller_data;
-
-        omap2_mcspi_set_enable(spi, 1);
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) {
-                        status = -EINVAL;
-                        break;
-                }
-                if (par_override || t->speed_hz || t->bits_per_word) {
-                        par_override = 1;
-                        status = omap2_mcspi_setup_transfer(spi, t);
-                        if (status < 0)
+                omap2_mcspi_set_enable(spi, 1);
+                list_for_each_entry(t, &m->transfers, transfer_list) {
+                        if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) {
+                                status = -EINVAL;
                                 break;
-                        if (!t->speed_hz && !t->bits_per_word)
-                                par_override = 0;
-                }
+                        }
+                        if (par_override || t->speed_hz || t->bits_per_word) {
+                                par_override = 1;
+                                status = omap2_mcspi_setup_transfer(spi, t);
+                                if (status < 0)
+                                        break;
+                                if (!t->speed_hz && !t->bits_per_word)
+                                        par_override = 0;
+                        }
 
-                if (!cs_active) {
-                        omap2_mcspi_force_cs(spi, 1);
-                        cs_active = 1;
-                }
+                        if (!cs_active) {
+                                omap2_mcspi_force_cs(spi, 1);
+                                cs_active = 1;
+                        }
 
-                chconf = mcspi_cached_chconf0(spi);
-                chconf &= ~OMAP2_MCSPI_CHCONF_TRM_MASK;
-                chconf &= ~OMAP2_MCSPI_CHCONF_TURBO;
+                        chconf = mcspi_cached_chconf0(spi);
+                        chconf &= ~OMAP2_MCSPI_CHCONF_TRM_MASK;
+                        chconf &= ~OMAP2_MCSPI_CHCONF_TURBO;
 
-                if (t->tx_buf == NULL)
-                        chconf |= OMAP2_MCSPI_CHCONF_TRM_RX_ONLY;
-                else if (t->rx_buf == NULL)
-                        chconf |= OMAP2_MCSPI_CHCONF_TRM_TX_ONLY;
+                        if (t->tx_buf == NULL)
+                                chconf |= OMAP2_MCSPI_CHCONF_TRM_RX_ONLY;
+                        else if (t->rx_buf == NULL)
+                                chconf |= OMAP2_MCSPI_CHCONF_TRM_TX_ONLY;
+
+                        if (cd && cd->turbo_mode && t->tx_buf == NULL) {
+                                /* Turbo mode is for more than one word */
+                                if (t->len > ((cs->word_len + 7) >> 3))
+                                        chconf |= OMAP2_MCSPI_CHCONF_TURBO;
+                        }
 
-                if (cd && cd->turbo_mode && t->tx_buf == NULL) {
-                        /* Turbo mode is for more than one word */
-                        if (t->len > ((cs->word_len + 7) >> 3))
-                                chconf |= OMAP2_MCSPI_CHCONF_TURBO;
-                }
+                        mcspi_write_chconf0(spi, chconf);
 
-                mcspi_write_chconf0(spi, chconf);
+                        if (t->len) {
+                                unsigned        count;
 
-                if (t->len) {
-                        unsigned        count;
+                                /* RX_ONLY mode needs dummy data in TX reg */
+                                if (t->tx_buf == NULL)
+                                        __raw_writel(0, cs->base
+                                                        + OMAP2_MCSPI_TX0);
 
-                        /* RX_ONLY mode needs dummy data in TX reg */
-                        if (t->tx_buf == NULL)
-                                __raw_writel(0, cs->base
-                                                + OMAP2_MCSPI_TX0);
+                                if (m->is_dma_mapped || t->len >= DMA_MIN_BYTES)
+                                        count = omap2_mcspi_txrx_dma(spi, t);
+                                else
+                                        count = omap2_mcspi_txrx_pio(spi, t);
+                                m->actual_length += count;
+
+                                if (count != t->len) {
+                                        status = -EIO;
+                                        break;
+                                }
+                        }
 
-                        if (m->is_dma_mapped || t->len >= DMA_MIN_BYTES)
-                                count = omap2_mcspi_txrx_dma(spi, t);
-                        else
-                                count = omap2_mcspi_txrx_pio(spi, t);
-                        m->actual_length += count;
+                        if (t->delay_usecs)
+                                udelay(t->delay_usecs);
 
-                        if (count != t->len) {
-                                status = -EIO;
-                                break;
+                        /* ignore the "leave it on after last xfer" hint */
+                        if (t->cs_change) {
+                                omap2_mcspi_force_cs(spi, 0);
+                                cs_active = 0;
                         }
                 }
 
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
+                /* Restore defaults if they were overriden */
+                if (par_override) {
+                        par_override = 0;
+                        status = omap2_mcspi_setup_transfer(spi, NULL);
+                }
 
-                /* ignore the "leave it on after last xfer" hint */
-                if (t->cs_change) {
+                if (cs_active)
                         omap2_mcspi_force_cs(spi, 0);
-                        cs_active = 0;
-                }
-        }
-        /* Restore defaults if they were overriden */
-        if (par_override) {
-                par_override = 0;
-                status = omap2_mcspi_setup_transfer(spi, NULL);
-        }
 
-        if (cs_active)
-                omap2_mcspi_force_cs(spi, 0);
+                omap2_mcspi_set_enable(spi, 0);
 
-        omap2_mcspi_set_enable(spi, 0);
+                m->status = status;
+                m->complete(m->context);
 
-        m->status = status;
+                spin_lock_irq(&mcspi->lock);
+        }
 
+        spin_unlock_irq(&mcspi->lock);
+
+        omap2_mcspi_disable_clocks(mcspi);
 }
 
-static int omap2_mcspi_transfer_one_message(struct spi_master *master,
-                                                struct spi_message *m)
+static int omap2_mcspi_transfer(struct spi_device *spi, struct spi_message *m)
 {
         struct omap2_mcspi      *mcspi;
+        unsigned long           flags;
         struct spi_transfer     *t;
 
-        mcspi = spi_master_get_devdata(master);
         m->actual_length = 0;
         m->status = 0;
 
         /* reject invalid messages and transfers */
-        if (list_empty(&m->transfers))
+        if (list_empty(&m->transfers) || !m->complete)
                 return -EINVAL;
         list_for_each_entry(t, &m->transfers, transfer_list) {
                 const void      *tx_buf = t->tx_buf;
@@ -1042,7 +998,7 @@ static int omap2_mcspi_transfer_one_message(struct spi_master *master,
                                 || (t->bits_per_word &&
                                         (  t->bits_per_word < 4
                                         || t->bits_per_word > 32))) {
-                        dev_dbg(mcspi->dev, "transfer: %d Hz, %d %s%s, %d bpw\n",
+                        dev_dbg(&spi->dev, "transfer: %d Hz, %d %s%s, %d bpw\n",
                                         t->speed_hz,
                                         len,
                                         tx_buf ? "tx" : "",
@@ -1051,7 +1007,7 @@ static int omap2_mcspi_transfer_one_message(struct spi_master *master,
                         return -EINVAL;
                 }
                 if (t->speed_hz && t->speed_hz < (OMAP2_MCSPI_MAX_FREQ >> 15)) {
-                        dev_dbg(mcspi->dev, "speed_hz %d below minimum %d Hz\n",
+                        dev_dbg(&spi->dev, "speed_hz %d below minimum %d Hz\n",
                                 t->speed_hz,
                                 OMAP2_MCSPI_MAX_FREQ >> 15);
                         return -EINVAL;
@@ -1061,50 +1017,54 @@ static int omap2_mcspi_transfer_one_message(struct spi_master *master,
                         continue;
 
                 if (tx_buf != NULL) {
-                        t->tx_dma = dma_map_single(mcspi->dev, (void *) tx_buf,
+                        t->tx_dma = dma_map_single(&spi->dev, (void *) tx_buf,
                                         len, DMA_TO_DEVICE);
-                        if (dma_mapping_error(mcspi->dev, t->tx_dma)) {
-                                dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
+                        if (dma_mapping_error(&spi->dev, t->tx_dma)) {
+                                dev_dbg(&spi->dev, "dma %cX %d bytes error\n",
                                                 'T', len);
                                 return -EINVAL;
                         }
                 }
                 if (rx_buf != NULL) {
-                        t->rx_dma = dma_map_single(mcspi->dev, rx_buf, t->len,
+                        t->rx_dma = dma_map_single(&spi->dev, rx_buf, t->len,
                                         DMA_FROM_DEVICE);
-                        if (dma_mapping_error(mcspi->dev, t->rx_dma)) {
-                                dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
+                        if (dma_mapping_error(&spi->dev, t->rx_dma)) {
+                                dev_dbg(&spi->dev, "dma %cX %d bytes error\n",
                                                 'R', len);
                                 if (tx_buf != NULL)
-                                        dma_unmap_single(mcspi->dev, t->tx_dma,
+                                        dma_unmap_single(&spi->dev, t->tx_dma,
                                                         len, DMA_TO_DEVICE);
                                 return -EINVAL;
                         }
                 }
         }
 
-        omap2_mcspi_work(mcspi, m);
-        spi_finalize_current_message(master);
+        mcspi = spi_master_get_devdata(spi->master);
+
+        spin_lock_irqsave(&mcspi->lock, flags);
+        list_add_tail(&m->queue, &mcspi->msg_queue);
+        queue_work(omap2_mcspi_wq, &mcspi->work);
+        spin_unlock_irqrestore(&mcspi->lock, flags);
+
         return 0;
 }
 
-static int omap2_mcspi_master_setup(struct omap2_mcspi *mcspi)
+static int __init omap2_mcspi_master_setup(struct omap2_mcspi *mcspi)
 {
         struct spi_master       *master = mcspi->master;
-        struct omap2_mcspi_regs *ctx = &mcspi->ctx;
-        int                     ret = 0;
+        u32                     tmp;
+        int ret = 0;
 
-        ret = pm_runtime_get_sync(mcspi->dev);
+        ret = omap2_mcspi_enable_clocks(mcspi);
         if (ret < 0)
                 return ret;
 
-        mcspi_write_reg(master, OMAP2_MCSPI_WAKEUPENABLE,
-                                OMAP2_MCSPI_WAKEUPENABLE_WKEN);
-        ctx->wakeupenable = OMAP2_MCSPI_WAKEUPENABLE_WKEN;
+        tmp = OMAP2_MCSPI_WAKEUPENABLE_WKEN;
+        mcspi_write_reg(master, OMAP2_MCSPI_WAKEUPENABLE, tmp);
+        omap2_mcspi_ctx[master->bus_num - 1].wakeupenable = tmp;
 
         omap2_mcspi_set_master_mode(master);
-        pm_runtime_mark_last_busy(mcspi->dev);
-        pm_runtime_put_autosuspend(mcspi->dev);
+        omap2_mcspi_disable_clocks(mcspi);
         return 0;
 }
 
@@ -1120,39 +1080,14 @@ static int omap_mcspi_runtime_resume(struct device *dev)
         return 0;
 }
 
-static struct omap2_mcspi_platform_config omap2_pdata = {
-        .regs_offset = 0,
-};
-
-static struct omap2_mcspi_platform_config omap4_pdata = {
-        .regs_offset = OMAP4_MCSPI_REG_OFFSET,
-};
-
-static const struct of_device_id omap_mcspi_of_match[] = {
-        {
-                .compatible = "ti,omap2-mcspi",
-                .data = &omap2_pdata,
-        },
-        {
-                .compatible = "ti,omap4-mcspi",
-                .data = &omap4_pdata,
-        },
-        { },
-};
-MODULE_DEVICE_TABLE(of, omap_mcspi_of_match);
 
-static int omap2_mcspi_probe(struct platform_device *pdev)
+static int __init omap2_mcspi_probe(struct platform_device *pdev)
 {
         struct spi_master       *master;
-        const struct omap2_mcspi_platform_config *pdata;
+        struct omap2_mcspi_platform_config *pdata = pdev->dev.platform_data;
         struct omap2_mcspi      *mcspi;
         struct resource         *r;
         int                     status = 0, i;
-        u32                     regs_offset = 0;
-        static int              bus_num = 1;
-        struct device_node      *node = pdev->dev.of_node;
-        const struct of_device_id *match;
-        struct pinctrl *pinctrl;
 
         master = spi_alloc_master(&pdev->dev, sizeof *mcspi);
         if (master == NULL) {
@@ -1163,64 +1098,54 @@ static int omap2_mcspi_probe(struct platform_device *pdev)
         /* the spi->mode bits understood by this driver: */
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 
+        if (pdev->id != -1)
+                master->bus_num = pdev->id;
+
         master->setup = omap2_mcspi_setup;
-        master->prepare_transfer_hardware = omap2_prepare_transfer;
-        master->unprepare_transfer_hardware = omap2_unprepare_transfer;
-        master->transfer_one_message = omap2_mcspi_transfer_one_message;
+        master->transfer = omap2_mcspi_transfer;
         master->cleanup = omap2_mcspi_cleanup;
-        master->dev.of_node = node;
+        master->num_chipselect = pdata->num_cs;
 
         dev_set_drvdata(&pdev->dev, master);
 
         mcspi = spi_master_get_devdata(master);
         mcspi->master = master;
 
-        match = of_match_device(omap_mcspi_of_match, &pdev->dev);
-        if (match) {
-                u32 num_cs = 1; /* default number of chipselect */
-                pdata = match->data;
-
-                of_property_read_u32(node, "ti,spi-num-cs", &num_cs);
-                master->num_chipselect = num_cs;
-                master->bus_num = bus_num++;
-                if (of_get_property(node, "ti,pindir-d0-out-d1-in", NULL))
-                        mcspi->pin_dir = MCSPI_PINDIR_D0_OUT_D1_IN;
-        } else {
-                pdata = pdev->dev.platform_data;
-                master->num_chipselect = pdata->num_cs;
-                if (pdev->id != -1)
-                        master->bus_num = pdev->id;
-                mcspi->pin_dir = pdata->pin_dir;
-        }
-        regs_offset = pdata->regs_offset;
-
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (r == NULL) {
                 status = -ENODEV;
-                goto free_master;
+                goto err1;
         }
 
-        r->start += regs_offset;
-        r->end += regs_offset;
+        r->start += pdata->regs_offset;
+        r->end += pdata->regs_offset;
         mcspi->phys = r->start;
+        if (!request_mem_region(r->start, resource_size(r),
+                                dev_name(&pdev->dev))) {
+                status = -EBUSY;
+                goto err1;
+        }
 
-        mcspi->base = devm_request_and_ioremap(&pdev->dev, r);
+        mcspi->base = ioremap(r->start, resource_size(r));
         if (!mcspi->base) {
                 dev_dbg(&pdev->dev, "can't ioremap MCSPI\n");
                 status = -ENOMEM;
-                goto free_master;
+                goto err2;
         }
 
         mcspi->dev = &pdev->dev;
+        INIT_WORK(&mcspi->work, omap2_mcspi_work);
 
-        INIT_LIST_HEAD(&mcspi->ctx.cs);
+        spin_lock_init(&mcspi->lock);
+        INIT_LIST_HEAD(&mcspi->msg_queue);
+        INIT_LIST_HEAD(&omap2_mcspi_ctx[master->bus_num - 1].cs);
 
         mcspi->dma_channels = kcalloc(master->num_chipselect,
                         sizeof(struct omap2_mcspi_dma),
                         GFP_KERNEL);
 
         if (mcspi->dma_channels == NULL)
-                goto free_master;
+                goto err2;
 
         for (i = 0; i < master->num_chipselect; i++) {
                 char dma_ch_name[14];
@@ -1235,6 +1160,7 @@ static int omap2_mcspi_probe(struct platform_device *pdev)
                         break;
                 }
 
+                mcspi->dma_channels[i].dma_rx_channel = -1;
                 mcspi->dma_channels[i].dma_rx_sync_dev = dma_res->start;
                 sprintf(dma_ch_name, "tx%d", i);
                 dma_res = platform_get_resource_byname(pdev, IORESOURCE_DMA,
@@ -1245,53 +1171,51 @@ static int omap2_mcspi_probe(struct platform_device *pdev)
                         break;
                 }
 
+                mcspi->dma_channels[i].dma_tx_channel = -1;
                 mcspi->dma_channels[i].dma_tx_sync_dev = dma_res->start;
         }
 
-        if (status < 0)
-                goto dma_chnl_free;
-
-        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
-        if (IS_ERR(pinctrl))
-                dev_warn(&pdev->dev,
-                        "pins are not configured from the driver\n");
-
-        pm_runtime_use_autosuspend(&pdev->dev);
-        pm_runtime_set_autosuspend_delay(&pdev->dev, SPI_AUTOSUSPEND_TIMEOUT);
         pm_runtime_enable(&pdev->dev);
 
         if (status || omap2_mcspi_master_setup(mcspi) < 0)
-                goto disable_pm;
+                goto err3;
 
         status = spi_register_master(master);
         if (status < 0)
-                goto disable_pm;
+                goto err4;
 
         return status;
 
-disable_pm:
-        pm_runtime_disable(&pdev->dev);
-dma_chnl_free:
-        kfree(mcspi->dma_channels);
-free_master:
+err4:
         spi_master_put(master);
+err3:
+        kfree(mcspi->dma_channels);
+err2:
+        release_mem_region(r->start, resource_size(r));
+        iounmap(mcspi->base);
+err1:
         return status;
 }
 
-static int omap2_mcspi_remove(struct platform_device *pdev)
+static int __exit omap2_mcspi_remove(struct platform_device *pdev)
 {
         struct spi_master       *master;
         struct omap2_mcspi      *mcspi;
         struct omap2_mcspi_dma  *dma_channels;
+        struct resource         *r;
+        void __iomem *base;
 
         master = dev_get_drvdata(&pdev->dev);
         mcspi = spi_master_get_devdata(master);
         dma_channels = mcspi->dma_channels;
 
-        pm_runtime_put_sync(mcspi->dev);
-        pm_runtime_disable(&pdev->dev);
+        omap2_mcspi_disable_clocks(mcspi);
+        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        release_mem_region(r->start, resource_size(r));
 
+        base = mcspi->base;
         spi_unregister_master(master);
+        iounmap(base);
         kfree(dma_channels);
 
         return 0;
@@ -1310,24 +1234,24 @@ static int omap2_mcspi_resume(struct device *dev)
 {
         struct spi_master       *master = dev_get_drvdata(dev);
         struct omap2_mcspi      *mcspi = spi_master_get_devdata(master);
-        struct omap2_mcspi_regs *ctx = &mcspi->ctx;
-        struct omap2_mcspi_cs   *cs;
+        struct omap2_mcspi_cs *cs;
 
-        pm_runtime_get_sync(mcspi->dev);
-        list_for_each_entry(cs, &ctx->cs, node) {
+        omap2_mcspi_enable_clocks(mcspi);
+        list_for_each_entry(cs, &omap2_mcspi_ctx[master->bus_num - 1].cs,
+                            node) {
                 if ((cs->chconf0 & OMAP2_MCSPI_CHCONF_FORCE) == 0) {
+
                         /*
                          * We need to toggle CS state for OMAP take this
                          * change in account.
                          */
-                        cs->chconf0 |= OMAP2_MCSPI_CHCONF_FORCE;
+                        MOD_REG_BIT(cs->chconf0, OMAP2_MCSPI_CHCONF_FORCE, 1);
                         __raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
-                        cs->chconf0 &= ~OMAP2_MCSPI_CHCONF_FORCE;
+                        MOD_REG_BIT(cs->chconf0, OMAP2_MCSPI_CHCONF_FORCE, 0);
                         __raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
                 }
         }
-        pm_runtime_mark_last_busy(mcspi->dev);
-        pm_runtime_put_autosuspend(mcspi->dev);
+        omap2_mcspi_disable_clocks(mcspi);
         return 0;
 }
 #else
@@ -1343,12 +1267,28 @@ static struct platform_driver omap2_mcspi_driver = {
         .driver = {
                 .name =         "omap2_mcspi",
                 .owner =        THIS_MODULE,
-                .pm =           &omap2_mcspi_pm_ops,
-                .of_match_table = omap_mcspi_of_match,
+                .pm =           &omap2_mcspi_pm_ops
         },
-        .probe =        omap2_mcspi_probe,
-        .remove =       omap2_mcspi_remove,
+        .remove =       __exit_p(omap2_mcspi_remove),
 };
 
-module_platform_driver(omap2_mcspi_driver);
+
+static int __init omap2_mcspi_init(void)
+{
+        omap2_mcspi_wq = create_singlethread_workqueue(
+                                omap2_mcspi_driver.driver.name);
+        if (omap2_mcspi_wq == NULL)
+                return -1;
+        return platform_driver_probe(&omap2_mcspi_driver, omap2_mcspi_probe);
+}
+subsys_initcall(omap2_mcspi_init);
+
+static void __exit omap2_mcspi_exit(void)
+{
+        platform_driver_unregister(&omap2_mcspi_driver);
+
+        destroy_workqueue(omap2_mcspi_wq);
+}
+module_exit(omap2_mcspi_exit);
+
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-orion.c b/drivers/spi/spi-orion.c
index b7e718254b1..9421a390a5e 100644
--- a/drivers/spi/spi-orion.c
+++ b/drivers/spi/spi-orion.c
@@ -16,9 +16,7 @@
 #include <linux/err.h>
 #include <linux/io.h>
 #include <linux/spi/spi.h>
-#include <linux/module.h>
-#include <linux/of.h>
-#include <linux/clk.h>
+#include <linux/spi/orion_spi.h>
 #include <asm/unaligned.h>
 
 #define DRIVER_NAME                     "orion_spi"
@@ -32,21 +30,25 @@
 #define ORION_SPI_DATA_IN_REG           0x0c
 #define ORION_SPI_INT_CAUSE_REG         0x10
 
-#define ORION_SPI_MODE_CPOL             (1 << 11)
-#define ORION_SPI_MODE_CPHA             (1 << 12)
 #define ORION_SPI_IF_8_16_BIT_MODE      (1 << 5)
 #define ORION_SPI_CLK_PRESCALE_MASK     0x1F
-#define ORION_SPI_MODE_MASK             (ORION_SPI_MODE_CPOL | \
-                                         ORION_SPI_MODE_CPHA)
 
 struct orion_spi {
+        struct work_struct      work;
+
+        /* Lock access to transfer list.        */
+        spinlock_t              lock;
+
+        struct list_head        msg_queue;
         struct spi_master       *master;
         void __iomem            *base;
         unsigned int            max_speed;
         unsigned int            min_speed;
-        struct clk              *clk;
+        struct orion_spi_info   *spi_info;
 };
 
+static struct workqueue_struct *orion_spi_wq;
+
 static inline void __iomem *spi_reg(struct orion_spi *orion_spi, u32 reg)
 {
         return orion_spi->base + reg;
@@ -101,7 +103,7 @@ static int orion_spi_baudrate_set(struct spi_device *spi, unsigned int speed)
 
         orion_spi = spi_master_get_devdata(spi->master);
 
-        tclk_hz = clk_get_rate(orion_spi->clk);
+        tclk_hz = orion_spi->spi_info->tclk;
 
         /*
          * the supported rates are: 4,6,8...30
@@ -127,23 +129,6 @@ static int orion_spi_baudrate_set(struct spi_device *spi, unsigned int speed)
         return 0;
 }
 
-static void
-orion_spi_mode_set(struct spi_device *spi)
-{
-        u32 reg;
-        struct orion_spi *orion_spi;
-
-        orion_spi = spi_master_get_devdata(spi->master);
-
-        reg = readl(spi_reg(orion_spi, ORION_SPI_IF_CONFIG_REG));
-        reg &= ~ORION_SPI_MODE_MASK;
-        if (spi->mode & SPI_CPOL)
-                reg |= ORION_SPI_MODE_CPOL;
-        if (spi->mode & SPI_CPHA)
-                reg |= ORION_SPI_MODE_CPHA;
-        writel(reg, spi_reg(orion_spi, ORION_SPI_IF_CONFIG_REG));
-}
-
 /*
  * called only when no transfer is active on the bus
  */
@@ -163,8 +148,6 @@ orion_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         if ((t != NULL) && t->bits_per_word)
                 bits_per_word = t->bits_per_word;
 
-        orion_spi_mode_set(spi);
-
         rc = orion_spi_baudrate_set(spi, speed);
         if (rc)
                 return rc;
@@ -292,78 +275,73 @@ out:
 }
 
 
-static int orion_spi_transfer_one_message(struct spi_master *master,
-                                           struct spi_message *m)
+static void orion_spi_work(struct work_struct *work)
 {
-        struct orion_spi *orion_spi = spi_master_get_devdata(master);
-        struct spi_device *spi = m->spi;
-        struct spi_transfer *t = NULL;
-        int par_override = 0;
-        int status = 0;
-        int cs_active = 0;
+        struct orion_spi *orion_spi =
+                container_of(work, struct orion_spi, work);
 
-        /* Load defaults */
-        status = orion_spi_setup_transfer(spi, NULL);
+        spin_lock_irq(&orion_spi->lock);
+        while (!list_empty(&orion_spi->msg_queue)) {
+                struct spi_message *m;
+                struct spi_device *spi;
+                struct spi_transfer *t = NULL;
+                int par_override = 0;
+                int status = 0;
+                int cs_active = 0;
 
-        if (status < 0)
-                goto msg_done;
+                m = container_of(orion_spi->msg_queue.next, struct spi_message,
+                                 queue);
 
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                /* make sure buffer length is even when working in 16
-                 * bit mode*/
-                if ((t->bits_per_word == 16) && (t->len & 1)) {
-                        dev_err(&spi->dev,
-                                "message rejected : "
-                                "odd data length %d while in 16 bit mode\n",
-                                t->len);
-                        status = -EIO;
-                        goto msg_done;
-                }
+                list_del_init(&m->queue);
+                spin_unlock_irq(&orion_spi->lock);
 
-                if (t->speed_hz && t->speed_hz < orion_spi->min_speed) {
-                        dev_err(&spi->dev,
-                                "message rejected : "
-                                "device min speed (%d Hz) exceeds "
-                                "required transfer speed (%d Hz)\n",
-                                orion_spi->min_speed, t->speed_hz);
-                        status = -EIO;
-                        goto msg_done;
-                }
+                spi = m->spi;
 
-                if (par_override || t->speed_hz || t->bits_per_word) {
-                        par_override = 1;
-                        status = orion_spi_setup_transfer(spi, t);
-                        if (status < 0)
-                                break;
-                        if (!t->speed_hz && !t->bits_per_word)
-                                par_override = 0;
-                }
+                /* Load defaults */
+                status = orion_spi_setup_transfer(spi, NULL);
 
-                if (!cs_active) {
-                        orion_spi_set_cs(orion_spi, 1);
-                        cs_active = 1;
-                }
-
-                if (t->len)
-                        m->actual_length += orion_spi_write_read(spi, t);
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
+                if (status < 0)
+                        goto msg_done;
 
-                if (t->cs_change) {
-                        orion_spi_set_cs(orion_spi, 0);
-                        cs_active = 0;
+                list_for_each_entry(t, &m->transfers, transfer_list) {
+                        if (par_override || t->speed_hz || t->bits_per_word) {
+                                par_override = 1;
+                                status = orion_spi_setup_transfer(spi, t);
+                                if (status < 0)
+                                        break;
+                                if (!t->speed_hz && !t->bits_per_word)
+                                        par_override = 0;
+                        }
+
+                        if (!cs_active) {
+                                orion_spi_set_cs(orion_spi, 1);
+                                cs_active = 1;
+                        }
+
+                        if (t->len)
+                                m->actual_length +=
+                                        orion_spi_write_read(spi, t);
+
+                        if (t->delay_usecs)
+                                udelay(t->delay_usecs);
+
+                        if (t->cs_change) {
+                                orion_spi_set_cs(orion_spi, 0);
+                                cs_active = 0;
+                        }
                 }
-        }
 
 msg_done:
-        if (cs_active)
-                orion_spi_set_cs(orion_spi, 0);
+                if (cs_active)
+                        orion_spi_set_cs(orion_spi, 0);
 
-        m->status = status;
-        spi_finalize_current_message(master);
+                m->status = status;
+                m->complete(m->context);
 
-        return 0;
+                spin_lock_irq(&orion_spi->lock);
+        }
+
+        spin_unlock_irq(&orion_spi->lock);
 }
 
 static int __init orion_spi_reset(struct orion_spi *orion_spi)
@@ -380,6 +358,11 @@ static int orion_spi_setup(struct spi_device *spi)
 
         orion_spi = spi_master_get_devdata(spi->master);
 
+        /* Fix ac timing if required.   */
+        if (orion_spi->spi_info->enable_clock_fix)
+                orion_spi_setbits(orion_spi, ORION_SPI_IF_CONFIG_REG,
+                                  (1 << 14));
+
         if ((spi->max_speed_hz == 0)
                         || (spi->max_speed_hz > orion_spi->max_speed))
                 spi->max_speed_hz = orion_spi->max_speed;
@@ -396,15 +379,84 @@ static int orion_spi_setup(struct spi_device *spi)
         return 0;
 }
 
+static int orion_spi_transfer(struct spi_device *spi, struct spi_message *m)
+{
+        struct orion_spi *orion_spi;
+        struct spi_transfer *t = NULL;
+        unsigned long flags;
+
+        m->actual_length = 0;
+        m->status = 0;
+
+        /* reject invalid messages and transfers */
+        if (list_empty(&m->transfers) || !m->complete)
+                return -EINVAL;
+
+        orion_spi = spi_master_get_devdata(spi->master);
+
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                unsigned int bits_per_word = spi->bits_per_word;
+
+                if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "invalid transfer data buffers\n");
+                        goto msg_rejected;
+                }
+
+                if (t->bits_per_word)
+                        bits_per_word = t->bits_per_word;
+
+                if ((bits_per_word != 8) && (bits_per_word != 16)) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "invalid transfer bits_per_word (%d bits)\n",
+                                bits_per_word);
+                        goto msg_rejected;
+                }
+                /*make sure buffer length is even when working in 16 bit mode*/
+                if ((t->bits_per_word == 16) && (t->len & 1)) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "odd data length (%d) while in 16 bit mode\n",
+                                t->len);
+                        goto msg_rejected;
+                }
+
+                if (t->speed_hz && t->speed_hz < orion_spi->min_speed) {
+                        dev_err(&spi->dev,
+                                "message rejected : "
+                                "device min speed (%d Hz) exceeds "
+                                "required transfer speed (%d Hz)\n",
+                                orion_spi->min_speed, t->speed_hz);
+                        goto msg_rejected;
+                }
+        }
+
+
+        spin_lock_irqsave(&orion_spi->lock, flags);
+        list_add_tail(&m->queue, &orion_spi->msg_queue);
+        queue_work(orion_spi_wq, &orion_spi->work);
+        spin_unlock_irqrestore(&orion_spi->lock, flags);
+
+        return 0;
+msg_rejected:
+        /* Message rejected and not queued */
+        m->status = -EINVAL;
+        if (m->complete)
+                m->complete(m->context);
+        return -EINVAL;
+}
+
 static int __init orion_spi_probe(struct platform_device *pdev)
 {
         struct spi_master *master;
         struct orion_spi *spi;
         struct resource *r;
-        unsigned long tclk_hz;
+        struct orion_spi_info *spi_info;
         int status = 0;
-        const u32 *iprop;
-        int size;
+
+        spi_info = pdev->dev.platform_data;
 
         master = spi_alloc_master(&pdev->dev, sizeof *spi);
         if (master == NULL) {
@@ -414,54 +466,44 @@ static int __init orion_spi_probe(struct platform_device *pdev)
 
         if (pdev->id != -1)
                 master->bus_num = pdev->id;
-        if (pdev->dev.of_node) {
-                iprop = of_get_property(pdev->dev.of_node, "cell-index",
-                                        &size);
-                if (iprop && size == sizeof(*iprop))
-                        master->bus_num = *iprop;
-        }
 
         /* we support only mode 0, and no options */
-        master->mode_bits = SPI_CPHA | SPI_CPOL;
+        master->mode_bits = 0;
 
         master->setup = orion_spi_setup;
-        master->transfer_one_message = orion_spi_transfer_one_message;
+        master->transfer = orion_spi_transfer;
         master->num_chipselect = ORION_NUM_CHIPSELECTS;
 
         dev_set_drvdata(&pdev->dev, master);
 
         spi = spi_master_get_devdata(master);
         spi->master = master;
+        spi->spi_info = spi_info;
 
-        spi->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(spi->clk)) {
-                status = PTR_ERR(spi->clk);
-                goto out;
-        }
-
-        clk_prepare(spi->clk);
-        clk_enable(spi->clk);
-        tclk_hz = clk_get_rate(spi->clk);
-        spi->max_speed = DIV_ROUND_UP(tclk_hz, 4);
-        spi->min_speed = DIV_ROUND_UP(tclk_hz, 30);
+        spi->max_speed = DIV_ROUND_UP(spi_info->tclk, 4);
+        spi->min_speed = DIV_ROUND_UP(spi_info->tclk, 30);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (r == NULL) {
                 status = -ENODEV;
-                goto out_rel_clk;
+                goto out;
         }
 
         if (!request_mem_region(r->start, resource_size(r),
                                 dev_name(&pdev->dev))) {
                 status = -EBUSY;
-                goto out_rel_clk;
+                goto out;
         }
         spi->base = ioremap(r->start, SZ_1K);
 
+        INIT_WORK(&spi->work, orion_spi_work);
+
+        spin_lock_init(&spi->lock);
+        INIT_LIST_HEAD(&spi->msg_queue);
+
         if (orion_spi_reset(spi) < 0)
                 goto out_rel_mem;
 
-        master->dev.of_node = pdev->dev.of_node;
         status = spi_register_master(master);
         if (status < 0)
                 goto out_rel_mem;
@@ -470,9 +512,7 @@ static int __init orion_spi_probe(struct platform_device *pdev)
 
 out_rel_mem:
         release_mem_region(r->start, resource_size(r));
-out_rel_clk:
-        clk_disable_unprepare(spi->clk);
-        clk_put(spi->clk);
+
 out:
         spi_master_put(master);
         return status;
@@ -482,14 +522,13 @@ out:
 static int __exit orion_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master;
-        struct resource *r;
         struct orion_spi *spi;
+        struct resource *r;
 
         master = dev_get_drvdata(&pdev->dev);
         spi = spi_master_get_devdata(master);
 
-        clk_disable_unprepare(spi->clk);
-        clk_put(spi->clk);
+        cancel_work_sync(&spi->work);
 
         r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         release_mem_region(r->start, resource_size(r));
@@ -501,30 +540,31 @@ static int __exit orion_spi_remove(struct platform_device *pdev)
 
 MODULE_ALIAS("platform:" DRIVER_NAME);
 
-static const struct of_device_id orion_spi_of_match_table[] = {
-        { .compatible = "marvell,orion-spi", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, orion_spi_of_match_table);
-
 static struct platform_driver orion_spi_driver = {
         .driver = {
                 .name   = DRIVER_NAME,
                 .owner  = THIS_MODULE,
-                .of_match_table = of_match_ptr(orion_spi_of_match_table),
         },
         .remove         = __exit_p(orion_spi_remove),
 };
 
 static int __init orion_spi_init(void)
 {
+        orion_spi_wq = create_singlethread_workqueue(
+                                orion_spi_driver.driver.name);
+        if (orion_spi_wq == NULL)
+                return -ENOMEM;
+
         return platform_driver_probe(&orion_spi_driver, orion_spi_probe);
 }
 module_init(orion_spi_init);
 
 static void __exit orion_spi_exit(void)
 {
+        flush_workqueue(orion_spi_wq);
         platform_driver_unregister(&orion_spi_driver);
+
+        destroy_workqueue(orion_spi_wq);
 }
 module_exit(orion_spi_exit);
 
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index b0fe393c882..730b4a37b82 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -1,7 +1,7 @@
 /*
  * A driver for the ARM PL022 PrimeCell SSP/SPI bus master.
  *
- * Copyright (C) 2008-2012 ST-Ericsson AB
+ * Copyright (C) 2008-2009 ST-Ericsson AB
  * Copyright (C) 2006 STMicroelectronics Pvt. Ltd.
  *
  * Author: Linus Walleij <linus.walleij@stericsson.com>
@@ -29,6 +29,7 @@
 #include <linux/errno.h>
 #include <linux/interrupt.h>
 #include <linux/spi/spi.h>
+#include <linux/workqueue.h>
 #include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/err.h>
@@ -40,9 +41,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/scatterlist.h>
 #include <linux/pm_runtime.h>
-#include <linux/gpio.h>
-#include <linux/of_gpio.h>
-#include <linux/pinctrl/consumer.h>
 
 /*
  * This macro is used to define some register default values.
@@ -115,6 +113,7 @@
 #define SSP_CR0_MASK_CSS_ST     (0x1FUL << 16)
 #define SSP_CR0_MASK_FRF_ST     (0x3UL << 21)
 
+
 /*
  * SSP Control Register 0  - SSP_CR1
  */
@@ -284,6 +283,7 @@
 
 #define SPI_POLLING_TIMEOUT 1000
 
+
 /*
  * The type of reading going on on this chip
  */
@@ -332,21 +332,16 @@ struct vendor_data {
  * @clk: outgoing clock "SPICLK" for the SPI bus
  * @master: SPI framework hookup
  * @master_info: controller-specific data from machine setup
- * @kworker: thread struct for message pump
- * @kworker_task: pointer to task for message pump kworker thread
- * @pump_messages: work struct for scheduling work to the message pump
+ * @workqueue: a workqueue on which any spi_message request is queued
+ * @pump_messages: work struct for scheduling work to the workqueue
  * @queue_lock: spinlock to syncronise access to message queue
  * @queue: message queue
- * @busy: message pump is busy
- * @running: message pump is running
+ * @busy: workqueue is busy
+ * @running: workqueue is running
  * @pump_transfers: Tasklet used in Interrupt Transfer mode
  * @cur_msg: Pointer to current spi_message being processed
  * @cur_transfer: Pointer to current spi_transfer
  * @cur_chip: pointer to current clients chip(assigned from controller_state)
- * @next_msg_cs_active: the next message in the queue has been examined
- *  and it was found that it uses the same chip select as the previous
- *  message, so we left it active after the previous transfer, and it's
- *  active already.
  * @tx: current position in TX buffer to be read
  * @tx_end: end position in TX buffer to be read
  * @rx: current position in RX buffer to be written
@@ -359,8 +354,6 @@ struct vendor_data {
  * @sgt_rx: scattertable for the RX transfer
  * @sgt_tx: scattertable for the TX transfer
  * @dummypage: a dummy page used for driving data on the bus with DMA
- * @cur_cs: current chip select (gpio)
- * @chipselects: list of chipselects (gpios)
  */
 struct pl022 {
         struct amba_device              *adev;
@@ -368,19 +361,20 @@ struct pl022 {
         resource_size_t                 phybase;
         void __iomem                    *virtbase;
         struct clk                      *clk;
-        /* Two optional pin states - default & sleep */
-        struct pinctrl                  *pinctrl;
-        struct pinctrl_state            *pins_default;
-        struct pinctrl_state            *pins_idle;
-        struct pinctrl_state            *pins_sleep;
         struct spi_master               *master;
         struct pl022_ssp_controller     *master_info;
-        /* Message per-transfer pump */
+        /* Driver message queue */
+        struct workqueue_struct         *workqueue;
+        struct work_struct              pump_messages;
+        spinlock_t                      queue_lock;
+        struct list_head                queue;
+        bool                            busy;
+        bool                            running;
+        /* Message transfer pump */
         struct tasklet_struct           pump_transfers;
         struct spi_message              *cur_msg;
         struct spi_transfer             *cur_transfer;
         struct chip_data                *cur_chip;
-        bool                            next_msg_cs_active;
         void                            *tx;
         void                            *tx_end;
         void                            *rx;
@@ -397,10 +391,7 @@ struct pl022 {
         struct sg_table                 sgt_rx;
         struct sg_table                 sgt_tx;
         char                            *dummypage;
-        bool                            dma_running;
 #endif
-        int cur_cs;
-        int *chipselects;
 };
 
 /**
@@ -445,14 +436,6 @@ static void null_cs_control(u32 command)
         pr_debug("pl022: dummy chip select control, CS=0x%x\n", command);
 }
 
-static void pl022_cs_control(struct pl022 *pl022, u32 command)
-{
-        if (gpio_is_valid(pl022->cur_cs))
-                gpio_set_value(pl022->cur_cs, command);
-        else
-                pl022->cur_chip->cs_control(command);
-}
-
 /**
  * giveback - current spi_message is over, schedule next message and call
  * callback of this message. Assumes that caller already
@@ -462,9 +445,25 @@ static void pl022_cs_control(struct pl022 *pl022, u32 command)
 static void giveback(struct pl022 *pl022)
 {
         struct spi_transfer *last_transfer;
-        pl022->next_msg_cs_active = false;
+        unsigned long flags;
+        struct spi_message *msg;
+        void (*curr_cs_control) (u32 command);
+
+        /*
+         * This local reference to the chip select function
+         * is needed because we set curr_chip to NULL
+         * as a step toward termininating the message.
+         */
+        curr_cs_control = pl022->cur_chip->cs_control;
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+        msg = pl022->cur_msg;
+        pl022->cur_msg = NULL;
+        pl022->cur_transfer = NULL;
+        pl022->cur_chip = NULL;
+        queue_work(pl022->workqueue, &pl022->pump_messages);
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
-        last_transfer = list_entry(pl022->cur_msg->transfers.prev,
+        last_transfer = list_entry(msg->transfers.prev,
                                         struct spi_transfer,
                                         transfer_list);
 
@@ -476,44 +475,50 @@ static void giveback(struct pl022 *pl022)
                  */
                 udelay(last_transfer->delay_usecs);
 
-        if (!last_transfer->cs_change) {
+        /*
+         * Drop chip select UNLESS cs_change is true or we are returning
+         * a message with an error, or next message is for another chip
+         */
+        if (!last_transfer->cs_change)
+                curr_cs_control(SSP_CHIP_DESELECT);
+        else {
                 struct spi_message *next_msg;
 
-                /*
-                 * cs_change was not set. We can keep the chip select
-                 * enabled if there is message in the queue and it is
-                 * for the same spi device.
+                /* Holding of cs was hinted, but we need to make sure
+                 * the next message is for the same chip.  Don't waste
+                 * time with the following tests unless this was hinted.
                  *
                  * We cannot postpone this until pump_messages, because
                  * after calling msg->complete (below) the driver that
                  * sent the current message could be unloaded, which
                  * could invalidate the cs_control() callback...
                  */
-                /* get a pointer to the next message, if any */
-                next_msg = spi_get_next_queued_message(pl022->master);
 
-                /*
-                 * see if the next and current messages point
-                 * to the same spi device.
-                 */
-                if (next_msg && next_msg->spi != pl022->cur_msg->spi)
+                /* get a pointer to the next message, if any */
+                spin_lock_irqsave(&pl022->queue_lock, flags);
+                if (list_empty(&pl022->queue))
                         next_msg = NULL;
-                if (!next_msg || pl022->cur_msg->state == STATE_ERROR)
-                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
                 else
-                        pl022->next_msg_cs_active = true;
+                        next_msg = list_entry(pl022->queue.next,
+                                        struct spi_message, queue);
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
+                /* see if the next and current messages point
+                 * to the same chip
+                 */
+                if (next_msg && next_msg->spi != msg->spi)
+                        next_msg = NULL;
+                if (!next_msg || msg->state == STATE_ERROR)
+                        curr_cs_control(SSP_CHIP_DESELECT);
         }
-
-        pl022->cur_msg = NULL;
-        pl022->cur_transfer = NULL;
-        pl022->cur_chip = NULL;
-        spi_finalize_current_message(pl022->master);
-
-        /* disable the SPI/SSP operation */
-        writew((readw(SSP_CR1(pl022->virtbase)) &
-                (~SSP_CR1_MASK_SSE)), SSP_CR1(pl022->virtbase));
-
+        msg->state = NULL;
+        if (msg->complete)
+                msg->complete(msg->context);
+        /* This message is completed, so let's turn off the clocks & power */
+        clk_disable(pl022->clk);
+        amba_pclk_disable(pl022->adev);
+        amba_vcore_disable(pl022->adev);
+        pm_runtime_put(&pl022->adev->dev);
 }
 
 /**
@@ -747,6 +752,7 @@ static void readwriter(struct pl022 *pl022)
          */
 }
 
+
 /**
  * next_transfer - Move to the Next transfer in the current spi message
  * @pl022: SSP driver private data structure
@@ -838,7 +844,8 @@ static void dma_callback(void *data)
         /* Update total bytes transferred */
         msg->actual_length += pl022->cur_transfer->len;
         if (pl022->cur_transfer->cs_change)
-                pl022_cs_control(pl022, SSP_CHIP_DESELECT);
+                pl022->cur_chip->
+                        cs_control(SSP_CHIP_DESELECT);
 
         /* Move to next transfer */
         msg->state = next_transfer(pl022);
@@ -903,13 +910,11 @@ static int configure_dma(struct pl022 *pl022)
 {
         struct dma_slave_config rx_conf = {
                 .src_addr = SSP_DR(pl022->phybase),
-                .direction = DMA_DEV_TO_MEM,
-                .device_fc = false,
+                .direction = DMA_FROM_DEVICE,
         };
         struct dma_slave_config tx_conf = {
                 .dst_addr = SSP_DR(pl022->phybase),
-                .direction = DMA_MEM_TO_DEV,
-                .device_fc = false,
+                .direction = DMA_TO_DEVICE,
         };
         unsigned int pages;
         int ret;
@@ -1014,14 +1019,14 @@ static int configure_dma(struct pl022 *pl022)
         dmaengine_slave_config(txchan, &tx_conf);
 
         /* Create sglists for the transfers */
-        pages = DIV_ROUND_UP(pl022->cur_transfer->len, PAGE_SIZE);
+        pages = (pl022->cur_transfer->len >> PAGE_SHIFT) + 1;
         dev_dbg(&pl022->adev->dev, "using %d pages for transfer\n", pages);
 
-        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_ATOMIC);
+        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_KERNEL);
         if (ret)
                 goto err_alloc_rx_sg;
 
-        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_ATOMIC);
+        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_KERNEL);
         if (ret)
                 goto err_alloc_tx_sg;
 
@@ -1043,18 +1048,18 @@ static int configure_dma(struct pl022 *pl022)
                 goto err_tx_sgmap;
 
         /* Send both scatterlists */
-        rxdesc = dmaengine_prep_slave_sg(rxchan,
+        rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
                                       pl022->sgt_rx.sgl,
                                       rx_sglen,
-                                      DMA_DEV_TO_MEM,
+                                      DMA_FROM_DEVICE,
                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!rxdesc)
                 goto err_rxdesc;
 
-        txdesc = dmaengine_prep_slave_sg(txchan,
+        txdesc = txchan->device->device_prep_slave_sg(txchan,
                                       pl022->sgt_tx.sgl,
                                       tx_sglen,
-                                      DMA_MEM_TO_DEV,
+                                      DMA_TO_DEVICE,
                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!txdesc)
                 goto err_txdesc;
@@ -1068,7 +1073,6 @@ static int configure_dma(struct pl022 *pl022)
         dmaengine_submit(txdesc);
         dma_async_issue_pending(rxchan);
         dma_async_issue_pending(txchan);
-        pl022->dma_running = true;
 
         return 0;
 
@@ -1089,7 +1093,7 @@ err_alloc_rx_sg:
         return -ENOMEM;
 }
 
-static int pl022_dma_probe(struct pl022 *pl022)
+static int __init pl022_dma_probe(struct pl022 *pl022)
 {
         dma_cap_mask_t mask;
 
@@ -1147,12 +1151,11 @@ static void terminate_dma(struct pl022 *pl022)
         dmaengine_terminate_all(rxchan);
         dmaengine_terminate_all(txchan);
         unmap_free_dma_scatter(pl022);
-        pl022->dma_running = false;
 }
 
 static void pl022_dma_remove(struct pl022 *pl022)
 {
-        if (pl022->dma_running)
+        if (pl022->busy)
                 terminate_dma(pl022);
         if (pl022->dma_tx_channel)
                 dma_release_channel(pl022->dma_tx_channel);
@@ -1247,9 +1250,9 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id)
 
         if ((pl022->tx == pl022->tx_end) && (flag == 0)) {
                 flag = 1;
-                /* Disable Transmit interrupt, enable receive interrupt */
-                writew((readw(SSP_IMSC(pl022->virtbase)) &
-                       ~SSP_IMSC_MASK_TXIM) | SSP_IMSC_MASK_RXIM,
+                /* Disable Transmit interrupt */
+                writew(readw(SSP_IMSC(pl022->virtbase)) &
+                       (~SSP_IMSC_MASK_TXIM),
                        SSP_IMSC(pl022->virtbase));
         }
 
@@ -1271,7 +1274,8 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id)
                 /* Update total bytes transferred */
                 msg->actual_length += pl022->cur_transfer->len;
                 if (pl022->cur_transfer->cs_change)
-                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
+                        pl022->cur_chip->
+                                cs_control(SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 msg->state = next_transfer(pl022);
                 tasklet_schedule(&pl022->pump_transfers);
@@ -1354,9 +1358,9 @@ static void pump_transfers(unsigned long data)
                          */
                         udelay(previous->delay_usecs);
 
-                /* Reselect chip select only if cs_change was requested */
+                /* Drop chip select only if cs_change is requested */
                 if (previous->cs_change)
-                        pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
         } else {
                 /* STATE_START */
                 message->state = STATE_RUNNING;
@@ -1381,22 +1385,15 @@ static void pump_transfers(unsigned long data)
         }
 
 err_config_dma:
-        /* enable all interrupts except RX */
-        writew(ENABLE_ALL_INTERRUPTS & ~SSP_IMSC_MASK_RXIM, SSP_IMSC(pl022->virtbase));
+        writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase));
 }
 
 static void do_interrupt_dma_transfer(struct pl022 *pl022)
 {
-        /*
-         * Default is to enable all interrupts except RX -
-         * this will be enabled once TX is complete
-         */
-        u32 irqflags = ENABLE_ALL_INTERRUPTS & ~SSP_IMSC_MASK_RXIM;
-
-        /* Enable target chip, if not already active */
-        if (!pl022->next_msg_cs_active)
-                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+        u32 irqflags = ENABLE_ALL_INTERRUPTS;
 
+        /* Enable target chip */
+        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
         if (set_up_next_transfer(pl022, pl022->cur_transfer)) {
                 /* Error path */
                 pl022->cur_msg->state = STATE_ERROR;
@@ -1447,12 +1444,11 @@ static void do_polling_transfer(struct pl022 *pl022)
                         if (previous->delay_usecs)
                                 udelay(previous->delay_usecs);
                         if (previous->cs_change)
-                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                                pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
                 } else {
                         /* STATE_START */
                         message->state = STATE_RUNNING;
-                        if (!pl022->next_msg_cs_active)
-                                pl022_cs_control(pl022, SSP_CHIP_SELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
                 }
 
                 /* Configuration Changing Per Transfer */
@@ -1484,7 +1480,7 @@ static void do_polling_transfer(struct pl022 *pl022)
                 /* Update total byte transferred */
                 message->actual_length += pl022->cur_transfer->len;
                 if (pl022->cur_transfer->cs_change)
-                        pl022_cs_control(pl022, SSP_CHIP_DESELECT);
+                        pl022->cur_chip->cs_control(SSP_CHIP_DESELECT);
                 /* Move to next transfer */
                 message->state = next_transfer(pl022);
         }
@@ -1499,22 +1495,59 @@ out:
         return;
 }
 
-static int pl022_transfer_one_message(struct spi_master *master,
-                                      struct spi_message *msg)
+/**
+ * pump_messages - Workqueue function which processes spi message queue
+ * @data: pointer to private data of SSP driver
+ *
+ * This function checks if there is any spi message in the queue that
+ * needs processing and delegate control to appropriate function
+ * do_polling_transfer()/do_interrupt_dma_transfer()
+ * based on the kind of the transfer
+ *
+ */
+static void pump_messages(struct work_struct *work)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        struct pl022 *pl022 =
+                container_of(work, struct pl022, pump_messages);
+        unsigned long flags;
+
+        /* Lock queue and check for queue work */
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+        if (list_empty(&pl022->queue) || !pl022->running) {
+                pl022->busy = false;
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return;
+        }
+        /* Make sure we are not already running a message */
+        if (pl022->cur_msg) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return;
+        }
+        /* Extract head of queue */
+        pl022->cur_msg =
+            list_entry(pl022->queue.next, struct spi_message, queue);
 
-        /* Initial message state */
-        pl022->cur_msg = msg;
-        msg->state = STATE_START;
+        list_del_init(&pl022->cur_msg->queue);
+        pl022->busy = true;
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
 
-        pl022->cur_transfer = list_entry(msg->transfers.next,
-                                         struct spi_transfer, transfer_list);
+        /* Initial message state */
+        pl022->cur_msg->state = STATE_START;
+        pl022->cur_transfer = list_entry(pl022->cur_msg->transfers.next,
+                                            struct spi_transfer,
+                                            transfer_list);
 
         /* Setup the SPI using the per chip configuration */
-        pl022->cur_chip = spi_get_ctldata(msg->spi);
-        pl022->cur_cs = pl022->chipselects[msg->spi->chip_select];
-
+        pl022->cur_chip = spi_get_ctldata(pl022->cur_msg->spi);
+        /*
+         * We enable the core voltage and clocks here, then the clocks
+         * and core will be disabled when giveback() is called in each method
+         * (poll/interrupt/DMA)
+         */
+        pm_runtime_get_sync(&pl022->adev->dev);
+        amba_vcore_enable(pl022->adev);
+        amba_pclk_enable(pl022->adev);
+        clk_enable(pl022->clk);
         restore_state(pl022);
         flush(pl022);
 
@@ -1522,37 +1555,97 @@ static int pl022_transfer_one_message(struct spi_master *master,
                 do_polling_transfer(pl022);
         else
                 do_interrupt_dma_transfer(pl022);
+}
+
+
+static int __init init_queue(struct pl022 *pl022)
+{
+        INIT_LIST_HEAD(&pl022->queue);
+        spin_lock_init(&pl022->queue_lock);
+
+        pl022->running = false;
+        pl022->busy = false;
+
+        tasklet_init(&pl022->pump_transfers,
+                        pump_transfers, (unsigned long)pl022);
+
+        INIT_WORK(&pl022->pump_messages, pump_messages);
+        pl022->workqueue = create_singlethread_workqueue(
+                                        dev_name(pl022->master->dev.parent));
+        if (pl022->workqueue == NULL)
+                return -EBUSY;
 
         return 0;
 }
 
-static int pl022_prepare_transfer_hardware(struct spi_master *master)
+
+static int start_queue(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+
+        if (pl022->running || pl022->busy) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return -EBUSY;
+        }
+
+        pl022->running = true;
+        pl022->cur_msg = NULL;
+        pl022->cur_transfer = NULL;
+        pl022->cur_chip = NULL;
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+
+        queue_work(pl022->workqueue, &pl022->pump_messages);
 
-        /*
-         * Just make sure we have all we need to run the transfer by syncing
-         * with the runtime PM framework.
-         */
-        pm_runtime_get_sync(&pl022->adev->dev);
         return 0;
 }
 
-static int pl022_unprepare_transfer_hardware(struct spi_master *master)
+
+static int stop_queue(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = spi_master_get_devdata(master);
+        unsigned long flags;
+        unsigned limit = 500;
+        int status = 0;
 
-        /* nothing more to do - disable spi/ssp and power off */
-        writew((readw(SSP_CR1(pl022->virtbase)) &
-                (~SSP_CR1_MASK_SSE)), SSP_CR1(pl022->virtbase));
+        spin_lock_irqsave(&pl022->queue_lock, flags);
 
-        if (pl022->master_info->autosuspend_delay > 0) {
-                pm_runtime_mark_last_busy(&pl022->adev->dev);
-                pm_runtime_put_autosuspend(&pl022->adev->dev);
-        } else {
-                pm_runtime_put(&pl022->adev->dev);
+        /* This is a bit lame, but is optimized for the common execution path.
+         * A wait_queue on the pl022->busy could be used, but then the common
+         * execution path (pump_messages) would be required to call wake_up or
+         * friends on every SPI message. Do this instead */
+        while ((!list_empty(&pl022->queue) || pl022->busy) && limit--) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                msleep(10);
+                spin_lock_irqsave(&pl022->queue_lock, flags);
         }
 
+        if (!list_empty(&pl022->queue) || pl022->busy)
+                status = -EBUSY;
+        else
+                pl022->running = false;
+
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+
+        return status;
+}
+
+static int destroy_queue(struct pl022 *pl022)
+{
+        int status;
+
+        status = stop_queue(pl022);
+        /* we are unloading the module or failing to load (only two calls
+         * to this routine), and neither call can handle a return value.
+         * However, destroy_workqueue calls flush_workqueue, and that will
+         * block until all work is done.  If the reason that stop_queue
+         * timed out is that the work will never finish, then it does no
+         * good to call destroy_workqueue, so return anyway. */
+        if (status != 0)
+                return status;
+
+        destroy_workqueue(pl022->workqueue);
+
         return 0;
 }
 
@@ -1672,87 +1765,103 @@ static int verify_controller_parameters(struct pl022 *pl022,
         return 0;
 }
 
-static inline u32 spi_rate(u32 rate, u16 cpsdvsr, u16 scr)
+/**
+ * pl022_transfer - transfer function registered to SPI master framework
+ * @spi: spi device which is requesting transfer
+ * @msg: spi message which is to handled is queued to driver queue
+ *
+ * This function is registered to the SPI framework for this SPI master
+ * controller. It will queue the spi_message in the queue of driver if
+ * the queue is not stopped and return.
+ */
+static int pl022_transfer(struct spi_device *spi, struct spi_message *msg)
 {
-        return rate / (cpsdvsr * (1 + scr));
+        struct pl022 *pl022 = spi_master_get_devdata(spi->master);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pl022->queue_lock, flags);
+
+        if (!pl022->running) {
+                spin_unlock_irqrestore(&pl022->queue_lock, flags);
+                return -ESHUTDOWN;
+        }
+        msg->actual_length = 0;
+        msg->status = -EINPROGRESS;
+        msg->state = STATE_START;
+
+        list_add_tail(&msg->queue, &pl022->queue);
+        if (pl022->running && !pl022->busy)
+                queue_work(pl022->workqueue, &pl022->pump_messages);
+
+        spin_unlock_irqrestore(&pl022->queue_lock, flags);
+        return 0;
 }
 
-static int calculate_effective_freq(struct pl022 *pl022, int freq, struct
-                                    ssp_clock_params * clk_freq)
+static int calculate_effective_freq(struct pl022 *pl022,
+                                    int freq,
+                                    struct ssp_clock_params *clk_freq)
 {
         /* Lets calculate the frequency parameters */
-        u16 cpsdvsr = CPSDVR_MIN, scr = SCR_MIN;
-        u32 rate, max_tclk, min_tclk, best_freq = 0, best_cpsdvsr = 0,
-                best_scr = 0, tmp, found = 0;
+        u16 cpsdvsr = 2;
+        u16 scr = 0;
+        bool freq_found = false;
+        u32 rate;
+        u32 max_tclk;
+        u32 min_tclk;
 
         rate = clk_get_rate(pl022->clk);
         /* cpsdvscr = 2 & scr 0 */
-        max_tclk = spi_rate(rate, CPSDVR_MIN, SCR_MIN);
+        max_tclk = (rate / (CPSDVR_MIN * (1 + SCR_MIN)));
         /* cpsdvsr = 254 & scr = 255 */
-        min_tclk = spi_rate(rate, CPSDVR_MAX, SCR_MAX);
-
-        if (freq > max_tclk)
-                dev_warn(&pl022->adev->dev,
-                        "Max speed that can be programmed is %d Hz, you requested %d\n",
-                        max_tclk, freq);
-
-        if (freq < min_tclk) {
-                dev_err(&pl022->adev->dev,
-                        "Requested frequency: %d Hz is less than minimum possible %d Hz\n",
-                        freq, min_tclk);
-                return -EINVAL;
-        }
-
-        /*
-         * best_freq will give closest possible available rate (<= requested
-         * freq) for all values of scr & cpsdvsr.
-         */
-        while ((cpsdvsr <= CPSDVR_MAX) && !found) {
-                while (scr <= SCR_MAX) {
-                        tmp = spi_rate(rate, cpsdvsr, scr);
-
-                        if (tmp > freq) {
-                                /* we need lower freq */
-                                scr++;
-                                continue;
+        min_tclk = (rate / (CPSDVR_MAX * (1 + SCR_MAX)));
+
+        if ((freq <= max_tclk) && (freq >= min_tclk)) {
+                while (cpsdvsr <= CPSDVR_MAX && !freq_found) {
+                        while (scr <= SCR_MAX && !freq_found) {
+                                if ((rate /
+                                     (cpsdvsr * (1 + scr))) > freq)
+                                        scr += 1;
+                                else {
+                                        /*
+                                         * This bool is made true when
+                                         * effective frequency >=
+                                         * target frequency is found
+                                         */
+                                        freq_found = true;
+                                        if ((rate /
+                                             (cpsdvsr * (1 + scr))) != freq) {
+                                                if (scr == SCR_MIN) {
+                                                        cpsdvsr -= 2;
+                                                        scr = SCR_MAX;
+                                                } else
+                                                        scr -= 1;
+                                        }
+                                }
                         }
-
-                        /*
-                         * If found exact value, mark found and break.
-                         * If found more closer value, update and break.
-                         */
-                        if (tmp > best_freq) {
-                                best_freq = tmp;
-                                best_cpsdvsr = cpsdvsr;
-                                best_scr = scr;
-
-                                if (tmp == freq)
-                                        found = 1;
+                        if (!freq_found) {
+                                cpsdvsr += 2;
+                                scr = SCR_MIN;
                         }
-                        /*
-                         * increased scr will give lower rates, which are not
-                         * required
-                         */
-                        break;
                 }
-                cpsdvsr += 2;
-                scr = SCR_MIN;
+                if (cpsdvsr != 0) {
+                        dev_dbg(&pl022->adev->dev,
+                                "SSP Effective Frequency is %u\n",
+                                (rate / (cpsdvsr * (1 + scr))));
+                        clk_freq->cpsdvsr = (u8) (cpsdvsr & 0xFF);
+                        clk_freq->scr = (u8) (scr & 0xFF);
+                        dev_dbg(&pl022->adev->dev,
+                                "SSP cpsdvsr = %d, scr = %d\n",
+                                clk_freq->cpsdvsr, clk_freq->scr);
+                }
+        } else {
+                dev_err(&pl022->adev->dev,
+                        "controller data is incorrect: out of range frequency");
+                return -EINVAL;
         }
-
-        WARN(!best_freq, "pl022: Matching cpsdvsr and scr not found for %d Hz rate \n",
-                        freq);
-
-        clk_freq->cpsdvsr = (u8) (best_cpsdvsr & 0xFF);
-        clk_freq->scr = (u8) (best_scr & 0xFF);
-        dev_dbg(&pl022->adev->dev,
-                "SSP Target Frequency is: %u, Effective Frequency is %u\n",
-                freq, best_freq);
-        dev_dbg(&pl022->adev->dev, "SSP cpsdvsr = %d, scr = %d\n",
-                clk_freq->cpsdvsr, clk_freq->scr);
-
         return 0;
 }
 
+
 /*
  * A piece of default chip info unless the platform
  * supplies it.
@@ -1770,6 +1879,7 @@ static const struct pl022_config_chip pl022_default_chip_info = {
         .cs_control = null_cs_control,
 };
 
+
 /**
  * pl022_setup - setup function registered to SPI master framework
  * @spi: spi device which is requesting setup
@@ -1785,14 +1895,12 @@ static const struct pl022_config_chip pl022_default_chip_info = {
 static int pl022_setup(struct spi_device *spi)
 {
         struct pl022_config_chip const *chip_info;
-        struct pl022_config_chip chip_info_dt;
         struct chip_data *chip;
-        struct ssp_clock_params clk_freq = { .cpsdvsr = 0, .scr = 0};
+        struct ssp_clock_params clk_freq = {0, };
         int status = 0;
         struct pl022 *pl022 = spi_master_get_devdata(spi->master);
         unsigned int bits = spi->bits_per_word;
         u32 tmp;
-        struct device_node *np = spi->dev.of_node;
 
         if (!spi->max_speed_hz)
                 return -EINVAL;
@@ -1815,32 +1923,10 @@ static int pl022_setup(struct spi_device *spi)
         chip_info = spi->controller_data;
 
         if (chip_info == NULL) {
-                if (np) {
-                        chip_info_dt = pl022_default_chip_info;
-
-                        chip_info_dt.hierarchy = SSP_MASTER;
-                        of_property_read_u32(np, "pl022,interface",
-                                &chip_info_dt.iface);
-                        of_property_read_u32(np, "pl022,com-mode",
-                                &chip_info_dt.com_mode);
-                        of_property_read_u32(np, "pl022,rx-level-trig",
-                                &chip_info_dt.rx_lev_trig);
-                        of_property_read_u32(np, "pl022,tx-level-trig",
-                                &chip_info_dt.tx_lev_trig);
-                        of_property_read_u32(np, "pl022,ctrl-len",
-                                &chip_info_dt.ctrl_len);
-                        of_property_read_u32(np, "pl022,wait-state",
-                                &chip_info_dt.wait_state);
-                        of_property_read_u32(np, "pl022,duplex",
-                                &chip_info_dt.duplex);
-
-                        chip_info = &chip_info_dt;
-                } else {
-                        chip_info = &pl022_default_chip_info;
-                        /* spi_board_info.controller_data not is supplied */
-                        dev_dbg(&spi->dev,
-                                "using default controller_data settings\n");
-                }
+                chip_info = &pl022_default_chip_info;
+                /* spi_board_info.controller_data not is supplied */
+                dev_dbg(&spi->dev,
+                        "using default controller_data settings\n");
         } else
                 dev_dbg(&spi->dev,
                         "using user supplied controller_data settings\n");
@@ -1870,6 +1956,7 @@ static int pl022_setup(struct spi_device *spi)
                 goto err_config_params;
         }
 
+
         status = verify_controller_parameters(pl022, chip_info);
         if (status) {
                 dev_err(&spi->dev, "controller data is incorrect");
@@ -1883,18 +1970,14 @@ static int pl022_setup(struct spi_device *spi)
         chip->xfer_type = chip_info->com_mode;
         if (!chip_info->cs_control) {
                 chip->cs_control = null_cs_control;
-                if (!gpio_is_valid(pl022->chipselects[spi->chip_select]))
-                        dev_warn(&spi->dev,
-                                 "invalid chip select\n");
+                dev_warn(&spi->dev,
+                         "chip select function is NULL for this chip\n");
         } else
                 chip->cs_control = chip_info->cs_control;
 
-        /* Check bits per word with vendor specific range */
-        if ((bits <= 3) || (bits > pl022->vendor->max_bpw)) {
+        if (bits <= 3) {
+                /* PL022 doesn't support less than 4-bits */
                 status = -ENOTSUPP;
-                dev_err(&spi->dev, "illegal data size for this controller!\n");
-                dev_err(&spi->dev, "This controller can only handle 4 <= n <= %d bit words\n",
-                                pl022->vendor->max_bpw);
                 goto err_config_params;
         } else if (bits <= 8) {
                 dev_dbg(&spi->dev, "4 <= n <=8 bits per word\n");
@@ -1907,10 +1990,20 @@ static int pl022_setup(struct spi_device *spi)
                 chip->read = READING_U16;
                 chip->write = WRITING_U16;
         } else {
-                dev_dbg(&spi->dev, "17 <= n <= 32 bits per word\n");
-                chip->n_bytes = 4;
-                chip->read = READING_U32;
-                chip->write = WRITING_U32;
+                if (pl022->vendor->max_bpw >= 32) {
+                        dev_dbg(&spi->dev, "17 <= n <= 32 bits per word\n");
+                        chip->n_bytes = 4;
+                        chip->read = READING_U32;
+                        chip->write = WRITING_U32;
+                } else {
+                        dev_err(&spi->dev,
+                                "illegal data size for this controller!\n");
+                        dev_err(&spi->dev,
+                                "a standard pl022 can only handle "
+                                "1 <= n <= 16 bit words\n");
+                        status = -ENOTSUPP;
+                        goto err_config_params;
+                }
         }
 
         /* Now Initialize all register settings required for this chip */
@@ -2003,8 +2096,7 @@ static int pl022_setup(struct spi_device *spi)
         }
         SSP_WRITE_BITS(chip->cr1, SSP_DISABLED, SSP_CR1_MASK_SSE, 1);
         SSP_WRITE_BITS(chip->cr1, chip_info->hierarchy, SSP_CR1_MASK_MS, 2);
-        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD,
-                3);
+        SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD, 3);
 
         /* Save controller_state */
         spi_set_ctldata(spi, chip);
@@ -2030,65 +2122,30 @@ static void pl022_cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
-static struct pl022_ssp_controller *
-pl022_platform_data_dt_get(struct device *dev)
-{
-        struct device_node *np = dev->of_node;
-        struct pl022_ssp_controller *pd;
-        u32 tmp;
-
-        if (!np) {
-                dev_err(dev, "no dt node defined\n");
-                return NULL;
-        }
-
-        pd = devm_kzalloc(dev, sizeof(struct pl022_ssp_controller), GFP_KERNEL);
-        if (!pd) {
-                dev_err(dev, "cannot allocate platform data memory\n");
-                return NULL;
-        }
-
-        pd->bus_id = -1;
-        of_property_read_u32(np, "num-cs", &tmp);
-        pd->num_chipselect = tmp;
-        of_property_read_u32(np, "pl022,autosuspend-delay",
-                             &pd->autosuspend_delay);
-        pd->rt = of_property_read_bool(np, "pl022,rt");
-
-        return pd;
-}
 
-static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
+static int __devinit
+pl022_probe(struct amba_device *adev, const struct amba_id *id)
 {
         struct device *dev = &adev->dev;
         struct pl022_ssp_controller *platform_info = adev->dev.platform_data;
         struct spi_master *master;
         struct pl022 *pl022 = NULL;     /*Data for this driver */
-        struct device_node *np = adev->dev.of_node;
-        int status = 0, i, num_cs;
+        int status = 0;
 
         dev_info(&adev->dev,
                  "ARM PL022 driver, device ID: 0x%08x\n", adev->periphid);
-        if (!platform_info && IS_ENABLED(CONFIG_OF))
-                platform_info = pl022_platform_data_dt_get(dev);
-
-        if (!platform_info) {
-                dev_err(dev, "probe: no platform data defined\n");
-                return -ENODEV;
-        }
-
-        if (platform_info->num_chipselect) {
-                num_cs = platform_info->num_chipselect;
-        } else {
-                dev_err(dev, "probe: no chip select defined\n");
-                return -ENODEV;
+        if (platform_info == NULL) {
+                dev_err(&adev->dev, "probe - no platform data supplied\n");
+                status = -ENODEV;
+                goto err_no_pdata;
         }
 
         /* Allocate master with space for data */
         master = spi_alloc_master(dev, sizeof(struct pl022));
         if (master == NULL) {
                 dev_err(&adev->dev, "probe - cannot alloc SPI master\n");
-                return -ENOMEM;
+                status = -ENOMEM;
+                goto err_no_master;
         }
 
         pl022 = spi_master_get_devdata(master);
@@ -2096,76 +2153,16 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
         pl022->master_info = platform_info;
         pl022->adev = adev;
         pl022->vendor = id->data;
-        pl022->chipselects = devm_kzalloc(dev, num_cs * sizeof(int),
-                                          GFP_KERNEL);
-
-        pl022->pinctrl = devm_pinctrl_get(dev);
-        if (IS_ERR(pl022->pinctrl)) {
-                status = PTR_ERR(pl022->pinctrl);
-                goto err_no_pinctrl;
-        }
-
-        pl022->pins_default = pinctrl_lookup_state(pl022->pinctrl,
-                                                 PINCTRL_STATE_DEFAULT);
-        /* enable pins to be muxed in and configured */
-        if (!IS_ERR(pl022->pins_default)) {
-                status = pinctrl_select_state(pl022->pinctrl,
-                                pl022->pins_default);
-                if (status)
-                        dev_err(dev, "could not set default pins\n");
-        } else
-                dev_err(dev, "could not get default pinstate\n");
-
-        pl022->pins_idle = pinctrl_lookup_state(pl022->pinctrl,
-                                              PINCTRL_STATE_IDLE);
-        if (IS_ERR(pl022->pins_idle))
-                dev_dbg(dev, "could not get idle pinstate\n");
-
-        pl022->pins_sleep = pinctrl_lookup_state(pl022->pinctrl,
-                                               PINCTRL_STATE_SLEEP);
-        if (IS_ERR(pl022->pins_sleep))
-                dev_dbg(dev, "could not get sleep pinstate\n");
 
         /*
          * Bus Number Which has been Assigned to this SSP controller
          * on this board
          */
         master->bus_num = platform_info->bus_id;
-        master->num_chipselect = num_cs;
+        master->num_chipselect = platform_info->num_chipselect;
         master->cleanup = pl022_cleanup;
         master->setup = pl022_setup;
-        master->prepare_transfer_hardware = pl022_prepare_transfer_hardware;
-        master->transfer_one_message = pl022_transfer_one_message;
-        master->unprepare_transfer_hardware = pl022_unprepare_transfer_hardware;
-        master->rt = platform_info->rt;
-        master->dev.of_node = dev->of_node;
-
-        if (platform_info->num_chipselect && platform_info->chipselects) {
-                for (i = 0; i < num_cs; i++)
-                        pl022->chipselects[i] = platform_info->chipselects[i];
-        } else if (IS_ENABLED(CONFIG_OF)) {
-                for (i = 0; i < num_cs; i++) {
-                        int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
-
-                        if (cs_gpio == -EPROBE_DEFER) {
-                                status = -EPROBE_DEFER;
-                                goto err_no_gpio;
-                        }
-
-                        pl022->chipselects[i] = cs_gpio;
-
-                        if (gpio_is_valid(cs_gpio)) {
-                                if (devm_gpio_request(dev, cs_gpio, "ssp-pl022"))
-                                        dev_err(&adev->dev,
-                                                "could not request %d gpio\n",
-                                                cs_gpio);
-                                else if (gpio_direction_output(cs_gpio, 1))
-                                        dev_err(&adev->dev,
-                                                "could set gpio %d as output\n",
-                                                cs_gpio);
-                        }
-                }
-        }
+        master->transfer = pl022_transfer;
 
         /*
          * Supports mode 0-3, loopback, and active low CS. Transfers are
@@ -2182,45 +2179,30 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                 goto err_no_ioregion;
 
         pl022->phybase = adev->res.start;
-        pl022->virtbase = devm_ioremap(dev, adev->res.start,
-                                       resource_size(&adev->res));
+        pl022->virtbase = ioremap(adev->res.start, resource_size(&adev->res));
         if (pl022->virtbase == NULL) {
                 status = -ENOMEM;
                 goto err_no_ioremap;
         }
         printk(KERN_INFO "pl022: mapped registers from 0x%08x to %p\n",
                adev->res.start, pl022->virtbase);
+        pm_runtime_enable(dev);
+        pm_runtime_resume(dev);
 
-        pl022->clk = devm_clk_get(&adev->dev, NULL);
+        pl022->clk = clk_get(&adev->dev, NULL);
         if (IS_ERR(pl022->clk)) {
                 status = PTR_ERR(pl022->clk);
                 dev_err(&adev->dev, "could not retrieve SSP/SPI bus clock\n");
                 goto err_no_clk;
         }
 
-        status = clk_prepare(pl022->clk);
-        if (status) {
-                dev_err(&adev->dev, "could not prepare SSP/SPI bus clock\n");
-                goto  err_clk_prep;
-        }
-
-        status = clk_enable(pl022->clk);
-        if (status) {
-                dev_err(&adev->dev, "could not enable SSP/SPI bus clock\n");
-                goto err_no_clk_en;
-        }
-
-        /* Initialize transfer pump */
-        tasklet_init(&pl022->pump_transfers, pump_transfers,
-                     (unsigned long)pl022);
-
         /* Disable SSP */
         writew((readw(SSP_CR1(pl022->virtbase)) & (~SSP_CR1_MASK_SSE)),
                SSP_CR1(pl022->virtbase));
         load_ssp_default_config(pl022);
 
-        status = devm_request_irq(dev, adev->irq[0], pl022_interrupt_handler,
-                                  0, "pl022", pl022);
+        status = request_irq(adev->irq[0], pl022_interrupt_handler, 0, "pl022",
+                             pl022);
         if (status < 0) {
                 dev_err(&adev->dev, "probe - cannot get IRQ (%d)\n", status);
                 goto err_no_irq;
@@ -2233,6 +2215,17 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                         platform_info->enable_dma = 0;
         }
 
+        /* Initialize and start queue */
+        status = init_queue(pl022);
+        if (status != 0) {
+                dev_err(&adev->dev, "probe - problem initializing queue\n");
+                goto err_init_queue;
+        }
+        status = start_queue(pl022);
+        if (status != 0) {
+                dev_err(&adev->dev, "probe - problem starting queue\n");
+                goto err_start_queue;
+        }
         /* Register with the SPI framework */
         amba_set_drvdata(adev, pl022);
         status = spi_register_master(master);
@@ -2242,39 +2235,35 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
                 goto err_spi_register;
         }
         dev_dbg(dev, "probe succeeded\n");
-
-        /* let runtime pm put suspend */
-        if (platform_info->autosuspend_delay > 0) {
-                dev_info(&adev->dev,
-                        "will use autosuspend for runtime pm, delay %dms\n",
-                        platform_info->autosuspend_delay);
-                pm_runtime_set_autosuspend_delay(dev,
-                        platform_info->autosuspend_delay);
-                pm_runtime_use_autosuspend(dev);
-        }
-        pm_runtime_put(dev);
-
+        /*
+         * Disable the silicon block pclk and any voltage domain and just
+         * power it up and clock it when it's needed
+         */
+        amba_pclk_disable(adev);
+        amba_vcore_disable(adev);
         return 0;
 
  err_spi_register:
-        if (platform_info->enable_dma)
-                pl022_dma_remove(pl022);
+ err_start_queue:
+ err_init_queue:
+        destroy_queue(pl022);
+        pl022_dma_remove(pl022);
+        free_irq(adev->irq[0], pl022);
+        pm_runtime_disable(&adev->dev);
  err_no_irq:
-        clk_disable(pl022->clk);
- err_no_clk_en:
-        clk_unprepare(pl022->clk);
- err_clk_prep:
+        clk_put(pl022->clk);
  err_no_clk:
+        iounmap(pl022->virtbase);
  err_no_ioremap:
         amba_release_regions(adev);
  err_no_ioregion:
- err_no_gpio:
- err_no_pinctrl:
         spi_master_put(master);
+ err_no_master:
+ err_no_pdata:
         return status;
 }
 
-static int
+static int __devexit
 pl022_remove(struct amba_device *adev)
 {
         struct pl022 *pl022 = amba_get_drvdata(adev);
@@ -2282,137 +2271,63 @@ pl022_remove(struct amba_device *adev)
         if (!pl022)
                 return 0;
 
-        /*
-         * undo pm_runtime_put() in probe.  I assume that we're not
-         * accessing the primecell here.
-         */
-        pm_runtime_get_noresume(&adev->dev);
-
+        /* Remove the queue */
+        if (destroy_queue(pl022) != 0)
+                dev_err(&adev->dev, "queue remove failed\n");
         load_ssp_default_config(pl022);
-        if (pl022->master_info->enable_dma)
-                pl022_dma_remove(pl022);
-
+        pl022_dma_remove(pl022);
+        free_irq(adev->irq[0], pl022);
         clk_disable(pl022->clk);
-        clk_unprepare(pl022->clk);
+        clk_put(pl022->clk);
+        iounmap(pl022->virtbase);
         amba_release_regions(adev);
         tasklet_disable(&pl022->pump_transfers);
         spi_unregister_master(pl022->master);
+        spi_master_put(pl022->master);
         amba_set_drvdata(adev, NULL);
         return 0;
 }
 
-#if defined(CONFIG_SUSPEND) || defined(CONFIG_PM_RUNTIME)
-/*
- * These two functions are used from both suspend/resume and
- * the runtime counterparts to handle external resources like
- * clocks, pins and regulators when going to sleep.
- */
-static void pl022_suspend_resources(struct pl022 *pl022, bool runtime)
+#ifdef CONFIG_PM
+static int pl022_suspend(struct amba_device *adev, pm_message_t state)
 {
-        int ret;
-        struct pinctrl_state *pins_state;
-
-        clk_disable(pl022->clk);
-
-        pins_state = runtime ? pl022->pins_idle : pl022->pins_sleep;
-        /* Optionally let pins go into sleep states */
-        if (!IS_ERR(pins_state)) {
-                ret = pinctrl_select_state(pl022->pinctrl, pins_state);
-                if (ret)
-                        dev_err(&pl022->adev->dev, "could not set %s pins\n",
-                                runtime ? "idle" : "sleep");
-        }
-}
-
-static void pl022_resume_resources(struct pl022 *pl022, bool runtime)
-{
-        int ret;
-
-        /* Optionaly enable pins to be muxed in and configured */
-        /* First go to the default state */
-        if (!IS_ERR(pl022->pins_default)) {
-                ret = pinctrl_select_state(pl022->pinctrl, pl022->pins_default);
-                if (ret)
-                        dev_err(&pl022->adev->dev,
-                                "could not set default pins\n");
-        }
-
-        if (!runtime) {
-                /* Then let's idle the pins until the next transfer happens */
-                if (!IS_ERR(pl022->pins_idle)) {
-                        ret = pinctrl_select_state(pl022->pinctrl,
-                                        pl022->pins_idle);
-                if (ret)
-                        dev_err(&pl022->adev->dev,
-                                "could not set idle pins\n");
-                }
-        }
-
-        clk_enable(pl022->clk);
-}
-#endif
-
-#ifdef CONFIG_SUSPEND
-static int pl022_suspend(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-        int ret;
+        struct pl022 *pl022 = amba_get_drvdata(adev);
+        int status = 0;
 
-        ret = spi_master_suspend(pl022->master);
-        if (ret) {
-                dev_warn(dev, "cannot suspend master\n");
-                return ret;
+        status = stop_queue(pl022);
+        if (status) {
+                dev_warn(&adev->dev, "suspend cannot stop queue\n");
+                return status;
         }
 
-        pm_runtime_get_sync(dev);
-        pl022_suspend_resources(pl022, false);
-
-        dev_dbg(dev, "suspended\n");
+        amba_vcore_enable(adev);
+        amba_pclk_enable(adev);
+        load_ssp_default_config(pl022);
+        amba_pclk_disable(adev);
+        amba_vcore_disable(adev);
+        dev_dbg(&adev->dev, "suspended\n");
         return 0;
 }
 
-static int pl022_resume(struct device *dev)
+static int pl022_resume(struct amba_device *adev)
 {
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-        int ret;
-
-        pl022_resume_resources(pl022, false);
-        pm_runtime_put(dev);
+        struct pl022 *pl022 = amba_get_drvdata(adev);
+        int status = 0;
 
         /* Start the queue running */
-        ret = spi_master_resume(pl022->master);
-        if (ret)
-                dev_err(dev, "problem starting queue (%d)\n", ret);
+        status = start_queue(pl022);
+        if (status)
+                dev_err(&adev->dev, "problem starting queue (%d)\n", status);
         else
-                dev_dbg(dev, "resumed\n");
+                dev_dbg(&adev->dev, "resumed\n");
 
-        return ret;
+        return status;
 }
+#else
+#define pl022_suspend NULL
+#define pl022_resume NULL
 #endif  /* CONFIG_PM */
 
-#ifdef CONFIG_PM_RUNTIME
-static int pl022_runtime_suspend(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-
-        pl022_suspend_resources(pl022, true);
-        return 0;
-}
-
-static int pl022_runtime_resume(struct device *dev)
-{
-        struct pl022 *pl022 = dev_get_drvdata(dev);
-
-        pl022_resume_resources(pl022, true);
-        return 0;
-}
-#endif
-
-static const struct dev_pm_ops pl022_dev_pm_ops = {
-        SET_SYSTEM_SLEEP_PM_OPS(pl022_suspend, pl022_resume)
-        SET_RUNTIME_PM_OPS(pl022_runtime_suspend, pl022_runtime_resume, NULL)
-};
-
 static struct vendor_data vendor_arm = {
         .fifodepth = 8,
         .max_bpw = 16,
@@ -2422,6 +2337,7 @@ static struct vendor_data vendor_arm = {
         .loopback = true,
 };
 
+
 static struct vendor_data vendor_st = {
         .fifodepth = 32,
         .max_bpw = 32,
@@ -2440,6 +2356,15 @@ static struct vendor_data vendor_st_pl023 = {
         .loopback = false,
 };
 
+static struct vendor_data vendor_db5500_pl023 = {
+        .fifodepth = 32,
+        .max_bpw = 32,
+        .unidir = false,
+        .extended_cr = true,
+        .pl023 = true,
+        .loopback = true,
+};
+
 static struct amba_id pl022_ids[] = {
         {
                 /*
@@ -2467,35 +2392,42 @@ static struct amba_id pl022_ids[] = {
                  * and 32 locations deep TX/RX FIFO but no extended
                  * CR0/CR1 register
                  */
-                .id     = 0x00080023,
+                .id     = 0x00080023,
+                .mask   = 0xffffffff,
+                .data   = &vendor_st_pl023,
+        },
+        {
+                .id     = 0x10080023,
                 .mask   = 0xffffffff,
-                .data   = &vendor_st_pl023,
+                .data   = &vendor_db5500_pl023,
         },
         { 0, 0 },
 };
 
-MODULE_DEVICE_TABLE(amba, pl022_ids);
-
 static struct amba_driver pl022_driver = {
         .drv = {
                 .name   = "ssp-pl022",
-                .pm     = &pl022_dev_pm_ops,
         },
         .id_table       = pl022_ids,
         .probe          = pl022_probe,
-        .remove         = pl022_remove,
+        .remove         = __devexit_p(pl022_remove),
+        .suspend        = pl022_suspend,
+        .resume         = pl022_resume,
 };
 
+
 static int __init pl022_init(void)
 {
         return amba_driver_register(&pl022_driver);
 }
+
 subsys_initcall(pl022_init);
 
 static void __exit pl022_exit(void)
 {
         amba_driver_unregister(&pl022_driver);
 }
+
 module_exit(pl022_exit);
 
 MODULE_AUTHOR("Linus Walleij <linus.walleij@stericsson.com>");
diff --git a/drivers/spi/spi-ppc4xx.c b/drivers/spi/spi-ppc4xx.c
index 7a85f22b647..b267fd901e5 100644
--- a/drivers/spi/spi-ppc4xx.c
+++ b/drivers/spi/spi-ppc4xx.c
@@ -30,6 +30,7 @@
 #include <linux/errno.h>
 #include <linux/wait.h>
 #include <linux/of_platform.h>
+#include <linux/of_spi.h>
 #include <linux/of_gpio.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
@@ -101,7 +102,7 @@ struct spi_ppc4xx_regs {
         u8 dummy;
         /*
          * Clock divisor modulus register
-         * This uses the following formula:
+         * This uses the follwing formula:
          *    SCPClkOut = OPBCLK/(4(CDM + 1))
          * or
          *    CDM = (OPBCLK/4*SCPClkOut) - 1
@@ -201,7 +202,7 @@ static int spi_ppc4xx_setupxfer(struct spi_device *spi, struct spi_transfer *t)
                 return -EINVAL;
         }
 
-        /* Write new configuration */
+        /* Write new configration */
         out_8(&hw->regs->mode, cs->mode);
 
         /* Set the clock */
@@ -466,6 +467,9 @@ static int __init spi_ppc4xx_of_probe(struct platform_device *op)
         bbp->master->setup = spi_ppc4xx_setup;
         bbp->master->cleanup = spi_ppc4xx_cleanup;
 
+        /* Allocate bus num dynamically. */
+        bbp->master->bus_num = -1;
+
         /* the spi->mode bits understood by this driver: */
         bbp->master->mode_bits =
                 SPI_CPHA | SPI_CPOL | SPI_CS_HIGH | SPI_LSB_FIRST;
@@ -510,7 +514,7 @@ static int __init spi_ppc4xx_of_probe(struct platform_device *op)
         /* Request IRQ */
         hw->irqnum = irq_of_parse_and_map(np, 0);
         ret = request_irq(hw->irqnum, spi_ppc4xx_int,
-                          0, "spi_ppc4xx_of", (void *)hw);
+                          IRQF_DISABLED, "spi_ppc4xx_of", (void *)hw);
         if (ret) {
                 dev_err(dev, "unable to allocate interrupt\n");
                 goto free_gpios;
@@ -590,7 +594,18 @@ static struct platform_driver spi_ppc4xx_of_driver = {
                 .of_match_table = spi_ppc4xx_of_match,
         },
 };
-module_platform_driver(spi_ppc4xx_of_driver);
+
+static int __init spi_ppc4xx_init(void)
+{
+        return platform_driver_register(&spi_ppc4xx_of_driver);
+}
+module_init(spi_ppc4xx_init);
+
+static void __exit spi_ppc4xx_exit(void)
+{
+        platform_driver_unregister(&spi_ppc4xx_of_driver);
+}
+module_exit(spi_ppc4xx_exit);
 
 MODULE_AUTHOR("Gary Jennejohn & Stefan Roese");
 MODULE_DESCRIPTION("Simple PPC4xx SPI Driver");
diff --git a/drivers/spi/spi-pxa2xx-pci.c b/drivers/spi/spi-pxa2xx-pci.c
index cf95587eefd..378e504f89e 100644
--- a/drivers/spi/spi-pxa2xx-pci.c
+++ b/drivers/spi/spi-pxa2xx-pci.c
@@ -5,7 +5,6 @@
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/of_device.h>
-#include <linux/module.h>
 #include <linux/spi/pxa2xx_spi.h>
 
 struct ce4100_info {
@@ -51,7 +50,7 @@ void pxa_ssp_free(struct ssp_device *ssp)
 }
 EXPORT_SYMBOL_GPL(pxa_ssp_free);
 
-static int ce4100_spi_probe(struct pci_dev *dev,
+static int __devinit ce4100_spi_probe(struct pci_dev *dev,
                 const struct pci_device_id *ent)
 {
         int ret;
@@ -129,7 +128,7 @@ err_nomem:
         return ret;
 }
 
-static void ce4100_spi_remove(struct pci_dev *dev)
+static void __devexit ce4100_spi_remove(struct pci_dev *dev)
 {
         struct ce4100_info *spi_info;
         struct ssp_device *ssp;
@@ -151,7 +150,7 @@ static void ce4100_spi_remove(struct pci_dev *dev)
         kfree(spi_info);
 }
 
-static DEFINE_PCI_DEVICE_TABLE(ce4100_spi_devices) = {
+static struct pci_device_id ce4100_spi_devices[] __devinitdata = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2e6a) },
         { },
 };
@@ -161,10 +160,20 @@ static struct pci_driver ce4100_spi_driver = {
         .name           = "ce4100_spi",
         .id_table       = ce4100_spi_devices,
         .probe          = ce4100_spi_probe,
-        .remove         = ce4100_spi_remove,
+        .remove         = __devexit_p(ce4100_spi_remove),
 };
 
-module_pci_driver(ce4100_spi_driver);
+static int __init ce4100_spi_init(void)
+{
+        return pci_register_driver(&ce4100_spi_driver);
+}
+module_init(ce4100_spi_init);
+
+static void __exit ce4100_spi_exit(void)
+{
+        pci_unregister_driver(&ce4100_spi_driver);
+}
+module_exit(ce4100_spi_exit);
 
 MODULE_DESCRIPTION("CE4100 PCI-SPI glue code for PXA's driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
index 5c8c4f5883c..dc25bee8d33 100644
--- a/drivers/spi/spi-pxa2xx.c
+++ b/drivers/spi/spi-pxa2xx.c
@@ -1438,7 +1438,7 @@ static void cleanup(struct spi_device *spi)
         kfree(chip);
 }
 
-static int init_queue(struct driver_data *drv_data)
+static int __devinit init_queue(struct driver_data *drv_data)
 {
         INIT_LIST_HEAD(&drv_data->queue);
         spin_lock_init(&drv_data->lock);
@@ -1526,7 +1526,7 @@ static int destroy_queue(struct driver_data *drv_data)
         return 0;
 }
 
-static int pxa2xx_spi_probe(struct platform_device *pdev)
+static int __devinit pxa2xx_spi_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct pxa2xx_spi_master *platform_info;
diff --git a/drivers/spi/spi-rspi.c b/drivers/spi/spi-rspi.c
deleted file mode 100644
index 902f2fb902d..00000000000
--- a/drivers/spi/spi-rspi.c
+++ /dev/null
@@ -1,841 +0,0 @@
-/*
- * SH RSPI driver
- *
- * Copyright (C) 2012  Renesas Solutions Corp.
- *
- * Based on spi-sh.c:
- * Copyright (C) 2011 Renesas Solutions Corp.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/sched.h>
-#include <linux/errno.h>
-#include <linux/list.h>
-#include <linux/workqueue.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/io.h>
-#include <linux/clk.h>
-#include <linux/dmaengine.h>
-#include <linux/dma-mapping.h>
-#include <linux/sh_dma.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/rspi.h>
-
-#define RSPI_SPCR               0x00
-#define RSPI_SSLP               0x01
-#define RSPI_SPPCR              0x02
-#define RSPI_SPSR               0x03
-#define RSPI_SPDR               0x04
-#define RSPI_SPSCR              0x08
-#define RSPI_SPSSR              0x09
-#define RSPI_SPBR               0x0a
-#define RSPI_SPDCR              0x0b
-#define RSPI_SPCKD              0x0c
-#define RSPI_SSLND              0x0d
-#define RSPI_SPND               0x0e
-#define RSPI_SPCR2              0x0f
-#define RSPI_SPCMD0             0x10
-#define RSPI_SPCMD1             0x12
-#define RSPI_SPCMD2             0x14
-#define RSPI_SPCMD3             0x16
-#define RSPI_SPCMD4             0x18
-#define RSPI_SPCMD5             0x1a
-#define RSPI_SPCMD6             0x1c
-#define RSPI_SPCMD7             0x1e
-
-/* SPCR */
-#define SPCR_SPRIE              0x80
-#define SPCR_SPE                0x40
-#define SPCR_SPTIE              0x20
-#define SPCR_SPEIE              0x10
-#define SPCR_MSTR               0x08
-#define SPCR_MODFEN             0x04
-#define SPCR_TXMD               0x02
-#define SPCR_SPMS               0x01
-
-/* SSLP */
-#define SSLP_SSL1P              0x02
-#define SSLP_SSL0P              0x01
-
-/* SPPCR */
-#define SPPCR_MOIFE             0x20
-#define SPPCR_MOIFV             0x10
-#define SPPCR_SPOM              0x04
-#define SPPCR_SPLP2             0x02
-#define SPPCR_SPLP              0x01
-
-/* SPSR */
-#define SPSR_SPRF               0x80
-#define SPSR_SPTEF              0x20
-#define SPSR_PERF               0x08
-#define SPSR_MODF               0x04
-#define SPSR_IDLNF              0x02
-#define SPSR_OVRF               0x01
-
-/* SPSCR */
-#define SPSCR_SPSLN_MASK        0x07
-
-/* SPSSR */
-#define SPSSR_SPECM_MASK        0x70
-#define SPSSR_SPCP_MASK         0x07
-
-/* SPDCR */
-#define SPDCR_SPLW              0x20
-#define SPDCR_SPRDTD            0x10
-#define SPDCR_SLSEL1            0x08
-#define SPDCR_SLSEL0            0x04
-#define SPDCR_SLSEL_MASK        0x0c
-#define SPDCR_SPFC1             0x02
-#define SPDCR_SPFC0             0x01
-
-/* SPCKD */
-#define SPCKD_SCKDL_MASK        0x07
-
-/* SSLND */
-#define SSLND_SLNDL_MASK        0x07
-
-/* SPND */
-#define SPND_SPNDL_MASK         0x07
-
-/* SPCR2 */
-#define SPCR2_PTE               0x08
-#define SPCR2_SPIE              0x04
-#define SPCR2_SPOE              0x02
-#define SPCR2_SPPE              0x01
-
-/* SPCMDn */
-#define SPCMD_SCKDEN            0x8000
-#define SPCMD_SLNDEN            0x4000
-#define SPCMD_SPNDEN            0x2000
-#define SPCMD_LSBF              0x1000
-#define SPCMD_SPB_MASK          0x0f00
-#define SPCMD_SPB_8_TO_16(bit)  (((bit - 1) << 8) & SPCMD_SPB_MASK)
-#define SPCMD_SPB_20BIT         0x0000
-#define SPCMD_SPB_24BIT         0x0100
-#define SPCMD_SPB_32BIT         0x0200
-#define SPCMD_SSLKP             0x0080
-#define SPCMD_SSLA_MASK         0x0030
-#define SPCMD_BRDV_MASK         0x000c
-#define SPCMD_CPOL              0x0002
-#define SPCMD_CPHA              0x0001
-
-struct rspi_data {
-        void __iomem *addr;
-        u32 max_speed_hz;
-        struct spi_master *master;
-        struct list_head queue;
-        struct work_struct ws;
-        wait_queue_head_t wait;
-        spinlock_t lock;
-        struct clk *clk;
-        unsigned char spsr;
-
-        /* for dmaengine */
-        struct dma_chan *chan_tx;
-        struct dma_chan *chan_rx;
-        int irq;
-
-        unsigned dma_width_16bit:1;
-        unsigned dma_callbacked:1;
-};
-
-static void rspi_write8(struct rspi_data *rspi, u8 data, u16 offset)
-{
-        iowrite8(data, rspi->addr + offset);
-}
-
-static void rspi_write16(struct rspi_data *rspi, u16 data, u16 offset)
-{
-        iowrite16(data, rspi->addr + offset);
-}
-
-static u8 rspi_read8(struct rspi_data *rspi, u16 offset)
-{
-        return ioread8(rspi->addr + offset);
-}
-
-static u16 rspi_read16(struct rspi_data *rspi, u16 offset)
-{
-        return ioread16(rspi->addr + offset);
-}
-
-static unsigned char rspi_calc_spbr(struct rspi_data *rspi)
-{
-        int tmp;
-        unsigned char spbr;
-
-        tmp = clk_get_rate(rspi->clk) / (2 * rspi->max_speed_hz) - 1;
-        spbr = clamp(tmp, 0, 255);
-
-        return spbr;
-}
-
-static void rspi_enable_irq(struct rspi_data *rspi, u8 enable)
-{
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) | enable, RSPI_SPCR);
-}
-
-static void rspi_disable_irq(struct rspi_data *rspi, u8 disable)
-{
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) & ~disable, RSPI_SPCR);
-}
-
-static int rspi_wait_for_interrupt(struct rspi_data *rspi, u8 wait_mask,
-                                   u8 enable_bit)
-{
-        int ret;
-
-        rspi->spsr = rspi_read8(rspi, RSPI_SPSR);
-        rspi_enable_irq(rspi, enable_bit);
-        ret = wait_event_timeout(rspi->wait, rspi->spsr & wait_mask, HZ);
-        if (ret == 0 && !(rspi->spsr & wait_mask))
-                return -ETIMEDOUT;
-
-        return 0;
-}
-
-static void rspi_assert_ssl(struct rspi_data *rspi)
-{
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) | SPCR_SPE, RSPI_SPCR);
-}
-
-static void rspi_negate_ssl(struct rspi_data *rspi)
-{
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) & ~SPCR_SPE, RSPI_SPCR);
-}
-
-static int rspi_set_config_register(struct rspi_data *rspi, int access_size)
-{
-        /* Sets output mode(CMOS) and MOSI signal(from previous transfer) */
-        rspi_write8(rspi, 0x00, RSPI_SPPCR);
-
-        /* Sets transfer bit rate */
-        rspi_write8(rspi, rspi_calc_spbr(rspi), RSPI_SPBR);
-
-        /* Sets number of frames to be used: 1 frame */
-        rspi_write8(rspi, 0x00, RSPI_SPDCR);
-
-        /* Sets RSPCK, SSL, next-access delay value */
-        rspi_write8(rspi, 0x00, RSPI_SPCKD);
-        rspi_write8(rspi, 0x00, RSPI_SSLND);
-        rspi_write8(rspi, 0x00, RSPI_SPND);
-
-        /* Sets parity, interrupt mask */
-        rspi_write8(rspi, 0x00, RSPI_SPCR2);
-
-        /* Sets SPCMD */
-        rspi_write16(rspi, SPCMD_SPB_8_TO_16(access_size) | SPCMD_SSLKP,
-                     RSPI_SPCMD0);
-
-        /* Sets RSPI mode */
-        rspi_write8(rspi, SPCR_MSTR, RSPI_SPCR);
-
-        return 0;
-}
-
-static int rspi_send_pio(struct rspi_data *rspi, struct spi_message *mesg,
-                         struct spi_transfer *t)
-{
-        int remain = t->len;
-        u8 *data;
-
-        data = (u8 *)t->tx_buf;
-        while (remain > 0) {
-                rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) | SPCR_TXMD,
-                            RSPI_SPCR);
-
-                if (rspi_wait_for_interrupt(rspi, SPSR_SPTEF, SPCR_SPTIE) < 0) {
-                        dev_err(&rspi->master->dev,
-                                "%s: tx empty timeout\n", __func__);
-                        return -ETIMEDOUT;
-                }
-
-                rspi_write16(rspi, *data, RSPI_SPDR);
-                data++;
-                remain--;
-        }
-
-        /* Waiting for the last transmition */
-        rspi_wait_for_interrupt(rspi, SPSR_SPTEF, SPCR_SPTIE);
-
-        return 0;
-}
-
-static void rspi_dma_complete(void *arg)
-{
-        struct rspi_data *rspi = arg;
-
-        rspi->dma_callbacked = 1;
-        wake_up_interruptible(&rspi->wait);
-}
-
-static int rspi_dma_map_sg(struct scatterlist *sg, void *buf, unsigned len,
-                           struct dma_chan *chan,
-                           enum dma_transfer_direction dir)
-{
-        sg_init_table(sg, 1);
-        sg_set_buf(sg, buf, len);
-        sg_dma_len(sg) = len;
-        return dma_map_sg(chan->device->dev, sg, 1, dir);
-}
-
-static void rspi_dma_unmap_sg(struct scatterlist *sg, struct dma_chan *chan,
-                              enum dma_transfer_direction dir)
-{
-        dma_unmap_sg(chan->device->dev, sg, 1, dir);
-}
-
-static void rspi_memory_to_8bit(void *buf, const void *data, unsigned len)
-{
-        u16 *dst = buf;
-        const u8 *src = data;
-
-        while (len) {
-                *dst++ = (u16)(*src++);
-                len--;
-        }
-}
-
-static void rspi_memory_from_8bit(void *buf, const void *data, unsigned len)
-{
-        u8 *dst = buf;
-        const u16 *src = data;
-
-        while (len) {
-                *dst++ = (u8)*src++;
-                len--;
-        }
-}
-
-static int rspi_send_dma(struct rspi_data *rspi, struct spi_transfer *t)
-{
-        struct scatterlist sg;
-        void *buf = NULL;
-        struct dma_async_tx_descriptor *desc;
-        unsigned len;
-        int ret = 0;
-
-        if (rspi->dma_width_16bit) {
-                /*
-                 * If DMAC bus width is 16-bit, the driver allocates a dummy
-                 * buffer. And, the driver converts original data into the
-                 * DMAC data as the following format:
-                 *  original data: 1st byte, 2nd byte ...
-                 *  DMAC data:     1st byte, dummy, 2nd byte, dummy ...
-                 */
-                len = t->len * 2;
-                buf = kmalloc(len, GFP_KERNEL);
-                if (!buf)
-                        return -ENOMEM;
-                rspi_memory_to_8bit(buf, t->tx_buf, t->len);
-        } else {
-                len = t->len;
-                buf = (void *)t->tx_buf;
-        }
-
-        if (!rspi_dma_map_sg(&sg, buf, len, rspi->chan_tx, DMA_TO_DEVICE)) {
-                ret = -EFAULT;
-                goto end_nomap;
-        }
-        desc = dmaengine_prep_slave_sg(rspi->chan_tx, &sg, 1, DMA_TO_DEVICE,
-                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        if (!desc) {
-                ret = -EIO;
-                goto end;
-        }
-
-        /*
-         * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
-         * called. So, this driver disables the IRQ while DMA transfer.
-         */
-        disable_irq(rspi->irq);
-
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) | SPCR_TXMD, RSPI_SPCR);
-        rspi_enable_irq(rspi, SPCR_SPTIE);
-        rspi->dma_callbacked = 0;
-
-        desc->callback = rspi_dma_complete;
-        desc->callback_param = rspi;
-        dmaengine_submit(desc);
-        dma_async_issue_pending(rspi->chan_tx);
-
-        ret = wait_event_interruptible_timeout(rspi->wait,
-                                               rspi->dma_callbacked, HZ);
-        if (ret > 0 && rspi->dma_callbacked)
-                ret = 0;
-        else if (!ret)
-                ret = -ETIMEDOUT;
-        rspi_disable_irq(rspi, SPCR_SPTIE);
-
-        enable_irq(rspi->irq);
-
-end:
-        rspi_dma_unmap_sg(&sg, rspi->chan_tx, DMA_TO_DEVICE);
-end_nomap:
-        if (rspi->dma_width_16bit)
-                kfree(buf);
-
-        return ret;
-}
-
-static void rspi_receive_init(struct rspi_data *rspi)
-{
-        unsigned char spsr;
-
-        spsr = rspi_read8(rspi, RSPI_SPSR);
-        if (spsr & SPSR_SPRF)
-                rspi_read16(rspi, RSPI_SPDR);   /* dummy read */
-        if (spsr & SPSR_OVRF)
-                rspi_write8(rspi, rspi_read8(rspi, RSPI_SPSR) & ~SPSR_OVRF,
-                            RSPI_SPCR);
-}
-
-static int rspi_receive_pio(struct rspi_data *rspi, struct spi_message *mesg,
-                            struct spi_transfer *t)
-{
-        int remain = t->len;
-        u8 *data;
-
-        rspi_receive_init(rspi);
-
-        data = (u8 *)t->rx_buf;
-        while (remain > 0) {
-                rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) & ~SPCR_TXMD,
-                            RSPI_SPCR);
-
-                if (rspi_wait_for_interrupt(rspi, SPSR_SPTEF, SPCR_SPTIE) < 0) {
-                        dev_err(&rspi->master->dev,
-                                "%s: tx empty timeout\n", __func__);
-                        return -ETIMEDOUT;
-                }
-                /* dummy write for generate clock */
-                rspi_write16(rspi, 0x00, RSPI_SPDR);
-
-                if (rspi_wait_for_interrupt(rspi, SPSR_SPRF, SPCR_SPRIE) < 0) {
-                        dev_err(&rspi->master->dev,
-                                "%s: receive timeout\n", __func__);
-                        return -ETIMEDOUT;
-                }
-                /* SPDR allows 16 or 32-bit access only */
-                *data = (u8)rspi_read16(rspi, RSPI_SPDR);
-
-                data++;
-                remain--;
-        }
-
-        return 0;
-}
-
-static int rspi_receive_dma(struct rspi_data *rspi, struct spi_transfer *t)
-{
-        struct scatterlist sg, sg_dummy;
-        void *dummy = NULL, *rx_buf = NULL;
-        struct dma_async_tx_descriptor *desc, *desc_dummy;
-        unsigned len;
-        int ret = 0;
-
-        if (rspi->dma_width_16bit) {
-                /*
-                 * If DMAC bus width is 16-bit, the driver allocates a dummy
-                 * buffer. And, finally the driver converts the DMAC data into
-                 * actual data as the following format:
-                 *  DMAC data:   1st byte, dummy, 2nd byte, dummy ...
-                 *  actual data: 1st byte, 2nd byte ...
-                 */
-                len = t->len * 2;
-                rx_buf = kmalloc(len, GFP_KERNEL);
-                if (!rx_buf)
-                        return -ENOMEM;
-         } else {
-                len = t->len;
-                rx_buf = t->rx_buf;
-        }
-
-        /* prepare dummy transfer to generate SPI clocks */
-        dummy = kzalloc(len, GFP_KERNEL);
-        if (!dummy) {
-                ret = -ENOMEM;
-                goto end_nomap;
-        }
-        if (!rspi_dma_map_sg(&sg_dummy, dummy, len, rspi->chan_tx,
-                             DMA_TO_DEVICE)) {
-                ret = -EFAULT;
-                goto end_nomap;
-        }
-        desc_dummy = dmaengine_prep_slave_sg(rspi->chan_tx, &sg_dummy, 1,
-                        DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        if (!desc_dummy) {
-                ret = -EIO;
-                goto end_dummy_mapped;
-        }
-
-        /* prepare receive transfer */
-        if (!rspi_dma_map_sg(&sg, rx_buf, len, rspi->chan_rx,
-                             DMA_FROM_DEVICE)) {
-                ret = -EFAULT;
-                goto end_dummy_mapped;
-
-        }
-        desc = dmaengine_prep_slave_sg(rspi->chan_rx, &sg, 1, DMA_FROM_DEVICE,
-                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
-        if (!desc) {
-                ret = -EIO;
-                goto end;
-        }
-
-        rspi_receive_init(rspi);
-
-        /*
-         * DMAC needs SPTIE, but if SPTIE is set, this IRQ routine will be
-         * called. So, this driver disables the IRQ while DMA transfer.
-         */
-        disable_irq(rspi->irq);
-
-        rspi_write8(rspi, rspi_read8(rspi, RSPI_SPCR) & ~SPCR_TXMD, RSPI_SPCR);
-        rspi_enable_irq(rspi, SPCR_SPTIE | SPCR_SPRIE);
-        rspi->dma_callbacked = 0;
-
-        desc->callback = rspi_dma_complete;
-        desc->callback_param = rspi;
-        dmaengine_submit(desc);
-        dma_async_issue_pending(rspi->chan_rx);
-
-        desc_dummy->callback = NULL;    /* No callback */
-        dmaengine_submit(desc_dummy);
-        dma_async_issue_pending(rspi->chan_tx);
-
-        ret = wait_event_interruptible_timeout(rspi->wait,
-                                               rspi->dma_callbacked, HZ);
-        if (ret > 0 && rspi->dma_callbacked)
-                ret = 0;
-        else if (!ret)
-                ret = -ETIMEDOUT;
-        rspi_disable_irq(rspi, SPCR_SPTIE | SPCR_SPRIE);
-
-        enable_irq(rspi->irq);
-
-end:
-        rspi_dma_unmap_sg(&sg, rspi->chan_rx, DMA_FROM_DEVICE);
-end_dummy_mapped:
-        rspi_dma_unmap_sg(&sg_dummy, rspi->chan_tx, DMA_TO_DEVICE);
-end_nomap:
-        if (rspi->dma_width_16bit) {
-                if (!ret)
-                        rspi_memory_from_8bit(t->rx_buf, rx_buf, t->len);
-                kfree(rx_buf);
-        }
-        kfree(dummy);
-
-        return ret;
-}
-
-static int rspi_is_dma(struct rspi_data *rspi, struct spi_transfer *t)
-{
-        if (t->tx_buf && rspi->chan_tx)
-                return 1;
-        /* If the module receives data by DMAC, it also needs TX DMAC */
-        if (t->rx_buf && rspi->chan_tx && rspi->chan_rx)
-                return 1;
-
-        return 0;
-}
-
-static void rspi_work(struct work_struct *work)
-{
-        struct rspi_data *rspi = container_of(work, struct rspi_data, ws);
-        struct spi_message *mesg;
-        struct spi_transfer *t;
-        unsigned long flags;
-        int ret;
-
-        spin_lock_irqsave(&rspi->lock, flags);
-        while (!list_empty(&rspi->queue)) {
-                mesg = list_entry(rspi->queue.next, struct spi_message, queue);
-                list_del_init(&mesg->queue);
-                spin_unlock_irqrestore(&rspi->lock, flags);
-
-                rspi_assert_ssl(rspi);
-
-                list_for_each_entry(t, &mesg->transfers, transfer_list) {
-                        if (t->tx_buf) {
-                                if (rspi_is_dma(rspi, t))
-                                        ret = rspi_send_dma(rspi, t);
-                                else
-                                        ret = rspi_send_pio(rspi, mesg, t);
-                                if (ret < 0)
-                                        goto error;
-                        }
-                        if (t->rx_buf) {
-                                if (rspi_is_dma(rspi, t))
-                                        ret = rspi_receive_dma(rspi, t);
-                                else
-                                        ret = rspi_receive_pio(rspi, mesg, t);
-                                if (ret < 0)
-                                        goto error;
-                        }
-                        mesg->actual_length += t->len;
-                }
-                rspi_negate_ssl(rspi);
-
-                mesg->status = 0;
-                mesg->complete(mesg->context);
-
-                spin_lock_irqsave(&rspi->lock, flags);
-        }
-
-        return;
-
-error:
-        mesg->status = ret;
-        mesg->complete(mesg->context);
-}
-
-static int rspi_setup(struct spi_device *spi)
-{
-        struct rspi_data *rspi = spi_master_get_devdata(spi->master);
-
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-        rspi->max_speed_hz = spi->max_speed_hz;
-
-        rspi_set_config_register(rspi, 8);
-
-        return 0;
-}
-
-static int rspi_transfer(struct spi_device *spi, struct spi_message *mesg)
-{
-        struct rspi_data *rspi = spi_master_get_devdata(spi->master);
-        unsigned long flags;
-
-        mesg->actual_length = 0;
-        mesg->status = -EINPROGRESS;
-
-        spin_lock_irqsave(&rspi->lock, flags);
-        list_add_tail(&mesg->queue, &rspi->queue);
-        schedule_work(&rspi->ws);
-        spin_unlock_irqrestore(&rspi->lock, flags);
-
-        return 0;
-}
-
-static void rspi_cleanup(struct spi_device *spi)
-{
-}
-
-static irqreturn_t rspi_irq(int irq, void *_sr)
-{
-        struct rspi_data *rspi = (struct rspi_data *)_sr;
-        unsigned long spsr;
-        irqreturn_t ret = IRQ_NONE;
-        unsigned char disable_irq = 0;
-
-        rspi->spsr = spsr = rspi_read8(rspi, RSPI_SPSR);
-        if (spsr & SPSR_SPRF)
-                disable_irq |= SPCR_SPRIE;
-        if (spsr & SPSR_SPTEF)
-                disable_irq |= SPCR_SPTIE;
-
-        if (disable_irq) {
-                ret = IRQ_HANDLED;
-                rspi_disable_irq(rspi, disable_irq);
-                wake_up(&rspi->wait);
-        }
-
-        return ret;
-}
-
-static int rspi_request_dma(struct rspi_data *rspi,
-                                      struct platform_device *pdev)
-{
-        struct rspi_plat_data *rspi_pd = pdev->dev.platform_data;
-        dma_cap_mask_t mask;
-        struct dma_slave_config cfg;
-        int ret;
-
-        if (!rspi_pd)
-                return 0;       /* The driver assumes no error. */
-
-        rspi->dma_width_16bit = rspi_pd->dma_width_16bit;
-
-        /* If the module receives data by DMAC, it also needs TX DMAC */
-        if (rspi_pd->dma_rx_id && rspi_pd->dma_tx_id) {
-                dma_cap_zero(mask);
-                dma_cap_set(DMA_SLAVE, mask);
-                rspi->chan_rx = dma_request_channel(mask, shdma_chan_filter,
-                                                    (void *)rspi_pd->dma_rx_id);
-                if (rspi->chan_rx) {
-                        cfg.slave_id = rspi_pd->dma_rx_id;
-                        cfg.direction = DMA_DEV_TO_MEM;
-                        ret = dmaengine_slave_config(rspi->chan_rx, &cfg);
-                        if (!ret)
-                                dev_info(&pdev->dev, "Use DMA when rx.\n");
-                        else
-                                return ret;
-                }
-        }
-        if (rspi_pd->dma_tx_id) {
-                dma_cap_zero(mask);
-                dma_cap_set(DMA_SLAVE, mask);
-                rspi->chan_tx = dma_request_channel(mask, shdma_chan_filter,
-                                                    (void *)rspi_pd->dma_tx_id);
-                if (rspi->chan_tx) {
-                        cfg.slave_id = rspi_pd->dma_tx_id;
-                        cfg.direction = DMA_MEM_TO_DEV;
-                        ret = dmaengine_slave_config(rspi->chan_tx, &cfg);
-                        if (!ret)
-                                dev_info(&pdev->dev, "Use DMA when tx\n");
-                        else
-                                return ret;
-                }
-        }
-
-        return 0;
-}
-
-static void rspi_release_dma(struct rspi_data *rspi)
-{
-        if (rspi->chan_tx)
-                dma_release_channel(rspi->chan_tx);
-        if (rspi->chan_rx)
-                dma_release_channel(rspi->chan_rx);
-}
-
-static int rspi_remove(struct platform_device *pdev)
-{
-        struct rspi_data *rspi = dev_get_drvdata(&pdev->dev);
-
-        spi_unregister_master(rspi->master);
-        rspi_release_dma(rspi);
-        free_irq(platform_get_irq(pdev, 0), rspi);
-        clk_put(rspi->clk);
-        iounmap(rspi->addr);
-        spi_master_put(rspi->master);
-
-        return 0;
-}
-
-static int rspi_probe(struct platform_device *pdev)
-{
-        struct resource *res;
-        struct spi_master *master;
-        struct rspi_data *rspi;
-        int ret, irq;
-        char clk_name[16];
-
-        /* get base addr */
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (unlikely(res == NULL)) {
-                dev_err(&pdev->dev, "invalid resource\n");
-                return -EINVAL;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_err(&pdev->dev, "platform_get_irq error\n");
-                return -ENODEV;
-        }
-
-        master = spi_alloc_master(&pdev->dev, sizeof(struct rspi_data));
-        if (master == NULL) {
-                dev_err(&pdev->dev, "spi_alloc_master error.\n");
-                return -ENOMEM;
-        }
-
-        rspi = spi_master_get_devdata(master);
-        dev_set_drvdata(&pdev->dev, rspi);
-
-        rspi->master = master;
-        rspi->addr = ioremap(res->start, resource_size(res));
-        if (rspi->addr == NULL) {
-                dev_err(&pdev->dev, "ioremap error.\n");
-                ret = -ENOMEM;
-                goto error1;
-        }
-
-        snprintf(clk_name, sizeof(clk_name), "rspi%d", pdev->id);
-        rspi->clk = clk_get(&pdev->dev, clk_name);
-        if (IS_ERR(rspi->clk)) {
-                dev_err(&pdev->dev, "cannot get clock\n");
-                ret = PTR_ERR(rspi->clk);
-                goto error2;
-        }
-        clk_enable(rspi->clk);
-
-        INIT_LIST_HEAD(&rspi->queue);
-        spin_lock_init(&rspi->lock);
-        INIT_WORK(&rspi->ws, rspi_work);
-        init_waitqueue_head(&rspi->wait);
-
-        master->num_chipselect = 2;
-        master->bus_num = pdev->id;
-        master->setup = rspi_setup;
-        master->transfer = rspi_transfer;
-        master->cleanup = rspi_cleanup;
-
-        ret = request_irq(irq, rspi_irq, 0, dev_name(&pdev->dev), rspi);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "request_irq error\n");
-                goto error3;
-        }
-
-        rspi->irq = irq;
-        ret = rspi_request_dma(rspi, pdev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "rspi_request_dma failed.\n");
-                goto error4;
-        }
-
-        ret = spi_register_master(master);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "spi_register_master error.\n");
-                goto error4;
-        }
-
-        dev_info(&pdev->dev, "probed\n");
-
-        return 0;
-
-error4:
-        rspi_release_dma(rspi);
-        free_irq(irq, rspi);
-error3:
-        clk_put(rspi->clk);
-error2:
-        iounmap(rspi->addr);
-error1:
-        spi_master_put(master);
-
-        return ret;
-}
-
-static struct platform_driver rspi_driver = {
-        .probe =        rspi_probe,
-        .remove =       rspi_remove,
-        .driver         = {
-                .name = "rspi",
-                .owner  = THIS_MODULE,
-        },
-};
-module_platform_driver(rspi_driver);
-
-MODULE_DESCRIPTION("Renesas RSPI bus driver");
-MODULE_LICENSE("GPL v2");
-MODULE_AUTHOR("Yoshihiro Shimoda");
-MODULE_ALIAS("platform:rspi");
diff --git a/drivers/spi/spi-s3c24xx.c b/drivers/spi/spi-s3c24xx.c
index 02d64603fcc..1996ac57ef9 100644
--- a/drivers/spi/spi-s3c24xx.c
+++ b/drivers/spi/spi-s3c24xx.c
@@ -24,10 +24,9 @@
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
-#include <linux/spi/s3c24xx.h>
-#include <linux/module.h>
 
 #include <plat/regs-spi.h>
+#include <mach/spi.h>
 
 #include <plat/fiq.h>
 #include <asm/fiq.h>
@@ -506,7 +505,7 @@ static void s3c24xx_spi_initialsetup(struct s3c24xx_spi *hw)
         }
 }
 
-static int s3c24xx_spi_probe(struct platform_device *pdev)
+static int __init s3c24xx_spi_probe(struct platform_device *pdev)
 {
         struct s3c2410_spi_info *pdata;
         struct s3c24xx_spi *hw;
@@ -611,7 +610,6 @@ static int s3c24xx_spi_probe(struct platform_device *pdev)
         if (!pdata->set_cs) {
                 if (pdata->pin_cs < 0) {
                         dev_err(&pdev->dev, "No chipselect pin\n");
-                        err = -EINVAL;
                         goto err_register;
                 }
 
@@ -663,7 +661,7 @@ static int s3c24xx_spi_probe(struct platform_device *pdev)
         return err;
 }
 
-static int s3c24xx_spi_remove(struct platform_device *dev)
+static int __exit s3c24xx_spi_remove(struct platform_device *dev)
 {
         struct s3c24xx_spi *hw = platform_get_drvdata(dev);
 
@@ -721,15 +719,26 @@ static const struct dev_pm_ops s3c24xx_spi_pmops = {
 
 MODULE_ALIAS("platform:s3c2410-spi");
 static struct platform_driver s3c24xx_spi_driver = {
-        .probe          = s3c24xx_spi_probe,
-        .remove         = s3c24xx_spi_remove,
+        .remove         = __exit_p(s3c24xx_spi_remove),
         .driver         = {
                 .name   = "s3c2410-spi",
                 .owner  = THIS_MODULE,
                 .pm     = S3C24XX_SPI_PMOPS,
         },
 };
-module_platform_driver(s3c24xx_spi_driver);
+
+static int __init s3c24xx_spi_init(void)
+{
+        return platform_driver_probe(&s3c24xx_spi_driver, s3c24xx_spi_probe);
+}
+
+static void __exit s3c24xx_spi_exit(void)
+{
+        platform_driver_unregister(&s3c24xx_spi_driver);
+}
+
+module_init(s3c24xx_spi_init);
+module_exit(s3c24xx_spi_exit);
 
 MODULE_DESCRIPTION("S3C24XX SPI Driver");
 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
diff --git a/drivers/spi/spi-s3c64xx.c b/drivers/spi/spi-s3c64xx.c
index ad93231a803..595dacc7645 100644
--- a/drivers/spi/spi-s3c64xx.c
+++ b/drivers/spi/spi-s3c64xx.c
@@ -20,21 +20,14 @@
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/workqueue.h>
-#include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
 #include <linux/spi/spi.h>
-#include <linux/gpio.h>
-#include <linux/of.h>
-#include <linux/of_gpio.h>
 
 #include <mach/dma.h>
-#include <linux/platform_data/spi-s3c64xx.h>
-
-#define MAX_SPI_PORTS           3
+#include <plat/s3c64xx-spi.h>
 
 /* Registers and bit-fields */
 
@@ -79,6 +72,11 @@
 #define S3C64XX_SPI_SLAVE_AUTO                  (1<<1)
 #define S3C64XX_SPI_SLAVE_SIG_INACT             (1<<0)
 
+#define S3C64XX_SPI_ACT(c) writel(0, (c)->regs + S3C64XX_SPI_SLAVE_SEL)
+
+#define S3C64XX_SPI_DEACT(c) writel(S3C64XX_SPI_SLAVE_SIG_INACT, \
+                                        (c)->regs + S3C64XX_SPI_SLAVE_SEL)
+
 #define S3C64XX_SPI_INT_TRAILING_EN             (1<<6)
 #define S3C64XX_SPI_INT_RX_OVERRUN_EN           (1<<5)
 #define S3C64XX_SPI_INT_RX_UNDERRUN_EN          (1<<4)
@@ -113,12 +111,13 @@
 
 #define S3C64XX_SPI_FBCLK_MSK           (3<<0)
 
-#define FIFO_LVL_MASK(i) ((i)->port_conf->fifo_lvl_mask[i->port_id])
-#define S3C64XX_SPI_ST_TX_DONE(v, i) (((v) & \
-                                (1 << (i)->port_conf->tx_st_done)) ? 1 : 0)
-#define TX_FIFO_LVL(v, i) (((v) >> 6) & FIFO_LVL_MASK(i))
-#define RX_FIFO_LVL(v, i) (((v) >> (i)->port_conf->rx_lvl_offset) & \
-                                        FIFO_LVL_MASK(i))
+#define S3C64XX_SPI_ST_TRLCNTZ(v, i) ((((v) >> (i)->rx_lvl_offset) & \
+                                        (((i)->fifo_lvl_mask + 1))) \
+                                        ? 1 : 0)
+
+#define S3C64XX_SPI_ST_TX_DONE(v, i) (((v) & (1 << (i)->tx_st_done)) ? 1 : 0)
+#define TX_FIFO_LVL(v, i) (((v) >> 6) & (i)->fifo_lvl_mask)
+#define RX_FIFO_LVL(v, i) (((v) >> (i)->rx_lvl_offset) & (i)->fifo_lvl_mask)
 
 #define S3C64XX_SPI_MAX_TRAILCNT        0x3ff
 #define S3C64XX_SPI_TRAILCNT_OFF        19
@@ -127,45 +126,20 @@
 
 #define msecs_to_loops(t) (loops_per_jiffy / 1000 * HZ * t)
 
+#define SUSPND    (1<<0)
+#define SPIBUSY   (1<<1)
 #define RXBUSY    (1<<2)
 #define TXBUSY    (1<<3)
 
-struct s3c64xx_spi_dma_data {
-        unsigned                ch;
-        enum dma_transfer_direction direction;
-        enum dma_ch     dmach;
-        struct property         *dma_prop;
-};
-
-/**
- * struct s3c64xx_spi_info - SPI Controller hardware info
- * @fifo_lvl_mask: Bit-mask for {TX|RX}_FIFO_LVL bits in SPI_STATUS register.
- * @rx_lvl_offset: Bit offset of RX_FIFO_LVL bits in SPI_STATUS regiter.
- * @tx_st_done: Bit offset of TX_DONE bit in SPI_STATUS regiter.
- * @high_speed: True, if the controller supports HIGH_SPEED_EN bit.
- * @clk_from_cmu: True, if the controller does not include a clock mux and
- *      prescaler unit.
- *
- * The Samsung s3c64xx SPI controller are used on various Samsung SoC's but
- * differ in some aspects such as the size of the fifo and spi bus clock
- * setup. Such differences are specified to the driver using this structure
- * which is provided as driver data to the driver.
- */
-struct s3c64xx_spi_port_config {
-        int     fifo_lvl_mask[MAX_SPI_PORTS];
-        int     rx_lvl_offset;
-        int     tx_st_done;
-        bool    high_speed;
-        bool    clk_from_cmu;
-};
-
 /**
  * struct s3c64xx_spi_driver_data - Runtime info holder for SPI driver.
  * @clk: Pointer to the spi clock.
  * @src_clk: Pointer to the clock used to generate SPI signals.
  * @master: Pointer to the SPI Protocol master.
+ * @workqueue: Work queue for the SPI xfer requests.
  * @cntrlr_info: Platform specific data for the controller this driver manages.
  * @tgl_spi: Pointer to the last CS left untoggled by the cs_change hint.
+ * @work: Work
  * @queue: To log SPI xfer requests.
  * @lock: Controller specific lock.
  * @state: Set of FLAGS to indicate status.
@@ -173,7 +147,6 @@ struct s3c64xx_spi_port_config {
  * @tx_dmach: Controller's DMA channel for Tx.
  * @sfr_start: BUS address of SPI controller regs.
  * @regs: Pointer to ioremap'ed controller registers.
- * @irq: interrupt
  * @xfer_completion: To indicate completion of xfer task.
  * @cur_mode: Stores the active configuration of the controller.
  * @cur_bpw: Stores the active bits per word settings.
@@ -185,21 +158,19 @@ struct s3c64xx_spi_driver_data {
         struct clk                      *src_clk;
         struct platform_device          *pdev;
         struct spi_master               *master;
+        struct workqueue_struct         *workqueue;
         struct s3c64xx_spi_info  *cntrlr_info;
         struct spi_device               *tgl_spi;
+        struct work_struct              work;
         struct list_head                queue;
         spinlock_t                      lock;
+        enum dma_ch                     rx_dmach;
+        enum dma_ch                     tx_dmach;
         unsigned long                   sfr_start;
         struct completion               xfer_completion;
         unsigned                        state;
         unsigned                        cur_mode, cur_bpw;
         unsigned                        cur_speed;
-        struct s3c64xx_spi_dma_data     rx_dma;
-        struct s3c64xx_spi_dma_data     tx_dma;
-        struct samsung_dma_ops          *ops;
-        struct s3c64xx_spi_port_config  *port_conf;
-        unsigned int                    port_id;
-        unsigned long                   gpios[4];
 };
 
 static struct s3c2410_dma_client s3c64xx_spi_dma_client = {
@@ -208,6 +179,7 @@ static struct s3c2410_dma_client s3c64xx_spi_dma_client = {
 
 static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         unsigned long loops;
         u32 val;
@@ -215,10 +187,6 @@ static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
         writel(0, regs + S3C64XX_SPI_PACKET_CNT);
 
         val = readl(regs + S3C64XX_SPI_CH_CFG);
-        val &= ~(S3C64XX_SPI_CH_RXCH_ON | S3C64XX_SPI_CH_TXCH_ON);
-        writel(val, regs + S3C64XX_SPI_CH_CFG);
-
-        val = readl(regs + S3C64XX_SPI_CH_CFG);
         val |= S3C64XX_SPI_CH_SW_RST;
         val &= ~S3C64XX_SPI_CH_HS_EN;
         writel(val, regs + S3C64XX_SPI_CH_CFG);
@@ -227,7 +195,7 @@ static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
         loops = msecs_to_loops(1);
         do {
                 val = readl(regs + S3C64XX_SPI_STATUS);
-        } while (TX_FIFO_LVL(val, sdd) && loops--);
+        } while (TX_FIFO_LVL(val, sci) && loops--);
 
         if (loops == 0)
                 dev_warn(&sdd->pdev->dev, "Timed out flushing TX FIFO\n");
@@ -236,7 +204,7 @@ static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
         loops = msecs_to_loops(1);
         do {
                 val = readl(regs + S3C64XX_SPI_STATUS);
-                if (RX_FIFO_LVL(val, sdd))
+                if (RX_FIFO_LVL(val, sci))
                         readl(regs + S3C64XX_SPI_RX_DATA);
                 else
                         break;
@@ -252,91 +220,17 @@ static void flush_fifo(struct s3c64xx_spi_driver_data *sdd)
         val = readl(regs + S3C64XX_SPI_MODE_CFG);
         val &= ~(S3C64XX_SPI_MODE_TXDMA_ON | S3C64XX_SPI_MODE_RXDMA_ON);
         writel(val, regs + S3C64XX_SPI_MODE_CFG);
-}
-
-static void s3c64xx_spi_dmacb(void *data)
-{
-        struct s3c64xx_spi_driver_data *sdd;
-        struct s3c64xx_spi_dma_data *dma = data;
-        unsigned long flags;
-
-        if (dma->direction == DMA_DEV_TO_MEM)
-                sdd = container_of(data,
-                        struct s3c64xx_spi_driver_data, rx_dma);
-        else
-                sdd = container_of(data,
-                        struct s3c64xx_spi_driver_data, tx_dma);
-
-        spin_lock_irqsave(&sdd->lock, flags);
-
-        if (dma->direction == DMA_DEV_TO_MEM) {
-                sdd->state &= ~RXBUSY;
-                if (!(sdd->state & TXBUSY))
-                        complete(&sdd->xfer_completion);
-        } else {
-                sdd->state &= ~TXBUSY;
-                if (!(sdd->state & RXBUSY))
-                        complete(&sdd->xfer_completion);
-        }
-
-        spin_unlock_irqrestore(&sdd->lock, flags);
-}
-
-static void prepare_dma(struct s3c64xx_spi_dma_data *dma,
-                                        unsigned len, dma_addr_t buf)
-{
-        struct s3c64xx_spi_driver_data *sdd;
-        struct samsung_dma_prep info;
-        struct samsung_dma_config config;
-
-        if (dma->direction == DMA_DEV_TO_MEM) {
-                sdd = container_of((void *)dma,
-                        struct s3c64xx_spi_driver_data, rx_dma);
-                config.direction = sdd->rx_dma.direction;
-                config.fifo = sdd->sfr_start + S3C64XX_SPI_RX_DATA;
-                config.width = sdd->cur_bpw / 8;
-                sdd->ops->config(sdd->rx_dma.ch, &config);
-        } else {
-                sdd = container_of((void *)dma,
-                        struct s3c64xx_spi_driver_data, tx_dma);
-                config.direction =  sdd->tx_dma.direction;
-                config.fifo = sdd->sfr_start + S3C64XX_SPI_TX_DATA;
-                config.width = sdd->cur_bpw / 8;
-                sdd->ops->config(sdd->tx_dma.ch, &config);
-        }
 
-        info.cap = DMA_SLAVE;
-        info.len = len;
-        info.fp = s3c64xx_spi_dmacb;
-        info.fp_param = dma;
-        info.direction = dma->direction;
-        info.buf = buf;
-
-        sdd->ops->prepare(dma->ch, &info);
-        sdd->ops->trigger(dma->ch);
-}
-
-static int acquire_dma(struct s3c64xx_spi_driver_data *sdd)
-{
-        struct samsung_dma_req req;
-
-        sdd->ops = samsung_dma_get_ops();
-
-        req.cap = DMA_SLAVE;
-        req.client = &s3c64xx_spi_dma_client;
-
-        req.dt_dmach_prop = sdd->rx_dma.dma_prop;
-        sdd->rx_dma.ch = sdd->ops->request(sdd->rx_dma.dmach, &req);
-        req.dt_dmach_prop = sdd->tx_dma.dma_prop;
-        sdd->tx_dma.ch = sdd->ops->request(sdd->tx_dma.dmach, &req);
-
-        return 1;
+        val = readl(regs + S3C64XX_SPI_CH_CFG);
+        val &= ~(S3C64XX_SPI_CH_RXCH_ON | S3C64XX_SPI_CH_TXCH_ON);
+        writel(val, regs + S3C64XX_SPI_CH_CFG);
 }
 
 static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                                 struct spi_device *spi,
                                 struct spi_transfer *xfer, int dma_mode)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         u32 modecfg, chcfg;
 
@@ -364,7 +258,10 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                 chcfg |= S3C64XX_SPI_CH_TXCH_ON;
                 if (dma_mode) {
                         modecfg |= S3C64XX_SPI_MODE_TXDMA_ON;
-                        prepare_dma(&sdd->tx_dma, xfer->len, xfer->tx_dma);
+                        s3c2410_dma_config(sdd->tx_dmach, sdd->cur_bpw / 8);
+                        s3c2410_dma_enqueue(sdd->tx_dmach, (void *)sdd,
+                                                xfer->tx_dma, xfer->len);
+                        s3c2410_dma_ctrl(sdd->tx_dmach, S3C2410_DMAOP_START);
                 } else {
                         switch (sdd->cur_bpw) {
                         case 32:
@@ -386,7 +283,7 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
         if (xfer->rx_buf != NULL) {
                 sdd->state |= RXBUSY;
 
-                if (sdd->port_conf->high_speed && sdd->cur_speed >= 30000000UL
+                if (sci->high_speed && sdd->cur_speed >= 30000000UL
                                         && !(sdd->cur_mode & SPI_CPHA))
                         chcfg |= S3C64XX_SPI_CH_HS_EN;
 
@@ -396,7 +293,10 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                         writel(((xfer->len * 8 / sdd->cur_bpw) & 0xffff)
                                         | S3C64XX_SPI_PACKET_CNT_EN,
                                         regs + S3C64XX_SPI_PACKET_CNT);
-                        prepare_dma(&sdd->rx_dma, xfer->len, xfer->rx_dma);
+                        s3c2410_dma_config(sdd->rx_dmach, sdd->cur_bpw / 8);
+                        s3c2410_dma_enqueue(sdd->rx_dmach, (void *)sdd,
+                                                xfer->rx_dma, xfer->len);
+                        s3c2410_dma_ctrl(sdd->rx_dmach, S3C2410_DMAOP_START);
                 }
         }
 
@@ -413,19 +313,20 @@ static inline void enable_cs(struct s3c64xx_spi_driver_data *sdd,
                 if (sdd->tgl_spi != spi) { /* if last mssg on diff device */
                         /* Deselect the last toggled device */
                         cs = sdd->tgl_spi->controller_data;
-                        gpio_set_value(cs->line,
-                                spi->mode & SPI_CS_HIGH ? 0 : 1);
+                        cs->set_level(cs->line,
+                                        spi->mode & SPI_CS_HIGH ? 0 : 1);
                 }
                 sdd->tgl_spi = NULL;
         }
 
         cs = spi->controller_data;
-        gpio_set_value(cs->line, spi->mode & SPI_CS_HIGH ? 1 : 0);
+        cs->set_level(cs->line, spi->mode & SPI_CS_HIGH ? 1 : 0);
 }
 
 static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,
                                 struct spi_transfer *xfer, int dma_mode)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         unsigned long val;
         int ms;
@@ -442,7 +343,7 @@ static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,
                 val = msecs_to_loops(ms);
                 do {
                         status = readl(regs + S3C64XX_SPI_STATUS);
-                } while (RX_FIFO_LVL(status, sdd) < xfer->len && --val);
+                } while (RX_FIFO_LVL(status, sci) < xfer->len && --val);
         }
 
         if (!val)
@@ -461,8 +362,8 @@ static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,
                 if (xfer->rx_buf == NULL) {
                         val = msecs_to_loops(10);
                         status = readl(regs + S3C64XX_SPI_STATUS);
-                        while ((TX_FIFO_LVL(status, sdd)
-                                || !S3C64XX_SPI_ST_TX_DONE(status, sdd))
+                        while ((TX_FIFO_LVL(status, sci)
+                                || !S3C64XX_SPI_ST_TX_DONE(status, sci))
                                         && --val) {
                                 cpu_relax();
                                 status = readl(regs + S3C64XX_SPI_STATUS);
@@ -506,17 +407,18 @@ static inline void disable_cs(struct s3c64xx_spi_driver_data *sdd,
         if (sdd->tgl_spi == spi)
                 sdd->tgl_spi = NULL;
 
-        gpio_set_value(cs->line, spi->mode & SPI_CS_HIGH ? 0 : 1);
+        cs->set_level(cs->line, spi->mode & SPI_CS_HIGH ? 0 : 1);
 }
 
 static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         u32 val;
 
         /* Disable Clock */
-        if (sdd->port_conf->clk_from_cmu) {
-                clk_disable_unprepare(sdd->src_clk);
+        if (sci->clk_from_cmu) {
+                clk_disable(sdd->src_clk);
         } else {
                 val = readl(regs + S3C64XX_SPI_CLK_CFG);
                 val &= ~S3C64XX_SPI_ENCLK_ENABLE;
@@ -559,12 +461,12 @@ static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
 
         writel(val, regs + S3C64XX_SPI_MODE_CFG);
 
-        if (sdd->port_conf->clk_from_cmu) {
+        if (sci->clk_from_cmu) {
                 /* Configure Clock */
                 /* There is half-multiplier before the SPI */
                 clk_set_rate(sdd->src_clk, sdd->cur_speed * 2);
                 /* Enable Clock */
-                clk_prepare_enable(sdd->src_clk);
+                clk_enable(sdd->src_clk);
         } else {
                 /* Configure Clock */
                 val = readl(regs + S3C64XX_SPI_CLK_CFG);
@@ -580,11 +482,52 @@ static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
         }
 }
 
+static void s3c64xx_spi_dma_rxcb(struct s3c2410_dma_chan *chan, void *buf_id,
+                                 int size, enum s3c2410_dma_buffresult res)
+{
+        struct s3c64xx_spi_driver_data *sdd = buf_id;
+        unsigned long flags;
+
+        spin_lock_irqsave(&sdd->lock, flags);
+
+        if (res == S3C2410_RES_OK)
+                sdd->state &= ~RXBUSY;
+        else
+                dev_err(&sdd->pdev->dev, "DmaAbrtRx-%d\n", size);
+
+        /* If the other done */
+        if (!(sdd->state & TXBUSY))
+                complete(&sdd->xfer_completion);
+
+        spin_unlock_irqrestore(&sdd->lock, flags);
+}
+
+static void s3c64xx_spi_dma_txcb(struct s3c2410_dma_chan *chan, void *buf_id,
+                                 int size, enum s3c2410_dma_buffresult res)
+{
+        struct s3c64xx_spi_driver_data *sdd = buf_id;
+        unsigned long flags;
+
+        spin_lock_irqsave(&sdd->lock, flags);
+
+        if (res == S3C2410_RES_OK)
+                sdd->state &= ~TXBUSY;
+        else
+                dev_err(&sdd->pdev->dev, "DmaAbrtTx-%d \n", size);
+
+        /* If the other done */
+        if (!(sdd->state & RXBUSY))
+                complete(&sdd->xfer_completion);
+
+        spin_unlock_irqrestore(&sdd->lock, flags);
+}
+
 #define XFER_DMAADDR_INVALID DMA_BIT_MASK(32)
 
 static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
                                                 struct spi_message *msg)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct device *dev = &sdd->pdev->dev;
         struct spi_transfer *xfer;
 
@@ -600,7 +543,7 @@ static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
         /* Map until end or first fail */
         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
 
-                if (xfer->len <= ((FIFO_LVL_MASK(sdd) >> 1) + 1))
+                if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1))
                         continue;
 
                 if (xfer->tx_buf != NULL) {
@@ -634,6 +577,7 @@ static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
 static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
                                                 struct spi_message *msg)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct device *dev = &sdd->pdev->dev;
         struct spi_transfer *xfer;
 
@@ -642,7 +586,7 @@ static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
 
         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
 
-                if (xfer->len <= ((FIFO_LVL_MASK(sdd) >> 1) + 1))
+                if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1))
                         continue;
 
                 if (xfer->rx_buf != NULL
@@ -657,10 +601,10 @@ static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
         }
 }
 
-static int s3c64xx_spi_transfer_one_message(struct spi_master *master,
-                                            struct spi_message *msg)
+static void handle_msg(struct s3c64xx_spi_driver_data *sdd,
+                                        struct spi_message *msg)
 {
-        struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct spi_device *spi = msg->spi;
         struct s3c64xx_spi_csinfo *cs = spi->controller_data;
         struct spi_transfer *xfer;
@@ -715,7 +659,7 @@ static int s3c64xx_spi_transfer_one_message(struct spi_master *master,
                 }
 
                 /* Polling method for xfers not bigger than FIFO capacity */
-                if (xfer->len <= ((FIFO_LVL_MASK(sdd) >> 1) + 1))
+                if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1))
                         use_dma = 0;
                 else
                         use_dma = 1;
@@ -732,15 +676,14 @@ static int s3c64xx_spi_transfer_one_message(struct spi_master *master,
                 enable_cs(sdd, spi);
 
                 /* Start the signals */
-                writel(0, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+                S3C64XX_SPI_ACT(sdd);
 
                 spin_unlock_irqrestore(&sdd->lock, flags);
 
                 status = wait_for_xfer(sdd, xfer, use_dma);
 
                 /* Quiese the signals */
-                writel(S3C64XX_SPI_SLAVE_SIG_INACT,
-                       sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+                S3C64XX_SPI_DEACT(sdd);
 
                 if (status) {
                         dev_err(&spi->dev, "I/O Error: "
@@ -753,10 +696,12 @@ static int s3c64xx_spi_transfer_one_message(struct spi_master *master,
                         if (use_dma) {
                                 if (xfer->tx_buf != NULL
                                                 && (sdd->state & TXBUSY))
-                                        sdd->ops->stop(sdd->tx_dma.ch);
+                                        s3c2410_dma_ctrl(sdd->tx_dmach,
+                                                        S3C2410_DMAOP_FLUSH);
                                 if (xfer->rx_buf != NULL
                                                 && (sdd->state & RXBUSY))
-                                        sdd->ops->stop(sdd->rx_dma.ch);
+                                        s3c2410_dma_ctrl(sdd->rx_dmach,
+                                                        S3C2410_DMAOP_FLUSH);
                         }
 
                         goto out;
@@ -771,6 +716,8 @@ static int s3c64xx_spi_transfer_one_message(struct spi_master *master,
                         if (list_is_last(&xfer->transfer_list,
                                                 &msg->transfers))
                                 cs_toggle = 1;
+                        else
+                                disable_cs(sdd, spi);
                 }
 
                 msg->actual_length += xfer->len;
@@ -788,78 +735,99 @@ out:
 
         msg->status = status;
 
-        spi_finalize_current_message(master);
+        if (msg->complete)
+                msg->complete(msg->context);
+}
 
-        return 0;
+static int acquire_dma(struct s3c64xx_spi_driver_data *sdd)
+{
+        if (s3c2410_dma_request(sdd->rx_dmach,
+                                        &s3c64xx_spi_dma_client, NULL) < 0) {
+                dev_err(&sdd->pdev->dev, "cannot get RxDMA\n");
+                return 0;
+        }
+        s3c2410_dma_set_buffdone_fn(sdd->rx_dmach, s3c64xx_spi_dma_rxcb);
+        s3c2410_dma_devconfig(sdd->rx_dmach, S3C2410_DMASRC_HW,
+                                        sdd->sfr_start + S3C64XX_SPI_RX_DATA);
+
+        if (s3c2410_dma_request(sdd->tx_dmach,
+                                        &s3c64xx_spi_dma_client, NULL) < 0) {
+                dev_err(&sdd->pdev->dev, "cannot get TxDMA\n");
+                s3c2410_dma_free(sdd->rx_dmach, &s3c64xx_spi_dma_client);
+                return 0;
+        }
+        s3c2410_dma_set_buffdone_fn(sdd->tx_dmach, s3c64xx_spi_dma_txcb);
+        s3c2410_dma_devconfig(sdd->tx_dmach, S3C2410_DMASRC_MEM,
+                                        sdd->sfr_start + S3C64XX_SPI_TX_DATA);
+
+        return 1;
 }
 
-static int s3c64xx_spi_prepare_transfer(struct spi_master *spi)
+static void s3c64xx_spi_work(struct work_struct *work)
 {
-        struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(spi);
+        struct s3c64xx_spi_driver_data *sdd = container_of(work,
+                                        struct s3c64xx_spi_driver_data, work);
+        unsigned long flags;
 
         /* Acquire DMA channels */
         while (!acquire_dma(sdd))
                 msleep(10);
 
-        pm_runtime_get_sync(&sdd->pdev->dev);
+        spin_lock_irqsave(&sdd->lock, flags);
 
-        return 0;
-}
+        while (!list_empty(&sdd->queue)
+                                && !(sdd->state & SUSPND)) {
 
-static int s3c64xx_spi_unprepare_transfer(struct spi_master *spi)
-{
-        struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(spi);
+                struct spi_message *msg;
 
-        /* Free DMA channels */
-        sdd->ops->release(sdd->rx_dma.ch, &s3c64xx_spi_dma_client);
-        sdd->ops->release(sdd->tx_dma.ch, &s3c64xx_spi_dma_client);
+                msg = container_of(sdd->queue.next, struct spi_message, queue);
 
-        pm_runtime_put(&sdd->pdev->dev);
+                list_del_init(&msg->queue);
 
-        return 0;
+                /* Set Xfer busy flag */
+                sdd->state |= SPIBUSY;
+
+                spin_unlock_irqrestore(&sdd->lock, flags);
+
+                handle_msg(sdd, msg);
+
+                spin_lock_irqsave(&sdd->lock, flags);
+
+                sdd->state &= ~SPIBUSY;
+        }
+
+        spin_unlock_irqrestore(&sdd->lock, flags);
+
+        /* Free DMA channels */
+        s3c2410_dma_free(sdd->tx_dmach, &s3c64xx_spi_dma_client);
+        s3c2410_dma_free(sdd->rx_dmach, &s3c64xx_spi_dma_client);
 }
 
-static struct s3c64xx_spi_csinfo *s3c64xx_get_slave_ctrldata(
-                                struct s3c64xx_spi_driver_data *sdd,
-                                struct spi_device *spi)
+static int s3c64xx_spi_transfer(struct spi_device *spi,
+                                                struct spi_message *msg)
 {
-        struct s3c64xx_spi_csinfo *cs;
-        struct device_node *slave_np, *data_np = NULL;
-        u32 fb_delay = 0;
+        struct s3c64xx_spi_driver_data *sdd;
+        unsigned long flags;
 
-        slave_np = spi->dev.of_node;
-        if (!slave_np) {
-                dev_err(&spi->dev, "device node not found\n");
-                return ERR_PTR(-EINVAL);
-        }
+        sdd = spi_master_get_devdata(spi->master);
 
-        data_np = of_get_child_by_name(slave_np, "controller-data");
-        if (!data_np) {
-                dev_err(&spi->dev, "child node 'controller-data' not found\n");
-                return ERR_PTR(-EINVAL);
-        }
+        spin_lock_irqsave(&sdd->lock, flags);
 
-        cs = kzalloc(sizeof(*cs), GFP_KERNEL);
-        if (!cs) {
-                dev_err(&spi->dev, "could not allocate memory for controller"
-                                        " data\n");
-                of_node_put(data_np);
-                return ERR_PTR(-ENOMEM);
+        if (sdd->state & SUSPND) {
+                spin_unlock_irqrestore(&sdd->lock, flags);
+                return -ESHUTDOWN;
         }
 
-        cs->line = of_get_named_gpio(data_np, "cs-gpio", 0);
-        if (!gpio_is_valid(cs->line)) {
-                dev_err(&spi->dev, "chip select gpio is not specified or "
-                                        "invalid\n");
-                kfree(cs);
-                of_node_put(data_np);
-                return ERR_PTR(-EINVAL);
-        }
+        msg->status = -EINPROGRESS;
+        msg->actual_length = 0;
+
+        list_add_tail(&msg->queue, &sdd->queue);
+
+        queue_work(sdd->workqueue, &sdd->work);
+
+        spin_unlock_irqrestore(&sdd->lock, flags);
 
-        of_property_read_u32(data_np, "samsung,spi-feedback-delay", &fb_delay);
-        cs->fb_delay = fb_delay;
-        of_node_put(data_np);
-        return cs;
+        return 0;
 }
 
 /*
@@ -875,31 +843,14 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
         struct s3c64xx_spi_info *sci;
         struct spi_message *msg;
         unsigned long flags;
-        int err;
+        int err = 0;
 
-        sdd = spi_master_get_devdata(spi->master);
-        if (!cs && spi->dev.of_node) {
-                cs = s3c64xx_get_slave_ctrldata(sdd, spi);
-                spi->controller_data = cs;
-        }
-
-        if (IS_ERR_OR_NULL(cs)) {
+        if (cs == NULL || cs->set_level == NULL) {
                 dev_err(&spi->dev, "No CS for SPI(%d)\n", spi->chip_select);
                 return -ENODEV;
         }
 
-        if (!spi_get_ctldata(spi)) {
-                err = gpio_request_one(cs->line, GPIOF_OUT_INIT_HIGH,
-                                       dev_name(&spi->dev));
-                if (err) {
-                        dev_err(&spi->dev,
-                                "Failed to get /CS gpio [%d]: %d\n",
-                                cs->line, err);
-                        goto err_gpio_req;
-                }
-                spi_set_ctldata(spi, cs);
-        }
-
+        sdd = spi_master_get_devdata(spi->master);
         sci = sdd->cntrlr_info;
 
         spin_lock_irqsave(&sdd->lock, flags);
@@ -910,11 +861,17 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
                         dev_err(&spi->dev,
                                 "setup: attempt while mssg in queue!\n");
                         spin_unlock_irqrestore(&sdd->lock, flags);
-                        err = -EBUSY;
-                        goto err_msgq;
+                        return -EBUSY;
                 }
         }
 
+        if (sdd->state & SUSPND) {
+                spin_unlock_irqrestore(&sdd->lock, flags);
+                dev_err(&spi->dev,
+                        "setup: SPI-%d not active!\n", spi->master->bus_num);
+                return -ESHUTDOWN;
+        }
+
         spin_unlock_irqrestore(&sdd->lock, flags);
 
         if (spi->bits_per_word != 8
@@ -926,10 +883,8 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
                 goto setup_exit;
         }
 
-        pm_runtime_get_sync(&sdd->pdev->dev);
-
         /* Check if we can provide the requested rate */
-        if (!sdd->port_conf->clk_from_cmu) {
+        if (!sci->clk_from_cmu) {
                 u32 psr, speed;
 
                 /* Max possible */
@@ -954,72 +909,20 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
                 }
 
                 speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
-                if (spi->max_speed_hz >= speed) {
+                if (spi->max_speed_hz >= speed)
                         spi->max_speed_hz = speed;
-                } else {
+                else
                         err = -EINVAL;
-                        goto setup_exit;
-                }
         }
 
-        pm_runtime_put(&sdd->pdev->dev);
-        disable_cs(sdd, spi);
-        return 0;
-
 setup_exit:
+
         /* setup() returns with device de-selected */
         disable_cs(sdd, spi);
 
-err_msgq:
-        gpio_free(cs->line);
-        spi_set_ctldata(spi, NULL);
-
-err_gpio_req:
-        if (spi->dev.of_node)
-                kfree(cs);
-
         return err;
 }
 
-static void s3c64xx_spi_cleanup(struct spi_device *spi)
-{
-        struct s3c64xx_spi_csinfo *cs = spi_get_ctldata(spi);
-
-        if (cs) {
-                gpio_free(cs->line);
-                if (spi->dev.of_node)
-                        kfree(cs);
-        }
-        spi_set_ctldata(spi, NULL);
-}
-
-static irqreturn_t s3c64xx_spi_irq(int irq, void *data)
-{
-        struct s3c64xx_spi_driver_data *sdd = data;
-        struct spi_master *spi = sdd->master;
-        unsigned int val;
-
-        val = readl(sdd->regs + S3C64XX_SPI_PENDING_CLR);
-
-        val &= S3C64XX_SPI_PND_RX_OVERRUN_CLR |
-                S3C64XX_SPI_PND_RX_UNDERRUN_CLR |
-                S3C64XX_SPI_PND_TX_OVERRUN_CLR |
-                S3C64XX_SPI_PND_TX_UNDERRUN_CLR;
-
-        writel(val, sdd->regs + S3C64XX_SPI_PENDING_CLR);
-
-        if (val & S3C64XX_SPI_PND_RX_OVERRUN_CLR)
-                dev_err(&spi->dev, "RX overrun\n");
-        if (val & S3C64XX_SPI_PND_RX_UNDERRUN_CLR)
-                dev_err(&spi->dev, "RX underrun\n");
-        if (val & S3C64XX_SPI_PND_TX_OVERRUN_CLR)
-                dev_err(&spi->dev, "TX overrun\n");
-        if (val & S3C64XX_SPI_PND_TX_UNDERRUN_CLR)
-                dev_err(&spi->dev, "TX underrun\n");
-
-        return IRQ_HANDLED;
-}
-
 static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
 {
         struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
@@ -1028,12 +931,12 @@ static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
 
         sdd->cur_speed = 0;
 
-        writel(S3C64XX_SPI_SLAVE_SIG_INACT, sdd->regs + S3C64XX_SPI_SLAVE_SEL);
+        S3C64XX_SPI_DEACT(sdd);
 
         /* Disable Interrupts - we use Polling if not DMA mode */
         writel(0, regs + S3C64XX_SPI_INT_EN);
 
-        if (!sdd->port_conf->clk_from_cmu)
+        if (!sci->clk_from_cmu)
                 writel(sci->src_clk_nr << S3C64XX_SPI_CLKSEL_SRCSHFT,
                                 regs + S3C64XX_SPI_CLK_CFG);
         writel(0, regs + S3C64XX_SPI_MODE_CFG);
@@ -1054,165 +957,44 @@ static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
         flush_fifo(sdd);
 }
 
-static int s3c64xx_spi_get_dmares(
-                        struct s3c64xx_spi_driver_data *sdd, bool tx)
-{
-        struct platform_device *pdev = sdd->pdev;
-        struct s3c64xx_spi_dma_data *dma_data;
-        struct property *prop;
-        struct resource *res;
-        char prop_name[15], *chan_str;
-
-        if (tx) {
-                dma_data = &sdd->tx_dma;
-                dma_data->direction = DMA_MEM_TO_DEV;
-                chan_str = "tx";
-        } else {
-                dma_data = &sdd->rx_dma;
-                dma_data->direction = DMA_DEV_TO_MEM;
-                chan_str = "rx";
-        }
-
-        if (!sdd->pdev->dev.of_node) {
-                res = platform_get_resource(pdev, IORESOURCE_DMA, tx ? 0 : 1);
-                if (!res) {
-                        dev_err(&pdev->dev, "Unable to get SPI-%s dma "
-                                        "resource\n", chan_str);
-                        return -ENXIO;
-                }
-                dma_data->dmach = res->start;
-                return 0;
-        }
-
-        sprintf(prop_name, "%s-dma-channel", chan_str);
-        prop = of_find_property(pdev->dev.of_node, prop_name, NULL);
-        if (!prop) {
-                dev_err(&pdev->dev, "%s dma channel property not specified\n",
-                                        chan_str);
-                return -ENXIO;
-        }
-
-        dma_data->dmach = DMACH_DT_PROP;
-        dma_data->dma_prop = prop;
-        return 0;
-}
-
-#ifdef CONFIG_OF
-static int s3c64xx_spi_parse_dt_gpio(struct s3c64xx_spi_driver_data *sdd)
-{
-        struct device *dev = &sdd->pdev->dev;
-        int idx, gpio, ret;
-
-        /* find gpios for mosi, miso and clock lines */
-        for (idx = 0; idx < 3; idx++) {
-                gpio = of_get_gpio(dev->of_node, idx);
-                if (!gpio_is_valid(gpio)) {
-                        dev_err(dev, "invalid gpio[%d]: %d\n", idx, gpio);
-                        goto free_gpio;
-                }
-                sdd->gpios[idx] = gpio;
-                ret = gpio_request(gpio, "spi-bus");
-                if (ret) {
-                        dev_err(dev, "gpio [%d] request failed: %d\n",
-                                gpio, ret);
-                        goto free_gpio;
-                }
-        }
-        return 0;
-
-free_gpio:
-        while (--idx >= 0)
-                gpio_free(sdd->gpios[idx]);
-        return -EINVAL;
-}
-
-static void s3c64xx_spi_dt_gpio_free(struct s3c64xx_spi_driver_data *sdd)
-{
-        unsigned int idx;
-        for (idx = 0; idx < 3; idx++)
-                gpio_free(sdd->gpios[idx]);
-}
-
-static struct s3c64xx_spi_info * s3c64xx_spi_parse_dt(
-                                                struct device *dev)
+static int __init s3c64xx_spi_probe(struct platform_device *pdev)
 {
+        struct resource *mem_res, *dmatx_res, *dmarx_res;
+        struct s3c64xx_spi_driver_data *sdd;
         struct s3c64xx_spi_info *sci;
-        u32 temp;
-
-        sci = devm_kzalloc(dev, sizeof(*sci), GFP_KERNEL);
-        if (!sci) {
-                dev_err(dev, "memory allocation for spi_info failed\n");
-                return ERR_PTR(-ENOMEM);
-        }
+        struct spi_master *master;
+        int ret;
 
-        if (of_property_read_u32(dev->of_node, "samsung,spi-src-clk", &temp)) {
-                dev_warn(dev, "spi bus clock parent not specified, using "
-                                "clock at index 0 as parent\n");
-                sci->src_clk_nr = 0;
-        } else {
-                sci->src_clk_nr = temp;
+        if (pdev->id < 0) {
+                dev_err(&pdev->dev,
+                                "Invalid platform device id-%d\n", pdev->id);
+                return -ENODEV;
         }
 
-        if (of_property_read_u32(dev->of_node, "num-cs", &temp)) {
-                dev_warn(dev, "number of chip select lines not specified, "
-                                "assuming 1 chip select line\n");
-                sci->num_cs = 1;
-        } else {
-                sci->num_cs = temp;
+        if (pdev->dev.platform_data == NULL) {
+                dev_err(&pdev->dev, "platform_data missing!\n");
+                return -ENODEV;
         }
 
-        return sci;
-}
-#else
-static struct s3c64xx_spi_info *s3c64xx_spi_parse_dt(struct device *dev)
-{
-        return dev->platform_data;
-}
-
-static int s3c64xx_spi_parse_dt_gpio(struct s3c64xx_spi_driver_data *sdd)
-{
-        return -EINVAL;
-}
-
-static void s3c64xx_spi_dt_gpio_free(struct s3c64xx_spi_driver_data *sdd)
-{
-}
-#endif
-
-static const struct of_device_id s3c64xx_spi_dt_match[];
-
-static inline struct s3c64xx_spi_port_config *s3c64xx_spi_get_port_config(
-                                                struct platform_device *pdev)
-{
-#ifdef CONFIG_OF
-        if (pdev->dev.of_node) {
-                const struct of_device_id *match;
-                match = of_match_node(s3c64xx_spi_dt_match, pdev->dev.of_node);
-                return (struct s3c64xx_spi_port_config *)match->data;
+        sci = pdev->dev.platform_data;
+        if (!sci->src_clk_name) {
+                dev_err(&pdev->dev,
+                        "Board init must call s3c64xx_spi_set_info()\n");
+                return -EINVAL;
         }
-#endif
-        return (struct s3c64xx_spi_port_config *)
-                         platform_get_device_id(pdev)->driver_data;
-}
 
-static int __init s3c64xx_spi_probe(struct platform_device *pdev)
-{
-        struct resource *mem_res;
-        struct s3c64xx_spi_driver_data *sdd;
-        struct s3c64xx_spi_info *sci = pdev->dev.platform_data;
-        struct spi_master *master;
-        int ret, irq;
-        char clk_name[16];
+        /* Check for availability of necessary resource */
 
-        if (!sci && pdev->dev.of_node) {
-                sci = s3c64xx_spi_parse_dt(&pdev->dev);
-                if (IS_ERR(sci))
-                        return PTR_ERR(sci);
+        dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (dmatx_res == NULL) {
+                dev_err(&pdev->dev, "Unable to get SPI-Tx dma resource\n");
+                return -ENXIO;
         }
 
-        if (!sci) {
-                dev_err(&pdev->dev, "platform_data missing!\n");
-                return -ENODEV;
+        dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
+        if (dmarx_res == NULL) {
+                dev_err(&pdev->dev, "Unable to get SPI-Rx dma resource\n");
+                return -ENXIO;
         }
 
         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
@@ -1221,12 +1003,6 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
                 return -ENXIO;
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                dev_warn(&pdev->dev, "Failed to get IRQ: %d\n", irq);
-                return irq;
-        }
-
         master = spi_alloc_master(&pdev->dev,
                                 sizeof(struct s3c64xx_spi_driver_data));
         if (master == NULL) {
@@ -1237,56 +1013,38 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
         platform_set_drvdata(pdev, master);
 
         sdd = spi_master_get_devdata(master);
-        sdd->port_conf = s3c64xx_spi_get_port_config(pdev);
         sdd->master = master;
         sdd->cntrlr_info = sci;
         sdd->pdev = pdev;
         sdd->sfr_start = mem_res->start;
-        if (pdev->dev.of_node) {
-                ret = of_alias_get_id(pdev->dev.of_node, "spi");
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "failed to get alias id, "
-                                                "errno %d\n", ret);
-                        goto err0;
-                }
-                sdd->port_id = ret;
-        } else {
-                sdd->port_id = pdev->id;
-        }
+        sdd->tx_dmach = dmatx_res->start;
+        sdd->rx_dmach = dmarx_res->start;
 
         sdd->cur_bpw = 8;
 
-        ret = s3c64xx_spi_get_dmares(sdd, true);
-        if (ret)
-                goto err0;
-
-        ret = s3c64xx_spi_get_dmares(sdd, false);
-        if (ret)
-                goto err0;
-
-        master->dev.of_node = pdev->dev.of_node;
-        master->bus_num = sdd->port_id;
+        master->bus_num = pdev->id;
         master->setup = s3c64xx_spi_setup;
-        master->cleanup = s3c64xx_spi_cleanup;
-        master->prepare_transfer_hardware = s3c64xx_spi_prepare_transfer;
-        master->transfer_one_message = s3c64xx_spi_transfer_one_message;
-        master->unprepare_transfer_hardware = s3c64xx_spi_unprepare_transfer;
+        master->transfer = s3c64xx_spi_transfer;
         master->num_chipselect = sci->num_cs;
         master->dma_alignment = 8;
         /* the spi->mode bits understood by this driver: */
         master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
 
-        sdd->regs = devm_request_and_ioremap(&pdev->dev, mem_res);
+        if (request_mem_region(mem_res->start,
+                        resource_size(mem_res), pdev->name) == NULL) {
+                dev_err(&pdev->dev, "Req mem region failed\n");
+                ret = -ENXIO;
+                goto err0;
+        }
+
+        sdd->regs = ioremap(mem_res->start, resource_size(mem_res));
         if (sdd->regs == NULL) {
                 dev_err(&pdev->dev, "Unable to remap IO\n");
                 ret = -ENXIO;
                 goto err1;
         }
 
-        if (!sci->cfg_gpio && pdev->dev.of_node) {
-                if (s3c64xx_spi_parse_dt_gpio(sdd))
-                        return -EBUSY;
-        } else if (sci->cfg_gpio == NULL || sci->cfg_gpio()) {
+        if (sci->cfg_gpio == NULL || sci->cfg_gpio(pdev)) {
                 dev_err(&pdev->dev, "Unable to config gpio\n");
                 ret = -EBUSY;
                 goto err2;
@@ -1300,45 +1058,43 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
                 goto err3;
         }
 
-        if (clk_prepare_enable(sdd->clk)) {
+        if (clk_enable(sdd->clk)) {
                 dev_err(&pdev->dev, "Couldn't enable clock 'spi'\n");
                 ret = -EBUSY;
                 goto err4;
         }
 
-        sprintf(clk_name, "spi_busclk%d", sci->src_clk_nr);
-        sdd->src_clk = clk_get(&pdev->dev, clk_name);
+        sdd->src_clk = clk_get(&pdev->dev, sci->src_clk_name);
         if (IS_ERR(sdd->src_clk)) {
                 dev_err(&pdev->dev,
-                        "Unable to acquire clock '%s'\n", clk_name);
+                        "Unable to acquire clock '%s'\n", sci->src_clk_name);
                 ret = PTR_ERR(sdd->src_clk);
                 goto err5;
         }
 
-        if (clk_prepare_enable(sdd->src_clk)) {
-                dev_err(&pdev->dev, "Couldn't enable clock '%s'\n", clk_name);
+        if (clk_enable(sdd->src_clk)) {
+                dev_err(&pdev->dev, "Couldn't enable clock '%s'\n",
+                                                        sci->src_clk_name);
                 ret = -EBUSY;
                 goto err6;
         }
 
+        sdd->workqueue = create_singlethread_workqueue(
+                                                dev_name(master->dev.parent));
+        if (sdd->workqueue == NULL) {
+                dev_err(&pdev->dev, "Unable to create workqueue\n");
+                ret = -ENOMEM;
+                goto err7;
+        }
+
         /* Setup Deufult Mode */
-        s3c64xx_spi_hwinit(sdd, sdd->port_id);
+        s3c64xx_spi_hwinit(sdd, pdev->id);
 
         spin_lock_init(&sdd->lock);
         init_completion(&sdd->xfer_completion);
+        INIT_WORK(&sdd->work, s3c64xx_spi_work);
         INIT_LIST_HEAD(&sdd->queue);
 
-        ret = request_irq(irq, s3c64xx_spi_irq, 0, "spi-s3c64xx", sdd);
-        if (ret != 0) {
-                dev_err(&pdev->dev, "Failed to request IRQ %d: %d\n",
-                        irq, ret);
-                goto err7;
-        }
-
-        writel(S3C64XX_SPI_INT_RX_OVERRUN_EN | S3C64XX_SPI_INT_RX_UNDERRUN_EN |
-               S3C64XX_SPI_INT_TX_OVERRUN_EN | S3C64XX_SPI_INT_TX_UNDERRUN_EN,
-               sdd->regs + S3C64XX_SPI_INT_EN);
-
         if (spi_register_master(master)) {
                 dev_err(&pdev->dev, "cannot register SPI master\n");
                 ret = -EBUSY;
@@ -1347,30 +1103,28 @@ static int __init s3c64xx_spi_probe(struct platform_device *pdev)
 
         dev_dbg(&pdev->dev, "Samsung SoC SPI Driver loaded for Bus SPI-%d "
                                         "with %d Slaves attached\n",
-                                        sdd->port_id, master->num_chipselect);
+                                        pdev->id, master->num_chipselect);
         dev_dbg(&pdev->dev, "\tIOmem=[0x%x-0x%x]\tDMA=[Rx-%d, Tx-%d]\n",
                                         mem_res->end, mem_res->start,
-                                        sdd->rx_dma.dmach, sdd->tx_dma.dmach);
-
-        pm_runtime_enable(&pdev->dev);
+                                        sdd->rx_dmach, sdd->tx_dmach);
 
         return 0;
 
 err8:
-        free_irq(irq, sdd);
+        destroy_workqueue(sdd->workqueue);
 err7:
-        clk_disable_unprepare(sdd->src_clk);
+        clk_disable(sdd->src_clk);
 err6:
         clk_put(sdd->src_clk);
 err5:
-        clk_disable_unprepare(sdd->clk);
+        clk_disable(sdd->clk);
 err4:
         clk_put(sdd->clk);
 err3:
-        if (!sdd->cntrlr_info->cfg_gpio && pdev->dev.of_node)
-                s3c64xx_spi_dt_gpio_free(sdd);
 err2:
+        iounmap((void *) sdd->regs);
 err1:
+        release_mem_region(mem_res->start, resource_size(mem_res));
 err0:
         platform_set_drvdata(pdev, NULL);
         spi_master_put(master);
@@ -1382,23 +1136,31 @@ static int s3c64xx_spi_remove(struct platform_device *pdev)
 {
         struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
+        struct resource *mem_res;
+        unsigned long flags;
 
-        pm_runtime_disable(&pdev->dev);
+        spin_lock_irqsave(&sdd->lock, flags);
+        sdd->state |= SUSPND;
+        spin_unlock_irqrestore(&sdd->lock, flags);
 
-        spi_unregister_master(master);
+        while (sdd->state & SPIBUSY)
+                msleep(10);
 
-        writel(0, sdd->regs + S3C64XX_SPI_INT_EN);
+        spi_unregister_master(master);
 
-        free_irq(platform_get_irq(pdev, 0), sdd);
+        destroy_workqueue(sdd->workqueue);
 
-        clk_disable_unprepare(sdd->src_clk);
+        clk_disable(sdd->src_clk);
         clk_put(sdd->src_clk);
 
-        clk_disable_unprepare(sdd->clk);
+        clk_disable(sdd->clk);
         clk_put(sdd->clk);
 
-        if (!sdd->cntrlr_info->cfg_gpio && pdev->dev.of_node)
-                s3c64xx_spi_dt_gpio_free(sdd);
+        iounmap((void *) sdd->regs);
+
+        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (mem_res != NULL)
+                release_mem_region(mem_res->start, resource_size(mem_res));
 
         platform_set_drvdata(pdev, NULL);
         spi_master_put(master);
@@ -1407,161 +1169,62 @@ static int s3c64xx_spi_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int s3c64xx_spi_suspend(struct device *dev)
+static int s3c64xx_spi_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct spi_master *master = dev_get_drvdata(dev);
+        struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
+        unsigned long flags;
 
-        spi_master_suspend(master);
+        spin_lock_irqsave(&sdd->lock, flags);
+        sdd->state |= SUSPND;
+        spin_unlock_irqrestore(&sdd->lock, flags);
 
-        /* Disable the clock */
-        clk_disable_unprepare(sdd->src_clk);
-        clk_disable_unprepare(sdd->clk);
+        while (sdd->state & SPIBUSY)
+                msleep(10);
 
-        if (!sdd->cntrlr_info->cfg_gpio && dev->of_node)
-                s3c64xx_spi_dt_gpio_free(sdd);
+        /* Disable the clock */
+        clk_disable(sdd->src_clk);
+        clk_disable(sdd->clk);
 
         sdd->cur_speed = 0; /* Output Clock is stopped */
 
         return 0;
 }
 
-static int s3c64xx_spi_resume(struct device *dev)
+static int s3c64xx_spi_resume(struct platform_device *pdev)
 {
-        struct spi_master *master = dev_get_drvdata(dev);
+        struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
         struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
         struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
+        unsigned long flags;
 
-        if (!sci->cfg_gpio && dev->of_node)
-                s3c64xx_spi_parse_dt_gpio(sdd);
-        else
-                sci->cfg_gpio();
+        sci->cfg_gpio(pdev);
 
         /* Enable the clock */
-        clk_prepare_enable(sdd->src_clk);
-        clk_prepare_enable(sdd->clk);
+        clk_enable(sdd->src_clk);
+        clk_enable(sdd->clk);
 
-        s3c64xx_spi_hwinit(sdd, sdd->port_id);
+        s3c64xx_spi_hwinit(sdd, pdev->id);
 
-        spi_master_resume(master);
+        spin_lock_irqsave(&sdd->lock, flags);
+        sdd->state &= ~SUSPND;
+        spin_unlock_irqrestore(&sdd->lock, flags);
 
         return 0;
 }
+#else
+#define s3c64xx_spi_suspend     NULL
+#define s3c64xx_spi_resume      NULL
 #endif /* CONFIG_PM */
 
-#ifdef CONFIG_PM_RUNTIME
-static int s3c64xx_spi_runtime_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
-
-        clk_disable_unprepare(sdd->clk);
-        clk_disable_unprepare(sdd->src_clk);
-
-        return 0;
-}
-
-static int s3c64xx_spi_runtime_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct s3c64xx_spi_driver_data *sdd = spi_master_get_devdata(master);
-
-        clk_prepare_enable(sdd->src_clk);
-        clk_prepare_enable(sdd->clk);
-
-        return 0;
-}
-#endif /* CONFIG_PM_RUNTIME */
-
-static const struct dev_pm_ops s3c64xx_spi_pm = {
-        SET_SYSTEM_SLEEP_PM_OPS(s3c64xx_spi_suspend, s3c64xx_spi_resume)
-        SET_RUNTIME_PM_OPS(s3c64xx_spi_runtime_suspend,
-                           s3c64xx_spi_runtime_resume, NULL)
-};
-
-static struct s3c64xx_spi_port_config s3c2443_spi_port_config = {
-        .fifo_lvl_mask  = { 0x7f },
-        .rx_lvl_offset  = 13,
-        .tx_st_done     = 21,
-        .high_speed     = true,
-};
-
-static struct s3c64xx_spi_port_config s3c6410_spi_port_config = {
-        .fifo_lvl_mask  = { 0x7f, 0x7F },
-        .rx_lvl_offset  = 13,
-        .tx_st_done     = 21,
-};
-
-static struct s3c64xx_spi_port_config s5p64x0_spi_port_config = {
-        .fifo_lvl_mask  = { 0x1ff, 0x7F },
-        .rx_lvl_offset  = 15,
-        .tx_st_done     = 25,
-};
-
-static struct s3c64xx_spi_port_config s5pc100_spi_port_config = {
-        .fifo_lvl_mask  = { 0x7f, 0x7F },
-        .rx_lvl_offset  = 13,
-        .tx_st_done     = 21,
-        .high_speed     = true,
-};
-
-static struct s3c64xx_spi_port_config s5pv210_spi_port_config = {
-        .fifo_lvl_mask  = { 0x1ff, 0x7F },
-        .rx_lvl_offset  = 15,
-        .tx_st_done     = 25,
-        .high_speed     = true,
-};
-
-static struct s3c64xx_spi_port_config exynos4_spi_port_config = {
-        .fifo_lvl_mask  = { 0x1ff, 0x7F, 0x7F },
-        .rx_lvl_offset  = 15,
-        .tx_st_done     = 25,
-        .high_speed     = true,
-        .clk_from_cmu   = true,
-};
-
-static struct platform_device_id s3c64xx_spi_driver_ids[] = {
-        {
-                .name           = "s3c2443-spi",
-                .driver_data    = (kernel_ulong_t)&s3c2443_spi_port_config,
-        }, {
-                .name           = "s3c6410-spi",
-                .driver_data    = (kernel_ulong_t)&s3c6410_spi_port_config,
-        }, {
-                .name           = "s5p64x0-spi",
-                .driver_data    = (kernel_ulong_t)&s5p64x0_spi_port_config,
-        }, {
-                .name           = "s5pc100-spi",
-                .driver_data    = (kernel_ulong_t)&s5pc100_spi_port_config,
-        }, {
-                .name           = "s5pv210-spi",
-                .driver_data    = (kernel_ulong_t)&s5pv210_spi_port_config,
-        }, {
-                .name           = "exynos4210-spi",
-                .driver_data    = (kernel_ulong_t)&exynos4_spi_port_config,
-        },
-        { },
-};
-
-#ifdef CONFIG_OF
-static const struct of_device_id s3c64xx_spi_dt_match[] = {
-        { .compatible = "samsung,exynos4210-spi",
-                        .data = (void *)&exynos4_spi_port_config,
-        },
-        { },
-};
-MODULE_DEVICE_TABLE(of, s3c64xx_spi_dt_match);
-#endif /* CONFIG_OF */
-
 static struct platform_driver s3c64xx_spi_driver = {
         .driver = {
                 .name   = "s3c64xx-spi",
                 .owner = THIS_MODULE,
-                .pm = &s3c64xx_spi_pm,
-                .of_match_table = of_match_ptr(s3c64xx_spi_dt_match),
         },
         .remove = s3c64xx_spi_remove,
-        .id_table = s3c64xx_spi_driver_ids,
+        .suspend = s3c64xx_spi_suspend,
+        .resume = s3c64xx_spi_resume,
 };
 MODULE_ALIAS("platform:s3c64xx-spi");
 
diff --git a/drivers/spi/spi-sc18is602.c b/drivers/spi/spi-sc18is602.c
deleted file mode 100644
index 9eda21d739c..00000000000
--- a/drivers/spi/spi-sc18is602.c
+++ /dev/null
@@ -1,364 +0,0 @@
-/*
- * NXP SC18IS602/603 SPI driver
- *
- * Copyright (C) Guenter Roeck <linux@roeck-us.net>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#include <linux/kernel.h>
-#include <linux/err.h>
-#include <linux/module.h>
-#include <linux/spi/spi.h>
-#include <linux/i2c.h>
-#include <linux/delay.h>
-#include <linux/pm_runtime.h>
-#include <linux/of.h>
-#include <linux/platform_data/sc18is602.h>
-
-enum chips { sc18is602, sc18is602b, sc18is603 };
-
-#define SC18IS602_BUFSIZ                200
-#define SC18IS602_CLOCK                 7372000
-
-#define SC18IS602_MODE_CPHA             BIT(2)
-#define SC18IS602_MODE_CPOL             BIT(3)
-#define SC18IS602_MODE_LSB_FIRST        BIT(5)
-#define SC18IS602_MODE_CLOCK_DIV_4      0x0
-#define SC18IS602_MODE_CLOCK_DIV_16     0x1
-#define SC18IS602_MODE_CLOCK_DIV_64     0x2
-#define SC18IS602_MODE_CLOCK_DIV_128    0x3
-
-struct sc18is602 {
-        struct spi_master       *master;
-        struct device           *dev;
-        u8                      ctrl;
-        u32                     freq;
-        u32                     speed;
-
-        /* I2C data */
-        struct i2c_client       *client;
-        enum chips              id;
-        u8                      buffer[SC18IS602_BUFSIZ + 1];
-        int                     tlen;   /* Data queued for tx in buffer */
-        int                     rindex; /* Receive data index in buffer */
-};
-
-static int sc18is602_wait_ready(struct sc18is602 *hw, int len)
-{
-        int i, err;
-        int usecs = 1000000 * len / hw->speed + 1;
-        u8 dummy[1];
-
-        for (i = 0; i < 10; i++) {
-                err = i2c_master_recv(hw->client, dummy, 1);
-                if (err >= 0)
-                        return 0;
-                usleep_range(usecs, usecs * 2);
-        }
-        return -ETIMEDOUT;
-}
-
-static int sc18is602_txrx(struct sc18is602 *hw, struct spi_message *msg,
-                          struct spi_transfer *t, bool do_transfer)
-{
-        unsigned int len = t->len;
-        int ret;
-
-        if (hw->tlen == 0) {
-                /* First byte (I2C command) is chip select */
-                hw->buffer[0] = 1 << msg->spi->chip_select;
-                hw->tlen = 1;
-                hw->rindex = 0;
-        }
-        /*
-         * We can not immediately send data to the chip, since each I2C message
-         * resembles a full SPI message (from CS active to CS inactive).
-         * Enqueue messages up to the first read or until do_transfer is true.
-         */
-        if (t->tx_buf) {
-                memcpy(&hw->buffer[hw->tlen], t->tx_buf, len);
-                hw->tlen += len;
-                if (t->rx_buf)
-                        do_transfer = true;
-                else
-                        hw->rindex = hw->tlen - 1;
-        } else if (t->rx_buf) {
-                /*
-                 * For receive-only transfers we still need to perform a dummy
-                 * write to receive data from the SPI chip.
-                 * Read data starts at the end of transmit data (minus 1 to
-                 * account for CS).
-                 */
-                hw->rindex = hw->tlen - 1;
-                memset(&hw->buffer[hw->tlen], 0, len);
-                hw->tlen += len;
-                do_transfer = true;
-        }
-
-        if (do_transfer && hw->tlen > 1) {
-                ret = sc18is602_wait_ready(hw, SC18IS602_BUFSIZ);
-                if (ret < 0)
-                        return ret;
-                ret = i2c_master_send(hw->client, hw->buffer, hw->tlen);
-                if (ret < 0)
-                        return ret;
-                if (ret != hw->tlen)
-                        return -EIO;
-
-                if (t->rx_buf) {
-                        int rlen = hw->rindex + len;
-
-                        ret = sc18is602_wait_ready(hw, hw->tlen);
-                        if (ret < 0)
-                                return ret;
-                        ret = i2c_master_recv(hw->client, hw->buffer, rlen);
-                        if (ret < 0)
-                                return ret;
-                        if (ret != rlen)
-                                return -EIO;
-                        memcpy(t->rx_buf, &hw->buffer[hw->rindex], len);
-                }
-                hw->tlen = 0;
-        }
-        return len;
-}
-
-static int sc18is602_setup_transfer(struct sc18is602 *hw, u32 hz, u8 mode)
-{
-        u8 ctrl = 0;
-        int ret;
-
-        if (mode & SPI_CPHA)
-                ctrl |= SC18IS602_MODE_CPHA;
-        if (mode & SPI_CPOL)
-                ctrl |= SC18IS602_MODE_CPOL;
-        if (mode & SPI_LSB_FIRST)
-                ctrl |= SC18IS602_MODE_LSB_FIRST;
-
-        /* Find the closest clock speed */
-        if (hz >= hw->freq / 4) {
-                ctrl |= SC18IS602_MODE_CLOCK_DIV_4;
-                hw->speed = hw->freq / 4;
-        } else if (hz >= hw->freq / 16) {
-                ctrl |= SC18IS602_MODE_CLOCK_DIV_16;
-                hw->speed = hw->freq / 16;
-        } else if (hz >= hw->freq / 64) {
-                ctrl |= SC18IS602_MODE_CLOCK_DIV_64;
-                hw->speed = hw->freq / 64;
-        } else {
-                ctrl |= SC18IS602_MODE_CLOCK_DIV_128;
-                hw->speed = hw->freq / 128;
-        }
-
-        /*
-         * Don't do anything if the control value did not change. The initial
-         * value of 0xff for hw->ctrl ensures that the correct mode will be set
-         * with the first call to this function.
-         */
-        if (ctrl == hw->ctrl)
-                return 0;
-
-        ret = i2c_smbus_write_byte_data(hw->client, 0xf0, ctrl);
-        if (ret < 0)
-                return ret;
-
-        hw->ctrl = ctrl;
-
-        return 0;
-}
-
-static int sc18is602_check_transfer(struct spi_device *spi,
-                                    struct spi_transfer *t, int tlen)
-{
-        int bpw;
-        uint32_t hz;
-
-        if (t && t->len + tlen > SC18IS602_BUFSIZ)
-                return -EINVAL;
-
-        bpw = spi->bits_per_word;
-        if (t && t->bits_per_word)
-                bpw = t->bits_per_word;
-        if (bpw != 8)
-                return -EINVAL;
-
-        hz = spi->max_speed_hz;
-        if (t && t->speed_hz)
-                hz = t->speed_hz;
-        if (hz == 0)
-                return -EINVAL;
-
-        return 0;
-}
-
-static int sc18is602_transfer_one(struct spi_master *master,
-                                  struct spi_message *m)
-{
-        struct sc18is602 *hw = spi_master_get_devdata(master);
-        struct spi_device *spi = m->spi;
-        struct spi_transfer *t;
-        int status = 0;
-
-        /* SC18IS602 does not support CS2 */
-        if (hw->id == sc18is602 && spi->chip_select == 2) {
-                status = -ENXIO;
-                goto error;
-        }
-
-        hw->tlen = 0;
-        list_for_each_entry(t, &m->transfers, transfer_list) {
-                u32 hz = t->speed_hz ? : spi->max_speed_hz;
-                bool do_transfer;
-
-                status = sc18is602_check_transfer(spi, t, hw->tlen);
-                if (status < 0)
-                        break;
-
-                status = sc18is602_setup_transfer(hw, hz, spi->mode);
-                if (status < 0)
-                        break;
-
-                do_transfer = t->cs_change || list_is_last(&t->transfer_list,
-                                                           &m->transfers);
-
-                if (t->len) {
-                        status = sc18is602_txrx(hw, m, t, do_transfer);
-                        if (status < 0)
-                                break;
-                        m->actual_length += status;
-                }
-                status = 0;
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
-        }
-error:
-        m->status = status;
-        spi_finalize_current_message(master);
-
-        return status;
-}
-
-static int sc18is602_setup(struct spi_device *spi)
-{
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-
-        if (spi->mode & ~(SPI_CPHA | SPI_CPOL | SPI_LSB_FIRST))
-                return -EINVAL;
-
-        return sc18is602_check_transfer(spi, NULL, 0);
-}
-
-static int sc18is602_probe(struct i2c_client *client,
-                           const struct i2c_device_id *id)
-{
-        struct device *dev = &client->dev;
-        struct device_node *np = dev->of_node;
-        struct sc18is602_platform_data *pdata = dev_get_platdata(dev);
-        struct sc18is602 *hw;
-        struct spi_master *master;
-        int error;
-
-        if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
-                                     I2C_FUNC_SMBUS_WRITE_BYTE_DATA))
-                return -EINVAL;
-
-        master = spi_alloc_master(dev, sizeof(struct sc18is602));
-        if (!master)
-                return -ENOMEM;
-
-        hw = spi_master_get_devdata(master);
-        i2c_set_clientdata(client, hw);
-
-        hw->master = master;
-        hw->client = client;
-        hw->dev = dev;
-        hw->ctrl = 0xff;
-
-        hw->id = id->driver_data;
-
-        switch (hw->id) {
-        case sc18is602:
-        case sc18is602b:
-                master->num_chipselect = 4;
-                hw->freq = SC18IS602_CLOCK;
-                break;
-        case sc18is603:
-                master->num_chipselect = 2;
-                if (pdata) {
-                        hw->freq = pdata->clock_frequency;
-                } else {
-                        const __be32 *val;
-                        int len;
-
-                        val = of_get_property(np, "clock-frequency", &len);
-                        if (val && len >= sizeof(__be32))
-                                hw->freq = be32_to_cpup(val);
-                }
-                if (!hw->freq)
-                        hw->freq = SC18IS602_CLOCK;
-                break;
-        }
-        master->bus_num = client->adapter->nr;
-        master->mode_bits = SPI_CPHA | SPI_CPOL | SPI_LSB_FIRST;
-        master->setup = sc18is602_setup;
-        master->transfer_one_message = sc18is602_transfer_one;
-        master->dev.of_node = np;
-
-        error = spi_register_master(master);
-        if (error)
-                goto error_reg;
-
-        return 0;
-
-error_reg:
-        spi_master_put(master);
-        return error;
-}
-
-static int sc18is602_remove(struct i2c_client *client)
-{
-        struct sc18is602 *hw = i2c_get_clientdata(client);
-        struct spi_master *master = hw->master;
-
-        spi_unregister_master(master);
-
-        return 0;
-}
-
-static const struct i2c_device_id sc18is602_id[] = {
-        { "sc18is602", sc18is602 },
-        { "sc18is602b", sc18is602b },
-        { "sc18is603", sc18is603 },
-        { }
-};
-MODULE_DEVICE_TABLE(i2c, sc18is602_id);
-
-static struct i2c_driver sc18is602_driver = {
-        .driver = {
-                .name = "sc18is602",
-        },
-        .probe = sc18is602_probe,
-        .remove = sc18is602_remove,
-        .id_table = sc18is602_id,
-};
-
-module_i2c_driver(sc18is602_driver);
-
-MODULE_DESCRIPTION("SC18IC602/603 SPI Master Driver");
-MODULE_AUTHOR("Guenter Roeck");
-MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-sh-hspi.c b/drivers/spi/spi-sh-hspi.c
deleted file mode 100644
index 60cfae51c71..00000000000
--- a/drivers/spi/spi-sh-hspi.c
+++ /dev/null
@@ -1,367 +0,0 @@
-/*
- * SuperH HSPI bus driver
- *
- * Copyright (C) 2011  Kuninori Morimoto
- *
- * Based on spi-sh.c:
- * Based on pxa2xx_spi.c:
- * Copyright (C) 2011 Renesas Solutions Corp.
- * Copyright (C) 2005 Stephen Street / StreetFire Sound Labs
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <linux/clk.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/timer.h>
-#include <linux/delay.h>
-#include <linux/list.h>
-#include <linux/interrupt.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/io.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/sh_hspi.h>
-
-#define SPCR    0x00
-#define SPSR    0x04
-#define SPSCR   0x08
-#define SPTBR   0x0C
-#define SPRBR   0x10
-#define SPCR2   0x14
-
-/* SPSR */
-#define RXFL    (1 << 2)
-
-#define hspi2info(h)    (h->dev->platform_data)
-
-struct hspi_priv {
-        void __iomem *addr;
-        struct spi_master *master;
-        struct device *dev;
-        struct clk *clk;
-};
-
-/*
- *              basic function
- */
-static void hspi_write(struct hspi_priv *hspi, int reg, u32 val)
-{
-        iowrite32(val, hspi->addr + reg);
-}
-
-static u32 hspi_read(struct hspi_priv *hspi, int reg)
-{
-        return ioread32(hspi->addr + reg);
-}
-
-static void hspi_bit_set(struct hspi_priv *hspi, int reg, u32 mask, u32 set)
-{
-        u32 val = hspi_read(hspi, reg);
-
-        val &= ~mask;
-        val |= set & mask;
-
-        hspi_write(hspi, reg, val);
-}
-
-/*
- *              transfer function
- */
-static int hspi_status_check_timeout(struct hspi_priv *hspi, u32 mask, u32 val)
-{
-        int t = 256;
-
-        while (t--) {
-                if ((mask & hspi_read(hspi, SPSR)) == val)
-                        return 0;
-
-                msleep(20);
-        }
-
-        dev_err(hspi->dev, "timeout\n");
-        return -ETIMEDOUT;
-}
-
-/*
- *              spi master function
- */
-static int hspi_prepare_transfer(struct spi_master *master)
-{
-        struct hspi_priv *hspi = spi_master_get_devdata(master);
-
-        pm_runtime_get_sync(hspi->dev);
-        return 0;
-}
-
-static int hspi_unprepare_transfer(struct spi_master *master)
-{
-        struct hspi_priv *hspi = spi_master_get_devdata(master);
-
-        pm_runtime_put_sync(hspi->dev);
-        return 0;
-}
-
-#define hspi_hw_cs_enable(hspi)         hspi_hw_cs_ctrl(hspi, 0)
-#define hspi_hw_cs_disable(hspi)        hspi_hw_cs_ctrl(hspi, 1)
-static void hspi_hw_cs_ctrl(struct hspi_priv *hspi, int hi)
-{
-        hspi_bit_set(hspi, SPSCR, (1 << 6), (hi) << 6);
-}
-
-static void hspi_hw_setup(struct hspi_priv *hspi,
-                          struct spi_message *msg,
-                          struct spi_transfer *t)
-{
-        struct spi_device *spi = msg->spi;
-        struct device *dev = hspi->dev;
-        u32 target_rate;
-        u32 spcr, idiv_clk;
-        u32 rate, best_rate, min, tmp;
-
-        target_rate = t ? t->speed_hz : 0;
-        if (!target_rate)
-                target_rate = spi->max_speed_hz;
-
-        /*
-         * find best IDIV/CLKCx settings
-         */
-        min = ~0;
-        best_rate = 0;
-        spcr = 0;
-        for (idiv_clk = 0x00; idiv_clk <= 0x3F; idiv_clk++) {
-                rate = clk_get_rate(hspi->clk);
-
-                /* IDIV calculation */
-                if (idiv_clk & (1 << 5))
-                        rate /= 128;
-                else
-                        rate /= 16;
-
-                /* CLKCx calculation */
-                rate /= (((idiv_clk & 0x1F) + 1) * 2) ;
-
-                /* save best settings */
-                tmp = abs(target_rate - rate);
-                if (tmp < min) {
-                        min = tmp;
-                        spcr = idiv_clk;
-                        best_rate = rate;
-                }
-        }
-
-        if (spi->mode & SPI_CPHA)
-                spcr |= 1 << 7;
-        if (spi->mode & SPI_CPOL)
-                spcr |= 1 << 6;
-
-        dev_dbg(dev, "speed %d/%d\n", target_rate, best_rate);
-
-        hspi_write(hspi, SPCR, spcr);
-        hspi_write(hspi, SPSR, 0x0);
-        hspi_write(hspi, SPSCR, 0x21);  /* master mode / CS control */
-}
-
-static int hspi_transfer_one_message(struct spi_master *master,
-                                     struct spi_message *msg)
-{
-        struct hspi_priv *hspi = spi_master_get_devdata(master);
-        struct spi_transfer *t;
-        u32 tx;
-        u32 rx;
-        int ret, i;
-        unsigned int cs_change;
-        const int nsecs = 50;
-
-        dev_dbg(hspi->dev, "%s\n", __func__);
-
-        cs_change = 1;
-        ret = 0;
-        list_for_each_entry(t, &msg->transfers, transfer_list) {
-
-                if (cs_change) {
-                        hspi_hw_setup(hspi, msg, t);
-                        hspi_hw_cs_enable(hspi);
-                        ndelay(nsecs);
-                }
-                cs_change = t->cs_change;
-
-                for (i = 0; i < t->len; i++) {
-
-                        /* wait remains */
-                        ret = hspi_status_check_timeout(hspi, 0x1, 0);
-                        if (ret < 0)
-                                break;
-
-                        tx = 0;
-                        if (t->tx_buf)
-                                tx = (u32)((u8 *)t->tx_buf)[i];
-
-                        hspi_write(hspi, SPTBR, tx);
-
-                        /* wait recive */
-                        ret = hspi_status_check_timeout(hspi, 0x4, 0x4);
-                        if (ret < 0)
-                                break;
-
-                        rx = hspi_read(hspi, SPRBR);
-                        if (t->rx_buf)
-                                ((u8 *)t->rx_buf)[i] = (u8)rx;
-
-                }
-
-                msg->actual_length += t->len;
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
-
-                if (cs_change) {
-                        ndelay(nsecs);
-                        hspi_hw_cs_disable(hspi);
-                        ndelay(nsecs);
-                }
-        }
-
-        msg->status = ret;
-        if (!cs_change) {
-                ndelay(nsecs);
-                hspi_hw_cs_disable(hspi);
-        }
-        spi_finalize_current_message(master);
-
-        return ret;
-}
-
-static int hspi_setup(struct spi_device *spi)
-{
-        struct hspi_priv *hspi = spi_master_get_devdata(spi->master);
-        struct device *dev = hspi->dev;
-
-        if (8 != spi->bits_per_word) {
-                dev_err(dev, "bits_per_word should be 8\n");
-                return -EIO;
-        }
-
-        dev_dbg(dev, "%s setup\n", spi->modalias);
-
-        return 0;
-}
-
-static void hspi_cleanup(struct spi_device *spi)
-{
-        struct hspi_priv *hspi = spi_master_get_devdata(spi->master);
-        struct device *dev = hspi->dev;
-
-        dev_dbg(dev, "%s cleanup\n", spi->modalias);
-}
-
-static int hspi_probe(struct platform_device *pdev)
-{
-        struct resource *res;
-        struct spi_master *master;
-        struct hspi_priv *hspi;
-        struct clk *clk;
-        int ret;
-
-        /* get base addr */
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(&pdev->dev, "invalid resource\n");
-                return -EINVAL;
-        }
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*hspi));
-        if (!master) {
-                dev_err(&pdev->dev, "spi_alloc_master error.\n");
-                return -ENOMEM;
-        }
-
-        clk = clk_get(NULL, "shyway_clk");
-        if (IS_ERR(clk)) {
-                dev_err(&pdev->dev, "shyway_clk is required\n");
-                ret = -EINVAL;
-                goto error0;
-        }
-
-        hspi = spi_master_get_devdata(master);
-        dev_set_drvdata(&pdev->dev, hspi);
-
-        /* init hspi */
-        hspi->master    = master;
-        hspi->dev       = &pdev->dev;
-        hspi->clk       = clk;
-        hspi->addr      = devm_ioremap(hspi->dev,
-                                       res->start, resource_size(res));
-        if (!hspi->addr) {
-                dev_err(&pdev->dev, "ioremap error.\n");
-                ret = -ENOMEM;
-                goto error1;
-        }
-
-        master->num_chipselect  = 1;
-        master->bus_num         = pdev->id;
-        master->setup           = hspi_setup;
-        master->cleanup         = hspi_cleanup;
-        master->mode_bits       = SPI_CPOL | SPI_CPHA;
-        master->prepare_transfer_hardware       = hspi_prepare_transfer;
-        master->transfer_one_message            = hspi_transfer_one_message;
-        master->unprepare_transfer_hardware     = hspi_unprepare_transfer;
-        ret = spi_register_master(master);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "spi_register_master error.\n");
-                goto error1;
-        }
-
-        pm_runtime_enable(&pdev->dev);
-
-        dev_info(&pdev->dev, "probed\n");
-
-        return 0;
-
- error1:
-        clk_put(clk);
- error0:
-        spi_master_put(master);
-
-        return ret;
-}
-
-static int hspi_remove(struct platform_device *pdev)
-{
-        struct hspi_priv *hspi = dev_get_drvdata(&pdev->dev);
-
-        pm_runtime_disable(&pdev->dev);
-
-        clk_put(hspi->clk);
-        spi_unregister_master(hspi->master);
-
-        return 0;
-}
-
-static struct platform_driver hspi_driver = {
-        .probe = hspi_probe,
-        .remove = hspi_remove,
-        .driver = {
-                .name = "sh-hspi",
-                .owner = THIS_MODULE,
-        },
-};
-module_platform_driver(hspi_driver);
-
-MODULE_DESCRIPTION("SuperH HSPI bus driver");
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>");
-MODULE_ALIAS("platform:sh_spi");
diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
index 96358d0eabb..e00d94b2225 100644
--- a/drivers/spi/spi-sh-msiof.c
+++ b/drivers/spi/spi-sh-msiof.c
@@ -19,7 +19,6 @@
 #include <linux/interrupt.h>
 #include <linux/io.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/pm_runtime.h>
 
@@ -597,6 +596,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
         struct resource *r;
         struct spi_master *master;
         struct sh_msiof_spi_priv *p;
+        char clk_name[16];
         int i;
         int ret;
 
@@ -613,9 +613,10 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
         p->info = pdev->dev.platform_data;
         init_completion(&p->done);
 
-        p->clk = clk_get(&pdev->dev, NULL);
+        snprintf(clk_name, sizeof(clk_name), "msiof%d", pdev->id);
+        p->clk = clk_get(&pdev->dev, clk_name);
         if (IS_ERR(p->clk)) {
-                dev_err(&pdev->dev, "cannot get clock\n");
+                dev_err(&pdev->dev, "cannot get clock \"%s\"\n", clk_name);
                 ret = PTR_ERR(p->clk);
                 goto err1;
         }
@@ -634,7 +635,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        ret = request_irq(i, sh_msiof_spi_irq, 0,
+        ret = request_irq(i, sh_msiof_spi_irq, IRQF_DISABLED,
                           dev_name(&pdev->dev), p);
         if (ret) {
                 dev_err(&pdev->dev, "unable to request irq\n");
@@ -729,7 +730,18 @@ static struct platform_driver sh_msiof_spi_drv = {
                 .pm             = &sh_msiof_spi_dev_pm_ops,
         },
 };
-module_platform_driver(sh_msiof_spi_drv);
+
+static int __init sh_msiof_spi_init(void)
+{
+        return platform_driver_register(&sh_msiof_spi_drv);
+}
+module_init(sh_msiof_spi_init);
+
+static void __exit sh_msiof_spi_exit(void)
+{
+        platform_driver_unregister(&sh_msiof_spi_drv);
+}
+module_exit(sh_msiof_spi_exit);
 
 MODULE_DESCRIPTION("SuperH MSIOF SPI Master Interface Driver");
 MODULE_AUTHOR("Magnus Damm");
diff --git a/drivers/spi/spi-sh-sci.c b/drivers/spi/spi-sh-sci.c
index 097e506042b..e7779c09f6e 100644
--- a/drivers/spi/spi-sh-sci.c
+++ b/drivers/spi/spi-sh-sci.c
@@ -22,7 +22,6 @@
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
-#include <linux/module.h>
 
 #include <asm/spi.h>
 #include <asm/io.h>
@@ -187,7 +186,18 @@ static struct platform_driver sh_sci_spi_drv = {
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(sh_sci_spi_drv);
+
+static int __init sh_sci_spi_init(void)
+{
+        return platform_driver_register(&sh_sci_spi_drv);
+}
+module_init(sh_sci_spi_init);
+
+static void __exit sh_sci_spi_exit(void)
+{
+        platform_driver_unregister(&sh_sci_spi_drv);
+}
+module_exit(sh_sci_spi_exit);
 
 MODULE_DESCRIPTION("SH SCI SPI Driver");
 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
diff --git a/drivers/spi/spi-sh.c b/drivers/spi/spi-sh.c
index 3c3600a994b..9eedd71ad89 100644
--- a/drivers/spi/spi-sh.c
+++ b/drivers/spi/spi-sh.c
@@ -92,26 +92,17 @@ struct spi_sh_data {
         unsigned long cr1;
         wait_queue_head_t wait;
         spinlock_t lock;
-        int width;
 };
 
 static void spi_sh_write(struct spi_sh_data *ss, unsigned long data,
                              unsigned long offset)
 {
-        if (ss->width == 8)
-                iowrite8(data, ss->addr + (offset >> 2));
-        else if (ss->width == 32)
-                iowrite32(data, ss->addr + offset);
+        writel(data, ss->addr + offset);
 }
 
 static unsigned long spi_sh_read(struct spi_sh_data *ss, unsigned long offset)
 {
-        if (ss->width == 8)
-                return ioread8(ss->addr + (offset >> 2));
-        else if (ss->width == 32)
-                return ioread32(ss->addr + offset);
-        else
-                return 0;
+        return readl(ss->addr + offset);
 }
 
 static void spi_sh_set_bit(struct spi_sh_data *ss, unsigned long val,
@@ -432,7 +423,7 @@ static irqreturn_t spi_sh_irq(int irq, void *_ss)
         return IRQ_HANDLED;
 }
 
-static int spi_sh_remove(struct platform_device *pdev)
+static int __devexit spi_sh_remove(struct platform_device *pdev)
 {
         struct spi_sh_data *ss = dev_get_drvdata(&pdev->dev);
 
@@ -444,7 +435,7 @@ static int spi_sh_remove(struct platform_device *pdev)
         return 0;
 }
 
-static int spi_sh_probe(struct platform_device *pdev)
+static int __devinit spi_sh_probe(struct platform_device *pdev)
 {
         struct resource *res;
         struct spi_master *master;
@@ -473,18 +464,6 @@ static int spi_sh_probe(struct platform_device *pdev)
         ss = spi_master_get_devdata(master);
         dev_set_drvdata(&pdev->dev, ss);
 
-        switch (res->flags & IORESOURCE_MEM_TYPE_MASK) {
-        case IORESOURCE_MEM_8BIT:
-                ss->width = 8;
-                break;
-        case IORESOURCE_MEM_32BIT:
-                ss->width = 32;
-                break;
-        default:
-                dev_err(&pdev->dev, "No support width\n");
-                ret = -ENODEV;
-                goto error1;
-        }
         ss->irq = irq;
         ss->master = master;
         ss->addr = ioremap(res->start, resource_size(res));
@@ -505,7 +484,7 @@ static int spi_sh_probe(struct platform_device *pdev)
                 goto error2;
         }
 
-        ret = request_irq(irq, spi_sh_irq, 0, "spi_sh", ss);
+        ret = request_irq(irq, spi_sh_irq, IRQF_DISABLED, "spi_sh", ss);
         if (ret < 0) {
                 dev_err(&pdev->dev, "request_irq error\n");
                 goto error3;
@@ -539,13 +518,24 @@ static int spi_sh_probe(struct platform_device *pdev)
 
 static struct platform_driver spi_sh_driver = {
         .probe = spi_sh_probe,
-        .remove = spi_sh_remove,
+        .remove = __devexit_p(spi_sh_remove),
         .driver = {
                 .name = "sh_spi",
                 .owner = THIS_MODULE,
         },
 };
-module_platform_driver(spi_sh_driver);
+
+static int __init spi_sh_init(void)
+{
+        return platform_driver_register(&spi_sh_driver);
+}
+module_init(spi_sh_init);
+
+static void __exit spi_sh_exit(void)
+{
+        platform_driver_unregister(&spi_sh_driver);
+}
+module_exit(spi_sh_exit);
 
 MODULE_DESCRIPTION("SH SPI bus driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-sirf.c b/drivers/spi/spi-sirf.c
deleted file mode 100644
index e0f43a512e8..00000000000
--- a/drivers/spi/spi-sirf.c
+++ /dev/null
@@ -1,683 +0,0 @@
-/*
- * SPI bus driver for CSR SiRFprimaII
- *
- * Copyright (c) 2011 Cambridge Silicon Radio Limited, a CSR plc group company.
- *
- * Licensed under GPLv2 or later.
- */
-
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/slab.h>
-#include <linux/clk.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/of.h>
-#include <linux/bitops.h>
-#include <linux/err.h>
-#include <linux/platform_device.h>
-#include <linux/of_gpio.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/spi_bitbang.h>
-#include <linux/pinctrl/consumer.h>
-
-#define DRIVER_NAME "sirfsoc_spi"
-
-#define SIRFSOC_SPI_CTRL                0x0000
-#define SIRFSOC_SPI_CMD                 0x0004
-#define SIRFSOC_SPI_TX_RX_EN            0x0008
-#define SIRFSOC_SPI_INT_EN              0x000C
-#define SIRFSOC_SPI_INT_STATUS          0x0010
-#define SIRFSOC_SPI_TX_DMA_IO_CTRL      0x0100
-#define SIRFSOC_SPI_TX_DMA_IO_LEN       0x0104
-#define SIRFSOC_SPI_TXFIFO_CTRL         0x0108
-#define SIRFSOC_SPI_TXFIFO_LEVEL_CHK    0x010C
-#define SIRFSOC_SPI_TXFIFO_OP           0x0110
-#define SIRFSOC_SPI_TXFIFO_STATUS       0x0114
-#define SIRFSOC_SPI_TXFIFO_DATA         0x0118
-#define SIRFSOC_SPI_RX_DMA_IO_CTRL      0x0120
-#define SIRFSOC_SPI_RX_DMA_IO_LEN       0x0124
-#define SIRFSOC_SPI_RXFIFO_CTRL         0x0128
-#define SIRFSOC_SPI_RXFIFO_LEVEL_CHK    0x012C
-#define SIRFSOC_SPI_RXFIFO_OP           0x0130
-#define SIRFSOC_SPI_RXFIFO_STATUS       0x0134
-#define SIRFSOC_SPI_RXFIFO_DATA         0x0138
-#define SIRFSOC_SPI_DUMMY_DELAY_CTL     0x0144
-
-/* SPI CTRL register defines */
-#define SIRFSOC_SPI_SLV_MODE            BIT(16)
-#define SIRFSOC_SPI_CMD_MODE            BIT(17)
-#define SIRFSOC_SPI_CS_IO_OUT           BIT(18)
-#define SIRFSOC_SPI_CS_IO_MODE          BIT(19)
-#define SIRFSOC_SPI_CLK_IDLE_STAT       BIT(20)
-#define SIRFSOC_SPI_CS_IDLE_STAT        BIT(21)
-#define SIRFSOC_SPI_TRAN_MSB            BIT(22)
-#define SIRFSOC_SPI_DRV_POS_EDGE        BIT(23)
-#define SIRFSOC_SPI_CS_HOLD_TIME        BIT(24)
-#define SIRFSOC_SPI_CLK_SAMPLE_MODE     BIT(25)
-#define SIRFSOC_SPI_TRAN_DAT_FORMAT_8   (0 << 26)
-#define SIRFSOC_SPI_TRAN_DAT_FORMAT_12  (1 << 26)
-#define SIRFSOC_SPI_TRAN_DAT_FORMAT_16  (2 << 26)
-#define SIRFSOC_SPI_TRAN_DAT_FORMAT_32  (3 << 26)
-#define SIRFSOC_SPI_CMD_BYTE_NUM(x)             ((x & 3) << 28)
-#define SIRFSOC_SPI_ENA_AUTO_CLR                BIT(30)
-#define SIRFSOC_SPI_MUL_DAT_MODE                BIT(31)
-
-/* Interrupt Enable */
-#define SIRFSOC_SPI_RX_DONE_INT_EN              BIT(0)
-#define SIRFSOC_SPI_TX_DONE_INT_EN              BIT(1)
-#define SIRFSOC_SPI_RX_OFLOW_INT_EN             BIT(2)
-#define SIRFSOC_SPI_TX_UFLOW_INT_EN             BIT(3)
-#define SIRFSOC_SPI_RX_IO_DMA_INT_EN    BIT(4)
-#define SIRFSOC_SPI_TX_IO_DMA_INT_EN    BIT(5)
-#define SIRFSOC_SPI_RXFIFO_FULL_INT_EN  BIT(6)
-#define SIRFSOC_SPI_TXFIFO_EMPTY_INT_EN BIT(7)
-#define SIRFSOC_SPI_RXFIFO_THD_INT_EN   BIT(8)
-#define SIRFSOC_SPI_TXFIFO_THD_INT_EN   BIT(9)
-#define SIRFSOC_SPI_FRM_END_INT_EN      BIT(10)
-
-#define SIRFSOC_SPI_INT_MASK_ALL                0x1FFF
-
-/* Interrupt status */
-#define SIRFSOC_SPI_RX_DONE             BIT(0)
-#define SIRFSOC_SPI_TX_DONE             BIT(1)
-#define SIRFSOC_SPI_RX_OFLOW            BIT(2)
-#define SIRFSOC_SPI_TX_UFLOW            BIT(3)
-#define SIRFSOC_SPI_RX_FIFO_FULL        BIT(6)
-#define SIRFSOC_SPI_TXFIFO_EMPTY        BIT(7)
-#define SIRFSOC_SPI_RXFIFO_THD_REACH    BIT(8)
-#define SIRFSOC_SPI_TXFIFO_THD_REACH    BIT(9)
-#define SIRFSOC_SPI_FRM_END             BIT(10)
-
-/* TX RX enable */
-#define SIRFSOC_SPI_RX_EN               BIT(0)
-#define SIRFSOC_SPI_TX_EN               BIT(1)
-#define SIRFSOC_SPI_CMD_TX_EN           BIT(2)
-
-#define SIRFSOC_SPI_IO_MODE_SEL         BIT(0)
-#define SIRFSOC_SPI_RX_DMA_FLUSH        BIT(2)
-
-/* FIFO OPs */
-#define SIRFSOC_SPI_FIFO_RESET          BIT(0)
-#define SIRFSOC_SPI_FIFO_START          BIT(1)
-
-/* FIFO CTRL */
-#define SIRFSOC_SPI_FIFO_WIDTH_BYTE     (0 << 0)
-#define SIRFSOC_SPI_FIFO_WIDTH_WORD     (1 << 0)
-#define SIRFSOC_SPI_FIFO_WIDTH_DWORD    (2 << 0)
-
-/* FIFO Status */
-#define SIRFSOC_SPI_FIFO_LEVEL_MASK     0xFF
-#define SIRFSOC_SPI_FIFO_FULL           BIT(8)
-#define SIRFSOC_SPI_FIFO_EMPTY          BIT(9)
-
-/* 256 bytes rx/tx FIFO */
-#define SIRFSOC_SPI_FIFO_SIZE           256
-#define SIRFSOC_SPI_DAT_FRM_LEN_MAX     (64 * 1024)
-
-#define SIRFSOC_SPI_FIFO_SC(x)          ((x) & 0x3F)
-#define SIRFSOC_SPI_FIFO_LC(x)          (((x) & 0x3F) << 10)
-#define SIRFSOC_SPI_FIFO_HC(x)          (((x) & 0x3F) << 20)
-#define SIRFSOC_SPI_FIFO_THD(x)         (((x) & 0xFF) << 2)
-
-struct sirfsoc_spi {
-        struct spi_bitbang bitbang;
-        struct completion done;
-
-        void __iomem *base;
-        u32 ctrl_freq;  /* SPI controller clock speed */
-        struct clk *clk;
-        struct pinctrl *p;
-
-        /* rx & tx bufs from the spi_transfer */
-        const void *tx;
-        void *rx;
-
-        /* place received word into rx buffer */
-        void (*rx_word) (struct sirfsoc_spi *);
-        /* get word from tx buffer for sending */
-        void (*tx_word) (struct sirfsoc_spi *);
-
-        /* number of words left to be tranmitted/received */
-        unsigned int left_tx_cnt;
-        unsigned int left_rx_cnt;
-
-        /* tasklet to push tx msg into FIFO */
-        struct tasklet_struct tasklet_tx;
-
-        int chipselect[0];
-};
-
-static void spi_sirfsoc_rx_word_u8(struct sirfsoc_spi *sspi)
-{
-        u32 data;
-        u8 *rx = sspi->rx;
-
-        data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
-
-        if (rx) {
-                *rx++ = (u8) data;
-                sspi->rx = rx;
-        }
-
-        sspi->left_rx_cnt--;
-}
-
-static void spi_sirfsoc_tx_word_u8(struct sirfsoc_spi *sspi)
-{
-        u32 data = 0;
-        const u8 *tx = sspi->tx;
-
-        if (tx) {
-                data = *tx++;
-                sspi->tx = tx;
-        }
-
-        writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
-        sspi->left_tx_cnt--;
-}
-
-static void spi_sirfsoc_rx_word_u16(struct sirfsoc_spi *sspi)
-{
-        u32 data;
-        u16 *rx = sspi->rx;
-
-        data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
-
-        if (rx) {
-                *rx++ = (u16) data;
-                sspi->rx = rx;
-        }
-
-        sspi->left_rx_cnt--;
-}
-
-static void spi_sirfsoc_tx_word_u16(struct sirfsoc_spi *sspi)
-{
-        u32 data = 0;
-        const u16 *tx = sspi->tx;
-
-        if (tx) {
-                data = *tx++;
-                sspi->tx = tx;
-        }
-
-        writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
-        sspi->left_tx_cnt--;
-}
-
-static void spi_sirfsoc_rx_word_u32(struct sirfsoc_spi *sspi)
-{
-        u32 data;
-        u32 *rx = sspi->rx;
-
-        data = readl(sspi->base + SIRFSOC_SPI_RXFIFO_DATA);
-
-        if (rx) {
-                *rx++ = (u32) data;
-                sspi->rx = rx;
-        }
-
-        sspi->left_rx_cnt--;
-
-}
-
-static void spi_sirfsoc_tx_word_u32(struct sirfsoc_spi *sspi)
-{
-        u32 data = 0;
-        const u32 *tx = sspi->tx;
-
-        if (tx) {
-                data = *tx++;
-                sspi->tx = tx;
-        }
-
-        writel(data, sspi->base + SIRFSOC_SPI_TXFIFO_DATA);
-        sspi->left_tx_cnt--;
-}
-
-static void spi_sirfsoc_tasklet_tx(unsigned long arg)
-{
-        struct sirfsoc_spi *sspi = (struct sirfsoc_spi *)arg;
-
-        /* Fill Tx FIFO while there are left words to be transmitted */
-        while (!((readl(sspi->base + SIRFSOC_SPI_TXFIFO_STATUS) &
-                        SIRFSOC_SPI_FIFO_FULL)) &&
-                        sspi->left_tx_cnt)
-                sspi->tx_word(sspi);
-}
-
-static irqreturn_t spi_sirfsoc_irq(int irq, void *dev_id)
-{
-        struct sirfsoc_spi *sspi = dev_id;
-        u32 spi_stat = readl(sspi->base + SIRFSOC_SPI_INT_STATUS);
-
-        writel(spi_stat, sspi->base + SIRFSOC_SPI_INT_STATUS);
-
-        /* Error Conditions */
-        if (spi_stat & SIRFSOC_SPI_RX_OFLOW ||
-                        spi_stat & SIRFSOC_SPI_TX_UFLOW) {
-                complete(&sspi->done);
-                writel(0x0, sspi->base + SIRFSOC_SPI_INT_EN);
-        }
-
-        if (spi_stat & SIRFSOC_SPI_FRM_END) {
-                while (!((readl(sspi->base + SIRFSOC_SPI_RXFIFO_STATUS)
-                                & SIRFSOC_SPI_FIFO_EMPTY)) &&
-                                sspi->left_rx_cnt)
-                        sspi->rx_word(sspi);
-
-                /* Received all words */
-                if ((sspi->left_rx_cnt == 0) && (sspi->left_tx_cnt == 0)) {
-                        complete(&sspi->done);
-                        writel(0x0, sspi->base + SIRFSOC_SPI_INT_EN);
-                }
-        }
-
-        if (spi_stat & SIRFSOC_SPI_RXFIFO_THD_REACH ||
-                spi_stat & SIRFSOC_SPI_TXFIFO_THD_REACH ||
-                spi_stat & SIRFSOC_SPI_RX_FIFO_FULL ||
-                spi_stat & SIRFSOC_SPI_TXFIFO_EMPTY)
-                tasklet_schedule(&sspi->tasklet_tx);
-
-        return IRQ_HANDLED;
-}
-
-static int spi_sirfsoc_transfer(struct spi_device *spi, struct spi_transfer *t)
-{
-        struct sirfsoc_spi *sspi;
-        int timeout = t->len * 10;
-        sspi = spi_master_get_devdata(spi->master);
-
-        sspi->tx = t->tx_buf;
-        sspi->rx = t->rx_buf;
-        sspi->left_tx_cnt = sspi->left_rx_cnt = t->len;
-        INIT_COMPLETION(sspi->done);
-
-        writel(SIRFSOC_SPI_INT_MASK_ALL, sspi->base + SIRFSOC_SPI_INT_STATUS);
-
-        if (t->len == 1) {
-                writel(readl(sspi->base + SIRFSOC_SPI_CTRL) |
-                        SIRFSOC_SPI_ENA_AUTO_CLR,
-                        sspi->base + SIRFSOC_SPI_CTRL);
-                writel(0, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
-                writel(0, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
-        } else if ((t->len > 1) && (t->len < SIRFSOC_SPI_DAT_FRM_LEN_MAX)) {
-                writel(readl(sspi->base + SIRFSOC_SPI_CTRL) |
-                                SIRFSOC_SPI_MUL_DAT_MODE |
-                                SIRFSOC_SPI_ENA_AUTO_CLR,
-                        sspi->base + SIRFSOC_SPI_CTRL);
-                writel(t->len - 1, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
-                writel(t->len - 1, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
-        } else {
-                writel(readl(sspi->base + SIRFSOC_SPI_CTRL),
-                        sspi->base + SIRFSOC_SPI_CTRL);
-                writel(0, sspi->base + SIRFSOC_SPI_TX_DMA_IO_LEN);
-                writel(0, sspi->base + SIRFSOC_SPI_RX_DMA_IO_LEN);
-        }
-
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-
-        /* Send the first word to trigger the whole tx/rx process */
-        sspi->tx_word(sspi);
-
-        writel(SIRFSOC_SPI_RX_OFLOW_INT_EN | SIRFSOC_SPI_TX_UFLOW_INT_EN |
-                SIRFSOC_SPI_RXFIFO_THD_INT_EN | SIRFSOC_SPI_TXFIFO_THD_INT_EN |
-                SIRFSOC_SPI_FRM_END_INT_EN | SIRFSOC_SPI_RXFIFO_FULL_INT_EN |
-                SIRFSOC_SPI_TXFIFO_EMPTY_INT_EN, sspi->base + SIRFSOC_SPI_INT_EN);
-        writel(SIRFSOC_SPI_RX_EN | SIRFSOC_SPI_TX_EN, sspi->base + SIRFSOC_SPI_TX_RX_EN);
-
-        if (wait_for_completion_timeout(&sspi->done, timeout) == 0)
-                dev_err(&spi->dev, "transfer timeout\n");
-
-        /* TX, RX FIFO stop */
-        writel(0, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(0, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-        writel(0, sspi->base + SIRFSOC_SPI_TX_RX_EN);
-        writel(0, sspi->base + SIRFSOC_SPI_INT_EN);
-
-        return t->len - sspi->left_rx_cnt;
-}
-
-static void spi_sirfsoc_chipselect(struct spi_device *spi, int value)
-{
-        struct sirfsoc_spi *sspi = spi_master_get_devdata(spi->master);
-
-        if (sspi->chipselect[spi->chip_select] == 0) {
-                u32 regval = readl(sspi->base + SIRFSOC_SPI_CTRL);
-                regval |= SIRFSOC_SPI_CS_IO_OUT;
-                switch (value) {
-                case BITBANG_CS_ACTIVE:
-                        if (spi->mode & SPI_CS_HIGH)
-                                regval |= SIRFSOC_SPI_CS_IO_OUT;
-                        else
-                                regval &= ~SIRFSOC_SPI_CS_IO_OUT;
-                        break;
-                case BITBANG_CS_INACTIVE:
-                        if (spi->mode & SPI_CS_HIGH)
-                                regval &= ~SIRFSOC_SPI_CS_IO_OUT;
-                        else
-                                regval |= SIRFSOC_SPI_CS_IO_OUT;
-                        break;
-                }
-                writel(regval, sspi->base + SIRFSOC_SPI_CTRL);
-        } else {
-                int gpio = sspi->chipselect[spi->chip_select];
-                gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1);
-        }
-}
-
-static int
-spi_sirfsoc_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
-{
-        struct sirfsoc_spi *sspi;
-        u8 bits_per_word = 0;
-        int hz = 0;
-        u32 regval;
-        u32 txfifo_ctrl, rxfifo_ctrl;
-        u32 fifo_size = SIRFSOC_SPI_FIFO_SIZE / 4;
-
-        sspi = spi_master_get_devdata(spi->master);
-
-        bits_per_word = t && t->bits_per_word ? t->bits_per_word :
-                spi->bits_per_word;
-        hz = t && t->speed_hz ? t->speed_hz : spi->max_speed_hz;
-
-        /* Enable IO mode for RX, TX */
-        writel(SIRFSOC_SPI_IO_MODE_SEL, sspi->base + SIRFSOC_SPI_TX_DMA_IO_CTRL);
-        writel(SIRFSOC_SPI_IO_MODE_SEL, sspi->base + SIRFSOC_SPI_RX_DMA_IO_CTRL);
-        regval = (sspi->ctrl_freq / (2 * hz)) - 1;
-
-        if (regval > 0xFFFF || regval < 0) {
-                dev_err(&spi->dev, "Speed %d not supported\n", hz);
-                return -EINVAL;
-        }
-
-        switch (bits_per_word) {
-        case 8:
-                regval |= SIRFSOC_SPI_TRAN_DAT_FORMAT_8;
-                sspi->rx_word = spi_sirfsoc_rx_word_u8;
-                sspi->tx_word = spi_sirfsoc_tx_word_u8;
-                txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_BYTE;
-                rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_BYTE;
-                break;
-        case 12:
-        case 16:
-                regval |= (bits_per_word ==  12) ? SIRFSOC_SPI_TRAN_DAT_FORMAT_12 :
-                        SIRFSOC_SPI_TRAN_DAT_FORMAT_16;
-                sspi->rx_word = spi_sirfsoc_rx_word_u16;
-                sspi->tx_word = spi_sirfsoc_tx_word_u16;
-                txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_WORD;
-                rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_WORD;
-                break;
-        case 32:
-                regval |= SIRFSOC_SPI_TRAN_DAT_FORMAT_32;
-                sspi->rx_word = spi_sirfsoc_rx_word_u32;
-                sspi->tx_word = spi_sirfsoc_tx_word_u32;
-                txfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_DWORD;
-                rxfifo_ctrl = SIRFSOC_SPI_FIFO_THD(SIRFSOC_SPI_FIFO_SIZE / 2) |
-                                        SIRFSOC_SPI_FIFO_WIDTH_DWORD;
-                break;
-        default:
-                dev_err(&spi->dev, "Bits per word %d not supported\n",
-                       bits_per_word);
-                return -EINVAL;
-        }
-
-        if (!(spi->mode & SPI_CS_HIGH))
-                regval |= SIRFSOC_SPI_CS_IDLE_STAT;
-        if (!(spi->mode & SPI_LSB_FIRST))
-                regval |= SIRFSOC_SPI_TRAN_MSB;
-        if (spi->mode & SPI_CPOL)
-                regval |= SIRFSOC_SPI_CLK_IDLE_STAT;
-
-        /*
-         * Data should be driven at least 1/2 cycle before the fetch edge to make
-         * sure that data gets stable at the fetch edge.
-         */
-        if (((spi->mode & SPI_CPOL) && (spi->mode & SPI_CPHA)) ||
-            (!(spi->mode & SPI_CPOL) && !(spi->mode & SPI_CPHA)))
-                regval &= ~SIRFSOC_SPI_DRV_POS_EDGE;
-        else
-                regval |= SIRFSOC_SPI_DRV_POS_EDGE;
-
-        writel(SIRFSOC_SPI_FIFO_SC(fifo_size - 2) |
-                        SIRFSOC_SPI_FIFO_LC(fifo_size / 2) |
-                        SIRFSOC_SPI_FIFO_HC(2),
-                sspi->base + SIRFSOC_SPI_TXFIFO_LEVEL_CHK);
-        writel(SIRFSOC_SPI_FIFO_SC(2) |
-                        SIRFSOC_SPI_FIFO_LC(fifo_size / 2) |
-                        SIRFSOC_SPI_FIFO_HC(fifo_size - 2),
-                sspi->base + SIRFSOC_SPI_RXFIFO_LEVEL_CHK);
-        writel(txfifo_ctrl, sspi->base + SIRFSOC_SPI_TXFIFO_CTRL);
-        writel(rxfifo_ctrl, sspi->base + SIRFSOC_SPI_RXFIFO_CTRL);
-
-        writel(regval, sspi->base + SIRFSOC_SPI_CTRL);
-        return 0;
-}
-
-static int spi_sirfsoc_setup(struct spi_device *spi)
-{
-        struct sirfsoc_spi *sspi;
-
-        if (!spi->max_speed_hz)
-                return -EINVAL;
-
-        sspi = spi_master_get_devdata(spi->master);
-
-        if (!spi->bits_per_word)
-                spi->bits_per_word = 8;
-
-        return spi_sirfsoc_setup_transfer(spi, NULL);
-}
-
-static int spi_sirfsoc_probe(struct platform_device *pdev)
-{
-        struct sirfsoc_spi *sspi;
-        struct spi_master *master;
-        struct resource *mem_res;
-        int num_cs, cs_gpio, irq;
-        int i;
-        int ret;
-
-        ret = of_property_read_u32(pdev->dev.of_node,
-                        "sirf,spi-num-chipselects", &num_cs);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Unable to get chip select number\n");
-                goto err_cs;
-        }
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*sspi) + sizeof(int) * num_cs);
-        if (!master) {
-                dev_err(&pdev->dev, "Unable to allocate SPI master\n");
-                return -ENOMEM;
-        }
-        platform_set_drvdata(pdev, master);
-        sspi = spi_master_get_devdata(master);
-
-        mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!mem_res) {
-                dev_err(&pdev->dev, "Unable to get IO resource\n");
-                ret = -ENODEV;
-                goto free_master;
-        }
-        master->num_chipselect = num_cs;
-
-        for (i = 0; i < master->num_chipselect; i++) {
-                cs_gpio = of_get_named_gpio(pdev->dev.of_node, "cs-gpios", i);
-                if (cs_gpio < 0) {
-                        dev_err(&pdev->dev, "can't get cs gpio from DT\n");
-                        ret = -ENODEV;
-                        goto free_master;
-                }
-
-                sspi->chipselect[i] = cs_gpio;
-                if (cs_gpio == 0)
-                        continue; /* use cs from spi controller */
-
-                ret = gpio_request(cs_gpio, DRIVER_NAME);
-                if (ret) {
-                        while (i > 0) {
-                                i--;
-                                if (sspi->chipselect[i] > 0)
-                                        gpio_free(sspi->chipselect[i]);
-                        }
-                        dev_err(&pdev->dev, "fail to request cs gpios\n");
-                        goto free_master;
-                }
-        }
-
-        sspi->base = devm_request_and_ioremap(&pdev->dev, mem_res);
-        if (!sspi->base) {
-                dev_err(&pdev->dev, "IO remap failed!\n");
-                ret = -ENOMEM;
-                goto free_master;
-        }
-
-        irq = platform_get_irq(pdev, 0);
-        if (irq < 0) {
-                ret = -ENXIO;
-                goto free_master;
-        }
-        ret = devm_request_irq(&pdev->dev, irq, spi_sirfsoc_irq, 0,
-                                DRIVER_NAME, sspi);
-        if (ret)
-                goto free_master;
-
-        sspi->bitbang.master = spi_master_get(master);
-        sspi->bitbang.chipselect = spi_sirfsoc_chipselect;
-        sspi->bitbang.setup_transfer = spi_sirfsoc_setup_transfer;
-        sspi->bitbang.txrx_bufs = spi_sirfsoc_transfer;
-        sspi->bitbang.master->setup = spi_sirfsoc_setup;
-        master->bus_num = pdev->id;
-        sspi->bitbang.master->dev.of_node = pdev->dev.of_node;
-
-        sspi->p = pinctrl_get_select_default(&pdev->dev);
-        ret = IS_ERR(sspi->p);
-        if (ret)
-                goto free_master;
-
-        sspi->clk = clk_get(&pdev->dev, NULL);
-        if (IS_ERR(sspi->clk)) {
-                ret = -EINVAL;
-                goto free_pin;
-        }
-        clk_enable(sspi->clk);
-        sspi->ctrl_freq = clk_get_rate(sspi->clk);
-
-        init_completion(&sspi->done);
-
-        tasklet_init(&sspi->tasklet_tx, spi_sirfsoc_tasklet_tx,
-                     (unsigned long)sspi);
-
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-        /* We are not using dummy delay between command and data */
-        writel(0, sspi->base + SIRFSOC_SPI_DUMMY_DELAY_CTL);
-
-        ret = spi_bitbang_start(&sspi->bitbang);
-        if (ret)
-                goto free_clk;
-
-        dev_info(&pdev->dev, "registerred, bus number = %d\n", master->bus_num);
-
-        return 0;
-
-free_clk:
-        clk_disable(sspi->clk);
-        clk_put(sspi->clk);
-free_pin:
-        pinctrl_put(sspi->p);
-free_master:
-        spi_master_put(master);
-err_cs:
-        return ret;
-}
-
-static int  spi_sirfsoc_remove(struct platform_device *pdev)
-{
-        struct spi_master *master;
-        struct sirfsoc_spi *sspi;
-        int i;
-
-        master = platform_get_drvdata(pdev);
-        sspi = spi_master_get_devdata(master);
-
-        spi_bitbang_stop(&sspi->bitbang);
-        for (i = 0; i < master->num_chipselect; i++) {
-                if (sspi->chipselect[i] > 0)
-                        gpio_free(sspi->chipselect[i]);
-        }
-        clk_disable(sspi->clk);
-        clk_put(sspi->clk);
-        pinctrl_put(sspi->p);
-        spi_master_put(master);
-        return 0;
-}
-
-#ifdef CONFIG_PM
-static int spi_sirfsoc_suspend(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct spi_master *master = platform_get_drvdata(pdev);
-        struct sirfsoc_spi *sspi = spi_master_get_devdata(master);
-
-        clk_disable(sspi->clk);
-        return 0;
-}
-
-static int spi_sirfsoc_resume(struct device *dev)
-{
-        struct platform_device *pdev = to_platform_device(dev);
-        struct spi_master *master = platform_get_drvdata(pdev);
-        struct sirfsoc_spi *sspi = spi_master_get_devdata(master);
-
-        clk_enable(sspi->clk);
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_RESET, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_RXFIFO_OP);
-        writel(SIRFSOC_SPI_FIFO_START, sspi->base + SIRFSOC_SPI_TXFIFO_OP);
-
-        return 0;
-}
-
-static const struct dev_pm_ops spi_sirfsoc_pm_ops = {
-        .suspend = spi_sirfsoc_suspend,
-        .resume = spi_sirfsoc_resume,
-};
-#endif
-
-static const struct of_device_id spi_sirfsoc_of_match[] = {
-        { .compatible = "sirf,prima2-spi", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, sirfsoc_spi_of_match);
-
-static struct platform_driver spi_sirfsoc_driver = {
-        .driver = {
-                .name = DRIVER_NAME,
-                .owner = THIS_MODULE,
-#ifdef CONFIG_PM
-                .pm     = &spi_sirfsoc_pm_ops,
-#endif
-                .of_match_table = spi_sirfsoc_of_match,
-        },
-        .probe = spi_sirfsoc_probe,
-        .remove = spi_sirfsoc_remove,
-};
-module_platform_driver(spi_sirfsoc_driver);
-
-MODULE_DESCRIPTION("SiRF SoC SPI master driver");
-MODULE_AUTHOR("Zhiwu Song <Zhiwu.Song@csr.com>, "
-                "Barry Song <Baohua.Song@csr.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-tegra20-sflash.c b/drivers/spi/spi-tegra20-sflash.c
deleted file mode 100644
index 448a8cc71df..00000000000
--- a/drivers/spi/spi-tegra20-sflash.c
+++ /dev/null
@@ -1,665 +0,0 @@
-/*
- * SPI driver for Nvidia's Tegra20 Serial Flash Controller.
- *
- * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
- *
- * Author: Laxman Dewangan <ldewangan@nvidia.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/clk.h>
-#include <linux/completion.h>
-#include <linux/delay.h>
-#include <linux/err.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/kthread.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/spi-tegra.h>
-#include <mach/clk.h>
-
-#define SPI_COMMAND                             0x000
-#define SPI_GO                                  BIT(30)
-#define SPI_M_S                                 BIT(28)
-#define SPI_ACTIVE_SCLK_MASK                    (0x3 << 26)
-#define SPI_ACTIVE_SCLK_DRIVE_LOW               (0 << 26)
-#define SPI_ACTIVE_SCLK_DRIVE_HIGH              (1 << 26)
-#define SPI_ACTIVE_SCLK_PULL_LOW                (2 << 26)
-#define SPI_ACTIVE_SCLK_PULL_HIGH               (3 << 26)
-
-#define SPI_CK_SDA_FALLING                      (1 << 21)
-#define SPI_CK_SDA_RISING                       (0 << 21)
-#define SPI_CK_SDA_MASK                         (1 << 21)
-#define SPI_ACTIVE_SDA                          (0x3 << 18)
-#define SPI_ACTIVE_SDA_DRIVE_LOW                (0 << 18)
-#define SPI_ACTIVE_SDA_DRIVE_HIGH               (1 << 18)
-#define SPI_ACTIVE_SDA_PULL_LOW                 (2 << 18)
-#define SPI_ACTIVE_SDA_PULL_HIGH                (3 << 18)
-
-#define SPI_CS_POL_INVERT                       BIT(16)
-#define SPI_TX_EN                               BIT(15)
-#define SPI_RX_EN                               BIT(14)
-#define SPI_CS_VAL_HIGH                         BIT(13)
-#define SPI_CS_VAL_LOW                          0x0
-#define SPI_CS_SW                               BIT(12)
-#define SPI_CS_HW                               0x0
-#define SPI_CS_DELAY_MASK                       (7 << 9)
-#define SPI_CS3_EN                              BIT(8)
-#define SPI_CS2_EN                              BIT(7)
-#define SPI_CS1_EN                              BIT(6)
-#define SPI_CS0_EN                              BIT(5)
-
-#define SPI_CS_MASK                     (SPI_CS3_EN | SPI_CS2_EN |      \
-                                        SPI_CS1_EN | SPI_CS0_EN)
-#define SPI_BIT_LENGTH(x)               (((x) & 0x1f) << 0)
-
-#define SPI_MODES                       (SPI_ACTIVE_SCLK_MASK | SPI_CK_SDA_MASK)
-
-#define SPI_STATUS                      0x004
-#define SPI_BSY                         BIT(31)
-#define SPI_RDY                         BIT(30)
-#define SPI_TXF_FLUSH                   BIT(29)
-#define SPI_RXF_FLUSH                   BIT(28)
-#define SPI_RX_UNF                      BIT(27)
-#define SPI_TX_OVF                      BIT(26)
-#define SPI_RXF_EMPTY                   BIT(25)
-#define SPI_RXF_FULL                    BIT(24)
-#define SPI_TXF_EMPTY                   BIT(23)
-#define SPI_TXF_FULL                    BIT(22)
-#define SPI_BLK_CNT(count)              (((count) & 0xffff) + 1)
-
-#define SPI_FIFO_ERROR                  (SPI_RX_UNF | SPI_TX_OVF)
-#define SPI_FIFO_EMPTY                  (SPI_TX_EMPTY | SPI_RX_EMPTY)
-
-#define SPI_RX_CMP                      0x8
-#define SPI_DMA_CTL                     0x0C
-#define SPI_DMA_EN                      BIT(31)
-#define SPI_IE_RXC                      BIT(27)
-#define SPI_IE_TXC                      BIT(26)
-#define SPI_PACKED                      BIT(20)
-#define SPI_RX_TRIG_MASK                (0x3 << 18)
-#define SPI_RX_TRIG_1W                  (0x0 << 18)
-#define SPI_RX_TRIG_4W                  (0x1 << 18)
-#define SPI_TX_TRIG_MASK                (0x3 << 16)
-#define SPI_TX_TRIG_1W                  (0x0 << 16)
-#define SPI_TX_TRIG_4W                  (0x1 << 16)
-#define SPI_DMA_BLK_COUNT(count)        (((count) - 1) & 0xFFFF);
-
-#define SPI_TX_FIFO                     0x10
-#define SPI_RX_FIFO                     0x20
-
-#define DATA_DIR_TX                     (1 << 0)
-#define DATA_DIR_RX                     (1 << 1)
-
-#define MAX_CHIP_SELECT                 4
-#define SPI_FIFO_DEPTH                  4
-#define SPI_DMA_TIMEOUT               (msecs_to_jiffies(1000))
-
-struct tegra_sflash_data {
-        struct device                           *dev;
-        struct spi_master                       *master;
-        spinlock_t                              lock;
-
-        struct clk                              *clk;
-        void __iomem                            *base;
-        unsigned                                irq;
-        u32                                     spi_max_frequency;
-        u32                                     cur_speed;
-
-        struct spi_device                       *cur_spi;
-        unsigned                                cur_pos;
-        unsigned                                cur_len;
-        unsigned                                bytes_per_word;
-        unsigned                                cur_direction;
-        unsigned                                curr_xfer_words;
-
-        unsigned                                cur_rx_pos;
-        unsigned                                cur_tx_pos;
-
-        u32                                     tx_status;
-        u32                                     rx_status;
-        u32                                     status_reg;
-
-        u32                                     def_command_reg;
-        u32                                     command_reg;
-        u32                                     dma_control_reg;
-
-        struct completion                       xfer_completion;
-        struct spi_transfer                     *curr_xfer;
-};
-
-static int tegra_sflash_runtime_suspend(struct device *dev);
-static int tegra_sflash_runtime_resume(struct device *dev);
-
-static inline unsigned long tegra_sflash_readl(struct tegra_sflash_data *tsd,
-                unsigned long reg)
-{
-        return readl(tsd->base + reg);
-}
-
-static inline void tegra_sflash_writel(struct tegra_sflash_data *tsd,
-                unsigned long val, unsigned long reg)
-{
-        writel(val, tsd->base + reg);
-}
-
-static void tegra_sflash_clear_status(struct tegra_sflash_data *tsd)
-{
-        /* Write 1 to clear status register */
-        tegra_sflash_writel(tsd, SPI_RDY | SPI_FIFO_ERROR, SPI_STATUS);
-}
-
-static unsigned tegra_sflash_calculate_curr_xfer_param(
-        struct spi_device *spi, struct tegra_sflash_data *tsd,
-        struct spi_transfer *t)
-{
-        unsigned remain_len = t->len - tsd->cur_pos;
-        unsigned max_word;
-
-        tsd->bytes_per_word = (t->bits_per_word - 1) / 8 + 1;
-        max_word = remain_len / tsd->bytes_per_word;
-        if (max_word > SPI_FIFO_DEPTH)
-                max_word = SPI_FIFO_DEPTH;
-        tsd->curr_xfer_words = max_word;
-        return max_word;
-}
-
-static unsigned tegra_sflash_fill_tx_fifo_from_client_txbuf(
-        struct tegra_sflash_data *tsd, struct spi_transfer *t)
-{
-        unsigned nbytes;
-        unsigned long status;
-        unsigned max_n_32bit = tsd->curr_xfer_words;
-        u8 *tx_buf = (u8 *)t->tx_buf + tsd->cur_tx_pos;
-
-        if (max_n_32bit > SPI_FIFO_DEPTH)
-                max_n_32bit = SPI_FIFO_DEPTH;
-        nbytes = max_n_32bit * tsd->bytes_per_word;
-
-        status = tegra_sflash_readl(tsd, SPI_STATUS);
-        while (!(status & SPI_TXF_FULL)) {
-                int i;
-                unsigned int x = 0;
-
-                for (i = 0; nbytes && (i < tsd->bytes_per_word);
-                                                        i++, nbytes--)
-                                x |= ((*tx_buf++) << i*8);
-                tegra_sflash_writel(tsd, x, SPI_TX_FIFO);
-                if (!nbytes)
-                        break;
-
-                status = tegra_sflash_readl(tsd, SPI_STATUS);
-        }
-        tsd->cur_tx_pos += max_n_32bit * tsd->bytes_per_word;
-        return max_n_32bit;
-}
-
-static int tegra_sflash_read_rx_fifo_to_client_rxbuf(
-                struct tegra_sflash_data *tsd, struct spi_transfer *t)
-{
-        unsigned long status;
-        unsigned int read_words = 0;
-        u8 *rx_buf = (u8 *)t->rx_buf + tsd->cur_rx_pos;
-
-        status = tegra_sflash_readl(tsd, SPI_STATUS);
-        while (!(status & SPI_RXF_EMPTY)) {
-                int i;
-                unsigned long x;
-
-                x = tegra_sflash_readl(tsd, SPI_RX_FIFO);
-                for (i = 0; (i < tsd->bytes_per_word); i++)
-                        *rx_buf++ = (x >> (i*8)) & 0xFF;
-                read_words++;
-                status = tegra_sflash_readl(tsd, SPI_STATUS);
-        }
-        tsd->cur_rx_pos += read_words * tsd->bytes_per_word;
-        return 0;
-}
-
-static int tegra_sflash_start_cpu_based_transfer(
-                struct tegra_sflash_data *tsd, struct spi_transfer *t)
-{
-        unsigned long val = 0;
-        unsigned cur_words;
-
-        if (tsd->cur_direction & DATA_DIR_TX)
-                val |= SPI_IE_TXC;
-
-        if (tsd->cur_direction & DATA_DIR_RX)
-                val |= SPI_IE_RXC;
-
-        tegra_sflash_writel(tsd, val, SPI_DMA_CTL);
-        tsd->dma_control_reg = val;
-
-        if (tsd->cur_direction & DATA_DIR_TX)
-                cur_words = tegra_sflash_fill_tx_fifo_from_client_txbuf(tsd, t);
-        else
-                cur_words = tsd->curr_xfer_words;
-        val |= SPI_DMA_BLK_COUNT(cur_words);
-        tegra_sflash_writel(tsd, val, SPI_DMA_CTL);
-        tsd->dma_control_reg = val;
-        val |= SPI_DMA_EN;
-        tegra_sflash_writel(tsd, val, SPI_DMA_CTL);
-        return 0;
-}
-
-static int tegra_sflash_start_transfer_one(struct spi_device *spi,
-                struct spi_transfer *t, bool is_first_of_msg,
-                bool is_single_xfer)
-{
-        struct tegra_sflash_data *tsd = spi_master_get_devdata(spi->master);
-        u32 speed;
-        unsigned long command;
-
-        speed = t->speed_hz ? t->speed_hz : spi->max_speed_hz;
-        if (!speed)
-                speed = tsd->spi_max_frequency;
-        if (speed != tsd->cur_speed) {
-                clk_set_rate(tsd->clk, speed);
-                tsd->cur_speed = speed;
-        }
-
-        tsd->cur_spi = spi;
-        tsd->cur_pos = 0;
-        tsd->cur_rx_pos = 0;
-        tsd->cur_tx_pos = 0;
-        tsd->curr_xfer = t;
-        tegra_sflash_calculate_curr_xfer_param(spi, tsd, t);
-        if (is_first_of_msg) {
-                command = tsd->def_command_reg;
-                command |= SPI_BIT_LENGTH(t->bits_per_word - 1);
-                command |= SPI_CS_VAL_HIGH;
-
-                command &= ~SPI_MODES;
-                if (spi->mode & SPI_CPHA)
-                        command |= SPI_CK_SDA_FALLING;
-
-                if (spi->mode & SPI_CPOL)
-                        command |= SPI_ACTIVE_SCLK_DRIVE_HIGH;
-                else
-                        command |= SPI_ACTIVE_SCLK_DRIVE_LOW;
-                command |= SPI_CS0_EN << spi->chip_select;
-        } else {
-                command = tsd->command_reg;
-                command &= ~SPI_BIT_LENGTH(~0);
-                command |= SPI_BIT_LENGTH(t->bits_per_word - 1);
-                command &= ~(SPI_RX_EN | SPI_TX_EN);
-        }
-
-        tsd->cur_direction = 0;
-        if (t->rx_buf) {
-                command |= SPI_RX_EN;
-                tsd->cur_direction |= DATA_DIR_RX;
-        }
-        if (t->tx_buf) {
-                command |= SPI_TX_EN;
-                tsd->cur_direction |= DATA_DIR_TX;
-        }
-        tegra_sflash_writel(tsd, command, SPI_COMMAND);
-        tsd->command_reg = command;
-
-        return  tegra_sflash_start_cpu_based_transfer(tsd, t);
-}
-
-static int tegra_sflash_transfer_one_message(struct spi_master *master,
-                        struct spi_message *msg)
-{
-        bool is_first_msg = true;
-        int single_xfer;
-        struct tegra_sflash_data *tsd = spi_master_get_devdata(master);
-        struct spi_transfer *xfer;
-        struct spi_device *spi = msg->spi;
-        int ret;
-
-        ret = pm_runtime_get_sync(tsd->dev);
-        if (ret < 0) {
-                dev_err(tsd->dev, "pm_runtime_get() failed, err = %d\n", ret);
-                return ret;
-        }
-
-        msg->status = 0;
-        msg->actual_length = 0;
-        single_xfer = list_is_singular(&msg->transfers);
-        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                INIT_COMPLETION(tsd->xfer_completion);
-                ret = tegra_sflash_start_transfer_one(spi, xfer,
-                                        is_first_msg, single_xfer);
-                if (ret < 0) {
-                        dev_err(tsd->dev,
-                                "spi can not start transfer, err %d\n", ret);
-                        goto exit;
-                }
-                is_first_msg = false;
-                ret = wait_for_completion_timeout(&tsd->xfer_completion,
-                                                SPI_DMA_TIMEOUT);
-                if (WARN_ON(ret == 0)) {
-                        dev_err(tsd->dev,
-                                "spi trasfer timeout, err %d\n", ret);
-                        ret = -EIO;
-                        goto exit;
-                }
-
-                if (tsd->tx_status ||  tsd->rx_status) {
-                        dev_err(tsd->dev, "Error in Transfer\n");
-                        ret = -EIO;
-                        goto exit;
-                }
-                msg->actual_length += xfer->len;
-                if (xfer->cs_change && xfer->delay_usecs) {
-                        tegra_sflash_writel(tsd, tsd->def_command_reg,
-                                        SPI_COMMAND);
-                        udelay(xfer->delay_usecs);
-                }
-        }
-        ret = 0;
-exit:
-        tegra_sflash_writel(tsd, tsd->def_command_reg, SPI_COMMAND);
-        msg->status = ret;
-        spi_finalize_current_message(master);
-        pm_runtime_put(tsd->dev);
-        return ret;
-}
-
-static irqreturn_t handle_cpu_based_xfer(struct tegra_sflash_data *tsd)
-{
-        struct spi_transfer *t = tsd->curr_xfer;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tsd->lock, flags);
-        if (tsd->tx_status || tsd->rx_status || (tsd->status_reg & SPI_BSY)) {
-                dev_err(tsd->dev,
-                        "CpuXfer ERROR bit set 0x%x\n", tsd->status_reg);
-                dev_err(tsd->dev,
-                        "CpuXfer 0x%08x:0x%08x\n", tsd->command_reg,
-                                tsd->dma_control_reg);
-                tegra_periph_reset_assert(tsd->clk);
-                udelay(2);
-                tegra_periph_reset_deassert(tsd->clk);
-                complete(&tsd->xfer_completion);
-                goto exit;
-        }
-
-        if (tsd->cur_direction & DATA_DIR_RX)
-                tegra_sflash_read_rx_fifo_to_client_rxbuf(tsd, t);
-
-        if (tsd->cur_direction & DATA_DIR_TX)
-                tsd->cur_pos = tsd->cur_tx_pos;
-        else
-                tsd->cur_pos = tsd->cur_rx_pos;
-
-        if (tsd->cur_pos == t->len) {
-                complete(&tsd->xfer_completion);
-                goto exit;
-        }
-
-        tegra_sflash_calculate_curr_xfer_param(tsd->cur_spi, tsd, t);
-        tegra_sflash_start_cpu_based_transfer(tsd, t);
-exit:
-        spin_unlock_irqrestore(&tsd->lock, flags);
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t tegra_sflash_isr(int irq, void *context_data)
-{
-        struct tegra_sflash_data *tsd = context_data;
-
-        tsd->status_reg = tegra_sflash_readl(tsd, SPI_STATUS);
-        if (tsd->cur_direction & DATA_DIR_TX)
-                tsd->tx_status = tsd->status_reg & SPI_TX_OVF;
-
-        if (tsd->cur_direction & DATA_DIR_RX)
-                tsd->rx_status = tsd->status_reg & SPI_RX_UNF;
-        tegra_sflash_clear_status(tsd);
-
-        return handle_cpu_based_xfer(tsd);
-}
-
-static struct tegra_spi_platform_data *tegra_sflash_parse_dt(
-                struct platform_device *pdev)
-{
-        struct tegra_spi_platform_data *pdata;
-        struct device_node *np = pdev->dev.of_node;
-        u32 max_freq;
-
-        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata) {
-                dev_err(&pdev->dev, "Memory alloc for pdata failed\n");
-                return NULL;
-        }
-
-        if (!of_property_read_u32(np, "spi-max-frequency", &max_freq))
-                pdata->spi_max_frequency = max_freq;
-
-        return pdata;
-}
-
-static struct of_device_id tegra_sflash_of_match[] = {
-        { .compatible = "nvidia,tegra20-sflash", },
-        {}
-};
-MODULE_DEVICE_TABLE(of, tegra_sflash_of_match);
-
-static int tegra_sflash_probe(struct platform_device *pdev)
-{
-        struct spi_master       *master;
-        struct tegra_sflash_data        *tsd;
-        struct resource         *r;
-        struct tegra_spi_platform_data *pdata = pdev->dev.platform_data;
-        int ret;
-        const struct of_device_id *match;
-
-        match = of_match_device(of_match_ptr(tegra_sflash_of_match),
-                                        &pdev->dev);
-        if (!match) {
-                dev_err(&pdev->dev, "Error: No device match found\n");
-                return -ENODEV;
-        }
-
-        if (!pdata && pdev->dev.of_node)
-                pdata = tegra_sflash_parse_dt(pdev);
-
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform data, exiting\n");
-                return -ENODEV;
-        }
-
-        if (!pdata->spi_max_frequency)
-                pdata->spi_max_frequency = 25000000; /* 25MHz */
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*tsd));
-        if (!master) {
-                dev_err(&pdev->dev, "master allocation failed\n");
-                return -ENOMEM;
-        }
-
-        /* the spi->mode bits understood by this driver: */
-        master->mode_bits = SPI_CPOL | SPI_CPHA;
-        master->transfer_one_message = tegra_sflash_transfer_one_message;
-        master->num_chipselect = MAX_CHIP_SELECT;
-        master->bus_num = -1;
-
-        dev_set_drvdata(&pdev->dev, master);
-        tsd = spi_master_get_devdata(master);
-        tsd->master = master;
-        tsd->dev = &pdev->dev;
-        spin_lock_init(&tsd->lock);
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r) {
-                dev_err(&pdev->dev, "No IO memory resource\n");
-                ret = -ENODEV;
-                goto exit_free_master;
-        }
-        tsd->base = devm_request_and_ioremap(&pdev->dev, r);
-        if (!tsd->base) {
-                dev_err(&pdev->dev,
-                        "Cannot request memregion/iomap dma address\n");
-                ret = -EADDRNOTAVAIL;
-                goto exit_free_master;
-        }
-
-        tsd->irq = platform_get_irq(pdev, 0);
-        ret = request_irq(tsd->irq, tegra_sflash_isr, 0,
-                        dev_name(&pdev->dev), tsd);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to register ISR for IRQ %d\n",
-                                        tsd->irq);
-                goto exit_free_master;
-        }
-
-        tsd->clk = devm_clk_get(&pdev->dev, "spi");
-        if (IS_ERR(tsd->clk)) {
-                dev_err(&pdev->dev, "can not get clock\n");
-                ret = PTR_ERR(tsd->clk);
-                goto exit_free_irq;
-        }
-
-        tsd->spi_max_frequency = pdata->spi_max_frequency;
-        init_completion(&tsd->xfer_completion);
-        pm_runtime_enable(&pdev->dev);
-        if (!pm_runtime_enabled(&pdev->dev)) {
-                ret = tegra_sflash_runtime_resume(&pdev->dev);
-                if (ret)
-                        goto exit_pm_disable;
-        }
-
-        ret = pm_runtime_get_sync(&pdev->dev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "pm runtime get failed, e = %d\n", ret);
-                goto exit_pm_disable;
-        }
-
-        /* Reset controller */
-        tegra_periph_reset_assert(tsd->clk);
-        udelay(2);
-        tegra_periph_reset_deassert(tsd->clk);
-
-        tsd->def_command_reg  = SPI_M_S | SPI_CS_SW;
-        tegra_sflash_writel(tsd, tsd->def_command_reg, SPI_COMMAND);
-        pm_runtime_put(&pdev->dev);
-
-        master->dev.of_node = pdev->dev.of_node;
-        ret = spi_register_master(master);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "can not register to master err %d\n", ret);
-                goto exit_pm_disable;
-        }
-        return ret;
-
-exit_pm_disable:
-        pm_runtime_disable(&pdev->dev);
-        if (!pm_runtime_status_suspended(&pdev->dev))
-                tegra_sflash_runtime_suspend(&pdev->dev);
-exit_free_irq:
-        free_irq(tsd->irq, tsd);
-exit_free_master:
-        spi_master_put(master);
-        return ret;
-}
-
-static int tegra_sflash_remove(struct platform_device *pdev)
-{
-        struct spi_master *master = dev_get_drvdata(&pdev->dev);
-        struct tegra_sflash_data        *tsd = spi_master_get_devdata(master);
-
-        free_irq(tsd->irq, tsd);
-        spi_unregister_master(master);
-
-        pm_runtime_disable(&pdev->dev);
-        if (!pm_runtime_status_suspended(&pdev->dev))
-                tegra_sflash_runtime_suspend(&pdev->dev);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int tegra_sflash_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-
-        return spi_master_suspend(master);
-}
-
-static int tegra_sflash_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_sflash_data *tsd = spi_master_get_devdata(master);
-        int ret;
-
-        ret = pm_runtime_get_sync(dev);
-        if (ret < 0) {
-                dev_err(dev, "pm runtime failed, e = %d\n", ret);
-                return ret;
-        }
-        tegra_sflash_writel(tsd, tsd->command_reg, SPI_COMMAND);
-        pm_runtime_put(dev);
-
-        return spi_master_resume(master);
-}
-#endif
-
-static int tegra_sflash_runtime_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_sflash_data *tsd = spi_master_get_devdata(master);
-
-        /* Flush all write which are in PPSB queue by reading back */
-        tegra_sflash_readl(tsd, SPI_COMMAND);
-
-        clk_disable_unprepare(tsd->clk);
-        return 0;
-}
-
-static int tegra_sflash_runtime_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_sflash_data *tsd = spi_master_get_devdata(master);
-        int ret;
-
-        ret = clk_prepare_enable(tsd->clk);
-        if (ret < 0) {
-                dev_err(tsd->dev, "clk_prepare failed: %d\n", ret);
-                return ret;
-        }
-        return 0;
-}
-
-static const struct dev_pm_ops slink_pm_ops = {
-        SET_RUNTIME_PM_OPS(tegra_sflash_runtime_suspend,
-                tegra_sflash_runtime_resume, NULL)
-        SET_SYSTEM_SLEEP_PM_OPS(tegra_sflash_suspend, tegra_sflash_resume)
-};
-static struct platform_driver tegra_sflash_driver = {
-        .driver = {
-                .name           = "spi-tegra-sflash",
-                .owner          = THIS_MODULE,
-                .pm             = &slink_pm_ops,
-                .of_match_table = of_match_ptr(tegra_sflash_of_match),
-        },
-        .probe =        tegra_sflash_probe,
-        .remove =       tegra_sflash_remove,
-};
-module_platform_driver(tegra_sflash_driver);
-
-MODULE_ALIAS("platform:spi-tegra-sflash");
-MODULE_DESCRIPTION("NVIDIA Tegra20 Serial Flash Controller Driver");
-MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-tegra20-slink.c b/drivers/spi/spi-tegra20-slink.c
deleted file mode 100644
index 651167f2e0a..00000000000
--- a/drivers/spi/spi-tegra20-slink.c
+++ /dev/null
@@ -1,1358 +0,0 @@
-/*
- * SPI driver for Nvidia's Tegra20/Tegra30 SLINK Controller.
- *
- * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope 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, see <http://www.gnu.org/licenses/>.
- */
-
-#include <linux/clk.h>
-#include <linux/completion.h>
-#include <linux/delay.h>
-#include <linux/dmaengine.h>
-#include <linux/dma-mapping.h>
-#include <linux/dmapool.h>
-#include <linux/err.h>
-#include <linux/init.h>
-#include <linux/interrupt.h>
-#include <linux/io.h>
-#include <linux/kernel.h>
-#include <linux/kthread.h>
-#include <linux/module.h>
-#include <linux/platform_device.h>
-#include <linux/pm_runtime.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
-#include <linux/spi/spi.h>
-#include <linux/spi/spi-tegra.h>
-#include <mach/clk.h>
-
-#define SLINK_COMMAND                   0x000
-#define SLINK_BIT_LENGTH(x)             (((x) & 0x1f) << 0)
-#define SLINK_WORD_SIZE(x)              (((x) & 0x1f) << 5)
-#define SLINK_BOTH_EN                   (1 << 10)
-#define SLINK_CS_SW                     (1 << 11)
-#define SLINK_CS_VALUE                  (1 << 12)
-#define SLINK_CS_POLARITY               (1 << 13)
-#define SLINK_IDLE_SDA_DRIVE_LOW        (0 << 16)
-#define SLINK_IDLE_SDA_DRIVE_HIGH       (1 << 16)
-#define SLINK_IDLE_SDA_PULL_LOW         (2 << 16)
-#define SLINK_IDLE_SDA_PULL_HIGH        (3 << 16)
-#define SLINK_IDLE_SDA_MASK             (3 << 16)
-#define SLINK_CS_POLARITY1              (1 << 20)
-#define SLINK_CK_SDA                    (1 << 21)
-#define SLINK_CS_POLARITY2              (1 << 22)
-#define SLINK_CS_POLARITY3              (1 << 23)
-#define SLINK_IDLE_SCLK_DRIVE_LOW       (0 << 24)
-#define SLINK_IDLE_SCLK_DRIVE_HIGH      (1 << 24)
-#define SLINK_IDLE_SCLK_PULL_LOW        (2 << 24)
-#define SLINK_IDLE_SCLK_PULL_HIGH       (3 << 24)
-#define SLINK_IDLE_SCLK_MASK            (3 << 24)
-#define SLINK_M_S                       (1 << 28)
-#define SLINK_WAIT                      (1 << 29)
-#define SLINK_GO                        (1 << 30)
-#define SLINK_ENB                       (1 << 31)
-
-#define SLINK_MODES                     (SLINK_IDLE_SCLK_MASK | SLINK_CK_SDA)
-
-#define SLINK_COMMAND2                  0x004
-#define SLINK_LSBFE                     (1 << 0)
-#define SLINK_SSOE                      (1 << 1)
-#define SLINK_SPIE                      (1 << 4)
-#define SLINK_BIDIROE                   (1 << 6)
-#define SLINK_MODFEN                    (1 << 7)
-#define SLINK_INT_SIZE(x)               (((x) & 0x1f) << 8)
-#define SLINK_CS_ACTIVE_BETWEEN         (1 << 17)
-#define SLINK_SS_EN_CS(x)               (((x) & 0x3) << 18)
-#define SLINK_SS_SETUP(x)               (((x) & 0x3) << 20)
-#define SLINK_FIFO_REFILLS_0            (0 << 22)
-#define SLINK_FIFO_REFILLS_1            (1 << 22)
-#define SLINK_FIFO_REFILLS_2            (2 << 22)
-#define SLINK_FIFO_REFILLS_3            (3 << 22)
-#define SLINK_FIFO_REFILLS_MASK         (3 << 22)
-#define SLINK_WAIT_PACK_INT(x)          (((x) & 0x7) << 26)
-#define SLINK_SPC0                      (1 << 29)
-#define SLINK_TXEN                      (1 << 30)
-#define SLINK_RXEN                      (1 << 31)
-
-#define SLINK_STATUS                    0x008
-#define SLINK_COUNT(val)                (((val) >> 0) & 0x1f)
-#define SLINK_WORD(val)                 (((val) >> 5) & 0x1f)
-#define SLINK_BLK_CNT(val)              (((val) >> 0) & 0xffff)
-#define SLINK_MODF                      (1 << 16)
-#define SLINK_RX_UNF                    (1 << 18)
-#define SLINK_TX_OVF                    (1 << 19)
-#define SLINK_TX_FULL                   (1 << 20)
-#define SLINK_TX_EMPTY                  (1 << 21)
-#define SLINK_RX_FULL                   (1 << 22)
-#define SLINK_RX_EMPTY                  (1 << 23)
-#define SLINK_TX_UNF                    (1 << 24)
-#define SLINK_RX_OVF                    (1 << 25)
-#define SLINK_TX_FLUSH                  (1 << 26)
-#define SLINK_RX_FLUSH                  (1 << 27)
-#define SLINK_SCLK                      (1 << 28)
-#define SLINK_ERR                       (1 << 29)
-#define SLINK_RDY                       (1 << 30)
-#define SLINK_BSY                       (1 << 31)
-#define SLINK_FIFO_ERROR                (SLINK_TX_OVF | SLINK_RX_UNF |  \
-                                        SLINK_TX_UNF | SLINK_RX_OVF)
-
-#define SLINK_FIFO_EMPTY                (SLINK_TX_EMPTY | SLINK_RX_EMPTY)
-
-#define SLINK_MAS_DATA                  0x010
-#define SLINK_SLAVE_DATA                0x014
-
-#define SLINK_DMA_CTL                   0x018
-#define SLINK_DMA_BLOCK_SIZE(x)         (((x) & 0xffff) << 0)
-#define SLINK_TX_TRIG_1                 (0 << 16)
-#define SLINK_TX_TRIG_4                 (1 << 16)
-#define SLINK_TX_TRIG_8                 (2 << 16)
-#define SLINK_TX_TRIG_16                (3 << 16)
-#define SLINK_TX_TRIG_MASK              (3 << 16)
-#define SLINK_RX_TRIG_1                 (0 << 18)
-#define SLINK_RX_TRIG_4                 (1 << 18)
-#define SLINK_RX_TRIG_8                 (2 << 18)
-#define SLINK_RX_TRIG_16                (3 << 18)
-#define SLINK_RX_TRIG_MASK              (3 << 18)
-#define SLINK_PACKED                    (1 << 20)
-#define SLINK_PACK_SIZE_4               (0 << 21)
-#define SLINK_PACK_SIZE_8               (1 << 21)
-#define SLINK_PACK_SIZE_16              (2 << 21)
-#define SLINK_PACK_SIZE_32              (3 << 21)
-#define SLINK_PACK_SIZE_MASK            (3 << 21)
-#define SLINK_IE_TXC                    (1 << 26)
-#define SLINK_IE_RXC                    (1 << 27)
-#define SLINK_DMA_EN                    (1 << 31)
-
-#define SLINK_STATUS2                   0x01c
-#define SLINK_TX_FIFO_EMPTY_COUNT(val)  (((val) & 0x3f) >> 0)
-#define SLINK_RX_FIFO_FULL_COUNT(val)   (((val) & 0x3f0000) >> 16)
-#define SLINK_SS_HOLD_TIME(val)         (((val) & 0xF) << 6)
-
-#define SLINK_TX_FIFO                   0x100
-#define SLINK_RX_FIFO                   0x180
-
-#define DATA_DIR_TX                     (1 << 0)
-#define DATA_DIR_RX                     (1 << 1)
-
-#define SLINK_DMA_TIMEOUT               (msecs_to_jiffies(1000))
-
-#define DEFAULT_SPI_DMA_BUF_LEN         (16*1024)
-#define TX_FIFO_EMPTY_COUNT_MAX         SLINK_TX_FIFO_EMPTY_COUNT(0x20)
-#define RX_FIFO_FULL_COUNT_ZERO         SLINK_RX_FIFO_FULL_COUNT(0)
-
-#define SLINK_STATUS2_RESET \
-        (TX_FIFO_EMPTY_COUNT_MAX | RX_FIFO_FULL_COUNT_ZERO << 16)
-
-#define MAX_CHIP_SELECT                 4
-#define SLINK_FIFO_DEPTH                32
-
-struct tegra_slink_chip_data {
-        bool cs_hold_time;
-};
-
-struct tegra_slink_data {
-        struct device                           *dev;
-        struct spi_master                       *master;
-        const struct tegra_slink_chip_data      *chip_data;
-        spinlock_t                              lock;
-
-        struct clk                              *clk;
-        void __iomem                            *base;
-        phys_addr_t                             phys;
-        unsigned                                irq;
-        int                                     dma_req_sel;
-        u32                                     spi_max_frequency;
-        u32                                     cur_speed;
-
-        struct spi_device                       *cur_spi;
-        unsigned                                cur_pos;
-        unsigned                                cur_len;
-        unsigned                                words_per_32bit;
-        unsigned                                bytes_per_word;
-        unsigned                                curr_dma_words;
-        unsigned                                cur_direction;
-
-        unsigned                                cur_rx_pos;
-        unsigned                                cur_tx_pos;
-
-        unsigned                                dma_buf_size;
-        unsigned                                max_buf_size;
-        bool                                    is_curr_dma_xfer;
-        bool                                    is_hw_based_cs;
-
-        struct completion                       rx_dma_complete;
-        struct completion                       tx_dma_complete;
-
-        u32                                     tx_status;
-        u32                                     rx_status;
-        u32                                     status_reg;
-        bool                                    is_packed;
-        unsigned long                           packed_size;
-
-        u32                                     command_reg;
-        u32                                     command2_reg;
-        u32                                     dma_control_reg;
-        u32                                     def_command_reg;
-        u32                                     def_command2_reg;
-
-        struct completion                       xfer_completion;
-        struct spi_transfer                     *curr_xfer;
-        struct dma_chan                         *rx_dma_chan;
-        u32                                     *rx_dma_buf;
-        dma_addr_t                              rx_dma_phys;
-        struct dma_async_tx_descriptor          *rx_dma_desc;
-
-        struct dma_chan                         *tx_dma_chan;
-        u32                                     *tx_dma_buf;
-        dma_addr_t                              tx_dma_phys;
-        struct dma_async_tx_descriptor          *tx_dma_desc;
-};
-
-static int tegra_slink_runtime_suspend(struct device *dev);
-static int tegra_slink_runtime_resume(struct device *dev);
-
-static inline unsigned long tegra_slink_readl(struct tegra_slink_data *tspi,
-                unsigned long reg)
-{
-        return readl(tspi->base + reg);
-}
-
-static inline void tegra_slink_writel(struct tegra_slink_data *tspi,
-                unsigned long val, unsigned long reg)
-{
-        writel(val, tspi->base + reg);
-
-        /* Read back register to make sure that register writes completed */
-        if (reg != SLINK_TX_FIFO)
-                readl(tspi->base + SLINK_MAS_DATA);
-}
-
-static void tegra_slink_clear_status(struct tegra_slink_data *tspi)
-{
-        unsigned long val;
-        unsigned long val_write = 0;
-
-        val = tegra_slink_readl(tspi, SLINK_STATUS);
-
-        /* Write 1 to clear status register */
-        val_write = SLINK_RDY | SLINK_FIFO_ERROR;
-        tegra_slink_writel(tspi, val_write, SLINK_STATUS);
-}
-
-static unsigned long tegra_slink_get_packed_size(struct tegra_slink_data *tspi,
-                                  struct spi_transfer *t)
-{
-        unsigned long val;
-
-        switch (tspi->bytes_per_word) {
-        case 0:
-                val = SLINK_PACK_SIZE_4;
-                break;
-        case 1:
-                val = SLINK_PACK_SIZE_8;
-                break;
-        case 2:
-                val = SLINK_PACK_SIZE_16;
-                break;
-        case 4:
-                val = SLINK_PACK_SIZE_32;
-                break;
-        default:
-                val = 0;
-        }
-        return val;
-}
-
-static unsigned tegra_slink_calculate_curr_xfer_param(
-        struct spi_device *spi, struct tegra_slink_data *tspi,
-        struct spi_transfer *t)
-{
-        unsigned remain_len = t->len - tspi->cur_pos;
-        unsigned max_word;
-        unsigned bits_per_word ;
-        unsigned max_len;
-        unsigned total_fifo_words;
-
-        bits_per_word = t->bits_per_word ? t->bits_per_word :
-                                                spi->bits_per_word;
-        tspi->bytes_per_word = (bits_per_word - 1) / 8 + 1;
-
-        if (bits_per_word == 8 || bits_per_word == 16) {
-                tspi->is_packed = 1;
-                tspi->words_per_32bit = 32/bits_per_word;
-        } else {
-                tspi->is_packed = 0;
-                tspi->words_per_32bit = 1;
-        }
-        tspi->packed_size = tegra_slink_get_packed_size(tspi, t);
-
-        if (tspi->is_packed) {
-                max_len = min(remain_len, tspi->max_buf_size);
-                tspi->curr_dma_words = max_len/tspi->bytes_per_word;
-                total_fifo_words = max_len/4;
-        } else {
-                max_word = (remain_len - 1) / tspi->bytes_per_word + 1;
-                max_word = min(max_word, tspi->max_buf_size/4);
-                tspi->curr_dma_words = max_word;
-                total_fifo_words = max_word;
-        }
-        return total_fifo_words;
-}
-
-static unsigned tegra_slink_fill_tx_fifo_from_client_txbuf(
-        struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned nbytes;
-        unsigned tx_empty_count;
-        unsigned long fifo_status;
-        unsigned max_n_32bit;
-        unsigned i, count;
-        unsigned long x;
-        unsigned int written_words;
-        unsigned fifo_words_left;
-        u8 *tx_buf = (u8 *)t->tx_buf + tspi->cur_tx_pos;
-
-        fifo_status = tegra_slink_readl(tspi, SLINK_STATUS2);
-        tx_empty_count = SLINK_TX_FIFO_EMPTY_COUNT(fifo_status);
-
-        if (tspi->is_packed) {
-                fifo_words_left = tx_empty_count * tspi->words_per_32bit;
-                written_words = min(fifo_words_left, tspi->curr_dma_words);
-                nbytes = written_words * tspi->bytes_per_word;
-                max_n_32bit = DIV_ROUND_UP(nbytes, 4);
-                for (count = 0; count < max_n_32bit; count++) {
-                        x = 0;
-                        for (i = 0; (i < 4) && nbytes; i++, nbytes--)
-                                x |= (*tx_buf++) << (i*8);
-                        tegra_slink_writel(tspi, x, SLINK_TX_FIFO);
-                }
-        } else {
-                max_n_32bit = min(tspi->curr_dma_words,  tx_empty_count);
-                written_words = max_n_32bit;
-                nbytes = written_words * tspi->bytes_per_word;
-                for (count = 0; count < max_n_32bit; count++) {
-                        x = 0;
-                        for (i = 0; nbytes && (i < tspi->bytes_per_word);
-                                                        i++, nbytes--)
-                                x |= ((*tx_buf++) << i*8);
-                        tegra_slink_writel(tspi, x, SLINK_TX_FIFO);
-                }
-        }
-        tspi->cur_tx_pos += written_words * tspi->bytes_per_word;
-        return written_words;
-}
-
-static unsigned int tegra_slink_read_rx_fifo_to_client_rxbuf(
-                struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned rx_full_count;
-        unsigned long fifo_status;
-        unsigned i, count;
-        unsigned long x;
-        unsigned int read_words = 0;
-        unsigned len;
-        u8 *rx_buf = (u8 *)t->rx_buf + tspi->cur_rx_pos;
-
-        fifo_status = tegra_slink_readl(tspi, SLINK_STATUS2);
-        rx_full_count = SLINK_RX_FIFO_FULL_COUNT(fifo_status);
-        if (tspi->is_packed) {
-                len = tspi->curr_dma_words * tspi->bytes_per_word;
-                for (count = 0; count < rx_full_count; count++) {
-                        x = tegra_slink_readl(tspi, SLINK_RX_FIFO);
-                        for (i = 0; len && (i < 4); i++, len--)
-                                *rx_buf++ = (x >> i*8) & 0xFF;
-                }
-                tspi->cur_rx_pos += tspi->curr_dma_words * tspi->bytes_per_word;
-                read_words += tspi->curr_dma_words;
-        } else {
-                unsigned int bits_per_word;
-
-                bits_per_word = t->bits_per_word ? t->bits_per_word :
-                                                tspi->cur_spi->bits_per_word;
-                for (count = 0; count < rx_full_count; count++) {
-                        x = tegra_slink_readl(tspi, SLINK_RX_FIFO);
-                        for (i = 0; (i < tspi->bytes_per_word); i++)
-                                *rx_buf++ = (x >> (i*8)) & 0xFF;
-                }
-                tspi->cur_rx_pos += rx_full_count * tspi->bytes_per_word;
-                read_words += rx_full_count;
-        }
-        return read_words;
-}
-
-static void tegra_slink_copy_client_txbuf_to_spi_txbuf(
-                struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned len;
-
-        /* Make the dma buffer to read by cpu */
-        dma_sync_single_for_cpu(tspi->dev, tspi->tx_dma_phys,
-                                tspi->dma_buf_size, DMA_TO_DEVICE);
-
-        if (tspi->is_packed) {
-                len = tspi->curr_dma_words * tspi->bytes_per_word;
-                memcpy(tspi->tx_dma_buf, t->tx_buf + tspi->cur_pos, len);
-        } else {
-                unsigned int i;
-                unsigned int count;
-                u8 *tx_buf = (u8 *)t->tx_buf + tspi->cur_tx_pos;
-                unsigned consume = tspi->curr_dma_words * tspi->bytes_per_word;
-                unsigned int x;
-
-                for (count = 0; count < tspi->curr_dma_words; count++) {
-                        x = 0;
-                        for (i = 0; consume && (i < tspi->bytes_per_word);
-                                                        i++, consume--)
-                                x |= ((*tx_buf++) << i * 8);
-                        tspi->tx_dma_buf[count] = x;
-                }
-        }
-        tspi->cur_tx_pos += tspi->curr_dma_words * tspi->bytes_per_word;
-
-        /* Make the dma buffer to read by dma */
-        dma_sync_single_for_device(tspi->dev, tspi->tx_dma_phys,
-                                tspi->dma_buf_size, DMA_TO_DEVICE);
-}
-
-static void tegra_slink_copy_spi_rxbuf_to_client_rxbuf(
-                struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned len;
-
-        /* Make the dma buffer to read by cpu */
-        dma_sync_single_for_cpu(tspi->dev, tspi->rx_dma_phys,
-                tspi->dma_buf_size, DMA_FROM_DEVICE);
-
-        if (tspi->is_packed) {
-                len = tspi->curr_dma_words * tspi->bytes_per_word;
-                memcpy(t->rx_buf + tspi->cur_rx_pos, tspi->rx_dma_buf, len);
-        } else {
-                unsigned int i;
-                unsigned int count;
-                unsigned char *rx_buf = t->rx_buf + tspi->cur_rx_pos;
-                unsigned int x;
-                unsigned int rx_mask, bits_per_word;
-
-                bits_per_word = t->bits_per_word ? t->bits_per_word :
-                                                tspi->cur_spi->bits_per_word;
-                rx_mask = (1 << bits_per_word) - 1;
-                for (count = 0; count < tspi->curr_dma_words; count++) {
-                        x = tspi->rx_dma_buf[count];
-                        x &= rx_mask;
-                        for (i = 0; (i < tspi->bytes_per_word); i++)
-                                *rx_buf++ = (x >> (i*8)) & 0xFF;
-                }
-        }
-        tspi->cur_rx_pos += tspi->curr_dma_words * tspi->bytes_per_word;
-
-        /* Make the dma buffer to read by dma */
-        dma_sync_single_for_device(tspi->dev, tspi->rx_dma_phys,
-                tspi->dma_buf_size, DMA_FROM_DEVICE);
-}
-
-static void tegra_slink_dma_complete(void *args)
-{
-        struct completion *dma_complete = args;
-
-        complete(dma_complete);
-}
-
-static int tegra_slink_start_tx_dma(struct tegra_slink_data *tspi, int len)
-{
-        INIT_COMPLETION(tspi->tx_dma_complete);
-        tspi->tx_dma_desc = dmaengine_prep_slave_single(tspi->tx_dma_chan,
-                                tspi->tx_dma_phys, len, DMA_MEM_TO_DEV,
-                                DMA_PREP_INTERRUPT |  DMA_CTRL_ACK);
-        if (!tspi->tx_dma_desc) {
-                dev_err(tspi->dev, "Not able to get desc for Tx\n");
-                return -EIO;
-        }
-
-        tspi->tx_dma_desc->callback = tegra_slink_dma_complete;
-        tspi->tx_dma_desc->callback_param = &tspi->tx_dma_complete;
-
-        dmaengine_submit(tspi->tx_dma_desc);
-        dma_async_issue_pending(tspi->tx_dma_chan);
-        return 0;
-}
-
-static int tegra_slink_start_rx_dma(struct tegra_slink_data *tspi, int len)
-{
-        INIT_COMPLETION(tspi->rx_dma_complete);
-        tspi->rx_dma_desc = dmaengine_prep_slave_single(tspi->rx_dma_chan,
-                                tspi->rx_dma_phys, len, DMA_DEV_TO_MEM,
-                                DMA_PREP_INTERRUPT |  DMA_CTRL_ACK);
-        if (!tspi->rx_dma_desc) {
-                dev_err(tspi->dev, "Not able to get desc for Rx\n");
-                return -EIO;
-        }
-
-        tspi->rx_dma_desc->callback = tegra_slink_dma_complete;
-        tspi->rx_dma_desc->callback_param = &tspi->rx_dma_complete;
-
-        dmaengine_submit(tspi->rx_dma_desc);
-        dma_async_issue_pending(tspi->rx_dma_chan);
-        return 0;
-}
-
-static int tegra_slink_start_dma_based_transfer(
-                struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned long val;
-        unsigned long test_val;
-        unsigned int len;
-        int ret = 0;
-        unsigned long status;
-
-        /* Make sure that Rx and Tx fifo are empty */
-        status = tegra_slink_readl(tspi, SLINK_STATUS);
-        if ((status & SLINK_FIFO_EMPTY) != SLINK_FIFO_EMPTY) {
-                dev_err(tspi->dev,
-                        "Rx/Tx fifo are not empty status 0x%08lx\n", status);
-                return -EIO;
-        }
-
-        val = SLINK_DMA_BLOCK_SIZE(tspi->curr_dma_words - 1);
-        val |= tspi->packed_size;
-        if (tspi->is_packed)
-                len = DIV_ROUND_UP(tspi->curr_dma_words * tspi->bytes_per_word,
-                                        4) * 4;
-        else
-                len = tspi->curr_dma_words * 4;
-
-        /* Set attention level based on length of transfer */
-        if (len & 0xF)
-                val |= SLINK_TX_TRIG_1 | SLINK_RX_TRIG_1;
-        else if (((len) >> 4) & 0x1)
-                val |= SLINK_TX_TRIG_4 | SLINK_RX_TRIG_4;
-        else
-                val |= SLINK_TX_TRIG_8 | SLINK_RX_TRIG_8;
-
-        if (tspi->cur_direction & DATA_DIR_TX)
-                val |= SLINK_IE_TXC;
-
-        if (tspi->cur_direction & DATA_DIR_RX)
-                val |= SLINK_IE_RXC;
-
-        tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-        tspi->dma_control_reg = val;
-
-        if (tspi->cur_direction & DATA_DIR_TX) {
-                tegra_slink_copy_client_txbuf_to_spi_txbuf(tspi, t);
-                wmb();
-                ret = tegra_slink_start_tx_dma(tspi, len);
-                if (ret < 0) {
-                        dev_err(tspi->dev,
-                                "Starting tx dma failed, err %d\n", ret);
-                        return ret;
-                }
-
-                /* Wait for tx fifo to be fill before starting slink */
-                test_val = tegra_slink_readl(tspi, SLINK_STATUS);
-                while (!(test_val & SLINK_TX_FULL))
-                        test_val = tegra_slink_readl(tspi, SLINK_STATUS);
-        }
-
-        if (tspi->cur_direction & DATA_DIR_RX) {
-                /* Make the dma buffer to read by dma */
-                dma_sync_single_for_device(tspi->dev, tspi->rx_dma_phys,
-                                tspi->dma_buf_size, DMA_FROM_DEVICE);
-
-                ret = tegra_slink_start_rx_dma(tspi, len);
-                if (ret < 0) {
-                        dev_err(tspi->dev,
-                                "Starting rx dma failed, err %d\n", ret);
-                        if (tspi->cur_direction & DATA_DIR_TX)
-                                dmaengine_terminate_all(tspi->tx_dma_chan);
-                        return ret;
-                }
-        }
-        tspi->is_curr_dma_xfer = true;
-        if (tspi->is_packed) {
-                val |= SLINK_PACKED;
-                tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-                /* HW need small delay after settign Packed mode */
-                udelay(1);
-        }
-        tspi->dma_control_reg = val;
-
-        val |= SLINK_DMA_EN;
-        tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-        return ret;
-}
-
-static int tegra_slink_start_cpu_based_transfer(
-                struct tegra_slink_data *tspi, struct spi_transfer *t)
-{
-        unsigned long val;
-        unsigned cur_words;
-
-        val = tspi->packed_size;
-        if (tspi->cur_direction & DATA_DIR_TX)
-                val |= SLINK_IE_TXC;
-
-        if (tspi->cur_direction & DATA_DIR_RX)
-                val |= SLINK_IE_RXC;
-
-        tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-        tspi->dma_control_reg = val;
-
-        if (tspi->cur_direction & DATA_DIR_TX)
-                cur_words = tegra_slink_fill_tx_fifo_from_client_txbuf(tspi, t);
-        else
-                cur_words = tspi->curr_dma_words;
-        val |= SLINK_DMA_BLOCK_SIZE(cur_words - 1);
-        tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-        tspi->dma_control_reg = val;
-
-        tspi->is_curr_dma_xfer = false;
-        if (tspi->is_packed) {
-                val |= SLINK_PACKED;
-                tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-                udelay(1);
-                wmb();
-        }
-        tspi->dma_control_reg = val;
-        val |= SLINK_DMA_EN;
-        tegra_slink_writel(tspi, val, SLINK_DMA_CTL);
-        return 0;
-}
-
-static int tegra_slink_init_dma_param(struct tegra_slink_data *tspi,
-                        bool dma_to_memory)
-{
-        struct dma_chan *dma_chan;
-        u32 *dma_buf;
-        dma_addr_t dma_phys;
-        int ret;
-        struct dma_slave_config dma_sconfig;
-        dma_cap_mask_t mask;
-
-        dma_cap_zero(mask);
-        dma_cap_set(DMA_SLAVE, mask);
-        dma_chan = dma_request_channel(mask, NULL, NULL);
-        if (!dma_chan) {
-                dev_err(tspi->dev,
-                        "Dma channel is not available, will try later\n");
-                return -EPROBE_DEFER;
-        }
-
-        dma_buf = dma_alloc_coherent(tspi->dev, tspi->dma_buf_size,
-                                &dma_phys, GFP_KERNEL);
-        if (!dma_buf) {
-                dev_err(tspi->dev, " Not able to allocate the dma buffer\n");
-                dma_release_channel(dma_chan);
-                return -ENOMEM;
-        }
-
-        dma_sconfig.slave_id = tspi->dma_req_sel;
-        if (dma_to_memory) {
-                dma_sconfig.src_addr = tspi->phys + SLINK_RX_FIFO;
-                dma_sconfig.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-                dma_sconfig.src_maxburst = 0;
-        } else {
-                dma_sconfig.dst_addr = tspi->phys + SLINK_TX_FIFO;
-                dma_sconfig.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
-                dma_sconfig.dst_maxburst = 0;
-        }
-
-        ret = dmaengine_slave_config(dma_chan, &dma_sconfig);
-        if (ret)
-                goto scrub;
-        if (dma_to_memory) {
-                tspi->rx_dma_chan = dma_chan;
-                tspi->rx_dma_buf = dma_buf;
-                tspi->rx_dma_phys = dma_phys;
-        } else {
-                tspi->tx_dma_chan = dma_chan;
-                tspi->tx_dma_buf = dma_buf;
-                tspi->tx_dma_phys = dma_phys;
-        }
-        return 0;
-
-scrub:
-        dma_free_coherent(tspi->dev, tspi->dma_buf_size, dma_buf, dma_phys);
-        dma_release_channel(dma_chan);
-        return ret;
-}
-
-static void tegra_slink_deinit_dma_param(struct tegra_slink_data *tspi,
-        bool dma_to_memory)
-{
-        u32 *dma_buf;
-        dma_addr_t dma_phys;
-        struct dma_chan *dma_chan;
-
-        if (dma_to_memory) {
-                dma_buf = tspi->rx_dma_buf;
-                dma_chan = tspi->rx_dma_chan;
-                dma_phys = tspi->rx_dma_phys;
-                tspi->rx_dma_chan = NULL;
-                tspi->rx_dma_buf = NULL;
-        } else {
-                dma_buf = tspi->tx_dma_buf;
-                dma_chan = tspi->tx_dma_chan;
-                dma_phys = tspi->tx_dma_phys;
-                tspi->tx_dma_buf = NULL;
-                tspi->tx_dma_chan = NULL;
-        }
-        if (!dma_chan)
-                return;
-
-        dma_free_coherent(tspi->dev, tspi->dma_buf_size, dma_buf, dma_phys);
-        dma_release_channel(dma_chan);
-}
-
-static int tegra_slink_start_transfer_one(struct spi_device *spi,
-                struct spi_transfer *t, bool is_first_of_msg,
-                bool is_single_xfer)
-{
-        struct tegra_slink_data *tspi = spi_master_get_devdata(spi->master);
-        u32 speed;
-        u8 bits_per_word;
-        unsigned total_fifo_words;
-        int ret;
-        struct tegra_spi_device_controller_data *cdata = spi->controller_data;
-        unsigned long command;
-        unsigned long command2;
-
-        bits_per_word = t->bits_per_word;
-        speed = t->speed_hz ? t->speed_hz : spi->max_speed_hz;
-        if (!speed)
-                speed = tspi->spi_max_frequency;
-        if (speed != tspi->cur_speed) {
-                clk_set_rate(tspi->clk, speed * 4);
-                tspi->cur_speed = speed;
-        }
-
-        tspi->cur_spi = spi;
-        tspi->cur_pos = 0;
-        tspi->cur_rx_pos = 0;
-        tspi->cur_tx_pos = 0;
-        tspi->curr_xfer = t;
-        total_fifo_words = tegra_slink_calculate_curr_xfer_param(spi, tspi, t);
-
-        if (is_first_of_msg) {
-                tegra_slink_clear_status(tspi);
-
-                command = tspi->def_command_reg;
-                command |= SLINK_BIT_LENGTH(bits_per_word - 1);
-
-                command2 = tspi->def_command2_reg;
-                command2 |= SLINK_SS_EN_CS(spi->chip_select);
-
-                /* possibly use the hw based chip select */
-                tspi->is_hw_based_cs = false;
-                if (cdata && cdata->is_hw_based_cs && is_single_xfer &&
-                        ((tspi->curr_dma_words * tspi->bytes_per_word) ==
-                                                (t->len - tspi->cur_pos))) {
-                        int setup_count;
-                        int sts2;
-
-                        setup_count = cdata->cs_setup_clk_count >> 1;
-                        setup_count = max(setup_count, 3);
-                        command2 |= SLINK_SS_SETUP(setup_count);
-                        if (tspi->chip_data->cs_hold_time) {
-                                int hold_count;
-
-                                hold_count = cdata->cs_hold_clk_count;
-                                hold_count = max(hold_count, 0xF);
-                                sts2 = tegra_slink_readl(tspi, SLINK_STATUS2);
-                                sts2 &= ~SLINK_SS_HOLD_TIME(0xF);
-                                sts2 |= SLINK_SS_HOLD_TIME(hold_count);
-                                tegra_slink_writel(tspi, sts2, SLINK_STATUS2);
-                        }
-                        tspi->is_hw_based_cs = true;
-                }
-
-                if (tspi->is_hw_based_cs)
-                        command &= ~SLINK_CS_SW;
-                else
-                        command |= SLINK_CS_SW | SLINK_CS_VALUE;
-
-                command &= ~SLINK_MODES;
-                if (spi->mode & SPI_CPHA)
-                        command |= SLINK_CK_SDA;
-
-                if (spi->mode & SPI_CPOL)
-                        command |= SLINK_IDLE_SCLK_DRIVE_HIGH;
-                else
-                        command |= SLINK_IDLE_SCLK_DRIVE_LOW;
-        } else {
-                command = tspi->command_reg;
-                command &= ~SLINK_BIT_LENGTH(~0);
-                command |= SLINK_BIT_LENGTH(bits_per_word - 1);
-
-                command2 = tspi->command2_reg;
-                command2 &= ~(SLINK_RXEN | SLINK_TXEN);
-        }
-
-        tegra_slink_writel(tspi, command, SLINK_COMMAND);
-        tspi->command_reg = command;
-
-        tspi->cur_direction = 0;
-        if (t->rx_buf) {
-                command2 |= SLINK_RXEN;
-                tspi->cur_direction |= DATA_DIR_RX;
-        }
-        if (t->tx_buf) {
-                command2 |= SLINK_TXEN;
-                tspi->cur_direction |= DATA_DIR_TX;
-        }
-        tegra_slink_writel(tspi, command2, SLINK_COMMAND2);
-        tspi->command2_reg = command2;
-
-        if (total_fifo_words > SLINK_FIFO_DEPTH)
-                ret = tegra_slink_start_dma_based_transfer(tspi, t);
-        else
-                ret = tegra_slink_start_cpu_based_transfer(tspi, t);
-        return ret;
-}
-
-static int tegra_slink_setup(struct spi_device *spi)
-{
-        struct tegra_slink_data *tspi = spi_master_get_devdata(spi->master);
-        unsigned long val;
-        unsigned long flags;
-        int ret;
-        unsigned int cs_pol_bit[MAX_CHIP_SELECT] = {
-                        SLINK_CS_POLARITY,
-                        SLINK_CS_POLARITY1,
-                        SLINK_CS_POLARITY2,
-                        SLINK_CS_POLARITY3,
-        };
-
-        dev_dbg(&spi->dev, "setup %d bpw, %scpol, %scpha, %dHz\n",
-                spi->bits_per_word,
-                spi->mode & SPI_CPOL ? "" : "~",
-                spi->mode & SPI_CPHA ? "" : "~",
-                spi->max_speed_hz);
-
-        BUG_ON(spi->chip_select >= MAX_CHIP_SELECT);
-
-        ret = pm_runtime_get_sync(tspi->dev);
-        if (ret < 0) {
-                dev_err(tspi->dev, "pm runtime failed, e = %d\n", ret);
-                return ret;
-        }
-
-        spin_lock_irqsave(&tspi->lock, flags);
-        val = tspi->def_command_reg;
-        if (spi->mode & SPI_CS_HIGH)
-                val |= cs_pol_bit[spi->chip_select];
-        else
-                val &= ~cs_pol_bit[spi->chip_select];
-        tspi->def_command_reg = val;
-        tegra_slink_writel(tspi, tspi->def_command_reg, SLINK_COMMAND);
-        spin_unlock_irqrestore(&tspi->lock, flags);
-
-        pm_runtime_put(tspi->dev);
-        return 0;
-}
-
-static int tegra_slink_prepare_transfer(struct spi_master *master)
-{
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-
-        return pm_runtime_get_sync(tspi->dev);
-}
-
-static int tegra_slink_unprepare_transfer(struct spi_master *master)
-{
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-
-        pm_runtime_put(tspi->dev);
-        return 0;
-}
-
-static int tegra_slink_transfer_one_message(struct spi_master *master,
-                        struct spi_message *msg)
-{
-        bool is_first_msg = true;
-        int single_xfer;
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-        struct spi_transfer *xfer;
-        struct spi_device *spi = msg->spi;
-        int ret;
-
-        msg->status = 0;
-        msg->actual_length = 0;
-        single_xfer = list_is_singular(&msg->transfers);
-        list_for_each_entry(xfer, &msg->transfers, transfer_list) {
-                INIT_COMPLETION(tspi->xfer_completion);
-                ret = tegra_slink_start_transfer_one(spi, xfer,
-                                        is_first_msg, single_xfer);
-                if (ret < 0) {
-                        dev_err(tspi->dev,
-                                "spi can not start transfer, err %d\n", ret);
-                        goto exit;
-                }
-                is_first_msg = false;
-                ret = wait_for_completion_timeout(&tspi->xfer_completion,
-                                                SLINK_DMA_TIMEOUT);
-                if (WARN_ON(ret == 0)) {
-                        dev_err(tspi->dev,
-                                "spi trasfer timeout, err %d\n", ret);
-                        ret = -EIO;
-                        goto exit;
-                }
-
-                if (tspi->tx_status ||  tspi->rx_status) {
-                        dev_err(tspi->dev, "Error in Transfer\n");
-                        ret = -EIO;
-                        goto exit;
-                }
-                msg->actual_length += xfer->len;
-                if (xfer->cs_change && xfer->delay_usecs) {
-                        tegra_slink_writel(tspi, tspi->def_command_reg,
-                                        SLINK_COMMAND);
-                        udelay(xfer->delay_usecs);
-                }
-        }
-        ret = 0;
-exit:
-        tegra_slink_writel(tspi, tspi->def_command_reg, SLINK_COMMAND);
-        tegra_slink_writel(tspi, tspi->def_command2_reg, SLINK_COMMAND2);
-        msg->status = ret;
-        spi_finalize_current_message(master);
-        return ret;
-}
-
-static irqreturn_t handle_cpu_based_xfer(struct tegra_slink_data *tspi)
-{
-        struct spi_transfer *t = tspi->curr_xfer;
-        unsigned long flags;
-
-        spin_lock_irqsave(&tspi->lock, flags);
-        if (tspi->tx_status ||  tspi->rx_status ||
-                                (tspi->status_reg & SLINK_BSY)) {
-                dev_err(tspi->dev,
-                        "CpuXfer ERROR bit set 0x%x\n", tspi->status_reg);
-                dev_err(tspi->dev,
-                        "CpuXfer 0x%08x:0x%08x:0x%08x\n", tspi->command_reg,
-                                tspi->command2_reg, tspi->dma_control_reg);
-                tegra_periph_reset_assert(tspi->clk);
-                udelay(2);
-                tegra_periph_reset_deassert(tspi->clk);
-                complete(&tspi->xfer_completion);
-                goto exit;
-        }
-
-        if (tspi->cur_direction & DATA_DIR_RX)
-                tegra_slink_read_rx_fifo_to_client_rxbuf(tspi, t);
-
-        if (tspi->cur_direction & DATA_DIR_TX)
-                tspi->cur_pos = tspi->cur_tx_pos;
-        else
-                tspi->cur_pos = tspi->cur_rx_pos;
-
-        if (tspi->cur_pos == t->len) {
-                complete(&tspi->xfer_completion);
-                goto exit;
-        }
-
-        tegra_slink_calculate_curr_xfer_param(tspi->cur_spi, tspi, t);
-        tegra_slink_start_cpu_based_transfer(tspi, t);
-exit:
-        spin_unlock_irqrestore(&tspi->lock, flags);
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t handle_dma_based_xfer(struct tegra_slink_data *tspi)
-{
-        struct spi_transfer *t = tspi->curr_xfer;
-        long wait_status;
-        int err = 0;
-        unsigned total_fifo_words;
-        unsigned long flags;
-
-        /* Abort dmas if any error */
-        if (tspi->cur_direction & DATA_DIR_TX) {
-                if (tspi->tx_status) {
-                        dmaengine_terminate_all(tspi->tx_dma_chan);
-                        err += 1;
-                } else {
-                        wait_status = wait_for_completion_interruptible_timeout(
-                                &tspi->tx_dma_complete, SLINK_DMA_TIMEOUT);
-                        if (wait_status <= 0) {
-                                dmaengine_terminate_all(tspi->tx_dma_chan);
-                                dev_err(tspi->dev, "TxDma Xfer failed\n");
-                                err += 1;
-                        }
-                }
-        }
-
-        if (tspi->cur_direction & DATA_DIR_RX) {
-                if (tspi->rx_status) {
-                        dmaengine_terminate_all(tspi->rx_dma_chan);
-                        err += 2;
-                } else {
-                        wait_status = wait_for_completion_interruptible_timeout(
-                                &tspi->rx_dma_complete, SLINK_DMA_TIMEOUT);
-                        if (wait_status <= 0) {
-                                dmaengine_terminate_all(tspi->rx_dma_chan);
-                                dev_err(tspi->dev, "RxDma Xfer failed\n");
-                                err += 2;
-                        }
-                }
-        }
-
-        spin_lock_irqsave(&tspi->lock, flags);
-        if (err) {
-                dev_err(tspi->dev,
-                        "DmaXfer: ERROR bit set 0x%x\n", tspi->status_reg);
-                dev_err(tspi->dev,
-                        "DmaXfer 0x%08x:0x%08x:0x%08x\n", tspi->command_reg,
-                                tspi->command2_reg, tspi->dma_control_reg);
-                tegra_periph_reset_assert(tspi->clk);
-                udelay(2);
-                tegra_periph_reset_deassert(tspi->clk);
-                complete(&tspi->xfer_completion);
-                spin_unlock_irqrestore(&tspi->lock, flags);
-                return IRQ_HANDLED;
-        }
-
-        if (tspi->cur_direction & DATA_DIR_RX)
-                tegra_slink_copy_spi_rxbuf_to_client_rxbuf(tspi, t);
-
-        if (tspi->cur_direction & DATA_DIR_TX)
-                tspi->cur_pos = tspi->cur_tx_pos;
-        else
-                tspi->cur_pos = tspi->cur_rx_pos;
-
-        if (tspi->cur_pos == t->len) {
-                complete(&tspi->xfer_completion);
-                goto exit;
-        }
-
-        /* Continue transfer in current message */
-        total_fifo_words = tegra_slink_calculate_curr_xfer_param(tspi->cur_spi,
-                                                        tspi, t);
-        if (total_fifo_words > SLINK_FIFO_DEPTH)
-                err = tegra_slink_start_dma_based_transfer(tspi, t);
-        else
-                err = tegra_slink_start_cpu_based_transfer(tspi, t);
-
-exit:
-        spin_unlock_irqrestore(&tspi->lock, flags);
-        return IRQ_HANDLED;
-}
-
-static irqreturn_t tegra_slink_isr_thread(int irq, void *context_data)
-{
-        struct tegra_slink_data *tspi = context_data;
-
-        if (!tspi->is_curr_dma_xfer)
-                return handle_cpu_based_xfer(tspi);
-        return handle_dma_based_xfer(tspi);
-}
-
-static irqreturn_t tegra_slink_isr(int irq, void *context_data)
-{
-        struct tegra_slink_data *tspi = context_data;
-
-        tspi->status_reg = tegra_slink_readl(tspi, SLINK_STATUS);
-        if (tspi->cur_direction & DATA_DIR_TX)
-                tspi->tx_status = tspi->status_reg &
-                                        (SLINK_TX_OVF | SLINK_TX_UNF);
-
-        if (tspi->cur_direction & DATA_DIR_RX)
-                tspi->rx_status = tspi->status_reg &
-                                        (SLINK_RX_OVF | SLINK_RX_UNF);
-        tegra_slink_clear_status(tspi);
-
-        return IRQ_WAKE_THREAD;
-}
-
-static struct tegra_spi_platform_data *tegra_slink_parse_dt(
-                struct platform_device *pdev)
-{
-        struct tegra_spi_platform_data *pdata;
-        const unsigned int *prop;
-        struct device_node *np = pdev->dev.of_node;
-        u32 of_dma[2];
-
-        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
-        if (!pdata) {
-                dev_err(&pdev->dev, "Memory alloc for pdata failed\n");
-                return NULL;
-        }
-
-        if (of_property_read_u32_array(np, "nvidia,dma-request-selector",
-                                of_dma, 2) >= 0)
-                pdata->dma_req_sel = of_dma[1];
-
-        prop = of_get_property(np, "spi-max-frequency", NULL);
-        if (prop)
-                pdata->spi_max_frequency = be32_to_cpup(prop);
-
-        return pdata;
-}
-
-const struct tegra_slink_chip_data tegra30_spi_cdata = {
-        .cs_hold_time = true,
-};
-
-const struct tegra_slink_chip_data tegra20_spi_cdata = {
-        .cs_hold_time = false,
-};
-
-static struct of_device_id tegra_slink_of_match[] = {
-        { .compatible = "nvidia,tegra30-slink", .data = &tegra30_spi_cdata, },
-        { .compatible = "nvidia,tegra20-slink", .data = &tegra20_spi_cdata, },
-        {}
-};
-MODULE_DEVICE_TABLE(of, tegra_slink_of_match);
-
-static int tegra_slink_probe(struct platform_device *pdev)
-{
-        struct spi_master       *master;
-        struct tegra_slink_data *tspi;
-        struct resource         *r;
-        struct tegra_spi_platform_data *pdata = pdev->dev.platform_data;
-        int ret, spi_irq;
-        const struct tegra_slink_chip_data *cdata = NULL;
-        const struct of_device_id *match;
-
-        match = of_match_device(of_match_ptr(tegra_slink_of_match), &pdev->dev);
-        if (!match) {
-                dev_err(&pdev->dev, "Error: No device match found\n");
-                return -ENODEV;
-        }
-        cdata = match->data;
-        if (!pdata && pdev->dev.of_node)
-                pdata = tegra_slink_parse_dt(pdev);
-
-        if (!pdata) {
-                dev_err(&pdev->dev, "No platform data, exiting\n");
-                return -ENODEV;
-        }
-
-        if (!pdata->spi_max_frequency)
-                pdata->spi_max_frequency = 25000000; /* 25MHz */
-
-        master = spi_alloc_master(&pdev->dev, sizeof(*tspi));
-        if (!master) {
-                dev_err(&pdev->dev, "master allocation failed\n");
-                return -ENOMEM;
-        }
-
-        /* the spi->mode bits understood by this driver: */
-        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
-        master->setup = tegra_slink_setup;
-        master->prepare_transfer_hardware = tegra_slink_prepare_transfer;
-        master->transfer_one_message = tegra_slink_transfer_one_message;
-        master->unprepare_transfer_hardware = tegra_slink_unprepare_transfer;
-        master->num_chipselect = MAX_CHIP_SELECT;
-        master->bus_num = -1;
-
-        dev_set_drvdata(&pdev->dev, master);
-        tspi = spi_master_get_devdata(master);
-        tspi->master = master;
-        tspi->dma_req_sel = pdata->dma_req_sel;
-        tspi->dev = &pdev->dev;
-        tspi->chip_data = cdata;
-        spin_lock_init(&tspi->lock);
-
-        r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!r) {
-                dev_err(&pdev->dev, "No IO memory resource\n");
-                ret = -ENODEV;
-                goto exit_free_master;
-        }
-        tspi->phys = r->start;
-        tspi->base = devm_request_and_ioremap(&pdev->dev, r);
-        if (!tspi->base) {
-                dev_err(&pdev->dev,
-                        "Cannot request memregion/iomap dma address\n");
-                ret = -EADDRNOTAVAIL;
-                goto exit_free_master;
-        }
-
-        spi_irq = platform_get_irq(pdev, 0);
-        tspi->irq = spi_irq;
-        ret = request_threaded_irq(tspi->irq, tegra_slink_isr,
-                        tegra_slink_isr_thread, IRQF_ONESHOT,
-                        dev_name(&pdev->dev), tspi);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "Failed to register ISR for IRQ %d\n",
-                                        tspi->irq);
-                goto exit_free_master;
-        }
-
-        tspi->clk = devm_clk_get(&pdev->dev, "slink");
-        if (IS_ERR(tspi->clk)) {
-                dev_err(&pdev->dev, "can not get clock\n");
-                ret = PTR_ERR(tspi->clk);
-                goto exit_free_irq;
-        }
-
-        tspi->max_buf_size = SLINK_FIFO_DEPTH << 2;
-        tspi->dma_buf_size = DEFAULT_SPI_DMA_BUF_LEN;
-        tspi->spi_max_frequency = pdata->spi_max_frequency;
-
-        if (pdata->dma_req_sel) {
-                ret = tegra_slink_init_dma_param(tspi, true);
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "RxDma Init failed, err %d\n", ret);
-                        goto exit_free_irq;
-                }
-
-                ret = tegra_slink_init_dma_param(tspi, false);
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "TxDma Init failed, err %d\n", ret);
-                        goto exit_rx_dma_free;
-                }
-                tspi->max_buf_size = tspi->dma_buf_size;
-                init_completion(&tspi->tx_dma_complete);
-                init_completion(&tspi->rx_dma_complete);
-        }
-
-        init_completion(&tspi->xfer_completion);
-
-        pm_runtime_enable(&pdev->dev);
-        if (!pm_runtime_enabled(&pdev->dev)) {
-                ret = tegra_slink_runtime_resume(&pdev->dev);
-                if (ret)
-                        goto exit_pm_disable;
-        }
-
-        ret = pm_runtime_get_sync(&pdev->dev);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "pm runtime get failed, e = %d\n", ret);
-                goto exit_pm_disable;
-        }
-        tspi->def_command_reg  = SLINK_M_S;
-        tspi->def_command2_reg = SLINK_CS_ACTIVE_BETWEEN;
-        tegra_slink_writel(tspi, tspi->def_command_reg, SLINK_COMMAND);
-        tegra_slink_writel(tspi, tspi->def_command2_reg, SLINK_COMMAND2);
-        pm_runtime_put(&pdev->dev);
-
-        master->dev.of_node = pdev->dev.of_node;
-        ret = spi_register_master(master);
-        if (ret < 0) {
-                dev_err(&pdev->dev, "can not register to master err %d\n", ret);
-                goto exit_pm_disable;
-        }
-        return ret;
-
-exit_pm_disable:
-        pm_runtime_disable(&pdev->dev);
-        if (!pm_runtime_status_suspended(&pdev->dev))
-                tegra_slink_runtime_suspend(&pdev->dev);
-        tegra_slink_deinit_dma_param(tspi, false);
-exit_rx_dma_free:
-        tegra_slink_deinit_dma_param(tspi, true);
-exit_free_irq:
-        free_irq(spi_irq, tspi);
-exit_free_master:
-        spi_master_put(master);
-        return ret;
-}
-
-static int tegra_slink_remove(struct platform_device *pdev)
-{
-        struct spi_master *master = dev_get_drvdata(&pdev->dev);
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-
-        free_irq(tspi->irq, tspi);
-        spi_unregister_master(master);
-
-        if (tspi->tx_dma_chan)
-                tegra_slink_deinit_dma_param(tspi, false);
-
-        if (tspi->rx_dma_chan)
-                tegra_slink_deinit_dma_param(tspi, true);
-
-        pm_runtime_disable(&pdev->dev);
-        if (!pm_runtime_status_suspended(&pdev->dev))
-                tegra_slink_runtime_suspend(&pdev->dev);
-
-        return 0;
-}
-
-#ifdef CONFIG_PM_SLEEP
-static int tegra_slink_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-
-        return spi_master_suspend(master);
-}
-
-static int tegra_slink_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-        int ret;
-
-        ret = pm_runtime_get_sync(dev);
-        if (ret < 0) {
-                dev_err(dev, "pm runtime failed, e = %d\n", ret);
-                return ret;
-        }
-        tegra_slink_writel(tspi, tspi->command_reg, SLINK_COMMAND);
-        tegra_slink_writel(tspi, tspi->command2_reg, SLINK_COMMAND2);
-        pm_runtime_put(dev);
-
-        return spi_master_resume(master);
-}
-#endif
-
-static int tegra_slink_runtime_suspend(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-
-        /* Flush all write which are in PPSB queue by reading back */
-        tegra_slink_readl(tspi, SLINK_MAS_DATA);
-
-        clk_disable_unprepare(tspi->clk);
-        return 0;
-}
-
-static int tegra_slink_runtime_resume(struct device *dev)
-{
-        struct spi_master *master = dev_get_drvdata(dev);
-        struct tegra_slink_data *tspi = spi_master_get_devdata(master);
-        int ret;
-
-        ret = clk_prepare_enable(tspi->clk);
-        if (ret < 0) {
-                dev_err(tspi->dev, "clk_prepare failed: %d\n", ret);
-                return ret;
-        }
-        return 0;
-}
-
-static const struct dev_pm_ops slink_pm_ops = {
-        SET_RUNTIME_PM_OPS(tegra_slink_runtime_suspend,
-                tegra_slink_runtime_resume, NULL)
-        SET_SYSTEM_SLEEP_PM_OPS(tegra_slink_suspend, tegra_slink_resume)
-};
-static struct platform_driver tegra_slink_driver = {
-        .driver = {
-                .name           = "spi-tegra-slink",
-                .owner          = THIS_MODULE,
-                .pm             = &slink_pm_ops,
-                .of_match_table = of_match_ptr(tegra_slink_of_match),
-        },
-        .probe =        tegra_slink_probe,
-        .remove =       tegra_slink_remove,
-};
-module_platform_driver(tegra_slink_driver);
-
-MODULE_ALIAS("platform:spi-tegra-slink");
-MODULE_DESCRIPTION("NVIDIA Tegra20/Tegra30 SLINK Controller Driver");
-MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-ti-ssp.c b/drivers/spi/spi-ti-ssp.c
index 46992cab65f..ee22795c797 100644
--- a/drivers/spi/spi-ti-ssp.c
+++ b/drivers/spi/spi-ti-ssp.c
@@ -22,7 +22,6 @@
 #include <linux/err.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
-#include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/spi/spi.h>
 #include <linux/mfd/ti_ssp.h>
@@ -289,7 +288,7 @@ error_unlock:
         return error;
 }
 
-static int ti_ssp_spi_probe(struct platform_device *pdev)
+static int __devinit ti_ssp_spi_probe(struct platform_device *pdev)
 {
         const struct ti_ssp_spi_data *pdata;
         struct ti_ssp_spi *hw;
@@ -357,7 +356,7 @@ error_wq:
         return error;
 }
 
-static int ti_ssp_spi_remove(struct platform_device *pdev)
+static int __devexit ti_ssp_spi_remove(struct platform_device *pdev)
 {
         struct ti_ssp_spi *hw = platform_get_drvdata(pdev);
         int error;
@@ -378,13 +377,24 @@ static int ti_ssp_spi_remove(struct platform_device *pdev)
 
 static struct platform_driver ti_ssp_spi_driver = {
         .probe          = ti_ssp_spi_probe,
-        .remove         = ti_ssp_spi_remove,
+        .remove         = __devexit_p(ti_ssp_spi_remove),
         .driver         = {
                 .name   = "ti-ssp-spi",
                 .owner  = THIS_MODULE,
         },
 };
-module_platform_driver(ti_ssp_spi_driver);
+
+static int __init ti_ssp_spi_init(void)
+{
+        return platform_driver_register(&ti_ssp_spi_driver);
+}
+module_init(ti_ssp_spi_init);
+
+static void __exit ti_ssp_spi_exit(void)
+{
+        platform_driver_unregister(&ti_ssp_spi_driver);
+}
+module_exit(ti_ssp_spi_exit);
 
 MODULE_DESCRIPTION("SSP SPI Master");
 MODULE_AUTHOR("Cyril Chemparathy");
diff --git a/drivers/spi/spi-tle62x0.c b/drivers/spi/spi-tle62x0.c
index 6b0874d782e..940e73d1cf0 100644
--- a/drivers/spi/spi-tle62x0.c
+++ b/drivers/spi/spi-tle62x0.c
@@ -11,7 +11,6 @@
 
 #include <linux/device.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/slab.h>
 
 #include <linux/spi/spi.h>
@@ -240,7 +239,7 @@ static int to_gpio_num(struct device_attribute *attr)
         return -1;
 }
 
-static int tle62x0_probe(struct spi_device *spi)
+static int __devinit tle62x0_probe(struct spi_device *spi)
 {
         struct tle62x0_state *st;
         struct tle62x0_pdata *pdata;
@@ -294,7 +293,7 @@ static int tle62x0_probe(struct spi_device *spi)
         return ret;
 }
 
-static int tle62x0_remove(struct spi_device *spi)
+static int __devexit tle62x0_remove(struct spi_device *spi)
 {
         struct tle62x0_state *st = spi_get_drvdata(spi);
         int ptr;
@@ -313,10 +312,21 @@ static struct spi_driver tle62x0_driver = {
                 .owner  = THIS_MODULE,
         },
         .probe          = tle62x0_probe,
-        .remove         = tle62x0_remove,
+        .remove         = __devexit_p(tle62x0_remove),
 };
 
-module_spi_driver(tle62x0_driver);
+static __init int tle62x0_init(void)
+{
+        return spi_register_driver(&tle62x0_driver);
+}
+
+static __exit void tle62x0_exit(void)
+{
+        spi_unregister_driver(&tle62x0_driver);
+}
+
+module_init(tle62x0_init);
+module_exit(tle62x0_exit);
 
 MODULE_AUTHOR("Ben Dooks <ben@simtec.co.uk>");
 MODULE_DESCRIPTION("TLE62x0 SPI driver");
diff --git a/drivers/spi/spi-topcliff-pch.c b/drivers/spi/spi-topcliff-pch.c
index f756481b0fe..6a80749391d 100644
--- a/drivers/spi/spi-topcliff-pch.c
+++ b/drivers/spi/spi-topcliff-pch.c
@@ -1,7 +1,7 @@
 /*
  * SPI bus driver for the Topcliff PCH used by Intel SoCs
  *
- * Copyright (C) 2011 LAPIS Semiconductor Co., Ltd.
+ * Copyright (C) 2010 OKI SEMICONDUCTOR Co., LTD.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -95,18 +95,16 @@
 #define PCH_CLOCK_HZ            50000000
 #define PCH_MAX_SPBR            1023
 
-/* Definition for ML7213/ML7223/ML7831 by LAPIS Semiconductor */
+/* Definition for ML7213 by OKI SEMICONDUCTOR */
 #define PCI_VENDOR_ID_ROHM              0x10DB
 #define PCI_DEVICE_ID_ML7213_SPI        0x802c
 #define PCI_DEVICE_ID_ML7223_SPI        0x800F
-#define PCI_DEVICE_ID_ML7831_SPI        0x8816
 
 /*
  * Set the number of SPI instance max
  * Intel EG20T PCH :            1ch
- * LAPIS Semiconductor ML7213 IOH :     2ch
- * LAPIS Semiconductor ML7223 IOH :     1ch
- * LAPIS Semiconductor ML7831 IOH :     1ch
+ * OKI SEMICONDUCTOR ML7213 IOH :       2ch
+ * OKI SEMICONDUCTOR ML7223 IOH :       1ch
 */
 #define PCH_SPI_MAX_DEV                 2
 
@@ -196,7 +194,6 @@ struct pch_spi_data {
         struct pch_spi_dma_ctrl dma;
         int use_dma;
         u8 irq_reg_sts;
-        int save_total_len;
 };
 
 /**
@@ -217,11 +214,10 @@ struct pch_pd_dev_save {
         struct pch_spi_board_data *board_dat;
 };
 
-static DEFINE_PCI_DEVICE_TABLE(pch_spi_pcidev_id) = {
+static struct pci_device_id pch_spi_pcidev_id[] = {
         { PCI_VDEVICE(INTEL, PCI_DEVICE_ID_GE_SPI),    1, },
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7213_SPI), 2, },
         { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7223_SPI), 1, },
-        { PCI_VDEVICE(ROHM, PCI_DEVICE_ID_ML7831_SPI), 1, },
         { }
 };
 
@@ -319,23 +315,22 @@ static void pch_spi_handler_sub(struct pch_spi_data *data, u32 reg_spsr_val,
                 data->tx_index = tx_index;
                 data->rx_index = rx_index;
 
-                /* if transfer complete interrupt */
-                if (reg_spsr_val & SPSR_FI_BIT) {
-                        if ((tx_index == bpw_len) && (rx_index == tx_index)) {
-                                /* disable interrupts */
-                                pch_spi_setclr_reg(data->master, PCH_SPCR, 0,
-                                                   PCH_ALL);
-
-                                /* transfer is completed;
-                                   inform pch_spi_process_messages */
-                                data->transfer_complete = true;
-                                data->transfer_active = false;
-                                wake_up(&data->wait);
-                        } else {
-                                dev_err(&data->master->dev,
-                                        "%s : Transfer is not completed",
-                                        __func__);
-                        }
+        }
+
+        /* if transfer complete interrupt */
+        if (reg_spsr_val & SPSR_FI_BIT) {
+                if ((tx_index == bpw_len) && (rx_index == tx_index)) {
+                        /* disable interrupts */
+                        pch_spi_setclr_reg(data->master, PCH_SPCR, 0, PCH_ALL);
+
+                        /* transfer is completed;
+                           inform pch_spi_process_messages */
+                        data->transfer_complete = true;
+                        data->transfer_active = false;
+                        wake_up(&data->wait);
+                } else {
+                        dev_err(&data->master->dev,
+                                "%s : Transfer is not completed", __func__);
                 }
         }
 }
@@ -505,7 +500,7 @@ static int pch_spi_transfer(struct spi_device *pspi, struct spi_message *pmsg)
         }
 
         if (unlikely(pspi->max_speed_hz == 0)) {
-                dev_err(&pspi->dev, "%s pch_spi_transfer maxspeed=%d\n",
+                dev_err(&pspi->dev, "%s pch_spi_tranfer maxspeed=%d\n",
                         __func__, pspi->max_speed_hz);
                 retval = -EINVAL;
                 goto err_out;
@@ -824,13 +819,11 @@ static void pch_spi_copy_rx_data_for_dma(struct pch_spi_data *data, int bpw)
                 rx_dma_buf = data->dma.rx_buf_virt;
                 for (j = 0; j < data->bpw_len; j++)
                         *rx_buf++ = *rx_dma_buf++ & 0xFF;
-                data->cur_trans->rx_buf = rx_buf;
         } else {
                 rx_sbuf = data->cur_trans->rx_buf;
                 rx_dma_sbuf = data->dma.rx_buf_virt;
                 for (j = 0; j < data->bpw_len; j++)
                         *rx_sbuf++ = *rx_dma_sbuf++;
-                data->cur_trans->rx_buf = rx_sbuf;
         }
 }
 
@@ -856,9 +849,6 @@ static int pch_spi_start_transfer(struct pch_spi_data *data)
         rtn = wait_event_interruptible_timeout(data->wait,
                                                data->transfer_complete,
                                                msecs_to_jiffies(2 * HZ));
-        if (!rtn)
-                dev_err(&data->master->dev,
-                        "%s wait-event timeout\n", __func__);
 
         dma_sync_sg_for_cpu(&data->master->dev, dma->sg_rx_p, dma->nent,
                             DMA_FROM_DEVICE);
@@ -930,8 +920,7 @@ static void pch_spi_request_dma(struct pch_spi_data *data, int bpw)
         dma_cap_set(DMA_SLAVE, mask);
 
         /* Get DMA's dev information */
-        dma_dev = pci_get_bus_and_slot(data->board_dat->pdev->bus->number,
-                                       PCI_DEVFN(12, 0));
+        dma_dev = pci_get_bus_and_slot(2, PCI_DEVFN(12, 0));
 
         /* Set Tx DMA */
         param = &dma->param_tx;
@@ -995,7 +984,6 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         int i;
         int size;
         int rem;
-        int head;
         unsigned long flags;
         struct pch_spi_dma_ctrl *dma;
 
@@ -1024,11 +1012,6 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         }
         data->bpw_len = data->cur_trans->len / (*bpw / 8);
 
-        if (data->bpw_len > PCH_BUF_SIZE) {
-                data->bpw_len = PCH_BUF_SIZE;
-                data->cur_trans->len -= PCH_BUF_SIZE;
-        }
-
         /* copy Tx Data */
         if (data->cur_trans->tx_buf != NULL) {
                 if (*bpw == 8) {
@@ -1043,17 +1026,10 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
                                 *tx_dma_sbuf++ = *tx_sbuf++;
                 }
         }
-
-        /* Calculate Rx parameter for DMA transmitting */
         if (data->bpw_len > PCH_DMA_TRANS_SIZE) {
-                if (data->bpw_len % PCH_DMA_TRANS_SIZE) {
-                        num = data->bpw_len / PCH_DMA_TRANS_SIZE + 1;
-                        rem = data->bpw_len % PCH_DMA_TRANS_SIZE;
-                } else {
-                        num = data->bpw_len / PCH_DMA_TRANS_SIZE;
-                        rem = PCH_DMA_TRANS_SIZE;
-                }
+                num = data->bpw_len / PCH_DMA_TRANS_SIZE + 1;
                 size = PCH_DMA_TRANS_SIZE;
+                rem = data->bpw_len % PCH_DMA_TRANS_SIZE;
         } else {
                 num = 1;
                 size = data->bpw_len;
@@ -1099,8 +1075,8 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
                 sg_dma_address(sg) = dma->rx_buf_dma + sg->offset;
         }
         sg = dma->sg_rx_p;
-        desc_rx = dmaengine_prep_slave_sg(dma->chan_rx, sg,
-                                        num, DMA_DEV_TO_MEM,
+        desc_rx = dma->chan_rx->device->device_prep_slave_sg(dma->chan_rx, sg,
+                                        num, DMA_FROM_DEVICE,
                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc_rx) {
                 dev_err(&data->master->dev, "%s:device_prep_slave_sg Failed\n",
@@ -1113,23 +1089,15 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         dma->nent = num;
         dma->desc_rx = desc_rx;
 
-        /* Calculate Tx parameter for DMA transmitting */
-        if (data->bpw_len > PCH_MAX_FIFO_DEPTH) {
-                head = PCH_MAX_FIFO_DEPTH - PCH_DMA_TRANS_SIZE;
-                if (data->bpw_len % PCH_DMA_TRANS_SIZE > 4) {
-                        num = data->bpw_len / PCH_DMA_TRANS_SIZE + 1;
-                        rem = data->bpw_len % PCH_DMA_TRANS_SIZE - head;
-                } else {
-                        num = data->bpw_len / PCH_DMA_TRANS_SIZE;
-                        rem = data->bpw_len % PCH_DMA_TRANS_SIZE +
-                              PCH_DMA_TRANS_SIZE - head;
-                }
+        /* TX */
+        if (data->bpw_len > PCH_DMA_TRANS_SIZE) {
+                num = data->bpw_len / PCH_DMA_TRANS_SIZE;
                 size = PCH_DMA_TRANS_SIZE;
+                rem = 16;
         } else {
                 num = 1;
                 size = data->bpw_len;
                 rem = data->bpw_len;
-                head = 0;
         }
 
         dma->sg_tx_p = kzalloc(sizeof(struct scatterlist)*num, GFP_ATOMIC);
@@ -1139,17 +1107,11 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
         for (i = 0; i < num; i++, sg++) {
                 if (i == 0) {
                         sg->offset = 0;
-                        sg_set_page(sg, virt_to_page(dma->tx_buf_virt), size + head,
-                                    sg->offset);
-                        sg_dma_len(sg) = size + head;
-                } else if (i == (num - 1)) {
-                        sg->offset = head + size * i;
-                        sg->offset = sg->offset * (*bpw / 8);
                         sg_set_page(sg, virt_to_page(dma->tx_buf_virt), rem,
                                     sg->offset);
                         sg_dma_len(sg) = rem;
                 } else {
-                        sg->offset = head + size * i;
+                        sg->offset = rem + size * (i - 1);
                         sg->offset = sg->offset * (*bpw / 8);
                         sg_set_page(sg, virt_to_page(dma->tx_buf_virt), size,
                                     sg->offset);
@@ -1158,8 +1120,8 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
                 sg_dma_address(sg) = dma->tx_buf_dma + sg->offset;
         }
         sg = dma->sg_tx_p;
-        desc_tx = dmaengine_prep_slave_sg(dma->chan_tx,
-                                        sg, num, DMA_MEM_TO_DEV,
+        desc_tx = dma->chan_tx->device->device_prep_slave_sg(dma->chan_tx,
+                                        sg, num, DMA_TO_DEVICE,
                                         DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
         if (!desc_tx) {
                 dev_err(&data->master->dev, "%s:device_prep_slave_sg Failed\n",
@@ -1237,7 +1199,6 @@ static void pch_spi_process_messages(struct work_struct *pwork)
                                     data->current_msg->spi->bits_per_word);
         pch_spi_writereg(data->master, PCH_SSNXCR, SSN_NO_CONTROL);
         do {
-                int cnt;
                 /* If we are already processing a message get the next
                 transfer structure from the message otherwise retrieve
                 the 1st transfer request from the message. */
@@ -1257,28 +1218,11 @@ static void pch_spi_process_messages(struct work_struct *pwork)
                 }
                 spin_unlock(&data->lock);
 
-                if (!data->cur_trans->len)
-                        goto out;
-                cnt = (data->cur_trans->len - 1) / PCH_BUF_SIZE + 1;
-                data->save_total_len = data->cur_trans->len;
                 if (data->use_dma) {
-                        int i;
-                        char *save_rx_buf = data->cur_trans->rx_buf;
-                        for (i = 0; i < cnt; i ++) {
-                                pch_spi_handle_dma(data, &bpw);
-                                if (!pch_spi_start_transfer(data)) {
-                                        data->transfer_complete = true;
-                                        data->current_msg->status = -EIO;
-                                        data->current_msg->complete
-                                                   (data->current_msg->context);
-                                        data->bcurrent_msg_processing = false;
-                                        data->current_msg = NULL;
-                                        data->cur_trans = NULL;
-                                        goto out;
-                                }
-                                pch_spi_copy_rx_data_for_dma(data, bpw);
-                        }
-                        data->cur_trans->rx_buf = save_rx_buf;
+                        pch_spi_handle_dma(data, &bpw);
+                        if (!pch_spi_start_transfer(data))
+                                goto out;
+                        pch_spi_copy_rx_data_for_dma(data, bpw);
                 } else {
                         pch_spi_set_tx(data, &bpw);
                         pch_spi_set_ir(data);
@@ -1289,7 +1233,6 @@ static void pch_spi_process_messages(struct work_struct *pwork)
                         data->pkt_tx_buff = NULL;
                 }
                 /* increment message count */
-                data->cur_trans->len = data->save_total_len;
                 data->current_msg->actual_length += data->cur_trans->len;
 
                 dev_dbg(&data->master->dev,
@@ -1401,7 +1344,7 @@ static void pch_alloc_dma_buf(struct pch_spi_board_data *board_dat,
                                 PCH_BUF_SIZE, &dma->rx_buf_dma, GFP_KERNEL);
 }
 
-static int pch_spi_pd_probe(struct platform_device *plat_dev)
+static int __devinit pch_spi_pd_probe(struct platform_device *plat_dev)
 {
         int ret;
         struct spi_master *master;
@@ -1438,10 +1381,10 @@ static int pch_spi_pd_probe(struct platform_device *plat_dev)
                 plat_dev->id, data->io_remap_addr);
 
         /* initialize members of SPI master */
+        master->bus_num = -1;
         master->num_chipselect = PCH_MAX_CS;
         master->setup = pch_spi_setup;
         master->transfer = pch_spi_transfer;
-        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST;
 
         data->board_dat = board_dat;
         data->plat_dev = plat_dev;
@@ -1498,7 +1441,7 @@ err_pci_iomap:
         return ret;
 }
 
-static int pch_spi_pd_remove(struct platform_device *plat_dev)
+static int __devexit pch_spi_pd_remove(struct platform_device *plat_dev)
 {
         struct pch_spi_board_data *board_dat = dev_get_platdata(&plat_dev->dev);
         struct pch_spi_data *data = platform_get_drvdata(plat_dev);
@@ -1536,6 +1479,8 @@ static int pch_spi_pd_remove(struct platform_device *plat_dev)
 
         pci_iounmap(board_dat->pdev, data->io_remap_addr);
         spi_unregister_master(data->master);
+        spi_master_put(data->master);
+        platform_set_drvdata(plat_dev, NULL);
 
         return 0;
 }
@@ -1619,12 +1564,12 @@ static struct platform_driver pch_spi_pd_driver = {
                 .owner = THIS_MODULE,
         },
         .probe = pch_spi_pd_probe,
-        .remove = pch_spi_pd_remove,
+        .remove = __devexit_p(pch_spi_pd_remove),
         .suspend = pch_spi_pd_suspend,
         .resume = pch_spi_pd_resume
 };
 
-static int pch_spi_probe(struct pci_dev *pdev,
+static int __devinit pch_spi_probe(struct pci_dev *pdev,
                                    const struct pci_device_id *id)
 {
         struct pch_spi_board_data *board_dat;
@@ -1705,7 +1650,7 @@ err_no_mem:
         return retval;
 }
 
-static void pch_spi_remove(struct pci_dev *pdev)
+static void __devexit pch_spi_remove(struct pci_dev *pdev)
 {
         int i;
         struct pch_pd_dev_save *pd_dev_save = pci_get_drvdata(pdev);
@@ -1772,7 +1717,7 @@ static int pch_spi_resume(struct pci_dev *pdev)
 
 #endif
 
-static struct pci_driver pch_spi_pcidev_driver = {
+static struct pci_driver pch_spi_pcidev = {
         .name = "pch_spi",
         .id_table = pch_spi_pcidev_id,
         .probe = pch_spi_probe,
@@ -1788,7 +1733,7 @@ static int __init pch_spi_init(void)
         if (ret)
                 return ret;
 
-        ret = pci_register_driver(&pch_spi_pcidev_driver);
+        ret = pci_register_driver(&pch_spi_pcidev);
         if (ret)
                 return ret;
 
@@ -1798,7 +1743,7 @@ module_init(pch_spi_init);
 
 static void __exit pch_spi_exit(void)
 {
-        pci_unregister_driver(&pch_spi_pcidev_driver);
+        pci_unregister_driver(&pch_spi_pcidev);
         platform_driver_unregister(&pch_spi_pd_driver);
 }
 module_exit(pch_spi_exit);
@@ -1808,4 +1753,4 @@ MODULE_PARM_DESC(use_dma,
                  "to use DMA for data transfers pass 1 else 0; default 1");
 
 MODULE_LICENSE("GPL");
-MODULE_DESCRIPTION("Intel EG20T PCH/LAPIS Semiconductor ML7xxx IOH SPI Driver");
+MODULE_DESCRIPTION("Intel EG20T PCH/OKI SEMICONDUCTOR ML7xxx IOH SPI Driver");
diff --git a/drivers/spi/spi-txx9.c b/drivers/spi/spi-txx9.c
index d5a3cbb646c..f0a2ab0428a 100644
--- a/drivers/spi/spi-txx9.c
+++ b/drivers/spi/spi-txx9.c
@@ -25,7 +25,6 @@
 #include <linux/err.h>
 #include <linux/clk.h>
 #include <linux/io.h>
-#include <linux/module.h>
 #include <asm/gpio.h>
 
 
diff --git a/drivers/spi/spi-xcomm.c b/drivers/spi/spi-xcomm.c
deleted file mode 100644
index 4d3ec8b9f47..00000000000
--- a/drivers/spi/spi-xcomm.c
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Analog Devices AD-FMCOMMS1-EBZ board I2C-SPI bridge driver
- *
- * Copyright 2012 Analog Devices Inc.
- * Author: Lars-Peter Clausen <lars@metafoo.de>
- *
- * Licensed under the GPL-2 or later.
- */
-
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/module.h>
-#include <linux/delay.h>
-#include <linux/i2c.h>
-#include <linux/spi/spi.h>
-#include <asm/unaligned.h>
-
-#define SPI_XCOMM_SETTINGS_LEN_OFFSET           10
-#define SPI_XCOMM_SETTINGS_3WIRE                BIT(6)
-#define SPI_XCOMM_SETTINGS_CS_HIGH              BIT(5)
-#define SPI_XCOMM_SETTINGS_SAMPLE_END           BIT(4)
-#define SPI_XCOMM_SETTINGS_CPHA                 BIT(3)
-#define SPI_XCOMM_SETTINGS_CPOL                 BIT(2)
-#define SPI_XCOMM_SETTINGS_CLOCK_DIV_MASK       0x3
-#define SPI_XCOMM_SETTINGS_CLOCK_DIV_64         0x2
-#define SPI_XCOMM_SETTINGS_CLOCK_DIV_16         0x1
-#define SPI_XCOMM_SETTINGS_CLOCK_DIV_4          0x0
-
-#define SPI_XCOMM_CMD_UPDATE_CONFIG     0x03
-#define SPI_XCOMM_CMD_WRITE             0x04
-
-#define SPI_XCOMM_CLOCK 48000000
-
-struct spi_xcomm {
-        struct i2c_client *i2c;
-
-        uint16_t settings;
-        uint16_t chipselect;
-
-        unsigned int current_speed;
-
-        uint8_t buf[63];
-};
-
-static int spi_xcomm_sync_config(struct spi_xcomm *spi_xcomm, unsigned int len)
-{
-        uint16_t settings;
-        uint8_t *buf = spi_xcomm->buf;
-
-        settings = spi_xcomm->settings;
-        settings |= len << SPI_XCOMM_SETTINGS_LEN_OFFSET;
-
-        buf[0] = SPI_XCOMM_CMD_UPDATE_CONFIG;
-        put_unaligned_be16(settings, &buf[1]);
-        put_unaligned_be16(spi_xcomm->chipselect, &buf[3]);
-
-        return i2c_master_send(spi_xcomm->i2c, buf, 5);
-}
-
-static void spi_xcomm_chipselect(struct spi_xcomm *spi_xcomm,
-        struct spi_device *spi, int is_active)
-{
-        unsigned long cs = spi->chip_select;
-        uint16_t chipselect = spi_xcomm->chipselect;
-
-        if (is_active)
-                chipselect |= BIT(cs);
-        else
-                chipselect &= ~BIT(cs);
-
-        spi_xcomm->chipselect = chipselect;
-}
-
-static int spi_xcomm_setup_transfer(struct spi_xcomm *spi_xcomm,
-        struct spi_device *spi, struct spi_transfer *t, unsigned int *settings)
-{
-        unsigned int speed;
-
-        if ((t->bits_per_word && t->bits_per_word != 8) || t->len > 62)
-                return -EINVAL;
-
-        speed = t->speed_hz ? t->speed_hz : spi->max_speed_hz;
-
-        if (speed != spi_xcomm->current_speed) {
-                unsigned int divider = DIV_ROUND_UP(SPI_XCOMM_CLOCK, speed);
-                if (divider >= 64)
-                        *settings |= SPI_XCOMM_SETTINGS_CLOCK_DIV_64;
-                else if (divider >= 16)
-                        *settings |= SPI_XCOMM_SETTINGS_CLOCK_DIV_16;
-                else
-                        *settings |= SPI_XCOMM_SETTINGS_CLOCK_DIV_4;
-
-                spi_xcomm->current_speed = speed;
-        }
-
-        if (spi->mode & SPI_CPOL)
-                *settings |= SPI_XCOMM_SETTINGS_CPOL;
-        else
-                *settings &= ~SPI_XCOMM_SETTINGS_CPOL;
-
-        if (spi->mode & SPI_CPHA)
-                *settings &= ~SPI_XCOMM_SETTINGS_CPHA;
-        else
-                *settings |= SPI_XCOMM_SETTINGS_CPHA;
-
-        if (spi->mode & SPI_3WIRE)
-                *settings |= SPI_XCOMM_SETTINGS_3WIRE;
-        else
-                *settings &= ~SPI_XCOMM_SETTINGS_3WIRE;
-
-        return 0;
-}
-
-static int spi_xcomm_txrx_bufs(struct spi_xcomm *spi_xcomm,
-        struct spi_device *spi, struct spi_transfer *t)
-{
-        int ret;
-
-        if (t->tx_buf) {
-                spi_xcomm->buf[0] = SPI_XCOMM_CMD_WRITE;
-                memcpy(spi_xcomm->buf + 1, t->tx_buf, t->len);
-
-                ret = i2c_master_send(spi_xcomm->i2c, spi_xcomm->buf, t->len + 1);
-                if (ret < 0)
-                        return ret;
-                else if (ret != t->len + 1)
-                        return -EIO;
-        } else if (t->rx_buf) {
-                ret = i2c_master_recv(spi_xcomm->i2c, t->rx_buf, t->len);
-                if (ret < 0)
-                        return ret;
-                else if (ret != t->len)
-                        return -EIO;
-        }
-
-        return t->len;
-}
-
-static int spi_xcomm_transfer_one(struct spi_master *master,
-        struct spi_message *msg)
-{
-        struct spi_xcomm *spi_xcomm = spi_master_get_devdata(master);
-        unsigned int settings = spi_xcomm->settings;
-        struct spi_device *spi = msg->spi;
-        unsigned cs_change = 0;
-        struct spi_transfer *t;
-        bool is_first = true;
-        int status = 0;
-        bool is_last;
-
-        is_first = true;
-
-        spi_xcomm_chipselect(spi_xcomm, spi, true);
-
-        list_for_each_entry(t, &msg->transfers, transfer_list) {
-
-                if (!t->tx_buf && !t->rx_buf && t->len) {
-                        status = -EINVAL;
-                        break;
-                }
-
-                status = spi_xcomm_setup_transfer(spi_xcomm, spi, t, &settings);
-                if (status < 0)
-                        break;
-
-                is_last = list_is_last(&t->transfer_list, &msg->transfers);
-                cs_change = t->cs_change;
-
-                if (cs_change ^ is_last)
-                        settings |= BIT(5);
-                else
-                        settings &= ~BIT(5);
-
-                if (t->rx_buf) {
-                        spi_xcomm->settings = settings;
-                        status = spi_xcomm_sync_config(spi_xcomm, t->len);
-                        if (status < 0)
-                                break;
-                } else if (settings != spi_xcomm->settings || is_first) {
-                        spi_xcomm->settings = settings;
-                        status = spi_xcomm_sync_config(spi_xcomm, 0);
-                        if (status < 0)
-                                break;
-                }
-
-                if (t->len) {
-                        status = spi_xcomm_txrx_bufs(spi_xcomm, spi, t);
-
-                        if (status < 0)
-                                break;
-
-                        if (status > 0)
-                                msg->actual_length += status;
-                }
-                status = 0;
-
-                if (t->delay_usecs)
-                        udelay(t->delay_usecs);
-
-                is_first = false;
-        }
-
-        if (status != 0 || !cs_change)
-                spi_xcomm_chipselect(spi_xcomm, spi, false);
-
-        msg->status = status;
-        spi_finalize_current_message(master);
-
-        return status;
-}
-
-static int spi_xcomm_setup(struct spi_device *spi)
-{
-        if (spi->bits_per_word != 8)
-                return -EINVAL;
-
-        return 0;
-}
-
-static int spi_xcomm_probe(struct i2c_client *i2c,
-        const struct i2c_device_id *id)
-{
-        struct spi_xcomm *spi_xcomm;
-        struct spi_master *master;
-        int ret;
-
-        master = spi_alloc_master(&i2c->dev, sizeof(*spi_xcomm));
-        if (!master)
-                return -ENOMEM;
-
-        spi_xcomm = spi_master_get_devdata(master);
-        spi_xcomm->i2c = i2c;
-
-        master->num_chipselect = 16;
-        master->mode_bits = SPI_CPHA | SPI_CPOL | SPI_3WIRE;
-        master->flags = SPI_MASTER_HALF_DUPLEX;
-        master->setup = spi_xcomm_setup;
-        master->transfer_one_message = spi_xcomm_transfer_one;
-        master->dev.of_node = i2c->dev.of_node;
-        i2c_set_clientdata(i2c, master);
-
-        ret = spi_register_master(master);
-        if (ret < 0)
-                spi_master_put(master);
-
-        return ret;
-}
-
-static int spi_xcomm_remove(struct i2c_client *i2c)
-{
-        struct spi_master *master = i2c_get_clientdata(i2c);
-
-        spi_unregister_master(master);
-
-        return 0;
-}
-
-static const struct i2c_device_id spi_xcomm_ids[] = {
-        { "spi-xcomm" },
-        { },
-};
-
-static struct i2c_driver spi_xcomm_driver = {
-        .driver = {
-                .name   = "spi-xcomm",
-                .owner  = THIS_MODULE,
-        },
-        .id_table       = spi_xcomm_ids,
-        .probe          = spi_xcomm_probe,
-        .remove         = spi_xcomm_remove,
-};
-module_i2c_driver(spi_xcomm_driver);
-
-MODULE_LICENSE("GPL");
-MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
-MODULE_DESCRIPTION("Analog Devices AD-FMCOMMS1-EBZ board I2C-SPI bridge driver");
diff --git a/drivers/spi/spi-xilinx.c b/drivers/spi/spi-xilinx.c
index e1d76960742..4d2c75df886 100644
--- a/drivers/spi/spi-xilinx.c
+++ b/drivers/spi/spi-xilinx.c
@@ -462,7 +462,7 @@ void xilinx_spi_deinit(struct spi_master *master)
 }
 EXPORT_SYMBOL(xilinx_spi_deinit);
 
-static int xilinx_spi_probe(struct platform_device *dev)
+static int __devinit xilinx_spi_probe(struct platform_device *dev)
 {
         struct xspi_platform_data *pdata;
         struct resource *r;
@@ -518,7 +518,7 @@ static int xilinx_spi_probe(struct platform_device *dev)
         return 0;
 }
 
-static int xilinx_spi_remove(struct platform_device *dev)
+static int __devexit xilinx_spi_remove(struct platform_device *dev)
 {
         xilinx_spi_deinit(platform_get_drvdata(dev));
         platform_set_drvdata(dev, 0);
@@ -531,14 +531,25 @@ MODULE_ALIAS("platform:" XILINX_SPI_NAME);
 
 static struct platform_driver xilinx_spi_driver = {
         .probe = xilinx_spi_probe,
-        .remove = xilinx_spi_remove,
+        .remove = __devexit_p(xilinx_spi_remove),
         .driver = {
                 .name = XILINX_SPI_NAME,
                 .owner = THIS_MODULE,
                 .of_match_table = xilinx_spi_of_match,
         },
 };
-module_platform_driver(xilinx_spi_driver);
+
+static int __init xilinx_spi_pltfm_init(void)
+{
+        return platform_driver_register(&xilinx_spi_driver);
+}
+module_init(xilinx_spi_pltfm_init);
+
+static void __exit xilinx_spi_pltfm_exit(void)
+{
+        platform_driver_unregister(&xilinx_spi_driver);
+}
+module_exit(xilinx_spi_pltfm_exit);
 
 MODULE_AUTHOR("MontaVista Software, Inc. <source@mvista.com>");
 MODULE_DESCRIPTION("Xilinx SPI driver");
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 19ee901577d..4d1b9f517ce 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -2,7 +2,6 @@
  * SPI init/core code
  *
  * Copyright (C) 2005 David Brownell
- * Copyright (C) 2008 Secret Lab Technologies Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -20,24 +19,16 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/kmod.h>
 #include <linux/device.h>
 #include <linux/init.h>
 #include <linux/cache.h>
 #include <linux/mutex.h>
 #include <linux/of_device.h>
-#include <linux/of_irq.h>
 #include <linux/slab.h>
 #include <linux/mod_devicetable.h>
 #include <linux/spi/spi.h>
-#include <linux/of_gpio.h>
+#include <linux/of_spi.h>
 #include <linux/pm_runtime.h>
-#include <linux/export.h>
-#include <linux/sched.h>
-#include <linux/delay.h>
-#include <linux/kthread.h>
-#include <linux/ioport.h>
-#include <linux/acpi.h>
 
 static void spidev_release(struct device *dev)
 {
@@ -56,7 +47,7 @@ modalias_show(struct device *dev, struct device_attribute *a, char *buf)
 {
         const struct spi_device *spi = to_spi_device(dev);
 
-        return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
+        return sprintf(buf, "%s\n", spi->modalias);
 }
 
 static struct device_attribute spi_dev_attrs[] = {
@@ -96,10 +87,6 @@ static int spi_match_device(struct device *dev, struct device_driver *drv)
         if (of_driver_match_device(dev, drv))
                 return 1;
 
-        /* Then try ACPI */
-        if (acpi_driver_match_device(dev, drv))
-                return 1;
-
         if (sdrv->id_table)
                 return !!spi_match_id(sdrv->id_table, spi);
 
@@ -331,10 +318,9 @@ struct spi_device *spi_alloc_device(struct spi_master *master)
         }
 
         spi->master = master;
-        spi->dev.parent = &master->dev;
+        spi->dev.parent = dev;
         spi->dev.bus = &spi_bus_type;
         spi->dev.release = spidev_release;
-        spi->cs_gpio = -EINVAL;
         device_initialize(&spi->dev);
         return spi;
 }
@@ -352,16 +338,15 @@ EXPORT_SYMBOL_GPL(spi_alloc_device);
 int spi_add_device(struct spi_device *spi)
 {
         static DEFINE_MUTEX(spi_add_lock);
-        struct spi_master *master = spi->master;
-        struct device *dev = master->dev.parent;
+        struct device *dev = spi->master->dev.parent;
         struct device *d;
         int status;
 
         /* Chipselects are numbered 0..max; validate. */
-        if (spi->chip_select >= master->num_chipselect) {
+        if (spi->chip_select >= spi->master->num_chipselect) {
                 dev_err(dev, "cs%d >= max %d\n",
                         spi->chip_select,
-                        master->num_chipselect);
+                        spi->master->num_chipselect);
                 return -EINVAL;
         }
 
@@ -385,9 +370,6 @@ int spi_add_device(struct spi_device *spi)
                 goto done;
         }
 
-        if (master->cs_gpios)
-                spi->cs_gpio = master->cs_gpios[spi->chip_select];
-
         /* Drivers may modify this initial i/o setup, but will
          * normally rely on the device being setup.  Devices
          * using SPI_CS_HIGH can't coexist well otherwise...
@@ -498,7 +480,8 @@ static void spi_match_master_to_boardinfo(struct spi_master *master,
  * The board info passed can safely be __initdata ... but be careful of
  * any embedded pointers (platform_data, etc), they're copied as-is.
  */
-int spi_register_board_info(struct spi_board_info const *info, unsigned n)
+int __init
+spi_register_board_info(struct spi_board_info const *info, unsigned n)
 {
         struct boardinfo *bi;
         int i;
@@ -523,481 +506,6 @@ int spi_register_board_info(struct spi_board_info const *info, unsigned n)
 
 /*-------------------------------------------------------------------------*/
 
-/**
- * spi_pump_messages - kthread work function which processes spi message queue
- * @work: pointer to kthread work struct contained in the master struct
- *
- * This function checks if there is any spi message in the queue that
- * needs processing and if so call out to the driver to initialize hardware
- * and transfer each message.
- *
- */
-static void spi_pump_messages(struct kthread_work *work)
-{
-        struct spi_master *master =
-                container_of(work, struct spi_master, pump_messages);
-        unsigned long flags;
-        bool was_busy = false;
-        int ret;
-
-        /* Lock queue and check for queue work */
-        spin_lock_irqsave(&master->queue_lock, flags);
-        if (list_empty(&master->queue) || !master->running) {
-                if (master->busy && master->unprepare_transfer_hardware) {
-                        ret = master->unprepare_transfer_hardware(master);
-                        if (ret) {
-                                spin_unlock_irqrestore(&master->queue_lock, flags);
-                                dev_err(&master->dev,
-                                        "failed to unprepare transfer hardware\n");
-                                return;
-                        }
-                }
-                master->busy = false;
-                spin_unlock_irqrestore(&master->queue_lock, flags);
-                return;
-        }
-
-        /* Make sure we are not already running a message */
-        if (master->cur_msg) {
-                spin_unlock_irqrestore(&master->queue_lock, flags);
-                return;
-        }
-        /* Extract head of queue */
-        master->cur_msg =
-            list_entry(master->queue.next, struct spi_message, queue);
-
-        list_del_init(&master->cur_msg->queue);
-        if (master->busy)
-                was_busy = true;
-        else
-                master->busy = true;
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-
-        if (!was_busy && master->prepare_transfer_hardware) {
-                ret = master->prepare_transfer_hardware(master);
-                if (ret) {
-                        dev_err(&master->dev,
-                                "failed to prepare transfer hardware\n");
-                        return;
-                }
-        }
-
-        ret = master->transfer_one_message(master, master->cur_msg);
-        if (ret) {
-                dev_err(&master->dev,
-                        "failed to transfer one message from queue\n");
-                return;
-        }
-}
-
-static int spi_init_queue(struct spi_master *master)
-{
-        struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
-
-        INIT_LIST_HEAD(&master->queue);
-        spin_lock_init(&master->queue_lock);
-
-        master->running = false;
-        master->busy = false;
-
-        init_kthread_worker(&master->kworker);
-        master->kworker_task = kthread_run(kthread_worker_fn,
-                                           &master->kworker,
-                                           dev_name(&master->dev));
-        if (IS_ERR(master->kworker_task)) {
-                dev_err(&master->dev, "failed to create message pump task\n");
-                return -ENOMEM;
-        }
-        init_kthread_work(&master->pump_messages, spi_pump_messages);
-
-        /*
-         * Master config will indicate if this controller should run the
-         * message pump with high (realtime) priority to reduce the transfer
-         * latency on the bus by minimising the delay between a transfer
-         * request and the scheduling of the message pump thread. Without this
-         * setting the message pump thread will remain at default priority.
-         */
-        if (master->rt) {
-                dev_info(&master->dev,
-                        "will run message pump with realtime priority\n");
-                sched_setscheduler(master->kworker_task, SCHED_FIFO, &param);
-        }
-
-        return 0;
-}
-
-/**
- * spi_get_next_queued_message() - called by driver to check for queued
- * messages
- * @master: the master to check for queued messages
- *
- * If there are more messages in the queue, the next message is returned from
- * this call.
- */
-struct spi_message *spi_get_next_queued_message(struct spi_master *master)
-{
-        struct spi_message *next;
-        unsigned long flags;
-
-        /* get a pointer to the next message, if any */
-        spin_lock_irqsave(&master->queue_lock, flags);
-        if (list_empty(&master->queue))
-                next = NULL;
-        else
-                next = list_entry(master->queue.next,
-                                  struct spi_message, queue);
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-
-        return next;
-}
-EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
-
-/**
- * spi_finalize_current_message() - the current message is complete
- * @master: the master to return the message to
- *
- * Called by the driver to notify the core that the message in the front of the
- * queue is complete and can be removed from the queue.
- */
-void spi_finalize_current_message(struct spi_master *master)
-{
-        struct spi_message *mesg;
-        unsigned long flags;
-
-        spin_lock_irqsave(&master->queue_lock, flags);
-        mesg = master->cur_msg;
-        master->cur_msg = NULL;
-
-        queue_kthread_work(&master->kworker, &master->pump_messages);
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-
-        mesg->state = NULL;
-        if (mesg->complete)
-                mesg->complete(mesg->context);
-}
-EXPORT_SYMBOL_GPL(spi_finalize_current_message);
-
-static int spi_start_queue(struct spi_master *master)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&master->queue_lock, flags);
-
-        if (master->running || master->busy) {
-                spin_unlock_irqrestore(&master->queue_lock, flags);
-                return -EBUSY;
-        }
-
-        master->running = true;
-        master->cur_msg = NULL;
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-
-        queue_kthread_work(&master->kworker, &master->pump_messages);
-
-        return 0;
-}
-
-static int spi_stop_queue(struct spi_master *master)
-{
-        unsigned long flags;
-        unsigned limit = 500;
-        int ret = 0;
-
-        spin_lock_irqsave(&master->queue_lock, flags);
-
-        /*
-         * This is a bit lame, but is optimized for the common execution path.
-         * A wait_queue on the master->busy could be used, but then the common
-         * execution path (pump_messages) would be required to call wake_up or
-         * friends on every SPI message. Do this instead.
-         */
-        while ((!list_empty(&master->queue) || master->busy) && limit--) {
-                spin_unlock_irqrestore(&master->queue_lock, flags);
-                msleep(10);
-                spin_lock_irqsave(&master->queue_lock, flags);
-        }
-
-        if (!list_empty(&master->queue) || master->busy)
-                ret = -EBUSY;
-        else
-                master->running = false;
-
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-
-        if (ret) {
-                dev_warn(&master->dev,
-                         "could not stop message queue\n");
-                return ret;
-        }
-        return ret;
-}
-
-static int spi_destroy_queue(struct spi_master *master)
-{
-        int ret;
-
-        ret = spi_stop_queue(master);
-
-        /*
-         * flush_kthread_worker will block until all work is done.
-         * If the reason that stop_queue timed out is that the work will never
-         * finish, then it does no good to call flush/stop thread, so
-         * return anyway.
-         */
-        if (ret) {
-                dev_err(&master->dev, "problem destroying queue\n");
-                return ret;
-        }
-
-        flush_kthread_worker(&master->kworker);
-        kthread_stop(master->kworker_task);
-
-        return 0;
-}
-
-/**
- * spi_queued_transfer - transfer function for queued transfers
- * @spi: spi device which is requesting transfer
- * @msg: spi message which is to handled is queued to driver queue
- */
-static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
-{
-        struct spi_master *master = spi->master;
-        unsigned long flags;
-
-        spin_lock_irqsave(&master->queue_lock, flags);
-
-        if (!master->running) {
-                spin_unlock_irqrestore(&master->queue_lock, flags);
-                return -ESHUTDOWN;
-        }
-        msg->actual_length = 0;
-        msg->status = -EINPROGRESS;
-
-        list_add_tail(&msg->queue, &master->queue);
-        if (master->running && !master->busy)
-                queue_kthread_work(&master->kworker, &master->pump_messages);
-
-        spin_unlock_irqrestore(&master->queue_lock, flags);
-        return 0;
-}
-
-static int spi_master_initialize_queue(struct spi_master *master)
-{
-        int ret;
-
-        master->queued = true;
-        master->transfer = spi_queued_transfer;
-
-        /* Initialize and start queue */
-        ret = spi_init_queue(master);
-        if (ret) {
-                dev_err(&master->dev, "problem initializing queue\n");
-                goto err_init_queue;
-        }
-        ret = spi_start_queue(master);
-        if (ret) {
-                dev_err(&master->dev, "problem starting queue\n");
-                goto err_start_queue;
-        }
-
-        return 0;
-
-err_start_queue:
-err_init_queue:
-        spi_destroy_queue(master);
-        return ret;
-}
-
-/*-------------------------------------------------------------------------*/
-
-#if defined(CONFIG_OF)
-/**
- * of_register_spi_devices() - Register child devices onto the SPI bus
- * @master:     Pointer to spi_master device
- *
- * Registers an spi_device for each child node of master node which has a 'reg'
- * property.
- */
-static void of_register_spi_devices(struct spi_master *master)
-{
-        struct spi_device *spi;
-        struct device_node *nc;
-        const __be32 *prop;
-        char modalias[SPI_NAME_SIZE + 4];
-        int rc;
-        int len;
-
-        if (!master->dev.of_node)
-                return;
-
-        for_each_available_child_of_node(master->dev.of_node, nc) {
-                /* Alloc an spi_device */
-                spi = spi_alloc_device(master);
-                if (!spi) {
-                        dev_err(&master->dev, "spi_device alloc error for %s\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-
-                /* Select device driver */
-                if (of_modalias_node(nc, spi->modalias,
-                                     sizeof(spi->modalias)) < 0) {
-                        dev_err(&master->dev, "cannot find modalias for %s\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-
-                /* Device address */
-                prop = of_get_property(nc, "reg", &len);
-                if (!prop || len < sizeof(*prop)) {
-                        dev_err(&master->dev, "%s has no 'reg' property\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-                spi->chip_select = be32_to_cpup(prop);
-
-                /* Mode (clock phase/polarity/etc.) */
-                if (of_find_property(nc, "spi-cpha", NULL))
-                        spi->mode |= SPI_CPHA;
-                if (of_find_property(nc, "spi-cpol", NULL))
-                        spi->mode |= SPI_CPOL;
-                if (of_find_property(nc, "spi-cs-high", NULL))
-                        spi->mode |= SPI_CS_HIGH;
-                if (of_find_property(nc, "spi-3wire", NULL))
-                        spi->mode |= SPI_3WIRE;
-
-                /* Device speed */
-                prop = of_get_property(nc, "spi-max-frequency", &len);
-                if (!prop || len < sizeof(*prop)) {
-                        dev_err(&master->dev, "%s has no 'spi-max-frequency' property\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                        continue;
-                }
-                spi->max_speed_hz = be32_to_cpup(prop);
-
-                /* IRQ */
-                spi->irq = irq_of_parse_and_map(nc, 0);
-
-                /* Store a pointer to the node in the device structure */
-                of_node_get(nc);
-                spi->dev.of_node = nc;
-
-                /* Register the new device */
-                snprintf(modalias, sizeof(modalias), "%s%s", SPI_MODULE_PREFIX,
-                         spi->modalias);
-                request_module(modalias);
-                rc = spi_add_device(spi);
-                if (rc) {
-                        dev_err(&master->dev, "spi_device register error %s\n",
-                                nc->full_name);
-                        spi_dev_put(spi);
-                }
-
-        }
-}
-#else
-static void of_register_spi_devices(struct spi_master *master) { }
-#endif
-
-#ifdef CONFIG_ACPI
-static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
-{
-        struct spi_device *spi = data;
-
-        if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
-                struct acpi_resource_spi_serialbus *sb;
-
-                sb = &ares->data.spi_serial_bus;
-                if (sb->type == ACPI_RESOURCE_SERIAL_TYPE_SPI) {
-                        spi->chip_select = sb->device_selection;
-                        spi->max_speed_hz = sb->connection_speed;
-
-                        if (sb->clock_phase == ACPI_SPI_SECOND_PHASE)
-                                spi->mode |= SPI_CPHA;
-                        if (sb->clock_polarity == ACPI_SPI_START_HIGH)
-                                spi->mode |= SPI_CPOL;
-                        if (sb->device_polarity == ACPI_SPI_ACTIVE_HIGH)
-                                spi->mode |= SPI_CS_HIGH;
-                }
-        } else if (spi->irq < 0) {
-                struct resource r;
-
-                if (acpi_dev_resource_interrupt(ares, 0, &r))
-                        spi->irq = r.start;
-        }
-
-        /* Always tell the ACPI core to skip this resource */
-        return 1;
-}
-
-static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
-                                       void *data, void **return_value)
-{
-        struct spi_master *master = data;
-        struct list_head resource_list;
-        struct acpi_device *adev;
-        struct spi_device *spi;
-        int ret;
-
-        if (acpi_bus_get_device(handle, &adev))
-                return AE_OK;
-        if (acpi_bus_get_status(adev) || !adev->status.present)
-                return AE_OK;
-
-        spi = spi_alloc_device(master);
-        if (!spi) {
-                dev_err(&master->dev, "failed to allocate SPI device for %s\n",
-                        dev_name(&adev->dev));
-                return AE_NO_MEMORY;
-        }
-
-        ACPI_HANDLE_SET(&spi->dev, handle);
-        spi->irq = -1;
-
-        INIT_LIST_HEAD(&resource_list);
-        ret = acpi_dev_get_resources(adev, &resource_list,
-                                     acpi_spi_add_resource, spi);
-        acpi_dev_free_resource_list(&resource_list);
-
-        if (ret < 0 || !spi->max_speed_hz) {
-                spi_dev_put(spi);
-                return AE_OK;
-        }
-
-        strlcpy(spi->modalias, dev_name(&adev->dev), sizeof(spi->modalias));
-        if (spi_add_device(spi)) {
-                dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
-                        dev_name(&adev->dev));
-                spi_dev_put(spi);
-        }
-
-        return AE_OK;
-}
-
-static void acpi_register_spi_devices(struct spi_master *master)
-{
-        acpi_status status;
-        acpi_handle handle;
-
-        handle = ACPI_HANDLE(&master->dev);
-        if (!handle)
-                return;
-
-        status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
-                                     acpi_spi_add_device, NULL,
-                                     master, NULL);
-        if (ACPI_FAILURE(status))
-                dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
-}
-#else
-static inline void acpi_register_spi_devices(struct spi_master *master) {}
-#endif /* CONFIG_ACPI */
-
 static void spi_master_release(struct device *dev)
 {
         struct spi_master *master;
@@ -1013,7 +521,6 @@ static struct class spi_master_class = {
 };
 
 
-
 /**
  * spi_alloc_master - allocate SPI master controller
  * @dev: the controller, possibly using the platform_bus
@@ -1031,8 +538,7 @@ static struct class spi_master_class = {
  *
  * The caller is responsible for assigning the bus number and initializing
  * the master's methods before calling spi_register_master(); and (after errors
- * adding the device) calling spi_master_put() and kfree() to prevent a memory
- * leak.
+ * adding the device) calling spi_master_put() to prevent a memory leak.
  */
 struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
 {
@@ -1046,8 +552,6 @@ struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
                 return NULL;
 
         device_initialize(&master->dev);
-        master->bus_num = -1;
-        master->num_chipselect = 1;
         master->dev.class = &spi_master_class;
         master->dev.parent = get_device(dev);
         spi_master_set_devdata(master, &master[1]);
@@ -1056,44 +560,6 @@ struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
 }
 EXPORT_SYMBOL_GPL(spi_alloc_master);
 
-#ifdef CONFIG_OF
-static int of_spi_register_master(struct spi_master *master)
-{
-        u16 nb;
-        int i, *cs;
-        struct device_node *np = master->dev.of_node;
-
-        if (!np)
-                return 0;
-
-        nb = of_gpio_named_count(np, "cs-gpios");
-        master->num_chipselect = max(nb, master->num_chipselect);
-
-        if (nb < 1)
-                return 0;
-
-        cs = devm_kzalloc(&master->dev,
-                          sizeof(int) * master->num_chipselect,
-                          GFP_KERNEL);
-        master->cs_gpios = cs;
-
-        if (!master->cs_gpios)
-                return -ENOMEM;
-
-        memset(cs, -EINVAL, master->num_chipselect);
-
-        for (i = 0; i < nb; i++)
-                cs[i] = of_get_named_gpio(np, "cs-gpios", i);
-
-        return 0;
-}
-#else
-static int of_spi_register_master(struct spi_master *master)
-{
-        return 0;
-}
-#endif
-
 /**
  * spi_register_master - register SPI master controller
  * @master: initialized master, originally from spi_alloc_master()
@@ -1125,10 +591,6 @@ int spi_register_master(struct spi_master *master)
         if (!dev)
                 return -ENODEV;
 
-        status = of_spi_register_master(master);
-        if (status)
-                return status;
-
         /* even if it's just one always-selected device, there must
          * be at least one chipselect
          */
@@ -1158,31 +620,22 @@ int spi_register_master(struct spi_master *master)
         dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
                         dynamic ? " (dynamic)" : "");
 
-        /* If we're using a queued driver, start the queue */
-        if (master->transfer)
-                dev_info(dev, "master is unqueued, this is deprecated\n");
-        else {
-                status = spi_master_initialize_queue(master);
-                if (status) {
-                        device_unregister(&master->dev);
-                        goto done;
-                }
-        }
-
         mutex_lock(&board_lock);
         list_add_tail(&master->list, &spi_master_list);
         list_for_each_entry(bi, &board_list, list)
                 spi_match_master_to_boardinfo(master, &bi->board_info);
         mutex_unlock(&board_lock);
 
-        /* Register devices from the device tree and ACPI */
+        status = 0;
+
+        /* Register devices from the device tree */
         of_register_spi_devices(master);
-        acpi_register_spi_devices(master);
 done:
         return status;
 }
 EXPORT_SYMBOL_GPL(spi_register_master);
 
+
 static int __unregister(struct device *dev, void *null)
 {
         spi_unregister_device(to_spi_device(dev));
@@ -1203,11 +656,6 @@ void spi_unregister_master(struct spi_master *master)
 {
         int dummy;
 
-        if (master->queued) {
-                if (spi_destroy_queue(master))
-                        dev_err(&master->dev, "queue remove failed\n");
-        }
-
         mutex_lock(&board_lock);
         list_del(&master->list);
         mutex_unlock(&board_lock);
@@ -1217,37 +665,6 @@ void spi_unregister_master(struct spi_master *master)
 }
 EXPORT_SYMBOL_GPL(spi_unregister_master);
 
-int spi_master_suspend(struct spi_master *master)
-{
-        int ret;
-
-        /* Basically no-ops for non-queued masters */
-        if (!master->queued)
-                return 0;
-
-        ret = spi_stop_queue(master);
-        if (ret)
-                dev_err(&master->dev, "queue stop failed\n");
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(spi_master_suspend);
-
-int spi_master_resume(struct spi_master *master)
-{
-        int ret;
-
-        if (!master->queued)
-                return 0;
-
-        ret = spi_start_queue(master);
-        if (ret)
-                dev_err(&master->dev, "queue restart failed\n");
-
-        return ret;
-}
-EXPORT_SYMBOL_GPL(spi_master_resume);
-
 static int __spi_master_match(struct device *dev, void *data)
 {
         struct spi_master *m;
@@ -1309,7 +726,7 @@ EXPORT_SYMBOL_GPL(spi_busnum_to_master);
 int spi_setup(struct spi_device *spi)
 {
         unsigned        bad_bits;
-        int             status = 0;
+        int             status;
 
         /* help drivers fail *cleanly* when they need options
          * that aren't supported with their current master
@@ -1324,8 +741,7 @@ int spi_setup(struct spi_device *spi)
         if (!spi->bits_per_word)
                 spi->bits_per_word = 8;
 
-        if (spi->master->setup)
-                status = spi->master->setup(spi);
+        status = spi->master->setup(spi);
 
         dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
                                 "%u bits/w, %u Hz max --> %d\n",
@@ -1344,7 +760,6 @@ EXPORT_SYMBOL_GPL(spi_setup);
 static int __spi_async(struct spi_device *spi, struct spi_message *message)
 {
         struct spi_master *master = spi->master;
-        struct spi_transfer *xfer;
 
         /* Half-duplex links include original MicroWire, and ones with
          * only one data pin like SPI_3WIRE (switches direction) or where
@@ -1353,6 +768,7 @@ static int __spi_async(struct spi_device *spi, struct spi_message *message)
          */
         if ((master->flags & SPI_MASTER_HALF_DUPLEX)
                         || (spi->mode & SPI_3WIRE)) {
+                struct spi_transfer *xfer;
                 unsigned flags = master->flags;
 
                 list_for_each_entry(xfer, &message->transfers, transfer_list) {
@@ -1365,15 +781,6 @@ static int __spi_async(struct spi_device *spi, struct spi_message *message)
                 }
         }
 
-        /**
-         * Set transfer bits_per_word as spi device default if it is not
-         * set for this transfer.
-         */
-        list_for_each_entry(xfer, &message->transfers, transfer_list) {
-                if (!xfer->bits_per_word)
-                        xfer->bits_per_word = spi->bits_per_word;
-        }
-
         message->spi = spi;
         message->status = -EINPROGRESS;
         return master->transfer(spi, message);
@@ -1650,18 +1057,12 @@ int spi_write_then_read(struct spi_device *spi,
         struct spi_transfer     x[2];
         u8                      *local_buf;
 
-        /* Use preallocated DMA-safe buffer if we can.  We can't avoid
-         * copying here, (as a pure convenience thing), but we can
-         * keep heap costs out of the hot path unless someone else is
-         * using the pre-allocated buffer or the transfer is too large.
+        /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
+         * (as a pure convenience thing), but we can keep heap costs
+         * out of the hot path ...
          */
-        if ((n_tx + n_rx) > SPI_BUFSIZ || !mutex_trylock(&lock)) {
-                local_buf = kmalloc(max((unsigned)SPI_BUFSIZ, n_tx + n_rx), GFP_KERNEL);
-                if (!local_buf)
-                        return -ENOMEM;
-        } else {
-                local_buf = buf;
-        }
+        if ((n_tx + n_rx) > SPI_BUFSIZ)
+                return -EINVAL;
 
         spi_message_init(&message);
         memset(x, 0, sizeof x);
@@ -1674,6 +1075,14 @@ int spi_write_then_read(struct spi_device *spi,
                 spi_message_add_tail(&x[1], &message);
         }
 
+        /* ... unless someone else is using the pre-allocated buffer */
+        if (!mutex_trylock(&lock)) {
+                local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
+                if (!local_buf)
+                        return -ENOMEM;
+        } else
+                local_buf = buf;
+
         memcpy(local_buf, txbuf, n_tx);
         x[0].tx_buf = local_buf;
         x[1].rx_buf = local_buf + n_tx;
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 2e0655dbe07..830adbed1d7 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -31,8 +31,6 @@
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/compat.h>
-#include <linux/of.h>
-#include <linux/of_device.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spidev.h>
@@ -573,7 +571,7 @@ static struct class *spidev_class;
 
 /*-------------------------------------------------------------------------*/
 
-static int spidev_probe(struct spi_device *spi)
+static int __devinit spidev_probe(struct spi_device *spi)
 {
         struct spidev_data      *spidev;
         int                     status;
@@ -622,7 +620,7 @@ static int spidev_probe(struct spi_device *spi)
         return status;
 }
 
-static int spidev_remove(struct spi_device *spi)
+static int __devexit spidev_remove(struct spi_device *spi)
 {
         struct spidev_data      *spidev = spi_get_drvdata(spi);
 
@@ -644,21 +642,13 @@ static int spidev_remove(struct spi_device *spi)
         return 0;
 }
 
-static const struct of_device_id spidev_dt_ids[] = {
-        { .compatible = "rohm,dh2228fv" },
-        {},
-};
-
-MODULE_DEVICE_TABLE(of, spidev_dt_ids);
-
 static struct spi_driver spidev_spi_driver = {
         .driver = {
                 .name =         "spidev",
                 .owner =        THIS_MODULE,
-                .of_match_table = of_match_ptr(spidev_dt_ids),
         },
         .probe =        spidev_probe,
-        .remove =       spidev_remove,
+        .remove =       __devexit_p(spidev_remove),
 
         /* NOTE:  suspend/resume methods are not necessary here.
          * We don't do anything except pass the requests to/from