spi/pxa2xx: break out the private DMA API usage into a separate file

The PXA SPI driver uses PXA platform specific private DMA implementation
which does not work on non-PXA platforms. In order to use this driver on
other platforms we break out the private DMA implementation into a separate
file that gets compiled only when CONFIG_SPI_PXA2XX_PXADMA is set. The DMA
functions are stubbed out if there is no DMA implementation selected (i.e
we are building on non-PXA platform).

While we are there we can kill the dummy DMA bits in pxa2xx_spi.h as they
are not needed anymore for CE4100.

Once this is done we can add the generic DMA engine support to the driver
that allows usage of any DMA controller that implements DMA engine API.

Signed-off-by: Mika Westerberg <mika.westerberg@linux.intel.com>
Acked-by: Linus Walleij <linus.walleij@linaro.org>
Tested-by: Lu Cao <lucao@marvell.com>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>

6 files changed, 712 insertions, 648 deletions

diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index a90393d7f106..f1878666e917 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -297,6 +297,12 @@ config SPI_PPC4xx
         help
           This selects a driver for the PPC4xx SPI Controller.
 
+config SPI_PXA2XX_PXADMA
+        bool "PXA2xx SSP legacy PXA DMA API support"
+        depends on SPI_PXA2XX && ARCH_PXA
+        help
+          Enable PXA private legacy DMA API support.
+
 config SPI_PXA2XX
         tristate "PXA2xx SSP SPI master"
         depends on ARCH_PXA || PCI
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index 64e970ba261c..2e3cdd3caba9 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -47,7 +47,9 @@ obj-$(CONFIG_SPI_OMAP24XX)		+= spi-omap2-mcspi.o
 obj-$(CONFIG_SPI_ORION)                 += spi-orion.o
 obj-$(CONFIG_SPI_PL022)                 += spi-pl022.o
 obj-$(CONFIG_SPI_PPC4xx)                += spi-ppc4xx.o
-obj-$(CONFIG_SPI_PXA2XX)                += spi-pxa2xx.o
+spi-pxa2xx-platform-objs                := spi-pxa2xx.o
+spi-pxa2xx-platform-$(CONFIG_SPI_PXA2XX_PXADMA) += spi-pxa2xx-pxadma.o
+obj-$(CONFIG_SPI_PXA2XX)                += spi-pxa2xx-platform.o
 obj-$(CONFIG_SPI_PXA2XX_PCI)            += spi-pxa2xx-pci.o
 obj-$(CONFIG_SPI_RSPI)                  += spi-rspi.o
 obj-$(CONFIG_SPI_S3C24XX)               += spi-s3c24xx-hw.o
diff --git a/drivers/spi/spi-pxa2xx-pxadma.c b/drivers/spi/spi-pxa2xx-pxadma.c
new file mode 100644
index 000000000000..2916efc7cfe5
--- /dev/null
+++ b/drivers/spi/spi-pxa2xx-pxadma.c
@@ -0,0 +1,490 @@
+/*
+ * PXA2xx SPI private DMA support.
+ *
+ * Copyright (C) 2005 Stephen Street / StreetFire Sound Labs
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/pxa2xx_ssp.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/pxa2xx_spi.h>
+
+#include "spi-pxa2xx.h"
+
+#define DMA_INT_MASK            (DCSR_ENDINTR | DCSR_STARTINTR | DCSR_BUSERR)
+#define RESET_DMA_CHANNEL       (DCSR_NODESC | DMA_INT_MASK)
+
+bool pxa2xx_spi_dma_is_possible(size_t len)
+{
+        /* Try to map dma buffer and do a dma transfer if successful, but
+         * only if the length is non-zero and less than MAX_DMA_LEN.
+         *
+         * Zero-length non-descriptor DMA is illegal on PXA2xx; force use
+         * of PIO instead.  Care is needed above because the transfer may
+         * have have been passed with buffers that are already dma mapped.
+         * A zero-length transfer in PIO mode will not try to write/read
+         * to/from the buffers
+         *
+         * REVISIT large transfers are exactly where we most want to be
+         * using DMA.  If this happens much, split those transfers into
+         * multiple DMA segments rather than forcing PIO.
+         */
+        return len > 0 && len <= MAX_DMA_LEN;
+}
+
+int pxa2xx_spi_map_dma_buffers(struct driver_data *drv_data)
+{
+        struct spi_message *msg = drv_data->cur_msg;
+        struct device *dev = &msg->spi->dev;
+
+        if (!drv_data->cur_chip->enable_dma)
+                return 0;
+
+        if (msg->is_dma_mapped)
+                return  drv_data->rx_dma && drv_data->tx_dma;
+
+        if (!IS_DMA_ALIGNED(drv_data->rx) || !IS_DMA_ALIGNED(drv_data->tx))
+                return 0;
+
+        /* Modify setup if rx buffer is null */
+        if (drv_data->rx == NULL) {
+                *drv_data->null_dma_buf = 0;
+                drv_data->rx = drv_data->null_dma_buf;
+                drv_data->rx_map_len = 4;
+        } else
+                drv_data->rx_map_len = drv_data->len;
+
+
+        /* Modify setup if tx buffer is null */
+        if (drv_data->tx == NULL) {
+                *drv_data->null_dma_buf = 0;
+                drv_data->tx = drv_data->null_dma_buf;
+                drv_data->tx_map_len = 4;
+        } else
+                drv_data->tx_map_len = drv_data->len;
+
+        /* Stream map the tx buffer. Always do DMA_TO_DEVICE first
+         * so we flush the cache *before* invalidating it, in case
+         * the tx and rx buffers overlap.
+         */
+        drv_data->tx_dma = dma_map_single(dev, drv_data->tx,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
+        if (dma_mapping_error(dev, drv_data->tx_dma))
+                return 0;
+
+        /* Stream map the rx buffer */
+        drv_data->rx_dma = dma_map_single(dev, drv_data->rx,
+                                        drv_data->rx_map_len, DMA_FROM_DEVICE);
+        if (dma_mapping_error(dev, drv_data->rx_dma)) {
+                dma_unmap_single(dev, drv_data->tx_dma,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
+                return 0;
+        }
+
+        return 1;
+}
+
+static void pxa2xx_spi_unmap_dma_buffers(struct driver_data *drv_data)
+{
+        struct device *dev;
+
+        if (!drv_data->dma_mapped)
+                return;
+
+        if (!drv_data->cur_msg->is_dma_mapped) {
+                dev = &drv_data->cur_msg->spi->dev;
+                dma_unmap_single(dev, drv_data->rx_dma,
+                                        drv_data->rx_map_len, DMA_FROM_DEVICE);
+                dma_unmap_single(dev, drv_data->tx_dma,
+                                        drv_data->tx_map_len, DMA_TO_DEVICE);
+        }
+
+        drv_data->dma_mapped = 0;
+}
+
+static int wait_ssp_rx_stall(void const __iomem *ioaddr)
+{
+        unsigned long limit = loops_per_jiffy << 1;
+
+        while ((read_SSSR(ioaddr) & SSSR_BSY) && --limit)
+                cpu_relax();
+
+        return limit;
+}
+
+static int wait_dma_channel_stop(int channel)
+{
+        unsigned long limit = loops_per_jiffy << 1;
+
+        while (!(DCSR(channel) & DCSR_STOPSTATE) && --limit)
+                cpu_relax();
+
+        return limit;
+}
+
+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(dr