ASoC: pandora: Add DAC regulator support
[linux-2.6.git] / sound / soc / omap / omap-pcm.c
index c3c931d..9db2770 100644 (file)
@@ -28,7 +28,7 @@
 #include <sound/pcm_params.h>
 #include <sound/soc.h>
 
-#include <mach/dma.h>
+#include <plat/dma.h>
 #include "omap-pcm.h"
 
 static const struct snd_pcm_hardware omap_pcm_hardware = {
@@ -59,16 +59,31 @@ static void omap_pcm_dma_irq(int ch, u16 stat, void *data)
        struct omap_runtime_data *prtd = runtime->private_data;
        unsigned long flags;
 
-       if (cpu_is_omap1510()) {
+       if ((cpu_is_omap1510()) &&
+                       (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)) {
                /*
-                * OMAP1510 doesn't support DMA chaining so have to restart
-                * the transfer after all periods are transferred
+                * OMAP1510 doesn't fully support DMA progress counter
+                * and there is no software emulation implemented yet,
+                * so have to maintain our own playback progress counter
+                * 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 (++prtd->period_index == runtime->periods) {
+                       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;
-                               omap_start_dma(prtd->dma_ch);
                        }
                }
                spin_unlock_irqrestore(&prtd->lock, flags);
@@ -100,7 +115,7 @@ static int omap_pcm_hw_params(struct snd_pcm_substream *substream,
        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 && !cpu_is_omap1510()) {
+       if (!err) {
                /*
                 * Link channel with itself so DMA doesn't need any
                 * reprogramming while looping the buffer
@@ -119,8 +134,7 @@ static int omap_pcm_hw_free(struct snd_pcm_substream *substream)
        if (prtd->dma_data == NULL)
                return 0;
 
-       if (!cpu_is_omap1510())
-               omap_dma_unlink_lch(prtd->dma_ch, prtd->dma_ch);
+       omap_dma_unlink_lch(prtd->dma_ch, prtd->dma_ch);
        omap_free_dma(prtd->dma_ch);
        prtd->dma_data = NULL;
 
@@ -148,7 +162,7 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
         */
        dma_params.data_type                    = OMAP_DMA_DATA_TYPE_S16;
        dma_params.trigger                      = dma_data->dma_req;
-       dma_params.sync_mode                    = OMAP_DMA_SYNC_ELEMENT;
+       dma_params.sync_mode                    = dma_data->sync_mode;
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                dma_params.src_amode            = OMAP_DMA_AMODE_POST_INC;
                dma_params.dst_amode            = OMAP_DMA_AMODE_CONSTANT;
@@ -174,7 +188,19 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
        dma_params.frame_count  = runtime->periods;
        omap_set_dma_params(prtd->dma_ch, &dma_params);
 
-       omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_IRQ);
+       if ((cpu_is_omap1510()) &&
+                       (substream->stream == SNDRV_PCM_STREAM_PLAYBACK))
+               omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_IRQ |
+                             OMAP_DMA_LAST_IRQ | OMAP_DMA_BLOCK_IRQ);
+       else
+               omap_enable_dma_irq(prtd->dma_ch, OMAP_DMA_FRAME_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);
+       }
 
        return 0;
 }
@@ -183,6 +209,7 @@ 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;
        int ret = 0;
 
@@ -192,6 +219,10 @@ static int omap_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
        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;
 
@@ -288,7 +319,7 @@ static struct snd_pcm_ops omap_pcm_ops = {
        .mmap           = omap_pcm_mmap,
 };
 
-static u64 omap_pcm_dmamask = DMA_BIT_MASK(32);
+static u64 omap_pcm_dmamask = DMA_BIT_MASK(64);
 
 static int omap_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
        int stream)
@@ -338,7 +369,7 @@ static int omap_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
        if (!card->dev->dma_mask)
                card->dev->dma_mask = &omap_pcm_dmamask;
        if (!card->dev->coherent_dma_mask)
-               card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
+               card->dev->coherent_dma_mask = DMA_BIT_MASK(64);
 
        if (dai->playback.channels_min) {
                ret = omap_pcm_preallocate_dma_buffer(pcm,