spi: omap2-mcspi: remove private DMA API implementation

Remove the private DMA API implementation from spi-omap2-mcspi.c,
making it use entirely the DMA engine API.

Acked-by: Grant Likely <grant.likely@secretlab.ca>
Signed-off-by: Russell King <rmk+kernel@arm.linux.org.uk>

1 files changed, 5 insertions, 99 deletions

diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index 9fdb7a9ae03f..26a99ae9a599 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -20,8 +20,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  *
  */
-#define USE_DMA_ENGINE_RX
-#define USE_DMA_ENGINE_TX
 
 #include <linux/kernel.h>
 #include <linux/init.h>
@@ -43,7 +41,6 @@
 
 #include <linux/spi/spi.h>
 
-#include <plat/dma.h>
 #include <plat/clock.h>
 #include <plat/mcspi.h>
 
@@ -99,8 +96,6 @@
 struct omap2_mcspi_dma {
         struct dma_chan *dma_tx;
         struct dma_chan *dma_rx;
-        int dma_tx_channel;
-        int dma_rx_channel;
 
         int dma_tx_sync_dev;
         int dma_rx_sync_dev;
@@ -336,9 +331,8 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         struct omap2_mcspi      *mcspi;
         struct omap2_mcspi_cs   *cs = spi->controller_state;
         struct omap2_mcspi_dma  *mcspi_dma;
-        unsigned int            count, c;
-        unsigned long           base, tx_reg, rx_reg;
-        int                     word_len, data_type, element_count;
+        unsigned int            count;
+        int                     word_len, element_count;
         int                     elements = 0;
         u32                     l;
         u8                      * rx;
@@ -420,73 +414,26 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         }
 
         count = xfer->len;
-        c = count;
         word_len = cs->word_len;
 
-        base = cs->phys;
-        tx_reg = base + OMAP2_MCSPI_TX0;
-        rx_reg = base + OMAP2_MCSPI_RX0;
         rx = xfer->rx_buf;
         tx = xfer->tx_buf;
 
         if (word_len <= 8) {
-                data_type = OMAP_DMA_DATA_TYPE_S8;
                 element_count = count;
         } else if (word_len <= 16) {
-                data_type = OMAP_DMA_DATA_TYPE_S16;
                 element_count = count >> 1;
         } else /* word_len <= 32 */ {
-                data_type = OMAP_DMA_DATA_TYPE_S32;
                 element_count = count >> 2;
         }
 
-        if (tx != NULL && mcspi_dma->dma_tx_channel != -1) {
-                omap_set_dma_transfer_params(mcspi_dma->dma_tx_channel,
-                                data_type, element_count, 1,
-                                OMAP_DMA_SYNC_ELEMENT,
-                                mcspi_dma->dma_tx_sync_dev, 0);
-
-                omap_set_dma_dest_params(mcspi_dma->dma_tx_channel, 0,
-                                OMAP_DMA_AMODE_CONSTANT,
-                                tx_reg, 0, 0);
-
-                omap_set_dma_src_params(mcspi_dma->dma_tx_channel, 0,
-                                OMAP_DMA_AMODE_POST_INC,
-                                xfer->tx_dma, 0, 0);
-        }
-
-        if (rx != NULL && mcspi_dma->dma_rx_channel != -1) {
-                elements = element_count - 1;
-                if (l & OMAP2_MCSPI_CHCONF_TURBO)
-                        elements--;
-
-                omap_set_dma_transfer_params(mcspi_dma->dma_rx_channel,
-                                data_type, elements, 1,
-                                OMAP_DMA_SYNC_ELEMENT,
-                                mcspi_dma->dma_rx_sync_dev, 1);
-
-                omap_set_dma_src_params(mcspi_dma->dma_rx_channel, 0,
-                                OMAP_DMA_AMODE_CONSTANT,
-                                rx_reg, 0, 0);
-
-                omap_set_dma_dest_params(mcspi_dma->dma_rx_channel, 0,
-                                OMAP_DMA_AMODE_POST_INC,
-                                xfer->rx_dma, 0, 0);
-        }
-
         if (tx != NULL) {
-                if (mcspi_dma->dma_tx)
-                        dma_async_issue_pending(mcspi_dma->dma_tx);
-                else
-                        omap_start_dma(mcspi_dma->dma_tx_channel);
+                dma_async_issue_pending(mcspi_dma->dma_tx);
                 omap2_mcspi_set_dma_req(spi, 0, 1);
         }
 
         if (rx != NULL) {
-                if (mcspi_dma->dma_rx)
-                        dma_async_issue_pending(mcspi_dma->dma_rx);
-                else
-                        omap_start_dma(mcspi_dma->dma_rx_channel);
+                dma_async_issue_pending(mcspi_dma->dma_rx);
                 omap2_mcspi_set_dma_req(spi, 1, 1);
         }
 
@@ -830,16 +777,6 @@ static int omap2_mcspi_setup_transfer(struct spi_device *spi,
         return 0;
 }
 
-static void omap2_mcspi_dma_rx_callback(int lch, u16 ch_status, void *data)
-{
-        omap2_mcspi_rx_callback(data);
-}
-
-static void omap2_mcspi_dma_tx_callback(int lch, u16 ch_status, void *data)
-{
-        omap2_mcspi_tx_callback(data);
-}
-
 static int omap2_mcspi_request_dma(struct spi_device *spi)
 {
         struct spi_master       *master = spi->master;
@@ -856,23 +793,13 @@ static int omap2_mcspi_request_dma(struct spi_device *spi)
 
         dma_cap_zero(mask);
         dma_cap_set(DMA_SLAVE, mask);
-#ifdef USE_DMA_ENGINE_RX
         sig = mcspi_dma->dma_rx_sync_dev;
         mcspi_dma->dma_rx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
         if (!mcspi_dma->dma_rx) {
                 dev_err(&spi->dev, "no RX DMA engine channel for McSPI\n");
                 return -EAGAIN;
         }
-#else
-        if (omap_request_dma(mcspi_dma->dma_rx_sync_dev, "McSPI RX",
-                        omap2_mcspi_dma_rx_callback, spi,
-                        &mcspi_dma->dma_rx_channel)) {
-                dev_err(&spi->dev, "no RX DMA channel for McSPI\n");
-                return -EAGAIN;
-        }
-#endif
 
-#ifdef USE_DMA_ENGINE_TX
         sig = mcspi_dma->dma_tx_sync_dev;
         mcspi_dma->dma_tx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
         if (!mcspi_dma->dma_tx) {
@@ -881,16 +808,6 @@ static int omap2_mcspi_request_dma(struct spi_device *spi)
                 mcspi_dma->dma_rx = NULL;
                 return -EAGAIN;
         }
-#else
-        if (omap_request_dma(mcspi_dma->dma_tx_sync_dev, "McSPI TX",
-                        omap2_mcspi_dma_tx_callback, spi,
-                        &mcspi_dma->dma_tx_channel)) {
-                omap_free_dma(mcspi_dma->dma_rx_channel);
-                mcspi_dma->dma_rx_channel = -1;
-                dev_err(&spi->dev, "no TX DMA channel for McSPI\n");
-                return -EAGAIN;
-        }
-#endif
 
         return 0;
 }
@@ -923,8 +840,7 @@ static int omap2_mcspi_setup(struct spi_device *spi)
                 list_add_tail(&cs->node, &ctx->cs);
         }
 
-        if ((!mcspi_dma->dma_rx && mcspi_dma->dma_rx_channel == -1) ||
-            (!mcspi_dma->dma_tx && mcspi_dma->dma_tx_channel == -1)) {
+        if (!mcspi_dma->dma_rx || !mcspi_dma->dma_tx) {
                 ret = omap2_mcspi_request_dma(spi);
                 if (ret < 0)
                         return ret;
@@ -967,14 +883,6 @@ static void omap2_mcspi_cleanup(struct spi_device *spi)
                         dma_release_channel(mcspi_dma->dma_tx);
                         mcspi_dma->dma_tx = NULL;
                 }
-                if (mcspi_dma->dma_rx_channel != -1) {
-                        omap_free_dma(mcspi_dma->dma_rx_channel);
-                        mcspi_dma->dma_rx_channel = -1;
-                }
-                if (mcspi_dma->dma_tx_channel != -1) {
-                        omap_free_dma(mcspi_dma->dma_tx_channel);
-                        mcspi_dma->dma_tx_channel = -1;
-                }
         }
 }
 
@@ -1293,7 +1201,6 @@ static int __devinit omap2_mcspi_probe(struct platform_device *pdev)
                         break;
                 }
 
-                mcspi->dma_channels[i].dma_rx_channel = -1;
                 mcspi->dma_channels[i].dma_rx_sync_dev = dma_res->start;
                 sprintf(dma_ch_name, "tx%d", i);
                 dma_res = platform_get_resource_byname(pdev, IORESOURCE_DMA,
@@ -1304,7 +1211,6 @@ static int __devinit omap2_mcspi_probe(struct platform_device *pdev)
                         break;
                 }
 
-                mcspi->dma_channels[i].dma_tx_channel = -1;
                 mcspi->dma_channels[i].dma_tx_sync_dev = dma_res->start;
         }