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

Commit 8c575289 authored by Liam Girdwood's avatar Liam Girdwood Committed by Dhananjay Kumar
Browse files

ASoC: compress: Add suport for DPCM into compressed audio 



Allow compressed audio streams to traverse the DAPM graph of DAIs
like PCM streams.

Change-Id: I15f227b73122071dfad106705a943199b679c273
Signed-off-by: default avatarLiam Girdwood <liam.r.girdwood@linux.intel.com>
Git-commit: d314c1c37de41c689dbfcfff736a08c814a0d9ba
Git-repo: https://android.googlesource.com/kernel/msm


Signed-off-by: default avatarDhananjay Kumar <dhakumar@codeaurora.org>
parent 23fd5bff

include/sound/compress_driver.h

+2 −0
Original line number Diff line number Diff line
@@ -32,6 +32,7 @@ 
#include <sound/pcm.h>



struct snd_compr_ops;

struct snd_pcm_substream;



/**

 * struct snd_compr_runtime: runtime stream description
@@ -59,6 +60,7 @@ struct snd_compr_runtime { 
	u64 total_bytes_available;

	u64 total_bytes_transferred;

	wait_queue_head_t sleep;

	struct snd_pcm_substream *fe_substream;

	void *private_data;

};

include/sound/soc.h

+1 −0
Original line number Diff line number Diff line
@@ -1088,6 +1088,7 @@ struct snd_soc_pcm_runtime { 


	/* Dynamic PCM BE runtime data */

	struct snd_soc_dpcm_runtime dpcm[2];

	int fe_compr;



	long pmdown_time;

	unsigned char pop_wait:1;

sound/soc/soc-compress.c

+234 −1
Original line number Diff line number Diff line
@@ -24,6 +24,7 @@ 
#include <sound/compress_driver.h>

#include <sound/soc.h>

#include <sound/initval.h>

#include <sound/soc-dpcm.h>



static int soc_compr_open(struct snd_compr_stream *cstream)

{
@@ -75,6 +76,80 @@ out: 
	return ret;

}



static int soc_compr_open_fe(struct snd_compr_stream *cstream)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_dpcm *dpcm;

	struct snd_soc_dapm_widget_list *list;

	int stream;

	int ret = 0;



	if (cstream->direction == SND_COMPRESS_PLAYBACK)

		stream = SNDRV_PCM_STREAM_PLAYBACK;

	else

		stream = SNDRV_PCM_STREAM_CAPTURE;



	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);



	if (platform->driver->compr_ops && platform->driver->compr_ops->open) {

		ret = platform->driver->compr_ops->open(cstream);

		if (ret < 0) {

			pr_err("compress asoc: can't open platform %s\n",

								platform->name);

			goto out;

		}

	}



	if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->startup) {

		ret = fe->dai_link->compr_ops->startup(cstream);

		if (ret < 0) {

			pr_err("compress asoc: %s startup failed\n",

							fe->dai_link->name);

			goto machine_err;

		}

	}



	fe->dpcm[stream].runtime = fe_substream->runtime;



	if (dpcm_path_get(fe, stream, &list) <= 0) {

		dev_dbg(fe->dev, "ASoC: %s no valid %s route\n",

			fe->dai_link->name, stream ? "capture" : "playback");

	}



	/* calculate valid and active FE <-> BE dpcms */

	dpcm_process_paths(fe, stream, &list, 1);



	ret = dpcm_be_dai_startup(fe, stream);

	if (ret < 0) {

		/* clean up all links */

		list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)

			dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;



		dpcm_be_disconnect(fe, stream);

		fe->dpcm[stream].runtime = NULL;

		goto fe_err;

	}



	dpcm_clear_pending_state(fe, stream);

	dpcm_path_put(&list);



	mutex_unlock(&fe->card->mutex);



	return 0;



fe_err:

	if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)

		fe->dai_link->compr_ops->shutdown(cstream);

machine_err:

	if (platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);

out:

	mutex_unlock(&fe->card->mutex);

	return ret;

}



/*

 * Power down the audio subsystem pmdown_time msecs after close is called.

 * This is to ensure there are no pops or clicks in between any music tracks
@@ -163,6 +238,45 @@ static int soc_compr_free(struct snd_compr_stream *cstream) 
	return 0;

}



static int soc_compr_free_fe(struct snd_compr_stream *cstream)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_soc_dpcm *dpcm;

	int stream, ret;



	if (cstream->direction == SND_COMPRESS_PLAYBACK)

		stream = SNDRV_PCM_STREAM_PLAYBACK;

	else

		stream = SNDRV_PCM_STREAM_CAPTURE;



	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);



	ret = dpcm_be_dai_hw_free(fe, stream);

	if (ret < 0)

		dev_err(fe->dev, "compressed hw_free failed %d\n", ret);



	ret = dpcm_be_dai_shutdown(fe, stream);



	/* mark FE's links ready to prune */

	list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be)

		dpcm->state = SND_SOC_DPCM_LINK_STATE_FREE;



	dpcm_be_disconnect(fe, stream);



	fe->dpcm[stream].runtime = NULL;



	if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->shutdown)

		fe->dai_link->compr_ops->shutdown(cstream);



	if (platform->driver->compr_ops && platform->driver->compr_ops->free)

		platform->driver->compr_ops->free(cstream);

	/*cpu_dai->runtime = NULL;*/



	mutex_unlock(&fe->card->mutex);

	return 0;

}



static int soc_compr_trigger(struct snd_compr_stream *cstream, int cmd)

{
@@ -193,6 +307,34 @@ out: 
	return ret;

}



static int soc_compr_trigger_fe(struct snd_compr_stream *cstream, int cmd)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_soc_platform *platform = fe->platform;

	int ret = 0, stream;



	if (cstream->direction == SND_COMPRESS_PLAYBACK)

		stream = SNDRV_PCM_STREAM_PLAYBACK;

	else

		stream = SNDRV_PCM_STREAM_CAPTURE;





	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);



	if (platform->driver->compr_ops &&

				platform->driver->compr_ops->trigger) {

		ret = platform->driver->compr_ops->trigger(cstream, cmd);

		if (ret < 0)

			goto out;

	}



	ret = dpcm_be_dai_trigger(fe, stream, cmd);



out:

	mutex_unlock(&fe->card->mutex);

	return ret;

}



static int soc_compr_set_params(struct snd_compr_stream *cstream,

					struct snd_compr_params *params)

{
@@ -240,6 +382,61 @@ err: 
	return ret;

}



static int soc_compr_set_params_fe(struct snd_compr_stream *cstream,

					struct snd_compr_params *params)

{

	struct snd_soc_pcm_runtime *fe = cstream->private_data;

	struct snd_pcm_substream *fe_substream = fe->pcm->streams[0].substream;

	struct snd_soc_platform *platform = fe->platform;

	struct snd_pcm_hw_params *hw_params;

	int ret = 0, stream;



	if (cstream->direction == SND_COMPRESS_PLAYBACK)

		stream = SNDRV_PCM_STREAM_PLAYBACK;

	else

		stream = SNDRV_PCM_STREAM_CAPTURE;



	hw_params = kzalloc(sizeof(*hw_params), GFP_KERNEL);

	if (hw_params == NULL)

		return -ENOMEM;



	mutex_lock_nested(&fe->card->mutex, SND_SOC_CARD_CLASS_RUNTIME);



	/* first we call set_params for the platform driver

	 * this should configure the soc side

	 * if the machine has compressed ops then we call that as well

	 * expectation is that platform and machine will configure everything

	 * for this compress path, like configuring pcm port for codec

	 */

	if (platform->driver->compr_ops &&

			platform->driver->compr_ops->set_params) {

		ret = platform->driver->compr_ops->set_params(cstream, params);

		if (ret < 0)

			goto out;

	}



	if (fe->dai_link->compr_ops && fe->dai_link->compr_ops->set_params) {

		ret = fe->dai_link->compr_ops->set_params(cstream);

		if (ret < 0)

			goto out;

	}





	memcpy(&fe->dpcm[fe_substream->stream].hw_params, params,

			sizeof(struct snd_pcm_hw_params));

	ret = dpcm_be_dai_hw_params(fe, stream);

	if (ret < 0)

		goto out;



	ret = dpcm_be_dai_prepare(fe, stream);

	if (ret < 0)

		goto out;



out:

	mutex_unlock(&fe->card->mutex);

	return ret;

}



static int soc_compr_get_params(struct snd_compr_stream *cstream,

					struct snd_codec *params)

{
@@ -374,6 +571,19 @@ static struct snd_compr_ops soc_compr_ops = { 
	.get_codec_caps = soc_compr_get_codec_caps

};



/* ASoC Dynamic Compress operations */

static struct snd_compr_ops soc_compr_dyn_ops = {

	.open		= soc_compr_open_fe,

	.free		= soc_compr_free_fe,

	.set_params	= soc_compr_set_params_fe,

	.get_params	= soc_compr_get_params,

	.trigger	= soc_compr_trigger_fe,

	.pointer	= soc_compr_pointer,

	.ack		= soc_compr_ack,

	.get_caps	= soc_compr_get_caps,

	.get_codec_caps = soc_compr_get_codec_caps

};



/* create a new compress */

int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num)

{
@@ -382,6 +592,7 @@ int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 
	struct snd_soc_dai *codec_dai = rtd->codec_dai;

	struct snd_soc_dai *cpu_dai = rtd->cpu_dai;

	struct snd_compr *compr;

	struct snd_pcm *be_pcm;

	char new_name[64];

	int ret = 0, direction = 0;
@@ -409,6 +620,28 @@ int soc_new_compress(struct snd_soc_pcm_runtime *rtd, int num) 
		ret = -ENOMEM;

		goto compr_err;

	}



	if (rtd->dai_link->dynamic) {

		snprintf(new_name, sizeof(new_name), "(%s)",

			rtd->dai_link->stream_name);



		ret = snd_pcm_new_internal(rtd->card->snd_card, new_name, num,

				1, 0, &be_pcm);

		if (ret < 0) {

			dev_err(rtd->card->dev, "ASoC: can't create compressed for %s\n",

				rtd->dai_link->name);

			goto compr_err;

		}



		rtd->pcm = be_pcm;

		rtd->fe_compr = 1;

		be_pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].

					substream->private_data = rtd;

		/*be_pcm->streams[SNDRV_PCM_STREAM_CAPTURE].

					substream->private_data = rtd;*/

		memcpy(compr->ops, &soc_compr_dyn_ops,

						sizeof(soc_compr_dyn_ops));

	} else

		memcpy(compr->ops, &soc_compr_ops, sizeof(soc_compr_ops));



	/* Add copy callback for not memory mapped DSPs */