ASoC: qdsp6: q6asm-dai: Add support to compress offload
authorSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Thu, 15 Nov 2018 18:13:24 +0000 (18:13 +0000)
committerMark Brown <broonie@kernel.org>
Fri, 14 Dec 2018 12:43:59 +0000 (12:43 +0000)
This patch adds MP3 playback support in q6asm dais, adding other codec
support should be pretty trivial.

Signed-off-by: Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
Acked-by: Vinod Koul <vkoul@kernel.org>
Signed-off-by: Mark Brown <broonie@kernel.org>
sound/soc/qcom/Kconfig
sound/soc/qcom/qdsp6/q6asm-dai.c

index 1b9fc066579241a6e0d9c16caaf72416ecc19ddf..804ae0d930589e80448d0c3ec57a64a348a24230 100644 (file)
@@ -66,6 +66,7 @@ config SND_SOC_QDSP6_ASM
        tristate
 
 config SND_SOC_QDSP6_ASM_DAI
+       select SND_SOC_COMPRESS
        tristate
 
 config SND_SOC_QDSP6
index 86115de5c1b2a1bd16a42a13305b4c62d6feee27..5b986b74dd36f96d0a4a37bc8714f0b741c39486 100644 (file)
@@ -10,6 +10,8 @@
 #include <sound/soc.h>
 #include <sound/soc-dapm.h>
 #include <sound/pcm.h>
+#include <linux/spinlock.h>
+#include <sound/compress_driver.h>
 #include <asm/dma.h>
 #include <linux/dma-mapping.h>
 #include <linux/of_device.h>
 #define CAPTURE_MIN_PERIOD_SIZE     320
 #define SID_MASK_DEFAULT       0xF
 
+/* Default values used if user space does not set */
+#define COMPR_PLAYBACK_MIN_FRAGMENT_SIZE (8 * 1024)
+#define COMPR_PLAYBACK_MAX_FRAGMENT_SIZE (128 * 1024)
+#define COMPR_PLAYBACK_MIN_NUM_FRAGMENTS (4)
+#define COMPR_PLAYBACK_MAX_NUM_FRAGMENTS (16 * 4)
+#define Q6ASM_DAI_TX_RX        0
+#define Q6ASM_DAI_TX   1
+#define Q6ASM_DAI_RX   2
+
 enum stream_state {
        Q6ASM_STREAM_IDLE = 0,
        Q6ASM_STREAM_STOPPED,
@@ -38,11 +49,18 @@ enum stream_state {
 
 struct q6asm_dai_rtd {
        struct snd_pcm_substream *substream;
+       struct snd_compr_stream *cstream;
+       struct snd_compr_params codec_param;
+       struct snd_dma_buffer dma_buffer;
+       spinlock_t lock;
        phys_addr_t phys;
        unsigned int pcm_size;
        unsigned int pcm_count;
        unsigned int pcm_irq_pos;       /* IRQ position */
        unsigned int periods;
+       unsigned int bytes_sent;
+       unsigned int bytes_received;
+       unsigned int copied_total;
        uint16_t bits_per_sample;
        uint16_t source; /* Encoding source bit mask */
        struct audio_client *audio_client;
@@ -137,6 +155,21 @@ static struct snd_pcm_hw_constraint_list constraints_sample_rates = {
        .mask = 0,
 };
 
+static const struct snd_compr_codec_caps q6asm_compr_caps = {
+       .num_descriptors = 1,
+       .descriptor[0].max_ch = 2,
+       .descriptor[0].sample_rates = { 8000, 11025, 12000, 16000, 22050,
+                                       24000, 32000, 44100, 48000, 88200,
+                                       96000, 176400, 192000 },
+       .descriptor[0].num_sample_rates = 13,
+       .descriptor[0].bit_rate[0] = 320,
+       .descriptor[0].bit_rate[1] = 128,
+       .descriptor[0].num_bitrates = 2,
+       .descriptor[0].profiles = 0,
+       .descriptor[0].modes = SND_AUDIOCHANMODE_MP3_STEREO,
+       .descriptor[0].formats = 0,
+};
+
 static void event_handler(uint32_t opcode, uint32_t token,
                          uint32_t *payload, void *priv)
 {
@@ -460,6 +493,306 @@ static struct snd_pcm_ops q6asm_dai_ops = {
        .mmap           = q6asm_dai_mmap,
 };
 
+static void compress_event_handler(uint32_t opcode, uint32_t token,
+                                  uint32_t *payload, void *priv)
+{
+       struct q6asm_dai_rtd *prtd = priv;
+       struct snd_compr_stream *substream = prtd->cstream;
+       unsigned long flags;
+       uint64_t avail;
+
+       switch (opcode) {
+       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);
+                       prtd->bytes_sent += prtd->pcm_count;
+               }
+
+               spin_unlock_irqrestore(&prtd->lock, flags);
+               break;
+
+       case ASM_CLIENT_EVENT_CMD_EOS_DONE:
+               prtd->state = Q6ASM_STREAM_STOPPED;
+               break;
+
+       case ASM_CLIENT_EVENT_DATA_WRITE_DONE:
+               spin_lock_irqsave(&prtd->lock, flags);
+
+               prtd->copied_total += prtd->pcm_count;
+               snd_compr_fragment_elapsed(substream);
+
+               if (prtd->state != Q6ASM_STREAM_RUNNING) {
+                       spin_unlock_irqrestore(&prtd->lock, flags);
+                       break;
+               }
+
+               avail = prtd->bytes_received - prtd->bytes_sent;
+
+               if (avail >= prtd->pcm_count) {
+                       q6asm_write_async(prtd->audio_client,
+                                          prtd->pcm_count, 0, 0, NO_TIMESTAMP);
+                       prtd->bytes_sent += prtd->pcm_count;
+               }
+
+               spin_unlock_irqrestore(&prtd->lock, flags);
+               break;
+
+       default:
+               break;
+       }
+}
+
+static int q6asm_dai_compr_open(struct snd_compr_stream *stream)
+{
+       struct snd_soc_pcm_runtime *rtd = stream->private_data;
+       struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
+       struct q6asm_dai_data *pdata;
+       struct device *dev = c->dev;
+       struct q6asm_dai_rtd *prtd;
+       int stream_id, size, ret;
+
+       stream_id = cpu_dai->driver->id;
+       pdata = snd_soc_component_get_drvdata(c);
+       if (!pdata) {
+               dev_err(dev, "Drv data not found ..\n");
+               return -EINVAL;
+       }
+
+       prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
+       if (!prtd)
+               return -ENOMEM;
+
+       prtd->cstream = stream;
+       prtd->audio_client = q6asm_audio_client_alloc(dev,
+                                       (q6asm_cb)compress_event_handler,
+                                       prtd, stream_id, LEGACY_PCM_MODE);
+       if (!prtd->audio_client) {
+               dev_err(dev, "Could not allocate memory\n");
+               kfree(prtd);
+               return -ENOMEM;
+       }
+
+       size = COMPR_PLAYBACK_MAX_FRAGMENT_SIZE *
+                       COMPR_PLAYBACK_MAX_NUM_FRAGMENTS;
+       ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dev, size,
+                                 &prtd->dma_buffer);
+       if (ret) {
+               dev_err(dev, "Cannot allocate buffer(s)\n");
+               return ret;
+       }
+
+       if (pdata->sid < 0)
+               prtd->phys = prtd->dma_buffer.addr;
+       else
+               prtd->phys = prtd->dma_buffer.addr | (pdata->sid << 32);
+
+       snd_compr_set_runtime_buffer(stream, &prtd->dma_buffer);
+       spin_lock_init(&prtd->lock);
+       runtime->private_data = prtd;
+
+       return 0;
+}
+
+static int q6asm_dai_compr_free(struct snd_compr_stream *stream)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       struct snd_soc_pcm_runtime *rtd = stream->private_data;
+
+       if (prtd->audio_client) {
+               if (prtd->state)
+                       q6asm_cmd(prtd->audio_client, CMD_CLOSE);
+
+               snd_dma_free_pages(&prtd->dma_buffer);
+               q6asm_unmap_memory_regions(stream->direction,
+                                          prtd->audio_client);
+               q6asm_audio_client_free(prtd->audio_client);
+               prtd->audio_client = NULL;
+       }
+       q6routing_stream_close(rtd->dai_link->id, stream->direction);
+       kfree(prtd);
+
+       return 0;
+}
+
+static int q6asm_dai_compr_set_params(struct snd_compr_stream *stream,
+                                     struct snd_compr_params *params)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       struct snd_soc_pcm_runtime *rtd = stream->private_data;
+       struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
+       int dir = stream->direction;
+       struct q6asm_dai_data *pdata;
+       struct device *dev = c->dev;
+       int ret;
+
+       memcpy(&prtd->codec_param, params, sizeof(*params));
+
+       pdata = snd_soc_component_get_drvdata(c);
+       if (!pdata)
+               return -EINVAL;
+
+       if (!prtd || !prtd->audio_client) {
+               dev_err(dev, "private data null or audio client freed\n");
+               return -EINVAL;
+       }
+
+       prtd->periods = runtime->fragments;
+       prtd->pcm_count = runtime->fragment_size;
+       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,
+                                       prtd->bits_per_sample);
+
+               if (ret < 0) {
+                       dev_err(dev, "q6asm_open_write failed\n");
+                       q6asm_audio_client_free(prtd->audio_client);
+                       prtd->audio_client = NULL;
+                       return ret;
+               }
+       }
+
+       prtd->session_id = q6asm_get_session_id(prtd->audio_client);
+       ret = q6routing_stream_open(rtd->dai_link->id, LEGACY_PCM_MODE,
+                             prtd->session_id, dir);
+       if (ret) {
+               dev_err(dev, "Stream reg failed ret:%d\n", ret);
+               return ret;
+       }
+
+       ret = q6asm_map_memory_regions(dir, prtd->audio_client, prtd->phys,
+                                      (prtd->pcm_size / prtd->periods),
+                                      prtd->periods);
+
+       if (ret < 0) {
+               dev_err(dev, "Buffer Mapping failed ret:%d\n", ret);
+               return -ENOMEM;
+       }
+
+       prtd->state = Q6ASM_STREAM_RUNNING;
+
+       return 0;
+}
+
+static int q6asm_dai_compr_trigger(struct snd_compr_stream *stream, int cmd)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       int ret = 0;
+
+       switch (cmd) {
+       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);
+               break;
+       case SNDRV_PCM_TRIGGER_STOP:
+               prtd->state = Q6ASM_STREAM_STOPPED;
+               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_EOS);
+               break;
+       case SNDRV_PCM_TRIGGER_SUSPEND:
+       case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+               ret = q6asm_cmd_nowait(prtd->audio_client, CMD_PAUSE);
+               break;
+       default:
+               ret = -EINVAL;
+               break;
+       }
+
+       return ret;
+}
+
+static int q6asm_dai_compr_pointer(struct snd_compr_stream *stream,
+               struct snd_compr_tstamp *tstamp)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       unsigned long flags;
+
+       spin_lock_irqsave(&prtd->lock, flags);
+
+       tstamp->copied_total = prtd->copied_total;
+       tstamp->byte_offset = prtd->copied_total % prtd->pcm_size;
+
+       spin_unlock_irqrestore(&prtd->lock, flags);
+
+       return 0;
+}
+
+static int q6asm_dai_compr_ack(struct snd_compr_stream *stream,
+                               size_t count)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       unsigned long flags;
+
+       spin_lock_irqsave(&prtd->lock, flags);
+       prtd->bytes_received += count;
+       spin_unlock_irqrestore(&prtd->lock, flags);
+
+       return count;
+}
+
+static int q6asm_dai_compr_mmap(struct snd_compr_stream *stream,
+               struct vm_area_struct *vma)
+{
+       struct snd_compr_runtime *runtime = stream->runtime;
+       struct q6asm_dai_rtd *prtd = runtime->private_data;
+       struct snd_soc_pcm_runtime *rtd = stream->private_data;
+       struct snd_soc_component *c = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
+       struct device *dev = c->dev;
+
+       return dma_mmap_coherent(dev, vma,
+                       prtd->dma_buffer.area, prtd->dma_buffer.addr,
+                       prtd->dma_buffer.bytes);
+}
+
+static int q6asm_dai_compr_get_caps(struct snd_compr_stream *stream,
+                                   struct snd_compr_caps *caps)
+{
+       caps->direction = SND_COMPRESS_PLAYBACK;
+       caps->min_fragment_size = COMPR_PLAYBACK_MIN_FRAGMENT_SIZE;
+       caps->max_fragment_size = COMPR_PLAYBACK_MAX_FRAGMENT_SIZE;
+       caps->min_fragments = COMPR_PLAYBACK_MIN_NUM_FRAGMENTS;
+       caps->max_fragments = COMPR_PLAYBACK_MAX_NUM_FRAGMENTS;
+       caps->num_codecs = 1;
+       caps->codecs[0] = SND_AUDIOCODEC_MP3;
+
+       return 0;
+}
+
+static int q6asm_dai_compr_get_codec_caps(struct snd_compr_stream *stream,
+                                         struct snd_compr_codec_caps *codec)
+{
+       switch (codec->codec) {
+       case SND_AUDIOCODEC_MP3:
+               *codec = q6asm_compr_caps;
+               break;
+       default:
+               break;
+       }
+
+       return 0;
+}
+
+static struct snd_compr_ops q6asm_dai_compr_ops = {
+       .open           = q6asm_dai_compr_open,
+       .free           = q6asm_dai_compr_free,
+       .set_params     = q6asm_dai_compr_set_params,
+       .pointer        = q6asm_dai_compr_pointer,
+       .trigger        = q6asm_dai_compr_trigger,
+       .get_caps       = q6asm_dai_compr_get_caps,
+       .get_codec_caps = q6asm_dai_compr_get_codec_caps,
+       .mmap           = q6asm_dai_compr_mmap,
+       .ack            = q6asm_dai_compr_ack,
+};
+
 static int q6asm_dai_pcm_new(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_pcm_substream *psubstream, *csubstream;
@@ -515,7 +848,7 @@ static const struct snd_soc_component_driver q6asm_fe_dai_component = {
        .ops            = &q6asm_dai_ops,
        .pcm_new        = q6asm_dai_pcm_new,
        .pcm_free       = q6asm_dai_pcm_free,
-
+       .compr_ops      = &q6asm_dai_compr_ops,
 };
 
 static struct snd_soc_dai_driver q6asm_fe_dais[] = {
@@ -529,6 +862,41 @@ static struct snd_soc_dai_driver q6asm_fe_dais[] = {
        Q6ASM_FEDAI_DRIVER(8),
 };
 
+static int of_q6asm_parse_dai_data(struct device *dev,
+                                   struct q6asm_dai_data *pdata)
+{
+       static struct snd_soc_dai_driver *dai_drv;
+       struct snd_soc_pcm_stream empty_stream;
+       struct device_node *node;
+       int ret, id, dir;
+
+       memset(&empty_stream, 0, sizeof(empty_stream));
+
+       for_each_child_of_node(dev->of_node, node) {
+               ret = of_property_read_u32(node, "reg", &id);
+               if (ret || id > MAX_SESSIONS || id < 0) {
+                       dev_err(dev, "valid dai id not found:%d\n", ret);
+                       continue;
+               }
+
+               dai_drv = &q6asm_fe_dais[id];
+
+               ret = of_property_read_u32(node, "direction", &dir);
+               if (ret)
+                       continue;
+
+               if (dir == Q6ASM_DAI_RX)
+                       dai_drv->capture = empty_stream;
+               else if (dir == Q6ASM_DAI_TX)
+                       dai_drv->playback = empty_stream;
+
+               if (of_property_read_bool(node, "is-compress-dai"))
+                       dai_drv->compress_new = snd_soc_new_compress;
+       }
+
+       return 0;
+}
+
 static int q6asm_dai_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
@@ -549,6 +917,8 @@ static int q6asm_dai_probe(struct platform_device *pdev)
 
        dev_set_drvdata(dev, pdata);
 
+       of_q6asm_parse_dai_data(dev, pdata);
+
        return devm_snd_soc_register_component(dev, &q6asm_fe_dai_component,
                                        q6asm_fe_dais,
                                        ARRAY_SIZE(q6asm_fe_dais));