Unverified Commit 7d88b960 authored by Pierre-Louis Bossart's avatar Pierre-Louis Bossart Committed by Mark Brown
Browse files

ASoC: SOF: Intel: hdac_ext_stream: consistent prefixes for variables/members 



The existing code maximizes confusion by using 'stream' and 'hstream'
variables of different types, e.g:

struct hdac_stream *stream;
struct hdac_ext_stream *stream;
struct hdac_stream *hstream;
struct hdac_ext_stream *hstream;

This confusion is partly inherited from legacy code but SOF
contributors added their own creative spin, e.g.

struct hdac_ext_stream *link_dev;
struct hdac_ext_stream *dsp_stream;
struct hdac_ext_stream hda_stream;

and my personal favorite:

stream = &hda_stream->hda_stream;

This patch suggests a consistent naming across all Intel code related
to HDAudio stream management. The convention is - by hierarchical
order:

struct sof_intel_hda_stream *hda_stream;
struct hdac_ext_stream *hext_stream;
struct hdac_stream *hstream;

No functionality change - just renaming of variables/members.

Signed-off-by: default avatarPierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Reviewed-by: default avatarKai Vehmanen <kai.vehmanen@linux.intel.com>
Reviewed-by: default avatarRander Wang <rander.wang@intel.com>
Signed-off-by: default avatarPeter Ujfalusi <peter.ujfalusi@linux.intel.com>
Link: https://lore.kernel.org/r/20220209063104.9971-1-peter.ujfalusi@linux.intel.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent 960a8904

sound/soc/sof/intel/hda-dai.c

+46 −46
Original line number Diff line number Diff line
@@ -62,7 +62,7 @@ static struct hdac_ext_stream * 
	const struct sof_intel_dsp_desc *chip;

	struct snd_sof_dev *sdev;

	struct hdac_ext_stream *res = NULL;

	struct hdac_stream *stream = NULL;

	struct hdac_stream *hstream = NULL;



	int stream_dir = substream->stream;
@@ -72,39 +72,39 @@ static struct hdac_ext_stream * 
	}



	spin_lock_irq(&bus->reg_lock);

	list_for_each_entry(stream, &bus->stream_list, list) {

		struct hdac_ext_stream *hstream =

			stream_to_hdac_ext_stream(stream);

		if (stream->direction != substream->stream)

	list_for_each_entry(hstream, &bus->stream_list, list) {

		struct hdac_ext_stream *hext_stream =

			stream_to_hdac_ext_stream(hstream);

		if (hstream->direction != substream->stream)

			continue;



		hda_stream = hstream_to_sof_hda_stream(hstream);

		hda_stream = hstream_to_sof_hda_stream(hext_stream);

		sdev = hda_stream->sdev;

		chip = get_chip_info(sdev->pdata);



		/* check if link is available */

		if (!hstream->link_locked) {

		if (!hext_stream->link_locked) {

			/*

			 * choose the first available link for platforms that do not have the

			 * PROCEN_FMT_QUIRK set.

			 */

			if (!(chip->quirks & SOF_INTEL_PROCEN_FMT_QUIRK)) {

				res = hstream;

				res = hext_stream;

				break;

			}



			if (stream->opened) {

			if (hstream->opened) {

				/*

				 * check if the stream tag matches the stream

				 * tag of one of the connected FEs

				 */

				if (hda_check_fes(rtd, stream_dir,

						  stream->stream_tag)) {

					res = hstream;

						  hstream->stream_tag)) {

					res = hext_stream;

					break;

				}

			} else {

				res = hstream;

				res = hext_stream;



				/*

				 * This must be a hostless stream.
@@ -132,17 +132,17 @@ static struct hdac_ext_stream * 
	return res;

}



static int hda_link_dma_params(struct hdac_ext_stream *stream,

static int hda_link_dma_params(struct hdac_ext_stream *hext_stream,

			       struct hda_pipe_params *params)

{

	struct hdac_stream *hstream = &stream->hstream;

	struct hdac_stream *hstream = &hext_stream->hstream;

	unsigned char stream_tag = hstream->stream_tag;

	struct hdac_bus *bus = hstream->bus;

	struct hdac_ext_link *link;

	unsigned int format_val;



	snd_hdac_ext_stream_decouple(bus, stream, true);

	snd_hdac_ext_link_stream_reset(stream);

	snd_hdac_ext_stream_decouple(bus, hext_stream, true);

	snd_hdac_ext_link_stream_reset(hext_stream);



	format_val = snd_hdac_calc_stream_format(params->s_freq, params->ch,

						 params->format,
@@ -151,9 +151,9 @@ static int hda_link_dma_params(struct hdac_ext_stream *stream, 
	dev_dbg(bus->dev, "format_val=%d, rate=%d, ch=%d, format=%d\n",

		format_val, params->s_freq, params->ch, params->format);



	snd_hdac_ext_link_stream_setup(stream, format_val);

	snd_hdac_ext_link_stream_setup(hext_stream, format_val);



	if (stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK) {

	if (hext_stream->hstream.direction == SNDRV_PCM_STREAM_PLAYBACK) {

		list_for_each_entry(link, &bus->hlink_list, list) {

			if (link->index == params->link_index)

				snd_hdac_ext_link_set_stream_id(link,
@@ -161,7 +161,7 @@ static int hda_link_dma_params(struct hdac_ext_stream *stream, 
		}

	}



	stream->link_prepared = 1;

	hext_stream->link_prepared = 1;



	return 0;

}
@@ -218,7 +218,7 @@ static int hda_link_hw_params(struct snd_pcm_substream *substream, 
{

	struct hdac_stream *hstream = substream->runtime->private_data;

	struct hdac_bus *bus = hstream->bus;

	struct hdac_ext_stream *link_dev;

	struct hdac_ext_stream *hext_stream;

	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

	struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);

	struct sof_intel_hda_stream *hda_stream;
@@ -229,18 +229,18 @@ static int hda_link_hw_params(struct snd_pcm_substream *substream, 
	int ret;



	/* get stored dma data if resuming from system suspend */

	link_dev = snd_soc_dai_get_dma_data(dai, substream);

	if (!link_dev) {

		link_dev = hda_link_stream_assign(bus, substream);

		if (!link_dev)

	hext_stream = snd_soc_dai_get_dma_data(dai, substream);

	if (!hext_stream) {

		hext_stream = hda_link_stream_assign(bus, substream);

		if (!hext_stream)

			return -EBUSY;



		snd_soc_dai_set_dma_data(dai, substream, (void *)link_dev);

		snd_soc_dai_set_dma_data(dai, substream, (void *)hext_stream);

	}



	stream_tag = hdac_stream(link_dev)->stream_tag;

	stream_tag = hdac_stream(hext_stream)->stream_tag;



	hda_stream = hstream_to_sof_hda_stream(link_dev);

	hda_stream = hstream_to_sof_hda_stream(hext_stream);



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

		w = dai->playback_widget;
@@ -257,7 +257,7 @@ static int hda_link_hw_params(struct snd_pcm_substream *substream, 
		return -EINVAL;



	/* set the hdac_stream in the codec dai */

	snd_soc_dai_set_stream(codec_dai, hdac_stream(link_dev), substream->stream);

	snd_soc_dai_set_stream(codec_dai, hdac_stream(hext_stream), substream->stream);



	p_params.s_fmt = snd_pcm_format_width(params_format(params));

	p_params.ch = params_channels(params);
@@ -271,20 +271,20 @@ static int hda_link_hw_params(struct snd_pcm_substream *substream, 
	else

		p_params.link_bps = codec_dai->driver->capture.sig_bits;



	return hda_link_dma_params(link_dev, &p_params);

	return hda_link_dma_params(hext_stream, &p_params);

}



static int hda_link_pcm_prepare(struct snd_pcm_substream *substream,

				struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *link_dev =

	struct hdac_ext_stream *hext_stream =

				snd_soc_dai_get_dma_data(dai, substream);

	struct snd_sof_dev *sdev =

				snd_soc_component_get_drvdata(dai->component);

	struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream);

	int stream = substream->stream;



	if (link_dev->link_prepared)

	if (hext_stream->link_prepared)

		return 0;



	dev_dbg(sdev->dev, "hda: prepare stream dir %d\n", substream->stream);
@@ -326,7 +326,7 @@ static int hda_link_dai_config_pause_push_ipc(struct snd_soc_dapm_widget *w) 
static int hda_link_pcm_trigger(struct snd_pcm_substream *substream,

				int cmd, struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *link_dev =

	struct hdac_ext_stream *hext_stream =

				snd_soc_dai_get_dma_data(dai, substream);

	struct sof_intel_hda_stream *hda_stream;

	struct snd_soc_pcm_runtime *rtd;
@@ -345,7 +345,7 @@ static int hda_link_pcm_trigger(struct snd_pcm_substream *substream, 
	if (!link)

		return -EINVAL;



	hda_stream = hstream_to_sof_hda_stream(link_dev);

	hda_stream = hstream_to_sof_hda_stream(hext_stream);



	dev_dbg(dai->dev, "In %s cmd=%d\n", __func__, cmd);
@@ -354,11 +354,11 @@ static int hda_link_pcm_trigger(struct snd_pcm_substream *substream, 
	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		snd_hdac_ext_link_stream_start(link_dev);

		snd_hdac_ext_link_stream_start(hext_stream);

		break;

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_STOP:

		snd_hdac_ext_link_stream_clear(link_dev);

		snd_hdac_ext_link_stream_clear(hext_stream);



		/*

		 * free DAI widget during stop/suspend to keep widget use_count's balanced.
@@ -368,14 +368,14 @@ static int hda_link_pcm_trigger(struct snd_pcm_substream *substream, 
			return ret;



		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			stream_tag = hdac_stream(link_dev)->stream_tag;

			stream_tag = hdac_stream(hext_stream)->stream_tag;

			snd_hdac_ext_link_clear_stream_id(link, stream_tag);

		}



		link_dev->link_prepared = 0;

		hext_stream->link_prepared = 0;

		break;

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

		snd_hdac_ext_link_stream_clear(link_dev);

		snd_hdac_ext_link_stream_clear(hext_stream);



		ret = hda_link_dai_config_pause_push_ipc(w);

		if (ret < 0)
@@ -396,22 +396,22 @@ static int hda_link_hw_free(struct snd_pcm_substream *substream, 
	struct hdac_ext_link *link;

	struct hdac_stream *hstream;

	struct snd_soc_pcm_runtime *rtd;

	struct hdac_ext_stream *link_dev;

	struct hdac_ext_stream *hext_stream;

	struct snd_soc_dapm_widget *w;

	int ret;



	hstream = substream->runtime->private_data;

	bus = hstream->bus;

	rtd = asoc_substream_to_rtd(substream);

	link_dev = snd_soc_dai_get_dma_data(dai, substream);

	hext_stream = snd_soc_dai_get_dma_data(dai, substream);



	if (!link_dev) {

	if (!hext_stream) {

		dev_dbg(dai->dev,

			"%s: link_dev is not assigned\n", __func__);

			"%s: hext_stream is not assigned\n", __func__);

		return -EINVAL;

	}



	hda_stream = hstream_to_sof_hda_stream(link_dev);

	hda_stream = hstream_to_sof_hda_stream(hext_stream);



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)

		w = dai->playback_widget;
@@ -428,13 +428,13 @@ static int hda_link_hw_free(struct snd_pcm_substream *substream, 
		return -EINVAL;



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

		stream_tag = hdac_stream(link_dev)->stream_tag;

		stream_tag = hdac_stream(hext_stream)->stream_tag;

		snd_hdac_ext_link_clear_stream_id(link, stream_tag);

	}



	snd_soc_dai_set_dma_data(dai, substream, NULL);

	snd_hdac_ext_stream_release(link_dev, HDAC_EXT_STREAM_TYPE_LINK);

	link_dev->link_prepared = 0;

	snd_hdac_ext_stream_release(hext_stream, HDAC_EXT_STREAM_TYPE_LINK);

	hext_stream->link_prepared = 0;



	/* free the host DMA channel reserved by hostless streams */

	hda_stream->host_reserved = 0;

sound/soc/sof/intel/hda-dsp.c

+7 −7
Original line number Diff line number Diff line
@@ -904,7 +904,7 @@ int hda_dsp_set_hw_params_upon_resume(struct snd_sof_dev *sdev) 
#if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA)

	struct hdac_bus *bus = sof_to_bus(sdev);

	struct snd_soc_pcm_runtime *rtd;

	struct hdac_ext_stream *stream;

	struct hdac_ext_stream *hext_stream;

	struct hdac_ext_link *link;

	struct hdac_stream *s;

	const char *name;
@@ -912,7 +912,7 @@ int hda_dsp_set_hw_params_upon_resume(struct snd_sof_dev *sdev) 


	/* set internal flag for BE */

	list_for_each_entry(s, &bus->stream_list, list) {

		stream = stream_to_hdac_ext_stream(s);

		hext_stream = stream_to_hdac_ext_stream(s);



		/*

		 * clear stream. This should already be taken care for running
@@ -920,20 +920,20 @@ int hda_dsp_set_hw_params_upon_resume(struct snd_sof_dev *sdev) 
		 * streams do not get suspended, so this needs to be done

		 * explicitly during suspend.

		 */

		if (stream->link_substream) {

			rtd = asoc_substream_to_rtd(stream->link_substream);

		if (hext_stream->link_substream) {

			rtd = asoc_substream_to_rtd(hext_stream->link_substream);

			name = asoc_rtd_to_codec(rtd, 0)->component->name;

			link = snd_hdac_ext_bus_get_link(bus, name);

			if (!link)

				return -EINVAL;



			stream->link_prepared = 0;

			hext_stream->link_prepared = 0;



			if (hdac_stream(stream)->direction ==

			if (hdac_stream(hext_stream)->direction ==

				SNDRV_PCM_STREAM_CAPTURE)

				continue;



			stream_tag = hdac_stream(stream)->stream_tag;

			stream_tag = hdac_stream(hext_stream)->stream_tag;

			snd_hdac_ext_link_clear_stream_id(link, stream_tag);

		}

	}

sound/soc/sof/intel/hda-ipc.c

+5 −5
Original line number Diff line number Diff line
@@ -255,13 +255,13 @@ int hda_ipc_msg_data(struct snd_sof_dev *sdev, 


		hda_stream = container_of(hstream,

					  struct sof_intel_hda_stream,

					  hda_stream.hstream);

					  hext_stream.hstream);



		/* The stream might already be closed */

		if (!hstream)

			return -ESTRPIPE;



		sof_mailbox_read(sdev, hda_stream->stream.posn_offset, p, sz);

		sof_mailbox_read(sdev, hda_stream->sof_intel_stream.posn_offset, p, sz);

	}



	return 0;
@@ -277,17 +277,17 @@ int hda_ipc_pcm_params(struct snd_sof_dev *sdev, 
	size_t posn_offset = reply->posn_offset;



	hda_stream = container_of(hstream, struct sof_intel_hda_stream,

				  hda_stream.hstream);

				  hext_stream.hstream);



	/* check for unaligned offset or overflow */

	if (posn_offset > sdev->stream_box.size ||

	    posn_offset % sizeof(struct sof_ipc_stream_posn) != 0)

		return -EINVAL;



	hda_stream->stream.posn_offset = sdev->stream_box.offset + posn_offset;

	hda_stream->sof_intel_stream.posn_offset = sdev->stream_box.offset + posn_offset;



	dev_dbg(sdev->dev, "pcm: stream dir %d, posn mailbox offset is %zu",

		substream->stream, hda_stream->stream.posn_offset);

		substream->stream, hda_stream->sof_intel_stream.posn_offset);



	return 0;

}

sound/soc/sof/intel/hda-loader.c

+25 −25
Original line number Diff line number Diff line
@@ -47,18 +47,18 @@ static struct hdac_ext_stream *cl_stream_prepare(struct snd_sof_dev *sdev, unsig 
						 unsigned int size, struct snd_dma_buffer *dmab,

						 int direction)

{

	struct hdac_ext_stream *dsp_stream;

	struct hdac_ext_stream *hext_stream;

	struct hdac_stream *hstream;

	struct pci_dev *pci = to_pci_dev(sdev->dev);

	int ret;



	dsp_stream = hda_dsp_stream_get(sdev, direction, 0);

	hext_stream = hda_dsp_stream_get(sdev, direction, 0);



	if (!dsp_stream) {

	if (!hext_stream) {

		dev_err(sdev->dev, "error: no stream available\n");

		return ERR_PTR(-ENODEV);

	}

	hstream = &dsp_stream->hstream;

	hstream = &hext_stream->hstream;

	hstream->substream = NULL;



	/* allocate DMA buffer */
@@ -73,21 +73,21 @@ static struct hdac_ext_stream *cl_stream_prepare(struct snd_sof_dev *sdev, unsig 
	hstream->bufsize = size;



	if (direction == SNDRV_PCM_STREAM_CAPTURE) {

		ret = hda_dsp_iccmax_stream_hw_params(sdev, dsp_stream, dmab, NULL);

		ret = hda_dsp_iccmax_stream_hw_params(sdev, hext_stream, dmab, NULL);

		if (ret < 0) {

			dev_err(sdev->dev, "error: iccmax stream prepare failed: %d\n", ret);

			goto error;

		}

	} else {

		ret = hda_dsp_stream_hw_params(sdev, dsp_stream, dmab, NULL);

		ret = hda_dsp_stream_hw_params(sdev, hext_stream, dmab, NULL);

		if (ret < 0) {

			dev_err(sdev->dev, "error: hdac prepare failed: %d\n", ret);

			goto error;

		}

		hda_dsp_stream_spib_config(sdev, dsp_stream, HDA_DSP_SPIB_ENABLE, size);

		hda_dsp_stream_spib_config(sdev, hext_stream, HDA_DSP_SPIB_ENABLE, size);

	}



	return dsp_stream;

	return hext_stream;



error:

	hda_dsp_stream_put(sdev, direction, hstream->stream_tag);
@@ -209,9 +209,9 @@ static int cl_dsp_init(struct snd_sof_dev *sdev, int stream_tag) 
}



static int cl_trigger(struct snd_sof_dev *sdev,

		      struct hdac_ext_stream *stream, int cmd)

		      struct hdac_ext_stream *hext_stream, int cmd)

{

	struct hdac_stream *hstream = &stream->hstream;

	struct hdac_stream *hstream = &hext_stream->hstream;

	int sd_offset = SOF_STREAM_SD_OFFSET(hstream);



	/* code loader is special case that reuses stream ops */
@@ -231,19 +231,19 @@ static int cl_trigger(struct snd_sof_dev *sdev, 
		hstream->running = true;

		return 0;

	default:

		return hda_dsp_stream_trigger(sdev, stream, cmd);

		return hda_dsp_stream_trigger(sdev, hext_stream, cmd);

	}

}



static int cl_cleanup(struct snd_sof_dev *sdev, struct snd_dma_buffer *dmab,

		      struct hdac_ext_stream *stream)

		      struct hdac_ext_stream *hext_stream)

{

	struct hdac_stream *hstream = &stream->hstream;

	struct hdac_stream *hstream = &hext_stream->hstream;

	int sd_offset = SOF_STREAM_SD_OFFSET(hstream);

	int ret = 0;



	if (hstream->direction == SNDRV_PCM_STREAM_PLAYBACK)

		ret = hda_dsp_stream_spib_config(sdev, stream, HDA_DSP_SPIB_DISABLE, 0);

		ret = hda_dsp_stream_spib_config(sdev, hext_stream, HDA_DSP_SPIB_DISABLE, 0);

	else

		snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, sd_offset,

					SOF_HDA_SD_CTL_DMA_START, 0);
@@ -267,12 +267,12 @@ static int cl_cleanup(struct snd_sof_dev *sdev, struct snd_dma_buffer *dmab, 
	return ret;

}



static int cl_copy_fw(struct snd_sof_dev *sdev, struct hdac_ext_stream *stream)

static int cl_copy_fw(struct snd_sof_dev *sdev, struct hdac_ext_stream *hext_stream)

{

	unsigned int reg;

	int ret, status;



	ret = cl_trigger(sdev, stream, SNDRV_PCM_TRIGGER_START);

	ret = cl_trigger(sdev, hext_stream, SNDRV_PCM_TRIGGER_START);

	if (ret < 0) {

		dev_err(sdev->dev, "error: DMA trigger start failed\n");

		return ret;
@@ -296,7 +296,7 @@ static int cl_copy_fw(struct snd_sof_dev *sdev, struct hdac_ext_stream *stream) 
			__func__);

	}



	ret = cl_trigger(sdev, stream, SNDRV_PCM_TRIGGER_STOP);

	ret = cl_trigger(sdev, hext_stream, SNDRV_PCM_TRIGGER_STOP);

	if (ret < 0) {

		dev_err(sdev->dev, "error: DMA trigger stop failed\n");

		if (!status)
@@ -392,7 +392,7 @@ int hda_dsp_cl_boot_firmware(struct snd_sof_dev *sdev) 
	struct snd_sof_pdata *plat_data = sdev->pdata;

	const struct sof_dev_desc *desc = plat_data->desc;

	const struct sof_intel_dsp_desc *chip_info;

	struct hdac_ext_stream *stream;

	struct hdac_ext_stream *hext_stream;

	struct firmware stripped_firmware;

	int ret, ret1, i;
@@ -417,11 +417,11 @@ int hda_dsp_cl_boot_firmware(struct snd_sof_dev *sdev) 
	init_waitqueue_head(&sdev->boot_wait);



	/* prepare DMA for code loader stream */

	stream = cl_stream_prepare(sdev, HDA_CL_STREAM_FORMAT, stripped_firmware.size,

	hext_stream = cl_stream_prepare(sdev, HDA_CL_STREAM_FORMAT, stripped_firmware.size,

					&sdev->dmab, SNDRV_PCM_STREAM_PLAYBACK);

	if (IS_ERR(stream)) {

	if (IS_ERR(hext_stream)) {

		dev_err(sdev->dev, "error: dma prepare for fw loading failed\n");

		return PTR_ERR(stream);

		return PTR_ERR(hext_stream);

	}



	memcpy(sdev->dmab.area, stripped_firmware.data,
@@ -433,7 +433,7 @@ int hda_dsp_cl_boot_firmware(struct snd_sof_dev *sdev) 
			"Attempting iteration %d of Core En/ROM load...\n", i);



		hda->boot_iteration = i + 1;

		ret = cl_dsp_init(sdev, stream->hstream.stream_tag);

		ret = cl_dsp_init(sdev, hext_stream->hstream.stream_tag);



		/* don't retry anymore if successful */

		if (!ret)
@@ -472,7 +472,7 @@ int hda_dsp_cl_boot_firmware(struct snd_sof_dev *sdev) 
	 * Continue with code loading and firmware boot

	 */

	hda->boot_iteration = HDA_FW_BOOT_ATTEMPTS;

	ret = cl_copy_fw(sdev, stream);

	ret = cl_copy_fw(sdev, hext_stream);

	if (!ret)

		dev_dbg(sdev->dev, "Firmware download successful, booting...\n");

	else
@@ -485,7 +485,7 @@ int hda_dsp_cl_boot_firmware(struct snd_sof_dev *sdev) 
	 * This should be done even if firmware loading fails.

	 * If the cleanup also fails, we return the initial error

	 */

	ret1 = cl_cleanup(sdev, &sdev->dmab, stream);

	ret1 = cl_cleanup(sdev, &sdev->dmab, hext_stream);

	if (ret1 < 0) {

		dev_err(sdev->dev, "error: Code loader DSP cleanup failed\n");

sound/soc/sof/intel/hda-pcm.c

+6 −6
Original line number Diff line number Diff line
@@ -96,7 +96,7 @@ int hda_dsp_pcm_hw_params(struct snd_sof_dev *sdev, 
			  struct sof_ipc_stream_params *ipc_params)

{

	struct hdac_stream *hstream = substream->runtime->private_data;

	struct hdac_ext_stream *stream = stream_to_hdac_ext_stream(hstream);

	struct hdac_ext_stream *hext_stream = stream_to_hdac_ext_stream(hstream);

	struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata;

	struct snd_dma_buffer *dmab;

	struct sof_ipc_fw_version *v = &sdev->fw_ready.version;
@@ -118,7 +118,7 @@ int hda_dsp_pcm_hw_params(struct snd_sof_dev *sdev, 
			(params->info & SNDRV_PCM_INFO_NO_PERIOD_WAKEUP) &&

			(params->flags & SNDRV_PCM_HW_PARAMS_NO_PERIOD_WAKEUP);



	ret = hda_dsp_stream_hw_params(sdev, stream, dmab, params);

	ret = hda_dsp_stream_hw_params(sdev, hext_stream, dmab, params);

	if (ret < 0) {

		dev_err(sdev->dev, "error: hdac prepare failed: %d\n", ret);

		return ret;
@@ -126,9 +126,9 @@ int hda_dsp_pcm_hw_params(struct snd_sof_dev *sdev, 


	/* enable SPIB when rewinds are disabled */

	if (hda_disable_rewinds)

		hda_dsp_stream_spib_config(sdev, stream, HDA_DSP_SPIB_ENABLE, 0);

		hda_dsp_stream_spib_config(sdev, hext_stream, HDA_DSP_SPIB_ENABLE, 0);

	else

		hda_dsp_stream_spib_config(sdev, stream, HDA_DSP_SPIB_DISABLE, 0);

		hda_dsp_stream_spib_config(sdev, hext_stream, HDA_DSP_SPIB_DISABLE, 0);



	/* update no_stream_position flag for ipc params */

	if (hda && hda->no_ipc_position) {
@@ -174,9 +174,9 @@ int hda_dsp_pcm_trigger(struct snd_sof_dev *sdev, 
			struct snd_pcm_substream *substream, int cmd)

{

	struct hdac_stream *hstream = substream->runtime->private_data;

	struct hdac_ext_stream *stream = stream_to_hdac_ext_stream(hstream);

	struct hdac_ext_stream *hext_stream = stream_to_hdac_ext_stream(hstream);



	return hda_dsp_stream_trigger(sdev, stream, cmd);

	return hda_dsp_stream_trigger(sdev, hext_stream, cmd);

}



snd_pcm_uframes_t hda_dsp_pcm_pointer(struct snd_sof_dev *sdev,