Commit 85762e71 authored by Stephen Warren's avatar Stephen Warren Committed by Mark Brown
Browse files

ASoC: dapm: Implement mixer control sharing 



This is the equivalent of commit af46800b "ASoC: Implement mux control
sharing", but applied to mixers instead of muxes.

This allows a single control to affect multiple mixer widgets at once,
which is useful when there is a single set of register bits that affects
multiple mixers in HW, for example both the L and R mixers of a stereo
path.

Without this, you either:

1) End up with multiple controls that affect the same register bits, but
whose DAPM state falls out of sync with HW, since the DAPM state is only
updated for the specific control that is modified, and not for other
paths that are affected by the register bit(s).

2) False paths through DAPM, since you end up merging unconnected stereo
paths together into a single widget which hosts the single control, and
then branching back out again, thus conjoining the enable states of the
two input paths.

Now that the kcontrol creation logic is split out into a separate
function, dapm_create_or_share_mixmux_kcontrol(), also use that to
replace most of the body of dapm_new_mux(). This should produce no
functional change, but simply eliminates some mostly duplicated code.

Signed-off-by: default avatarStephen Warren <swarren@nvidia.com>
Signed-off-by: default avatarMark Brown <broonie@opensource.wolfsonmicro.com>
parent 8bb96604

sound/soc/soc-dapm.c

+136 −134
Original line number Diff line number Diff line
@@ -504,17 +504,27 @@ static int dapm_is_shared_kcontrol(struct snd_soc_dapm_context *dapm, 
	return 0;

}



/* create new dapm mixer control */

static int dapm_new_mixer(struct snd_soc_dapm_widget *w)

/*

 * Determine if a kcontrol is shared. If it is, look it up. If it isn't,

 * create it. Either way, add the widget into the control's widget list

 */

static int dapm_create_or_share_mixmux_kcontrol(struct snd_soc_dapm_widget *w,

	int kci, struct snd_soc_dapm_path *path)

{

	struct snd_soc_dapm_context *dapm = w->dapm;

	int i, ret = 0;

	size_t name_len, prefix_len;

	struct snd_soc_dapm_path *path;

	struct snd_card *card = dapm->card->snd_card;

	const char *prefix;

	size_t prefix_len;

	int shared;

	struct snd_kcontrol *kcontrol;

	struct snd_soc_dapm_widget_list *wlist;

	int wlistentries;

	size_t wlistsize;

	bool wname_in_long_name, kcname_in_long_name;

	size_t name_len;

	char *long_name;

	const char *name;

	int ret;



	if (dapm->codec)

		prefix = dapm->codec->name_prefix;
@@ -526,103 +536,141 @@ static int dapm_new_mixer(struct snd_soc_dapm_widget *w) 
	else

		prefix_len = 0;



	/* add kcontrol */

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



		/* match name */

		list_for_each_entry(path, &w->sources, list_sink) {



			/* mixer/mux paths name must match control name */

			if (path->name != (char *)w->kcontrol_news[i].name)

				continue;

	shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[kci],

					 &kcontrol);



			if (w->kcontrols[i]) {

				path->kcontrol = w->kcontrols[i];

				continue;

	if (kcontrol) {

		wlist = kcontrol->private_data;

		wlistentries = wlist->num_widgets + 1;

	} else {

		wlist = NULL;

		wlistentries = 1;

	}



	wlistsize = sizeof(struct snd_soc_dapm_widget_list) +

				    sizeof(struct snd_soc_dapm_widget *),

			wlist = kzalloc(wlistsize, GFP_KERNEL);

			wlistentries * sizeof(struct snd_soc_dapm_widget *);

	wlist = krealloc(wlist, wlistsize, GFP_KERNEL);

	if (wlist == NULL) {

				dev_err(dapm->dev,

					"ASoC: can't allocate widget list for %s\n",

		dev_err(dapm->dev, "ASoC: can't allocate widget list for %s\n",

			w->name);

		return -ENOMEM;

	}

			wlist->num_widgets = 1;

			wlist->widgets[0] = w;

	wlist->num_widgets = wlistentries;

	wlist->widgets[wlistentries - 1] = w;



			/* add dapm control with long name.

			 * for dapm_mixer this is the concatenation of the

			 * mixer and kcontrol name.

			 * for dapm_mixer_named_ctl this is simply the

			 * kcontrol name.

			 */

			name_len = strlen(w->kcontrol_news[i].name) + 1;

			if (w->id != snd_soc_dapm_mixer_named_ctl)

				name_len += 1 + strlen(w->name);

	if (!kcontrol) {

		if (shared) {

			wname_in_long_name = false;

			kcname_in_long_name = true;

		} else {

			switch (w->id) {

			case snd_soc_dapm_switch:

			case snd_soc_dapm_mixer:

				wname_in_long_name = true;

				kcname_in_long_name = true;

				break;

			case snd_soc_dapm_mixer_named_ctl:

				wname_in_long_name = false;

				kcname_in_long_name = true;

				break;

			case snd_soc_dapm_mux:

			case snd_soc_dapm_virt_mux:

			case snd_soc_dapm_value_mux:

				wname_in_long_name = true;

				kcname_in_long_name = false;

				break;

			default:

				kfree(wlist);

				return -EINVAL;

			}

		}



			path->long_name = kmalloc(name_len, GFP_KERNEL);

		if (wname_in_long_name && kcname_in_long_name) {

			name_len = strlen(w->name) - prefix_len + 1 +

				   strlen(w->kcontrol_news[kci].name) + 1;



			if (path->long_name == NULL) {

			long_name = kmalloc(name_len, GFP_KERNEL);

			if (long_name == NULL) {

				kfree(wlist);

				return -ENOMEM;

			}



			switch (w->id) {

			default:

				/* The control will get a prefix from

				 * the control creation process but

				 * we're also using the same prefix

				 * for widgets so cut the prefix off

				 * the front of the widget name.

			/*

			 * The control will get a prefix from the control

			 * creation process but we're also using the same

			 * prefix for widgets so cut the prefix off the

			 * front of the widget name.

			 */

				snprintf((char *)path->long_name, name_len,

					 "%s %s", w->name + prefix_len,

					 w->kcontrol_news[i].name);

				break;

			case snd_soc_dapm_mixer_named_ctl:

				snprintf((char *)path->long_name, name_len,

					 "%s", w->kcontrol_news[i].name);

				break;

			snprintf(long_name, name_len, "%s %s",

				 w->name + prefix_len,

				 w->kcontrol_news[kci].name);

			long_name[name_len - 1] = '\0';



			name = long_name;

		} else if (wname_in_long_name) {

			long_name = NULL;

			name = w->name + prefix_len;

		} else {

			long_name = NULL;

			name = w->kcontrol_news[kci].name;

		}



			((char *)path->long_name)[name_len - 1] = '\0';



			path->kcontrol = snd_soc_cnew(&w->kcontrol_news[i],

						      wlist, path->long_name,

		kcontrol = snd_soc_cnew(&w->kcontrol_news[kci], wlist, name,

					prefix);

			ret = snd_ctl_add(card, path->kcontrol);

		ret = snd_ctl_add(card, kcontrol);

		if (ret < 0) {

				dev_err(dapm->dev, "ASoC: failed to add widget"

					" %s dapm kcontrol %s: %d\n",

					w->name, path->long_name, ret);

			dev_err(dapm->dev,

				"ASoC: failed to add widget %s dapm kcontrol %s: %d\n",

				w->name, name, ret);

			kfree(wlist);

				kfree(path->long_name);

				path->long_name = NULL;

			kfree(long_name);

			return ret;

		}

			w->kcontrols[i] = path->kcontrol;



		path->long_name = long_name;

	}



	kcontrol->private_data = wlist;

	w->kcontrols[kci] = kcontrol;

	path->kcontrol = kcontrol;



	return 0;

}



/* create new dapm mixer control */

static int dapm_new_mixer(struct snd_soc_dapm_widget *w)

{

	int i, ret;

	struct snd_soc_dapm_path *path;



	/* add kcontrol */

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

		/* match name */

		list_for_each_entry(path, &w->sources, list_sink) {

			/* mixer/mux paths name must match control name */

			if (path->name != (char *)w->kcontrol_news[i].name)

				continue;



			if (w->kcontrols[i]) {

				path->kcontrol = w->kcontrols[i];

				continue;

			}



			ret = dapm_create_or_share_mixmux_kcontrol(w, i, path);

			if (ret < 0)

				return ret;

		}

	}



	return 0;

}



/* create new dapm mux control */

static int dapm_new_mux(struct snd_soc_dapm_widget *w)

{

	struct snd_soc_dapm_context *dapm = w->dapm;

	struct snd_soc_dapm_path *path = NULL;

	struct snd_kcontrol *kcontrol;

	struct snd_card *card = dapm->card->snd_card;

	const char *prefix;

	size_t prefix_len;

	struct snd_soc_dapm_path *path;

	int ret;

	struct snd_soc_dapm_widget_list *wlist;

	int shared, wlistentries;

	size_t wlistsize;

	const char *name;



	if (w->num_kcontrols != 1) {

		dev_err(dapm->dev,
@@ -631,65 +679,19 @@ static int dapm_new_mux(struct snd_soc_dapm_widget *w) 
		return -EINVAL;

	}



	shared = dapm_is_shared_kcontrol(dapm, w, &w->kcontrol_news[0],

					 &kcontrol);

	if (kcontrol) {

		wlist = kcontrol->private_data;

		wlistentries = wlist->num_widgets + 1;

	} else {

		wlist = NULL;

		wlistentries = 1;

	}

	wlistsize = sizeof(struct snd_soc_dapm_widget_list) +

		wlistentries * sizeof(struct snd_soc_dapm_widget *),

	wlist = krealloc(wlist, wlistsize, GFP_KERNEL);

	if (wlist == NULL) {

		dev_err(dapm->dev,

			"ASoC: can't allocate widget list for %s\n", w->name);

		return -ENOMEM;

	}

	wlist->num_widgets = wlistentries;

	wlist->widgets[wlistentries - 1] = w;



	if (!kcontrol) {

		if (dapm->codec)

			prefix = dapm->codec->name_prefix;

		else

			prefix = NULL;



		if (shared) {

			name = w->kcontrol_news[0].name;

			prefix_len = 0;

		} else {

			name = w->name;

			if (prefix)

				prefix_len = strlen(prefix) + 1;

			else

				prefix_len = 0;

	path = list_first_entry(&w->sources, struct snd_soc_dapm_path,

				list_sink);

	if (!path) {

		dev_err(dapm->dev, "ASoC: mux %s has no paths\n", w->name);

		return -EINVAL;

	}



		/*

		 * The control will get a prefix from the control creation

		 * process but we're also using the same prefix for widgets so

		 * cut the prefix off the front of the widget name.

		 */

		kcontrol = snd_soc_cnew(&w->kcontrol_news[0], wlist,

					name + prefix_len, prefix);

		ret = snd_ctl_add(card, kcontrol);

		if (ret < 0) {

			dev_err(dapm->dev, "ASoC: failed to add kcontrol %s: %d\n",

				w->name, ret);

			kfree(wlist);

	ret = dapm_create_or_share_mixmux_kcontrol(w, 0, path);

	if (ret < 0)

		return ret;

		}

	}



	kcontrol->private_data = wlist;



	w->kcontrols[0] = kcontrol;



	list_for_each_entry(path, &w->sources, list_sink)

		path->kcontrol = kcontrol;

		path->kcontrol = w->kcontrols[0];



	return 0;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE