[RFC V4 PATCH 13/19] ALSA: mixer_audient: Add enumerated controls

From: Christian Ruppert

Date: Sun Nov 15 2026 - 16:44:28 EST


From: Will Porter <mrwillporter@xxxxxxxxx>

The iD14 has selectors with a fixed set of device values: output
routing, mono mode, the iD key function, talkback source and the
digital input mode. Add an enumerated control type with a value list.

The item list has one item more than the values. A put cannot select
it. A get shows it for a device value outside the list, so a value set
by other means stays visible as such, not as a wrong item, and for a
write-only value that no write has confirmed.

Signed-off-by: Will Porter <mrwillporter@xxxxxxxxx>
---
sound/usb/mixer_audient.c | 126 ++++++++++++++++++++++++++++++++++++++
1 file changed, 126 insertions(+)

diff --git a/sound/usb/mixer_audient.c b/sound/usb/mixer_audient.c
index 771a45cf6b45..2e1d4809645f 100644
--- a/sound/usb/mixer_audient.c
+++ b/sound/usb/mixer_audient.c
@@ -42,6 +42,25 @@ static const DECLARE_TLV_DB_MINMAX_MUTE(snd_audient_tlv_mixer, -12800, 600);
#define SND_AUDIENT_CTYPE_FLAGS_GET_BROKEN BIT(2)
#define SND_AUDIENT_CTYPE_FLAGS_CACHE BIT(3)

+/*
+ * An enumerated control: item i sends values[i]. A get of a device value
+ * outside the list returns -EIO; it does not show a wrong item.
+ */
+struct snd_audient_enum {
+ const char *const *texts;
+ const u32 *values;
+ unsigned int items;
+};
+
+#define SND_AUDIENT_ENUM(name, texts_, ...) \
+ static const u32 name##_values[] = { __VA_ARGS__ }; \
+ static const struct snd_audient_enum name = { \
+ .texts = texts_, \
+ .values = name##_values, \
+ .items = ARRAY_SIZE(name##_values), \
+ }; \
+ static_assert(ARRAY_SIZE(texts_) == ARRAY_SIZE(name##_values))
+
static const struct snd_audient_ctrl_type {
snd_ctl_elem_type_t type;
unsigned long flags;
@@ -54,6 +73,7 @@ static const struct snd_audient_ctrl_type {
} 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 struct snd_audient_enum *enumeration;
const unsigned int *tlv;
u8 unit;
u8 sel;
@@ -537,12 +557,114 @@ static int snd_ctl_audient_integer_set(struct snd_kcontrol *kctl,
return changed;
}

+static unsigned int snd_audient_enum_item(const struct snd_audient_enum *e,
+ u32 value)
+{
+ unsigned int item;
+
+ for (item = 0; item < e->items; item++)
+ if (e->values[item] == value)
+ break;
+
+ return item; /* e->items: not in the list */
+}
+
+static int snd_ctl_audient_enum_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);
+
+ unsigned 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++) {
+ unsigned int item;
+ u32 val;
+ int ret;
+
+ ret = snd_audient_raw_get_one(elem, ctype, base + i, &val);
+ if (ret == -ENODATA) /* unknown write-only value: init */
+ val = ctype->init;
+ else if (ret < 0)
+ return ret;
+
+ item = snd_audient_enum_item(ctype->enumeration, val);
+ if (item >= ctype->enumeration->items)
+ return -EIO;
+
+ ctl_val->value.enumerated.item[i] = item;
+ }
+
+ 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)
+{
+ 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 struct snd_audient_enum *const e = ctype->enumeration;
+ const u8 base = snd_audient_kctl_cidxoffs(kctl);
+
+ unsigned int i;
+ int changed = 0;
+
+ for (i = 0; i < hwchan; i++)
+ if (ctl_val->value.enumerated.item[i] >= e->items)
+ 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++) {
+ const unsigned int item = ctl_val->value.enumerated.item[i];
+ int ret;
+
+ ret = snd_audient_raw_set_one(elem, ctype, base + i,
+ e->values[item], false);
+ if (ret < 0)
+ return ret;
+
+ if (ret)
+ changed = 1;
+ }
+
+ return changed;
+}
+
static int snd_ctl_audient_info(struct snd_kcontrol *kctl,
struct snd_ctl_elem_info *uinfo)
{
const struct snd_audient_ctrl_type *const ctype
= snd_audient_kctl_type(kctl);

+ if (ctype->type == SNDRV_CTL_ELEM_TYPE_ENUMERATED)
+ return snd_ctl_enum_info(uinfo, snd_audient_kctl_channels(kctl),
+ ctype->enumeration->items,
+ ctype->enumeration->texts);
+
uinfo->type = ctype->type;
uinfo->count = snd_audient_kctl_channels(kctl);

@@ -590,6 +712,10 @@ static int snd_audient_add_ctrl(struct usb_mixer_interface *mixer,
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;
}
--
2.56.1