dmaengine/dma_slave: introduce inline wrappers
Alexandre Bounine [Thu, 8 Mar 2012 21:11:18 +0000 (16:11 -0500)]
Add inline wrappers for device_prep_slave_sg() and device_prep_dma_cyclic()
interfaces to hide new parameter from current users of affected interfaces.
Convert current users to use new wrappers instead of direct calls.
Suggested by Russell King [https://lkml.org/lkml/2012/2/3/269].

Signed-off-by: Alexandre Bounine <alexandre.bounine@idt.com>
Signed-off-by: Vinod Koul <vinod.koul@linux.intel.com>

cherry-picked from mainline commit
16052827d98fbc13c31ebad560af4bd53e2b4dd5

Change-Id: I929a49556539621a0546829e88b3caa498c94be2
Signed-off-by: Laxman Dewangan <ldewangan@nvidia.com>
Reviewed-on: http://git-master/r/94463

24 files changed:
arch/arm/plat-nomadik/include/plat/ste_dma40.h
drivers/media/video/mx3_camera.c
drivers/media/video/timblogiw.c
drivers/mmc/host/atmel-mci.c
drivers/mmc/host/mmci.c
drivers/mmc/host/mxcmmc.c
drivers/mmc/host/mxs-mmc.c
drivers/mmc/host/sh_mmcif.c
drivers/mmc/host/tmio_mmc_dma.c
drivers/spi/spi-dw-mid.c
drivers/spi/spi-ep93xx.c
drivers/spi/spi-pl022.c
drivers/spi/spi-topcliff-pch.c
drivers/tty/serial/amba-pl011.c
drivers/tty/serial/pch_uart.c
drivers/tty/serial/sh-sci.c
drivers/usb/musb/ux500_dma.c
drivers/usb/renesas_usbhs/fifo.c
drivers/video/mx3fb.c
include/linux/dmaengine.h
sound/soc/ep93xx/ep93xx-pcm.c
sound/soc/imx/imx-pcm-dma-mx2.c
sound/soc/sh/siu_pcm.c
sound/soc/txx9/txx9aclc.c

index 685c787..37487d7 100644 (file)
@@ -195,8 +195,7 @@ dma_async_tx_descriptor *stedma40_slave_mem(struct dma_chan *chan,
        sg.dma_address = addr;
        sg.length = size;
 
-       return chan->device->device_prep_slave_sg(chan, &sg, 1,
-                                                 direction, flags);
+       return dmaengine_prep_slave_sg(chan, &sg, 1, direction, flags);
 }
 
 #else
index c045b47..8fd8281 100644 (file)
@@ -292,6 +292,38 @@ static void mx3_videobuf_queue(struct vb2_buffer *vb)
        dma_cookie_t cookie;
        u32 fourcc = icd->current_fmt->host_fmt->fourcc;
        unsigned long flags;
+       size_t new_size;
+
+       BUG_ON(bytes_per_line <= 0);
+
+       new_size = bytes_per_line * icd->user_height;
+
+       if (vb2_plane_size(vb, 0) < new_size) {
+               dev_err(icd->parent, "Buffer #%d too small (%lu < %zu)\n",
+                       vb->v4l2_buf.index, vb2_plane_size(vb, 0), new_size);
+               goto error;
+       }
+
+       if (buf->state == CSI_BUF_NEEDS_INIT) {
+               sg_dma_address(sg)      = vb2_dma_contig_plane_dma_addr(vb, 0);
+               sg_dma_len(sg)          = new_size;
+
+               txd = dmaengine_prep_slave_sg(
+                       &ichan->dma_chan, sg, 1, DMA_DEV_TO_MEM,
+                       DMA_PREP_INTERRUPT);
+               if (!txd)
+                       goto error;
+
+               txd->callback_param     = txd;
+               txd->callback           = mx3_cam_dma_done;
+
+               buf->state              = CSI_BUF_PREPARED;
+               buf->txd                = txd;
+       } else {
+               txd = buf->txd;
+       }
+
+       vb2_set_plane_payload(vb, 0, new_size);
 
        /* This is the configuration of one sg-element */
        video->out_pixel_fmt    = fourcc_to_ipu_pix(fourcc);
index 84cd1b6..81f6c05 100644 (file)
@@ -563,8 +563,8 @@ static void buffer_queue(struct videobuf_queue *vq, struct videobuf_buffer *vb)
 
        spin_unlock_irq(&fh->queue_lock);
 
-       desc = fh->chan->device->device_prep_slave_sg(fh->chan,
-               buf->sg, sg_elems, DMA_FROM_DEVICE,
+       desc = dmaengine_prep_slave_sg(fh->chan,
+               buf->sg, sg_elems, DMA_DEV_TO_MEM,
                DMA_PREP_INTERRUPT | DMA_COMPL_SKIP_SRC_UNMAP);
        if (!desc) {
                spin_lock_irq(&fh->queue_lock);
index fa8cae1..bcc5728 100644 (file)
@@ -689,8 +689,9 @@ atmci_prepare_data_dma(struct atmel_mci *host, struct mmc_data *data)
        sglen = dma_map_sg(chan->device->dev, data->sg,
                           data->sg_len, direction);
 
-       desc = chan->device->device_prep_slave_sg(chan,
-                       data->sg, sglen, direction,
+       dmaengine_slave_config(chan, &host->dma_conf);
+       desc = dmaengine_prep_slave_sg(chan,
+                       data->sg, sglen, slave_dirn,
                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc)
                goto unmap_exit;
index d8eac24..b66b466 100644 (file)
@@ -406,7 +406,7 @@ static int mmci_dma_prep_data(struct mmci_host *host, struct mmc_data *data,
                return -EINVAL;
 
        dmaengine_slave_config(chan, &conf);
-       desc = device->device_prep_slave_sg(chan, data->sg, nr_sg,
+       desc = dmaengine_prep_slave_sg(chan, data->sg, nr_sg,
                                            conf.direction, DMA_CTRL_ACK);
        if (!desc)
                goto unmap_exit;
index b87143d..1365e7a 100644 (file)
@@ -249,8 +249,8 @@ static int mxcmci_setup_data(struct mxcmci_host *host, struct mmc_data *data)
        if (nents != data->sg_len)
                return -EINVAL;
 
-       host->desc = host->dma->device->device_prep_slave_sg(host->dma,
-               data->sg, data->sg_len, host->dma_dir,
+       host->desc = dmaengine_prep_slave_sg(host->dma,
+               data->sg, data->sg_len, slave_dirn,
                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 
        if (!host->desc) {
index d513d47..a31b338 100644 (file)
@@ -322,8 +322,8 @@ static struct dma_async_tx_descriptor *mxs_mmc_prep_dma(
                sg_len = SSP_PIO_NUM;
        }
 
-       desc = host->dmach->device->device_prep_slave_sg(host->dmach,
-                               sgl, sg_len, host->dma_dir, append);
+       desc = dmaengine_prep_slave_sg(host->dmach,
+                               sgl, sg_len, host->slave_dirn, append);
        if (desc) {
                desc->callback = mxs_mmc_dma_irq_callback;
                desc->callback_param = host;
index 557886b..34f83a4 100644 (file)
@@ -229,8 +229,8 @@ static void sh_mmcif_start_dma_rx(struct sh_mmcif_host *host)
                         DMA_FROM_DEVICE);
        if (ret > 0) {
                host->dma_active = true;
-               desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                       DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+               desc = dmaengine_prep_slave_sg(chan, sg, ret,
+                       DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        }
 
        if (desc) {
@@ -277,8 +277,13 @@ static void sh_mmcif_start_dma_tx(struct sh_mmcif_host *host)
                         DMA_TO_DEVICE);
        if (ret > 0) {
                host->dma_active = true;
+<<<<<<< HEAD
                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
                        DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+=======
+               desc = dmaengine_prep_slave_sg(chan, sg, ret,
+                       DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
        }
 
        if (desc) {
index 86f259c..d298e7b 100644 (file)
@@ -76,8 +76,8 @@ static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
 
        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_FROM_DEVICE);
        if (ret > 0)
-               desc = chan->device->device_prep_slave_sg(chan, sg, ret,
-                       DMA_FROM_DEVICE, DMA_CTRL_ACK);
+               desc = dmaengine_prep_slave_sg(chan, sg, ret,
+                       DMA_DEV_TO_MEM, DMA_CTRL_ACK);
 
        if (desc) {
                cookie = dmaengine_submit(desc);
@@ -157,8 +157,13 @@ static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
 
        ret = dma_map_sg(chan->device->dev, sg, host->sg_len, DMA_TO_DEVICE);
        if (ret > 0)
+<<<<<<< HEAD
                desc = chan->device->device_prep_slave_sg(chan, sg, ret,
                        DMA_TO_DEVICE, DMA_CTRL_ACK);
+=======
+               desc = dmaengine_prep_slave_sg(chan, sg, ret,
+                       DMA_MEM_TO_DEV, DMA_CTRL_ACK);
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
 
        if (desc) {
                cookie = dmaengine_submit(desc);
index 130e555..e9f1e40 100644 (file)
@@ -144,7 +144,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
        dws->tx_sgl.dma_address = dws->tx_dma;
        dws->tx_sgl.length = dws->len;
 
-       txdesc = txchan->device->device_prep_slave_sg(txchan,
+       txdesc = dmaengine_prep_slave_sg(txchan,
                                &dws->tx_sgl,
                                1,
                                DMA_TO_DEVICE,
@@ -166,7 +166,7 @@ static int mid_spi_dma_transfer(struct dw_spi *dws, int cs_change)
        dws->rx_sgl.dma_address = dws->rx_dma;
        dws->rx_sgl.length = dws->len;
 
-       rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
+       rxdesc = dmaengine_prep_slave_sg(rxchan,
                                &dws->rx_sgl,
                                1,
                                DMA_FROM_DEVICE,
index 1cf6454..9a9e27b 100644 (file)
@@ -629,8 +629,8 @@ ep93xx_spi_dma_prepare(struct ep93xx_spi *espi, enum dma_data_direction dir)
        if (!nents)
                return ERR_PTR(-ENOMEM);
 
-       txd = chan->device->device_prep_slave_sg(chan, sgt->sgl, nents,
-                                                dir, DMA_CTRL_ACK);
+       txd = dmaengine_prep_slave_sg(chan, sgt->sgl, nents,
+                                       slave_dirn, DMA_CTRL_ACK);
        if (!txd) {
                dma_unmap_sg(chan->device->dev, sgt->sgl, sgt->nents, dir);
                return ERR_PTR(-ENOMEM);
index 730b4a3..45d7381 100644 (file)
@@ -1048,7 +1048,7 @@ static int configure_dma(struct pl022 *pl022)
                goto err_tx_sgmap;
 
        /* Send both scatterlists */
-       rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
+       rxdesc = dmaengine_prep_slave_sg(rxchan,
                                      pl022->sgt_rx.sgl,
                                      rx_sglen,
                                      DMA_FROM_DEVICE,
@@ -1056,7 +1056,7 @@ static int configure_dma(struct pl022 *pl022)
        if (!rxdesc)
                goto err_rxdesc;
 
-       txdesc = txchan->device->device_prep_slave_sg(txchan,
+       txdesc = dmaengine_prep_slave_sg(txchan,
                                      pl022->sgt_tx.sgl,
                                      tx_sglen,
                                      DMA_TO_DEVICE,
index 6a80749..f5c226c 100644 (file)
@@ -1075,8 +1075,8 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
                sg_dma_address(sg) = dma->rx_buf_dma + sg->offset;
        }
        sg = dma->sg_rx_p;
-       desc_rx = dma->chan_rx->device->device_prep_slave_sg(dma->chan_rx, sg,
-                                       num, DMA_FROM_DEVICE,
+       desc_rx = dmaengine_prep_slave_sg(dma->chan_rx, sg,
+                                       num, DMA_DEV_TO_MEM,
                                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc_rx) {
                dev_err(&data->master->dev, "%s:device_prep_slave_sg Failed\n",
@@ -1120,8 +1120,13 @@ static void pch_spi_handle_dma(struct pch_spi_data *data, int *bpw)
                sg_dma_address(sg) = dma->tx_buf_dma + sg->offset;
        }
        sg = dma->sg_tx_p;
+<<<<<<< HEAD
        desc_tx = dma->chan_tx->device->device_prep_slave_sg(dma->chan_tx,
                                        sg, num, DMA_TO_DEVICE,
+=======
+       desc_tx = dmaengine_prep_slave_sg(dma->chan_tx,
+                                       sg, num, DMA_MEM_TO_DEV,
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
                                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc_tx) {
                dev_err(&data->master->dev, "%s:device_prep_slave_sg Failed\n",
index 4a4733e..df8c8fa 100644 (file)
@@ -480,7 +480,7 @@ static int pl011_dma_tx_refill(struct uart_amba_port *uap)
                return -EBUSY;
        }
 
-       desc = dma_dev->device_prep_slave_sg(chan, &dmatx->sg, 1, DMA_TO_DEVICE,
+       desc = dmaengine_prep_slave_sg(chan, &dmatx->sg, 1, DMA_MEM_TO_DEV,
                                             DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc) {
                dma_unmap_sg(dma_dev->dev, &dmatx->sg, 1, DMA_TO_DEVICE);
@@ -663,7 +663,6 @@ static void pl011_dma_rx_callback(void *data);
 static int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap)
 {
        struct dma_chan *rxchan = uap->dmarx.chan;
-       struct dma_device *dma_dev;
        struct pl011_dmarx_data *dmarx = &uap->dmarx;
        struct dma_async_tx_descriptor *desc;
        struct pl011_sgbuf *sgbuf;
@@ -674,9 +673,14 @@ static int pl011_dma_rx_trigger_dma(struct uart_amba_port *uap)
        /* Start the RX DMA job */
        sgbuf = uap->dmarx.use_buf_b ?
                &uap->dmarx.sgbuf_b : &uap->dmarx.sgbuf_a;
+<<<<<<< HEAD
        dma_dev = rxchan->device;
        desc = rxchan->device->device_prep_slave_sg(rxchan, &sgbuf->sg, 1,
                                        DMA_FROM_DEVICE,
+=======
+       desc = dmaengine_prep_slave_sg(rxchan, &sgbuf->sg, 1,
+                                       DMA_DEV_TO_MEM,
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
                                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        /*
         * If the DMA engine is busy and cannot prepare a
index f913ed0..5c33cef 100644 (file)
@@ -751,8 +751,8 @@ static int dma_handle_rx(struct eg20t_port *priv)
 
        sg_dma_address(sg) = priv->rx_buf_dma;
 
-       desc = priv->chan_rx->device->device_prep_slave_sg(priv->chan_rx,
-                       sg, 1, DMA_FROM_DEVICE,
+       desc = dmaengine_prep_slave_sg(priv->chan_rx,
+                       sg, 1, DMA_DEV_TO_MEM,
                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
 
        if (!desc)
@@ -910,8 +910,13 @@ static unsigned int dma_handle_tx(struct eg20t_port *priv)
                        sg_dma_len(sg) = size;
        }
 
+<<<<<<< HEAD
        desc = priv->chan_tx->device->device_prep_slave_sg(priv->chan_tx,
                                        priv->sg_tx_p, nent, DMA_TO_DEVICE,
+=======
+       desc = dmaengine_prep_slave_sg(priv->chan_tx,
+                                       priv->sg_tx_p, nent, DMA_MEM_TO_DEV,
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
                                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc) {
                dev_err(priv->port.dev, "%s:device_prep_slave_sg Failed\n",
index 5ea6ec3..3f4d919 100644 (file)
@@ -1213,8 +1213,8 @@ static void sci_submit_rx(struct sci_port *s)
                struct scatterlist *sg = &s->sg_rx[i];
                struct dma_async_tx_descriptor *desc;
 
-               desc = chan->device->device_prep_slave_sg(chan,
-                       sg, 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT);
+               desc = dmaengine_prep_slave_sg(chan,
+                       sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT);
 
                if (desc) {
                        s->desc_rx[i] = desc;
@@ -1328,8 +1328,13 @@ static void work_fn_tx(struct work_struct *work)
 
        BUG_ON(!sg_dma_len(sg));
 
+<<<<<<< HEAD
        desc = chan->device->device_prep_slave_sg(chan,
                        sg, s->sg_len_tx, DMA_TO_DEVICE,
+=======
+       desc = dmaengine_prep_slave_sg(chan,
+                       sg, s->sg_len_tx, DMA_MEM_TO_DEV,
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
                        DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc) {
                /* switch to PIO */
index ef4333f..6be1697 100644 (file)
@@ -147,8 +147,7 @@ static bool ux500_configure_channel(struct dma_channel *channel,
        dma_chan->device->device_control(dma_chan, DMA_SLAVE_CONFIG,
                                             (unsigned long) &slave_conf);
 
-       dma_desc = dma_chan->device->
-                       device_prep_slave_sg(dma_chan, &sg, 1, direction,
+       dma_desc = dmaengine_prep_slave_sg(dma_chan, &sg, 1, direction,
                                             DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!dma_desc)
                return false;
index a34430f..18d909e 100644 (file)
@@ -602,9 +602,8 @@ static void usbhsf_dma_prepare_tasklet(unsigned long data)
        sg_dma_address(&sg) = pkt->dma + pkt->actual;
        sg_dma_len(&sg) = pkt->trans;
 
-       desc = chan->device->device_prep_slave_sg(chan, &sg, 1, dir,
-                                                 DMA_PREP_INTERRUPT |
-                                                 DMA_CTRL_ACK);
+       desc = dmaengine_prep_slave_sg(chan, &sg, 1, dir,
+                                       DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc)
                return;
 
index 7e3a490..473875a 100644 (file)
@@ -333,8 +333,8 @@ static void sdc_enable_channel(struct mx3fb_info *mx3_fbi)
 
        /* This enables the channel */
        if (mx3_fbi->cookie < 0) {
-               mx3_fbi->txd = dma_chan->device->device_prep_slave_sg(dma_chan,
-                     &mx3_fbi->sg[0], 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT);
+               mx3_fbi->txd = dmaengine_prep_slave_sg(dma_chan,
+                     &mx3_fbi->sg[0], 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
                if (!mx3_fbi->txd) {
                        dev_err(mx3fb->dev, "Cannot allocate descriptor on %d\n",
                                dma_chan->chan_id);
@@ -1103,8 +1103,13 @@ static int mx3fb_pan_display(struct fb_var_screeninfo *var,
        if (mx3_fbi->txd)
                async_tx_ack(mx3_fbi->txd);
 
+<<<<<<< HEAD
        txd = dma_chan->device->device_prep_slave_sg(dma_chan, sg +
                mx3_fbi->cur_ipu_buf, 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT);
+=======
+       txd = dmaengine_prep_slave_sg(dma_chan, sg +
+               mx3_fbi->cur_ipu_buf, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT);
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
        if (!txd) {
                dev_err(fbi->device,
                        "Error preparing a DMA transaction descriptor.\n");
index c203fc8..0d41e44 100644 (file)
@@ -542,6 +542,22 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
        return chan->device->device_prep_slave_sg(chan, &sg, 1, dir, flags);
 }
 
+static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_sg(
+       struct dma_chan *chan, struct scatterlist *sgl, unsigned int sg_len,
+       enum dma_transfer_direction dir, unsigned long flags)
+{
+       return chan->device->device_prep_slave_sg(chan, sgl, sg_len,
+                                                 dir, flags);
+}
+
+static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(
+               struct dma_chan *chan, dma_addr_t buf_addr, size_t buf_len,
+               size_t period_len, enum dma_transfer_direction dir)
+{
+       return chan->device->device_prep_dma_cyclic(chan, buf_addr, buf_len,
+                                                       period_len, dir);
+}
+
 static inline int dmaengine_terminate_all(struct dma_chan *chan)
 {
        return dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
index 8dfd3ad..87c6e0a 100644 (file)
@@ -142,11 +142,10 @@ static int ep93xx_pcm_dma_submit(struct snd_pcm_substream *substream)
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct ep93xx_runtime_data *rtd = runtime->private_data;
        struct dma_chan *chan = rtd->dma_chan;
-       struct dma_device *dma_dev = chan->device;
        struct dma_async_tx_descriptor *desc;
 
        rtd->pointer_bytes = 0;
-       desc = dma_dev->device_prep_dma_cyclic(chan, runtime->dma_addr,
+       desc = dmaengine_prep_dma_cyclic(chan, runtime->dma_addr,
                                               rtd->period_bytes * rtd->periods,
                                               rtd->period_bytes,
                                               rtd->dma_data.direction);
index 43fdc24..edc2cea 100644 (file)
@@ -155,7 +155,7 @@ static int snd_imx_pcm_hw_params(struct snd_pcm_substream *substream,
 
        iprtd->buf = (unsigned int *)substream->dma_buffer.area;
 
-       iprtd->desc = chan->device->device_prep_dma_cyclic(chan, dma_addr,
+       iprtd->desc = dmaengine_prep_dma_cyclic(chan, dma_addr,
                        iprtd->period_bytes * iprtd->periods,
                        iprtd->period_bytes,
                        substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
index f8f6816..de9abd0 100644 (file)
@@ -130,8 +130,8 @@ static int siu_pcm_wr_set(struct siu_port *port_info,
        sg_dma_len(&sg) = size;
        sg_dma_address(&sg) = buff;
 
-       desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,
-               &sg, 1, DMA_TO_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+       desc = dmaengine_prep_slave_sg(siu_stream->chan,
+               &sg, 1, DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
        if (!desc) {
                dev_err(dev, "Failed to allocate a dma descriptor\n");
                return -ENOMEM;
@@ -180,8 +180,13 @@ static int siu_pcm_rd_set(struct siu_port *port_info,
        sg_dma_len(&sg) = size;
        sg_dma_address(&sg) = buff;
 
+<<<<<<< HEAD
        desc = siu_stream->chan->device->device_prep_slave_sg(siu_stream->chan,
                &sg, 1, DMA_FROM_DEVICE, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+=======
+       desc = dmaengine_prep_slave_sg(siu_stream->chan,
+               &sg, 1, DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+>>>>>>> 1605282... dmaengine/dma_slave: introduce inline wrappers
        if (!desc) {
                dev_err(dev, "Failed to allocate dma descriptor\n");
                return -ENOMEM;
index 3de99af..acd0027 100644 (file)
@@ -132,7 +132,7 @@ txx9aclc_dma_submit(struct txx9aclc_dmadata *dmadata, dma_addr_t buf_dma_addr)
        sg_set_page(&sg, pfn_to_page(PFN_DOWN(buf_dma_addr)),
                    dmadata->frag_bytes, buf_dma_addr & (PAGE_SIZE - 1));
        sg_dma_address(&sg) = buf_dma_addr;
-       desc = chan->device->device_prep_slave_sg(chan, &sg, 1,
+       desc = dmaengine_prep_slave_sg(chan, &sg, 1,
                dmadata->substream->stream == SNDRV_PCM_STREAM_PLAYBACK ?
                DMA_TO_DEVICE : DMA_FROM_DEVICE,
                DMA_PREP_INTERRUPT | DMA_CTRL_ACK);