ASoC: q6asm-dai: add gapless support

Add support to gapless playback by implementing metadata,
next_track, drain and partial drain support.

Gapless on Q6ASM is implemented by opening 2 streams in a single
q6asm stream and toggling them on next track.

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-10-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 e463d7c..68da769 100644 (file)
--- a/sound/soc/qcom/qdsp6/q6asm-dai.c
+++ b/sound/soc/qcom/qdsp6/q6asm-dai.c
@@ -64,11 +64,14 @@ struct q6asm_dai_rtd {
        uint16_t bits_per_sample;
        uint16_t source; /* Encoding source bit mask */
        struct audio_client *audio_client;
+       uint32_t next_track_stream_id;
+       bool next_track;
        uint32_t stream_id;
        uint16_t session_id;
        enum stream_state state;
        uint32_t initial_samples_drop;
        uint32_t trailing_samples_drop;
+       bool notify_on_drain;
 };
 
 struct q6asm_dai_data {
@@ -507,13 +510,19 @@ static void compress_event_handler(uint32_t opcode, uint32_t token,
        struct q6asm_dai_rtd *prtd = priv;
        struct snd_compr_stream *substream = prtd->cstream;
        unsigned long flags;
+       u32 wflags = 0;
        uint64_t avail;
-       uint32_t bytes_written;
+       uint32_t bytes_written, bytes_to_write;
+       bool is_last_buffer = false;
 
        switch (opcode) {
        case ASM_CLIENT_EVENT_CMD_RUN_DONE:
                spin_lock_irqsave(&prtd->lock, flags);
                if (!prtd->bytes_sent) {
+                       q6asm_stream_remove_initial_silence(prtd->audio_client,
+                                                   prtd->stream_id,
+                                                   prtd->initial_samples_drop);
+
                        q6asm_write_async(prtd->audio_client, prtd->stream_id,
                                          prtd->pcm_count, 0, 0, 0);
                        prtd->bytes_sent += prtd->pcm_count;
@@ -523,7 +532,30 @@ static void compress_event_handler(uint32_t opcode, uint32_t token,
                break;
 
        case ASM_CLIENT_EVENT_CMD_EOS_DONE:
-               prtd->state = Q6ASM_STREAM_STOPPED;
+               spin_lock_irqsave(&prtd->lock, flags);
+               if (prtd->notify_on_drain) {
+                       if (substream->partial_drain) {
+                               /*
+                                * Close old stream and make it stale, switch
+                                * the active stream now!
+                                */
+                               q6asm_cmd_nowait(prtd->audio_client,
+                                                prtd->stream_id,
+                                                CMD_CLOSE);
+                               /*
+                                * vaild stream ids start from 1, So we are
+                                * toggling this between 1 and 2.
+                                */
+                               prtd->stream_id = (prtd->stream_id == 1 ? 2 : 1);
+                       }
+
+                       snd_compr_drain_notify(prtd->cstream);
+                       prtd->notify_on_drain = false;
+
+               } else {
+                       prtd->state = Q6ASM_STREAM_STOPPED;
+               }
+               spin_unlock_irqrestore(&prtd->lock, flags);
                break;
 
        case ASM_CLIENT_EVENT_DATA_WRITE_DONE:
@@ -539,13 +571,32 @@ static void compress_event_handler(uint32_t opcode, uint32_t token,
                }
 
                avail = prtd->bytes_received - prtd->bytes_sent;
+               if (avail > prtd->pcm_count) {
+                       bytes_to_write = prtd->pcm_count;
+               } else {
+                       if (substream->partial_drain || prtd->notify_on_drain)
+                               is_last_buffer = true;
+                       bytes_to_write = avail;
+               }
+
+               if (bytes_to_write) {
+                       if (substream->partial_drain && is_last_buffer) {
+                               wflags |= ASM_LAST_BUFFER_FLAG;
+                               q6asm_stream_remove_trailing_silence(prtd->audio_client,
+                                                    prtd->stream_id,
+                                                    prtd->trailing_samples_drop);
+                       }
 
-               if (avail >= prtd->pcm_count) {
                        q6asm_write_async(prtd->audio_client, prtd->stream_id,
-                                          prtd->pcm_count, 0, 0, 0);
-                       prtd->bytes_sent += prtd->pcm_count;
+                                         bytes_to_write, 0, 0, wflags);
+
+                       prtd->bytes_sent += bytes_to_write;
                }
 
+               if (prtd->notify_on_drain && is_last_buffer)
+                       q6asm_cmd_nowait(prtd->audio_client,
+                                        prtd->stream_id, CMD_EOS);
+
                spin_unlock_irqrestore(&prtd->lock, flags);
                break;
 
@@ -625,9 +676,15 @@ static int q6asm_dai_compr_free(struct snd_soc_component *component,
        struct snd_soc_pcm_runtime *rtd = stream->private_data;
 
        if (prtd->audio_client) {
-               if (prtd->state)
+               if (prtd->state) {
                        q6asm_cmd(prtd->audio_client, prtd->stream_id,
                                  CMD_CLOSE);
+                       if (prtd->next_track_stream_id) {
+                               q6asm_cmd(prtd->audio_client,
+                                         prtd->next_track_stream_id,
+                                         CMD_CLOSE);
+                       }
+               }
 
                snd_dma_free_pages(&prtd->dma_buffer);
                q6asm_unmap_memory_regions(stream->direction,
@@ -902,6 +959,32 @@ static int q6asm_dai_compr_set_metadata(struct snd_soc_component *component,
                break;
        case SNDRV_COMPRESS_ENCODER_DELAY:
                prtd->initial_samples_drop = metadata->value[0];
+               if (prtd->next_track_stream_id) {
+                       ret = q6asm_open_write(prtd->audio_client,
+                                              prtd->next_track_stream_id,
+                                              prtd->codec.id,
+                                              prtd->codec.profile,
+                                              prtd->bits_per_sample,
+                                      true);
+                       if (ret < 0) {
+                               dev_err(component->dev, "q6asm_open_write failed\n");
+                               return ret;
+                       }
+                       ret = __q6asm_dai_compr_set_codec_params(component, stream,
+                                                                &prtd->codec,
+                                                                prtd->next_track_stream_id);
+                       if (ret < 0) {
+                               dev_err(component->dev, "q6asm_open_write failed\n");
+                               return ret;
+                       }
+
+                       ret = q6asm_stream_remove_initial_silence(prtd->audio_client,
+                                                   prtd->next_track_stream_id,
+                                                   prtd->initial_samples_drop);
+                       prtd->next_track_stream_id = 0;
+
+               }
+
                break;
        default:
                ret = -EINVAL;
@@ -935,6 +1018,14 @@ static int q6asm_dai_compr_trigger(struct snd_soc_component *component,
                ret = q6asm_cmd_nowait(prtd->audio_client, prtd->stream_id,
                                       CMD_PAUSE);
                break;
+       case SND_COMPR_TRIGGER_NEXT_TRACK:
+               prtd->next_track = true;
+               prtd->next_track_stream_id = (prtd->stream_id == 1 ? 2 : 1);
+               break;
+       case SND_COMPR_TRIGGER_DRAIN:
+       case SND_COMPR_TRIGGER_PARTIAL_DRAIN:
+               prtd->notify_on_drain = true;
+               break;
        default:
                ret = -EINVAL;
                break;

diff --git a/sound/soc/qcom/qdsp6/q6asm.h b/sound/soc/qcom/qdsp6/q6asm.h
index f20e144..82e584a 100644 (file)
--- a/sound/soc/qcom/qdsp6/q6asm.h
+++ b/sound/soc/qcom/qdsp6/q6asm.h
@@ -33,6 +33,7 @@ enum {
 
 #define MAX_SESSIONS   8
 #define FORMAT_LINEAR_PCM   0x0000
+#define ASM_LAST_BUFFER_FLAG           BIT(30)
 
 struct q6asm_flac_cfg {
         u32 sample_rate;