[RFC V4 PATCH 18/19] ALSA: mixer_audient: Unify snd_audient_*_set/get functions for different types

[Christian Ruppert <arc@gmx.li>]

The set/get functions were originally type specific. With more and more
types needed we reached the threshold where it makes sense to merge them
into one function for get and one for set and handle the type differences
in a switch statement. Perform this merge to reduce code duplication.

Signed-off-by: Christian Ruppert <arc@gmx.li>
---
 sound/usb/mixer_audient.c | 294 ++++++++++++--------------------------
 1 file changed, 88 insertions(+), 206 deletions(-)

diff --git a/sound/usb/mixer_audient.c b/sound/usb/mixer_audient.c
index f144fc549c88..13940572de3f 100644
--- a/sound/usb/mixer_audient.c
+++ b/sound/usb/mixer_audient.c
@@ -683,83 +683,6 @@ static int snd_audient_raw_set_one(struct usb_mixer_elem_info *const elem,
 }
 
 
-static int snd_ctl_audient_boolean_get(struct snd_kcontrol *kctl,
-				       struct snd_ctl_elem_value *ctl_val)
-{
-	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
-	struct usb_mixer_interface *const mixer = elem->head.mixer;
-
-	const unsigned int nchan = snd_audient_kctl_channels(kctl);
-	const unsigned int hwchan = snd_audient_kctl_hwchannels(kctl);
-	const struct snd_audient_ctrl_type *const ctype
-						= snd_audient_kctl_type(kctl);
-	const u8 base = snd_audient_kctl_cidxoffs(kctl);
-
-	int i;
-
-	CLASS(snd_usb_lock, pm)(mixer->chip);
-	if (pm.err < 0)
-		return pm.err;
-	/* serializes the transfers and the cache, also between gets */
-	guard(mutex)(&mixer->lock);
-
-	for (i = 0; i < hwchan; i++) {
-		u32 buf;
-		int ret;
-
-		ret = snd_audient_raw_get_one(elem, ctype, base + i, &buf);
-		if (ret == -ENODATA)	/* unknown write-only value: off */
-			buf = ctype->min.integer;
-		else if (ret < 0)
-			return ret;
-
-		ctl_val->value.integer.value[i] = (buf == ctype->min.integer)
-						  ? false : true;
-	}
-
-	for (; i < nchan; i++)
-		ctl_val->value.integer.value[i] = 0;
-
-	return 0;
-}
-
-static int snd_ctl_audient_boolean_set(struct snd_kcontrol *kctl,
-				       struct snd_ctl_elem_value *ctl_val)
-{
-	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
-	struct usb_mixer_interface *const mixer = elem->head.mixer;
-
-	const unsigned int hwchan = snd_audient_kctl_hwchannels(kctl);
-	const struct snd_audient_ctrl_type *const ctype
-						= snd_audient_kctl_type(kctl);
-	const u8 base = snd_audient_kctl_cidxoffs(kctl);
-
-	int changed = 0;
-	int i;
-
-	CLASS(snd_usb_lock, pm)(mixer->chip);
-	if (pm.err < 0)
-		return pm.err;
-	/* serializes the transfers and the cache, also between gets */
-	guard(mutex)(&mixer->lock);
-
-	for (i = 0; i < hwchan; i++) {
-		u32 buf = ctl_val->value.integer.value[i] ? ctype->max.integer
-							  : ctype->min.integer;
-		int ret;
-
-		ret = snd_audient_raw_set_one(elem, ctype, base + i, buf,
-					      false);
-		if (ret < 0)
-			return ret;
-
-		if (ret)
-			changed = 1;
-	}
-
-	return changed;
-}
-
 /*
  * With a step size (res), an integer control counts steps from min:
  * 0 ... (max - min) / res. Without one it shows the device value.
@@ -778,8 +701,9 @@ snd_audient_int_min(const struct snd_audient_ctrl_type *ctype)
 }
 
 static long snd_audient_int_to_ctl(const struct snd_audient_ctrl_type *ctype,
-				   long val)
+				   u32 buf)
 {
+	s32 val = (s32)buf;
 	val = clamp(val, ctype->min.integer, ctype->max.integer);
 	if (!ctype->res)
 		return val;
@@ -789,96 +713,19 @@ static long snd_audient_int_to_ctl(const struct snd_audient_ctrl_type *ctype,
 		   snd_audient_int_max(ctype));
 }
 
-static inline long
+static inline u32
 snd_audient_int_from_ctl(const struct snd_audient_ctrl_type *ctype, long val)
 {
-	return ctype->res ? ctype->min.integer + val * ctype->res : val;
-}
-
-static int snd_ctl_audient_integer_get(struct snd_kcontrol *kctl,
-				   struct snd_ctl_elem_value *ctl_val)
-{
-	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
-	struct usb_mixer_interface *const mixer = elem->head.mixer;
-
-	const unsigned int nchan = snd_audient_kctl_channels(kctl);
-	const unsigned int hwchan = snd_audient_kctl_hwchannels(kctl);
-	const struct snd_audient_ctrl_type *const ctype
-						= snd_audient_kctl_type(kctl);
-	const u8 base = snd_audient_kctl_cidxoffs(kctl);
-
-	int i;
-
-	CLASS(snd_usb_lock, pm)(mixer->chip);
-	if (pm.err < 0)
-		return pm.err;
-	/* serializes the transfers and the cache, also between gets */
-	guard(mutex)(&mixer->lock);
-
-	for (i = 0; i < hwchan; i++) {
-		s32 val;
-		int ret;
-
-		ret = snd_audient_raw_get_one(elem, ctype, base + i, &val);
-		if (ret == -ENODATA)	/* unknown write-only value: minimum */
-			val = ctype->min.integer;
-		else if (ret < 0)
-			return ret;
+	s32 ret;
 
-		ctl_val->value.integer.value[i] =
-			snd_audient_int_to_ctl(ctype, val);
-	}
+	if (ctype->res)
+		ret = ctype->min.integer + val * ctype->res;
+	else
+		ret = val;
 
-	for (; i < nchan; i++)
-		ctl_val->value.integer.value[i] = snd_audient_int_min(ctype);
-
-	return 0;
+	return (u32)ret;
 }
 
-static int snd_ctl_audient_integer_set(struct snd_kcontrol *kctl,
-				   struct snd_ctl_elem_value *ctl_val)
-{
-	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
-	struct usb_mixer_interface *mixer = elem->head.mixer;
-
-	const unsigned int hwchan = snd_audient_kctl_hwchannels(kctl);
-	const struct snd_audient_ctrl_type *const ctype
-						= snd_audient_kctl_type(kctl);
-	const u8 base = snd_audient_kctl_cidxoffs(kctl);
-
-	int changed = 0;
-	int i;
-
-	for (i = 0; i < hwchan; i++) {
-		long val = ctl_val->value.integer.value[i];
-
-		if (val < snd_audient_int_min(ctype) ||
-		    val > snd_audient_int_max(ctype))
-			return -EINVAL;
-	}
-
-	CLASS(snd_usb_lock, pm)(mixer->chip);
-	if (pm.err < 0)
-		return pm.err;
-	/* serializes the transfers and the cache, also between gets */
-	guard(mutex)(&mixer->lock);
-
-	for (i = 0; i < hwchan; i++) {
-		s32 val = snd_audient_int_from_ctl(ctype,
-						   ctl_val->value.integer.value[i]);
-		int ret;
-
-		ret = snd_audient_raw_set_one(elem, ctype, base + i, val,
-					      false);
-		if (ret < 0)
-			return ret;
-
-		if (ret)
-			changed = 1;
-	}
-
-	return changed;
-}
 
 /* The item index of a device value, or -EIO if the value is not in the list */
 static int snd_audient_enum_item(const struct snd_audient_enum *e, u32 value)
@@ -892,8 +739,9 @@ static int snd_audient_enum_item(const struct snd_audient_enum *e, u32 value)
 	return -EIO;
 }
 
-static int snd_ctl_audient_enum_get(struct snd_kcontrol *kctl,
-				    struct snd_ctl_elem_value *ctl_val)
+
+static int snd_ctl_audient_get(struct snd_kcontrol *kctl,
+				       struct snd_ctl_elem_value *ctl_val)
 {
 	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
 	struct usb_mixer_interface *const mixer = elem->head.mixer;
@@ -904,7 +752,7 @@ static int snd_ctl_audient_enum_get(struct snd_kcontrol *kctl,
 						= snd_audient_kctl_type(kctl);
 	const u8 base = snd_audient_kctl_cidxoffs(kctl);
 
-	unsigned int i;
+	int i;
 
 	CLASS(snd_usb_lock, pm)(mixer->chip);
 	if (pm.err < 0)
@@ -912,32 +760,53 @@ static int snd_ctl_audient_enum_get(struct snd_kcontrol *kctl,
 	/* serializes the transfers and the cache, also between gets */
 	guard(mutex)(&mixer->lock);
 
-	for (i = 0; i < hwchan; i++) {
-		u32 val;
-		int item;
-		int ret;
+	for (i = 0; i < nchan; i++) {
+		u32 buf;
+		long ret;
 
-		ret = snd_audient_raw_get_one(elem, ctype, base + i, &val);
-		if (ret == -ENODATA)	/* unknown write-only value: init */
-			val = ctype->init;
+		ret = snd_audient_raw_get_one(elem, ctype, base + i, &buf);
+		if (ret == -ENODATA)	/* unknown write-only value: off */
+			buf = ctype->init;
 		else if (ret < 0)
 			return ret;
 
-		item = snd_audient_enum_item(ctype->enumeration, val);
-		if (item < 0)
-			return item;
-
-		ctl_val->value.enumerated.item[i] = item;
+		switch (ctype->type) {
+		case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+			if (i >= hwchan)
+				ctl_val->value.integer.value[i] = 0;
+			else if (buf == ctype->min.integer)
+				ctl_val->value.integer.value[i] = false;
+			else
+				ctl_val->value.integer.value[i] = true;
+			break;
+		case SNDRV_CTL_ELEM_TYPE_INTEGER:
+			if (i >= hwchan)
+				ctl_val->value.integer.value[i] =
+					snd_audient_int_min(ctype);
+			else
+				ctl_val->value.integer.value[i] =
+					snd_audient_int_to_ctl(ctype, buf);
+			break;
+		case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+			if (i >= hwchan) {
+				ctl_val->value.enumerated.item[i] = 0;
+			} else {
+				ret = snd_audient_enum_item(ctype->enumeration,
+							    buf);
+				if (ret < 0)
+					return ret;
+
+				ctl_val->value.enumerated.item[i] = ret;
+			}
+			break;
+		}
 	}
 
-	for (; i < nchan; i++)
-		ctl_val->value.enumerated.item[i] = 0;
-
 	return 0;
 }
 
-static int snd_ctl_audient_enum_set(struct snd_kcontrol *kctl,
-				    struct snd_ctl_elem_value *ctl_val)
+static int snd_ctl_audient_set(struct snd_kcontrol *kctl,
+			       struct snd_ctl_elem_value *ctl_val)
 {
 	struct usb_mixer_elem_info *const elem = snd_kcontrol_chip(kctl);
 	struct usb_mixer_interface *const mixer = elem->head.mixer;
@@ -945,15 +814,28 @@ static int snd_ctl_audient_enum_set(struct snd_kcontrol *kctl,
 	const unsigned int hwchan = snd_audient_kctl_hwchannels(kctl);
 	const struct snd_audient_ctrl_type *const ctype
 						= snd_audient_kctl_type(kctl);
-	const struct snd_audient_enum *const e = ctype->enumeration;
 	const u8 base = snd_audient_kctl_cidxoffs(kctl);
 
-	unsigned int i;
+	typeof(ctl_val->value) *const v = &ctl_val->value;
+	const struct snd_audient_enum *const e = ctype->enumeration;
+
 	int changed = 0;
+	int i;
 
-	for (i = 0; i < hwchan; i++)
-		if (ctl_val->value.enumerated.item[i] >= e->items)
-			return -EINVAL;
+
+	for (i = 0; i < hwchan; i++) {
+		switch (ctype->type) {
+		case SNDRV_CTL_ELEM_TYPE_INTEGER:
+			if (v->integer.value[i] < snd_audient_int_min(ctype) ||
+			    v->integer.value[i] > snd_audient_int_max(ctype))
+				return -EINVAL;
+			break;
+		case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+			if (v->enumerated.item[i] >= e->items)
+				return -EINVAL;
+			break;
+		}
+	}
 
 	CLASS(snd_usb_lock, pm)(mixer->chip);
 	if (pm.err < 0)
@@ -962,11 +844,25 @@ static int snd_ctl_audient_enum_set(struct snd_kcontrol *kctl,
 	guard(mutex)(&mixer->lock);
 
 	for (i = 0; i < hwchan; i++) {
-		const unsigned int item = ctl_val->value.enumerated.item[i];
+		u32 val;
 		int ret;
 
-		ret = snd_audient_raw_set_one(elem, ctype, base + i,
-					      e->values[item], false);
+		switch (ctype->type) {
+		case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+			val = v->integer.value[i] ? ctype->max.integer
+						  : ctype->min.integer;
+			break;
+		case SNDRV_CTL_ELEM_TYPE_INTEGER:
+			val = snd_audient_int_from_ctl(ctype,
+						       v->integer.value[i]);
+			break;
+		case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
+			val = e->values[v->enumerated.item[i]];
+			break;
+		}
+
+		ret = snd_audient_raw_set_one(elem, ctype, base + i, val,
+					      false);
 		if (ret < 0)
 			return ret;
 
@@ -1029,22 +925,8 @@ static int snd_audient_add_ctrl(struct usb_mixer_interface *mixer,
 			   : SNDRV_CTL_ELEM_ACCESS_VOLATILE)
 			| (ctype->tlv ? SNDRV_CTL_ELEM_ACCESS_TLV_READ : 0);
 
-	switch (ctype->type) {
-	case SNDRV_CTL_ELEM_TYPE_INTEGER:
-		knew.get = snd_ctl_audient_integer_get;
-		knew.put = snd_ctl_audient_integer_set;
-		break;
-	case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
-		knew.get = snd_ctl_audient_boolean_get;
-		knew.put = snd_ctl_audient_boolean_set;
-		break;
-	case SNDRV_CTL_ELEM_TYPE_ENUMERATED:
-		knew.get = snd_ctl_audient_enum_get;
-		knew.put = snd_ctl_audient_enum_set;
-		break;
-	default:
-		return -EINVAL;
-	}
+	knew.get = snd_ctl_audient_get;
+	knew.put = snd_ctl_audient_set;
 
 	elem = kzalloc_obj(*elem);
 	if (!elem)
-- 
2.56.1