Unverified Commit 700462f5 authored by Cezary Rojewski's avatar Cezary Rojewski Committed by Mark Brown
Browse files

ASoC: Intel: avs: Probe compress operations 



Add compress operations handlers for data extraction through probes. A
single HDAudio stream is enlisted for said purpose. Operations follow
same protocol as for standard PCM streaming on HOST side.

Signed-off-by: default avatarCezary Rojewski <cezary.rojewski@intel.com>
Link: https://lore.kernel.org/r/20221202152841.672536-11-cezary.rojewski@intel.com


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

sound/soc/intel/Kconfig

+1 −0
Original line number Diff line number Diff line
@@ -217,6 +217,7 @@ config SND_SOC_INTEL_AVS 
	select SND_SOC_ACPI if ACPI

	select SND_SOC_TOPOLOGY

	select SND_SOC_HDA

	select SND_SOC_COMPRESS if DEBUG_FS

	select SND_HDA_EXT_CORE

	select SND_HDA_DSP_LOADER

	select SND_INTEL_DSP_CONFIG

sound/soc/intel/avs/avs.h

+3 −0
Original line number Diff line number Diff line
@@ -144,6 +144,9 @@ struct avs_dev { 
	u32 aging_timer_period;

	u32 fifo_full_timer_period;

	u32 logged_resources;	/* context dependent: core or library */

	/* probes */

	struct hdac_ext_stream *extractor;

	unsigned int num_probe_streams;

#endif

};

sound/soc/intel/avs/probes.c

+221 −3
Original line number Diff line number Diff line
@@ -6,13 +6,15 @@ 
//          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>

//



#include <sound/compress_driver.h>

#include <sound/hdaudio_ext.h>

#include <sound/hdaudio.h>

#include <sound/soc.h>

#include "avs.h"

#include "messages.h"



__maybe_unused

static int avs_dsp_init_probe(struct avs_dev *adev, union avs_connector_node_id node_id,

			      size_t buffer_size)



{

	struct avs_probe_cfg cfg = {{0}};

	struct avs_module_entry mentry;
@@ -34,7 +36,6 @@ static int avs_dsp_init_probe(struct avs_dev *adev, union avs_connector_node_id 
				   sizeof(cfg), &dummy);

}



__maybe_unused

static void avs_dsp_delete_probe(struct avs_dev *adev)

{

	struct avs_module_entry mentry;
@@ -44,3 +45,220 @@ static void avs_dsp_delete_probe(struct avs_dev *adev) 
	/* There is only ever one probe module instance. */

	avs_dsp_delete_module(adev, mentry.module_id, 0, INVALID_PIPELINE_ID, 0);

}



static inline struct hdac_ext_stream *avs_compr_get_host_stream(struct snd_compr_stream *cstream)

{

	return cstream->runtime->private_data;

}



static int avs_probe_compr_open(struct snd_compr_stream *cstream, struct snd_soc_dai *dai)

{

	struct avs_dev *adev = to_avs_dev(dai->dev);

	struct hdac_bus *bus = &adev->base.core;

	struct hdac_ext_stream *host_stream;



	if (adev->extractor) {

		dev_err(dai->dev, "Cannot open more than one extractor stream\n");

		return -EEXIST;

	}



	host_stream = snd_hdac_ext_cstream_assign(bus, cstream);

	if (!host_stream) {

		dev_err(dai->dev, "Failed to assign HDAudio stream for extraction\n");

		return -EBUSY;

	}



	adev->extractor = host_stream;

	hdac_stream(host_stream)->curr_pos = 0;

	cstream->runtime->private_data = host_stream;



	return 0;

}



static int avs_probe_compr_free(struct snd_compr_stream *cstream, struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *host_stream = avs_compr_get_host_stream(cstream);

	struct avs_dev *adev = to_avs_dev(dai->dev);

	struct avs_probe_point_desc *desc;

	/* Extractor node identifier. */

	unsigned int vindex = INVALID_NODE_ID.vindex;

	size_t num_desc;

	int i, ret;



	/* Disconnect all probe points. */

	ret = avs_ipc_probe_get_points(adev, &desc, &num_desc);

	if (ret) {

		dev_err(dai->dev, "get probe points failed: %d\n", ret);

		ret = AVS_IPC_RET(ret);

		goto exit;

	}



	for (i = 0; i < num_desc; i++)

		if (desc[i].node_id.vindex == vindex)

			avs_ipc_probe_disconnect_points(adev, &desc[i].id, 1);

	kfree(desc);



exit:

	if (adev->num_probe_streams) {

		adev->num_probe_streams--;

		if (!adev->num_probe_streams) {

			avs_dsp_delete_probe(adev);

			avs_dsp_enable_d0ix(adev);

		}

	}



	snd_hdac_stream_cleanup(hdac_stream(host_stream));

	hdac_stream(host_stream)->prepared = 0;

	snd_hdac_ext_stream_release(host_stream, HDAC_EXT_STREAM_TYPE_HOST);



	snd_compr_free_pages(cstream);

	adev->extractor = NULL;



	return ret;

}



static int avs_probe_compr_set_params(struct snd_compr_stream *cstream,

				      struct snd_compr_params *params, struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *host_stream = avs_compr_get_host_stream(cstream);

	struct snd_compr_runtime *rtd = cstream->runtime;

	struct avs_dev *adev = to_avs_dev(dai->dev);

	/* compr params do not store bit depth, default to S32_LE. */

	snd_pcm_format_t format = SNDRV_PCM_FORMAT_S32_LE;

	unsigned int format_val;

	int bps, ret;



	hdac_stream(host_stream)->bufsize = 0;

	hdac_stream(host_stream)->period_bytes = 0;

	hdac_stream(host_stream)->format_val = 0;

	cstream->dma_buffer.dev.type = SNDRV_DMA_TYPE_DEV_SG;

	cstream->dma_buffer.dev.dev = adev->dev;



	ret = snd_compr_malloc_pages(cstream, rtd->buffer_size);

	if (ret < 0)

		return ret;

	bps = snd_pcm_format_physical_width(format);

	if (bps < 0)

		return bps;

	format_val = snd_hdac_calc_stream_format(params->codec.sample_rate, params->codec.ch_out,

						 format, bps, 0);

	ret = snd_hdac_stream_set_params(hdac_stream(host_stream), format_val);

	if (ret < 0)

		return ret;

	ret = snd_hdac_stream_setup(hdac_stream(host_stream));

	if (ret < 0)

		return ret;



	hdac_stream(host_stream)->prepared = 1;



	if (!adev->num_probe_streams) {

		union avs_connector_node_id node_id;



		/* D0ix not allowed during probing. */

		ret = avs_dsp_disable_d0ix(adev);

		if (ret)

			return ret;



		node_id.vindex = hdac_stream(host_stream)->stream_tag - 1;

		node_id.dma_type = AVS_DMA_HDA_HOST_INPUT;



		ret = avs_dsp_init_probe(adev, node_id, rtd->dma_bytes);

		if (ret < 0) {

			dev_err(dai->dev, "probe init failed: %d\n", ret);

			avs_dsp_enable_d0ix(adev);

			return ret;

		}

	}



	adev->num_probe_streams++;

	return 0;

}



static int avs_probe_compr_trigger(struct snd_compr_stream *cstream, int cmd,

				   struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *host_stream = avs_compr_get_host_stream(cstream);

	struct avs_dev *adev = to_avs_dev(dai->dev);

	struct hdac_bus *bus = &adev->base.core;

	unsigned long cookie;



	if (!hdac_stream(host_stream)->prepared)

		return -EPIPE;



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

	case SNDRV_PCM_TRIGGER_RESUME:

		spin_lock_irqsave(&bus->reg_lock, cookie);

		snd_hdac_stream_start(hdac_stream(host_stream), true);

		spin_unlock_irqrestore(&bus->reg_lock, cookie);

		break;



	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_STOP:

		spin_lock_irqsave(&bus->reg_lock, cookie);

		snd_hdac_stream_stop(hdac_stream(host_stream));

		spin_unlock_irqrestore(&bus->reg_lock, cookie);

		break;



	default:

		return -EINVAL;

	}



	return 0;

}



static int avs_probe_compr_pointer(struct snd_compr_stream *cstream,

				   struct snd_compr_tstamp *tstamp, struct snd_soc_dai *dai)

{

	struct hdac_ext_stream *host_stream = avs_compr_get_host_stream(cstream);

	struct snd_soc_pcm_stream *pstream;



	pstream = &dai->driver->capture;

	tstamp->copied_total = hdac_stream(host_stream)->curr_pos;

	tstamp->sampling_rate = snd_pcm_rate_bit_to_rate(pstream->rates);



	return 0;

}



static int avs_probe_compr_copy(struct snd_soc_component *comp, struct snd_compr_stream *cstream,

				char __user *buf, size_t count)

{

	struct snd_compr_runtime *rtd = cstream->runtime;

	unsigned int offset, n;

	void *ptr;

	int ret;



	if (count > rtd->buffer_size)

		count = rtd->buffer_size;



	div_u64_rem(rtd->total_bytes_transferred, rtd->buffer_size, &offset);

	ptr = rtd->dma_area + offset;

	n = rtd->buffer_size - offset;



	if (count < n) {

		ret = copy_to_user(buf, ptr, count);

	} else {

		ret = copy_to_user(buf, ptr, n);

		ret += copy_to_user(buf + n, rtd->dma_area, count - n);

	}



	if (ret)

		return count - ret;

	return count;

}



__maybe_unused

static const struct snd_soc_cdai_ops avs_probe_dai_ops = {

	.startup = avs_probe_compr_open,

	.shutdown = avs_probe_compr_free,

	.set_params = avs_probe_compr_set_params,

	.trigger = avs_probe_compr_trigger,

	.pointer = avs_probe_compr_pointer,

};



__maybe_unused

static const struct snd_compress_ops avs_probe_compress_ops = {

	.copy = avs_probe_compr_copy,

};