rapidio: add DMA engine support for RIO data transfers

Adds DMA Engine framework support into RapidIO subsystem.

Uses DMA Engine DMA_SLAVE interface to generate data transfers to/from
remote RapidIO target devices.

Introduces RapidIO-specific wrapper for prep_slave_sg() interface with an
extra parameter to pass target specific information.

Uses scatterlist to describe local data buffer.  Address flat data buffer
on a remote side.

Signed-off-by: Alexandre Bounine <alexandre.bounine@idt.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Acked-by: Vinod Koul <vinod.koul@linux.intel.com>
Cc: Li Yang <leoli@freescale.com>
Cc: Matt Porter <mporter@kernel.crashing.org>
Cc: Paul Gortmaker <paul.gortmaker@windriver.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

2 files changed, 95 insertions, 0 deletions

diff --git a/drivers/rapidio/Kconfig b/drivers/rapidio/Kconfig
index bc8719238793..6194d35ebb97 100644
--- a/drivers/rapidio/Kconfig
+++ b/drivers/rapidio/Kconfig
@@ -22,6 +22,20 @@ config RAPIDIO_ENABLE_RX_TX_PORTS
           ports for Input/Output direction to allow other traffic
           than Maintenance transfers.
 
+config RAPIDIO_DMA_ENGINE
+        bool "DMA Engine support for RapidIO"
+        depends on RAPIDIO
+        select DMADEVICES
+        select DMA_ENGINE
+        help
+          Say Y here if you want to use DMA Engine frameork for RapidIO data
+          transfers to/from target RIO devices. RapidIO uses NREAD and
+          NWRITE (NWRITE_R, SWRITE) requests to transfer data between local
+          memory and memory on remote target device. You need a DMA controller
+          capable to perform data transfers to/from RapidIO.
+
+          If you are unsure about this, say Y here.
+
 config RAPIDIO_DEBUG
         bool "RapidIO subsystem debug messages"
         depends on RAPIDIO
diff --git a/drivers/rapidio/rio.c b/drivers/rapidio/rio.c
index 86c9a091a2ff..c40665a4fa33 100644
--- a/drivers/rapidio/rio.c
+++ b/drivers/rapidio/rio.c
@@ -1121,6 +1121,87 @@ int rio_std_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
         return 0;
 }
 
+#ifdef CONFIG_RAPIDIO_DMA_ENGINE
+
+static bool rio_chan_filter(struct dma_chan *chan, void *arg)
+{
+        struct rio_dev *rdev = arg;
+
+        /* Check that DMA device belongs to the right MPORT */
+        return (rdev->net->hport ==
+                container_of(chan->device, struct rio_mport, dma));
+}
+
+/**
+ * rio_request_dma - request RapidIO capable DMA channel that supports
+ *   specified target RapidIO device.
+ * @rdev: RIO device control structure
+ *
+ * Returns pointer to allocated DMA channel or NULL if failed.
+ */
+struct dma_chan *rio_request_dma(struct rio_dev *rdev)
+{
+        dma_cap_mask_t mask;
+        struct dma_chan *dchan;
+
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        dchan = dma_request_channel(mask, rio_chan_filter, rdev);
+
+        return dchan;
+}
+EXPORT_SYMBOL_GPL(rio_request_dma);
+
+/**
+ * rio_release_dma - release specified DMA channel
+ * @dchan: DMA channel to release
+ */
+void rio_release_dma(struct dma_chan *dchan)
+{
+        dma_release_channel(dchan);
+}
+EXPORT_SYMBOL_GPL(rio_release_dma);
+
+/**
+ * rio_dma_prep_slave_sg - RapidIO specific wrapper
+ *   for device_prep_slave_sg callback defined by DMAENGINE.
+ * @rdev: RIO device control structure
+ * @dchan: DMA channel to configure
+ * @data: RIO specific data descriptor
+ * @direction: DMA data transfer direction (TO or FROM the device)
+ * @flags: dmaengine defined flags
+ *
+ * Initializes RapidIO capable DMA channel for the specified data transfer.
+ * Uses DMA channel private extension to pass information related to remote
+ * target RIO device.
+ * Returns pointer to DMA transaction descriptor or NULL if failed.
+ */
+struct dma_async_tx_descriptor *rio_dma_prep_slave_sg(struct rio_dev *rdev,
+        struct dma_chan *dchan, struct rio_dma_data *data,
+        enum dma_transfer_direction direction, unsigned long flags)
+{
+        struct dma_async_tx_descriptor *txd = NULL;
+        struct rio_dma_ext rio_ext;
+
+        if (dchan->device->device_prep_slave_sg == NULL) {
+                pr_err("%s: prep_rio_sg == NULL\n", __func__);
+                return NULL;
+        }
+
+        rio_ext.destid = rdev->destid;
+        rio_ext.rio_addr_u = data->rio_addr_u;
+        rio_ext.rio_addr = data->rio_addr;
+        rio_ext.wr_type = data->wr_type;
+
+        txd = dmaengine_prep_rio_sg(dchan, data->sg, data->sg_len,
+                                        direction, flags, &rio_ext);
+
+        return txd;
+}
+EXPORT_SYMBOL_GPL(rio_dma_prep_slave_sg);
+
+#endif /* CONFIG_RAPIDIO_DMA_ENGINE */
+
 static void rio_fixup_device(struct rio_dev *dev)
 {
 }