ASoC: pandora: Add DAC regulator support
[linux-2.6.git] / sound / soc / omap / omap-pcm.c
index 1bdbb04..9db2770 100644 (file)
@@ -3,7 +3,8 @@
  *
  * Copyright (C) 2008 Nokia Corporation
  *
- * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
+ * Contact: Jarkko Nikula <jhnikula@gmail.com>
+ *          Peter Ujfalusi <peter.ujfalusi@nokia.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License
@@ -27,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 = {
@@ -58,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);
@@ -86,8 +102,10 @@ static int omap_pcm_hw_params(struct snd_pcm_substream *substream,
        struct omap_pcm_dma_data *dma_data = rtd->dai->cpu_dai->dma_data;
        int err = 0;
 
+       /* return if this is a bufferless transfer e.g.
+        * codec <--> BT codec or GSM modem -- lg FIXME */
        if (!dma_data)
-               return -ENODEV;
+               return 0;
 
        snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
        runtime->dma_bytes = params_buffer_bytes(params);
@@ -97,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
@@ -116,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;
 
@@ -133,6 +150,11 @@ static int omap_pcm_prepare(struct snd_pcm_substream *substream)
        struct omap_pcm_dma_data *dma_data = prtd->dma_data;
        struct omap_dma_channel_params dma_params;
 
+       /* 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));
        /*
         * Note: Regardless of interface data formats supported by OMAP McBSP
@@ -140,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;
@@ -166,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;
 }
@@ -175,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;
 
@@ -184,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;
 
@@ -208,12 +247,15 @@ static snd_pcm_uframes_t omap_pcm_pointer(struct snd_pcm_substream *substream)
        dma_addr_t ptr;
        snd_pcm_uframes_t offset;
 
-       if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-               ptr = omap_get_dma_src_pos(prtd->dma_ch);
-       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 if (!(cpu_is_omap1510())) {
+               ptr = omap_get_dma_src_pos(prtd->dma_ch);
+               offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
+       } else
+               offset = prtd->period_index * runtime->period_size;
 
-       offset = bytes_to_frames(runtime, ptr - runtime->dma_addr);
        if (offset >= runtime->buffer_size)
                offset = 0;
 
@@ -277,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)
@@ -319,7 +361,7 @@ static void omap_pcm_free_dma_buffers(struct snd_pcm *pcm)
        }
 }
 
-int omap_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
+static int omap_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
                 struct snd_pcm *pcm)
 {
        int ret = 0;
@@ -327,7 +369,7 @@ 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,
@@ -367,6 +409,6 @@ static void __exit omap_soc_platform_exit(void)
 }
 module_exit(omap_soc_platform_exit);
 
-MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
+MODULE_AUTHOR("Jarkko Nikula <jhnikula@gmail.com>");
 MODULE_DESCRIPTION("OMAP PCM DMA module");
 MODULE_LICENSE("GPL");