ASoC: Intel: mfld_pcm: move stream handling to dai_ops

This helps us to handle pcm and compress ops seperately and per dai

Signed-off-by: Vinod Koul <vinod.koul@intel.com>
Signed-off-by: Mark Brown <broonie@linaro.org>

diff --git a/sound/soc/intel/sst-mfld-platform-pcm.c b/sound/soc/intel/sst-mfld-platform-pcm.c
index 7c790f51d2597d30d3c22325d6d4d589dc341d1d..0d46005752bceb397f2ce91ec8124ebfa6ca7a63 100644 (file)
--- a/sound/soc/intel/sst-mfld-platform-pcm.c
+++ b/sound/soc/intel/sst-mfld-platform-pcm.c
@@ -230,19 +230,12 @@ static int sst_platform_init_stream(struct snd_pcm_substream *substream)
 }
 /* end -- helper functions */
 
-static int sst_platform_open(struct snd_pcm_substream *substream)
+static int sst_media_open(struct snd_pcm_substream *substream,
+               struct snd_soc_dai *dai)
 {
+       int ret_val = 0;
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct sst_runtime_stream *stream;
-       int ret_val;
-
-       pr_debug("sst_platform_open called\n");
-
-       snd_soc_set_runtime_hwparams(substream, &sst_platform_pcm_hw);
-       ret_val = snd_pcm_hw_constraint_integer(runtime,
-                                               SNDRV_PCM_HW_PARAM_PERIODS);
-       if (ret_val < 0)
-               return ret_val;
 
        stream = kzalloc(sizeof(*stream), GFP_KERNEL);
        if (!stream)
@@ -251,50 +244,54 @@ static int sst_platform_open(struct snd_pcm_substream *substream)
 
        /* get the sst ops */
        mutex_lock(&sst_lock);
-       if (!sst) {
+       if (!sst ||
+           !try_module_get(sst->dev->driver->owner)) {
                pr_err("no device available to run\n");
-               mutex_unlock(&sst_lock);
-               kfree(stream);
-               return -ENODEV;
-       }
-       if (!try_module_get(sst->dev->driver->owner)) {
-               mutex_unlock(&sst_lock);
-               kfree(stream);
-               return -ENODEV;
+               ret_val = -ENODEV;
+               goto out_ops;
        }
        stream->ops = sst->ops;
        mutex_unlock(&sst_lock);
 
        stream->stream_info.str_id = 0;
-       sst_set_stream_status(stream, SST_PLATFORM_INIT);
+
        stream->stream_info.mad_substream = substream;
        /* allocate memory for SST API set */
        runtime->private_data = stream;
 
-       return 0;
+       /* Make sure, that the period size is always even */
+       snd_pcm_hw_constraint_step(substream->runtime, 0,
+                          SNDRV_PCM_HW_PARAM_PERIODS, 2);
+
+       return snd_pcm_hw_constraint_integer(runtime,
+                        SNDRV_PCM_HW_PARAM_PERIODS);
+out_ops:
+       kfree(stream);
+       mutex_unlock(&sst_lock);
+       return ret_val;
 }
 
-static int sst_platform_close(struct snd_pcm_substream *substream)
+static void sst_media_close(struct snd_pcm_substream *substream,
+               struct snd_soc_dai *dai)
 {
        struct sst_runtime_stream *stream;
        int ret_val = 0, str_id;
 
-       pr_debug("sst_platform_close called\n");
        stream = substream->runtime->private_data;
        str_id = stream->stream_info.str_id;
        if (str_id)
                ret_val = stream->ops->close(str_id);
        module_put(sst->dev->driver->owner);
        kfree(stream);
-       return ret_val;
+       return;
 }
 
-static int sst_platform_pcm_prepare(struct snd_pcm_substream *substream)
+static int sst_media_prepare(struct snd_pcm_substream *substream,
+               struct snd_soc_dai *dai)
 {
        struct sst_runtime_stream *stream;
        int ret_val = 0, str_id;
 
-       pr_debug("sst_platform_pcm_prepare called\n");
        stream = substream->runtime->private_data;
        str_id = stream->stream_info.str_id;
        if (stream->stream_info.str_id) {
@@ -316,6 +313,41 @@ static int sst_platform_pcm_prepare(struct snd_pcm_substream *substream)
        return ret_val;
 }
 
+static int sst_media_hw_params(struct snd_pcm_substream *substream,
+                               struct snd_pcm_hw_params *params,
+                               struct snd_soc_dai *dai)
+{
+       snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
+       memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
+       return 0;
+}
+
+static int sst_media_hw_free(struct snd_pcm_substream *substream,
+               struct snd_soc_dai *dai)
+{
+       return snd_pcm_lib_free_pages(substream);
+}
+
+static struct snd_soc_dai_ops sst_media_dai_ops = {
+       .startup = sst_media_open,
+       .shutdown = sst_media_close,
+       .prepare = sst_media_prepare,
+       .hw_params = sst_media_hw_params,
+       .hw_free = sst_media_hw_free,
+};
+
+static int sst_platform_open(struct snd_pcm_substream *substream)
+{
+       struct snd_pcm_runtime *runtime;
+
+       if (substream->pcm->internal)
+               return 0;
+
+       runtime = substream->runtime;
+       runtime->hw = sst_platform_pcm_hw;
+       return 0;
+}
+
 static int sst_platform_pcm_trigger(struct snd_pcm_substream *substream,
                                        int cmd)
 {
@@ -377,32 +409,14 @@ static snd_pcm_uframes_t sst_platform_pcm_pointer
                pr_err("sst: error code = %d\n", ret_val);
                return ret_val;
        }
-       return stream->stream_info.buffer_ptr;
-}
-
-static int sst_platform_pcm_hw_params(struct snd_pcm_substream *substream,
-               struct snd_pcm_hw_params *params)
-{
-       snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
-       memset(substream->runtime->dma_area, 0, params_buffer_bytes(params));
-
-       return 0;
-}
-
-static int sst_platform_pcm_hw_free(struct snd_pcm_substream *substream)
-{
-       return snd_pcm_lib_free_pages(substream);
+       return str_info->buffer_ptr;
 }
 
 static struct snd_pcm_ops sst_platform_ops = {
        .open = sst_platform_open,
-       .close = sst_platform_close,
        .ioctl = snd_pcm_lib_ioctl,
-       .prepare = sst_platform_pcm_prepare,
        .trigger = sst_platform_pcm_trigger,
        .pointer = sst_platform_pcm_pointer,
-       .hw_params = sst_platform_pcm_hw_params,
-       .hw_free = sst_platform_pcm_hw_free,
 };
 
 static void sst_pcm_free(struct snd_pcm *pcm)
@@ -413,15 +427,15 @@ static void sst_pcm_free(struct snd_pcm *pcm)
 
 static int sst_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
+       struct snd_soc_dai *dai = rtd->cpu_dai;
        struct snd_pcm *pcm = rtd->pcm;
        int retval = 0;
 
-       pr_debug("sst_pcm_new called\n");
-       if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream ||
-                       pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
+       if (dai->driver->playback.channels_min ||
+                       dai->driver->capture.channels_min) {
                retval =  snd_pcm_lib_preallocate_pages_for_all(pcm,
                        SNDRV_DMA_TYPE_CONTINUOUS,
-                       snd_dma_continuous_data(GFP_KERNEL),
+                       snd_dma_continuous_data(GFP_DMA),
                        SST_MIN_BUFFER, SST_MAX_BUFFER);
                if (retval) {
                        pr_err("dma buffer allocationf fail\n");