Merge tag 'spi-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi

Pull spi updates from Mark Brown:
 "The major highlight this release is a refactoring of the core to allow
  us to run synchronous transfers in the context of the caller when
  there is no contention for the bus.  This improves performance in the
  very common case by eliminating context switches and reducing the
  number of hardware setup and teardown operations we need to perform.

  Other changes:

   - New drivers for DLN-2 USB-SPI adapter and ST SPI controllers.

   - A big round of cleanups, performance and feature improvements for
     the xilinx driver from Ricardo Ribalda Delgado.

   - A wide range of smaller cleanups, fixes and feature improvements
     throughout the subsystem"

* tag 'spi-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi: (68 commits)
  spi: mxs: cleanup wait_for_completion return handling
  spi: ti-qspi: cleanup wait_for_completion return handling
  spi: spi-imx: cleanup wait_for_completion handling
  spi: sh-msiof: cleanup wait_for_completion return handling
  spi: match var type to return type of wait_for_completion
  spi: spi-pxa2xx: only include mach/dma.h for legacy DMA
  spi: atmel: cleanup wait_for_completion return handling
  spi: fsl-dspi: Remove possible memory leak of 'chip'
  spi: sh-msiof: Update calculation of frequency dividing
  spi: spidev: Convert buf pointers for 32-bit compat SPI_IOC_MESSAGE(n)
  spi/xilinx: Fix access invalid memory on xilinx_spi_tx
  spi: Revert "spi/xilinx: Remove iowrite/ioread wrappers"
  spi/xilinx: Check number of slaves range
  spi/xilinx: Use polling mode on small transfers
  spi/xilinx: Remove remaining_words driver data variable
  spi/xilinx: Remove iowrite/ioread wrappers
  spi/xilinx: Convert bits_per_word in bytes_per_word
  spi/xilinx: Convert remainding_bytes in remaining words
  spi/xilinx: Make spi_tx and spi_rx simmetric
  spi/xilinx: Remove rx_fn and tx_fn pointer
  ...

64 files changed, 2300 insertions, 741 deletions

diff --git a/Documentation/devicetree/bindings/spi/sh-msiof.txt b/Documentation/devicetree/bindings/spi/sh-msiof.txt
index d11c3721e7cd..4c388bb2f0a2 100644
--- a/Documentation/devicetree/bindings/spi/sh-msiof.txt
+++ b/Documentation/devicetree/bindings/spi/sh-msiof.txt
@@ -30,6 +30,22 @@ Optional properties:
                          specifiers, one for transmission, and one for
                          reception.
 - dma-names            : Must contain a list of two DMA names, "tx" and "rx".
+- renesas,dtdl         : delay sync signal (setup) in transmit mode.
+                         Must contain one of the following values:
+                         0   (no bit delay)
+                         50  (0.5-clock-cycle delay)
+                         100 (1-clock-cycle delay)
+                         150 (1.5-clock-cycle delay)
+                         200 (2-clock-cycle delay)
+
+- renesas,syncdl       : delay sync signal (hold) in transmit mode.
+                         Must contain one of the following values:
+                         0   (no bit delay)
+                         50  (0.5-clock-cycle delay)
+                         100 (1-clock-cycle delay)
+                         150 (1.5-clock-cycle delay)
+                         200 (2-clock-cycle delay)
+                         300 (3-clock-cycle delay)
 
 Optional properties, deprecated for soctype-specific bindings:
 - renesas,tx-fifo-size : Overrides the default tx fifo size given in words
diff --git a/Documentation/devicetree/bindings/spi/spi-sirf.txt b/Documentation/devicetree/bindings/spi/spi-sirf.txt
new file mode 100644
index 000000000000..4c7adb8f777c
--- /dev/null
+++ b/Documentation/devicetree/bindings/spi/spi-sirf.txt
@@ -0,0 +1,41 @@
+* CSR SiRFprimaII Serial Peripheral Interface
+
+Required properties:
+- compatible : Should be "sirf,prima2-spi"
+- reg : Offset and length of the register set for the device
+- interrupts : Should contain SPI interrupt
+- resets: phandle to the reset controller asserting this device in
+          reset
+  See ../reset/reset.txt for details.
+- dmas : Must contain an entry for each entry in clock-names.
+  See ../dma/dma.txt for details.
+- dma-names : Must include the following entries:
+  - rx
+  - tx
+- clocks : Must contain an entry for each entry in clock-names.
+  See ../clocks/clock-bindings.txt for details.
+
+- #address-cells: Number of cells required to define a chip select
+                  address on the SPI bus. Should be set to 1.
+- #size-cells:    Should be zero.
+
+Optional properties:
+- spi-max-frequency: Specifies maximum SPI clock frequency,
+                     Units - Hz. Definition as per
+                     Documentation/devicetree/bindings/spi/spi-bus.txt
+- cs-gpios:     should specify GPIOs used for chipselects.
+
+Example:
+
+spi0: spi@b00d0000 {
+        compatible = "sirf,prima2-spi";
+        reg = <0xb00d0000 0x10000>;
+        interrupts = <15>;
+        dmas = <&dmac1 9>,
+                <&dmac1 4>;
+        dma-names = "rx", "tx";
+        #address-cells = <1>;
+        #size-cells = <0>;
+        clocks = <&clks 19>;
+        resets = <&rstc 26>;
+};
diff --git a/Documentation/devicetree/bindings/spi/spi-st-ssc.txt b/Documentation/devicetree/bindings/spi/spi-st-ssc.txt
new file mode 100644
index 000000000000..fe54959ec957
--- /dev/null
+++ b/Documentation/devicetree/bindings/spi/spi-st-ssc.txt
@@ -0,0 +1,40 @@
+STMicroelectronics SSC (SPI) Controller
+---------------------------------------
+
+Required properties:
+- compatible    : "st,comms-ssc4-spi"
+- reg           : Offset and length of the device's register set
+- interrupts    : The interrupt specifier
+- clock-names   : Must contain "ssc"
+- clocks        : Must contain an entry for each name in clock-names
+                    See ../clk/*
+- pinctrl-names : Uses "default", can use "sleep" if provided
+                    See ../pinctrl/pinctrl-binding.txt
+
+Optional properties:
+- cs-gpios      : List of GPIO chip selects
+                    See ../spi/spi-bus.txt
+
+Child nodes represent devices on the SPI bus
+  See ../spi/spi-bus.txt
+
+Example:
+        spi@9840000 {
+                compatible      = "st,comms-ssc4-spi";
+                reg             = <0x9840000 0x110>;
+                interrupts      = <GIC_SPI 112 IRQ_TYPE_LEVEL_HIGH>;
+                clocks          = <&clk_s_c0_flexgen CLK_EXT2F_A9>;
+                clock-names     = "ssc";
+                pinctrl-0       = <&pinctrl_spi0_default>;
+                pinctrl-names   = "default";
+                cs-gpios        = <&pio17 5 0>;
+                #address-cells  = <1>;
+                #size-cells     = <0>;
+
+                st95hf@0{
+                        compatible              = "st,st95hf";
+                        reg                     = <0>;
+                        spi-max-frequency       = <1000000>;
+                        interrupts              = <2 IRQ_TYPE_EDGE_FALLING>;
+                };
+        };
diff --git a/arch/x86/pci/intel_mid_pci.c b/arch/x86/pci/intel_mid_pci.c
index 44b9271580b5..852aa4c92da0 100644
--- a/arch/x86/pci/intel_mid_pci.c
+++ b/arch/x86/pci/intel_mid_pci.c
@@ -293,7 +293,6 @@ static void mrst_power_off_unused_dev(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0801, mrst_power_off_unused_dev);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0809, mrst_power_off_unused_dev);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x080C, mrst_power_off_unused_dev);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0812, mrst_power_off_unused_dev);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0815, mrst_power_off_unused_dev);
 
 /*
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 99829985c1a1..95ccedabba4f 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -185,6 +185,16 @@ config SPI_DAVINCI
         help
           SPI master controller for DaVinci/DA8x/OMAP-L/AM1x SPI modules.
 
+config SPI_DLN2
+       tristate "Diolan DLN-2 USB SPI adapter"
+       depends on MFD_DLN2
+       help
+         If you say yes to this option, support will be included for Diolan
+         DLN2, a USB to SPI interface.
+
+         This driver can also be built as a module.  If so, the module
+         will be called spi-dln2.
+
 config SPI_EFM32
         tristate "EFM32 SPI controller"
         depends on OF && ARM && (ARCH_EFM32 || COMPILE_TEST)
@@ -279,7 +289,7 @@ config SPI_FSL_CPM
         depends on FSL_SOC
 
 config SPI_FSL_SPI
-        bool "Freescale SPI controller and Aeroflex Gaisler GRLIB SPI controller"
+        tristate "Freescale SPI controller and Aeroflex Gaisler GRLIB SPI controller"
         depends on OF
         select SPI_FSL_LIB
         select SPI_FSL_CPM if FSL_SOC
@@ -292,7 +302,6 @@ config SPI_FSL_SPI
 
 config SPI_FSL_DSPI
         tristate "Freescale DSPI controller"
-        select SPI_BITBANG
         select REGMAP_MMIO
         depends on SOC_VF610 || COMPILE_TEST
         help
@@ -300,7 +309,7 @@ config SPI_FSL_DSPI
           mode. VF610 platform uses the controller.
 
 config SPI_FSL_ESPI
-        bool "Freescale eSPI controller"
+        tristate "Freescale eSPI controller"
         depends on FSL_SOC
         select SPI_FSL_LIB
         help
@@ -460,7 +469,6 @@ config SPI_S3C24XX_FIQ
 config SPI_S3C64XX
         tristate "Samsung S3C64XX series type SPI"
         depends on (PLAT_SAMSUNG || ARCH_EXYNOS)
-        select S3C64XX_PL080 if ARCH_S3C64XX
         help
           SPI driver for Samsung S3C64XX and newer SoCs.
 
@@ -503,6 +511,13 @@ config SPI_SIRF
         help
           SPI driver for CSR SiRFprimaII SoCs
 
+config SPI_ST_SSC4
+        tristate "STMicroelectronics SPI SSC-based driver"
+        depends on ARCH_STI
+        help
+          STMicroelectronics SoCs support for SPI. If you say yes to
+          this option, support will be included for the SSC driven SPI.
+
 config SPI_SUN4I
         tristate "Allwinner A10 SoCs SPI controller"
         depends on ARCH_SUNXI || COMPILE_TEST
@@ -595,7 +610,6 @@ config SPI_XTENSA_XTFPGA
           16 bit words in SPI mode 0, automatically asserting CS on transfer
           start and deasserting on end.
 
-
 config SPI_NUC900
         tristate "Nuvoton NUC900 series SPI"
         depends on ARCH_W90X900
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 6b9d2ac629cc..d8cbf654976b 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_SPI_CADENCE)		+= spi-cadence.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_DLN2)                  += spi-dln2.o
 obj-$(CONFIG_SPI_DESIGNWARE)            += spi-dw.o
 obj-$(CONFIG_SPI_DW_MMIO)               += spi-dw-mmio.o
 obj-$(CONFIG_SPI_DW_PCI)                += spi-dw-midpci.o
@@ -76,6 +77,7 @@ 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_ST_SSC4)               += spi-st-ssc4.o
 obj-$(CONFIG_SPI_SUN4I)                 += spi-sun4i.o
 obj-$(CONFIG_SPI_SUN6I)                 += spi-sun6i.o
 obj-$(CONFIG_SPI_TEGRA114)              += spi-tegra114.o
diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c
index 23d8f5f56579..9af7841f2e8c 100644
--- a/drivers/spi/spi-atmel.c
+++ b/drivers/spi/spi-atmel.c
@@ -1046,6 +1046,7 @@ static int atmel_spi_one_transfer(struct spi_master *master,
         struct atmel_spi_device *asd;
         int                     timeout;
         int                     ret;
+        unsigned long           dma_timeout;
 
         as = spi_master_get_devdata(master);
 
@@ -1103,15 +1104,12 @@ static int atmel_spi_one_transfer(struct spi_master *master,
 
                 /* interrupts are disabled, so free the lock for schedule */
                 atmel_spi_unlock(as);
-                ret = wait_for_completion_timeout(&as->xfer_completion,
-                                                        SPI_DMA_TIMEOUT);
+                dma_timeout = wait_for_completion_timeout(&as->xfer_completion,
+                                                          SPI_DMA_TIMEOUT);
                 atmel_spi_lock(as);
-                if (WARN_ON(ret == 0)) {
-                        dev_err(&spi->dev,
-                                "spi trasfer timeout, err %d\n", ret);
+                if (WARN_ON(dma_timeout == 0)) {
+                        dev_err(&spi->dev, "spi transfer timeout\n");
                         as->done_status = -EIO;
-                } else {
-                        ret = 0;
                 }
 
                 if (as->done_status)
diff --git a/drivers/spi/spi-au1550.c b/drivers/spi/spi-au1550.c
index 326f47973684..f45e085c01a6 100644
--- a/drivers/spi/spi-au1550.c
+++ b/drivers/spi/spi-au1550.c
@@ -15,10 +15,6 @@
  * 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/init.h>
diff --git a/drivers/spi/spi-bcm2835.c b/drivers/spi/spi-bcm2835.c
index 98aab457b24d..419a782ab6d5 100644
--- a/drivers/spi/spi-bcm2835.c
+++ b/drivers/spi/spi-bcm2835.c
@@ -17,10 +17,6 @@
  * 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/clk.h>
diff --git a/drivers/spi/spi-bcm63xx.c b/drivers/spi/spi-bcm63xx.c
index c20530982e26..e73e2b052c9c 100644
--- a/drivers/spi/spi-bcm63xx.c
+++ b/drivers/spi/spi-bcm63xx.c
@@ -13,10 +13,6 @@
  * 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>
diff --git a/drivers/spi/spi-bitbang.c b/drivers/spi/spi-bitbang.c
index dc7d2c2d643e..5ef6638d5e8a 100644
--- a/drivers/spi/spi-bitbang.c
+++ b/drivers/spi/spi-bitbang.c
@@ -10,10 +10,6 @@
  * 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/spinlock.h>
diff --git a/drivers/spi/spi-butterfly.c b/drivers/spi/spi-butterfly.c
index ee4f91ccd8fd..9a95862986c8 100644
--- a/drivers/spi/spi-butterfly.c
+++ b/drivers/spi/spi-butterfly.c
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
diff --git a/drivers/spi/spi-coldfire-qspi.c b/drivers/spi/spi-coldfire-qspi.c
index 41b5dc4445f6..688956ff5095 100644
--- a/drivers/spi/spi-coldfire-qspi.c
+++ b/drivers/spi/spi-coldfire-qspi.c
@@ -12,11 +12,6 @@
  * 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/kernel.h>
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index b3707badb1e5..5e991065f5b0 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -11,10 +11,6 @@
  * 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/interrupt.h>
diff --git a/drivers/spi/spi-dln2.c b/drivers/spi/spi-dln2.c
new file mode 100644
index 000000000000..3b7d91d94fea
--- /dev/null
+++ b/drivers/spi/spi-dln2.c
@@ -0,0 +1,881 @@
+/*
+ * Driver for the Diolan DLN-2 USB-SPI adapter
+ *
+ * Copyright (c) 2014 Intel Corporation
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/mfd/dln2.h>
+#include <linux/spi/spi.h>
+#include <linux/pm_runtime.h>
+#include <asm/unaligned.h>
+
+#define DLN2_SPI_MODULE_ID              0x02
+#define DLN2_SPI_CMD(cmd)               DLN2_CMD(cmd, DLN2_SPI_MODULE_ID)
+
+/* SPI commands */
+#define DLN2_SPI_GET_PORT_COUNT                 DLN2_SPI_CMD(0x00)
+#define DLN2_SPI_ENABLE                         DLN2_SPI_CMD(0x11)
+#define DLN2_SPI_DISABLE                        DLN2_SPI_CMD(0x12)
+#define DLN2_SPI_IS_ENABLED                     DLN2_SPI_CMD(0x13)
+#define DLN2_SPI_SET_MODE                       DLN2_SPI_CMD(0x14)
+#define DLN2_SPI_GET_MODE                       DLN2_SPI_CMD(0x15)
+#define DLN2_SPI_SET_FRAME_SIZE                 DLN2_SPI_CMD(0x16)
+#define DLN2_SPI_GET_FRAME_SIZE                 DLN2_SPI_CMD(0x17)
+#define DLN2_SPI_SET_FREQUENCY                  DLN2_SPI_CMD(0x18)
+#define DLN2_SPI_GET_FREQUENCY                  DLN2_SPI_CMD(0x19)
+#define DLN2_SPI_READ_WRITE                     DLN2_SPI_CMD(0x1A)
+#define DLN2_SPI_READ                           DLN2_SPI_CMD(0x1B)
+#define DLN2_SPI_WRITE                          DLN2_SPI_CMD(0x1C)
+#define DLN2_SPI_SET_DELAY_BETWEEN_SS           DLN2_SPI_CMD(0x20)
+#define DLN2_SPI_GET_DELAY_BETWEEN_SS           DLN2_SPI_CMD(0x21)
+#define DLN2_SPI_SET_DELAY_AFTER_SS             DLN2_SPI_CMD(0x22)
+#define DLN2_SPI_GET_DELAY_AFTER_SS             DLN2_SPI_CMD(0x23)
+#define DLN2_SPI_SET_DELAY_BETWEEN_FRAMES       DLN2_SPI_CMD(0x24)
+#define DLN2_SPI_GET_DELAY_BETWEEN_FRAMES       DLN2_SPI_CMD(0x25)
+#define DLN2_SPI_SET_SS                         DLN2_SPI_CMD(0x26)
+#define DLN2_SPI_GET_SS                         DLN2_SPI_CMD(0x27)
+#define DLN2_SPI_RELEASE_SS                     DLN2_SPI_CMD(0x28)
+#define DLN2_SPI_SS_VARIABLE_ENABLE             DLN2_SPI_CMD(0x2B)
+#define DLN2_SPI_SS_VARIABLE_DISABLE            DLN2_SPI_CMD(0x2C)
+#define DLN2_SPI_SS_VARIABLE_IS_ENABLED         DLN2_SPI_CMD(0x2D)
+#define DLN2_SPI_SS_AAT_ENABLE                  DLN2_SPI_CMD(0x2E)
+#define DLN2_SPI_SS_AAT_DISABLE                 DLN2_SPI_CMD(0x2F)
+#define DLN2_SPI_SS_AAT_IS_ENABLED              DLN2_SPI_CMD(0x30)
+#define DLN2_SPI_SS_BETWEEN_FRAMES_ENABLE       DLN2_SPI_CMD(0x31)
+#define DLN2_SPI_SS_BETWEEN_FRAMES_DISABLE      DLN2_SPI_CMD(0x32)
+#define DLN2_SPI_SS_BETWEEN_FRAMES_IS_ENABLED   DLN2_SPI_CMD(0x33)
+#define DLN2_SPI_SET_CPHA                       DLN2_SPI_CMD(0x34)
+#define DLN2_SPI_GET_CPHA                       DLN2_SPI_CMD(0x35)
+#define DLN2_SPI_SET_CPOL                       DLN2_SPI_CMD(0x36)
+#define DLN2_SPI_GET_CPOL                       DLN2_SPI_CMD(0x37)
+#define DLN2_SPI_SS_MULTI_ENABLE                DLN2_SPI_CMD(0x38)
+#define DLN2_SPI_SS_MULTI_DISABLE               DLN2_SPI_CMD(0x39)
+#define DLN2_SPI_SS_MULTI_IS_ENABLED            DLN2_SPI_CMD(0x3A)
+#define DLN2_SPI_GET_SUPPORTED_MODES            DLN2_SPI_CMD(0x40)
+#define DLN2_SPI_GET_SUPPORTED_CPHA_VALUES      DLN2_SPI_CMD(0x41)
+#define DLN2_SPI_GET_SUPPORTED_CPOL_VALUES      DLN2_SPI_CMD(0x42)
+#define DLN2_SPI_GET_SUPPORTED_FRAME_SIZES      DLN2_SPI_CMD(0x43)
+#define DLN2_SPI_GET_SS_COUNT                   DLN2_SPI_CMD(0x44)
+#define DLN2_SPI_GET_MIN_FREQUENCY              DLN2_SPI_CMD(0x45)
+#define DLN2_SPI_GET_MAX_FREQUENCY              DLN2_SPI_CMD(0x46)
+#define DLN2_SPI_GET_MIN_DELAY_BETWEEN_SS       DLN2_SPI_CMD(0x47)
+#define DLN2_SPI_GET_MAX_DELAY_BETWEEN_SS       DLN2_SPI_CMD(0x48)
+#define DLN2_SPI_GET_MIN_DELAY_AFTER_SS         DLN2_SPI_CMD(0x49)
+#define DLN2_SPI_GET_MAX_DELAY_AFTER_SS         DLN2_SPI_CMD(0x4A)
+#define DLN2_SPI_GET_MIN_DELAY_BETWEEN_FRAMES   DLN2_SPI_CMD(0x4B)
+#define DLN2_SPI_GET_MAX_DELAY_BETWEEN_FRAMES   DLN2_SPI_CMD(0x4C)
+
+#define DLN2_SPI_MAX_XFER_SIZE                  256
+#define DLN2_SPI_BUF_SIZE                       (DLN2_SPI_MAX_XFER_SIZE + 16)
+#define DLN2_SPI_ATTR_LEAVE_SS_LOW              BIT(0)
+#define DLN2_TRANSFERS_WAIT_COMPLETE            1
+#define DLN2_TRANSFERS_CANCEL                   0
+#define DLN2_RPM_AUTOSUSPEND_TIMEOUT            2000
+
+struct dln2_spi {
+        struct platform_device *pdev;
+        struct spi_master *master;
+        u8 port;
+
+        /*
+         * This buffer will be used mainly for read/write operations. Since
+         * they're quite large, we cannot use the stack. Protection is not
+         * needed because all SPI communication is serialized by the SPI core.
+         */
+        void *buf;
+
+        u8 bpw;
+        u32 speed;
+        u16 mode;
+        u8 cs;
+};
+
+/*
+ * Enable/Disable SPI module. The disable command will wait for transfers to
+ * complete first.
+ */
+static int dln2_spi_enable(struct dln2_spi *dln2, bool enable)
+{
+        u16 cmd;
+        struct {
+                u8 port;
+                u8 wait_for_completion;
+        } tx;
+        unsigned len = sizeof(tx);
+
+        tx.port = dln2->port;
+
+        if (enable) {
+                cmd = DLN2_SPI_ENABLE;
+                len -= sizeof(tx.wait_for_completion);
+        } else {
+                tx.wait_for_completion = DLN2_TRANSFERS_WAIT_COMPLETE;
+                cmd = DLN2_SPI_DISABLE;
+        }
+
+        return dln2_transfer_tx(dln2->pdev, cmd, &tx, len);
+}
+
+/*
+ * Select/unselect multiple CS lines. The selected lines will be automatically
+ * toggled LOW/HIGH by the board firmware during transfers, provided they're
+ * enabled first.
+ *
+ * Ex: cs_mask = 0x03 -> CS0 & CS1 will be selected and the next WR/RD operation
+ *                       will toggle the lines LOW/HIGH automatically.
+ */
+static int dln2_spi_cs_set(struct dln2_spi *dln2, u8 cs_mask)
+{
+        struct {
+                u8 port;
+                u8 cs;
+        } tx;
+
+        tx.port = dln2->port;
+
+        /*
+         * According to Diolan docs, "a slave device can be selected by changing
+         * the corresponding bit value to 0". The rest must be set to 1. Hence
+         * the bitwise NOT in front.
+         */
+        tx.cs = ~cs_mask;
+
+        return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_SS, &tx, sizeof(tx));
+}
+
+/*
+ * Select one CS line. The other lines will be un-selected.
+ */
+static int dln2_spi_cs_set_one(struct dln2_spi *dln2, u8 cs)
+{
+        return dln2_spi_cs_set(dln2, BIT(cs));
+}
+
+/*
+ * Enable/disable CS lines for usage. The module has to be disabled first.
+ */
+static int dln2_spi_cs_enable(struct dln2_spi *dln2, u8 cs_mask, bool enable)
+{
+        struct {
+                u8 port;
+                u8 cs;
+        } tx;
+        u16 cmd;
+
+        tx.port = dln2->port;
+        tx.cs = cs_mask;
+        cmd = enable ? DLN2_SPI_SS_MULTI_ENABLE : DLN2_SPI_SS_MULTI_DISABLE;
+
+        return dln2_transfer_tx(dln2->pdev, cmd, &tx, sizeof(tx));
+}
+
+static int dln2_spi_cs_enable_all(struct dln2_spi *dln2, bool enable)
+{
+        u8 cs_mask = GENMASK(dln2->master->num_chipselect - 1, 0);
+
+        return dln2_spi_cs_enable(dln2, cs_mask, enable);
+}
+
+static int dln2_spi_get_cs_num(struct dln2_spi *dln2, u16 *cs_num)
+{
+        int ret;
+        struct {
+                u8 port;
+        } tx;
+        struct {
+                __le16 cs_count;
+        } rx;
+        unsigned rx_len = sizeof(rx);
+
+        tx.port = dln2->port;
+        ret = dln2_transfer(dln2->pdev, DLN2_SPI_GET_SS_COUNT, &tx, sizeof(tx),
+                            &rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx))
+                return -EPROTO;
+
+        *cs_num = le16_to_cpu(rx.cs_count);
+
+        dev_dbg(&dln2->pdev->dev, "cs_num = %d\n", *cs_num);
+
+        return 0;
+}
+
+static int dln2_spi_get_speed(struct dln2_spi *dln2, u16 cmd, u32 *freq)
+{
+        int ret;
+        struct {
+                u8 port;
+        } tx;
+        struct {
+                __le32 speed;
+        } rx;
+        unsigned rx_len = sizeof(rx);
+
+        tx.port = dln2->port;
+
+        ret = dln2_transfer(dln2->pdev, cmd, &tx, sizeof(tx), &rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx))
+                return -EPROTO;
+
+        *freq = le32_to_cpu(rx.speed);
+
+        return 0;
+}
+
+/*
+ * Get bus min/max frequencies.
+ */
+static int dln2_spi_get_speed_range(struct dln2_spi *dln2, u32 *fmin, u32 *fmax)
+{
+        int ret;
+
+        ret = dln2_spi_get_speed(dln2, DLN2_SPI_GET_MIN_FREQUENCY, fmin);
+        if (ret < 0)
+                return ret;
+
+        ret = dln2_spi_get_speed(dln2, DLN2_SPI_GET_MAX_FREQUENCY, fmax);
+        if (ret < 0)
+                return ret;
+
+        dev_dbg(&dln2->pdev->dev, "freq_min = %d, freq_max = %d\n",
+                *fmin, *fmax);
+
+        return 0;
+}
+
+/*
+ * Set the bus speed. The module will automatically round down to the closest
+ * available frequency and returns it. The module has to be disabled first.
+ */
+static int dln2_spi_set_speed(struct dln2_spi *dln2, u32 speed)
+{
+        int ret;
+        struct {
+                u8 port;
+                __le32 speed;
+        } __packed tx;
+        struct {
+                __le32 speed;
+        } rx;
+        int rx_len = sizeof(rx);
+
+        tx.port = dln2->port;
+        tx.speed = cpu_to_le32(speed);
+
+        ret = dln2_transfer(dln2->pdev, DLN2_SPI_SET_FREQUENCY, &tx, sizeof(tx),
+                            &rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx))
+                return -EPROTO;
+
+        return 0;
+}
+
+/*
+ * Change CPOL & CPHA. The module has to be disabled first.
+ */
+static int dln2_spi_set_mode(struct dln2_spi *dln2, u8 mode)
+{
+        struct {
+                u8 port;
+                u8 mode;
+        } tx;
+
+        tx.port = dln2->port;
+        tx.mode = mode;
+
+        return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_MODE, &tx, sizeof(tx));
+}
+
+/*
+ * Change frame size. The module has to be disabled first.
+ */
+static int dln2_spi_set_bpw(struct dln2_spi *dln2, u8 bpw)
+{
+        struct {
+                u8 port;
+                u8 bpw;
+        } tx;
+
+        tx.port = dln2->port;
+        tx.bpw = bpw;
+
+        return dln2_transfer_tx(dln2->pdev, DLN2_SPI_SET_FRAME_SIZE,
+                                &tx, sizeof(tx));
+}
+
+static int dln2_spi_get_supported_frame_sizes(struct dln2_spi *dln2,
+                                              u32 *bpw_mask)
+{
+        int ret;
+        struct {
+                u8 port;
+        } tx;
+        struct {
+                u8 count;
+                u8 frame_sizes[36];
+        } *rx = dln2->buf;
+        unsigned rx_len = sizeof(*rx);
+        int i;
+
+        tx.port = dln2->port;
+
+        ret = dln2_transfer(dln2->pdev, DLN2_SPI_GET_SUPPORTED_FRAME_SIZES,
+                            &tx, sizeof(tx), rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(*rx))
+                return -EPROTO;
+        if (rx->count > ARRAY_SIZE(rx->frame_sizes))
+                return -EPROTO;
+
+        *bpw_mask = 0;
+        for (i = 0; i < rx->count; i++)
+                *bpw_mask |= BIT(rx->frame_sizes[i] - 1);
+
+        dev_dbg(&dln2->pdev->dev, "bpw_mask = 0x%X\n", *bpw_mask);
+
+        return 0;
+}
+
+/*
+ * Copy the data to DLN2 buffer and change the byte order to LE, requested by
+ * DLN2 module. SPI core makes sure that the data length is a multiple of word
+ * size.
+ */
+static int dln2_spi_copy_to_buf(u8 *dln2_buf, const u8 *src, u16 len, u8 bpw)
+{
+#ifdef __LITTLE_ENDIAN
+        memcpy(dln2_buf, src, len);
+#else
+        if (bpw <= 8) {
+                memcpy(dln2_buf, src, len);
+        } else if (bpw <= 16) {
+                __le16 *d = (__le16 *)dln2_buf;
+                u16 *s = (u16 *)src;
+
+                len = len / 2;
+                while (len--)
+                        *d++ = cpu_to_le16p(s++);
+        } else {
+                __le32 *d = (__le32 *)dln2_buf;
+                u32 *s = (u32 *)src;
+
+                len = len / 4;
+                while (len--)
+                        *d++ = cpu_to_le32p(s++);
+        }
+#endif
+
+        return 0;
+}
+
+/*
+ * Copy the data from DLN2 buffer and convert to CPU byte order since the DLN2
+ * buffer is LE ordered. SPI core makes sure that the data length is a multiple
+ * of word size. The RX dln2_buf is 2 byte aligned so, for BE, we have to make
+ * sure we avoid unaligned accesses for 32 bit case.
+ */
+static int dln2_spi_copy_from_buf(u8 *dest, const u8 *dln2_buf, u16 len, u8 bpw)
+{
+#ifdef __LITTLE_ENDIAN
+        memcpy(dest, dln2_buf, len);
+#else
+        if (bpw <= 8) {
+                memcpy(dest, dln2_buf, len);
+        } else if (bpw <= 16) {
+                u16 *d = (u16 *)dest;
+                __le16 *s = (__le16 *)dln2_buf;
+
+                len = len / 2;
+                while (len--)
+                        *d++ = le16_to_cpup(s++);
+        } else {
+                u32 *d = (u32 *)dest;
+                __le32 *s = (__le32 *)dln2_buf;
+
+                len = len / 4;
+                while (len--)
+                        *d++ = get_unaligned_le32(s++);
+        }
+#endif
+
+        return 0;
+}
+
+/*
+ * Perform one write operation.
+ */
+static int dln2_spi_write_one(struct dln2_spi *dln2, const u8 *data,
+                              u16 data_len, u8 attr)
+{
+        struct {
+                u8 port;
+                __le16 size;
+                u8 attr;
+                u8 buf[DLN2_SPI_MAX_XFER_SIZE];
+        } __packed *tx = dln2->buf;
+        unsigned tx_len;
+
+        BUILD_BUG_ON(sizeof(*tx) > DLN2_SPI_BUF_SIZE);
+
+        if (data_len > DLN2_SPI_MAX_XFER_SIZE)
+                return -EINVAL;
+
+        tx->port = dln2->port;
+        tx->size = cpu_to_le16(data_len);
+        tx->attr = attr;
+
+        dln2_spi_copy_to_buf(tx->buf, data, data_len, dln2->bpw);
+
+        tx_len = sizeof(*tx) + data_len - DLN2_SPI_MAX_XFER_SIZE;
+        return dln2_transfer_tx(dln2->pdev, DLN2_SPI_WRITE, tx, tx_len);
+}
+
+/*
+ * Perform one read operation.
+ */
+static int dln2_spi_read_one(struct dln2_spi *dln2, u8 *data,
+                             u16 data_len, u8 attr)
+{
+        int ret;
+        struct {
+                u8 port;
+                __le16 size;
+                u8 attr;
+        } __packed tx;
+        struct {
+                __le16 size;
+                u8 buf[DLN2_SPI_MAX_XFER_SIZE];
+        } __packed *rx = dln2->buf;
+        unsigned rx_len = sizeof(*rx);
+
+        BUILD_BUG_ON(sizeof(*rx) > DLN2_SPI_BUF_SIZE);
+
+        if (data_len > DLN2_SPI_MAX_XFER_SIZE)
+                return -EINVAL;
+
+        tx.port = dln2->port;
+        tx.size = cpu_to_le16(data_len);
+        tx.attr = attr;
+
+        ret = dln2_transfer(dln2->pdev, DLN2_SPI_READ, &tx, sizeof(tx),
+                            rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx->size) + data_len)
+                return -EPROTO;
+        if (le16_to_cpu(rx->size) != data_len)
+                return -EPROTO;
+
+        dln2_spi_copy_from_buf(data, rx->buf, data_len, dln2->bpw);
+
+        return 0;
+}
+
+/*
+ * Perform one write & read operation.
+ */
+static int dln2_spi_read_write_one(struct dln2_spi *dln2, const u8 *tx_data,
+                                   u8 *rx_data, u16 data_len, u8 attr)
+{
+        int ret;
+        struct {
+                u8 port;
+                __le16 size;
+                u8 attr;
+                u8 buf[DLN2_SPI_MAX_XFER_SIZE];
+        } __packed *tx;
+        struct {
+                __le16 size;
+                u8 buf[DLN2_SPI_MAX_XFER_SIZE];
+        } __packed *rx;
+        unsigned tx_len, rx_len;
+
+        BUILD_BUG_ON(sizeof(*tx) > DLN2_SPI_BUF_SIZE ||
+                     sizeof(*rx) > DLN2_SPI_BUF_SIZE);
+
+        if (data_len > DLN2_SPI_MAX_XFER_SIZE)
+                return -EINVAL;
+
+        /*
+         * Since this is a pseudo full-duplex communication, we're perfectly
+         * safe to use the same buffer for both tx and rx. When DLN2 sends the
+         * response back, with the rx data, we don't need the tx buffer anymore.
+         */
+        tx = dln2->buf;
+        rx = dln2->buf;
+
+        tx->port = dln2->port;
+        tx->size = cpu_to_le16(data_len);
+        tx->attr = attr;
+
+        dln2_spi_copy_to_buf(tx->buf, tx_data, data_len, dln2->bpw);
+
+        tx_len = sizeof(*tx) + data_len - DLN2_SPI_MAX_XFER_SIZE;
+        rx_len = sizeof(*rx);
+
+        ret = dln2_transfer(dln2->pdev, DLN2_SPI_READ_WRITE, tx, tx_len,
+                            rx, &rx_len);
+        if (ret < 0)
+                return ret;
+        if (rx_len < sizeof(rx->size) + data_len)
+                return -EPROTO;
+        if (le16_to_cpu(rx->size) != data_len)
+                return -EPROTO;
+
+        dln2_spi_copy_from_buf(rx_data, rx->buf, data_len, dln2->bpw);
+
+        return 0;
+}
+
+/*
+ * Read/Write wrapper. It will automatically split an operation into multiple
+ * single ones due to device buffer constraints.
+ */
+static int dln2_spi_rdwr(struct dln2_spi *dln2, const u8 *tx_data,
+                         u8 *rx_data, u16 data_len, u8 attr) {
+        int ret;
+        u16 len;
+        u8 temp_attr;
+        u16 remaining = data_len;
+        u16 offset;
+
+        do {
+                if (remaining > DLN2_SPI_MAX_XFER_SIZE) {
+                        len = DLN2_SPI_MAX_XFER_SIZE;
+                        temp_attr = DLN2_SPI_ATTR_LEAVE_SS_LOW;
+                } else {
+                        len = remaining;
+                        temp_attr = attr;
+                }
+
+                offset = data_len - remaining;
+
+                if (tx_data && rx_data) {
+                        ret = dln2_spi_read_write_one(dln2,
+                                                      tx_data + offset,
+                                                      rx_data + offset,
+                                                      len, temp_attr);
+                } else if (tx_data) {
+                        ret = dln2_spi_write_one(dln2,
+                                                 tx_data + offset,
+                                                 len, temp_attr);
+                } else if (rx_data) {
+                        ret = dln2_spi_read_one(dln2,
+                                                rx_data + offset,
+                                                len, temp_attr);
+                 } else {
+                        return -EINVAL;
+                 }
+
+                if (ret < 0)
+                        return ret;
+
+                remaining -= len;
+        } while (remaining);
+
+        return 0;
+}
+
+static int dln2_spi_prepare_message(struct spi_master *master,
+                                    struct spi_message *message)
+{
+        int ret;
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+        struct spi_device *spi = message->spi;
+
+        if (dln2->cs != spi->chip_select) {
+                ret = dln2_spi_cs_set_one(dln2, spi->chip_select);
+                if (ret < 0)
+                        return ret;
+
+                dln2->cs = spi->chip_select;
+        }
+
+        return 0;
+}
+
+static int dln2_spi_transfer_setup(struct dln2_spi *dln2, u32 speed,
+                                   u8 bpw, u8 mode)
+{
+        int ret;
+        bool bus_setup_change;
+
+        bus_setup_change = dln2->speed != speed || dln2->mode != mode ||
+                           dln2->bpw != bpw;
+
+        if (!bus_setup_change)
+                return 0;
+
+        ret = dln2_spi_enable(dln2, false);
+        if (ret < 0)
+                return ret;
+
+        if (dln2->speed != speed) {
+                ret = dln2_spi_set_speed(dln2, speed);
+                if (ret < 0)
+                        return ret;
+
+                dln2->speed = speed;
+        }
+
+        if (dln2->mode != mode) {
+                ret = dln2_spi_set_mode(dln2, mode & 0x3);
+                if (ret < 0)
+                        return ret;
+
+                dln2->mode = mode;
+        }
+
+        if (dln2->bpw != bpw) {
+                ret = dln2_spi_set_bpw(dln2, bpw);
+                if (ret < 0)
+                        return ret;
+
+                dln2->bpw = bpw;
+        }
+
+        return dln2_spi_enable(dln2, true);
+}
+
+static int dln2_spi_transfer_one(struct spi_master *master,
+                                 struct spi_device *spi,
+                                 struct spi_transfer *xfer)
+{
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+        int status;
+        u8 attr = 0;
+
+        status = dln2_spi_transfer_setup(dln2, xfer->speed_hz,
+                                         xfer->bits_per_word,
+                                         spi->mode);
+        if (status < 0) {
+                dev_err(&dln2->pdev->dev, "Cannot setup transfer\n");
+                return status;
+        }
+
+        if (!xfer->cs_change && !spi_transfer_is_last(master, xfer))
+                attr = DLN2_SPI_ATTR_LEAVE_SS_LOW;
+
+        status = dln2_spi_rdwr(dln2, xfer->tx_buf, xfer->rx_buf,
+                               xfer->len, attr);
+        if (status < 0)
+                dev_err(&dln2->pdev->dev, "write/read failed!\n");
+
+        return status;
+}
+
+static int dln2_spi_probe(struct platform_device *pdev)
+{
+        struct spi_master *master;
+        struct dln2_spi *dln2;
+        struct dln2_platform_data *pdata = dev_get_platdata(&pdev->dev);
+        int ret;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(*dln2));
+        if (!master)
+                return -ENOMEM;
+
+        platform_set_drvdata(pdev, master);
+
+        dln2 = spi_master_get_devdata(master);
+
+        dln2->buf = devm_kmalloc(&pdev->dev, DLN2_SPI_BUF_SIZE, GFP_KERNEL);
+        if (!dln2->buf) {
+                ret = -ENOMEM;
+                goto exit_free_master;
+        }
+
+        dln2->master = master;
+        dln2->pdev = pdev;
+        dln2->port = pdata->port;
+        /* cs/mode can never be 0xff, so the first transfer will set them */
+        dln2->cs = 0xff;
+        dln2->mode = 0xff;
+
+        /* disable SPI module before continuing with the setup */
+        ret = dln2_spi_enable(dln2, false);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to disable SPI module\n");
+                goto exit_free_master;
+        }
+
+        ret = dln2_spi_get_cs_num(dln2, &master->num_chipselect);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to get number of CS pins\n");
+                goto exit_free_master;
+        }
+
+        ret = dln2_spi_get_speed_range(dln2,
+                                       &master->min_speed_hz,
+                                       &master->max_speed_hz);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read bus min/max freqs\n");
+                goto exit_free_master;
+        }
+
+        ret = dln2_spi_get_supported_frame_sizes(dln2,
+                                                 &master->bits_per_word_mask);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to read supported frame sizes\n");
+                goto exit_free_master;
+        }
+
+        ret = dln2_spi_cs_enable_all(dln2, true);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to enable CS pins\n");
+                goto exit_free_master;
+        }
+
+        master->bus_num = -1;
+        master->mode_bits = SPI_CPOL | SPI_CPHA;
+        master->prepare_message = dln2_spi_prepare_message;
+        master->transfer_one = dln2_spi_transfer_one;
+        master->auto_runtime_pm = true;
+
+        /* enable SPI module, we're good to go */
+        ret = dln2_spi_enable(dln2, true);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to enable SPI module\n");
+                goto exit_free_master;
+        }
+
+        pm_runtime_set_autosuspend_delay(&pdev->dev,
+                                         DLN2_RPM_AUTOSUSPEND_TIMEOUT);
+        pm_runtime_use_autosuspend(&pdev->dev);
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        ret = devm_spi_register_master(&pdev->dev, master);
+        if (ret < 0) {
+                dev_err(&pdev->dev, "Failed to register master\n");
+                goto exit_register;
+        }
+
+        return ret;
+
+exit_register:
+        pm_runtime_disable(&pdev->dev);
+        pm_runtime_set_suspended(&pdev->dev);
+
+        if (dln2_spi_enable(dln2, false) < 0)
+                dev_err(&pdev->dev, "Failed to disable SPI module\n");
+exit_free_master:
+        spi_master_put(master);
+
+        return ret;
+}
+
+static int dln2_spi_remove(struct platform_device *pdev)
+{
+        struct spi_master *master = spi_master_get(platform_get_drvdata(pdev));
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+
+        pm_runtime_disable(&pdev->dev);
+
+        if (dln2_spi_enable(dln2, false) < 0)
+                dev_err(&pdev->dev, "Failed to disable SPI module\n");
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_SLEEP
+static int dln2_spi_suspend(struct device *dev)
+{
+        int ret;
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+
+        ret = spi_master_suspend(master);
+        if (ret < 0)
+                return ret;
+
+        if (!pm_runtime_suspended(dev)) {
+                ret = dln2_spi_enable(dln2, false);
+                if (ret < 0)
+                        return ret;
+        }
+
+        /*
+         * USB power may be cut off during sleep. Resetting the following
+         * parameters will force the board to be set up before first transfer.
+         */
+        dln2->cs = 0xff;
+        dln2->speed = 0;
+        dln2->bpw = 0;
+        dln2->mode = 0xff;
+
+        return 0;
+}
+
+static int dln2_spi_resume(struct device *dev)
+{
+        int ret;
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+
+        if (!pm_runtime_suspended(dev)) {
+                ret = dln2_spi_cs_enable_all(dln2, true);
+                if (ret < 0)
+                        return ret;
+
+                ret = dln2_spi_enable(dln2, true);
+                if (ret < 0)
+                        return ret;
+        }
+
+        return spi_master_resume(master);
+}
+#endif /* CONFIG_PM_SLEEP */
+
+#ifdef CONFIG_PM
+static int dln2_spi_runtime_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+
+        return dln2_spi_enable(dln2, false);
+}
+
+static int dln2_spi_runtime_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct dln2_spi *dln2 = spi_master_get_devdata(master);
+
+        return  dln2_spi_enable(dln2, true);
+}
+#endif /* CONFIG_PM */
+
+static const struct dev_pm_ops dln2_spi_pm = {
+        SET_SYSTEM_SLEEP_PM_OPS(dln2_spi_suspend, dln2_spi_resume)
+        SET_RUNTIME_PM_OPS(dln2_spi_runtime_suspend,
+                           dln2_spi_runtime_resume, NULL)
+};
+
+static struct platform_driver spi_dln2_driver = {
+        .driver = {
+                .name   = "dln2-spi",
+                .pm     = &dln2_spi_pm,
+        },
+        .probe          = dln2_spi_probe,
+        .remove         = dln2_spi_remove,
+};
+module_platform_driver(spi_dln2_driver);
+
+MODULE_DESCRIPTION("Driver for the Diolan DLN2 SPI master interface");
+MODULE_AUTHOR("Laurentiu Palcu <laurentiu.palcu@intel.com>");
+MODULE_LICENSE("GPL v2");
+MODULE_ALIAS("platform:dln2-spi");
diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c
index a67d37c7e3c0..a0197fd4e95c 100644
--- a/drivers/spi/spi-dw-mid.c
+++ b/drivers/spi/spi-dw-mid.c
@@ -247,9 +247,9 @@ static struct dw_spi_dma_ops mid_dma_ops = {
 
 /* Some specific info for SPI0 controller on Intel MID */
 
-/* HW info for MRST CLk Control Unit, one 32b reg */
+/* HW info for MRST Clk Control Unit, 32b reg per controller */
 #define MRST_SPI_CLK_BASE       100000000       /* 100m */
-#define MRST_CLK_SPI0_REG       0xff11d86c
+#define MRST_CLK_SPI_REG        0xff11d86c
 #define CLK_SPI_BDIV_OFFSET     0
 #define CLK_SPI_BDIV_MASK       0x00000007
 #define CLK_SPI_CDIV_OFFSET     9
@@ -261,16 +261,17 @@ int dw_spi_mid_init(struct dw_spi *dws)
         void __iomem *clk_reg;
         u32 clk_cdiv;
 
-        clk_reg = ioremap_nocache(MRST_CLK_SPI0_REG, 16);
+        clk_reg = ioremap_nocache(MRST_CLK_SPI_REG, 16);
         if (!clk_reg)
                 return -ENOMEM;
 
-        /* get SPI controller operating freq info */
-        clk_cdiv  = (readl(clk_reg) & CLK_SPI_CDIV_MASK) >> CLK_SPI_CDIV_OFFSET;
+        /* Get SPI controller operating freq info */
+        clk_cdiv = readl(clk_reg + dws->bus_num * sizeof(u32));
+        clk_cdiv &= CLK_SPI_CDIV_MASK;
+        clk_cdiv >>= CLK_SPI_CDIV_OFFSET;
         dws->max_freq = MRST_SPI_CLK_BASE / (clk_cdiv + 1);
-        iounmap(clk_reg);
 
-        dws->num_cs = 16;
+        iounmap(clk_reg);
 
 #ifdef CONFIG_SPI_DW_MID_DMA
         dws->dma_priv = kzalloc(sizeof(struct mid_dma), GFP_KERNEL);
diff --git a/drivers/spi/spi-dw-pci.c b/drivers/spi/spi-dw-pci.c
index ba68da12cdf0..5ba331047cbe 100644
--- a/drivers/spi/spi-dw-pci.c
+++ b/drivers/spi/spi-dw-pci.c
@@ -30,10 +30,20 @@ struct dw_spi_pci {
 
 struct spi_pci_desc {
         int     (*setup)(struct dw_spi *);
+        u16     num_cs;
+        u16     bus_num;
 };
 
-static struct spi_pci_desc spi_pci_mid_desc = {
+static struct spi_pci_desc spi_pci_mid_desc_1 = {
         .setup = dw_spi_mid_init,
+        .num_cs = 32,
+        .bus_num = 0,
+};
+
+static struct spi_pci_desc spi_pci_mid_desc_2 = {
+        .setup = dw_spi_mid_init,
+        .num_cs = 4,
+        .bus_num = 1,
 };
 
 static int spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
@@ -65,18 +75,23 @@ static int spi_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         dws->regs = pcim_iomap_table(pdev)[pci_bar];
 
-        dws->bus_num = 0;
-        dws->num_cs = 4;
         dws->irq = pdev->irq;
 
         /*
          * Specific handling for paltforms, like dma setup,
          * clock rate, FIFO depth.
          */
-        if (desc && desc->setup) {
-                ret = desc->setup(dws);
-                if (ret)
-                        return ret;
+        if (desc) {
+                dws->num_cs = desc->num_cs;
+                dws->bus_num = desc->bus_num;
+
+                if (desc->setup) {
+                        ret = desc->setup(dws);
+                        if (ret)
+                                return ret;
+                }
+        } else {
+                return -ENODEV;
         }
 
         ret = dw_spi_add_host(&pdev->dev, dws);
@@ -121,7 +136,14 @@ static SIMPLE_DEV_PM_OPS(dw_spi_pm_ops, spi_suspend, spi_resume);
 
 static const struct pci_device_id pci_ids[] = {
         /* Intel MID platform SPI controller 0 */
-        { PCI_VDEVICE(INTEL, 0x0800), (kernel_ulong_t)&spi_pci_mid_desc},
+        /*
+         * The access to the device 8086:0801 is disabled by HW, since it's
+         * exclusively used by SCU to communicate with MSIC.
+         */
+        /* Intel MID platform SPI controller 1 */
+        { PCI_VDEVICE(INTEL, 0x0800), (kernel_ulong_t)&spi_pci_mid_desc_1},
+        /* Intel MID platform SPI controller 2 */
+        { PCI_VDEVICE(INTEL, 0x0812), (kernel_ulong_t)&spi_pci_mid_desc_2},
         {},
 };
 
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index 8edcd1b84562..5a97a62b298a 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -608,7 +608,7 @@ static void dw_spi_cleanup(struct spi_device *spi)
 }
 
 /* Restart the controller, disable all interrupts, clean rx fifo */
-static void spi_hw_init(struct dw_spi *dws)
+static void spi_hw_init(struct device *dev, struct dw_spi *dws)
 {
         spi_enable_chip(dws, 0);
         spi_mask_intr(dws, 0xff);
@@ -626,9 +626,10 @@ static void spi_hw_init(struct dw_spi *dws)
                         if (fifo != dw_readw(dws, DW_SPI_TXFLTR))
                                 break;
                 }
+                dw_writew(dws, DW_SPI_TXFLTR, 0);
 
                 dws->fifo_len = (fifo == 2) ? 0 : fifo - 1;
-                dw_writew(dws, DW_SPI_TXFLTR, 0);
+                dev_dbg(dev, "Detected FIFO size: %u bytes\n", dws->fifo_len);
         }
 }
 
@@ -668,7 +669,7 @@ int dw_spi_add_host(struct device *dev, struct dw_spi *dws)
         master->dev.of_node = dev->of_node;
 
         /* Basic HW init */
-        spi_hw_init(dws);
+        spi_hw_init(dev, dws);
 
         if (dws->dma_ops && dws->dma_ops->dma_init) {
                 ret = dws->dma_ops->dma_init(dws);
@@ -731,7 +732,7 @@ int dw_spi_resume_host(struct dw_spi *dws)
 {
         int ret;
 
-        spi_hw_init(dws);
+        spi_hw_init(&dws->master->dev, dws);
         ret = spi_master_resume(dws->master);
         if (ret)
                 dev_err(&dws->master->dev, "fail to start queue (%d)\n", ret);
diff --git a/drivers/spi/spi-falcon.c b/drivers/spi/spi-falcon.c
index 912b9037e9cf..286b2c81fc6b 100644
--- a/drivers/spi/spi-falcon.c
+++ b/drivers/spi/spi-falcon.c
@@ -353,16 +353,6 @@ static int falcon_sflash_setup(struct spi_device *spi)
         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)
 {
@@ -420,9 +410,7 @@ static int falcon_sflash_probe(struct platform_device *pdev)
         master->mode_bits = SPI_MODE_3;
         master->flags = SPI_MASTER_HALF_DUPLEX;
         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;
 
         ret = devm_spi_register_master(&pdev->dev, master);
diff --git a/drivers/spi/spi-fsl-cpm.c b/drivers/spi/spi-fsl-cpm.c
index e85ab1cb17a2..9c46a3058743 100644
--- a/drivers/spi/spi-fsl-cpm.c
+++ b/drivers/spi/spi-fsl-cpm.c
@@ -20,6 +20,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/fsl_devices.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/of_address.h>
 #include <linux/spi/spi.h>
 #include <linux/types.h>
@@ -68,6 +69,7 @@ void fsl_spi_cpm_reinit_txrx(struct mpc8xxx_spi *mspi)
                 }
         }
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_reinit_txrx);
 
 static void fsl_spi_cpm_bufs_start(struct mpc8xxx_spi *mspi)
 {
@@ -162,6 +164,7 @@ err_rx_dma:
                 dma_unmap_single(dev, mspi->tx_dma, t->len, DMA_TO_DEVICE);
         return -ENOMEM;
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_bufs);
 
 void fsl_spi_cpm_bufs_complete(struct mpc8xxx_spi *mspi)
 {
@@ -174,6 +177,7 @@ void fsl_spi_cpm_bufs_complete(struct mpc8xxx_spi *mspi)
                 dma_unmap_single(dev, mspi->rx_dma, t->len, DMA_FROM_DEVICE);
         mspi->xfer_in_progress = NULL;
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_bufs_complete);
 
 void fsl_spi_cpm_irq(struct mpc8xxx_spi *mspi, u32 events)
 {
@@ -198,6 +202,7 @@ void fsl_spi_cpm_irq(struct mpc8xxx_spi *mspi, u32 events)
         else
                 complete(&mspi->done);
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_irq);
 
 static void *fsl_spi_alloc_dummy_rx(void)
 {
@@ -375,6 +380,7 @@ err_pram:
         fsl_spi_free_dummy_rx();
         return -ENOMEM;
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_init);
 
 void fsl_spi_cpm_free(struct mpc8xxx_spi *mspi)
 {
@@ -389,3 +395,6 @@ void fsl_spi_cpm_free(struct mpc8xxx_spi *mspi)
         cpm_muram_free(cpm_muram_offset(mspi->pram));
         fsl_spi_free_dummy_rx();
 }
+EXPORT_SYMBOL_GPL(fsl_spi_cpm_free);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-fsl-dspi.c b/drivers/spi/spi-fsl-dspi.c
index 9b80d54d4ddb..d1a39249704a 100644
--- a/drivers/spi/spi-fsl-dspi.c
+++ b/drivers/spi/spi-fsl-dspi.c
@@ -106,7 +106,7 @@ struct chip_data {
 };
 
 struct fsl_dspi {
-        struct spi_bitbang      bitbang;
+        struct spi_master       *master;
         struct platform_device  *pdev;
 
         struct regmap           *regmap;
@@ -114,6 +114,7 @@ struct fsl_dspi {
         struct clk              *clk;
 
         struct spi_transfer     *cur_transfer;
+        struct spi_message      *cur_msg;
         struct chip_data        *cur_chip;
         size_t                  len;
         void                    *tx;
@@ -123,6 +124,7 @@ struct fsl_dspi {
         char                    dataflags;
         u8                      cs;
         u16                     void_write_data;
+        u32                     cs_change;
 
         wait_queue_head_t       waitq;
         u32                     waitflags;
@@ -225,6 +227,8 @@ static int dspi_transfer_write(struct fsl_dspi *dspi)
                 if (dspi->len == 0 || tx_count == DSPI_FIFO_SIZE - 1) {
                         /* last transfer in the transfer */
                         dspi_pushr |= SPI_PUSHR_EOQ;
+                        if ((dspi->cs_change) && (!dspi->len))
+                                dspi_pushr &= ~SPI_PUSHR_CONT;
                 } else if (tx_word && (dspi->len == 1))
                         dspi_pushr |= SPI_PUSHR_EOQ;
 
@@ -246,6 +250,7 @@ static int dspi_transfer_read(struct fsl_dspi *dspi)
         int rx_count = 0;
         int rx_word = is_double_byte_mode(dspi);
         u16 d;
+
         while ((dspi->rx < dspi->rx_end)
                         && (rx_count < DSPI_FIFO_SIZE)) {
                 if (rx_word) {
@@ -276,69 +281,79 @@ static int dspi_transfer_read(struct fsl_dspi *dspi)
         return rx_count;
 }
 
-static int dspi_txrx_transfer(struct spi_device *spi, struct spi_transfer *t)
+static int dspi_transfer_one_message(struct spi_master *master,
+                struct spi_message *message)
 {
-        struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
-        dspi->cur_transfer = t;
-        dspi->cur_chip = spi_get_ctldata(spi);
-        dspi->cs = spi->chip_select;
-        dspi->void_write_data = dspi->cur_chip->void_write_data;
-
-        dspi->dataflags = 0;
-        dspi->tx = (void *)t->tx_buf;
-        dspi->tx_end = dspi->tx + t->len;
-        dspi->rx = t->rx_buf;
-        dspi->rx_end = dspi->rx + t->len;
-        dspi->len = t->len;
-
-        if (!dspi->rx)
-                dspi->dataflags |= TRAN_STATE_RX_VOID;
-
-        if (!dspi->tx)
-                dspi->dataflags |= TRAN_STATE_TX_VOID;
-
-        regmap_write(dspi->regmap, SPI_MCR, dspi->cur_chip->mcr_val);
-        regmap_write(dspi->regmap, SPI_CTAR(dspi->cs), dspi->cur_chip->ctar_val);
-        regmap_write(dspi->regmap, SPI_RSER, SPI_RSER_EOQFE);
-
-        if (t->speed_hz)
+        struct fsl_dspi *dspi = spi_master_get_devdata(master);
+        struct spi_device *spi = message->spi;
+        struct spi_transfer *transfer;
+        int status = 0;
+        message->actual_length = 0;
+
+        list_for_each_entry(transfer, &message->transfers, transfer_list) {
+                dspi->cur_transfer = transfer;
+                dspi->cur_msg = message;
+                dspi->cur_chip = spi_get_ctldata(spi);
+                dspi->cs = spi->chip_select;
+                if (dspi->cur_transfer->transfer_list.next
+                                == &dspi->cur_msg->transfers)
+                        transfer->cs_change = 1;
+                dspi->cs_change = transfer->cs_change;
+                dspi->void_write_data = dspi->cur_chip->void_write_data;
+
+                dspi->dataflags = 0;
+                dspi->tx = (void *)transfer->tx_buf;
+                dspi->tx_end = dspi->tx + transfer->len;
+                dspi->rx = transfer->rx_buf;
+                dspi->rx_end = dspi->rx + transfer->len;
+                dspi->len = transfer->len;
+
+                if (!dspi->rx)
+                        dspi->dataflags |= TRAN_STATE_RX_VOID;
+
+                if (!dspi->tx)
+                        dspi->dataflags |= TRAN_STATE_TX_VOID;
+
+                regmap_write(dspi->regmap, SPI_MCR, dspi->cur_chip->mcr_val);
+                regmap_update_bits(dspi->regmap, SPI_MCR,
+                                SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF,
+                                SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF);
                 regmap_write(dspi->regmap, SPI_CTAR(dspi->cs),
                                 dspi->cur_chip->ctar_val);
+                if (transfer->speed_hz)
+                        regmap_write(dspi->regmap, SPI_CTAR(dspi->cs),
+                                        dspi->cur_chip->ctar_val);
 
-        dspi_transfer_write(dspi);
-
-        if (wait_event_interruptible(dspi->waitq, dspi->waitflags))
-                dev_err(&dspi->pdev->dev, "wait transfer complete fail!\n");
-        dspi->waitflags = 0;
-
-        return t->len - dspi->len;
-}
+                regmap_write(dspi->regmap, SPI_RSER, SPI_RSER_EOQFE);
+                message->actual_length += dspi_transfer_write(dspi);
 
-static void dspi_chipselect(struct spi_device *spi, int value)
-{
-        struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
-        unsigned int pushr;
+                if (wait_event_interruptible(dspi->waitq, dspi->waitflags))
+                        dev_err(&dspi->pdev->dev, "wait transfer complete fail!\n");
+                dspi->waitflags = 0;
 
-        regmap_read(dspi->regmap, SPI_PUSHR, &pushr);
-
-        switch (value) {
-        case BITBANG_CS_ACTIVE:
-                pushr |= SPI_PUSHR_CONT;
-                break;
-        case BITBANG_CS_INACTIVE:
-                pushr &= ~SPI_PUSHR_CONT;
-                break;
+                if (transfer->delay_usecs)
+                        udelay(transfer->delay_usecs);
         }
 
-        regmap_write(dspi->regmap, SPI_PUSHR, pushr);
+        message->status = status;
+        spi_finalize_current_message(master);
+
+        return status;
 }
 
-static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
+static int dspi_setup(struct spi_device *spi)
 {
         struct chip_data *chip;
         struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
         unsigned char br = 0, pbr = 0, fmsz = 0;
 
+        if ((spi->bits_per_word >= 4) && (spi->bits_per_word <= 16)) {
+                fmsz = spi->bits_per_word - 1;
+        } else {
+                pr_err("Invalid wordsize\n");
+                return -ENODEV;
+        }
+
         /* Only alloc on first setup */
         chip = spi_get_ctldata(spi);
         if (chip == NULL) {
@@ -349,12 +364,6 @@ static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
 
         chip->mcr_val = SPI_MCR_MASTER | SPI_MCR_PCSIS |
                 SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF;
-        if ((spi->bits_per_word >= 4) && (spi->bits_per_word <= 16)) {
-                fmsz = spi->bits_per_word - 1;
-        } else {
-                pr_err("Invalid wordsize\n");
-                return -ENODEV;
-        }
 
         chip->void_write_data = 0;
 
@@ -373,14 +382,6 @@ static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         return 0;
 }
 
-static int dspi_setup(struct spi_device *spi)
-{
-        if (!spi->max_speed_hz)
-                return -EINVAL;
-
-        return dspi_setup_transfer(spi, NULL);
-}
-
 static void dspi_cleanup(struct spi_device *spi)
 {
         struct chip_data *chip = spi_get_ctldata((struct spi_device *)spi);
@@ -395,22 +396,20 @@ static irqreturn_t dspi_interrupt(int irq, void *dev_id)
 {
         struct fsl_dspi *dspi = (struct fsl_dspi *)dev_id;
 
-        regmap_write(dspi->regmap, SPI_SR, SPI_SR_EOQF);
+        struct spi_message *msg = dspi->cur_msg;
 
+        regmap_write(dspi->regmap, SPI_SR, SPI_SR_EOQF);
         dspi_transfer_read(dspi);
 
         if (!dspi->len) {
                 if (dspi->dataflags & TRAN_STATE_WORD_ODD_NUM)
                         regmap_update_bits(dspi->regmap, SPI_CTAR(dspi->cs),
-                                SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(16));
+                        SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(16));
 
                 dspi->waitflags = 1;
                 wake_up_interruptible(&dspi->waitq);
-        } else {
-                dspi_transfer_write(dspi);
-
-                return IRQ_HANDLED;
-        }
+        } else
+                msg->actual_length += dspi_transfer_write(dspi);
 
         return IRQ_HANDLED;
 }
@@ -469,12 +468,12 @@ static int dspi_probe(struct platform_device *pdev)
 
         dspi = spi_master_get_devdata(master);
         dspi->pdev = pdev;
-        dspi->bitbang.master = master;
-        dspi->bitbang.chipselect = dspi_chipselect;
-        dspi->bitbang.setup_transfer = dspi_setup_transfer;
-        dspi->bitbang.txrx_bufs = dspi_txrx_transfer;
-        dspi->bitbang.master->setup = dspi_setup;
-        dspi->bitbang.master->dev.of_node = pdev->dev.of_node;
+        dspi->master = master;
+
+        master->transfer = NULL;
+        master->setup = dspi_setup;
+        master->transfer_one_message = dspi_transfer_one_message;
+        master->dev.of_node = pdev->dev.of_node;
 
         master->cleanup = dspi_cleanup;
         master->mode_bits = SPI_CPOL | SPI_CPHA;
@@ -535,7 +534,7 @@ static int dspi_probe(struct platform_device *pdev)
         init_waitqueue_head(&dspi->waitq);
         platform_set_drvdata(pdev, master);
 
-        ret = spi_bitbang_start(&dspi->bitbang);
+        ret = spi_register_master(master);
         if (ret != 0) {
                 dev_err(&pdev->dev, "Problem registering DSPI master\n");
                 goto out_clk_put;
@@ -557,9 +556,9 @@ static int dspi_remove(struct platform_device *pdev)
         struct fsl_dspi *dspi = spi_master_get_devdata(master);
 
         /* Disconnect from the SPI framework */
-        spi_bitbang_stop(&dspi->bitbang);
         clk_disable_unprepare(dspi->clk);
-        spi_master_put(dspi->bitbang.master);
+        spi_unregister_master(dspi->master);
+        spi_master_put(dspi->master);
 
         return 0;
 }
diff --git a/drivers/spi/spi-fsl-lib.c b/drivers/spi/spi-fsl-lib.c
index 446b737e1532..cb35d2f0d0e6 100644
--- a/drivers/spi/spi-fsl-lib.c
+++ b/drivers/spi/spi-fsl-lib.c
@@ -21,6 +21,7 @@
 #include <linux/interrupt.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/module.h>
 #include <linux/of_platform.h>
 #include <linux/spi/spi.h>
 #ifdef CONFIG_FSL_SOC
@@ -35,7 +36,8 @@ void mpc8xxx_spi_rx_buf_##type(u32 data, struct mpc8xxx_spi *mpc8xxx_spi) \
         type *rx = mpc8xxx_spi->rx;                                       \
         *rx++ = (type)(data >> mpc8xxx_spi->rx_shift);                    \
         mpc8xxx_spi->rx = rx;                                             \
-}
+}                                                                         \
+EXPORT_SYMBOL_GPL(mpc8xxx_spi_rx_buf_##type);
 
 #define MPC8XXX_SPI_TX_BUF(type)                                \
 u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi)  \
@@ -47,7 +49,8 @@ u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi)	\
         data = *tx++ << mpc8xxx_spi->tx_shift;                  \
         mpc8xxx_spi->tx = tx;                                   \
         return data;                                            \
-}
+}                                                               \
+EXPORT_SYMBOL_GPL(mpc8xxx_spi_tx_buf_##type);
 
 MPC8XXX_SPI_RX_BUF(u8)
 MPC8XXX_SPI_RX_BUF(u16)
@@ -60,6 +63,7 @@ struct mpc8xxx_spi_probe_info *to_of_pinfo(struct fsl_spi_platform_data *pdata)
 {
         return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
 }
+EXPORT_SYMBOL_GPL(to_of_pinfo);
 
 const char *mpc8xxx_spi_strmode(unsigned int flags)
 {
@@ -75,6 +79,7 @@ const char *mpc8xxx_spi_strmode(unsigned int flags)
         }
         return "CPU";
 }
+EXPORT_SYMBOL_GPL(mpc8xxx_spi_strmode);
 
 void mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
                         unsigned int irq)
@@ -102,13 +107,12 @@ void mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
         mpc8xxx_spi->rx_shift = 0;
         mpc8xxx_spi->tx_shift = 0;
 
-        init_completion(&mpc8xxx_spi->done);
-
         master->bus_num = pdata->bus_num;
         master->num_chipselect = pdata->max_chipselect;
 
         init_completion(&mpc8xxx_spi->done);
 }
+EXPORT_SYMBOL_GPL(mpc8xxx_spi_probe);
 
 int mpc8xxx_spi_remove(struct device *dev)
 {
@@ -127,6 +131,7 @@ int mpc8xxx_spi_remove(struct device *dev)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(mpc8xxx_spi_remove);
 
 int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
 {
@@ -173,3 +178,6 @@ int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(of_mpc8xxx_spi_probe);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi-fsl-lib.h b/drivers/spi/spi-fsl-lib.h
index b4ed04e8862f..1326a392adca 100644
--- a/drivers/spi/spi-fsl-lib.h
+++ b/drivers/spi/spi-fsl-lib.h
@@ -28,7 +28,7 @@ struct mpc8xxx_spi {
         /* rx & tx bufs from the spi_transfer */
         const void *tx;
         void *rx;
-#ifdef CONFIG_SPI_FSL_ESPI
+#if IS_ENABLED(CONFIG_SPI_FSL_ESPI)
         int len;
 #endif
 
@@ -68,7 +68,7 @@ struct mpc8xxx_spi {
 
         unsigned int flags;
 
-#ifdef CONFIG_SPI_FSL_SPI
+#if IS_ENABLED(CONFIG_SPI_FSL_SPI)
         int type;
         int native_chipselects;
         u8 max_bits_per_word;
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index aee4e7589568..1c34c9314c8a 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -92,7 +88,7 @@ struct spi_gpio {
 
 /*----------------------------------------------------------------------*/
 
-static inline struct spi_gpio * __pure
+static inline struct spi_gpio *__pure
 spi_to_spi_gpio(const struct spi_device *spi)
 {
         const struct spi_bitbang        *bang;
@@ -103,7 +99,7 @@ spi_to_spi_gpio(const struct spi_device *spi)
         return spi_gpio;
 }
 
-static inline struct spi_gpio_platform_data * __pure
+static inline struct spi_gpio_platform_data *__pure
 spi_to_pdata(const struct spi_device *spi)
 {
         return &spi_to_spi_gpio(spi)->pdata;
diff --git a/drivers/spi/spi-img-spfi.c b/drivers/spi/spi-img-spfi.c
index aad6683db81b..c01567d53581 100644
--- a/drivers/spi/spi-img-spfi.c
+++ b/drivers/spi/spi-img-spfi.c
@@ -160,16 +160,16 @@ static unsigned int spfi_pio_write32(struct img_spfi *spfi, const u32 *buf,
         unsigned int count = 0;
         u32 status;
 
-        while (count < max) {
+        while (count < max / 4) {
                 spfi_writel(spfi, SPFI_INTERRUPT_SDFUL, SPFI_INTERRUPT_CLEAR);
                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
                 if (status & SPFI_INTERRUPT_SDFUL)
                         break;
-                spfi_writel(spfi, buf[count / 4], SPFI_TX_32BIT_VALID_DATA);
-                count += 4;
+                spfi_writel(spfi, buf[count], SPFI_TX_32BIT_VALID_DATA);
+                count++;
         }
 
-        return count;
+        return count * 4;
 }
 
 static unsigned int spfi_pio_write8(struct img_spfi *spfi, const u8 *buf,
@@ -196,17 +196,17 @@ static unsigned int spfi_pio_read32(struct img_spfi *spfi, u32 *buf,
         unsigned int count = 0;
         u32 status;
 
-        while (count < max) {
+        while (count < max / 4) {
                 spfi_writel(spfi, SPFI_INTERRUPT_GDEX32BIT,
                             SPFI_INTERRUPT_CLEAR);
                 status = spfi_readl(spfi, SPFI_INTERRUPT_STATUS);
                 if (!(status & SPFI_INTERRUPT_GDEX32BIT))
                         break;
-                buf[count / 4] = spfi_readl(spfi, SPFI_RX_32BIT_VALID_DATA);
-                count += 4;
+                buf[count] = spfi_readl(spfi, SPFI_RX_32BIT_VALID_DATA);
+                count++;
         }
 
-        return count;
+        return count * 4;
 }
 
 static unsigned int spfi_pio_read8(struct img_spfi *spfi, u8 *buf,
@@ -251,17 +251,15 @@ static int img_spfi_start_pio(struct spi_master *master,
                time_before(jiffies, timeout)) {
                 unsigned int tx_count, rx_count;
 
-                switch (xfer->bits_per_word) {
-                case 32:
+                if (tx_bytes >= 4)
                         tx_count = spfi_pio_write32(spfi, tx_buf, tx_bytes);
-                        rx_count = spfi_pio_read32(spfi, rx_buf, rx_bytes);
-                        break;
-                case 8:
-                default:
+                else
                         tx_count = spfi_pio_write8(spfi, tx_buf, tx_bytes);
+
+                if (rx_bytes >= 4)
+                        rx_count = spfi_pio_read32(spfi, rx_buf, rx_bytes);
+                else
                         rx_count = spfi_pio_read8(spfi, rx_buf, rx_bytes);
-                        break;
-                }
 
                 tx_buf += tx_count;
                 rx_buf += rx_count;
@@ -331,14 +329,11 @@ static int img_spfi_start_dma(struct spi_master *master,
 
         if (xfer->rx_buf) {
                 rxconf.direction = DMA_DEV_TO_MEM;
-                switch (xfer->bits_per_word) {
-                case 32:
+                if (xfer->len % 4 == 0) {
                         rxconf.src_addr = spfi->phys + SPFI_RX_32BIT_VALID_DATA;
                         rxconf.src_addr_width = 4;
                         rxconf.src_maxburst = 4;
-                        break;
-                case 8:
-                default:
+                } else {
                         rxconf.src_addr = spfi->phys + SPFI_RX_8BIT_VALID_DATA;
                         rxconf.src_addr_width = 1;
                         rxconf.src_maxburst = 4;
@@ -358,18 +353,14 @@ static int img_spfi_start_dma(struct spi_master *master,
 
         if (xfer->tx_buf) {
                 txconf.direction = DMA_MEM_TO_DEV;
-                switch (xfer->bits_per_word) {
-                case 32:
+                if (xfer->len % 4 == 0) {
                         txconf.dst_addr = spfi->phys + SPFI_TX_32BIT_VALID_DATA;
                         txconf.dst_addr_width = 4;
                         txconf.dst_maxburst = 4;
-                        break;
-                case 8:
-                default:
+                } else {
                         txconf.dst_addr = spfi->phys + SPFI_TX_8BIT_VALID_DATA;
                         txconf.dst_addr_width = 1;
                         txconf.dst_maxburst = 4;
-                        break;
                 }
                 dmaengine_slave_config(spfi->tx_ch, &txconf);
 
@@ -508,9 +499,7 @@ static void img_spfi_set_cs(struct spi_device *spi, bool enable)
 static bool img_spfi_can_dma(struct spi_master *master, struct spi_device *spi,
                              struct spi_transfer *xfer)
 {
-        if (xfer->bits_per_word == 8 && xfer->len > SPFI_8BIT_FIFO_SIZE)
-                return true;
-        if (xfer->bits_per_word == 32 && xfer->len > SPFI_32BIT_FIFO_SIZE)
+        if (xfer->len > SPFI_32BIT_FIFO_SIZE)
                 return true;
         return false;
 }
diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c
index fe1b7699fab6..6fea4af51c41 100644
--- a/drivers/spi/spi-imx.c
+++ b/drivers/spi/spi-imx.c
@@ -89,7 +89,6 @@ struct spi_imx_data {
 
         struct completion xfer_done;
         void __iomem *base;
-        int irq;
         struct clk *clk_per;
         struct clk *clk_ipg;
         unsigned long spi_clk;
@@ -896,6 +895,7 @@ static int spi_imx_dma_transfer(struct spi_imx_data *spi_imx,
 {
         struct dma_async_tx_descriptor *desc_tx = NULL, *desc_rx = NULL;
         int ret;
+        unsigned long timeout;
         u32 dma;
         int left;
         struct spi_master *master = spi_imx->bitbang.master;
@@ -943,17 +943,17 @@ static int spi_imx_dma_transfer(struct spi_imx_data *spi_imx,
         dma_async_issue_pending(master->dma_tx);
         dma_async_issue_pending(master->dma_rx);
         /* Wait SDMA to finish the data transfer.*/
-        ret = wait_for_completion_timeout(&spi_imx->dma_tx_completion,
+        timeout = wait_for_completion_timeout(&spi_imx->dma_tx_completion,
                                                 IMX_DMA_TIMEOUT);
-        if (!ret) {
+        if (!timeout) {
                 pr_warn("%s %s: I/O Error in DMA TX\n",
                         dev_driver_string(&master->dev),
                         dev_name(&master->dev));
                 dmaengine_terminate_all(master->dma_tx);
         } else {
-                ret = wait_for_completion_timeout(&spi_imx->dma_rx_completion,
-                                IMX_DMA_TIMEOUT);
-                if (!ret) {
+                timeout = wait_for_completion_timeout(
+                                &spi_imx->dma_rx_completion, IMX_DMA_TIMEOUT);
+                if (!timeout) {
                         pr_warn("%s %s: I/O Error in DMA RX\n",
                                 dev_driver_string(&master->dev),
                                 dev_name(&master->dev));
@@ -968,9 +968,9 @@ static int spi_imx_dma_transfer(struct spi_imx_data *spi_imx,
         spi_imx->dma_finished = 1;
         spi_imx->devtype_data->trigger(spi_imx);
 
-        if (!ret)
+        if (!timeout)
                 ret = -ETIMEDOUT;
-        else if (ret > 0)
+        else
                 ret = transfer->len;
 
         return ret;
@@ -1080,7 +1080,7 @@ static int spi_imx_probe(struct platform_device *pdev)
         struct spi_master *master;
         struct spi_imx_data *spi_imx;
         struct resource *res;
-        int i, ret, num_cs;
+        int i, ret, num_cs, irq;
 
         if (!np && !mxc_platform_info) {
                 dev_err(&pdev->dev, "can't get the platform data\n");
@@ -1147,16 +1147,16 @@ static int spi_imx_probe(struct platform_device *pdev)
                 goto out_master_put;
         }
 
-        spi_imx->irq = platform_get_irq(pdev, 0);
-        if (spi_imx->irq < 0) {
-                ret = spi_imx->irq;
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                ret = irq;
                 goto out_master_put;
         }
 
-        ret = devm_request_irq(&pdev->dev, spi_imx->irq, spi_imx_isr, 0,
+        ret = devm_request_irq(&pdev->dev, irq, spi_imx_isr, 0,
                                dev_name(&pdev->dev), spi_imx);
         if (ret) {
-                dev_err(&pdev->dev, "can't get irq%d: %d\n", spi_imx->irq, ret);
+                dev_err(&pdev->dev, "can't get irq%d: %d\n", irq, ret);
                 goto out_master_put;
         }
 
diff --git a/drivers/spi/spi-lm70llp.c b/drivers/spi/spi-lm70llp.c
index 41c5765be746..ba72347cb99d 100644
--- a/drivers/spi/spi-lm70llp.c
+++ b/drivers/spi/spi-lm70llp.c
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/init.h>
diff --git a/drivers/spi/spi-meson-spifc.c b/drivers/spi/spi-meson-spifc.c
index 1bbac0378bf7..5468fc70dbf8 100644
--- a/drivers/spi/spi-meson-spifc.c
+++ b/drivers/spi/spi-meson-spifc.c
@@ -85,7 +85,7 @@ struct meson_spifc {
         struct device *dev;
 };
 
-static struct regmap_config spifc_regmap_config = {
+static const struct regmap_config spifc_regmap_config = {
         .reg_bits = 32,
         .val_bits = 32,
         .reg_stride = 4,
diff --git a/drivers/spi/spi-mxs.c b/drivers/spi/spi-mxs.c
index 4045a1e580e1..5b0e9a3e83f6 100644
--- a/drivers/spi/spi-mxs.c
+++ b/drivers/spi/spi-mxs.c
@@ -282,9 +282,8 @@ static int mxs_spi_txrx_dma(struct mxs_spi *spi,
         dmaengine_submit(desc);
         dma_async_issue_pending(ssp->dmach);
 
-        ret = wait_for_completion_timeout(&spi->c,
-                                msecs_to_jiffies(SSP_TIMEOUT));
-        if (!ret) {
+        if (!wait_for_completion_timeout(&spi->c,
+                                         msecs_to_jiffies(SSP_TIMEOUT))) {
                 dev_err(ssp->dev, "DMA transfer timeout\n");
                 ret = -ETIMEDOUT;
                 dmaengine_terminate_all(ssp->dmach);
diff --git a/drivers/spi/spi-omap-100k.c b/drivers/spi/spi-omap-100k.c
index 79399ae9c84c..d890d309dff9 100644
--- a/drivers/spi/spi-omap-100k.c
+++ b/drivers/spi/spi-omap-100k.c
@@ -16,11 +16,6 @@
  * 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/init.h>
diff --git a/drivers/spi/spi-omap-uwire.c b/drivers/spi/spi-omap-uwire.c
index daf1ada5cd11..3c0844457c07 100644
--- a/drivers/spi/spi-omap-uwire.c
+++ b/drivers/spi/spi-omap-uwire.c
@@ -28,10 +28,6 @@
  * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #include <linux/kernel.h>
 #include <linux/init.h>
diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index 3bc3cbabbbc0..4df8942058de 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -14,11 +14,6 @@
  * 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>
diff --git a/drivers/spi/spi-orion.c b/drivers/spi/spi-orion.c
index 3dec9e0b99b8..861664776672 100644
--- a/drivers/spi/spi-orion.c
+++ b/drivers/spi/spi-orion.c
@@ -28,7 +28,12 @@
 /* Runtime PM autosuspend timeout: PM is fairly light on this driver */
 #define SPI_AUTOSUSPEND_TIMEOUT         200
 
-#define ORION_NUM_CHIPSELECTS           1 /* only one slave is supported*/
+/* Some SoCs using this driver support up to 8 chip selects.
+ * It is up to the implementer to only use the chip selects
+ * that are available.
+ */
+#define ORION_NUM_CHIPSELECTS           8
+
 #define ORION_SPI_WAIT_RDY_MAX_LOOP     2000 /* in usec */
 
 #define ORION_SPI_IF_CTRL_REG           0x00
@@ -44,6 +49,10 @@
 #define ARMADA_SPI_CLK_PRESCALE_MASK    0xDF
 #define ORION_SPI_MODE_MASK             (ORION_SPI_MODE_CPOL | \
                                          ORION_SPI_MODE_CPHA)
+#define ORION_SPI_CS_MASK       0x1C
+#define ORION_SPI_CS_SHIFT      2
+#define ORION_SPI_CS(cs)        ((cs << ORION_SPI_CS_SHIFT) & \
+                                        ORION_SPI_CS_MASK)
 
 enum orion_spi_type {
         ORION_SPI,
@@ -215,9 +224,18 @@ orion_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         return 0;
 }
 
-static void orion_spi_set_cs(struct orion_spi *orion_spi, int enable)
+static void orion_spi_set_cs(struct spi_device *spi, bool enable)
 {
-        if (enable)
+        struct orion_spi *orion_spi;
+
+        orion_spi = spi_master_get_devdata(spi->master);
+
+        orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, ORION_SPI_CS_MASK);
+        orion_spi_setbits(orion_spi, ORION_SPI_IF_CTRL_REG,
+                                ORION_SPI_CS(spi->chip_select));
+
+        /* Chip select logic is inverted from spi_set_cs */
+        if (!enable)
                 orion_spi_setbits(orion_spi, ORION_SPI_IF_CTRL_REG, 0x1);
         else
                 orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, 0x1);
@@ -332,64 +350,31 @@ out:
         return xfer->len - count;
 }
 
-static int orion_spi_transfer_one_message(struct spi_master *master,
-                                           struct spi_message *m)
+static int orion_spi_transfer_one(struct spi_master *master,
+                                        struct spi_device *spi,
+                                        struct spi_transfer *t)
 {
-        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;
-
-        /* Load defaults */
-        status = orion_spi_setup_transfer(spi, NULL);
 
+        status = orion_spi_setup_transfer(spi, t);
         if (status < 0)
-                goto msg_done;
-
-        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;
-                }
+                return status;
 
-                if (t->len)
-                        m->actual_length += orion_spi_write_read(spi, t);
+        if (t->len)
+                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);
-
-        m->status = status;
-        spi_finalize_current_message(master);
+        return status;
+}
 
-        return 0;
+static int orion_spi_setup(struct spi_device *spi)
+{
+        return orion_spi_setup_transfer(spi, NULL);
 }
 
 static int orion_spi_reset(struct orion_spi *orion_spi)
 {
         /* Verify that the CS is deasserted */
-        orion_spi_set_cs(orion_spi, 0);
-
+        orion_spi_clrbits(orion_spi, ORION_SPI_IF_CTRL_REG, 0x1);
         return 0;
 }
 
@@ -442,9 +427,10 @@ static int orion_spi_probe(struct platform_device *pdev)
 
         /* we support only mode 0, and no options */
         master->mode_bits = SPI_CPHA | SPI_CPOL;
-
-        master->transfer_one_message = orion_spi_transfer_one_message;
+        master->set_cs = orion_spi_set_cs;
+        master->transfer_one = orion_spi_transfer_one;
         master->num_chipselect = ORION_NUM_CHIPSELECTS;
+        master->setup = orion_spi_setup;
         master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
         master->auto_runtime_pm = true;
 
diff --git a/drivers/spi/spi-pxa2xx-dma.c b/drivers/spi/spi-pxa2xx-dma.c
index 62a9297e96ac..66a173939be8 100644
--- a/drivers/spi/spi-pxa2xx-dma.c
+++ b/drivers/spi/spi-pxa2xx-dma.c
@@ -111,23 +111,24 @@ static void pxa2xx_spi_dma_transfer_complete(struct driver_data *drv_data,
          * by using ->dma_running.
          */
         if (atomic_dec_and_test(&drv_data->dma_running)) {
-                void __iomem *reg = drv_data->ioaddr;
-
                 /*
                  * If the other CPU is still handling the ROR interrupt we
                  * might not know about the error yet. So we re-check the
                  * ROR bit here before we clear the status register.
                  */
                 if (!error) {
-                        u32 status = read_SSSR(reg) & drv_data->mask_sr;
+                        u32 status = pxa2xx_spi_read(drv_data, SSSR)
+                                     & drv_data->mask_sr;
                         error = status & SSSR_ROR;
                 }
 
                 /* Clear status & disable interrupts */
-                write_SSCR1(read_SSCR1(reg) & ~drv_data->dma_cr1, reg);
+                pxa2xx_spi_write(drv_data, SSCR1,
+                                 pxa2xx_spi_read(drv_data, SSCR1)
+                                 & ~drv_data->dma_cr1);
                 write_SSSR_CS(drv_data, drv_data->clear_sr);
                 if (!pxa25x_ssp_comp(drv_data))
-                        write_SSTO(0, reg);
+                        pxa2xx_spi_write(drv_data, SSTO, 0);
 
                 if (!error) {
                         pxa2xx_spi_unmap_dma_buffers(drv_data);
@@ -139,7 +140,9 @@ static void pxa2xx_spi_dma_transfer_complete(struct driver_data *drv_data,
                         msg->state = pxa2xx_spi_next_transfer(drv_data);
                 } else {
                         /* In case we got an error we disable the SSP now */
-                        write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
+                        pxa2xx_spi_write(drv_data, SSCR0,
+                                         pxa2xx_spi_read(drv_data, SSCR0)
+                                         & ~SSCR0_SSE);
 
                         msg->state = ERROR_STATE;
                 }
@@ -247,7 +250,7 @@ irqreturn_t pxa2xx_spi_dma_transfer(struct driver_data *drv_data)
 {
         u32 status;
 
-        status = read_SSSR(drv_data->ioaddr) & drv_data->mask_sr;
+        status = pxa2xx_spi_read(drv_data, SSSR) & drv_data->mask_sr;
         if (status & SSSR_ROR) {
                 dev_err(&drv_data->pdev->dev, "FIFO overrun\n");
 
diff --git a/drivers/spi/spi-pxa2xx-pxadma.c b/drivers/spi/spi-pxa2xx-pxadma.c
index e8a26f25d5c0..2e0796a0003f 100644
--- a/drivers/spi/spi-pxa2xx-pxadma.c
+++ b/drivers/spi/spi-pxa2xx-pxadma.c
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/delay.h>
@@ -25,6 +21,7 @@
 #include <linux/spi/spi.h>
 #include <linux/spi/pxa2xx_spi.h>
 
+#include <mach/dma.h>
 #include "spi-pxa2xx.h"
 
 #define DMA_INT_MASK            (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
@@ -118,11 +115,11 @@ static void pxa2xx_spi_unmap_dma_buffers(struct driver_data *drv_data)
         drv_data->dma_mapped = 0;
 }
 
-static int wait_ssp_rx_stall(void const __iomem *ioaddr)
+static int wait_ssp_rx_stall(struct driver_data *drv_data)
 {
         unsigned long limit = loops_per_jiffy << 1;
 
-        while ((read_SSSR(ioaddr) & SSSR_BSY) && --limit)
+        while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY) && --limit)
                 cpu_relax();
 
         return limit;
@@ -141,17 +138,18 @@ static int wait_dma_channel_stop(int channel)
 static void pxa2xx_spi_dma_error_stop(struct driver_data *drv_data,
                                       const char *msg)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         /* Stop and reset */
         DCSR(drv_data->rx_channel) = RESET_DMA_CHANNEL;
         DCSR(drv_data->tx_channel) = RESET_DMA_CHANNEL;
         write_SSSR_CS(drv_data, drv_data->clear_sr);
-        write_SSCR1(read_SSCR1(reg) & ~drv_data->dma_cr1, reg);
+        pxa2xx_spi_write(drv_data, SSCR1,
+                         pxa2xx_spi_read(drv_data, SSCR1)
+                         & ~drv_data->dma_cr1);
         if (!pxa25x_ssp_comp(drv_data))
-                write_SSTO(0, reg);
+                pxa2xx_spi_write(drv_data, SSTO, 0);
         pxa2xx_spi_flush(drv_data);
-        write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
+        pxa2xx_spi_write(drv_data, SSCR0,
+                         pxa2xx_spi_read(drv_data, SSCR0) & ~SSCR0_SSE);
 
         pxa2xx_spi_unmap_dma_buffers(drv_data);
 
@@ -163,11 +161,12 @@ static void pxa2xx_spi_dma_error_stop(struct driver_data *drv_data,
 
 static void pxa2xx_spi_dma_transfer_complete(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
         struct spi_message *msg = drv_data->cur_msg;
 
         /* Clear and disable interrupts on SSP and DMA channels*/
-        write_SSCR1(read_SSCR1(reg) & ~drv_data->dma_cr1, reg);
+        pxa2xx_spi_write(drv_data, SSCR1,
+                         pxa2xx_spi_read(drv_data, SSCR1)
+                         & ~drv_data->dma_cr1);
         write_SSSR_CS(drv_data, drv_data->clear_sr);
         DCSR(drv_data->tx_channel) = RESET_DMA_CHANNEL;
         DCSR(drv_data->rx_channel) = RESET_DMA_CHANNEL;
@@ -228,7 +227,7 @@ void pxa2xx_spi_dma_handler(int channel, void *data)
                 && (drv_data->ssp_type == PXA25x_SSP)) {
 
                 /* Wait for rx to stall */
-                if (wait_ssp_rx_stall(drv_data->ioaddr) == 0)
+                if (wait_ssp_rx_stall(drv_data) == 0)
                         dev_err(&drv_data->pdev->dev,
                                 "dma_handler: ssp rx stall failed\n");
 
@@ -240,9 +239,8 @@ void pxa2xx_spi_dma_handler(int channel, void *data)
 irqreturn_t pxa2xx_spi_dma_transfer(struct driver_data *drv_data)
 {
         u32 irq_status;
-        void __iomem *reg = drv_data->ioaddr;
 
-        irq_status = read_SSSR(reg) & drv_data->mask_sr;
+        irq_status = pxa2xx_spi_read(drv_data, SSSR) & drv_data->mask_sr;
         if (irq_status & SSSR_ROR) {
                 pxa2xx_spi_dma_error_stop(drv_data,
                                           "dma_transfer: fifo overrun");
@@ -252,7 +250,7 @@ irqreturn_t pxa2xx_spi_dma_transfer(struct driver_data *drv_data)
         /* Check for false positive timeout */
         if ((irq_status & SSSR_TINT)
                 && (DCSR(drv_data->tx_channel) & DCSR_RUN)) {
-                write_SSSR(SSSR_TINT, reg);
+                pxa2xx_spi_write(drv_data, SSSR, SSSR_TINT);
                 return IRQ_HANDLED;
         }
 
@@ -261,7 +259,7 @@ irqreturn_t pxa2xx_spi_dma_transfer(struct driver_data *drv_data)
                 /* Clear and disable timeout interrupt, do the rest in
                  * dma_transfer_complete */
                 if (!pxa25x_ssp_comp(drv_data))
-                        write_SSTO(0, reg);
+                        pxa2xx_spi_write(drv_data, SSTO, 0);
 
                 /* finish this transfer, start the next */
                 pxa2xx_spi_dma_transfer_complete(drv_data);
diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
index 23822e7df6c1..6f72ad01e041 100644
--- a/drivers/spi/spi-pxa2xx.c
+++ b/drivers/spi/spi-pxa2xx.c
@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/init.h>
@@ -45,8 +41,6 @@ MODULE_DESCRIPTION("PXA2xx SSP SPI Controller");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS("platform:pxa2xx-spi");
 
-#define MAX_BUSES 3
-
 #define TIMOUT_DFLT             1000
 
 /*
@@ -162,7 +156,6 @@ pxa2xx_spi_get_rx_default_thre(const struct driver_data *drv_data)
 
 static bool pxa2xx_spi_txfifo_full(const struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
         u32 mask;
 
         switch (drv_data->ssp_type) {
@@ -174,7 +167,7 @@ static bool pxa2xx_spi_txfifo_full(const struct driver_data *drv_data)
                 break;
         }
 
-        return (read_SSSR(reg) & mask) == mask;
+        return (pxa2xx_spi_read(drv_data, SSSR) & mask) == mask;
 }
 
 static void pxa2xx_spi_clear_rx_thre(const struct driver_data *drv_data,
@@ -253,9 +246,6 @@ static void lpss_ssp_setup(struct driver_data *drv_data)
         unsigned offset = 0x400;
         u32 value, orig;
 
-        if (!is_lpss_ssp(drv_data))
-                return;
-
         /*
          * Perform auto-detection of the LPSS SSP private registers. They
          * can be either at 1k or 2k offset from the base address.
@@ -304,9 +294,6 @@ static void lpss_ssp_cs_control(struct driver_data *drv_data, bool enable)
 {
         u32 value;
 
-        if (!is_lpss_ssp(drv_data))
-                return;
-
         value = __lpss_ssp_read_priv(drv_data, SPI_CS_CONTROL);
         if (enable)
                 value &= ~SPI_CS_CONTROL_CS_HIGH;
@@ -320,7 +307,7 @@ static void cs_assert(struct driver_data *drv_data)
         struct chip_data *chip = drv_data->cur_chip;
 
         if (drv_data->ssp_type == CE4100_SSP) {
-                write_SSSR(drv_data->cur_chip->frm, drv_data->ioaddr);
+                pxa2xx_spi_write(drv_data, SSSR, drv_data->cur_chip->frm);
                 return;
         }
 
@@ -334,7 +321,8 @@ static void cs_assert(struct driver_data *drv_data)
                 return;
         }
 
-        lpss_ssp_cs_control(drv_data, true);
+        if (is_lpss_ssp(drv_data))
+                lpss_ssp_cs_control(drv_data, true);
 }
 
 static void cs_deassert(struct driver_data *drv_data)
@@ -354,20 +342,18 @@ static void cs_deassert(struct driver_data *drv_data)
                 return;
         }
 
-        lpss_ssp_cs_control(drv_data, false);
+        if (is_lpss_ssp(drv_data))
+                lpss_ssp_cs_control(drv_data, false);
 }
 
 int pxa2xx_spi_flush(struct driver_data *drv_data)
 {
         unsigned long limit = loops_per_jiffy << 1;
 
-        void __iomem *reg = drv_data->ioaddr;
-
         do {
-                while (read_SSSR(reg) & SSSR_RNE) {
-                        read_SSDR(reg);
-                }
-        } while ((read_SSSR(reg) & SSSR_BSY) && --limit);
+                while (pxa2xx_spi_read(drv_data, SSSR) & SSSR_RNE)
+                        pxa2xx_spi_read(drv_data, SSDR);
+        } while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_BSY) && --limit);
         write_SSSR_CS(drv_data, SSSR_ROR);
 
         return limit;
@@ -375,14 +361,13 @@ int pxa2xx_spi_flush(struct driver_data *drv_data)
 
 static int null_writer(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
         u8 n_bytes = drv_data->n_bytes;
 
         if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
-        write_SSDR(0, reg);
+        pxa2xx_spi_write(drv_data, SSDR, 0);
         drv_data->tx += n_bytes;
 
         return 1;
@@ -390,12 +375,11 @@ static int null_writer(struct driver_data *drv_data)
 
 static int null_reader(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
         u8 n_bytes = drv_data->n_bytes;
 
-        while ((read_SSSR(reg) & SSSR_RNE)
-                && (drv_data->rx < drv_data->rx_end)) {
-                read_SSDR(reg);
+        while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_RNE)
+               && (drv_data->rx < drv_data->rx_end)) {
+                pxa2xx_spi_read(drv_data, SSDR);
                 drv_data->rx += n_bytes;
         }
 
@@ -404,13 +388,11 @@ static int null_reader(struct driver_data *drv_data)
 
 static int u8_writer(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
-        write_SSDR(*(u8 *)(drv_data->tx), reg);
+        pxa2xx_spi_write(drv_data, SSDR, *(u8 *)(drv_data->tx));
         ++drv_data->tx;
 
         return 1;
@@ -418,11 +400,9 @@ static int u8_writer(struct driver_data *drv_data)
 
 static int u8_reader(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
-        while ((read_SSSR(reg) & SSSR_RNE)
-                && (drv_data->rx < drv_data->rx_end)) {
-                *(u8 *)(drv_data->rx) = read_SSDR(reg);
+        while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_RNE)
+               && (drv_data->rx < drv_data->rx_end)) {
+                *(u8 *)(drv_data->rx) = pxa2xx_spi_read(drv_data, SSDR);
                 ++drv_data->rx;
         }
 
@@ -431,13 +411,11 @@ static int u8_reader(struct driver_data *drv_data)
 
 static int u16_writer(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
-        write_SSDR(*(u16 *)(drv_data->tx), reg);
+        pxa2xx_spi_write(drv_data, SSDR, *(u16 *)(drv_data->tx));
         drv_data->tx += 2;
 
         return 1;
@@ -445,11 +423,9 @@ static int u16_writer(struct driver_data *drv_data)
 
 static int u16_reader(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
-        while ((read_SSSR(reg) & SSSR_RNE)
-                && (drv_data->rx < drv_data->rx_end)) {
-                *(u16 *)(drv_data->rx) = read_SSDR(reg);
+        while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_RNE)
+               && (drv_data->rx < drv_data->rx_end)) {
+                *(u16 *)(drv_data->rx) = pxa2xx_spi_read(drv_data, SSDR);
                 drv_data->rx += 2;
         }
 
@@ -458,13 +434,11 @@ static int u16_reader(struct driver_data *drv_data)
 
 static int u32_writer(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         if (pxa2xx_spi_txfifo_full(drv_data)
                 || (drv_data->tx == drv_data->tx_end))
                 return 0;
 
-        write_SSDR(*(u32 *)(drv_data->tx), reg);
+        pxa2xx_spi_write(drv_data, SSDR, *(u32 *)(drv_data->tx));
         drv_data->tx += 4;
 
         return 1;
@@ -472,11 +446,9 @@ static int u32_writer(struct driver_data *drv_data)
 
 static int u32_reader(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
-        while ((read_SSSR(reg) & SSSR_RNE)
-                && (drv_data->rx < drv_data->rx_end)) {
-                *(u32 *)(drv_data->rx) = read_SSDR(reg);
+        while ((pxa2xx_spi_read(drv_data, SSSR) & SSSR_RNE)
+               && (drv_data->rx < drv_data->rx_end)) {
+                *(u32 *)(drv_data->rx) = pxa2xx_spi_read(drv_data, SSDR);
                 drv_data->rx += 4;
         }
 
@@ -552,27 +524,25 @@ static void giveback(struct driver_data *drv_data)
 
 static void reset_sccr1(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
         struct chip_data *chip = drv_data->cur_chip;
         u32 sccr1_reg;
 
-        sccr1_reg = read_SSCR1(reg) & ~drv_data->int_cr1;
+        sccr1_reg = pxa2xx_spi_read(drv_data, SSCR1) & ~drv_data->int_cr1;
         sccr1_reg &= ~SSCR1_RFT;
         sccr1_reg |= chip->threshold;
-        write_SSCR1(sccr1_reg, reg);
+        pxa2xx_spi_write(drv_data, SSCR1, sccr1_reg);
 }
 
 static void int_error_stop(struct driver_data *drv_data, const char* msg)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         /* Stop and reset SSP */
         write_SSSR_CS(drv_data, drv_data->clear_sr);
         reset_sccr1(drv_data);
         if (!pxa25x_ssp_comp(drv_data))
-                write_SSTO(0, reg);
+                pxa2xx_spi_write(drv_data, SSTO, 0);
         pxa2xx_spi_flush(drv_data);
-        write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
+        pxa2xx_spi_write(drv_data, SSCR0,
+                         pxa2xx_spi_read(drv_data, SSCR0) & ~SSCR0_SSE);
 
         dev_err(&drv_data->pdev->dev, "%s\n", msg);
 
@@ -582,13 +552,11 @@ static void int_error_stop(struct driver_data *drv_data, const char* msg)
 
 static void int_transfer_complete(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         /* Stop SSP */
         write_SSSR_CS(drv_data, drv_data->clear_sr);
         reset_sccr1(drv_data);
         if (!pxa25x_ssp_comp(drv_data))
-                write_SSTO(0, reg);
+                pxa2xx_spi_write(drv_data, SSTO, 0);
 
         /* Update total byte transferred return count actual bytes read */
         drv_data->cur_msg->actual_length += drv_data->len -
@@ -607,12 +575,10 @@ static void int_transfer_complete(struct driver_data *drv_data)
 
 static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
 {
-        void __iomem *reg = drv_data->ioaddr;
+        u32 irq_mask = (pxa2xx_spi_read(drv_data, SSCR1) & SSCR1_TIE) ?
+                       drv_data->mask_sr : drv_data->mask_sr & ~SSSR_TFS;
 
-        u32 irq_mask = (read_SSCR1(reg) & SSCR1_TIE) ?
-                        drv_data->mask_sr : drv_data->mask_sr & ~SSSR_TFS;
-
-        u32 irq_status = read_SSSR(reg) & irq_mask;
+        u32 irq_status = pxa2xx_spi_read(drv_data, SSSR) & irq_mask;
 
         if (irq_status & SSSR_ROR) {
                 int_error_stop(drv_data, "interrupt_transfer: fifo overrun");
@@ -620,7 +586,7 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
         }
 
         if (irq_status & SSSR_TINT) {
-                write_SSSR(SSSR_TINT, reg);
+                pxa2xx_spi_write(drv_data, SSSR, SSSR_TINT);
                 if (drv_data->read(drv_data)) {
                         int_transfer_complete(drv_data);
                         return IRQ_HANDLED;
@@ -644,7 +610,7 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
                 u32 bytes_left;
                 u32 sccr1_reg;
 
-                sccr1_reg = read_SSCR1(reg);
+                sccr1_reg = pxa2xx_spi_read(drv_data, SSCR1);
                 sccr1_reg &= ~SSCR1_TIE;
 
                 /*
@@ -670,7 +636,7 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
 
                         pxa2xx_spi_set_rx_thre(drv_data, &sccr1_reg, rx_thre);
                 }
-                write_SSCR1(sccr1_reg, reg);
+                pxa2xx_spi_write(drv_data, SSCR1, sccr1_reg);
         }
 
         /* We did something */
@@ -680,7 +646,6 @@ static irqreturn_t interrupt_transfer(struct driver_data *drv_data)
 static irqreturn_t ssp_int(int irq, void *dev_id)
 {
         struct driver_data *drv_data = dev_id;
-        void __iomem *reg = drv_data->ioaddr;
         u32 sccr1_reg;
         u32 mask = drv_data->mask_sr;
         u32 status;
@@ -700,11 +665,11 @@ static irqreturn_t ssp_int(int irq, void *dev_id)
          * are all set to one. That means that the device is already
          * powered off.
          */
-        status = read_SSSR(reg);
+        status = pxa2xx_spi_read(drv_data, SSSR);
         if (status == ~0)
                 return IRQ_NONE;
 
-        sccr1_reg = read_SSCR1(reg);
+        sccr1_reg = pxa2xx_spi_read(drv_data, SSCR1);
 
         /* Ignore possible writes if we don't need to write */
         if (!(sccr1_reg & SSCR1_TIE))
@@ -715,10 +680,14 @@ static irqreturn_t ssp_int(int irq, void *dev_id)
 
         if (!drv_data->cur_msg) {
 
-                write_SSCR0(read_SSCR0(reg) & ~SSCR0_SSE, reg);
-                write_SSCR1(read_SSCR1(reg) & ~drv_data->int_cr1, reg);
+                pxa2xx_spi_write(drv_data, SSCR0,
+                                 pxa2xx_spi_read(drv_data, SSCR0)
+                                 & ~SSCR0_SSE);
+                pxa2xx_spi_write(drv_data, SSCR1,
+                                 pxa2xx_spi_read(drv_data, SSCR1)
+                                 & ~drv_data->int_cr1);
                 if (!pxa25x_ssp_comp(drv_data))
-                        write_SSTO(0, reg);
+                        pxa2xx_spi_write(drv_data, SSTO, 0);
                 write_SSSR_CS(drv_data, drv_data->clear_sr);
 
                 dev_err(&drv_data->pdev->dev,
@@ -787,7 +756,6 @@ static void pump_transfers(unsigned long data)
         struct spi_transfer *transfer = NULL;
         struct spi_transfer *previous = NULL;
         struct chip_data *chip = NULL;
-        void __iomem *reg = drv_data->ioaddr;
         u32 clk_div = 0;
         u8 bits = 0;
         u32 speed = 0;
@@ -931,7 +899,7 @@ static void pump_transfers(unsigned long data)
 
                 /* Clear status and start DMA engine */
                 cr1 = chip->cr1 | dma_thresh | drv_data->dma_cr1;
-                write_SSSR(drv_data->clear_sr, reg);
+                pxa2xx_spi_write(drv_data, SSSR, drv_data->clear_sr);
 
                 pxa2xx_spi_dma_start(drv_data);
         } else {
@@ -944,39 +912,43 @@ static void pump_transfers(unsigned long data)
         }
 
         if (is_lpss_ssp(drv_data)) {
-                if ((read_SSIRF(reg) & 0xff) != chip->lpss_rx_threshold)
-                        write_SSIRF(chip->lpss_rx_threshold, reg);
-                if ((read_SSITF(reg) & 0xffff) != chip->lpss_tx_threshold)
-                        write_SSITF(chip->lpss_tx_threshold, reg);
+                if ((pxa2xx_spi_read(drv_data, SSIRF) & 0xff)
+                    != chip->lpss_rx_threshold)
+                        pxa2xx_spi_write(drv_data, SSIRF,
+                                         chip->lpss_rx_threshold);
+                if ((pxa2xx_spi_read(drv_data, SSITF) & 0xffff)
+                    != chip->lpss_tx_threshold)
+                        pxa2xx_spi_write(drv_data, SSITF,
+                                         chip->lpss_tx_threshold);
         }
 
         if (is_quark_x1000_ssp(drv_data) &&
-            (read_DDS_RATE(reg) != chip->dds_rate))
-                write_DDS_RATE(chip->dds_rate, reg);
+            (pxa2xx_spi_read(drv_data, DDS_RATE) != chip->dds_rate))
+                pxa2xx_spi_write(drv_data, DDS_RATE, chip->dds_rate);
 
         /* see if we need to reload the config registers */
-        if ((read_SSCR0(reg) != cr0) ||
-            (read_SSCR1(reg) & change_mask) != (cr1 & change_mask)) {
-
+        if ((pxa2xx_spi_read(drv_data, SSCR0) != cr0)
+            || (pxa2xx_spi_read(drv_data, SSCR1) & change_mask)
+            != (cr1 & change_mask)) {
                 /* stop the SSP, and update the other bits */
-                write_SSCR0(cr0 & ~SSCR0_SSE, reg);
+                pxa2xx_spi_write(drv_data, SSCR0, cr0 & ~SSCR0_SSE);
                 if (!pxa25x_ssp_comp(drv_data))
-                        write_SSTO(chip->timeout, reg);
+                        pxa2xx_spi_write(drv_data, SSTO, chip->timeout);
                 /* first set CR1 without interrupt and service enables */
-                write_SSCR1(cr1 & change_mask, reg);
+                pxa2xx_spi_write(drv_data, SSCR1, cr1 & change_mask);
                 /* restart the SSP */
-                write_SSCR0(cr0, reg);
+                pxa2xx_spi_write(drv_data, SSCR0, cr0);
 
         } else {
                 if (!pxa25x_ssp_comp(drv_data))
-                        write_SSTO(chip->timeout, reg);
+                        pxa2xx_spi_write(drv_data, SSTO, chip->timeout);
         }
 
         cs_assert(drv_data);
 
         /* after chip select, release the data by enabling service
          * requests and interrupts, without changing any mode bits */
-        write_SSCR1(cr1, reg);
+        pxa2xx_spi_write(drv_data, SSCR1, cr1);
 }
 
 static int pxa2xx_spi_transfer_one_message(struct spi_master *master,
@@ -1005,8 +977,8 @@ static int pxa2xx_spi_unprepare_transfer(struct spi_master *master)
         struct driver_data *drv_data = spi_master_get_devdata(master);
 
         /* Disable the SSP now */
-        write_SSCR0(read_SSCR0(drv_data->ioaddr) & ~SSCR0_SSE,
-                    drv_data->ioaddr);
+        pxa2xx_spi_write(drv_data, SSCR0,
+                         pxa2xx_spi_read(drv_data, SSCR0) & ~SSCR0_SSE);
 
         return 0;
 }
@@ -1289,6 +1261,7 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
         struct driver_data *drv_data;
         struct ssp_device *ssp;
         int status;
+        u32 tmp;
 
         platform_info = dev_get_platdata(dev);
         if (!platform_info) {
@@ -1386,38 +1359,35 @@ static int pxa2xx_spi_probe(struct platform_device *pdev)
         drv_data->max_clk_rate = clk_get_rate(ssp->clk);
 
         /* Load default SSP configuration */
-        write_SSCR0(0, drv_data->ioaddr);
+        pxa2xx_spi_write(drv_data, SSCR0, 0);
         switch (drv_data->ssp_type) {
         case QUARK_X1000_SSP:
-                write_SSCR1(QUARK_X1000_SSCR1_RxTresh(
-                                        RX_THRESH_QUARK_X1000_DFLT) |
-                            QUARK_X1000_SSCR1_TxTresh(
-                                        TX_THRESH_QUARK_X1000_DFLT),
-                            drv_data->ioaddr);
+                tmp = QUARK_X1000_SSCR1_RxTresh(RX_THRESH_QUARK_X1000_DFLT)
+                      | QUARK_X1000_SSCR1_TxTresh(TX_THRESH_QUARK_X1000_DFLT);
+                pxa2xx_spi_write(drv_data, SSCR1, tmp);
 
                 /* using the Motorola SPI protocol and use 8 bit frame */
-                write_SSCR0(QUARK_X1000_SSCR0_Motorola
-                            | QUARK_X1000_SSCR0_DataSize(8),
-                            drv_data->ioaddr);
+                pxa2xx_spi_write(drv_data, SSCR0,
+                                 QUARK_X1000_SSCR0_Motorola
+                                 | QUARK_X1000_SSCR0_DataSize(8));
                 break;
         default:
-                write_SSCR1(SSCR1_RxTresh(RX_THRESH_DFLT) |
-                            SSCR1_TxTresh(TX_THRESH_DFLT),
-                            drv_data->ioaddr);
-                write_SSCR0(SSCR0_SCR(2)
-                            | SSCR0_Motorola
-                            | SSCR0_DataSize(8),
-                            drv_data->ioaddr);
+                tmp = SSCR1_RxTresh(RX_THRESH_DFLT) |
+                      SSCR1_TxTresh(TX_THRESH_DFLT);
+                pxa2xx_spi_write(drv_data, SSCR1, tmp);
+                tmp = SSCR0_SCR(2) | SSCR0_Motorola | SSCR0_DataSize(8);
+                pxa2xx_spi_write(drv_data, SSCR0, tmp);
                 break;
         }
 
         if (!pxa25x_ssp_comp(drv_data))
-                write_SSTO(0, drv_data->ioaddr);
+                pxa2xx_spi_write(drv_data, SSTO, 0);
 
         if (!is_quark_x1000_ssp(drv_data))
-                write_SSPSP(0, drv_data->ioaddr);
+                pxa2xx_spi_write(drv_data, SSPSP, 0);
 
-        lpss_ssp_setup(drv_data);
+        if (is_lpss_ssp(drv_data))
+                lpss_ssp_setup(drv_data);
 
         tasklet_init(&drv_data->pump_transfers, pump_transfers,
                      (unsigned long)drv_data);
@@ -1460,7 +1430,7 @@ static int pxa2xx_spi_remove(struct platform_device *pdev)
         pm_runtime_get_sync(&pdev->dev);
 
         /* Disable the SSP at the peripheral and SOC level */
-        write_SSCR0(0, drv_data->ioaddr);
+        pxa2xx_spi_write(drv_data, SSCR0, 0);
         clk_disable_unprepare(ssp->clk);
 
         /* Release DMA */
@@ -1497,7 +1467,7 @@ static int pxa2xx_spi_suspend(struct device *dev)
         status = spi_master_suspend(drv_data->master);
         if (status != 0)
                 return status;
-        write_SSCR0(0, drv_data->ioaddr);
+        pxa2xx_spi_write(drv_data, SSCR0, 0);
 
         if (!pm_runtime_suspended(dev))
                 clk_disable_unprepare(ssp->clk);
@@ -1518,7 +1488,8 @@ static int pxa2xx_spi_resume(struct device *dev)
                 clk_prepare_enable(ssp->clk);
 
         /* Restore LPSS private register bits */
-        lpss_ssp_setup(drv_data);
+        if (is_lpss_ssp(drv_data))
+                lpss_ssp_setup(drv_data);
 
         /* Start the queue running */
         status = spi_master_resume(drv_data->master);
diff --git a/drivers/spi/spi-pxa2xx.h b/drivers/spi/spi-pxa2xx.h
index 6bec59c90cd4..85a58c906869 100644
--- a/drivers/spi/spi-pxa2xx.h
+++ b/drivers/spi/spi-pxa2xx.h
@@ -115,23 +115,17 @@ struct chip_data {
         void (*cs_control)(u32 command);
 };
 
-#define DEFINE_SSP_REG(reg, off) \
-static inline u32 read_##reg(void const __iomem *p) \
-{ return __raw_readl(p + (off)); } \
-\
-static inline void write_##reg(u32 v, void __iomem *p) \
-{ __raw_writel(v, p + (off)); }
-
-DEFINE_SSP_REG(SSCR0, 0x00)
-DEFINE_SSP_REG(SSCR1, 0x04)
-DEFINE_SSP_REG(SSSR, 0x08)
-DEFINE_SSP_REG(SSITR, 0x0c)
-DEFINE_SSP_REG(SSDR, 0x10)
-DEFINE_SSP_REG(DDS_RATE, 0x28)  /* DDS Clock Rate */
-DEFINE_SSP_REG(SSTO, 0x28)
-DEFINE_SSP_REG(SSPSP, 0x2c)
-DEFINE_SSP_REG(SSITF, SSITF)
-DEFINE_SSP_REG(SSIRF, SSIRF)
+static inline u32 pxa2xx_spi_read(const struct driver_data *drv_data,
+                                  unsigned reg)
+{
+        return __raw_readl(drv_data->ioaddr + reg);
+}
+
+static  inline void pxa2xx_spi_write(const struct driver_data *drv_data,
+                                     unsigned reg, u32 val)
+{
+        __raw_writel(val, drv_data->ioaddr + reg);
+}
 
 #define START_STATE ((void *)0)
 #define RUNNING_STATE ((void *)1)
@@ -155,13 +149,11 @@ static inline int pxa25x_ssp_comp(struct driver_data *drv_data)
 
 static inline void write_SSSR_CS(struct driver_data *drv_data, u32 val)
 {
-        void __iomem *reg = drv_data->ioaddr;
-
         if (drv_data->ssp_type == CE4100_SSP ||
             drv_data->ssp_type == QUARK_X1000_SSP)
-                val |= read_SSSR(reg) & SSSR_ALT_FRM_MASK;
+                val |= pxa2xx_spi_read(drv_data, SSSR) & SSSR_ALT_FRM_MASK;
 
-        write_SSSR(val, reg);
+        pxa2xx_spi_write(drv_data, SSSR, val);
 }
 
 extern int pxa2xx_spi_flush(struct driver_data *drv_data);
diff --git a/drivers/spi/spi-qup.c b/drivers/spi/spi-qup.c
index e7fb5a0d2e8d..ff9cdbdb6672 100644
--- a/drivers/spi/spi-qup.c
+++ b/drivers/spi/spi-qup.c
@@ -337,7 +337,7 @@ static irqreturn_t spi_qup_qup_irq(int irq, void *dev_id)
 static int spi_qup_io_config(struct spi_device *spi, struct spi_transfer *xfer)
 {
         struct spi_qup *controller = spi_master_get_devdata(spi->master);
-        u32 config, iomode, mode;
+        u32 config, iomode, mode, control;
         int ret, n_words, w_size;
 
         if (spi->mode & SPI_LOOP && xfer->len > controller->in_fifo_sz) {
@@ -392,6 +392,15 @@ static int spi_qup_io_config(struct spi_device *spi, struct spi_transfer *xfer)
 
         writel_relaxed(iomode, controller->base + QUP_IO_M_MODES);
 
+        control = readl_relaxed(controller->base + SPI_IO_CONTROL);
+
+        if (spi->mode & SPI_CPOL)
+                control |= SPI_IO_C_CLK_IDLE_HIGH;
+        else
+                control &= ~SPI_IO_C_CLK_IDLE_HIGH;
+
+        writel_relaxed(control, controller->base + SPI_IO_CONTROL);
+
         config = readl_relaxed(controller->base + SPI_CONFIG);
 
         if (spi->mode & SPI_LOOP)
diff --git a/drivers/spi/spi-rockchip.c b/drivers/spi/spi-rockchip.c
index daabbabd26b0..1a777dc261d6 100644
--- a/drivers/spi/spi-rockchip.c
+++ b/drivers/spi/spi-rockchip.c
@@ -437,6 +437,7 @@ static void rockchip_spi_prepare_dma(struct rockchip_spi *rs)
         rs->state &= ~TXBUSY;
         spin_unlock_irqrestore(&rs->lock, flags);
 
+        rxdesc = NULL;
         if (rs->rx) {
                 rxconf.direction = rs->dma_rx.direction;
                 rxconf.src_addr = rs->dma_rx.addr;
@@ -453,6 +454,7 @@ static void rockchip_spi_prepare_dma(struct rockchip_spi *rs)
                 rxdesc->callback_param = rs;
         }
 
+        txdesc = NULL;
         if (rs->tx) {
                 txconf.direction = rs->dma_tx.direction;
                 txconf.dst_addr = rs->dma_tx.addr;
@@ -470,7 +472,7 @@ static void rockchip_spi_prepare_dma(struct rockchip_spi *rs)
         }
 
         /* rx must be started before tx due to spi instinct */
-        if (rs->rx) {
+        if (rxdesc) {
                 spin_lock_irqsave(&rs->lock, flags);
                 rs->state |= RXBUSY;
                 spin_unlock_irqrestore(&rs->lock, flags);
@@ -478,7 +480,7 @@ static void rockchip_spi_prepare_dma(struct rockchip_spi *rs)
                 dma_async_issue_pending(rs->dma_rx.ch);
         }
 
-        if (rs->tx) {
+        if (txdesc) {
                 spin_lock_irqsave(&rs->lock, flags);
                 rs->state |= TXBUSY;
                 spin_unlock_irqrestore(&rs->lock, flags);
diff --git a/drivers/spi/spi-rspi.c b/drivers/spi/spi-rspi.c
index 2071f788c6fb..46ce47076e63 100644
--- a/drivers/spi/spi-rspi.c
+++ b/drivers/spi/spi-rspi.c
@@ -15,11 +15,6 @@
  * 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>
diff --git a/drivers/spi/spi-s3c64xx.c b/drivers/spi/spi-s3c64xx.c
index 37b19836f5cb..9231c34b5a5c 100644
--- a/drivers/spi/spi-s3c64xx.c
+++ b/drivers/spi/spi-s3c64xx.c
@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/init.h>
diff --git a/drivers/spi/spi-sc18is602.c b/drivers/spi/spi-sc18is602.c
index 237f2e7a7179..5a56acf8a43e 100644
--- a/drivers/spi/spi-sc18is602.c
+++ b/drivers/spi/spi-sc18is602.c
@@ -12,10 +12,6 @@
  * 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>
diff --git a/drivers/spi/spi-sh-hspi.c b/drivers/spi/spi-sh-hspi.c
index fc29233d0650..20e800e70442 100644
--- a/drivers/spi/spi-sh-hspi.c
+++ b/drivers/spi/spi-sh-hspi.c
@@ -16,11 +16,6 @@
  * 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>
diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
index 3ab7a21445fc..e57eec0b2f46 100644
--- a/drivers/spi/spi-sh-msiof.c
+++ b/drivers/spi/spi-sh-msiof.c
@@ -82,6 +82,8 @@ struct sh_msiof_spi_priv {
 #define MDR1_SYNCMD_LR   0x30000000 /*   L/R mode */
 #define MDR1_SYNCAC_SHIFT        25 /* Sync Polarity (1 = Active-low) */
 #define MDR1_BITLSB_SHIFT        24 /* MSB/LSB First (1 = LSB first) */
+#define MDR1_DTDL_SHIFT          20 /* Data Pin Bit Delay for MSIOF_SYNC */
+#define MDR1_SYNCDL_SHIFT        16 /* Frame Sync Signal Timing Delay */
 #define MDR1_FLD_MASK    0x0000000c /* Frame Sync Signal Interval (0-3) */
 #define MDR1_FLD_SHIFT            2
 #define MDR1_XXSTP       0x00000001 /* Transmission/Reception Stop on FIFO */
@@ -241,42 +243,80 @@ static irqreturn_t sh_msiof_spi_irq(int irq, void *data)
 
 static struct {
         unsigned short div;
-        unsigned short scr;
-} const sh_msiof_spi_clk_table[] = {
-        { 1,    SCR_BRPS( 1) | SCR_BRDV_DIV_1 },
-        { 2,    SCR_BRPS( 1) | SCR_BRDV_DIV_2 },
-        { 4,    SCR_BRPS( 1) | SCR_BRDV_DIV_4 },
-        { 8,    SCR_BRPS( 1) | SCR_BRDV_DIV_8 },
-        { 16,   SCR_BRPS( 1) | SCR_BRDV_DIV_16 },
-        { 32,   SCR_BRPS( 1) | SCR_BRDV_DIV_32 },
-        { 64,   SCR_BRPS(32) | SCR_BRDV_DIV_2 },
-        { 128,  SCR_BRPS(32) | SCR_BRDV_DIV_4 },
-        { 256,  SCR_BRPS(32) | SCR_BRDV_DIV_8 },
-        { 512,  SCR_BRPS(32) | SCR_BRDV_DIV_16 },
-        { 1024, SCR_BRPS(32) | SCR_BRDV_DIV_32 },
+        unsigned short brdv;
+} const sh_msiof_spi_div_table[] = {
+        { 1,    SCR_BRDV_DIV_1 },
+        { 2,    SCR_BRDV_DIV_2 },
+        { 4,    SCR_BRDV_DIV_4 },
+        { 8,    SCR_BRDV_DIV_8 },
+        { 16,   SCR_BRDV_DIV_16 },
+        { 32,   SCR_BRDV_DIV_32 },
 };
 
 static void sh_msiof_spi_set_clk_regs(struct sh_msiof_spi_priv *p,
                                       unsigned long parent_rate, u32 spi_hz)
 {
         unsigned long div = 1024;
+        u32 brps, scr;
         size_t k;
 
         if (!WARN_ON(!spi_hz || !parent_rate))
                 div = DIV_ROUND_UP(parent_rate, spi_hz);
 
-        /* TODO: make more fine grained */
-
-        for (k = 0; k < ARRAY_SIZE(sh_msiof_spi_clk_table); k++) {
-                if (sh_msiof_spi_clk_table[k].div >= div)
+        for (k = 0; k < ARRAY_SIZE(sh_msiof_spi_div_table); k++) {
+                brps = DIV_ROUND_UP(div, sh_msiof_spi_div_table[k].div);
+                if (brps <= 32) /* max of brdv is 32 */
                         break;
         }
 
-        k = min_t(int, k, ARRAY_SIZE(sh_msiof_spi_clk_table) - 1);
+        k = min_t(int, k, ARRAY_SIZE(sh_msiof_spi_div_table) - 1);
 
-        sh_msiof_write(p, TSCR, sh_msiof_spi_clk_table[k].scr);
+        scr = sh_msiof_spi_div_table[k].brdv | SCR_BRPS(brps);
+        sh_msiof_write(p, TSCR, scr);
         if (!(p->chipdata->master_flags & SPI_MASTER_MUST_TX))
-                sh_msiof_write(p, RSCR, sh_msiof_spi_clk_table[k].scr);
+                sh_msiof_write(p, RSCR, scr);
+}
+
+static u32 sh_msiof_get_delay_bit(u32 dtdl_or_syncdl)
+{
+        /*
+         * DTDL/SYNCDL bit      : p->info->dtdl or p->info->syncdl
+         * b'000                : 0
+         * b'001                : 100
+         * b'010                : 200
+         * b'011 (SYNCDL only)  : 300
+         * b'101                : 50
+         * b'110                : 150
+         */
+        if (dtdl_or_syncdl % 100)
+                return dtdl_or_syncdl / 100 + 5;
+        else
+                return dtdl_or_syncdl / 100;
+}
+
+static u32 sh_msiof_spi_get_dtdl_and_syncdl(struct sh_msiof_spi_priv *p)
+{
+        u32 val;
+
+        if (!p->info)
+                return 0;
+
+        /* check if DTDL and SYNCDL is allowed value */
+        if (p->info->dtdl > 200 || p->info->syncdl > 300) {
+                dev_warn(&p->pdev->dev, "DTDL or SYNCDL is too large\n");
+                return 0;
+        }
+
+        /* check if the sum of DTDL and SYNCDL becomes an integer value  */
+        if ((p->info->dtdl + p->info->syncdl) % 100) {
+                dev_warn(&p->pdev->dev, "the sum of DTDL/SYNCDL is not good\n");
+                return 0;
+        }
+
+        val = sh_msiof_get_delay_bit(p->info->dtdl) << MDR1_DTDL_SHIFT;
+        val |= sh_msiof_get_delay_bit(p->info->syncdl) << MDR1_SYNCDL_SHIFT;
+
+        return val;
 }
 
 static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p,
@@ -296,6 +336,7 @@ static void sh_msiof_spi_set_pin_regs(struct sh_msiof_spi_priv *p,
         tmp = MDR1_SYNCMD_SPI | 1 << MDR1_FLD_SHIFT | MDR1_XXSTP;
         tmp |= !cs_high << MDR1_SYNCAC_SHIFT;
         tmp |= lsb_first << MDR1_BITLSB_SHIFT;
+        tmp |= sh_msiof_spi_get_dtdl_and_syncdl(p);
         sh_msiof_write(p, TMDR1, tmp | MDR1_TRMD | TMDR1_PCON);
         if (p->chipdata->master_flags & SPI_MASTER_MUST_TX) {
                 /* These bits are reserved if RX needs TX */
@@ -501,7 +542,7 @@ static int sh_msiof_spi_setup(struct spi_device *spi)
                 gpio_set_value(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));
 
 
-        pm_runtime_put_sync(&p->pdev->dev);
+        pm_runtime_put(&p->pdev->dev);
 
         return 0;
 }
@@ -595,8 +636,7 @@ static int sh_msiof_spi_txrx_once(struct sh_msiof_spi_priv *p,
         }
 
         /* wait for tx fifo to be emptied / rx fifo to be filled */
-        ret = wait_for_completion_timeout(&p->done, HZ);
-        if (!ret) {
+        if (!wait_for_completion_timeout(&p->done, HZ)) {
                 dev_err(&p->pdev->dev, "PIO timeout\n");
                 ret = -ETIMEDOUT;
                 goto stop_reset;
@@ -706,8 +746,7 @@ static int sh_msiof_dma_once(struct sh_msiof_spi_priv *p, const void *tx,
         }
 
         /* wait for tx fifo to be emptied / rx fifo to be filled */
-        ret = wait_for_completion_timeout(&p->done, HZ);
-        if (!ret) {
+        if (!wait_for_completion_timeout(&p->done, HZ)) {
                 dev_err(&p->pdev->dev, "DMA timeout\n");
                 ret = -ETIMEDOUT;
                 goto stop_reset;
@@ -957,6 +996,8 @@ static struct sh_msiof_spi_info *sh_msiof_spi_parse_dt(struct device *dev)
                                         &info->tx_fifo_override);
         of_property_read_u32(np, "renesas,rx-fifo-size",
                                         &info->rx_fifo_override);
+        of_property_read_u32(np, "renesas,dtdl", &info->dtdl);
+        of_property_read_u32(np, "renesas,syncdl", &info->syncdl);
 
         info->num_chipselect = num_cs;
 
diff --git a/drivers/spi/spi-sh.c b/drivers/spi/spi-sh.c
index 1cfc906dd174..502501187c9e 100644
--- a/drivers/spi/spi-sh.c
+++ b/drivers/spi/spi-sh.c
@@ -14,11 +14,6 @@
  * 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>
diff --git a/drivers/spi/spi-sirf.c b/drivers/spi/spi-sirf.c
index d075191476f0..f5715c9f68b0 100644
--- a/drivers/spi/spi-sirf.c
+++ b/drivers/spi/spi-sirf.c
@@ -818,7 +818,6 @@ static SIMPLE_DEV_PM_OPS(spi_sirfsoc_pm_ops, spi_sirfsoc_suspend,
 
 static const struct of_device_id spi_sirfsoc_of_match[] = {
         { .compatible = "sirf,prima2-spi", },
-        { .compatible = "sirf,marco-spi", },
         {}
 };
 MODULE_DEVICE_TABLE(of, spi_sirfsoc_of_match);
diff --git a/drivers/spi/spi-st-ssc4.c b/drivers/spi/spi-st-ssc4.c
new file mode 100644
index 000000000000..2faeaa7b57a8
--- /dev/null
+++ b/drivers/spi/spi-st-ssc4.c
@@ -0,0 +1,504 @@
+/*
+ *  Copyright (c) 2008-2014 STMicroelectronics Limited
+ *
+ *  Author: Angus Clark <Angus.Clark@st.com>
+ *          Patrice Chotard <patrice.chotard@st.com>
+ *          Lee Jones <lee.jones@linaro.org>
+ *
+ *  SPI master mode controller driver, used in STMicroelectronics devices.
+ *
+ *  May be copied or modified under the terms of the GNU General Public
+ *  License Version 2.0 only.  See linux/COPYING for more information.
+ */
+
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/pinctrl/consumer.h>
+#include <linux/platform_device.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/of_irq.h>
+#include <linux/pm_runtime.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi_bitbang.h>
+
+/* SSC registers */
+#define SSC_BRG                         0x000
+#define SSC_TBUF                        0x004
+#define SSC_RBUF                        0x008
+#define SSC_CTL                         0x00C
+#define SSC_IEN                         0x010
+#define SSC_I2C                         0x018
+
+/* SSC Control */
+#define SSC_CTL_DATA_WIDTH_9            0x8
+#define SSC_CTL_DATA_WIDTH_MSK          0xf
+#define SSC_CTL_BM                      0xf
+#define SSC_CTL_HB                      BIT(4)
+#define SSC_CTL_PH                      BIT(5)
+#define SSC_CTL_PO                      BIT(6)
+#define SSC_CTL_SR                      BIT(7)
+#define SSC_CTL_MS                      BIT(8)
+#define SSC_CTL_EN                      BIT(9)
+#define SSC_CTL_LPB                     BIT(10)
+#define SSC_CTL_EN_TX_FIFO              BIT(11)
+#define SSC_CTL_EN_RX_FIFO              BIT(12)
+#define SSC_CTL_EN_CLST_RX              BIT(13)
+
+/* SSC Interrupt Enable */
+#define SSC_IEN_TEEN                    BIT(2)
+
+#define FIFO_SIZE                       8
+
+struct spi_st {
+        /* SSC SPI Controller */
+        void __iomem            *base;
+        struct clk              *clk;
+        struct device           *dev;
+
+        /* SSC SPI current transaction */
+        const u8                *tx_ptr;
+        u8                      *rx_ptr;
+        u16                     bytes_per_word;
+        unsigned int            words_remaining;
+        unsigned int            baud;
+        struct completion       done;
+};
+
+static int spi_st_clk_enable(struct spi_st *spi_st)
+{
+        /*
+         * Current platforms use one of the core clocks for SPI and I2C.
+         * If we attempt to disable the clock, the system will hang.
+         *
+         * TODO: Remove this when platform supports power domains.
+         */
+        return 0;
+
+        return clk_prepare_enable(spi_st->clk);
+}
+
+static void spi_st_clk_disable(struct spi_st *spi_st)
+{
+        /*
+         * Current platforms use one of the core clocks for SPI and I2C.
+         * If we attempt to disable the clock, the system will hang.
+         *
+         * TODO: Remove this when platform supports power domains.
+         */
+        return;
+
+        clk_disable_unprepare(spi_st->clk);
+}
+
+/* Load the TX FIFO */
+static void ssc_write_tx_fifo(struct spi_st *spi_st)
+{
+        unsigned int count, i;
+        uint32_t word = 0;
+
+        if (spi_st->words_remaining > FIFO_SIZE)
+                count = FIFO_SIZE;
+        else
+                count = spi_st->words_remaining;
+
+        for (i = 0; i < count; i++) {
+                if (spi_st->tx_ptr) {
+                        if (spi_st->bytes_per_word == 1) {
+                                word = *spi_st->tx_ptr++;
+                        } else {
+                                word = *spi_st->tx_ptr++;
+                                word = *spi_st->tx_ptr++ | (word << 8);
+                        }
+                }
+                writel_relaxed(word, spi_st->base + SSC_TBUF);
+        }
+}
+
+/* Read the RX FIFO */
+static void ssc_read_rx_fifo(struct spi_st *spi_st)
+{
+        unsigned int count, i;
+        uint32_t word = 0;
+
+        if (spi_st->words_remaining > FIFO_SIZE)
+                count = FIFO_SIZE;
+        else
+                count = spi_st->words_remaining;
+
+        for (i = 0; i < count; i++) {
+                word = readl_relaxed(spi_st->base + SSC_RBUF);
+
+                if (spi_st->rx_ptr) {
+                        if (spi_st->bytes_per_word == 1) {
+                                *spi_st->rx_ptr++ = (uint8_t)word;
+                        } else {
+                                *spi_st->rx_ptr++ = (word >> 8);
+                                *spi_st->rx_ptr++ = word & 0xff;
+                        }
+                }
+        }
+        spi_st->words_remaining -= count;
+}
+
+static int spi_st_transfer_one(struct spi_master *master,
+                               struct spi_device *spi, struct spi_transfer *t)
+{
+        struct spi_st *spi_st = spi_master_get_devdata(master);
+        uint32_t ctl = 0;
+
+        /* Setup transfer */
+        spi_st->tx_ptr = t->tx_buf;
+        spi_st->rx_ptr = t->rx_buf;
+
+        if (spi->bits_per_word > 8) {
+                /*
+                 * Anything greater than 8 bits-per-word requires 2
+                 * bytes-per-word in the RX/TX buffers
+                 */
+                spi_st->bytes_per_word = 2;
+                spi_st->words_remaining = t->len / 2;
+
+        } else if (spi->bits_per_word == 8 && !(t->len & 0x1)) {
+                /*
+                 * If transfer is even-length, and 8 bits-per-word, then
+                 * implement as half-length 16 bits-per-word transfer
+                 */
+                spi_st->bytes_per_word = 2;
+                spi_st->words_remaining = t->len / 2;
+
+                /* Set SSC_CTL to 16 bits-per-word */
+                ctl = readl_relaxed(spi_st->base + SSC_CTL);
+                writel_relaxed((ctl | 0xf), spi_st->base + SSC_CTL);
+
+                readl_relaxed(spi_st->base + SSC_RBUF);
+
+        } else {
+                spi_st->bytes_per_word = 1;
+                spi_st->words_remaining = t->len;
+        }
+
+        reinit_completion(&spi_st->done);
+
+        /* Start transfer by writing to the TX FIFO */
+        ssc_write_tx_fifo(spi_st);
+        writel_relaxed(SSC_IEN_TEEN, spi_st->base + SSC_IEN);
+
+        /* Wait for transfer to complete */
+        wait_for_completion(&spi_st->done);
+
+        /* Restore SSC_CTL if necessary */
+        if (ctl)
+                writel_relaxed(ctl, spi_st->base + SSC_CTL);
+
+        spi_finalize_current_transfer(spi->master);
+
+        return t->len;
+}
+
+static void spi_st_cleanup(struct spi_device *spi)
+{
+        int cs = spi->cs_gpio;
+
+        if (gpio_is_valid(cs))
+                devm_gpio_free(&spi->dev, cs);
+}
+
+/* the spi->mode bits understood by this driver: */
+#define MODEBITS  (SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST | SPI_LOOP | SPI_CS_HIGH)
+static int spi_st_setup(struct spi_device *spi)
+{
+        struct spi_st *spi_st = spi_master_get_devdata(spi->master);
+        u32 spi_st_clk, sscbrg, var;
+        u32 hz = spi->max_speed_hz;
+        int cs = spi->cs_gpio;
+        int ret;
+
+        if (!hz)  {
+                dev_err(&spi->dev, "max_speed_hz unspecified\n");
+                return -EINVAL;
+        }
+
+        if (!gpio_is_valid(cs)) {
+                dev_err(&spi->dev, "%d is not a valid gpio\n", cs);
+                return -EINVAL;
+        }
+
+        if (devm_gpio_request(&spi->dev, cs, dev_name(&spi->dev))) {
+                dev_err(&spi->dev, "could not request gpio:%d\n", cs);
+                return -EINVAL;
+        }
+
+        ret = gpio_direction_output(cs, spi->mode & SPI_CS_HIGH);
+        if (ret)
+                return ret;
+
+        spi_st_clk = clk_get_rate(spi_st->clk);
+
+        /* Set SSC_BRF */
+        sscbrg = spi_st_clk / (2 * hz);
+        if (sscbrg < 0x07 || sscbrg > BIT(16)) {
+                dev_err(&spi->dev,
+                        "baudrate %d outside valid range %d\n", sscbrg, hz);
+                return -EINVAL;
+        }
+
+        spi_st->baud = spi_st_clk / (2 * sscbrg);
+        if (sscbrg == BIT(16)) /* 16-bit counter wraps */
+                sscbrg = 0x0;
+
+        writel_relaxed(sscbrg, spi_st->base + SSC_BRG);
+
+        dev_dbg(&spi->dev,
+                "setting baudrate:target= %u hz, actual= %u hz, sscbrg= %u\n",
+                hz, spi_st->baud, sscbrg);
+
+         /* Set SSC_CTL and enable SSC */
+         var = readl_relaxed(spi_st->base + SSC_CTL);
+         var |= SSC_CTL_MS;
+
+         if (spi->mode & SPI_CPOL)
+                var |= SSC_CTL_PO;
+         else
+                var &= ~SSC_CTL_PO;
+
+         if (spi->mode & SPI_CPHA)
+                var |= SSC_CTL_PH;
+         else
+                var &= ~SSC_CTL_PH;
+
+         if ((spi->mode & SPI_LSB_FIRST) == 0)
+                var |= SSC_CTL_HB;
+         else
+                var &= ~SSC_CTL_HB;
+
+         if (spi->mode & SPI_LOOP)
+                var |= SSC_CTL_LPB;
+         else
+                var &= ~SSC_CTL_LPB;
+
+         var &= ~SSC_CTL_DATA_WIDTH_MSK;
+         var |= (spi->bits_per_word - 1);
+
+         var |= SSC_CTL_EN_TX_FIFO | SSC_CTL_EN_RX_FIFO;
+         var |= SSC_CTL_EN;
+
+         writel_relaxed(var, spi_st->base + SSC_CTL);
+
+         /* Clear the status register */
+         readl_relaxed(spi_st->base + SSC_RBUF);
+
+         return 0;
+}
+
+/* Interrupt fired when TX shift register becomes empty */
+static irqreturn_t spi_st_irq(int irq, void *dev_id)
+{
+        struct spi_st *spi_st = (struct spi_st *)dev_id;
+
+        /* Read RX FIFO */
+        ssc_read_rx_fifo(spi_st);
+
+        /* Fill TX FIFO */
+        if (spi_st->words_remaining) {
+                ssc_write_tx_fifo(spi_st);
+        } else {
+                /* TX/RX complete */
+                writel_relaxed(0x0, spi_st->base + SSC_IEN);
+                /*
+                 * read SSC_IEN to ensure that this bit is set
+                 * before re-enabling interrupt
+                 */
+                readl(spi_st->base + SSC_IEN);
+                complete(&spi_st->done);
+        }
+
+        return IRQ_HANDLED;
+}
+
+static int spi_st_probe(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct spi_master *master;
+        struct resource *res;
+        struct spi_st *spi_st;
+        int irq, ret = 0;
+        u32 var;
+
+        master = spi_alloc_master(&pdev->dev, sizeof(*spi_st));
+        if (!master)
+                return -ENOMEM;
+
+        master->dev.of_node             = np;
+        master->mode_bits               = MODEBITS;
+        master->setup                   = spi_st_setup;
+        master->cleanup                 = spi_st_cleanup;
+        master->transfer_one            = spi_st_transfer_one;
+        master->bits_per_word_mask      = SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
+        master->auto_runtime_pm         = true;
+        master->bus_num                 = pdev->id;
+        spi_st                          = spi_master_get_devdata(master);
+
+        spi_st->clk = devm_clk_get(&pdev->dev, "ssc");
+        if (IS_ERR(spi_st->clk)) {
+                dev_err(&pdev->dev, "Unable to request clock\n");
+                return PTR_ERR(spi_st->clk);
+        }
+
+        ret = spi_st_clk_enable(spi_st);
+        if (ret)
+                return ret;
+
+        init_completion(&spi_st->done);
+
+        /* Get resources */
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        spi_st->base = devm_ioremap_resource(&pdev->dev, res);
+        if (IS_ERR(spi_st->base)) {
+                ret = PTR_ERR(spi_st->base);
+                goto clk_disable;
+        }
+
+        /* Disable I2C and Reset SSC */
+        writel_relaxed(0x0, spi_st->base + SSC_I2C);
+        var = readw_relaxed(spi_st->base + SSC_CTL);
+        var |= SSC_CTL_SR;
+        writel_relaxed(var, spi_st->base + SSC_CTL);
+
+        udelay(1);
+        var = readl_relaxed(spi_st->base + SSC_CTL);
+        var &= ~SSC_CTL_SR;
+        writel_relaxed(var, spi_st->base + SSC_CTL);
+
+        /* Set SSC into slave mode before reconfiguring PIO pins */
+        var = readl_relaxed(spi_st->base + SSC_CTL);
+        var &= ~SSC_CTL_MS;
+        writel_relaxed(var, spi_st->base + SSC_CTL);
+
+        irq = irq_of_parse_and_map(np, 0);
+        if (!irq) {
+                dev_err(&pdev->dev, "IRQ missing or invalid\n");
+                ret = -EINVAL;
+                goto clk_disable;
+        }
+
+        ret = devm_request_irq(&pdev->dev, irq, spi_st_irq, 0,
+                               pdev->name, spi_st);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to request irq %d\n", irq);
+                goto clk_disable;
+        }
+
+        /* by default the device is on */
+        pm_runtime_set_active(&pdev->dev);
+        pm_runtime_enable(&pdev->dev);
+
+        platform_set_drvdata(pdev, master);
+
+        ret = devm_spi_register_master(&pdev->dev, master);
+        if (ret) {
+                dev_err(&pdev->dev, "Failed to register master\n");
+                goto clk_disable;
+        }
+
+        return 0;
+
+clk_disable:
+        spi_st_clk_disable(spi_st);
+
+        return ret;
+}
+
+static int spi_st_remove(struct platform_device *pdev)
+{
+        struct spi_master *master = platform_get_drvdata(pdev);
+        struct spi_st *spi_st = spi_master_get_devdata(master);
+
+        spi_st_clk_disable(spi_st);
+
+        pinctrl_pm_select_sleep_state(&pdev->dev);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int spi_st_runtime_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct spi_st *spi_st = spi_master_get_devdata(master);
+
+        writel_relaxed(0, spi_st->base + SSC_IEN);
+        pinctrl_pm_select_sleep_state(dev);
+
+        spi_st_clk_disable(spi_st);
+
+        return 0;
+}
+
+static int spi_st_runtime_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        struct spi_st *spi_st = spi_master_get_devdata(master);
+        int ret;
+
+        ret = spi_st_clk_enable(spi_st);
+        pinctrl_pm_select_default_state(dev);
+
+        return ret;
+}
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+static int spi_st_suspend(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        int ret;
+
+        ret = spi_master_suspend(master);
+        if (ret)
+                return ret;
+
+        return pm_runtime_force_suspend(dev);
+}
+
+static int spi_st_resume(struct device *dev)
+{
+        struct spi_master *master = dev_get_drvdata(dev);
+        int ret;
+
+        ret = spi_master_resume(master);
+        if (ret)
+                return ret;
+
+        return pm_runtime_force_resume(dev);
+}
+#endif
+
+static const struct dev_pm_ops spi_st_pm = {
+        SET_SYSTEM_SLEEP_PM_OPS(spi_st_suspend, spi_st_resume)
+        SET_RUNTIME_PM_OPS(spi_st_runtime_suspend, spi_st_runtime_resume, NULL)
+};
+
+static struct of_device_id stm_spi_match[] = {
+        { .compatible = "st,comms-ssc4-spi", },
+        {},
+};
+MODULE_DEVICE_TABLE(of, stm_spi_match);
+
+static struct platform_driver spi_st_driver = {
+        .driver = {
+                .name = "spi-st",
+                .pm = &spi_st_pm,
+                .of_match_table = of_match_ptr(stm_spi_match),
+        },
+        .probe = spi_st_probe,
+        .remove = spi_st_remove,
+};
+module_platform_driver(spi_st_driver);
+
+MODULE_AUTHOR("Patrice Chotard <patrice.chotard@st.com>");
+MODULE_DESCRIPTION("STM SSC SPI driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/spi/spi-ti-qspi.c b/drivers/spi/spi-ti-qspi.c
index 6146c4cd6583..884a716e50cb 100644
--- a/drivers/spi/spi-ti-qspi.c
+++ b/drivers/spi/spi-ti-qspi.c
@@ -201,7 +201,7 @@ static void ti_qspi_restore_ctx(struct ti_qspi *qspi)
 
 static int qspi_write_msg(struct ti_qspi *qspi, struct spi_transfer *t)
 {
-        int wlen, count, ret;
+        int wlen, count;
         unsigned int cmd;
         const u8 *txbuf;
 
@@ -230,9 +230,8 @@ static int qspi_write_msg(struct ti_qspi *qspi, struct spi_transfer *t)
                 }
 
                 ti_qspi_write(qspi, cmd, QSPI_SPI_CMD_REG);
-                ret = wait_for_completion_timeout(&qspi->transfer_complete,
-                                                  QSPI_COMPLETION_TIMEOUT);
-                if (ret == 0) {
+                if (!wait_for_completion_timeout(&qspi->transfer_complete,
+                                                 QSPI_COMPLETION_TIMEOUT)) {
                         dev_err(qspi->dev, "write timed out\n");
                         return -ETIMEDOUT;
                 }
@@ -245,7 +244,7 @@ static int qspi_write_msg(struct ti_qspi *qspi, struct spi_transfer *t)
 
 static int qspi_read_msg(struct ti_qspi *qspi, struct spi_transfer *t)
 {
-        int wlen, count, ret;
+        int wlen, count;
         unsigned int cmd;
         u8 *rxbuf;
 
@@ -268,9 +267,8 @@ static int qspi_read_msg(struct ti_qspi *qspi, struct spi_transfer *t)
         while (count) {
                 dev_dbg(qspi->dev, "rx cmd %08x dc %08x\n", cmd, qspi->dc);
                 ti_qspi_write(qspi, cmd, QSPI_SPI_CMD_REG);
-                ret = wait_for_completion_timeout(&qspi->transfer_complete,
-                                QSPI_COMPLETION_TIMEOUT);
-                if (ret == 0) {
+                if (!wait_for_completion_timeout(&qspi->transfer_complete,
+                                                 QSPI_COMPLETION_TIMEOUT)) {
                         dev_err(qspi->dev, "read timed out\n");
                         return -ETIMEDOUT;
                 }
diff --git a/drivers/spi/spi-topcliff-pch.c b/drivers/spi/spi-topcliff-pch.c
index be692ad50442..93dfcee0f987 100644
--- a/drivers/spi/spi-topcliff-pch.c
+++ b/drivers/spi/spi-topcliff-pch.c
@@ -11,10 +11,6 @@
  * 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/delay.h>
diff --git a/drivers/spi/spi-xilinx.c b/drivers/spi/spi-xilinx.c
index 79bd84f43430..133f53a9c1d4 100644
--- a/drivers/spi/spi-xilinx.c
+++ b/drivers/spi/spi-xilinx.c
@@ -22,6 +22,8 @@
 #include <linux/spi/xilinx_spi.h>
 #include <linux/io.h>
 
+#define XILINX_SPI_MAX_CS       32
+
 #define XILINX_SPI_NAME "xilinx_spi"
 
 /* Register definitions as per "OPB Serial Peripheral Interface (SPI) (v1.00e)
@@ -34,7 +36,8 @@
 #define XSPI_CR_MASTER_MODE     0x04
 #define XSPI_CR_CPOL            0x08
 #define XSPI_CR_CPHA            0x10
-#define XSPI_CR_MODE_MASK       (XSPI_CR_CPHA | XSPI_CR_CPOL)
+#define XSPI_CR_MODE_MASK       (XSPI_CR_CPHA | XSPI_CR_CPOL | \
+                                 XSPI_CR_LSB_FIRST | XSPI_CR_LOOP)
 #define XSPI_CR_TXFIFO_RESET    0x20
 #define XSPI_CR_RXFIFO_RESET    0x40
 #define XSPI_CR_MANUAL_SSELECT  0x80
@@ -85,12 +88,11 @@ struct xilinx_spi {
 
         u8 *rx_ptr;             /* pointer in the Tx buffer */
         const u8 *tx_ptr;       /* pointer in the Rx buffer */
-        int remaining_bytes;    /* the number of bytes left to transfer */
-        u8 bits_per_word;
+        u8 bytes_per_word;
+        int buffer_size;        /* buffer size in words */
+        u32 cs_inactive;        /* Level of the CS pins when inactive*/
         unsigned int (*read_fn)(void __iomem *);
         void (*write_fn)(u32, void __iomem *);
-        void (*tx_fn)(struct xilinx_spi *);
-        void (*rx_fn)(struct xilinx_spi *);
 };
 
 static void xspi_write32(u32 val, void __iomem *addr)
@@ -113,49 +115,51 @@ static unsigned int xspi_read32_be(void __iomem *addr)
         return ioread32be(addr);
 }
 
-static void xspi_tx8(struct xilinx_spi *xspi)
+static void xilinx_spi_tx(struct xilinx_spi *xspi)
 {
-        xspi->write_fn(*xspi->tx_ptr, xspi->regs + XSPI_TXD_OFFSET);
-        xspi->tx_ptr++;
-}
-
-static void xspi_tx16(struct xilinx_spi *xspi)
-{
-        xspi->write_fn(*(u16 *)(xspi->tx_ptr), xspi->regs + XSPI_TXD_OFFSET);
-        xspi->tx_ptr += 2;
-}
+        u32 data = 0;
 
-static void xspi_tx32(struct xilinx_spi *xspi)
-{
-        xspi->write_fn(*(u32 *)(xspi->tx_ptr), xspi->regs + XSPI_TXD_OFFSET);
-        xspi->tx_ptr += 4;
-}
-
-static void xspi_rx8(struct xilinx_spi *xspi)
-{
-        u32 data = xspi->read_fn(xspi->regs + XSPI_RXD_OFFSET);
-        if (xspi->rx_ptr) {
-                *xspi->rx_ptr = data & 0xff;
-                xspi->rx_ptr++;
+        if (!xspi->tx_ptr) {
+                xspi->write_fn(0, xspi->regs + XSPI_TXD_OFFSET);
+                return;
         }
-}
 
-static void xspi_rx16(struct xilinx_spi *xspi)
-{
-        u32 data = xspi->read_fn(xspi->regs + XSPI_RXD_OFFSET);
-        if (xspi->rx_ptr) {
-                *(u16 *)(xspi->rx_ptr) = data & 0xffff;
-                xspi->rx_ptr += 2;
+        switch (xspi->bytes_per_word) {
+        case 1:
+                data = *(u8 *)(xspi->tx_ptr);
+                break;
+        case 2:
+                data = *(u16 *)(xspi->tx_ptr);
+                break;
+        case 4:
+                data = *(u32 *)(xspi->tx_ptr);
+                break;
         }
+
+        xspi->write_fn(data, xspi->regs + XSPI_TXD_OFFSET);
+        xspi->tx_ptr += xspi->bytes_per_word;
 }
 
-static void xspi_rx32(struct xilinx_spi *xspi)
+static void xilinx_spi_rx(struct xilinx_spi *xspi)
 {
         u32 data = xspi->read_fn(xspi->regs + XSPI_RXD_OFFSET);
-        if (xspi->rx_ptr) {
+
+        if (!xspi->rx_ptr)
+                return;
+
+        switch (xspi->bytes_per_word) {
+        case 1:
+                *(u8 *)(xspi->rx_ptr) = data;
+                break;
+        case 2:
+                *(u16 *)(xspi->rx_ptr) = data;
+                break;
+        case 4:
                 *(u32 *)(xspi->rx_ptr) = data;
-                xspi->rx_ptr += 4;
+                break;
         }
+
+        xspi->rx_ptr += xspi->bytes_per_word;
 }
 
 static void xspi_init_hw(struct xilinx_spi *xspi)
@@ -165,46 +169,56 @@ static void xspi_init_hw(struct xilinx_spi *xspi)
         /* Reset the SPI device */
         xspi->write_fn(XIPIF_V123B_RESET_MASK,
                 regs_base + XIPIF_V123B_RESETR_OFFSET);
-        /* Disable all the interrupts just in case */
-        xspi->write_fn(0, regs_base + XIPIF_V123B_IIER_OFFSET);
-        /* Enable the global IPIF interrupt */
-        xspi->write_fn(XIPIF_V123B_GINTR_ENABLE,
-                regs_base + XIPIF_V123B_DGIER_OFFSET);
+        /* Enable the transmit empty interrupt, which we use to determine
+         * progress on the transmission.
+         */
+        xspi->write_fn(XSPI_INTR_TX_EMPTY,
+                        regs_base + XIPIF_V123B_IIER_OFFSET);
+        /* Disable the global IPIF interrupt */
+        xspi->write_fn(0, regs_base + XIPIF_V123B_DGIER_OFFSET);
         /* Deselect the slave on the SPI bus */
         xspi->write_fn(0xffff, regs_base + XSPI_SSR_OFFSET);
         /* Disable the transmitter, enable Manual Slave Select Assertion,
          * put SPI controller into master mode, and enable it */
-        xspi->write_fn(XSPI_CR_TRANS_INHIBIT | XSPI_CR_MANUAL_SSELECT |
-                XSPI_CR_MASTER_MODE | XSPI_CR_ENABLE | XSPI_CR_TXFIFO_RESET |
-                XSPI_CR_RXFIFO_RESET, regs_base + XSPI_CR_OFFSET);
+        xspi->write_fn(XSPI_CR_MANUAL_SSELECT | XSPI_CR_MASTER_MODE |
+                XSPI_CR_ENABLE | XSPI_CR_TXFIFO_RESET | XSPI_CR_RXFIFO_RESET,
+                regs_base + XSPI_CR_OFFSET);
 }
 
 static void xilinx_spi_chipselect(struct spi_device *spi, int is_on)
 {
         struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
+        u16 cr;
+        u32 cs;
 
         if (is_on == BITBANG_CS_INACTIVE) {
                 /* Deselect the slave on the SPI bus */
-                xspi->write_fn(0xffff, xspi->regs + XSPI_SSR_OFFSET);
-        } else if (is_on == BITBANG_CS_ACTIVE) {
-                /* Set the SPI clock phase and polarity */
-                u16 cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET)
-                         & ~XSPI_CR_MODE_MASK;
-                if (spi->mode & SPI_CPHA)
-                        cr |= XSPI_CR_CPHA;
-                if (spi->mode & SPI_CPOL)
-                        cr |= XSPI_CR_CPOL;
-                xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
-
-                /* We do not check spi->max_speed_hz here as the SPI clock
-                 * frequency is not software programmable (the IP block design
-                 * parameter)
-                 */
-
-                /* Activate the chip select */
-                xspi->write_fn(~(0x0001 << spi->chip_select),
-                        xspi->regs + XSPI_SSR_OFFSET);
+                xspi->write_fn(xspi->cs_inactive, xspi->regs + XSPI_SSR_OFFSET);
+                return;
         }
+
+        /* Set the SPI clock phase and polarity */
+        cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET) & ~XSPI_CR_MODE_MASK;
+        if (spi->mode & SPI_CPHA)
+                cr |= XSPI_CR_CPHA;
+        if (spi->mode & SPI_CPOL)
+                cr |= XSPI_CR_CPOL;
+        if (spi->mode & SPI_LSB_FIRST)
+                cr |= XSPI_CR_LSB_FIRST;
+        if (spi->mode & SPI_LOOP)
+                cr |= XSPI_CR_LOOP;
+        xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
+
+        /* We do not check spi->max_speed_hz here as the SPI clock
+         * frequency is not software programmable (the IP block design
+         * parameter)
+         */
+
+        cs = xspi->cs_inactive;
+        cs ^= BIT(spi->chip_select);
+
+        /* Activate the chip select */
+        xspi->write_fn(cs, xspi->regs + XSPI_SSR_OFFSET);
 }
 
 /* spi_bitbang requires custom setup_transfer() to be defined if there is a
@@ -213,85 +227,85 @@ static void xilinx_spi_chipselect(struct spi_device *spi, int is_on)
 static int xilinx_spi_setup_transfer(struct spi_device *spi,
                 struct spi_transfer *t)
 {
-        return 0;
-}
+        struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
 
-static void xilinx_spi_fill_tx_fifo(struct xilinx_spi *xspi)
-{
-        u8 sr;
+        if (spi->mode & SPI_CS_HIGH)
+                xspi->cs_inactive &= ~BIT(spi->chip_select);
+        else
+                xspi->cs_inactive |= BIT(spi->chip_select);
 
-        /* Fill the Tx FIFO with as many bytes as possible */
-        sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
-        while ((sr & XSPI_SR_TX_FULL_MASK) == 0 && xspi->remaining_bytes > 0) {
-                if (xspi->tx_ptr)
-                        xspi->tx_fn(xspi);
-                else
-                        xspi->write_fn(0, xspi->regs + XSPI_TXD_OFFSET);
-                xspi->remaining_bytes -= xspi->bits_per_word / 8;
-                sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
-        }
+        return 0;
 }
 
 static int xilinx_spi_txrx_bufs(struct spi_device *spi, struct spi_transfer *t)
 {
         struct xilinx_spi *xspi = spi_master_get_devdata(spi->master);
-        u32 ipif_ier;
+        int remaining_words;    /* the number of words left to transfer */
+        bool use_irq = false;
+        u16 cr = 0;
 
         /* We get here with transmitter inhibited */
 
         xspi->tx_ptr = t->tx_buf;
         xspi->rx_ptr = t->rx_buf;
-        xspi->remaining_bytes = t->len;
+        remaining_words = t->len / xspi->bytes_per_word;
         reinit_completion(&xspi->done);
 
+        if (xspi->irq >= 0 &&  remaining_words > xspi->buffer_size) {
+                use_irq = true;
+                xspi->write_fn(XSPI_INTR_TX_EMPTY,
+                                xspi->regs + XIPIF_V123B_IISR_OFFSET);
+                /* Enable the global IPIF interrupt */
+                xspi->write_fn(XIPIF_V123B_GINTR_ENABLE,
+                                xspi->regs + XIPIF_V123B_DGIER_OFFSET);
+                /* Inhibit irq to avoid spurious irqs on tx_empty*/
+                cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET);
+                xspi->write_fn(cr | XSPI_CR_TRANS_INHIBIT,
+                               xspi->regs + XSPI_CR_OFFSET);
+        }
 
-        /* Enable the transmit empty interrupt, which we use to determine
-         * progress on the transmission.
-         */
-        ipif_ier = xspi->read_fn(xspi->regs + XIPIF_V123B_IIER_OFFSET);
-        xspi->write_fn(ipif_ier | XSPI_INTR_TX_EMPTY,
-                xspi->regs + XIPIF_V123B_IIER_OFFSET);
+        while (remaining_words) {
+                int n_words, tx_words, rx_words;
 
-        for (;;) {
-                u16 cr;
-                u8 sr;
+                n_words = min(remaining_words, xspi->buffer_size);
 
-                xilinx_spi_fill_tx_fifo(xspi);
+                tx_words = n_words;
+                while (tx_words--)
+                        xilinx_spi_tx(xspi);
 
                 /* Start the transfer by not inhibiting the transmitter any
                  * longer
                  */
-                cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET) &
-                                                        ~XSPI_CR_TRANS_INHIBIT;
-                xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
 
-                wait_for_completion(&xspi->done);
+                if (use_irq) {
+                        xspi->write_fn(cr, xspi->regs + XSPI_CR_OFFSET);
+                        wait_for_completion(&xspi->done);
+                } else
+                        while (!(xspi->read_fn(xspi->regs + XSPI_SR_OFFSET) &
+                                                XSPI_SR_TX_EMPTY_MASK))
+                                ;
 
                 /* A transmit has just completed. Process received data and
                  * check for more data to transmit. Always inhibit the
                  * transmitter while the Isr refills the transmit register/FIFO,
                  * or make sure it is stopped if we're done.
                  */
-                cr = xspi->read_fn(xspi->regs + XSPI_CR_OFFSET);
-                xspi->write_fn(cr | XSPI_CR_TRANS_INHIBIT,
+                if (use_irq)
+                        xspi->write_fn(cr | XSPI_CR_TRANS_INHIBIT,
                                xspi->regs + XSPI_CR_OFFSET);
 
                 /* Read out all the data from the Rx FIFO */
-                sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
-                while ((sr & XSPI_SR_RX_EMPTY_MASK) == 0) {
-                        xspi->rx_fn(xspi);
-                        sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
-                }
-
-                /* See if there is more data to send */
-                if (xspi->remaining_bytes <= 0)
-                        break;
+                rx_words = n_words;
+                while (rx_words--)
+                        xilinx_spi_rx(xspi);
+
+                remaining_words -= n_words;
         }
 
-        /* Disable the transmit empty interrupt */
-        xspi->write_fn(ipif_ier, xspi->regs + XIPIF_V123B_IIER_OFFSET);
+        if (use_irq)
+                xspi->write_fn(0, xspi->regs + XIPIF_V123B_DGIER_OFFSET);
 
-        return t->len - xspi->remaining_bytes;
+        return t->len;
 }
 
 
@@ -316,6 +330,28 @@ static irqreturn_t xilinx_spi_irq(int irq, void *dev_id)
         return IRQ_HANDLED;
 }
 
+static int xilinx_spi_find_buffer_size(struct xilinx_spi *xspi)
+{
+        u8 sr;
+        int n_words = 0;
+
+        /*
+         * Before the buffer_size detection we reset the core
+         * to make sure we start with a clean state.
+         */
+        xspi->write_fn(XIPIF_V123B_RESET_MASK,
+                xspi->regs + XIPIF_V123B_RESETR_OFFSET);
+
+        /* Fill the Tx FIFO with as many words as possible */
+        do {
+                xspi->write_fn(0, xspi->regs + XSPI_TXD_OFFSET);
+                sr = xspi->read_fn(xspi->regs + XSPI_SR_OFFSET);
+                n_words++;
+        } while (!(sr & XSPI_SR_TX_FULL_MASK));
+
+        return n_words;
+}
+
 static const struct of_device_id xilinx_spi_of_match[] = {
         { .compatible = "xlnx,xps-spi-2.00.a", },
         { .compatible = "xlnx,xps-spi-2.00.b", },
@@ -348,14 +384,21 @@ static int xilinx_spi_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
 
+        if (num_cs > XILINX_SPI_MAX_CS) {
+                dev_err(&pdev->dev, "Invalid number of spi slaves\n");
+                return -EINVAL;
+        }
+
         master = spi_alloc_master(&pdev->dev, sizeof(struct xilinx_spi));
         if (!master)
                 return -ENODEV;
 
         /* the spi->mode bits understood by this driver: */
-        master->mode_bits = SPI_CPOL | SPI_CPHA;
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST | SPI_LOOP |
+                            SPI_CS_HIGH;
 
         xspi = spi_master_get_devdata(master);
+        xspi->cs_inactive = 0xffffffff;
         xspi->bitbang.master = master;
         xspi->bitbang.chipselect = xilinx_spi_chipselect;
         xspi->bitbang.setup_transfer = xilinx_spi_setup_transfer;
@@ -392,35 +435,20 @@ static int xilinx_spi_probe(struct platform_device *pdev)
         }
 
         master->bits_per_word_mask = SPI_BPW_MASK(bits_per_word);
-        xspi->bits_per_word = bits_per_word;
-        if (xspi->bits_per_word == 8) {
-                xspi->tx_fn = xspi_tx8;
-                xspi->rx_fn = xspi_rx8;
-        } else if (xspi->bits_per_word == 16) {
-                xspi->tx_fn = xspi_tx16;
-                xspi->rx_fn = xspi_rx16;
-        } else if (xspi->bits_per_word == 32) {
-                xspi->tx_fn = xspi_tx32;
-                xspi->rx_fn = xspi_rx32;
-        } else {
-                ret = -EINVAL;
-                goto put_master;
-        }
-
-        /* SPI controller initializations */
-        xspi_init_hw(xspi);
+        xspi->bytes_per_word = bits_per_word / 8;
+        xspi->buffer_size = xilinx_spi_find_buffer_size(xspi);
 
         xspi->irq = platform_get_irq(pdev, 0);
-        if (xspi->irq < 0) {
-                ret = xspi->irq;
-                goto put_master;
+        if (xspi->irq >= 0) {
+                /* Register for SPI Interrupt */
+                ret = devm_request_irq(&pdev->dev, xspi->irq, xilinx_spi_irq, 0,
+                                dev_name(&pdev->dev), xspi);
+                if (ret)
+                        goto put_master;
         }
 
-        /* Register for SPI Interrupt */
-        ret = devm_request_irq(&pdev->dev, xspi->irq, xilinx_spi_irq, 0,
-                               dev_name(&pdev->dev), xspi);
-        if (ret)
-                goto put_master;
+        /* SPI controller initializations */
+        xspi_init_hw(xspi);
 
         ret = spi_bitbang_start(&xspi->bitbang);
         if (ret) {
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 66a70e9bc743..c64a3e59fce3 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -13,10 +13,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/kernel.h>
@@ -788,7 +784,7 @@ static int spi_transfer_one_message(struct spi_master *master,
         struct spi_transfer *xfer;
         bool keep_cs = false;
         int ret = 0;
-        int ms = 1;
+        unsigned long ms = 1;
 
         spi_set_cs(msg->spi, true);
 
@@ -875,31 +871,59 @@ void spi_finalize_current_transfer(struct spi_master *master)
 EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
 
 /**
- * spi_pump_messages - kthread work function which processes spi message queue
- * @work: pointer to kthread work struct contained in the master struct
+ * __spi_pump_messages - function which processes spi message queue
+ * @master: master to process queue for
+ * @in_kthread: true if we are in the context of the message pump thread
  *
  * 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.
  *
+ * Note that it is called both from the kthread itself and also from
+ * inside spi_sync(); the queue extraction handling at the top of the
+ * function should deal with this safely.
  */
-static void spi_pump_messages(struct kthread_work *work)
+static void __spi_pump_messages(struct spi_master *master, bool in_kthread)
 {
-        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 */
+        /* Lock queue */
         spin_lock_irqsave(&master->queue_lock, flags);
+
+        /* Make sure we are not already running a message */
+        if (master->cur_msg) {
+                spin_unlock_irqrestore(&master->queue_lock, flags);
+                return;
+        }
+
+        /* If another context is idling the device then defer */
+        if (master->idling) {
+                queue_kthread_work(&master->kworker, &master->pump_messages);
+                spin_unlock_irqrestore(&master->queue_lock, flags);
+                return;
+        }
+
+        /* Check if the queue is idle */
         if (list_empty(&master->queue) || !master->running) {
                 if (!master->busy) {
                         spin_unlock_irqrestore(&master->queue_lock, flags);
                         return;
                 }
+
+                /* Only do teardown in the thread */
+                if (!in_kthread) {
+                        queue_kthread_work(&master->kworker,
+                                           &master->pump_messages);
+                        spin_unlock_irqrestore(&master->queue_lock, flags);
+                        return;
+                }
+
                 master->busy = false;
+                master->idling = true;
                 spin_unlock_irqrestore(&master->queue_lock, flags);
+
                 kfree(master->dummy_rx);
                 master->dummy_rx = NULL;
                 kfree(master->dummy_tx);
@@ -913,14 +937,13 @@ static void spi_pump_messages(struct kthread_work *work)
                         pm_runtime_put_autosuspend(master->dev.parent);
                 }
                 trace_spi_master_idle(master);
-                return;
-        }
 
-        /* Make sure we are not already running a message */
-        if (master->cur_msg) {
+                spin_lock_irqsave(&master->queue_lock, flags);
+                master->idling = false;
                 spin_unlock_irqrestore(&master->queue_lock, flags);
                 return;
         }
+
         /* Extract head of queue */
         master->cur_msg =
                 list_first_entry(&master->queue, struct spi_message, queue);
@@ -985,13 +1008,22 @@ static void spi_pump_messages(struct kthread_work *work)
         }
 }
 
+/**
+ * spi_pump_messages - kthread work function which processes spi message queue
+ * @work: pointer to kthread work struct contained in the master struct
+ */
+static void spi_pump_messages(struct kthread_work *work)
+{
+        struct spi_master *master =
+                container_of(work, struct spi_master, pump_messages);
+
+        __spi_pump_messages(master, true);
+}
+
 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;
 
@@ -1161,12 +1193,9 @@ static int spi_destroy_queue(struct spi_master *master)
         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)
+static int __spi_queued_transfer(struct spi_device *spi,
+                                 struct spi_message *msg,
+                                 bool need_pump)
 {
         struct spi_master *master = spi->master;
         unsigned long flags;
@@ -1181,13 +1210,23 @@ static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
         msg->status = -EINPROGRESS;
 
         list_add_tail(&msg->queue, &master->queue);
-        if (!master->busy)
+        if (!master->busy && need_pump)
                 queue_kthread_work(&master->kworker, &master->pump_messages);
 
         spin_unlock_irqrestore(&master->queue_lock, flags);
         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)
+{
+        return __spi_queued_transfer(spi, msg, true);
+}
+
 static int spi_master_initialize_queue(struct spi_master *master)
 {
         int ret;
@@ -1609,6 +1648,8 @@ int spi_register_master(struct spi_master *master)
                 dynamic = 1;
         }
 
+        INIT_LIST_HEAD(&master->queue);
+        spin_lock_init(&master->queue_lock);
         spin_lock_init(&master->bus_lock_spinlock);
         mutex_init(&master->bus_lock_mutex);
         master->bus_lock_flag = 0;
@@ -2114,19 +2155,46 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message,
         DECLARE_COMPLETION_ONSTACK(done);
         int status;
         struct spi_master *master = spi->master;
+        unsigned long flags;
+
+        status = __spi_validate(spi, message);
+        if (status != 0)
+                return status;
 
         message->complete = spi_complete;
         message->context = &done;
+        message->spi = spi;
 
         if (!bus_locked)
                 mutex_lock(&master->bus_lock_mutex);
 
-        status = spi_async_locked(spi, message);
+        /* If we're not using the legacy transfer method then we will
+         * try to transfer in the calling context so special case.
+         * This code would be less tricky if we could remove the
+         * support for driver implemented message queues.
+         */
+        if (master->transfer == spi_queued_transfer) {
+                spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+
+                trace_spi_message_submit(message);
+
+                status = __spi_queued_transfer(spi, message, false);
+
+                spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
+        } else {
+                status = spi_async_locked(spi, message);
+        }
 
         if (!bus_locked)
                 mutex_unlock(&master->bus_lock_mutex);
 
         if (status == 0) {
+                /* Push out the messages in the calling context if we
+                 * can.
+                 */
+                if (master->transfer == spi_queued_transfer)
+                        __spi_pump_messages(master, false);
+
                 wait_for_completion(&done);
                 status = message->status;
         }
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 6941e04afb8c..4eb7a980e670 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -14,10 +14,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <linux/init.h>
@@ -317,6 +313,37 @@ done:
         return status;
 }
 
+static struct spi_ioc_transfer *
+spidev_get_ioc_message(unsigned int cmd, struct spi_ioc_transfer __user *u_ioc,
+                unsigned *n_ioc)
+{
+        struct spi_ioc_transfer *ioc;
+        u32     tmp;
+
+        /* Check type, command number and direction */
+        if (_IOC_TYPE(cmd) != SPI_IOC_MAGIC
+                        || _IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
+                        || _IOC_DIR(cmd) != _IOC_WRITE)
+                return ERR_PTR(-ENOTTY);
+
+        tmp = _IOC_SIZE(cmd);
+        if ((tmp % sizeof(struct spi_ioc_transfer)) != 0)
+                return ERR_PTR(-EINVAL);
+        *n_ioc = tmp / sizeof(struct spi_ioc_transfer);
+        if (*n_ioc == 0)
+                return NULL;
+
+        /* copy into scratch area */
+        ioc = kmalloc(tmp, GFP_KERNEL);
+        if (!ioc)
+                return ERR_PTR(-ENOMEM);
+        if (__copy_from_user(ioc, u_ioc, tmp)) {
+                kfree(ioc);
+                return ERR_PTR(-EFAULT);
+        }
+        return ioc;
+}
+
 static long
 spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
@@ -456,32 +483,15 @@ spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
         default:
                 /* segmented and/or full-duplex I/O request */
-                if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
-                                || _IOC_DIR(cmd) != _IOC_WRITE) {
-                        retval = -ENOTTY;
-                        break;
-                }
-
-                tmp = _IOC_SIZE(cmd);
-                if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
-                        retval = -EINVAL;
-                        break;
-                }
-                n_ioc = tmp / sizeof(struct spi_ioc_transfer);
-                if (n_ioc == 0)
-                        break;
-
-                /* copy into scratch area */
-                ioc = kmalloc(tmp, GFP_KERNEL);
-                if (!ioc) {
-                        retval = -ENOMEM;
-                        break;
-                }
-                if (__copy_from_user(ioc, (void __user *)arg, tmp)) {
-                        kfree(ioc);
-                        retval = -EFAULT;
+                /* Check message and copy into scratch area */
+                ioc = spidev_get_ioc_message(cmd,
+                                (struct spi_ioc_transfer __user *)arg, &n_ioc);
+                if (IS_ERR(ioc)) {
+                        retval = PTR_ERR(ioc);
                         break;
                 }
+                if (!ioc)
+                        break;  /* n_ioc is also 0 */
 
                 /* translate to spi_message, execute */
                 retval = spidev_message(spidev, ioc, n_ioc);
@@ -496,8 +506,67 @@ spidev_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 
 #ifdef CONFIG_COMPAT
 static long
+spidev_compat_ioc_message(struct file *filp, unsigned int cmd,
+                unsigned long arg)
+{
+        struct spi_ioc_transfer __user  *u_ioc;
+        int                             retval = 0;
+        struct spidev_data              *spidev;
+        struct spi_device               *spi;
+        unsigned                        n_ioc, n;
+        struct spi_ioc_transfer         *ioc;
+
+        u_ioc = (struct spi_ioc_transfer __user *) compat_ptr(arg);
+        if (!access_ok(VERIFY_READ, u_ioc, _IOC_SIZE(cmd)))
+                return -EFAULT;
+
+        /* guard against device removal before, or while,
+         * we issue this ioctl.
+         */
+        spidev = filp->private_data;
+        spin_lock_irq(&spidev->spi_lock);
+        spi = spi_dev_get(spidev->spi);
+        spin_unlock_irq(&spidev->spi_lock);
+
+        if (spi == NULL)
+                return -ESHUTDOWN;
+
+        /* SPI_IOC_MESSAGE needs the buffer locked "normally" */
+        mutex_lock(&spidev->buf_lock);
+
+        /* Check message and copy into scratch area */
+        ioc = spidev_get_ioc_message(cmd, u_ioc, &n_ioc);
+        if (IS_ERR(ioc)) {
+                retval = PTR_ERR(ioc);
+                goto done;
+        }
+        if (!ioc)
+                goto done;      /* n_ioc is also 0 */
+
+        /* Convert buffer pointers */
+        for (n = 0; n < n_ioc; n++) {
+                ioc[n].rx_buf = (uintptr_t) compat_ptr(ioc[n].rx_buf);
+                ioc[n].tx_buf = (uintptr_t) compat_ptr(ioc[n].tx_buf);
+        }
+
+        /* translate to spi_message, execute */
+        retval = spidev_message(spidev, ioc, n_ioc);
+        kfree(ioc);
+
+done:
+        mutex_unlock(&spidev->buf_lock);
+        spi_dev_put(spi);
+        return retval;
+}
+
+static long
 spidev_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
+        if (_IOC_TYPE(cmd) == SPI_IOC_MAGIC
+                        && _IOC_NR(cmd) == _IOC_NR(SPI_IOC_MESSAGE(0))
+                        && _IOC_DIR(cmd) == _IOC_WRITE)
+                return spidev_compat_ioc_message(filp, cmd, arg);
+
         return spidev_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
 }
 #else
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index 77aed9ea1d26..dab545bb66b3 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -37,6 +37,7 @@
 #define SSDR            (0x10)  /* SSP Data Write/Data Read Register */
 
 #define SSTO            (0x28)  /* SSP Time Out Register */
+#define DDS_RATE        (0x28)  /* SSP DDS Clock Rate Register (Intel Quark) */
 #define SSPSP           (0x2C)  /* SSP Programmable Serial Protocol */
 #define SSTSA           (0x30)  /* SSP Tx Timeslot Active */
 #define SSRSA           (0x34)  /* SSP Rx Timeslot Active */
diff --git a/include/linux/spi/at86rf230.h b/include/linux/spi/at86rf230.h
index b2b1afbb3202..cd519a11c2c6 100644
--- a/include/linux/spi/at86rf230.h
+++ b/include/linux/spi/at86rf230.h
@@ -12,10 +12,6 @@
  * 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, Boston, MA 02110-1301 USA.
- *
  * Written by:
  * Dmitry Eremin-Solenikov <dmitry.baryshkov@siemens.com>
  */
diff --git a/include/linux/spi/l4f00242t03.h b/include/linux/spi/l4f00242t03.h
index bc8677c8eba9..e69e9b51b21a 100644
--- a/include/linux/spi/l4f00242t03.h
+++ b/include/linux/spi/l4f00242t03.h
@@ -12,10 +12,6 @@
  * 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
 */
 
 #ifndef _INCLUDE_LINUX_SPI_L4F00242T03_H_
diff --git a/include/linux/spi/lms283gf05.h b/include/linux/spi/lms283gf05.h
index 555d254e6606..fdd1d1d51da5 100644
--- a/include/linux/spi/lms283gf05.h
+++ b/include/linux/spi/lms283gf05.h
@@ -11,10 +11,6 @@
  * 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
 */
 
 #ifndef _INCLUDE_LINUX_SPI_LMS283GF05_H_
diff --git a/include/linux/spi/mxs-spi.h b/include/linux/spi/mxs-spi.h
index 4835486f58e5..381d368b91b4 100644
--- a/include/linux/spi/mxs-spi.h
+++ b/include/linux/spi/mxs-spi.h
@@ -15,10 +15,6 @@
  * 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, Boston, MA 02110-1301 USA.
  */
 
 #ifndef __LINUX_SPI_MXS_SPI_H__
diff --git a/include/linux/spi/pxa2xx_spi.h b/include/linux/spi/pxa2xx_spi.h
index d5a316550177..6d36dacec4ba 100644
--- a/include/linux/spi/pxa2xx_spi.h
+++ b/include/linux/spi/pxa2xx_spi.h
@@ -10,10 +10,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #ifndef __linux_pxa2xx_spi_h
 #define __linux_pxa2xx_spi_h
@@ -57,7 +53,6 @@ struct pxa2xx_spi_chip {
 #if defined(CONFIG_ARCH_PXA) || defined(CONFIG_ARCH_MMP)
 
 #include <linux/clk.h>
-#include <mach/dma.h>
 
 extern void pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_master *info);
 
diff --git a/include/linux/spi/rspi.h b/include/linux/spi/rspi.h
index e546b2ceb623..a693188cc08b 100644
--- a/include/linux/spi/rspi.h
+++ b/include/linux/spi/rspi.h
@@ -11,11 +11,6 @@
  * 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
- *
  */
 
 #ifndef __LINUX_SPI_RENESAS_SPI_H__
diff --git a/include/linux/spi/sh_hspi.h b/include/linux/spi/sh_hspi.h
index a1121f872ac1..aa0d440ab4f0 100644
--- a/include/linux/spi/sh_hspi.h
+++ b/include/linux/spi/sh_hspi.h
@@ -9,10 +9,6 @@
  * 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
  */
 #ifndef SH_HSPI_H
 #define SH_HSPI_H
diff --git a/include/linux/spi/sh_msiof.h b/include/linux/spi/sh_msiof.h
index 88a14d81c49e..b087a85f5f72 100644
--- a/include/linux/spi/sh_msiof.h
+++ b/include/linux/spi/sh_msiof.h
@@ -7,6 +7,8 @@ struct sh_msiof_spi_info {
         u16 num_chipselect;
         unsigned int dma_tx_id;
         unsigned int dma_rx_id;
+        u32 dtdl;
+        u32 syncdl;
 };
 
 #endif /* __SPI_SH_MSIOF_H__ */
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index a6ef2a8e6de4..ed9489d893a4 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -10,10 +10,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #ifndef __LINUX_SPI_H
@@ -260,6 +256,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @pump_messages: work struct for scheduling work to the message pump
  * @queue_lock: spinlock to syncronise access to message queue
  * @queue: message queue
+ * @idling: the device is entering idle state
  * @cur_msg: the currently in-flight message
  * @cur_msg_prepared: spi_prepare_message was called for the currently
  *                    in-flight message
@@ -425,6 +422,7 @@ struct spi_master {
         spinlock_t                      queue_lock;
         struct list_head                queue;
         struct spi_message              *cur_msg;
+        bool                            idling;
         bool                            busy;
         bool                            running;
         bool                            rt;
diff --git a/include/linux/spi/tle62x0.h b/include/linux/spi/tle62x0.h
index 60b59187e590..414c6fddfcf0 100644
--- a/include/linux/spi/tle62x0.h
+++ b/include/linux/spi/tle62x0.h
@@ -12,10 +12,6 @@
  * 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
 */
 
 struct tle62x0_pdata {
diff --git a/include/linux/spi/tsc2005.h b/include/linux/spi/tsc2005.h
index 8f721e465e05..563b3b1799a8 100644
--- a/include/linux/spi/tsc2005.h
+++ b/include/linux/spi/tsc2005.h
@@ -12,11 +12,6 @@
  * 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
- *
  */
 
 #ifndef _LINUX_SPI_TSC2005_H