Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Unverified Commit 22930c79 authored by Srinivas Kandagatla's avatar Srinivas Kandagatla Committed by Mark Brown
Browse files

ASoC: qdsp6: q6asm-dai: Add support to compress offload 



This patch adds MP3 playback support in q6asm dais, adding other codec
support should be pretty trivial.

Signed-off-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Acked-by: default avatarVinod Koul <vkoul@kernel.org>
Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent f2e6c6aa

sound/soc/qcom/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -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

sound/soc/qcom/qdsp6/q6asm-dai.c

+371 −1
Original line number Diff line number Diff line
@@ -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>
@@ -30,6 +32,15 @@ 
#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));