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

From: Will Porter

Date: Fri Nov 06 2026 - 11:38:06 EST


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.

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

diff --git a/sound/usb/mixer_audient.c b/sound/usb/mixer_audient.c
index c4ce2340f8bb..3e6cd8981b4f 100644
--- a/sound/usb/mixer_audient.c
+++ b/sound/usb/mixer_audient.c
@@ -42,6 +42,27 @@ static const DECLARE_TLV_DB_MINMAX_MUTE(snd_audient_tlv_mixer, -12800, 600);
#define SND_AUDIENT_CTYPE_FLAGS_FORCE_SET BIT(2)
#define SND_AUDIENT_CTYPE_FLAGS_CACHE BIT(3)

+/*
+ * An enumerated control: item i sends values[i]. The texts have one item
+ * more than the values. A put cannot select that last item: a get shows it
+ * for a device value outside the list ("Other"), or for a write-only value
+ * that no write has confirmed ("Unknown").
+ */
+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) + 1)
+
static const struct snd_audient_ctrl_type {
snd_ctl_elem_type_t type;
unsigned long flags;
@@ -54,6 +75,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;
@@ -560,12 +582,116 @@ 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++) {
+ u32 val;
+ int ret;
+
+ ret = snd_audient_raw_get_one(mixer, ctype,
+ snd_audient_cache_slot(elem, i),
+ base + i, &val);
+ if (ret == -ENODATA) { /* unknown write-only value */
+ ctl_val->value.enumerated.item[i] =
+ ctype->enumeration->items;
+ continue;
+ } else if (ret < 0) {
+ return ret;
+ }
+
+ ctl_val->value.enumerated.item[i] =
+ snd_audient_enum_item(ctype->enumeration, val);
+ }
+
+ 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(mixer, ctype,
+ snd_audient_cache_slot(elem, i),
+ 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 + 1,
+ ctype->enumeration->texts);
+
uinfo->type = ctype->type;
uinfo->count = snd_audient_kctl_channels(kctl);

@@ -613,6 +739,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.47.3