ASoC: q6asm: make commands specific to streams

Each ASM session can have multiple streams attached to it,
current design was to allow only one static stream id 1 per each session.
However for use-case like gapless, we would need 2 streams to open per session.

This patch converts all the q6asm apis to take stream id as argument
to allow multiple streams to open on a single session, This is useful
for gapless playback cases.

Now the dai driver can specify which stream id for each command.

Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Tested-by: Vinod Koul <vkoul@kernel.org>
Reviewed-by: Pierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Reviewed-by: Vinod Koul <vkoul@kernel.org>
Link: https://lore.kernel.org/r/20200727093806.17089-3-srinivas.kandagatla@linaro.org
Signed-off-by: Mark Brown <broonie@kernel.org>

diff --git a/sound/soc/qcom/qdsp6/q6asm-dai.c b/sound/soc/qcom/qdsp6/q6asm-dai.c
index 9b7b218..0f157f1 100644 (file)
--- a/sound/soc/qcom/qdsp6/q6asm-dai.c
+++ b/sound/soc/qcom/qdsp6/q6asm-dai.c
@@ -64,6 +64,7 @@ struct q6asm_dai_rtd {
        uint16_t bits_per_sample;
        uint16_t source; /* Encoding source bit mask */
        struct audio_client *audio_client;
+       uint32_t stream_id;
        uint16_t session_id;
        enum stream_state state;
 };
@@ -181,7 +182,7 @@ static void event_handler(uint32_t opcode, uint32_t token,
        switch (opcode) {
        case ASM_CLIENT_EVENT_CMD_RUN_DONE:
                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
-                       q6asm_write_async(prtd->audio_client,
+                       q6asm_write_async(prtd->audio_client, prtd->stream_id,
                                   prtd->pcm_count, 0, 0, NO_TIMESTAMP);
                break;
        case ASM_CLIENT_EVENT_CMD_EOS_DONE:
@@ -191,7 +192,7 @@ static void event_handler(uint32_t opcode, uint32_t token,
                prtd->pcm_irq_pos += prtd->pcm_count;
                snd_pcm_period_elapsed(substream);
                if (prtd->state == Q6ASM_STREAM_RUNNING)
-                       q6asm_write_async(prtd->audio_client,
+                       q6asm_write_async(prtd->audio_client, prtd->stream_id,
                                           prtd->pcm_count, 0, 0, NO_TIMESTAMP);
 
                break;
@@ -200,7 +201,7 @@ static void event_handler(uint32_t opcode, uint32_t token,
                prtd->pcm_irq_pos += prtd->pcm_count;
                snd_pcm_period_elapsed(substream);
                if (prtd->state == Q6ASM_STREAM_RUNNING)
-                       q6asm_read(prtd->audio_client);
+                       q6asm_read(prtd->audio_client, prtd->stream_id);
 
                break;
        default:
@@ -233,7 +234,7 @@ static int q6asm_dai_prepare(struct snd_soc_component *component,
        /* rate and channels are sent to audio driver */
        if (prtd->state) {
                /* clear the previous setup if any  */
-               q6asm_cmd(prtd->audio_client, CMD_CLOSE);
+               q6asm_cmd(prtd->audio_client, prtd->stream_id, CMD_CLOSE);
                q6asm_unmap_memory_regions(substream->stream,
                                           prtd->audio_client);
                q6routing_stream_close(soc_prtd->dai_link->id,
@@ -252,11 +253,13 @@ static int q6asm_dai_prepare(struct snd_soc_component *component,
        }
 
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
-               ret = q6asm_open_write(prtd->audio_client, FORMAT_LINEAR_PCM,
+               ret = q6asm_open_write(prtd->audio_client, prtd->stream_id,
+                                      FORMAT_LINEAR_PCM,
                                       0, prtd->bits_per_sample);
        } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
-               ret = q6asm_open_read(prtd->audio_client, FORMAT_LINEAR_PCM,
-                                      prtd->bits_per_sample);
+               ret = q6asm_open_read(prtd->audio_client, prtd->stream_id,
+                                     FORMAT_LINEAR_PCM,
+                                     prtd->bits_per_sample);
        }
 
        if (ret < 0) {
@@ -276,17 +279,19 @@ static int q6asm_dai_prepare(struct snd_soc_component *component,
 
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                ret = q6asm_media_format_block_multi_ch_pcm(
-                               prtd->audio_client, runtime->rate,
-                               runtime->channels, NULL,
+                               prtd->audio_client, prtd->stream_id,
+                               runtime->rate, runtime->channels, NULL,
                                prtd->bits_per_sample);
        } else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
                ret = q6asm_enc_cfg_blk_pcm_format_support(prtd->audio_client,
-                                       runtime->rate, runtime->channels,
-                                       prtd->bits_per_sample);
+                                                          prtd->stream_id,
+                                                          runtime->rate,
+                                                          runtime->channels,
+                                                          prtd->bits_per_sample);
 
                /* Queue the buffers */
                for (i = 0; i < runtime->periods; i++)
-                       q6asm_read(prtd->audio_client);
+                       q6asm_read(prtd->audio_client, prtd->stream_id);
 
        }
        if (ret < 0)
@@ -308,15 +313,18 @@ static int q6asm_dai_trigger(struct snd_soc_component *component,
        case SNDRV_PCM_TRIGGER_START:
        case SNDRV_PCM_TRIGGER_RESUME:
        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-               ret = q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
+               ret = q6asm_run_nowait(prtd->audio_client, prtd->stream_id,
+                                      0, 0, 0);
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                prtd->state = Q6ASM_STREAM_STOPPED;
-               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
+               ret = q6asm_cmd_nowait(prtd->audio_client, prtd->stream_id,
+                                      CMD_EOS);
                break;
        case SNDRV_PCM_TRIGGER_SUSPEND:
        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
+               ret = q6asm_cmd_nowait(prtd->audio_client, prtd->stream_id,
+                                      CMD_PAUSE);
                break;
        default:
                ret = -EINVAL;
@@ -361,6 +369,9 @@ static int q6asm_dai_open(struct snd_soc_component *component,
                return ret;
        }
 
+       /* DSP expects stream id from 1 */
+       prtd->stream_id = 1;
+
        if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                runtime->hw = q6asm_dai_hardware_playback;
        else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
@@ -427,7 +438,8 @@ static int q6asm_dai_close(struct snd_soc_component *component,
 
        if (prtd->audio_client) {
                if (prtd->state)
-                       q6asm_cmd(prtd->audio_client, CMD_CLOSE);
+                       q6asm_cmd(prtd->audio_client, prtd->stream_id,
+                                 CMD_CLOSE);
 
                q6asm_unmap_memory_regions(substream->stream,
                                           prtd->audio_client);
@@ -499,8 +511,8 @@ static void compress_event_handler(uint32_t opcode, uint32_t token,
        case ASM_CLIENT_EVENT_CMD_RUN_DONE:
                spin_lock_irqsave(&prtd->lock, flags);
                if (!prtd->bytes_sent) {
-                       q6asm_write_async(prtd->audio_client, prtd->pcm_count,
-                                         0, 0, NO_TIMESTAMP);
+                       q6asm_write_async(prtd->audio_client, prtd->stream_id,
+                                         prtd->pcm_count, 0, 0, NO_TIMESTAMP);
                        prtd->bytes_sent += prtd->pcm_count;
                }
 
@@ -525,7 +537,7 @@ static void compress_event_handler(uint32_t opcode, uint32_t token,
                avail = prtd->bytes_received - prtd->bytes_sent;
 
                if (avail >= prtd->pcm_count) {
-                       q6asm_write_async(prtd->audio_client,
+                       q6asm_write_async(prtd->audio_client, prtd->stream_id,
                                           prtd->pcm_count, 0, 0, NO_TIMESTAMP);
                        prtd->bytes_sent += prtd->pcm_count;
                }
@@ -560,6 +572,9 @@ static int q6asm_dai_compr_open(struct snd_soc_component *component,
        if (!prtd)
                return -ENOMEM;
 
+       /* DSP expects stream id from 1 */
+       prtd->stream_id = 1;
+
        prtd->cstream = stream;
        prtd->audio_client = q6asm_audio_client_alloc(dev,
                                        (q6asm_cb)compress_event_handler,
@@ -607,7 +622,8 @@ static int q6asm_dai_compr_free(struct snd_soc_component *component,
 
        if (prtd->audio_client) {
                if (prtd->state)
-                       q6asm_cmd(prtd->audio_client, CMD_CLOSE);
+                       q6asm_cmd(prtd->audio_client, prtd->stream_id,
+                                 CMD_CLOSE);
 
                snd_dma_free_pages(&prtd->dma_buffer);
                q6asm_unmap_memory_regions(stream->direction,
@@ -662,8 +678,9 @@ static int q6asm_dai_compr_set_params(struct snd_soc_component *component,
        prtd->pcm_size = runtime->fragments * runtime->fragment_size;
        prtd->bits_per_sample = 16;
        if (dir == SND_COMPRESS_PLAYBACK) {
-               ret = q6asm_open_write(prtd->audio_client, params->codec.id,
-                               params->codec.profile, prtd->bits_per_sample);
+               ret = q6asm_open_write(prtd->audio_client, prtd->stream_id,
+                                      params->codec.id, params->codec.profile,
+                                      prtd->bits_per_sample);
 
                if (ret < 0) {
                        dev_err(dev, "q6asm_open_write failed\n");
@@ -697,6 +714,7 @@ static int q6asm_dai_compr_set_params(struct snd_soc_component *component,
                flac_cfg.min_frame_size = flac->min_frame_size;
 
                ret = q6asm_stream_media_format_block_flac(prtd->audio_client,
+                                                          prtd->stream_id,
                                                           &flac_cfg);
                if (ret < 0) {
                        dev_err(dev, "FLAC CMD Format block failed:%d\n", ret);
@@ -756,10 +774,12 @@ static int q6asm_dai_compr_set_params(struct snd_soc_component *component,
 
                if (wma_v9)
                        ret = q6asm_stream_media_format_block_wma_v9(
-                                       prtd->audio_client, &wma_cfg);
+                                       prtd->audio_client, prtd->stream_id,
+                                       &wma_cfg);
                else
                        ret = q6asm_stream_media_format_block_wma_v10(
-                                       prtd->audio_client, &wma_cfg);
+                                       prtd->audio_client, prtd->stream_id,
+                                       &wma_cfg);
                if (ret < 0) {
                        dev_err(dev, "WMA9 CMD failed:%d\n", ret);
                        return -EIO;
@@ -792,6 +812,7 @@ static int q6asm_dai_compr_set_params(struct snd_soc_component *component,
                        break;
                }
                ret = q6asm_stream_media_format_block_alac(prtd->audio_client,
+                                                          prtd->stream_id,
                                                           &alac_cfg);
                if (ret < 0) {
                        dev_err(dev, "ALAC CMD Format block failed:%d\n", ret);
@@ -816,6 +837,7 @@ static int q6asm_dai_compr_set_params(struct snd_soc_component *component,
                ape_cfg.seek_table_present = ape->seek_table_present;
 
                ret = q6asm_stream_media_format_block_ape(prtd->audio_client,
+                                                         prtd->stream_id,
                                                          &ape_cfg);
                if (ret < 0) {
                        dev_err(dev, "APE CMD Format block failed:%d\n", ret);
@@ -852,15 +874,18 @@ static int q6asm_dai_compr_trigger(struct snd_soc_component *component,
        case SNDRV_PCM_TRIGGER_START:
        case SNDRV_PCM_TRIGGER_RESUME:
        case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
-               ret = q6asm_run_nowait(prtd->audio_client, 0, 0, 0);
+               ret = q6asm_run_nowait(prtd->audio_client, prtd->stream_id,
+                                      0, 0, 0);
                break;
        case SNDRV_PCM_TRIGGER_STOP:
                prtd->state = Q6ASM_STREAM_STOPPED;
-               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
+               ret = q6asm_cmd_nowait(prtd->audio_client, prtd->stream_id,
+                                      CMD_EOS);
                break;
        case SNDRV_PCM_TRIGGER_SUSPEND:
        case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
-               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
+               ret = q6asm_cmd_nowait(prtd->audio_client, prtd->stream_id,
+                                      CMD_PAUSE);
                break;
        default:
                ret = -EINVAL;

diff --git a/sound/soc/qcom/qdsp6/q6asm.c b/sound/soc/qcom/qdsp6/q6asm.c
index b543d77..97f448b 100644 (file)
--- a/sound/soc/qcom/qdsp6/q6asm.c
+++ b/sound/soc/qcom/qdsp6/q6asm.c
@@ -270,7 +270,6 @@ struct audio_client {
        wait_queue_head_t cmd_wait;
        struct aprv2_ibasic_rsp_result_t result;
        int perf_mode;
-       int stream_id;
        struct q6asm *q6asm;
        struct device *dev;
 };
@@ -862,8 +861,6 @@ struct audio_client *q6asm_audio_client_alloc(struct device *dev, q6asm_cb cb,
        ac->priv = priv;
        ac->io_mode = ASM_SYNC_IO_MODE;
        ac->perf_mode = perf_mode;
-       /* DSP expects stream id from 1 */
-       ac->stream_id = 1;
        ac->adev = a->adev;
        kref_init(&ac->refcount);
 
@@ -919,8 +916,9 @@ err:
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_open_write(struct audio_client *ac, uint32_t format,
-                    u32 codec_profile, uint16_t bits_per_sample)
+int q6asm_open_write(struct audio_client *ac, uint32_t stream_id,
+                    uint32_t format, u32 codec_profile,
+                    uint16_t bits_per_sample)
 {
        struct asm_stream_cmd_open_write_v3 *open;
        struct apr_pkt *pkt;
@@ -935,7 +933,7 @@ int q6asm_open_write(struct audio_client *ac, uint32_t format,
 
        pkt = p;
        open = p + APR_HDR_SIZE;
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_WRITE_V3;
        open->mode_flags = 0x00;
@@ -998,8 +996,9 @@ err:
 }
 EXPORT_SYMBOL_GPL(q6asm_open_write);
 
-static int __q6asm_run(struct audio_client *ac, uint32_t flags,
-             uint32_t msw_ts, uint32_t lsw_ts, bool wait)
+static int __q6asm_run(struct audio_client *ac, uint32_t stream_id,
+                      uint32_t flags, uint32_t msw_ts, uint32_t lsw_ts,
+                      bool wait)
 {
        struct asm_session_cmd_run_v2 *run;
        struct apr_pkt *pkt;
@@ -1014,7 +1013,7 @@ static int __q6asm_run(struct audio_client *ac, uint32_t flags,
        pkt = p;
        run = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_SESSION_CMD_RUN_V2;
        run->flags = flags;
@@ -1042,10 +1041,10 @@ static int __q6asm_run(struct audio_client *ac, uint32_t flags,
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_run(struct audio_client *ac, uint32_t flags,
+int q6asm_run(struct audio_client *ac, uint32_t stream_id, uint32_t flags,
              uint32_t msw_ts, uint32_t lsw_ts)
 {
-       return __q6asm_run(ac, flags, msw_ts, lsw_ts, true);
+       return __q6asm_run(ac, stream_id, flags, msw_ts, lsw_ts, true);
 }
 EXPORT_SYMBOL_GPL(q6asm_run);
 
@@ -1053,16 +1052,17 @@ EXPORT_SYMBOL_GPL(q6asm_run);
  * q6asm_run_nowait() - start the audio client withou blocking
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @flags: flags associated with write
  * @msw_ts: timestamp msw
  * @lsw_ts: timestamp lsw
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_run_nowait(struct audio_client *ac, uint32_t flags,
-             uint32_t msw_ts, uint32_t lsw_ts)
+int q6asm_run_nowait(struct audio_client *ac, uint32_t stream_id,
+                    uint32_t flags, uint32_t msw_ts, uint32_t lsw_ts)
 {
-       return __q6asm_run(ac, flags, msw_ts, lsw_ts, false);
+       return __q6asm_run(ac, stream_id, flags, msw_ts, lsw_ts, false);
 }
 EXPORT_SYMBOL_GPL(q6asm_run_nowait);
 
@@ -1070,6 +1070,7 @@ EXPORT_SYMBOL_GPL(q6asm_run_nowait);
  * q6asm_media_format_block_multi_ch_pcm() - setup pcm configuration
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @rate: audio sample rate
  * @channels: number of audio channels.
  * @channel_map: channel map pointer
@@ -1078,6 +1079,7 @@ EXPORT_SYMBOL_GPL(q6asm_run_nowait);
  * Return: Will be an negative value on error or zero on success
  */
 int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac,
+                                         uint32_t stream_id,
                                          uint32_t rate, uint32_t channels,
                                          u8 channel_map[PCM_MAX_NUM_CHANNEL],
                                          uint16_t bits_per_sample)
@@ -1096,7 +1098,7 @@ int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1125,8 +1127,8 @@ err:
 }
 EXPORT_SYMBOL_GPL(q6asm_media_format_block_multi_ch_pcm);
 
-
 int q6asm_stream_media_format_block_flac(struct audio_client *ac,
+                                        uint32_t stream_id,
                                         struct q6asm_flac_cfg *cfg)
 {
        struct asm_flac_fmt_blk_v2 *fmt;
@@ -1142,7 +1144,7 @@ int q6asm_stream_media_format_block_flac(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1163,6 +1165,7 @@ int q6asm_stream_media_format_block_flac(struct audio_client *ac,
 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_flac);
 
 int q6asm_stream_media_format_block_wma_v9(struct audio_client *ac,
+                                          uint32_t stream_id,
                                           struct q6asm_wma_cfg *cfg)
 {
        struct asm_wmastdv9_fmt_blk_v2 *fmt;
@@ -1178,7 +1181,7 @@ int q6asm_stream_media_format_block_wma_v9(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1200,6 +1203,7 @@ int q6asm_stream_media_format_block_wma_v9(struct audio_client *ac,
 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_wma_v9);
 
 int q6asm_stream_media_format_block_wma_v10(struct audio_client *ac,
+                                           uint32_t stream_id,
                                            struct q6asm_wma_cfg *cfg)
 {
        struct asm_wmaprov10_fmt_blk_v2 *fmt;
@@ -1215,7 +1219,7 @@ int q6asm_stream_media_format_block_wma_v10(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1238,6 +1242,7 @@ int q6asm_stream_media_format_block_wma_v10(struct audio_client *ac,
 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_wma_v10);
 
 int q6asm_stream_media_format_block_alac(struct audio_client *ac,
+                                        uint32_t stream_id,
                                         struct q6asm_alac_cfg *cfg)
 {
        struct asm_alac_fmt_blk_v2 *fmt;
@@ -1253,7 +1258,7 @@ int q6asm_stream_media_format_block_alac(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1279,6 +1284,7 @@ int q6asm_stream_media_format_block_alac(struct audio_client *ac,
 EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_alac);
 
 int q6asm_stream_media_format_block_ape(struct audio_client *ac,
+                                       uint32_t stream_id,
                                        struct q6asm_ape_cfg *cfg)
 {
        struct asm_ape_fmt_blk_v2 *fmt;
@@ -1294,7 +1300,7 @@ int q6asm_stream_media_format_block_ape(struct audio_client *ac,
        pkt = p;
        fmt = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_DATA_CMD_MEDIA_FMT_UPDATE_V2;
        fmt->fmt_blk.fmt_blk_size = sizeof(*fmt) - sizeof(fmt->fmt_blk);
@@ -1321,6 +1327,7 @@ EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_ape);
  * q6asm_enc_cfg_blk_pcm_format_support() - setup pcm configuration for capture
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @rate: audio sample rate
  * @channels: number of audio channels.
  * @bits_per_sample: bits per sample
@@ -1328,7 +1335,9 @@ EXPORT_SYMBOL_GPL(q6asm_stream_media_format_block_ape);
  * Return: Will be an negative value on error or zero on success
  */
 int q6asm_enc_cfg_blk_pcm_format_support(struct audio_client *ac,
-               uint32_t rate, uint32_t channels, uint16_t bits_per_sample)
+                                        uint32_t stream_id, uint32_t rate,
+                                        uint32_t channels,
+                                        uint16_t bits_per_sample)
 {
        struct asm_multi_channel_pcm_enc_cfg_v2  *enc_cfg;
        struct apr_pkt *pkt;
@@ -1344,7 +1353,7 @@ int q6asm_enc_cfg_blk_pcm_format_support(struct audio_client *ac,
 
        pkt = p;
        enc_cfg = p + APR_HDR_SIZE;
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, true, stream_id);
 
        pkt->hdr.opcode = ASM_STREAM_CMD_SET_ENCDEC_PARAM;
        enc_cfg->encdec.param_id = ASM_PARAM_ID_ENCDEC_ENC_CFG_BLK_V2;
@@ -1376,10 +1385,11 @@ EXPORT_SYMBOL_GPL(q6asm_enc_cfg_blk_pcm_format_support);
  * q6asm_read() - read data of period size from audio client
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_read(struct audio_client *ac)
+int q6asm_read(struct audio_client *ac, uint32_t stream_id)
 {
        struct asm_data_cmd_read_v2 *read;
        struct audio_port_data *port;
@@ -1400,7 +1410,7 @@ int q6asm_read(struct audio_client *ac)
 
        spin_lock_irqsave(&ac->lock, flags);
        port = &ac->port[SNDRV_PCM_STREAM_CAPTURE];
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, stream_id);
        ab = &port->buf[port->dsp_buf];
        pkt->hdr.opcode = ASM_DATA_CMD_READ_V2;
        read->buf_addr_lsw = lower_32_bits(ab->phys);
@@ -1428,7 +1438,7 @@ int q6asm_read(struct audio_client *ac)
 }
 EXPORT_SYMBOL_GPL(q6asm_read);
 
-static int __q6asm_open_read(struct audio_client *ac,
+static int __q6asm_open_read(struct audio_client *ac, uint32_t stream_id,
                uint32_t format, uint16_t bits_per_sample)
 {
        struct asm_stream_cmd_open_read_v3 *open;
@@ -1444,7 +1454,7 @@ static int __q6asm_open_read(struct audio_client *ac,
        pkt = p;
        open = p + APR_HDR_SIZE;
 
-       q6asm_add_hdr(ac, &pkt->hdr,  pkt_size, true, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr,  pkt_size, true, stream_id);
        pkt->hdr.opcode = ASM_STREAM_CMD_OPEN_READ_V3;
        /* Stream prio : High, provide meta info with encoded frames */
        open->src_endpointype = ASM_END_POINT_DEVICE_MATRIX;
@@ -1475,15 +1485,16 @@ static int __q6asm_open_read(struct audio_client *ac,
  * q6asm_open_read() - Open audio client for reading
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @format: audio sample format
  * @bits_per_sample: bits per sample
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_open_read(struct audio_client *ac, uint32_t format,
-                       uint16_t bits_per_sample)
+int q6asm_open_read(struct audio_client *ac, uint32_t stream_id,
+                   uint32_t format, uint16_t bits_per_sample)
 {
-       return __q6asm_open_read(ac, format, bits_per_sample);
+       return __q6asm_open_read(ac, stream_id, format, bits_per_sample);
 }
 EXPORT_SYMBOL_GPL(q6asm_open_read);
 
@@ -1491,6 +1502,7 @@ EXPORT_SYMBOL_GPL(q6asm_open_read);
  * q6asm_write_async() - non blocking write
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @len: length in bytes
  * @msw_ts: timestamp msw
  * @lsw_ts: timestamp lsw
@@ -1498,8 +1510,8 @@ EXPORT_SYMBOL_GPL(q6asm_open_read);
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_write_async(struct audio_client *ac, uint32_t len, uint32_t msw_ts,
-                      uint32_t lsw_ts, uint32_t wflags)
+int q6asm_write_async(struct audio_client *ac, uint32_t stream_id, uint32_t len,
+                     uint32_t msw_ts, uint32_t lsw_ts, uint32_t wflags)
 {
        struct asm_data_cmd_write_v2 *write;
        struct audio_port_data *port;
@@ -1520,7 +1532,7 @@ int q6asm_write_async(struct audio_client *ac, uint32_t len, uint32_t msw_ts,
 
        spin_lock_irqsave(&ac->lock, flags);
        port = &ac->port[SNDRV_PCM_STREAM_PLAYBACK];
-       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, ac->stream_id);
+       q6asm_add_hdr(ac, &pkt->hdr, pkt_size, false, stream_id);
 
        ab = &port->buf[port->dsp_buf];
        pkt->hdr.token = port->dsp_buf;
@@ -1567,9 +1579,9 @@ static void q6asm_reset_buf_state(struct audio_client *ac)
        spin_unlock_irqrestore(&ac->lock, flags);
 }
 
-static int __q6asm_cmd(struct audio_client *ac, int cmd, bool wait)
+static int __q6asm_cmd(struct audio_client *ac, uint32_t stream_id, int cmd,
+                      bool wait)
 {
-       int stream_id = ac->stream_id;
        struct apr_pkt pkt;
        int rc;
 
@@ -1616,13 +1628,14 @@ static int __q6asm_cmd(struct audio_client *ac, int cmd, bool wait)
  * q6asm_cmd() - run cmd on audio client
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @cmd: command to run on audio client.
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_cmd(struct audio_client *ac, int cmd)
+int q6asm_cmd(struct audio_client *ac, uint32_t stream_id, int cmd)
 {
-       return __q6asm_cmd(ac, cmd, true);
+       return __q6asm_cmd(ac, stream_id, cmd, true);
 }
 EXPORT_SYMBOL_GPL(q6asm_cmd);
 
@@ -1630,13 +1643,14 @@ EXPORT_SYMBOL_GPL(q6asm_cmd);
  * q6asm_cmd_nowait() - non blocking, run cmd on audio client
  *
  * @ac: audio client pointer
+ * @stream_id: stream id
  * @cmd: command to run on audio client.
  *
  * Return: Will be an negative value on error or zero on success
  */
-int q6asm_cmd_nowait(struct audio_client *ac, int cmd)
+int q6asm_cmd_nowait(struct audio_client *ac, uint32_t stream_id, int cmd)
 {
-       return __q6asm_cmd(ac, cmd, false);
+       return __q6asm_cmd(ac, stream_id, cmd, false);
 }
 EXPORT_SYMBOL_GPL(q6asm_cmd_nowait);
 

diff --git a/sound/soc/qcom/qdsp6/q6asm.h b/sound/soc/qcom/qdsp6/q6asm.h
index 38a207d..ceece12 100644 (file)
--- a/sound/soc/qcom/qdsp6/q6asm.h
+++ b/sound/soc/qcom/qdsp6/q6asm.h
@@ -93,37 +93,47 @@ struct audio_client *q6asm_audio_client_alloc(struct device *dev,
                                              q6asm_cb cb, void *priv,
                                              int session_id, int perf_mode);
 void q6asm_audio_client_free(struct audio_client *ac);
-int q6asm_write_async(struct audio_client *ac, uint32_t len, uint32_t msw_ts,
-                      uint32_t lsw_ts, uint32_t flags);
-int q6asm_open_write(struct audio_client *ac, uint32_t format,
-                    u32 codec_profile, uint16_t bits_per_sample);
-
-int q6asm_open_read(struct audio_client *ac, uint32_t format,
+int q6asm_write_async(struct audio_client *ac, uint32_t stream_id, uint32_t len,
+                     uint32_t msw_ts, uint32_t lsw_ts, uint32_t flags);
+int q6asm_open_write(struct audio_client *ac, uint32_t stream_id,
+                    uint32_t format, u32 codec_profile,
                     uint16_t bits_per_sample);
+
+int q6asm_open_read(struct audio_client *ac, uint32_t stream_id,
+                   uint32_t format, uint16_t bits_per_sample);
 int q6asm_enc_cfg_blk_pcm_format_support(struct audio_client *ac,
-               uint32_t rate, uint32_t channels, uint16_t bits_per_sample);
-int q6asm_read(struct audio_client *ac);
+                                        uint32_t stream_id, uint32_t rate,
+                                        uint32_t channels,
+                                        uint16_t bits_per_sample);
+
+int q6asm_read(struct audio_client *ac, uint32_t stream_id);
 
 int q6asm_media_format_block_multi_ch_pcm(struct audio_client *ac,
+                                         uint32_t stream_id,
                                          uint32_t rate, uint32_t channels,
                                          u8 channel_map[PCM_MAX_NUM_CHANNEL],
                                          uint16_t bits_per_sample);
 int q6asm_stream_media_format_block_flac(struct audio_client *ac,
+                                        uint32_t stream_id,
                                         struct q6asm_flac_cfg *cfg);
 int q6asm_stream_media_format_block_wma_v9(struct audio_client *ac,
+                                          uint32_t stream_id,
                                           struct q6asm_wma_cfg *cfg);
 int q6asm_stream_media_format_block_wma_v10(struct audio_client *ac,
+                                           uint32_t stream_id,
                                            struct q6asm_wma_cfg *cfg);
 int q6asm_stream_media_format_block_alac(struct audio_client *ac,
+                                        uint32_t stream_id,
                                         struct q6asm_alac_cfg *cfg);
 int q6asm_stream_media_format_block_ape(struct audio_client *ac,
+                                       uint32_t stream_id,
                                        struct q6asm_ape_cfg *cfg);
-int q6asm_run(struct audio_client *ac, uint32_t flags, uint32_t msw_ts,
-             uint32_t lsw_ts);
-int q6asm_run_nowait(struct audio_client *ac, uint32_t flags, uint32_t msw_ts,
-                    uint32_t lsw_ts);
-int q6asm_cmd(struct audio_client *ac, int cmd);
-int q6asm_cmd_nowait(struct audio_client *ac, int cmd);
+int q6asm_run(struct audio_client *ac, uint32_t stream_id, uint32_t flags,
+             uint32_t msw_ts, uint32_t lsw_ts);
+int q6asm_run_nowait(struct audio_client *ac, uint32_t stream_id,
+                    uint32_t flags, uint32_t msw_ts, uint32_t lsw_ts);
+int q6asm_cmd(struct audio_client *ac, uint32_t stream_id,  int cmd);
+int q6asm_cmd_nowait(struct audio_client *ac, uint32_t stream_id,  int cmd);
 int q6asm_get_session_id(struct audio_client *ac);
 int q6asm_map_memory_regions(unsigned int dir,
                             struct audio_client *ac,