[RFC PATCH 12/16] ALSA: mixer_audient: Add a step size to integer controls

[Will Porter]

The iD14 level controls use s16 values in 1/256 dB. Expose them in
1 dB steps, matching the volume knob's adjustment. Let a control type
give a step size: the control then counts steps from the minimum, as
the generic USB mixer does with the RANGE resolution. A device value
between two steps reads as the nearest step, clamped to the maximum.
Types without a step size keep the device value.

Assisted-by: Claude:claude-opus-5-5
Signed-off-by: Will Porter <mrwillporter@xxxxxxxxx>
---
 sound/usb/mixer_audient.c | 55 ++++++++++++++++++++++++++++++---------
 1 file changed, 43 insertions(+), 12 deletions(-)

diff --git a/sound/usb/mixer_audient.c b/sound/usb/mixer_audient.c
index f15f96a8b7d2..c4ce2340f8bb 100644
--- a/sound/usb/mixer_audient.c
+++ b/sound/usb/mixer_audient.c
@@ -53,6 +53,7 @@ static const struct snd_audient_ctrl_type {
 		long integer;
 	} max;		/* for booleans holds physical int value for true */
 	u32 init;	/* hardware and cache are initialized to this value */
+	unsigned int res;	/* integers: device units per control step, 0 = 1 */
 	const unsigned int *tlv;
 	u8 unit;
 	u8 sel;
@@ -438,6 +439,39 @@ static int snd_ctl_audient_boolean_set(struct snd_kcontrol *kctl,
 	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.
+ */
+static long snd_audient_int_max(const struct snd_audient_ctrl_type *ctype)
+{
+	return ctype->res ? (ctype->max.integer - ctype->min.integer) / ctype->res
+			  : ctype->max.integer;
+}
+
+static long snd_audient_int_min(const struct snd_audient_ctrl_type *ctype)
+{
+	return ctype->res ? 0 : ctype->min.integer;
+}
+
+static long snd_audient_int_to_ctl(const struct snd_audient_ctrl_type *ctype,
+				   long val)
+{
+	val = clamp(val, ctype->min.integer, ctype->max.integer);
+	if (!ctype->res)
+		return val;
+
+	/* round a device value between two steps to the nearest one */
+	return min(DIV_ROUND_CLOSEST(val - ctype->min.integer, (long)ctype->res),
+		   snd_audient_int_max(ctype));
+}
+
+static long 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)
 {
@@ -470,17 +504,12 @@ static int snd_ctl_audient_integer_get(struct snd_kcontrol *kctl,
 		else if (ret < 0)
 			return ret;
 
-		if (val < ctype->min.integer)
-			val = ctype->min.integer;
-
-		if (val > ctype->max.integer)
-			val = ctype->max.integer;
-
-		ctl_val->value.integer.value[i] = val;
+		ctl_val->value.integer.value[i] =
+			snd_audient_int_to_ctl(ctype, val);
 	}
 
 	for (; i < nchan; i++)
-		ctl_val->value.integer.value[i] = ctype->min.integer;
+		ctl_val->value.integer.value[i] = snd_audient_int_min(ctype);
 
 	return 0;
 }
@@ -502,7 +531,8 @@ static int snd_ctl_audient_integer_set(struct snd_kcontrol *kctl,
 	for (i = 0; i < hwchan; i++) {
 		long val = ctl_val->value.integer.value[i];
 
-		if ((val < ctype->min.integer) || (val > ctype->max.integer))
+		if (val < snd_audient_int_min(ctype) ||
+		    val > snd_audient_int_max(ctype))
 			return -EINVAL;
 	}
 
@@ -513,7 +543,8 @@ static int snd_ctl_audient_integer_set(struct snd_kcontrol *kctl,
 	guard(mutex)(&mixer->lock);
 
 	for (i = 0; i < hwchan; i++) {
-		s32 val = ctl_val->value.integer.value[i];
+		s32 val = snd_audient_int_from_ctl(ctype,
+						   ctl_val->value.integer.value[i]);
 		int ret;
 
 		ret = snd_audient_raw_set_one(mixer, ctype,
@@ -542,8 +573,8 @@ static int snd_ctl_audient_info(struct snd_kcontrol *kctl,
 		uinfo->value.integer.min = 0;
 		uinfo->value.integer.max = 1;
 	} else {
-		uinfo->value.integer.min = ctype->min.integer;
-		uinfo->value.integer.max = ctype->max.integer;
+		uinfo->value.integer.min = snd_audient_int_min(ctype);
+		uinfo->value.integer.max = snd_audient_int_max(ctype);
 	}
 
 	return 0;
-- 
2.47.3