ASoC: omap-pcm: Convert to use dmaengine
authorPeter Ujfalusi <peter.ujfalusi@ti.com>
Fri, 14 Sep 2012 12:05:58 +0000 (15:05 +0300)
committerMark Brown <broonie@opensource.wolfsonmicro.com>
Sat, 22 Sep 2012 15:13:02 +0000 (11:13 -0400)
Original author: Russell King <rmk+kernel@arm.linux.org.uk>

Switch the omap-pcm to use dmaengine.
Certain features are not supported by after dmaengine conversion:
1. No period wakeup mode
   DMA engine has no way to communicate this information through
   standard channels.

Signed-off-by: Peter Ujfalusi <peter.ujfalusi@ti.com>
Tested-by: Janusz Krzysztofik <jkrzyszt@tis.icnet.pl>
Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
sound/soc/omap/Kconfig
sound/soc/omap/omap-pcm.c

index 2c484a52ef924de45b9d8e858f527d3eb48b79a4..7048137f9a337340e0e0a78a7a55859220718538 100644 (file)
@@ -1,6 +1,7 @@
 config SND_OMAP_SOC
        tristate "SoC Audio for the Texas Instruments OMAP chips"
-       depends on ARCH_OMAP
+       depends on ARCH_OMAP && DMA_OMAP
+       select SND_SOC_DMAENGINE_PCM
 
 config SND_OMAP_SOC_DMIC
        tristate
index 74da4b7209d077d0f5e16f3efa9b5626c53ecf0a..a2636f6b836210ea8b55645e5906114535fb904f 100644 (file)
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 #include <linux/module.h>
+#include <linux/omap-dma.h>
 #include <sound/core.h>
 #include <sound/pcm.h>
 #include <sound/pcm_params.h>
+#include <sound/dmaengine_pcm.h>
 #include <sound/soc.h>
 
-#include <plat/dma.h>
 #include "omap-pcm.h"
 
 static const struct snd_pcm_hardware omap_pcm_hardware = {
@@ -49,61 +50,34 @@ static const struct snd_pcm_hardware omap_pcm_hardware = {
        .buffer_bytes_max       = 128 * 1024,
 };
 
-struct omap_runtime_data {
-       spinlock_t                      lock;
-       struct omap_pcm_dma_data        *dma_data;
-       int                             dma_ch;
-       int                             period_index;
-};
-
-static void omap_pcm_dma_irq(int ch, u16 stat, void *data)
+static int omap_pcm_get_dma_buswidth(int num_bits)
 {
-       struct snd_pcm_substream *substream = data;
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd = runtime->private_data;
-       unsigned long flags;
-
-       if ((cpu_is_omap1510())) {
-               /*
-                * OMAP1510 doesn't fully support DMA progress counter
-                * and there is no software emulation implemented yet,
-                * so have to maintain our own progress counters
-                * that can be used by omap_pcm_pointer() instead.
-                */
-               spin_lock_irqsave(&prtd->lock, flags);
-               if ((stat == OMAP_DMA_LAST_IRQ) &&
-                               (prtd->period_index == runtime->periods - 1)) {
-                       /* we are in sync, do nothing */
-                       spin_unlock_irqrestore(&prtd->lock, flags);
-                       return;
-               }
-               if (prtd->period_index >= 0) {
-                       if (stat & OMAP_DMA_BLOCK_IRQ) {
-                               /* end of buffer reached, loop back */
-                               prtd->period_index = 0;
-                       } else if (stat & OMAP_DMA_LAST_IRQ) {
-                               /* update the counter for the last period */
-                               prtd->period_index = runtime->periods - 1;
-                       } else if (++prtd->period_index >= runtime->periods) {
-                               /* end of buffer missed? loop back */
-                               prtd->period_index = 0;
-                       }
-               }
-               spin_unlock_irqrestore(&prtd->lock, flags);
-       }
+       int buswidth;
 
-       snd_pcm_period_elapsed(substream);
+       switch (num_bits) {
+       case 16:
+               buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
+               break;
+       case 32:
+               buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
+               break;
+       default:
+               buswidth = -EINVAL;
+               break;
+       }
+       return buswidth;
 }
 
+
 /* this may get called several times by oss emulation */
 static int omap_pcm_hw_params(struct snd_pcm_substream *substream,
                              struct snd_pcm_hw_params *params)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct omap_runtime_data *prtd = runtime->private_data;
        struct omap_pcm_dma_data *dma_data;
-
+       struct dma_slave_config config;
+       struct dma_chan *chan;
        int err = 0;
 
        dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
@@ -116,195 +90,78 @@ static int omap_pcm_hw_params(struct snd_pcm_substream *substream,
        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
        runtime->dma_bytes = params_buffer_bytes(params);
 
-       if (prtd->dma_data)
-               return 0;
-       prtd->dma_data = dma_data;
-       err = omap_request_dma(dma_data->dma_req, dma_data->name,
-                              omap_pcm_dma_irq, substream, &prtd->dma_ch);
-       if (!err) {
-               /*
-                * Link channel with itself so DMA doesn't need any
-                * reprogramming while looping the buffer
-                */
-               omap_dma_link_lch(prtd->dma_ch, prtd->dma_ch);
-       }
-
-       return err;
-}
-
-static int omap_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd = runtime->private_data;
-
-       if (prtd->dma_data == NULL)
-               return 0;
+       chan = snd_dmaengine_pcm_get_chan(substream);
+       if (!chan)
+               return -EINVAL;
 
-       omap_dma_unlink_lch(prtd->dma_ch, prtd->dma_ch);
-       omap_free_dma(prtd->dma_ch);
-       prtd->dma_data = NULL;
+       /* fills in addr_width and direction */
+       err = snd_hwparams_to_dma_slave_config(substream, params, &config);
+       if (err)
+               return err;
 
-       snd_pcm_set_runtime_buffer(substream, NULL);
+       /* Override the *_dma addr_width if requested by the DAI driver */
+       if (dma_data->data_type) {
+               int buswidth = omap_pcm_get_dma_buswidth(dma_data->data_type);
 
-       return 0;
-}
+               if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+                       config.dst_addr_width = buswidth;
+               else
+                       config.src_addr_width = buswidth;
+       }
 
-static int omap_pcm_get_dma_type(int num_bits)
-{
-       int data_type;
+       config.src_addr = dma_data->port_addr;
+       config.dst_addr = dma_data->port_addr;
+       config.src_maxburst = dma_data->packet_size;
+       config.dst_maxburst = dma_data->packet_size;
 
-       switch (num_bits) {
-       case 16:
-               data_type = OMAP_DMA_DATA_TYPE_S16;
-               break;
-       case 32:
-               data_type = OMAP_DMA_DATA_TYPE_S32;
-               break;
-       default:
-               data_type = -EINVAL;
-               break;
-       }
-       return data_type;
+       return dmaengine_slave_config(chan, &config);
 }
 
-static int omap_pcm_prepare(struct snd_pcm_substream *substream)
+static int omap_pcm_hw_free(struct snd_pcm_substream *substream)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd = runtime->private_data;
-       struct omap_pcm_dma_data *dma_data = prtd->dma_data;
-       struct omap_dma_channel_params dma_params;
-       int bytes;
-
-       /* return if this is a bufferless transfer e.g.
-        * codec <--> BT codec or GSM modem -- lg FIXME */
-       if (!prtd->dma_data)
-               return 0;
-
-       memset(&dma_params, 0, sizeof(dma_params));
-
-       if (dma_data->data_type)
-               dma_params.data_type = omap_pcm_get_dma_type(
-                               dma_data->data_type);
-       else
-               dma_params.data_type = omap_pcm_get_dma_type(
-                               snd_pcm_format_physical_width(runtime->format));
-
-       if (dma_params.data_type < 0)
-               return dma_params.data_type;
-
-       dma_params.trigger                      = dma_data->dma_req;
-
-       if (dma_data->packet_size)
-               dma_params.sync_mode = OMAP_DMA_SYNC_PACKET;
-       else
-               dma_params.sync_mode = OMAP_DMA_SYNC_ELEMENT;
-
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-               dma_params.src_amode            = OMAP_DMA_AMODE_POST_INC;
-               dma_params.dst_amode            = OMAP_DMA_AMODE_CONSTANT;
-               dma_params.src_or_dst_synch     = OMAP_DMA_DST_SYNC;
-               dma_params.src_start            = runtime->dma_addr;
-               dma_params.dst_start            = dma_data->port_addr;
-               dma_params.dst_port             = OMAP_DMA_PORT_MPUI;
-               dma_params.dst_fi               = dma_data->packet_size;
-       } else {
-               dma_params.src_amode            = OMAP_DMA_AMODE_CONSTANT;
-               dma_params.dst_amode            = OMAP_DMA_AMODE_POST_INC;
-               dma_params.src_or_dst_synch     = OMAP_DMA_SRC_SYNC;
-               dma_params.src_start            = dma_data->port_addr;
-               dma_params.dst_start            = runtime->dma_addr;
-               dma_params.src_port             = OMAP_DMA_PORT_MPUI;
-               dma_params.src_fi               = dma_data->packet_size;
-       }
-       /*
-        * Set DMA transfer frame size equal to ALSA period size and frame
-        * count as no. of ALSA periods. Then with DMA frame interrupt enabled,
-        * we can transfer the whole ALSA buffer with single DMA transfer but
-        * still can get an interrupt at each period bounary
-        */
-       bytes = snd_pcm_lib_period_bytes(substream);
-       dma_params.elem_count   = bytes >> dma_params.data_type;
-       dma_params.frame_count  = runtime->periods;
-       omap_set_dma_params(prtd->dma_ch, &dma_params);
-
-       if ((cpu_is_omap1510()))
-               omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_IRQ |
-                             OMAP_DMA_LAST_IRQ | OMAP_DMA_BLOCK_IRQ);
-       else if (!substream->runtime->no_period_wakeup)
-               omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_IRQ);
-       else {
-               /*
-                * No period wakeup:
-                * we need to disable BLOCK_IRQ, which is enabled by the omap
-                * dma core at request dma time.
-                */
-               omap_disable_dma_irq(prtd->dma_ch, OMAP_DMA_BLOCK_IRQ);
-       }
-
-       if (!(cpu_class_is_omap1())) {
-               omap_set_dma_src_burst_mode(prtd->dma_ch,
-                                               OMAP_DMA_DATA_BURST_16);
-               omap_set_dma_dest_burst_mode(prtd->dma_ch,
-                                               OMAP_DMA_DATA_BURST_16);
-       }
-
+       snd_pcm_set_runtime_buffer(substream, NULL);
        return 0;
 }
 
 static int omap_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd = runtime->private_data;
-       struct omap_pcm_dma_data *dma_data = prtd->dma_data;
-       unsigned long flags;
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct omap_pcm_dma_data *dma_data;
        int ret = 0;
 
-       spin_lock_irqsave(&prtd->lock, flags);
+       dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
+
        switch (cmd) {
        case SNDRV_PCM_TRIGGER_START:
        case SNDRV_PCM_TRIGGER_RESUME:
        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-               prtd->period_index = 0;
                /* Configure McBSP internal buffer usage */
                if (dma_data->set_threshold)
                        dma_data->set_threshold(substream);
-
-               omap_start_dma(prtd->dma_ch);
                break;
 
        case SNDRV_PCM_TRIGGER_STOP:
        case SNDRV_PCM_TRIGGER_SUSPEND:
        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-               prtd->period_index = -1;
-               omap_stop_dma(prtd->dma_ch);
                break;
        default:
                ret = -EINVAL;
        }
-       spin_unlock_irqrestore(&prtd->lock, flags);
+
+       if (ret == 0)
+               ret = snd_dmaengine_pcm_trigger(substream, cmd);
 
        return ret;
 }
 
 static snd_pcm_uframes_t omap_pcm_pointer(struct snd_pcm_substream *substream)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd = runtime->private_data;
-       dma_addr_t ptr;
        snd_pcm_uframes_t offset;
 
-       if (cpu_is_omap1510()) {
-               offset = prtd->period_index * runtime->period_size;
-       } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
-               ptr = omap_get_dma_dst_pos(prtd->dma_ch);
-               offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
-       } else {
-               ptr = omap_get_dma_src_pos(prtd->dma_ch);
-               offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
-       }
-
-       if (offset >= runtime->buffer_size)
-               offset = 0;
+       if (cpu_is_omap1510())
+               offset = snd_dmaengine_pcm_pointer_no_residue(substream);
+       else
+               offset = snd_dmaengine_pcm_pointer(substream);
 
        return offset;
 }
@@ -312,7 +169,8 @@ static snd_pcm_uframes_t omap_pcm_pointer(struct snd_pcm_substream *substream)
 static int omap_pcm_open(struct snd_pcm_substream *substream)
 {
        struct snd_pcm_runtime *runtime = substream->runtime;
-       struct omap_runtime_data *prtd;
+       struct snd_soc_pcm_runtime *rtd = substream->private_data;
+       struct omap_pcm_dma_data *dma_data;
        int ret;
 
        snd_soc_set_runtime_hwparams(substream, &omap_pcm_hardware);
@@ -321,25 +179,17 @@ static int omap_pcm_open(struct snd_pcm_substream *substream)
        ret = snd_pcm_hw_constraint_integer(runtime,
                                            SNDRV_PCM_HW_PARAM_PERIODS);
        if (ret < 0)
-               goto out;
-
-       prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
-       if (prtd == NULL) {
-               ret = -ENOMEM;
-               goto out;
-       }
-       spin_lock_init(&prtd->lock);
-       runtime->private_data = prtd;
+               return ret;
 
-out:
+       dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
+       ret = snd_dmaengine_pcm_open(substream, omap_dma_filter_fn,
+                                    &dma_data->dma_req);
        return ret;
 }
 
 static int omap_pcm_close(struct snd_pcm_substream *substream)
 {
-       struct snd_pcm_runtime *runtime = substream->runtime;
-
-       kfree(runtime->private_data);
+       snd_dmaengine_pcm_close(substream);
        return 0;
 }
 
@@ -360,7 +210,6 @@ static struct snd_pcm_ops omap_pcm_ops = {
        .ioctl          = snd_pcm_lib_ioctl,
        .hw_params      = omap_pcm_hw_params,
        .hw_free        = omap_pcm_hw_free,
-       .prepare        = omap_pcm_prepare,
        .trigger        = omap_pcm_trigger,
        .pointer        = omap_pcm_pointer,
        .mmap           = omap_pcm_mmap,