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

Commit e65579e3 authored by Vaibhav Agarwal's avatar Vaibhav Agarwal Committed by Alex Elder
Browse files

greybus: audio: topology: Enable enumerated control support 



Added .get/.set callback and relevant changes in parser to enable
enumerated control support for kcontrols and DAPM widget controls.
Currently, it is limited to enumerated strings only.

Signed-off-by: default avatarVaibhav Agarwal <vaibhav.agarwal@linaro.org>
Reviewed-by: default avatarMark Greer <mark.greer@animalcreek.com>
Signed-off-by: default avatarAlex Elder <elder@linaro.org>
parent d4cd9daa

drivers/staging/greybus/audio_topology.c

+319 −39
Original line number Diff line number Diff line
@@ -77,6 +77,21 @@ static const char *gbaudio_map_controlid(struct gbaudio_module_info *module, 
	return NULL;

}



static int gbaudio_map_controlname(struct gbaudio_module_info *module,

				   const char *name)

{

	struct gbaudio_control *control;



	list_for_each_entry(control, &module->ctl_list, list) {

		if (!strncmp(control->name, name, NAME_SIZE))

			return control->id;

	}



	dev_warn(module->dev, "%s: missing in modules controls list\n", name);



	return -EINVAL;

}



static int gbaudio_map_wcontrolname(struct gbaudio_module_info *module,

				    const char *name)

{
@@ -116,6 +131,27 @@ static const char *gbaudio_map_widgetid(struct gbaudio_module_info *module, 
	return NULL;

}



const char **gb_generate_enum_strings(struct gbaudio_module_info *gb,

				      struct gb_audio_enumerated *gbenum)

{

	const char **strings;

	int i;

	__u8 *data;



	strings = devm_kzalloc(gb->dev, sizeof(char *) * gbenum->items,

			       GFP_KERNEL);

	data = gbenum->names;



	for (i = 0; i < gbenum->items; i++) {

		strings[i] = (const char *)data;

		while (*data != '\0')

			data++;

		data++;

	}



	return strings;

}



static int gbcodec_mixer_ctl_info(struct snd_kcontrol *kcontrol,

		     struct snd_ctl_elem_info *uinfo)

{
@@ -473,15 +509,125 @@ static int gbaudio_validate_kcontrol_count(struct gb_audio_widget *w) 
	return ret;

}



static int gbcodec_enum_ctl_get(struct snd_kcontrol *kcontrol,

				struct snd_ctl_elem_value *ucontrol)

{

	int ret, ctl_id;

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

	struct gb_audio_ctl_elem_value gbvalue;

	struct gbaudio_module_info *module;

	struct gbaudio_codec_info *gb = snd_soc_codec_get_drvdata(codec);



	module = find_gb_module(gb, kcontrol->id.name);

	if (!module)

		return -EINVAL;



	ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);

	if (ctl_id < 0)

		return -EINVAL;



	ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,

				      GB_AUDIO_INVALID_INDEX, &gbvalue);

	if (ret) {

		dev_err_ratelimited(codec->dev, "%d:Error in %s for %s\n", ret,

				    __func__, kcontrol->id.name);

		return ret;

	}



	ucontrol->value.enumerated.item[0] = gbvalue.value.enumerated_item[0];

	if (e->shift_l != e->shift_r)

		ucontrol->value.enumerated.item[1] =

			gbvalue.value.enumerated_item[1];



	return 0;

}



static int gbcodec_enum_ctl_put(struct snd_kcontrol *kcontrol,

				struct snd_ctl_elem_value *ucontrol)

{

	int ret, ctl_id;

	struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);

	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;

	struct gb_audio_ctl_elem_value gbvalue;

	struct gbaudio_module_info *module;

	struct gbaudio_codec_info *gb = snd_soc_codec_get_drvdata(codec);



	module = find_gb_module(gb, kcontrol->id.name);

	if (!module)

		return -EINVAL;



	ctl_id = gbaudio_map_controlname(module, kcontrol->id.name);

	if (ctl_id < 0)

		return -EINVAL;



	if (ucontrol->value.enumerated.item[0] > e->max - 1)

		return -EINVAL;

	gbvalue.value.enumerated_item[0] = ucontrol->value.enumerated.item[0];



	if (e->shift_l != e->shift_r) {

		if (ucontrol->value.enumerated.item[1] > e->max - 1)

			return -EINVAL;

		gbvalue.value.enumerated_item[1] =

			ucontrol->value.enumerated.item[1];

	}



	ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,

				      GB_AUDIO_INVALID_INDEX, &gbvalue);

	if (ret) {

		dev_err_ratelimited(codec->dev, "%d:Error in %s for %s\n", ret,

				    __func__, kcontrol->id.name);

	}



	return ret;

}



static int gbaudio_tplg_create_enum_kctl(struct gbaudio_module_info *gb,

					 struct snd_kcontrol_new *kctl,

					 struct gb_audio_control *ctl)

{

	struct soc_enum *gbe;

	struct gb_audio_enumerated *gb_enum;

	int i;



	gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);

	if (!gbe)

		return -ENOMEM;



	gb_enum = &ctl->info.value.enumerated;



	/* since count=1, and reg is dummy */

	gbe->max = gb_enum->items;

	gbe->texts = gb_generate_enum_strings(gb, gb_enum);



	/* debug enum info */

	dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gb_enum->items,

		 gb_enum->names_length);

	for (i = 0; i < gb_enum->items; i++)

		dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);



	*kctl = (struct snd_kcontrol_new)

		SOC_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_ctl_get,

			     gbcodec_enum_ctl_put);

	return 0;

}



static int gbaudio_tplg_create_kcontrol(struct gbaudio_module_info *gb,

					struct snd_kcontrol_new *kctl,

					struct gb_audio_control *ctl)

{

	int ret = 0;

	struct gbaudio_ctl_pvt *ctldata;



	switch (ctl->iface) {

	case SNDRV_CTL_ELEM_IFACE_MIXER:

		ctldata = devm_kzalloc(gb->dev, sizeof(struct gbaudio_ctl_pvt),

		switch (ctl->info.type) {

		case GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED:

			ret = gbaudio_tplg_create_enum_kctl(gb, kctl, ctl);

			break;

		default:

			ctldata = devm_kzalloc(gb->dev,

					       sizeof(struct gbaudio_ctl_pvt),

					       GFP_KERNEL);

			if (!ctldata)

				return -ENOMEM;
@@ -494,39 +640,157 @@ static int gbaudio_tplg_create_kcontrol(struct gbaudio_module_info *gb, 
				SOC_MIXER_GB(ctl->name, ctl->count, ctldata);

			ctldata = NULL;

			break;

		}

		break;

	default:

		return -EINVAL;

	}



	dev_dbg(gb->dev, "%s:%d control created\n", ctl->name, ctl->id);

	return ret;

}



static int gbcodec_enum_dapm_ctl_get(struct snd_kcontrol *kcontrol,

				     struct snd_ctl_elem_value *ucontrol)

{

	int ret, ctl_id;

	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);

	struct snd_soc_dapm_widget *widget = wlist->widgets[0];

	struct gbaudio_module_info *module;

	struct gb_audio_ctl_elem_value gbvalue;

	struct snd_soc_codec *codec = widget->codec;

	struct gbaudio_codec_info *gb = snd_soc_codec_get_drvdata(codec);

	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;



	module = find_gb_module(gb, kcontrol->id.name);

	if (!module)

		return -EINVAL;



	ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);

	if (ctl_id < 0)

		return -EINVAL;



	ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,

				      GB_AUDIO_INVALID_INDEX, &gbvalue);

	if (ret) {

		dev_err_ratelimited(codec->dev, "%d:Error in %s for %s\n", ret,

				    __func__, kcontrol->id.name);

		return ret;

	}



	ucontrol->value.enumerated.item[0] = gbvalue.value.enumerated_item[0];

	if (e->shift_l != e->shift_r)

		ucontrol->value.enumerated.item[1] =

			gbvalue.value.enumerated_item[1];



	return 0;

}



static const char * const gbtexts[] = {"Stereo", "Left", "Right"};

static int gbcodec_enum_dapm_ctl_put(struct snd_kcontrol *kcontrol,

				     struct snd_ctl_elem_value *ucontrol)

{

	int ret, wi, ctl_id;

	unsigned int val, mux, change;

	unsigned int mask;

	struct snd_soc_dapm_widget_list *wlist = snd_kcontrol_chip(kcontrol);

	struct snd_soc_dapm_widget *widget = wlist->widgets[0];

	struct gb_audio_ctl_elem_value gbvalue;

	struct gbaudio_module_info *module;

	struct snd_soc_codec *codec = widget->codec;

	struct gbaudio_codec_info *gb = snd_soc_codec_get_drvdata(codec);

	struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;



static const SOC_ENUM_SINGLE_DECL(

	module_apb1_rx_enum, GBCODEC_APB1_MUX_REG, 0, gbtexts);

	if (ucontrol->value.enumerated.item[0] > e->max - 1)

		return -EINVAL;



static const SOC_ENUM_SINGLE_DECL(

	module_mic_enum, GBCODEC_APB1_MUX_REG, 4, gbtexts);

	module = find_gb_module(gb, kcontrol->id.name);

	if (!module)

		return -EINVAL;



	ctl_id = gbaudio_map_wcontrolname(module, kcontrol->id.name);

	if (ctl_id < 0)

		return -EINVAL;



	change = 0;

	ret = gb_audio_gb_get_control(module->mgmt_connection, ctl_id,

				      GB_AUDIO_INVALID_INDEX, &gbvalue);

	if (ret) {

		dev_err_ratelimited(codec->dev, "%d:Error in %s for %s\n", ret,

				    __func__, kcontrol->id.name);

		return ret;

	}



	mux = ucontrol->value.enumerated.item[0];

	val = mux << e->shift_l;

	mask = e->mask << e->shift_l;



	if (gbvalue.value.enumerated_item[0] !=

	    ucontrol->value.enumerated.item[0]) {

		change = 1;

		gbvalue.value.enumerated_item[0] =

			ucontrol->value.enumerated.item[0];

	}



	if (e->shift_l != e->shift_r) {

		if (ucontrol->value.enumerated.item[1] > e->max - 1)

			return -EINVAL;

		val |= ucontrol->value.enumerated.item[1] << e->shift_r;

		mask |= e->mask << e->shift_r;

		if (gbvalue.value.enumerated_item[1] !=

		    ucontrol->value.enumerated.item[1]) {

			change = 1;

			gbvalue.value.enumerated_item[1] =

				ucontrol->value.enumerated.item[1];

		}

	}



	if (change) {

		ret = gb_audio_gb_set_control(module->mgmt_connection, ctl_id,

					      GB_AUDIO_INVALID_INDEX, &gbvalue);

		if (ret) {

			dev_err_ratelimited(codec->dev,

					    "%d:Error in %s for %s\n", ret,

					    __func__, kcontrol->id.name);

		}

		for (wi = 0; wi < wlist->num_widgets; wi++) {

			widget = wlist->widgets[wi];



			widget->value = val;

			widget->dapm->update = NULL;

			snd_soc_dapm_mux_update_power(widget, kcontrol, mux, e);

		}

	}



	return change;

}



static int gbaudio_tplg_create_enum_ctl(struct gbaudio_module_info *gb,

					struct snd_kcontrol_new *kctl,

					struct gb_audio_control *ctl)

{

	switch (ctl->id) {

	case 8:

		*kctl = (struct snd_kcontrol_new)

			SOC_DAPM_ENUM(ctl->name, module_apb1_rx_enum);

		break;

	case 9:

		*kctl = (struct snd_kcontrol_new)

			SOC_DAPM_ENUM(ctl->name, module_mic_enum);

		break;

	default:

		return -EINVAL;

	}

	struct soc_enum *gbe;

	struct gb_audio_enumerated *gb_enum;

	int i;



	gbe = devm_kzalloc(gb->dev, sizeof(*gbe), GFP_KERNEL);

	if (!gbe)

		return -ENOMEM;



	gb_enum = &ctl->info.value.enumerated;



	/* since count=1, and reg is dummy */

	gbe->max = gb_enum->items;

	gbe->texts = gb_generate_enum_strings(gb, gb_enum);



	/* debug enum info */

	dev_dbg(gb->dev, "Max:%d, name_length:%d\n", gb_enum->items,

		 gb_enum->names_length);

	for (i = 0; i < gb_enum->items; i++)

		dev_dbg(gb->dev, "src[%d]: %s\n", i, gbe->texts[i]);



	*kctl = (struct snd_kcontrol_new)

		SOC_DAPM_ENUM_EXT(ctl->name, *gbe, gbcodec_enum_dapm_ctl_get,

				  gbcodec_enum_dapm_ctl_put);

	return 0;

}
@@ -672,9 +936,17 @@ static int gbaudio_tplg_create_widget(struct gbaudio_module_info *module, 
		control->name = curr->name;

		control->wname = w->name;



		if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)

		if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {

			struct gb_audio_enumerated *gbenum =

				&curr->info.value.enumerated;



			csize = offsetof(struct gb_audio_control, info);

			csize += offsetof(struct gb_audio_ctl_elem_info, value);

			csize += offsetof(struct gb_audio_enumerated, names);

			csize += gbenum->names_length;

			control->texts = (const char * const *)

				curr->info.value.enumerated.names;

				gb_generate_enum_strings(module, gbenum);

		} else

			csize = sizeof(struct gb_audio_control);

		*w_size += csize;

		curr = (void *)curr + csize;
@@ -810,9 +1082,17 @@ static int gbaudio_tplg_process_kcontrols(struct gbaudio_module_info *module, 
		snprintf(curr->name, NAME_SIZE, "GB %d %s", module->dev_id,

			 temp_name);

		control->name = curr->name;

		if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED)

		if (curr->info.type == GB_AUDIO_CTL_ELEM_TYPE_ENUMERATED) {

			struct gb_audio_enumerated *gbenum =

				&curr->info.value.enumerated;



			csize = offsetof(struct gb_audio_control, info);

			csize += offsetof(struct gb_audio_ctl_elem_info, value);

			csize += offsetof(struct gb_audio_enumerated, names);

			csize += gbenum->names_length;

			control->texts = (const char * const *)

				curr->info.value.enumerated.names;

				gb_generate_enum_strings(module, gbenum);

		} else

			csize = sizeof(struct gb_audio_control);



		list_add(&control->list, &module->ctl_list);