Unverified Commit 756bbe42 authored by Peter Ujfalusi's avatar Peter Ujfalusi Committed by Mark Brown
Browse files

ASoC: SOF: Handle control change notification from firmware 



If the value/data associated with a control changes in SOF it will send a
notification (SOF_IPC_GLB_COMP_MSG with SOF_IPC_COMP_GET_VALUE/DATA).

We have support for binary volatile control type, but we might have
features where enum/switch/volume changes. Re-implementing everything as
volatile as well would be not much of a gain for several reasons:
- volatile controls would do an IPC all the time, regardless if there is a
  need or not.
- We still don't have notification which forces userspace to continuously
  poll.

When such notification arrives we use snd_ctl_notify_one() to signal
userspace about the change.

The kernel is prepared for two types of notification:
- the notification carries the new data for the control (num_elems != 0)
The new value/data is copied to the control's local data

- blank message about a change
The new flag for the scontrol (comp_data_dirty) is set and when next
time user space reads the value via the kcontrol's get callback we will
refresh the control's local data from the firmware.

Signed-off-by: default avatarPeter Ujfalusi <peter.ujfalusi@linux.intel.com>
Reviewed-by: default avatarKai Vehmanen <kai.vehmanen@linux.intel.com>
Reviewed-by: default avatarPierre-Louis Bossart <pierre-louis.bossart@linux.intel.com>
Reviewed-by: default avatarGuennadi Liakhovetski <guennadi.liakhovetski@linux.intel.com>
Tested-by: default avatarSeppo Ingalsuo <seppo.ingalsuo@linux.intel.com>
Link: https://lore.kernel.org/r/20210903114018.2962-1-peter.ujfalusi@linux.intel.com


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

sound/soc/sof/control.c

+186 −0
Original line number Diff line number Diff line
@@ -65,6 +65,40 @@ static inline u32 ipc_to_mixer(u32 value, u32 *volume_map, int size) 
	return i - 1;

}



static void snd_sof_refresh_control(struct snd_sof_control *scontrol)

{

	struct sof_ipc_ctrl_data *cdata = scontrol->control_data;

	struct snd_soc_component *scomp = scontrol->scomp;

	enum sof_ipc_ctrl_type ctrl_type;

	int ret;



	if (!scontrol->comp_data_dirty)

		return;



	if (!pm_runtime_active(scomp->dev))

		return;



	if (scontrol->cmd == SOF_CTRL_CMD_BINARY)

		ctrl_type = SOF_IPC_COMP_GET_DATA;

	else

		ctrl_type = SOF_IPC_COMP_GET_VALUE;



	/* set the ABI header values */

	cdata->data->magic = SOF_ABI_MAGIC;

	cdata->data->abi = SOF_ABI_VERSION;



	/* refresh the component data from DSP */

	scontrol->comp_data_dirty = false;

	ret = snd_sof_ipc_set_get_comp_data(scontrol, ctrl_type,

					    SOF_CTRL_TYPE_VALUE_CHAN_GET,

					    scontrol->cmd, false);

	if (ret < 0) {

		dev_err(scomp->dev, "error: failed to get control data: %d\n", ret);

		/* Set the flag to re-try next time to get the data */

		scontrol->comp_data_dirty = true;

	}

}



int snd_sof_volume_get(struct snd_kcontrol *kcontrol,

		       struct snd_ctl_elem_value *ucontrol)

{
@@ -74,6 +108,8 @@ int snd_sof_volume_get(struct snd_kcontrol *kcontrol, 
	struct sof_ipc_ctrl_data *cdata = scontrol->control_data;

	unsigned int i, channels = scontrol->num_channels;



	snd_sof_refresh_control(scontrol);



	/* read back each channel */

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

		ucontrol->value.integer.value[i] =
@@ -145,6 +181,8 @@ int snd_sof_switch_get(struct snd_kcontrol *kcontrol, 
	struct sof_ipc_ctrl_data *cdata = scontrol->control_data;

	unsigned int i, channels = scontrol->num_channels;



	snd_sof_refresh_control(scontrol);



	/* read back each channel */

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

		ucontrol->value.integer.value[i] = cdata->chanv[i].value;
@@ -195,6 +233,8 @@ int snd_sof_enum_get(struct snd_kcontrol *kcontrol, 
	struct sof_ipc_ctrl_data *cdata = scontrol->control_data;

	unsigned int i, channels = scontrol->num_channels;



	snd_sof_refresh_control(scontrol);



	/* read back each channel */

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

		ucontrol->value.enumerated.item[i] = cdata->chanv[i].value;
@@ -244,6 +284,8 @@ int snd_sof_bytes_get(struct snd_kcontrol *kcontrol, 
	struct sof_abi_hdr *data = cdata->data;

	size_t size;



	snd_sof_refresh_control(scontrol);



	if (be->max > sizeof(ucontrol->value.bytes.data)) {

		dev_err_ratelimited(scomp->dev,

				    "error: data max %d exceeds ucontrol data array size\n",
@@ -475,6 +517,8 @@ int snd_sof_bytes_ext_get(struct snd_kcontrol *kcontrol, 
		(struct snd_ctl_tlv __user *)binary_data;

	size_t data_size;



	snd_sof_refresh_control(scontrol);



	/*

	 * Decrement the limit by ext bytes header size to

	 * ensure the user space buffer is not exceeded.
@@ -511,3 +555,145 @@ int snd_sof_bytes_ext_get(struct snd_kcontrol *kcontrol, 


	return 0;

}



static void snd_sof_update_control(struct snd_sof_control *scontrol,

				   struct sof_ipc_ctrl_data *cdata)

{

	struct snd_soc_component *scomp = scontrol->scomp;

	struct sof_ipc_ctrl_data *local_cdata;

	int i;



	local_cdata = scontrol->control_data;



	if (cdata->cmd == SOF_CTRL_CMD_BINARY) {

		if (cdata->num_elems != local_cdata->data->size) {

			dev_err(scomp->dev,

				"error: cdata binary size mismatch %u - %u\n",

				cdata->num_elems, local_cdata->data->size);

			return;

		}



		/* copy the new binary data */

		memcpy(local_cdata->data, cdata->data, cdata->num_elems);

	} else if (cdata->num_elems != scontrol->num_channels) {

		dev_err(scomp->dev,

			"error: cdata channel count mismatch %u - %d\n",

			cdata->num_elems, scontrol->num_channels);

	} else {

		/* copy the new values */

		for (i = 0; i < cdata->num_elems; i++)

			local_cdata->chanv[i].value = cdata->chanv[i].value;

	}

}



void snd_sof_control_notify(struct snd_sof_dev *sdev,

			    struct sof_ipc_ctrl_data *cdata)

{

	struct snd_soc_dapm_widget *widget;

	struct snd_sof_control *scontrol;

	struct snd_sof_widget *swidget;

	struct snd_kcontrol *kc = NULL;

	struct soc_mixer_control *sm;

	struct soc_bytes_ext *be;

	size_t expected_size;

	struct soc_enum *se;

	bool found = false;

	int i, type;



	/* Find the swidget first */

	list_for_each_entry(swidget, &sdev->widget_list, list) {

		if (swidget->comp_id == cdata->comp_id) {

			found = true;

			break;

		}

	}



	if (!found)

		return;



	/* Translate SOF cmd to TPLG type */

	switch (cdata->cmd) {

	case SOF_CTRL_CMD_VOLUME:

	case SOF_CTRL_CMD_SWITCH:

		type = SND_SOC_TPLG_TYPE_MIXER;

		break;

	case SOF_CTRL_CMD_BINARY:

		type = SND_SOC_TPLG_TYPE_BYTES;

		break;

	case SOF_CTRL_CMD_ENUM:

		type = SND_SOC_TPLG_TYPE_ENUM;

		break;

	default:

		dev_err(sdev->dev, "error: unknown cmd %u\n", cdata->cmd);

		return;

	}



	widget = swidget->widget;

	for (i = 0; i < widget->num_kcontrols; i++) {

		/* skip non matching types or non matching indexes within type */

		if (widget->dobj.widget.kcontrol_type[i] == type &&

		    widget->kcontrol_news[i].index == cdata->index) {

			kc = widget->kcontrols[i];

			break;

		}

	}



	if (!kc)

		return;



	switch (cdata->cmd) {

	case SOF_CTRL_CMD_VOLUME:

	case SOF_CTRL_CMD_SWITCH:

		sm = (struct soc_mixer_control *)kc->private_value;

		scontrol = sm->dobj.private;

		break;

	case SOF_CTRL_CMD_BINARY:

		be = (struct soc_bytes_ext *)kc->private_value;

		scontrol = be->dobj.private;

		break;

	case SOF_CTRL_CMD_ENUM:

		se = (struct soc_enum *)kc->private_value;

		scontrol = se->dobj.private;

		break;

	default:

		return;

	}



	expected_size = sizeof(struct sof_ipc_ctrl_data);

	switch (cdata->type) {

	case SOF_CTRL_TYPE_VALUE_CHAN_GET:

	case SOF_CTRL_TYPE_VALUE_CHAN_SET:

		expected_size += cdata->num_elems *

				 sizeof(struct sof_ipc_ctrl_value_chan);

		break;

	case SOF_CTRL_TYPE_VALUE_COMP_GET:

	case SOF_CTRL_TYPE_VALUE_COMP_SET:

		expected_size += cdata->num_elems *

				 sizeof(struct sof_ipc_ctrl_value_comp);

		break;

	case SOF_CTRL_TYPE_DATA_GET:

	case SOF_CTRL_TYPE_DATA_SET:

		expected_size += cdata->num_elems + sizeof(struct sof_abi_hdr);

		break;

	default:

		return;

	}



	if (cdata->rhdr.hdr.size != expected_size) {

		dev_err(sdev->dev, "error: component notification size mismatch\n");

		return;

	}



	if (cdata->num_elems)

		/*

		 * The message includes the updated value/data, update the

		 * control's local cache using the received notification

		 */

		snd_sof_update_control(scontrol, cdata);

	else

		/* Mark the scontrol that the value/data is changed in SOF */

		scontrol->comp_data_dirty = true;



	snd_ctl_notify_one(swidget->scomp->card->snd_card,

			   SNDRV_CTL_EVENT_MASK_VALUE, kc, 0);

}

sound/soc/sof/ipc.c

+28 −0
Original line number Diff line number Diff line
@@ -369,6 +369,32 @@ void snd_sof_ipc_reply(struct snd_sof_dev *sdev, u32 msg_id) 
}

EXPORT_SYMBOL(snd_sof_ipc_reply);



static void ipc_comp_notification(struct snd_sof_dev *sdev,

				  struct sof_ipc_cmd_hdr *hdr)

{

	u32 msg_type = hdr->cmd & SOF_CMD_TYPE_MASK;

	struct sof_ipc_ctrl_data *cdata;



	switch (msg_type) {

	case SOF_IPC_COMP_GET_VALUE:

	case SOF_IPC_COMP_GET_DATA:

		cdata = kmalloc(hdr->size, GFP_KERNEL);

		if (!cdata)

			return;



		/* read back full message */

		snd_sof_ipc_msg_data(sdev, NULL, cdata, hdr->size);

		break;

	default:

		dev_err(sdev->dev, "error: unhandled component message %#x\n", msg_type);

		return;

	}



	snd_sof_control_notify(sdev, cdata);



	kfree(cdata);

}



/* DSP firmware has sent host a message  */

void snd_sof_ipc_msgs_rx(struct snd_sof_dev *sdev)

{
@@ -404,7 +430,9 @@ void snd_sof_ipc_msgs_rx(struct snd_sof_dev *sdev) 
	case SOF_IPC_GLB_COMPOUND:

	case SOF_IPC_GLB_TPLG_MSG:

	case SOF_IPC_GLB_PM_MSG:

		break;

	case SOF_IPC_GLB_COMP_MSG:

		ipc_comp_notification(sdev, &hdr);

		break;

	case SOF_IPC_GLB_STREAM_MSG:

		/* need to pass msg id into the function */

sound/soc/sof/sof-audio.h

+5 −0
Original line number Diff line number Diff line
@@ -75,6 +75,9 @@ struct snd_sof_control { 
	struct list_head list;	/* list in sdev control list */



	struct snd_sof_led_control led_ctl;



	/* if true, the control's data needs to be updated from Firmware */

	bool comp_data_dirty;

};



/* ASoC SOF DAPM widget */
@@ -148,6 +151,8 @@ int snd_sof_bytes_ext_get(struct snd_kcontrol *kcontrol, 
			  unsigned int size);

int snd_sof_bytes_ext_volatile_get(struct snd_kcontrol *kcontrol, unsigned int __user *binary_data,

				   unsigned int size);

void snd_sof_control_notify(struct snd_sof_dev *sdev,

			    struct sof_ipc_ctrl_data *cdata);



/*

 * Topology.