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

Commit a870cdce authored by Vinod Koul's avatar Vinod Koul Committed by Mark Brown
Browse files

ASoC: Intel: mfld-pcm: modularize stream allocation code 



Tis will be used to add table based support for pcm front ends in subsequent
patches

Signed-off-by: default avatarVinod Koul <vinod.koul@intel.com>
Signed-off-by: default avatarMark Brown <broonie@linaro.org>
parent aa9b045f

sound/soc/intel/sst-mfld-platform-pcm.c

+70 −32
Original line number Diff line number Diff line
@@ -143,52 +143,90 @@ static inline int sst_get_stream_status(struct sst_runtime_stream *stream) 
	return state;

}



static void sst_fill_alloc_params(struct snd_pcm_substream *substream,

				struct snd_sst_alloc_params_ext *alloc_param)

{

	unsigned int channels;

	snd_pcm_uframes_t period_size;

	ssize_t periodbytes;

	ssize_t buffer_bytes = snd_pcm_lib_buffer_bytes(substream);

	u32 buffer_addr = virt_to_phys(substream->dma_buffer.area);



	channels = substream->runtime->channels;

	period_size = substream->runtime->period_size;

	periodbytes = samples_to_bytes(substream->runtime, period_size);

	alloc_param->ring_buf_info[0].addr = buffer_addr;

	alloc_param->ring_buf_info[0].size = buffer_bytes;

	alloc_param->sg_count = 1;

	alloc_param->reserved = 0;

	alloc_param->frag_size = periodbytes * channels;



}

static void sst_fill_pcm_params(struct snd_pcm_substream *substream,

				struct sst_pcm_params *param)

				struct snd_sst_stream_params *param)

{

	param->uc.pcm_params.num_chan = (u8) substream->runtime->channels;

	param->uc.pcm_params.pcm_wd_sz = substream->runtime->sample_bits;

	param->uc.pcm_params.sfreq = substream->runtime->rate;



	param->num_chan = (u8) substream->runtime->channels;

	param->pcm_wd_sz = substream->runtime->sample_bits;

	param->reserved = 0;

	param->sfreq = substream->runtime->rate;

	param->ring_buffer_size = snd_pcm_lib_buffer_bytes(substream);

	param->period_count = substream->runtime->period_size;

	param->ring_buffer_addr = virt_to_phys(substream->dma_buffer.area);

	pr_debug("period_cnt = %d\n", param->period_count);

	pr_debug("sfreq= %d, wd_sz = %d\n", param->sfreq, param->pcm_wd_sz);

	/* PCM stream via ALSA interface */

	param->uc.pcm_params.use_offload_path = 0;

	param->uc.pcm_params.reserved2 = 0;

	memset(param->uc.pcm_params.channel_map, 0, sizeof(u8));



}

int sst_fill_stream_params(void *substream,

	struct snd_sst_params *str_params, bool is_compress)

{

	struct snd_pcm_substream *pstream = NULL;

	struct snd_compr_stream *cstream = NULL;



	if (is_compress == true)

		cstream = (struct snd_compr_stream *)substream;

	else

		pstream = (struct snd_pcm_substream *)substream;



	str_params->stream_type = SST_STREAM_TYPE_MUSIC;



	/* For pcm streams */

	if (pstream)

		str_params->ops = (u8)pstream->stream;

	if (cstream)

		str_params->ops = (u8)cstream->direction;



	return 0;

}



static int sst_platform_alloc_stream(struct snd_pcm_substream *substream)

static int sst_platform_alloc_stream(struct snd_pcm_substream *substream,

		struct snd_soc_platform *platform)

{

	struct sst_runtime_stream *stream =

			substream->runtime->private_data;

	struct sst_pcm_params param = {0};

	struct sst_stream_params str_params = {0};

	int ret_val;

	struct snd_sst_stream_params param = {{{0,},},};

	struct snd_sst_params str_params = {0};

	struct snd_sst_alloc_params_ext alloc_params = {0};

	int ret_val = 0;



	/* set codec params and inform SST driver the same */

	sst_fill_pcm_params(substream, &param);

	sst_fill_alloc_params(substream, &alloc_params);

	substream->runtime->dma_area = substream->dma_buffer.area;

	str_params.sparams = param;

	str_params.codec =  param.codec;

	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

		str_params.ops = STREAM_OPS_PLAYBACK;

		str_params.device_type = substream->pcm->device + 1;

		pr_debug("Playbck stream,Device %d\n",

					substream->pcm->device);

	} else {

		str_params.ops = STREAM_OPS_CAPTURE;

		str_params.device_type = SND_SST_DEVICE_CAPTURE;

		pr_debug("Capture stream,Device %d\n",

					substream->pcm->device);

	}

	ret_val = stream->ops->open(&str_params);

	pr_debug("SST_SND_PLAY/CAPTURE ret_val = %x\n", ret_val);

	str_params.aparams = alloc_params;

	str_params.codec = SST_CODEC_TYPE_PCM;



	/* fill the device type and stream id to pass to SST driver */

	ret_val = sst_fill_stream_params(substream, &str_params, false);

	if (ret_val < 0)

		return ret_val;



	stream->stream_info.str_id = ret_val;

	pr_debug("str id :  %d\n", stream->stream_info.str_id);

	stream->stream_info.str_id = str_params.stream_id;



	ret_val = stream->ops->open(&str_params);

	if (ret_val <= 0)

		return ret_val;





	return ret_val;

}
@@ -300,8 +338,8 @@ static int sst_media_prepare(struct snd_pcm_substream *substream, 
		return ret_val;

	}



	ret_val = sst_platform_alloc_stream(substream);

	if (ret_val < 0)

	ret_val = sst_platform_alloc_stream(substream, dai->platform);

	if (ret_val <= 0)

		return ret_val;

	snprintf(substream->pcm->id, sizeof(substream->pcm->id),

			"%d", stream->stream_info.str_id);

sound/soc/intel/sst-mfld-platform.h

+1 −1
Original line number Diff line number Diff line
@@ -125,7 +125,7 @@ struct compress_sst_ops { 
};



struct sst_ops {

	int (*open) (struct sst_stream_params *str_param);

	int (*open) (struct snd_sst_params *str_param);

	int (*device_control) (int cmd, void *arg);

	int (*close) (unsigned int str_id);

};