* [RFC PATCH v3 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897)
@ 2026-11-17 9:25 Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag Pavel Artemev
0 siblings, 2 replies; 4+ messages in thread
From: Pavel Artemev @ 2026-11-17 9:25 UTC (permalink / raw)
To: Takashi Iwai; +Cc: Jaroslav Kysela, linux-sound, linux-kernel
During a two-week campaign to make a Temple (XiiSound/Weltrend
040b:0897) wireless dongle audible I captured the complete control
traffic of the device on both Linux (usbmon) and the vendor's own
Windows 10 stack (USBPcap). This cover letter summarizes what the
wire says about this chipset, because it differs from the device model
encoded in the recently merged workaround, commit ba9bccdf711a
("ALSA: usb-audio: Skip broken playback feature unit on XiiSound
chips"), which is queued for 7.5.
To be clear up front: that commit fixes the user-visible bug (the
dongle coming up silent or one-eared), nothing here is a regression
report against it, and this RFC is not asking for its immediate
removal. It proposes the alternative I ended up running locally -
keep the playback feature unit exposed and make its hardware volume
work - and offers the captures as evidence, both for this design
discussion and for whoever debugs these devices next.
What the wire shows
===================
1. The playback feature unit is a working hardware volume. Per-
channel SET_CUR writes apply deterministically and independently
(a fast pair CN1<-50 + CN2<-100 applies exactly; a lone channel
write does not disturb its sibling), the master gates both ears
symmetrically, and intermediate values are audible and graded.
The vendor's Windows driver drives this exact unit on every slider
and hardware-button step, mapped linearly from its slider percent
(10% -> raw 9, 50% -> raw 49), and every intermediate value is
audible there too.
2. The "any volume below the maximum mutes one or both channels"
behaviour that motivated the skip is host-side, in three stacked
layers:
- the unit advertises a bogus 0.00..0.39 dB range, under which
every user-space volume at or below 0 dB - the whole normal
PipeWire range, 100% included - resolves to the raw minimum,
which does silence the channel;
- the stereo control's GET_CUR returns a constant value, so the
sticky-GET sanity check classifies it broken and the probe
writes the minimum to both channels at every mixer build;
- user space applies one logical volume change as fragmented
writes (one per channel, the first carrying the stale sibling
value), and the device silently drops control writes in the
first seconds after enumeration (measured: the window closes
6.5-9 s after enumeration, with a ragged tail), so a stale
channel can survive until some later write happens to refresh
it. The per-ear asymmetry users report is exactly this stale
state, not a channel-mapping property: under wire-verified
canonical writes the attenuation is symmetric (12/12 steps).
3. The Windows driver never reads back (GET_CUR is broken, so it
cannot), and does not need to: it keeps the whole channel picture
at a single source of truth, writes every channel of a control in
one short burst - master first - and re-pushes the complete state
at every device open. That every-open re-push is what repairs
whatever the enumeration window swallowed.
One consequence worth recording: the create-time pin writes of the
merged quirk sit inside the loss window and are dropped along with
every other early write. The dongle still comes up audible because
it powers up with every volume channel at the maximum - which is what
the pin intended to enforce anyway - and the resume re-pin added in
its v3 is the part that does real work. So the merged fix is sound
in effect; only its description of the hardware is not.
The RFC
=======
Patch 1 replaces the skip-and-pin with three quirk flags for
040b:0897: the new QUIRK_FLAG_MIXER_INIT_VOLUME_MAX (initialize the
channels of volume controls to the maximum instead of the minimum,
exactly where the broken-GET minimum writes happen) plus the existing
PLAYBACK/CAPTURE LINEAR_VOL flags (linear scale instead of the bogus
dB range). Hardware volume then behaves like on Windows.
Patch 2 adds QUIRK_FLAG_MIXER_STATE_REPUSH, which replicates the
vendor's write discipline for write-lossy devices: volume and mute
puts only record values, one deferred flush writes each touched
feature unit in a single canonical burst (master first, derived from
the loudest channel), and every PCM stream open re-pushes the full
cached state - the every-open repair the Windows stack relies on.
This is new mechanism territory (I found no prior proposal for write
batching or re-push in the archives), hence RFC.
Both ran as locally built DKMS modules - first against a 7.2 tree over
the wire-verified campaign, then this exact tree against 7.3.4 - and
in daily use; details in the commit messages.
Known limitations, stated for the record:
- Through the linear scale PipeWire applies its cubic, so the
mid-slider feel is quieter than on Windows (50% -> raw ~12).
Users who want the vendor loudness feel can set
api.alsa.soft-mixer = true - which is effectively what the merged
skip approach gives everyone. The value of this RFC is that the
choice stays with the user and the hardware volume keeps working
for stacks that do drive it.
- After a replug the device sits at its power-up state (maximum)
until the first write lands past the loss window; with patch 2 a
stream open re-pushes and heals, provided streams actually open
and close (a wedged PipeWire session that holds the device open
indefinitely defers the heal to the first user volume gesture).
- Hardware buttons keep stepping an internal device state that the
host cannot observe (no readback); neither approach - skip or
drive - syncs with the buttons.
I am happy to rework or drop either patch; the capture evidence is
offered independently of the design preference.
Changes in v3
=============
Thanks again to the sashiko AI review; everything it raised on this
patch is addressed:
- Suspend no longer waits for an in-flight flush worker. Its
control writes can be blocked in runtime-PM resume, waiting for
the suspend callback to finish, so cancel_delayed_work_sync()
there could deadlock the PM worker against the flush worker when
the device suspends while a flush is pending. The cancel is now
non-blocking; values recorded but not flushed stay in the cache
and resume requests a full re-push that re-derives and re-asserts
them (the resume path only trylocks the mixer lock, so a flush
whose write triggered the resume itself never blocks it).
- An explicit master put is sticky: derivation stops for that unit
once user space has set the master - the previous revision only
protected the value until the next full flush - and a full
re-push now re-asserts the value the user chose.
- Mixer unit controls are excluded from deferral: they share the
feature put callback but store a 1-based input channel number in
the selector field, which collides with the volume and mute
selector values (num_outputs is only ever set for mixer units).
- Read-only channels are neither written nor cached on the deferred
path, matching the direct write path (a shared helper keeps the
two from drifting).
- The stream-open flush log moved from info to debug level.
Not adopted: taking a runtime-PM reference for the whole flush and
pre-updating the master cache, as suggested for the stale-restore
finding. The reference does not close the underlying race (the flush
can still start while the device is suspending), and pre-setting the
master cache value would make the skip-equal guard suppress the master
write on the device-already-awake path, leaving a stale master
indefinitely.
Pavel Artemev (2):
ALSA: usb-audio: drive XiiSound playback volume instead of skipping it
ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
Documentation/sound/alsa-configuration.rst | 9 +
sound/usb/mixer.c | 410 ++++++++++++++++++++-
sound/usb/mixer.h | 14 +
sound/usb/mixer_maps.c | 19 -
sound/usb/mixer_quirks.c | 59 ---
sound/usb/pcm.c | 4 +
sound/usb/quirks.c | 7 +
sound/usb/usbaudio.h | 29 ++
8 files changed, 458 insertions(+), 93 deletions(-)
base-commit: f930156051f6a3dcd454ff723ca36b14d49650d2
--
2.56.1
^ permalink raw reply [flat|nested] 4+ messages in thread
* [RFC PATCH v3 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it
2026-11-17 9:25 [RFC PATCH v3 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897) Pavel Artemev
@ 2026-11-17 9:25 ` Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag Pavel Artemev
1 sibling, 0 replies; 4+ messages in thread
From: Pavel Artemev @ 2026-11-17 9:25 UTC (permalink / raw)
To: Takashi Iwai; +Cc: Jaroslav Kysela, linux-sound, linux-kernel
Replace the XiiSound (040b:0897) playback feature unit workaround from
commit ba9bccdf711a ("ALSA: usb-audio: Skip broken playback feature unit
on XiiSound chips") with quirk flags that keep the unit exposed and make
its hardware volume work.
Wire-level captures (usbmon on Linux, USBPcap on the vendor's own
Windows 10 stack) show the playback feature unit is functional as a
hardware volume: per-channel SET_CUR writes apply deterministically and
independently (a fast pair CN1<-50 + CN2<-100 applies exactly; a lone
channel write does not disturb its sibling), the master channel gates
both ears symmetrically, and intermediate values are audible and graded.
The vendor's Windows driver drives exactly this unit on every slider and
hardware-button step, writing all three channels with plain 0..100 raw
values mapped linearly from its slider.
The "any volume below the maximum mutes one or both channels" behaviour
that motivated the skip is host-side, not firmware:
* the unit advertises a bogus 0.00..0.39 dB range, under which every
user-space volume at or below 0 dB - the whole normal PipeWire
range, 100% included - resolves to the raw minimum, which silences
the channel;
* the stereo volume control's GET_CUR returns a constant value, so
the sanity check classifies it as broken and init_cur_mix_raw()
writes the minimum to both channels at every mixer build;
* user space applies one logical volume change as fragmented writes
(one per channel, the first carrying the stale sibling value), and
these devices silently drop control writes in the first seconds
after enumeration, so a channel can be left behind at a stale
value that no later write corrects.
Enable three quirk flags for 040b:0897. The new
QUIRK_FLAG_MIXER_INIT_VOLUME_MAX makes init_cur_mix_raw() initialize the
channels of volume controls to the maximum instead of the minimum: it
runs exactly where the broken-GET minimum writes would, supersedes them
(also when range discovery is deferred with -EAGAIN and initialization
repeats later from mixer_ctl_feature_info()), and touches nothing else -
controls whose GET_CUR works are read, not written, and switches keep
the safe unmuted minimum. The existing MIXER_PLAYBACK_LINEAR_VOL and
MIXER_CAPTURE_LINEAR_VOL replace the bogus dB scale with a linear one,
so user-space volumes map onto the full raw range. The controls stay
writable; hardware volume then behaves like on Windows.
The create-time pin writes of the previous quirk sit inside that
post-enumeration write-loss window and are dropped along with every
other early write; the device comes up audible after a plug only
because it powers up with every volume channel at the maximum, which
the explicit init reproduces if a write ever does land. No separate
resume re-pin is needed: with the controls created, the standard mixer
resume path restores the cached values.
Testing: the same flag combination ran on the device as a locally
built DKMS module against a 7.2 tree through a wire-level verification
campaign: the initialization writes were observed on the bus at every
mixer build, the full raw range became reachable from PipeWire (route
volumes 0/13/100 for 0.0/0.5/1.00), and mute and balance track. This
exact tree also ran on the device as a DKMS module against 7.3.4: the
broken-GET stereo control is initialized to the maximum in place of
the minimum, the other controls are read but not written, and the
linear raw mapping holds (route volume restores landed as 13/100/35
on the bus for 0.5/1.0/0.7).
Closes: https://github.com/alsa-project/alsa-ucm-conf/issues/760
Closes: https://github.com/linuxmint/linuxmint/issues/822
Link: https://bugzilla.kernel.org/show_bug.cgi?id=221401
Link: https://lore.kernel.org/linux-sound/20261116153521.188570-2-a@pavel.bz
Assisted-by: LLM
Signed-off-by: Pavel Artemev <a@pavel.bz>
---
Documentation/sound/alsa-configuration.rst | 4 ++
sound/usb/mixer.c | 13 ++++-
sound/usb/mixer_maps.c | 19 -------
sound/usb/mixer_quirks.c | 59 ----------------------
sound/usb/quirks.c | 5 ++
sound/usb/usbaudio.h | 11 ++++
6 files changed, 32 insertions(+), 79 deletions(-)
diff --git a/Documentation/sound/alsa-configuration.rst b/Documentation/sound/alsa-configuration.rst
index 689eccf6a..ea7f5aa31 100644
--- a/Documentation/sound/alsa-configuration.rst
+++ b/Documentation/sound/alsa-configuration.rst
@@ -2413,6 +2413,10 @@ quirk_flags
versa (same for 88200 <-> 96000 and 176400 <-> 192000). The driver
sends the partner rate in SET_CUR so the device ends up running at the
requested one.
+ * bit 34: ``mixer_init_volume_max``
+ Initialize the volume control channels to the maximum value instead
+ of the minimum at mixer creation. For devices that silence their
+ audio path while a volume channel sits at the minimum value.
This module supports multiple devices, autoprobe and hotplugging.
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index 95209ec00..bf1d9fbf0 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -1310,7 +1310,18 @@ static void init_cur_mix_raw(struct usb_mixer_elem_info *cval, int ch, int idx)
"%d:%d: failed to get current value for ch %d (%d)\n",
cval->head.id, mixer_ctrl_intf(cval->head.mixer),
ch, err);
- snd_usb_set_cur_mix_value(cval, ch, idx, cval->min);
+ /*
+ * QUIRK_FLAG_MIXER_INIT_VOLUME_MAX: some devices silence an audio
+ * path while a volume channel sits at the minimum value, so
+ * initialize those to the maximum instead. Only volume controls:
+ * for switches the minimum is the safe (unmuted) value.
+ */
+ if ((cval->head.mixer->chip->quirk_flags &
+ QUIRK_FLAG_MIXER_INIT_VOLUME_MAX) &&
+ cval->control == UAC_FU_VOLUME)
+ snd_usb_set_cur_mix_value(cval, ch, idx, cval->max);
+ else
+ snd_usb_set_cur_mix_value(cval, ch, idx, cval->min);
}
/*
diff --git a/sound/usb/mixer_maps.c b/sound/usb/mixer_maps.c
index 9218ca631..98b414621 100644
--- a/sound/usb/mixer_maps.c
+++ b/sound/usb/mixer_maps.c
@@ -374,20 +374,6 @@ static const struct usbmix_name_map dell_alc4020_map[] = {
{ 0 }
};
-/*
- * Weltrend XiiSound chips (040b:0897, e.g. Redragon H878):
- * the playback feature unit is broken; its volume controls act like
- * mute switches below the maximum value and the channel mapping is
- * unreliable, so any hardware volume change mutes one or both
- * channels. Skip the unit entirely and let userspace fall back to
- * software volume; the unit is pinned to maximum/unmuted by the
- * mixer quirk in mixer_quirks.c.
- */
-static const struct usbmix_name_map xiisound_map[] = {
- { 5, NULL }, /* playback feature unit */
- { 0 }
-};
-
/*
* Corsair Virtuoso calls everything "Headset" without this, leading to
* applications moving the sidetone control instead of the main one.
@@ -804,11 +790,6 @@ static const struct usbmix_ctl_map usbmix_ctl_maps[] = {
.id = USB_ID(0x1395, 0x0025),
.map = sennheiser_pc8_map,
},
- {
- /* Weltrend XiiSound (Redragon H878) */
- .id = USB_ID(0x040b, 0x0897),
- .map = xiisound_map,
- },
{
/* Microsoft USB Link headset */
.id = USB_ID(0x045e, 0x083c),
diff --git a/sound/usb/mixer_quirks.c b/sound/usb/mixer_quirks.c
index 4c7d68311..583971944 100644
--- a/sound/usb/mixer_quirks.c
+++ b/sound/usb/mixer_quirks.c
@@ -4603,59 +4603,6 @@ static int snd_audiofuse_controls_create(struct usb_mixer_interface *mixer)
return err;
}
-/*
- * Weltrend XiiSound chips (040b:0897, e.g. Redragon H878):
- * the playback feature unit (id 5) is broken; its volume controls act like
- * mute switches below the maximum value and the channel mapping is
- * unreliable, so the unit is hidden from userspace entirely (see the
- * quirk in mixer_maps.c) and userspace falls back to software volume.
- * Pin the unit's master and channel volumes to the reported maximum
- * and unmute them, so the audio path stays fully open.
- */
-static int snd_xiisound_init_fu_pins(struct usb_mixer_interface *mixer)
-{
- struct snd_usb_audio *chip = mixer->chip;
- unsigned char buf[2];
- int ifnum, ch, err;
-
- if (mixer->protocol != UAC_VERSION_1)
- return 0;
-
- ifnum = snd_usb_ctrl_intf(chip->ctrl_intf);
-
- /* unit 5 is the playback feature unit on these chips */
- for (ch = 0; ch <= 2; ch++) {
- err = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0),
- UAC_GET_MAX,
- USB_DIR_IN | USB_TYPE_CLASS |
- USB_RECIP_INTERFACE,
- (UAC_FU_VOLUME << 8) | ch,
- (5 << 8) | ifnum, buf, 2);
- if (err < 2)
- return 0; /* no such unit/channels, nothing to pin */
-
- err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
- UAC_SET_CUR,
- USB_DIR_OUT | USB_TYPE_CLASS |
- USB_RECIP_INTERFACE,
- (UAC_FU_VOLUME << 8) | ch,
- (5 << 8) | ifnum, buf, 2);
- if (err < 0)
- return err;
-
- buf[0] = 0; /* unmute */
- err = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0),
- UAC_SET_CUR,
- USB_DIR_OUT | USB_TYPE_CLASS |
- USB_RECIP_INTERFACE,
- (UAC_FU_MUTE << 8) | ch,
- (5 << 8) | ifnum, buf, 1);
- if (err < 0)
- return err;
- }
- return 0;
-}
-
int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
{
int err = 0;
@@ -4669,9 +4616,6 @@ int snd_usb_mixer_apply_create_quirk(struct usb_mixer_interface *mixer)
case USB_ID(0x0644, 0x8047):
err = snd_us16x08_controls_create(mixer);
break;
- case USB_ID(0x040b, 0x0897):
- err = snd_xiisound_init_fu_pins(mixer);
- break;
case USB_ID(0x041e, 0x3020):
case USB_ID(0x041e, 0x3040):
case USB_ID(0x041e, 0x3042):
@@ -4863,9 +4807,6 @@ void snd_usb_mixer_resume_quirk(struct usb_mixer_interface *mixer)
case USB_ID(0x0bda, 0x4014): /* Dell WD15 dock */
dell_dock_mixer_init(mixer);
break;
- case USB_ID(0x040b, 0x0897): /* Weltrend XiiSound (Redragon H878) */
- snd_xiisound_init_fu_pins(mixer);
- break;
}
}
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index a4eb0d0cd..6ef6d4410 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -2502,6 +2502,10 @@ static const struct usb_audio_quirk_flags_table quirk_flags_table[] = {
QUIRK_FLAG_FIXED_RATE),
DEVICE_FLG(0x03f0, 0x654a, /* HP 320 FHD Webcam */
QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_MIC_RES_16),
+ DEVICE_FLG(0x040b, 0x0897, /* XiiSound/Weltrend Temple and rebranded headsets */
+ QUIRK_FLAG_MIXER_INIT_VOLUME_MAX |
+ QUIRK_FLAG_MIXER_PLAYBACK_LINEAR_VOL |
+ QUIRK_FLAG_MIXER_CAPTURE_LINEAR_VOL),
DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */
QUIRK_FLAG_IGNORE_CTL_ERROR),
DEVICE_FLG(0x041e, 0x324d, /* Creative Sound Blaster Play! 3 */
@@ -2979,6 +2983,7 @@ static const char *const snd_usb_audio_quirk_flag_names[] = {
QUIRK_STRING_ENTRY(PLAYBACK_URB_FIXUP),
QUIRK_STRING_ENTRY(ALWAYS_SET_RATE),
QUIRK_STRING_ENTRY(SWAP_RATES),
+ QUIRK_STRING_ENTRY(MIXER_INIT_VOLUME_MAX),
NULL
};
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index c6d59218d..61794fdc4 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -262,6 +262,15 @@ extern bool snd_usb_skip_validation;
* The device applies a requested sample rate to the other base-rate family
* (44100 <-> 48000, 88200 <-> 96000, 176400 <-> 192000). Send the partner
* rate in SET_CUR so that the device runs at the requested rate.
+ * QUIRK_FLAG_MIXER_INIT_VOLUME_MAX
+ * A Feature Unit volume channel left at the minimum value silences its
+ * audio path on some devices; user space that does not write all
+ * channels of such a control would leave the device silent. Where
+ * GET_CUR is broken the kernel additionally discards the test values
+ * and initializes the channels to the minimum at every mixer build.
+ * Initialize the volume control channels to the maximum instead of
+ * the minimum; the controls remain writable and the hardware volume
+ * operates normally afterwards.
*/
enum {
@@ -299,6 +308,7 @@ enum {
QUIRK_TYPE_PLAYBACK_URB_FIXUP = 31,
QUIRK_TYPE_ALWAYS_SET_RATE = 32,
QUIRK_TYPE_SWAP_RATES = 33,
+ QUIRK_TYPE_MIXER_INIT_VOLUME_MAX = 34,
/* Please also edit snd_usb_audio_quirk_flag_names and alsa-configuration.rst */
};
@@ -338,5 +348,6 @@ enum {
#define QUIRK_FLAG_PLAYBACK_URB_FIXUP QUIRK_FLAG(PLAYBACK_URB_FIXUP)
#define QUIRK_FLAG_ALWAYS_SET_RATE QUIRK_FLAG(ALWAYS_SET_RATE)
#define QUIRK_FLAG_SWAP_RATES QUIRK_FLAG(SWAP_RATES)
+#define QUIRK_FLAG_MIXER_INIT_VOLUME_MAX QUIRK_FLAG(MIXER_INIT_VOLUME_MAX)
#endif /* __USBAUDIO_H */
--
2.56.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
2026-11-17 9:25 [RFC PATCH v3 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897) Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it Pavel Artemev
@ 2026-11-17 9:25 ` Pavel Artemev
2026-11-17 10:02 ` sashiko-bot
1 sibling, 1 reply; 4+ messages in thread
From: Pavel Artemev @ 2026-11-17 9:25 UTC (permalink / raw)
To: Takashi Iwai; +Cc: Jaroslav Kysela, linux-sound, linux-kernel
Some USB audio devices silently drop Feature Unit control writes in
the first seconds after USB enumeration, and occasionally drop
individual writes at any later time as well. When GET_CUR on such a
device is broken there is no way to detect the divergence by reading
back, so the state the host believes in silently drifts from the
hardware state: a channel left at a stale value is never corrected.
The Windows driver of one such chipset (Weltrend/XiiSound, 040b:0897)
handles this by never reading back at all. USBPcap captures of it
show a single source of truth for the whole channel picture, every
channel of a control written in one short burst - master first, then
the channels - and the complete state re-pushed at every device open.
That every-open re-push is the load-bearing mechanism: it repairs
whatever writes were swallowed around enumeration.
Add QUIRK_FLAG_MIXER_STATE_REPUSH, which replicates that write
discipline in the driver:
* volume and mute puts only record values; the cache is defined as
"what user space last asked for" and is never read back from the
device, and never invalidated by device status notifications;
* a single deferred flush (30 ms quiescence) writes each touched
feature unit in one burst, master first, derived as the loudest
channel - never asserted from its own possibly stale cache. An
explicit master put is sticky: once user space has set the master,
derivation stops for that unit and the master is only written
when user space puts it again;
* a PCM stream open and a resume re-push all cached volume values
through the same timer - the every-open repair the Windows stack
relies on.
The flush runs under the mixer lock, like the write path of the put
callback it replaces, so a put can never interleave with a burst.
The flush worker is cancelled synchronously on disconnect. On
suspend it is cancelled without waiting: a flush in flight may be
blocked in runtime-PM resume, waiting for the suspend callback to
finish, so waiting for it there would deadlock the PM worker against
the flush worker. Values recorded but not flushed stay in the cache;
the resume path then requests a full re-push that re-derives and
re-asserts them.
Only controls written through mixer_ctl_feature_put() with a volume
or mute selector are deferred. Mixer unit controls share that put
callback but store an input channel number in the selector field and
are excluded (num_outputs is only ever set for mixer units); other
feature unit controls (AGC, tone) keep the direct write path; and
read-only channels are neither written nor cached, matching the
direct write path. A derived master equal to the cached value is
not re-sent: an unchanged limit value re-delivered makes these
devices emit their in-headset limit notification with no user action
nearby. The residual gap - a sporadically dropped master write is
only healed by the next change, not by an unchanged re-push - is
accepted; the vendor driver has no readback either.
Mute switches are only written when user space changed them: a lost
re-assert can at worst fail to mute (power-up is unmuted), and mute
writes during playback audibly chop the stream on these devices.
Volume writes are delayed by the quiescence window, which is not
perceptible for a volume control.
The flag is enabled for 040b:0897, whose loss window was measured on
the wire at 6.5-9 s after enumeration with a ragged tail (beep-ACKed
limit-write probes at increasing delays).
Testing: ran on the device as a locally built DKMS module (7.2 tree,
daily use over 10 days) and wire-verified: 21 volume gestures produced
21 bursts of exactly one write per channel in the master-first order,
no readbacks, no re-sends; endpoint limit notifications fire only on
user arrivals at a limit; no stream chops during playback; replug,
suspend/resume, balance and mute pass end to end. The same mechanism
also ran on the device as a DKMS module against 7.3.4, wire-verified:
volume gestures (PipeWire 0.5/1.0/0.7) each produced exactly one
burst of one write per channel in the master-first order (13/100/35),
with no readbacks, no re-sends, and no writes to the capture unit.
The changes over the previous revision (suspend without waiting,
resume re-push, mixer unit and read-only exclusion, sticky explicit
master) are verified by analysis of the runtime-PM core semantics,
and ran on the device as a DKMS module against 7.3.4 with normal
operation, but are not yet re-verified on the wire.
Closes: https://github.com/alsa-project/alsa-ucm-conf/issues/760
Link: https://bugzilla.kernel.org/show_bug.cgi?id=221401
Link: https://lore.kernel.org/linux-sound/20261117074318.378876-3-a@pavel.bz
Assisted-by: LLM
Signed-off-by: Pavel Artemev <a@pavel.bz>
---
Documentation/sound/alsa-configuration.rst | 5 +
sound/usb/mixer.c | 397 ++++++++++++++++++++-
sound/usb/mixer.h | 14 +
sound/usb/pcm.c | 4 +
sound/usb/quirks.c | 2 +
sound/usb/usbaudio.h | 18 +
6 files changed, 426 insertions(+), 14 deletions(-)
diff --git a/Documentation/sound/alsa-configuration.rst b/Documentation/sound/alsa-configuration.rst
index ea7f5aa31..9b4b13969 100644
--- a/Documentation/sound/alsa-configuration.rst
+++ b/Documentation/sound/alsa-configuration.rst
@@ -2417,6 +2417,11 @@ quirk_flags
Initialize the volume control channels to the maximum value instead
of the minimum at mixer creation. For devices that silence their
audio path while a volume channel sits at the minimum value.
+ * bit 35: ``mixer_state_repush``
+ Defer volume and mute writes into one burst per feature unit, and
+ re-push the complete cached mixer state at every PCM stream open
+ and after resume. For devices that silently drop control writes
+ around enumeration and whose controls cannot be read back.
This module supports multiple devices, autoprobe and hotplugging.
diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
index bf1d9fbf0..2ac5a54a4 100644
--- a/sound/usb/mixer.c
+++ b/sound/usb/mixer.c
@@ -37,6 +37,7 @@
#include <linux/usb/audio.h>
#include <linux/usb/audio-v2.h>
#include <linux/usb/audio-v3.h>
+#include <linux/workqueue.h>
#include <sound/core.h>
#include <sound/control.h>
@@ -584,13 +585,22 @@ static int set_cur_ctl_value(struct usb_mixer_elem_info *cval,
return snd_usb_mixer_set_ctl_value(cval, UAC_SET_CUR, validx, value);
}
+/* read-only indication of one channel of a control (channel 0 = master);
+ * read-only channels are not written and not cached
+ */
+static unsigned int mixer_ch_readonly(const struct usb_mixer_elem_info *cval,
+ int channel)
+{
+ if (channel == 0)
+ return cval->master_readonly;
+ return cval->ch_readonly & BIT(channel - 1);
+}
+
int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
int index, int value)
{
int err;
- unsigned int read_only = (channel == 0) ?
- cval->master_readonly :
- cval->ch_readonly & BIT(channel - 1);
+ unsigned int read_only = mixer_ch_readonly(cval, channel);
if (read_only) {
usb_audio_dbg(cval->head.mixer->chip,
@@ -1608,15 +1618,275 @@ static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol,
return 0;
}
+/*
+ * Atomic mixer write bursts (QUIRK_FLAG_MIXER_STATE_REPUSH).
+ *
+ * Some devices silently drop mixer writes issued in the first seconds
+ * after USB enumeration, and can drop individual writes at any later
+ * time as well; GET_CUR is broken on them, so the divergence cannot
+ * be detected by reading back. The vendor's Windows driver never
+ * reads either: it collects the whole channel picture at a single
+ * source of truth and writes every channel of a control in one short
+ * burst (master first), re-pushing the complete state at every device
+ * open.
+ *
+ * User space applies one logical volume change as multiple fragmented
+ * control writes (one per channel, the first carrying stale siblings),
+ * so the stock write-per-put path cannot produce that burst. Puts
+ * therefore only record values - the cache is defined as "what user
+ * space last asked for" and is never read back from the device - and
+ * a single flush timer coalesces the fragments. When it fires, each
+ * touched feature unit is written in the Windows order: the master,
+ * derived as the loudest channel, first, then the changed channels,
+ * one write each. A stream open requests a full-state re-push
+ * (healing writes lost in the post-enumeration window), merged into
+ * the same timer so a burst never observes a half-applied gesture
+ * (user space opens streams mid-gesture for UI feedback sounds).
+ *
+ * The whole flush runs under the mixer lock, like the write path of
+ * the put callback it replaces: snd_usb_set_cur_mix_value() completes
+ * its USB transfer before updating the cache, so an unlocked flush
+ * could clobber values recorded concurrently by a put.
+ */
+
+/* quiescence window for the flush; user space applies a stereo change
+ * as two control writes 5..20 ms apart
+ */
+#define MIXER_FLUSH_DELAY msecs_to_jiffies(30)
+
+static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+
+static bool is_feature_volume_mute_ctl(struct usb_mixer_elem_info *cval)
+{
+ if (!cval->head.kctl || !cval->head.kctl->put)
+ return false;
+ /* the info callback is shared with processing unit controls, whose
+ * put writes through a different path and does not manage the
+ * shared cache; the put callback is unique to feature unit and
+ * mixer unit controls, which the cache does cover
+ */
+ if (cval->head.kctl->put != mixer_ctl_feature_put)
+ return false;
+ /* mixer unit controls share that put callback but store the
+ * 1-based input channel in cval->control, not a UAC_FU_* selector;
+ * num_outputs is only ever set for mixer units, so it tells the
+ * two apart
+ */
+ if (cval->num_outputs)
+ return false;
+ return cval->control == UAC_FU_VOLUME || cval->control == UAC_FU_MUTE;
+}
+
+/* Re-send every cached channel of one control, unchanged values
+ * included
+ */
+static void repush_ctl_cached(struct usb_mixer_elem_info *cval)
+{
+ int c, err, idx = 0;
+
+ if (cval->cmask) {
+ for (c = 0; c < MAX_CHANNELS; c++) {
+ if (!(cval->cmask & BIT_ULL(c)))
+ continue;
+ if (test_bit(c + 1, cval->cached)) {
+ err = snd_usb_set_cur_mix_value(cval, c + 1,
+ idx, cval->cache_val[idx]);
+ if (err < 0)
+ usb_audio_dbg(cval->head.mixer->chip,
+ "repush ctl %d ch %d failed (%d)\n",
+ cval->control, c + 1, err);
+ }
+ idx++;
+ }
+ } else {
+ /* master channel */
+ if (test_bit(0, cval->cached)) {
+ err = snd_usb_set_cur_mix_value(cval, 0, 0,
+ *cval->cache_val);
+ if (err < 0)
+ usb_audio_dbg(cval->head.mixer->chip,
+ "repush ctl %d ch 0 failed (%d)\n",
+ cval->control, err);
+ }
+ }
+}
+
+/* Write one control's pending (changed-since-last-flush) channels.
+ * Pending bits are only set together with cache_val by a put, so the
+ * value is written unconditionally; the cache bit may have been
+ * cleared under us, and snd_usb_set_cur_mix_value() sets it again.
+ */
+static void flush_ctl_pending(struct usb_mixer_elem_info *cval)
+{
+ int c, err, idx = 0;
+
+ for (c = 0; c < MAX_CHANNELS; c++) {
+ if (!(cval->cmask & BIT_ULL(c)))
+ continue;
+ if (test_bit(c + 1, cval->pending)) {
+ clear_bit(c + 1, cval->pending);
+ err = snd_usb_set_cur_mix_value(cval, c + 1,
+ idx, cval->cache_val[idx]);
+ if (err < 0)
+ usb_audio_dbg(cval->head.mixer->chip,
+ "flush ctl %d ch %d failed (%d)\n",
+ cval->control, c + 1, err);
+ }
+ idx++;
+ }
+ if (!cval->cmask && test_bit(0, cval->pending)) {
+ /* master channel */
+ clear_bit(0, cval->pending);
+ err = snd_usb_set_cur_mix_value(cval, 0, 0,
+ *cval->cache_val);
+ if (err < 0)
+ usb_audio_dbg(cval->head.mixer->chip,
+ "flush ctl %d ch 0 failed (%d)\n",
+ cval->control, err);
+ }
+}
+
+/*
+ * One atomic write burst per touched feature unit, Windows-style:
+ * full = re-push every cached volume value (the stream-open heal),
+ * otherwise only the channels user space changed since the last
+ * flush. The master is written first and derived as the loudest
+ * cached channel - never asserted from its own (possibly stale)
+ * cache. An explicit master put is sticky: once user space has set
+ * the master, derivation stops for that unit and the master is only
+ * written when user space puts it again; a lost write is healed by
+ * the next full re-push, the same residual accepted for derived
+ * masters below.
+ * The derived master is skipped when it already equals the cached
+ * value: re-sending an unchanged limit value makes these devices emit
+ * their in-headset limit notification with no user action nearby.
+ * Mute switches are only written when user space changed them: a
+ * lost re-assert can only fail to mute (power-up is unmuted), and
+ * mute writes during playback audibly chop the stream on these
+ * devices.
+ *
+ * Called with mixer->lock held.
+ */
+static void snd_usb_mixer_flush_pending(struct usb_mixer_interface *mixer,
+ bool full)
+{
+ struct usb_mixer_elem_list *list;
+ struct usb_mixer_elem_info *cval, *master;
+ int id, c, idx, max_val;
+ bool have_ch, touched, master_pending;
+
+ lockdep_assert_held(&mixer->lock);
+
+ if (mixer->disconnected)
+ return;
+
+ for (id = 0; id < MAX_ID_ELEMS; id++) {
+ master = NULL;
+ max_val = 0;
+ have_ch = false;
+ touched = false;
+ master_pending = false;
+ for_each_mixer_elem(list, mixer, id) {
+ cval = mixer_elem_list_to_info(list);
+ if (!is_feature_volume_mute_ctl(cval) ||
+ cval->control != UAC_FU_VOLUME)
+ continue;
+ if (!cval->cmask) {
+ if (!master) {
+ master = cval;
+ master_pending =
+ test_bit(0, cval->pending);
+ }
+ continue;
+ }
+ if (!bitmap_empty(cval->pending, MAX_CHANNELS + 1))
+ touched = true;
+ idx = 0;
+ for (c = 0; c < MAX_CHANNELS; c++) {
+ if (!(cval->cmask & BIT_ULL(c)))
+ continue;
+ if (test_bit(c + 1, cval->cached)) {
+ /* seed from the first cached value:
+ * raw volume ranges can be signed
+ * and all-negative
+ */
+ if (!have_ch ||
+ cval->cache_val[idx] > max_val)
+ max_val = cval->cache_val[idx];
+ have_ch = true;
+ }
+ idx++;
+ }
+ }
+ /* master first (the Windows burst order) */
+ if (master && !master_pending && !master->master_explicit &&
+ have_ch &&
+ (touched || full) &&
+ (!test_bit(0, master->cached) ||
+ *master->cache_val != max_val)) {
+ int err = snd_usb_set_cur_mix_value(master, 0, 0,
+ max_val);
+ if (err < 0)
+ usb_audio_dbg(mixer->chip,
+ "derive ctl %d ch 0 failed (%d)\n",
+ master->control, err);
+ }
+ if (master && full && !master_pending &&
+ (master->master_explicit || !have_ch))
+ /* user-owned master, or a unit without per-channel
+ * data: re-assert the cached master value
+ */
+ repush_ctl_cached(master);
+ for_each_mixer_elem(list, mixer, id) {
+ cval = mixer_elem_list_to_info(list);
+ if (!is_feature_volume_mute_ctl(cval))
+ continue;
+ if (cval->control == UAC_FU_VOLUME && full &&
+ cval->cmask) {
+ bitmap_zero(cval->pending, MAX_CHANNELS + 1);
+ repush_ctl_cached(cval);
+ continue;
+ }
+ if (!bitmap_empty(cval->pending, MAX_CHANNELS + 1))
+ flush_ctl_pending(cval);
+ }
+ }
+}
+
+static void snd_usb_mixer_flush_work(struct work_struct *work)
+{
+ struct usb_mixer_interface *mixer =
+ container_of(work, struct usb_mixer_interface,
+ flush_work.work);
+ bool full;
+
+ scoped_guard(mutex, &mixer->lock) {
+ full = mixer->flush_full;
+ mixer->flush_full = false;
+ if (mixer->disconnected)
+ return;
+ if (full)
+ usb_audio_dbg(mixer->chip,
+ "flushing mixer state (stream open)\n");
+ snd_usb_mixer_flush_pending(mixer, full);
+ }
+}
+
/* put the current value to feature/mixer unit */
static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct usb_mixer_elem_info *cval = snd_kcontrol_chip(kcontrol);
+ bool deferred;
int max_val;
int c, cnt, val, oval, err;
int changed = 0;
+ deferred = (cval->head.mixer->chip->quirk_flags &
+ QUIRK_FLAG_MIXER_STATE_REPUSH) &&
+ is_feature_volume_mute_ctl(cval);
+
guard(mutex)(&cval->head.mixer->lock);
max_val = get_max_exposed(cval);
if (cval->cmask) {
@@ -1632,10 +1902,27 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
return -EINVAL;
val = get_abs_value(cval, val);
if (oval != val) {
- err = snd_usb_set_cur_mix_value(cval, c + 1,
- cnt, val);
- if (err < 0)
- return filter_error(cval, err);
+ if (deferred) {
+ /* record only; one flush writes the
+ * whole unit in a single burst.
+ * Read-only channels keep the
+ * direct-path behaviour: no write,
+ * no cache update.
+ */
+ if (!mixer_ch_readonly(cval, c + 1)) {
+ set_bit(c + 1, cval->cached);
+ cval->cache_val[cnt] = val;
+ set_bit(c + 1, cval->pending);
+ mod_delayed_work(system_wq,
+ &cval->head.mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+ }
+ } else {
+ err = snd_usb_set_cur_mix_value(cval, c + 1,
+ cnt, val);
+ if (err < 0)
+ return filter_error(cval, err);
+ }
changed = 1;
}
cnt++;
@@ -1650,9 +1937,26 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
return -EINVAL;
val = get_abs_value(cval, val);
if (val != oval) {
- err = snd_usb_set_cur_mix_value(cval, 0, 0, val);
- if (err < 0)
- return filter_error(cval, err);
+ if (deferred) {
+ /* record only; one flush writes the whole
+ * unit in a single burst. Read-only
+ * masters keep the direct-path behaviour:
+ * no write, no cache update.
+ */
+ if (!mixer_ch_readonly(cval, 0)) {
+ set_bit(0, cval->cached);
+ cval->cache_val[0] = val;
+ set_bit(0, cval->pending);
+ cval->master_explicit = true;
+ mod_delayed_work(system_wq,
+ &cval->head.mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+ }
+ } else {
+ err = snd_usb_set_cur_mix_value(cval, 0, 0, val);
+ if (err < 0)
+ return filter_error(cval, err);
+ }
changed = 1;
}
}
@@ -3259,6 +3563,8 @@ static void snd_usb_mixer_free(struct usb_mixer_interface *mixer)
/* kill pending URBs */
snd_usb_mixer_disconnect(mixer);
+ cancel_delayed_work_sync(&mixer->flush_work);
+
/* Unregister controls first, snd_ctl_remove() frees the element */
if (mixer->id_elems) {
for (id = 0; id < MAX_ID_ELEMS; id++) {
@@ -3685,8 +3991,12 @@ void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
if (!list->is_std_info)
continue;
info = mixer_elem_list_to_info(list);
- /* invalidate cache, so the value is read from the device */
- if (!info->get_cur_broken)
+ /* invalidate cache, so the value is read from the device;
+ * under QUIRK_FLAG_MIXER_STATE_REPUSH the cache is the
+ * host-side truth and is never invalidated
+ */
+ if (!info->get_cur_broken &&
+ !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH))
bitmap_zero(info->cached, MAX_CHANNELS + 1);
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
&list->kctl->id);
@@ -3783,8 +4093,13 @@ static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
switch (attribute) {
case UAC2_CS_CUR:
- /* invalidate cache, so the value is read from the device */
- if (!info->get_cur_broken) {
+ /* invalidate cache, so the value is read from the
+ * device; under QUIRK_FLAG_MIXER_STATE_REPUSH the
+ * cache is the host-side truth and is never
+ * invalidated
+ */
+ if (!info->get_cur_broken &&
+ !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH)) {
if (channel)
clear_bit(channel, info->cached);
else /* master channel */
@@ -3914,6 +4229,7 @@ int snd_usb_create_mixer(struct snd_usb_audio *chip, int ctrlif)
if (!mixer)
return -ENOMEM;
mixer->chip = chip;
+ INIT_DELAYED_WORK(&mixer->flush_work, snd_usb_mixer_flush_work);
mixer->ignore_ctl_error = !!(chip->quirk_flags & QUIRK_FLAG_IGNORE_CTL_ERROR);
mixer->id_elems = kzalloc_objs(*mixer->id_elems, MAX_ID_ELEMS);
if (!mixer->id_elems) {
@@ -3976,6 +4292,7 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
{
if (mixer->disconnected)
return;
+ cancel_delayed_work_sync(&mixer->flush_work);
if (mixer->urb)
usb_kill_urb(mixer->urb);
if (mixer->rc_urb)
@@ -3985,6 +4302,34 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
mixer->disconnected = true;
}
+/**
+ * snd_usb_mixer_stream_opened - notify mixers of a PCM stream open
+ * @chip: the USB audio chip
+ *
+ * Called from the PCM open path. Devices flagged
+ * QUIRK_FLAG_MIXER_STATE_REPUSH request a full-state re-push (the
+ * vendor driver's every-open write pattern, healing writes swallowed
+ * in the post-enumeration loss window), merged into the flush timer
+ * so the burst never observes a half-applied gesture.
+ */
+void snd_usb_mixer_stream_opened(struct snd_usb_audio *chip)
+{
+ struct usb_mixer_interface *mixer;
+
+ if (!(chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH))
+ return;
+
+ list_for_each_entry(mixer, &chip->mixer_list, list) {
+ if (mixer->disconnected)
+ continue;
+ scoped_guard(mutex, &mixer->lock) {
+ mixer->flush_full = true;
+ mod_delayed_work(system_wq, &mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+ }
+ }
+}
+
/* stop any bus activity of a mixer */
static void snd_usb_mixer_inactivate(struct usb_mixer_interface *mixer)
{
@@ -4007,6 +4352,14 @@ static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
{
+ /* Do not wait for an in-flight flush here: its control writes can
+ * be blocked in runtime-PM resume, waiting for this very suspend
+ * callback to finish - cancel_delayed_work_sync() would deadlock
+ * the PM worker against the flush worker. Cancel without waiting;
+ * values recorded but not yet flushed stay in the cache, and the
+ * resume path requests a full re-push that re-derives them.
+ */
+ cancel_delayed_work(&mixer->flush_work);
snd_usb_mixer_inactivate(mixer);
if (mixer->private_suspend)
mixer->private_suspend(mixer);
@@ -4067,6 +4420,22 @@ int snd_usb_mixer_resume(struct usb_mixer_interface *mixer)
snd_usb_mixer_resume_quirk(mixer);
+ /* A suspend may have cancelled a flush that had not fired yet:
+ * the values are restored above, but a master derived only at
+ * flush time may lag behind its channels. Request a full
+ * re-push, which re-derives and re-asserts everything. The
+ * lock is only tried: an in-flight flush whose control write
+ * triggered this very resume holds it and already delivers the
+ * state, so there is nothing to re-arm in that case.
+ */
+ if (mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH &&
+ mutex_trylock(&mixer->lock)) {
+ mixer->flush_full = true;
+ mutex_unlock(&mixer->lock);
+ mod_delayed_work(system_wq, &mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+ }
+
return snd_usb_mixer_activate(mixer);
}
diff --git a/sound/usb/mixer.h b/sound/usb/mixer.h
index c40f83285..281dbfe1d 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -41,6 +41,10 @@ struct usb_mixer_interface {
bool disconnected;
+ /* atomic write bursts (QUIRK_FLAG_MIXER_STATE_REPUSH) */
+ struct delayed_work flush_work;
+ bool flush_full; /* full-state re-push requested at next flush */
+
void *private_data;
void (*private_free)(struct usb_mixer_interface *mixer);
void (*private_suspend)(struct usb_mixer_interface *mixer);
@@ -95,6 +99,14 @@ struct usb_mixer_elem_info {
int dBmin, dBmax;
DECLARE_BITMAP(cached, MAX_CHANNELS + 1);
int cache_val[MAX_CHANNELS];
+ /* channels changed since the last flush
+ * (QUIRK_FLAG_MIXER_STATE_REPUSH); same bit layout as cached
+ */
+ DECLARE_BITMAP(pending, MAX_CHANNELS + 1);
+ /* user space has put this master explicitly: stop deriving it from
+ * the channels (QUIRK_FLAG_MIXER_STATE_REPUSH)
+ */
+ bool master_explicit;
u8 initialized;
u8 min_mute;
u8 get_cur_broken;
@@ -129,6 +141,8 @@ int snd_usb_mixer_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer);
int snd_usb_mixer_resume(struct usb_mixer_interface *mixer);
+void snd_usb_mixer_stream_opened(struct snd_usb_audio *chip);
+
int snd_usb_set_cur_mix_value(struct usb_mixer_elem_info *cval, int channel,
int index, int value);
diff --git a/sound/usb/pcm.c b/sound/usb/pcm.c
index 57a26492d..ec8ad7bd7 100644
--- a/sound/usb/pcm.c
+++ b/sound/usb/pcm.c
@@ -24,6 +24,7 @@
#include "power.h"
#include "media.h"
#include "implicit.h"
+#include "mixer.h"
#define SUBSTREAM_FLAG_DATA_EP_STARTED 0
#define SUBSTREAM_FLAG_SYNC_EP_STARTED 1
@@ -1271,6 +1272,9 @@ static int snd_usb_pcm_open(struct snd_pcm_substream *substream)
if (ret < 0)
goto err_resume;
+ /* may re-push the cached mixer state (write-loss recovery) */
+ snd_usb_mixer_stream_opened(chip);
+
return 0;
err_resume:
diff --git a/sound/usb/quirks.c b/sound/usb/quirks.c
index 6ef6d4410..5328faa3d 100644
--- a/sound/usb/quirks.c
+++ b/sound/usb/quirks.c
@@ -2504,6 +2504,7 @@ static const struct usb_audio_quirk_flags_table quirk_flags_table[] = {
QUIRK_FLAG_GET_SAMPLE_RATE | QUIRK_FLAG_MIC_RES_16),
DEVICE_FLG(0x040b, 0x0897, /* XiiSound/Weltrend Temple and rebranded headsets */
QUIRK_FLAG_MIXER_INIT_VOLUME_MAX |
+ QUIRK_FLAG_MIXER_STATE_REPUSH |
QUIRK_FLAG_MIXER_PLAYBACK_LINEAR_VOL |
QUIRK_FLAG_MIXER_CAPTURE_LINEAR_VOL),
DEVICE_FLG(0x041e, 0x3000, /* Creative SB Extigy */
@@ -2984,6 +2985,7 @@ static const char *const snd_usb_audio_quirk_flag_names[] = {
QUIRK_STRING_ENTRY(ALWAYS_SET_RATE),
QUIRK_STRING_ENTRY(SWAP_RATES),
QUIRK_STRING_ENTRY(MIXER_INIT_VOLUME_MAX),
+ QUIRK_STRING_ENTRY(MIXER_STATE_REPUSH),
NULL
};
diff --git a/sound/usb/usbaudio.h b/sound/usb/usbaudio.h
index 61794fdc4..b530513a3 100644
--- a/sound/usb/usbaudio.h
+++ b/sound/usb/usbaudio.h
@@ -271,6 +271,22 @@ extern bool snd_usb_skip_validation;
* Initialize the volume control channels to the maximum instead of
* the minimum; the controls remain writable and the hardware volume
* operates normally afterwards.
+ * QUIRK_FLAG_MIXER_STATE_REPUSH
+ * Some devices silently drop mixer writes issued in the first seconds
+ * after USB enumeration, and can drop individual writes at any later
+ * time as well, so the state the host believes in never reaches the
+ * hardware (and GET_CUR is typically broken on these devices, so the
+ * divergence cannot be detected by reading back). The vendor's own
+ * Windows driver never reads back either: it collects the whole
+ * channel picture at a single source of truth and writes every
+ * channel of a control in one short burst, re-pushing the complete
+ * state at every device open. Record volume and mute control writes
+ * instead of issuing them directly, and write each touched feature
+ * unit in one burst from a deferred flush (the master volume first,
+ * derived from the loudest channel); a PCM stream open requests a
+ * full-state re-push through the same timer. Under this flag the
+ * cache holds what user space last asked for and is never invalidated
+ * by device status notifications.
*/
enum {
@@ -309,6 +325,7 @@ enum {
QUIRK_TYPE_ALWAYS_SET_RATE = 32,
QUIRK_TYPE_SWAP_RATES = 33,
QUIRK_TYPE_MIXER_INIT_VOLUME_MAX = 34,
+ QUIRK_TYPE_MIXER_STATE_REPUSH = 35,
/* Please also edit snd_usb_audio_quirk_flag_names and alsa-configuration.rst */
};
@@ -349,5 +366,6 @@ enum {
#define QUIRK_FLAG_ALWAYS_SET_RATE QUIRK_FLAG(ALWAYS_SET_RATE)
#define QUIRK_FLAG_SWAP_RATES QUIRK_FLAG(SWAP_RATES)
#define QUIRK_FLAG_MIXER_INIT_VOLUME_MAX QUIRK_FLAG(MIXER_INIT_VOLUME_MAX)
+#define QUIRK_FLAG_MIXER_STATE_REPUSH QUIRK_FLAG(MIXER_STATE_REPUSH)
#endif /* __USBAUDIO_H */
--
2.56.1
^ permalink raw reply related [flat|nested] 4+ messages in thread
* Re: [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
2026-11-17 9:25 ` [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag Pavel Artemev
@ 2026-11-17 10:02 ` sashiko-bot
0 siblings, 0 replies; 4+ messages in thread
From: sashiko-bot @ 2026-11-17 10:02 UTC (permalink / raw)
To: Pavel Artemev; +Cc: linux-sound
Thank you for your contribution! Sashiko AI review found 7 potential
issues to consider:
- [Medium] ALSA: usb-audio: stale master and mute writes in
snd_usb_mixer_resume()
- [Medium] ALSA: usb-audio: unlocked restore_mixer_value() clobbers
deferred puts
- [Medium] ALSA: usb-audio: mutex_trylock() in snd_usb_mixer_resume()
drops re-push
- [Medium] ALSA: usb-audio: sticky master_explicit breaks volume after
alsactl restore
- [Medium] ALSA: usb-audio: flush_work races with system suspend and
drops mute state
- [Medium] ALSA: usb-audio: race re-arming flush_work in
snd_usb_mixer_disconnect()
- [Low] ALSA: usb-audio: overly broad cache invalidation suppression on
notify
--
commit 111702616777f0f8b7d0639f8fa713f234292a2d
Author: Pavel Artemev <a@pavel.bz>
ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
This commit adds the QUIRK_FLAG_MIXER_STATE_REPUSH quirk flag to defer
Feature Unit volume and mute writes into coalesced master-first bursts and
re-push cached volume state on PCM stream open and resume, and enables it
for Weltrend/XiiSound (040b:0897) headsets.
Link: https://bugzilla.kernel.org/show_bug.cgi?id=221401
Link: https://lore.kernel.org/linux-sound/20261117074318.378876-3-a@pavel.bz
> diff --git a/sound/usb/mixer.c b/sound/usb/mixer.c
> index bf1d9fbf08aae..2ac5a54a40e4c 100644
> --- a/sound/usb/mixer.c
> +++ b/sound/usb/mixer.c
[ ... ]
> @@ -1608,15 +1618,275 @@ static int mixer_ctl_feature_get(struct snd_kcontrol *kcontrol,
> + /* master first (the Windows burst order) */
> + if (master && !master_pending && !master->master_explicit &&
> + have_ch &&
> + (touched || full) &&
> + (!test_bit(0, master->cached) ||
> + *master->cache_val != max_val)) {
> + int err = snd_usb_set_cur_mix_value(master, 0, 0,
> + max_val);
> + if (err < 0)
> + usb_audio_dbg(mixer->chip,
> + "derive ctl %d ch 0 failed (%d)\n",
> + master->control, err);
> + }
[Severity: Medium]
When snd_usb_mixer_flush_work() runs while the device is runtime-suspended,
does this snd_usb_set_cur_mix_value() call cause snd_usb_mixer_resume() to
write stale master and mute values before the burst is sent?
snd_usb_set_cur_mix_value() calls snd_usb_mixer_set_ctl_value() before
updating cval->cache_val[index]:
sound/usb/mixer.c:snd_usb_set_cur_mix_value() {
...
err = snd_usb_mixer_set_ctl_value(cval,
UAC_SET_CUR, (cval->control << 8) | channel,
value);
if (err < 0)
return err;
set_bit(channel, cval->cached);
cval->cache_val[index] = value;
return 0;
}
Inside snd_usb_mixer_set_ctl_value(), CLASS(snd_usb_lock, pm)(chip) calls
snd_usb_autoresume(), which synchronously runs snd_usb_mixer_resume() ->
restore_mixer_value() on every control before the master UAC_SET_CUR
transfer is issued. Because master->cache_val[0] still holds its old
pre-flush value, restore_mixer_value() writes the stale master value (which
can re-trigger the spurious limit notification or transiently attenuate the
output), writes cached UAC_FU_MUTE controls, and writes the channel volumes
before snd_usb_mixer_flush_pending() sends the newly derived master and
writes the pending channels a second time. The same stale master and mute
writes happen on resume after snd_usb_mixer_suspend() cancels a pending
flush_work.
Skipping controls matching is_feature_volume_mute_ctl(cval) in
restore_mixer_value() when QUIRK_FLAG_MIXER_STATE_REPUSH is set would let
the flush mechanism handle them exclusively.
[ ... ]
> @@ -1632,10 +1902,27 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
> return -EINVAL;
> val = get_abs_value(cval, val);
> if (oval != val) {
> - err = snd_usb_set_cur_mix_value(cval, c + 1,
> - cnt, val);
> - if (err < 0)
> - return filter_error(cval, err);
> + if (deferred) {
> + /* record only; one flush writes the
> + * whole unit in a single burst.
> + * Read-only channels keep the
> + * direct-path behaviour: no write,
> + * no cache update.
> + */
> + if (!mixer_ch_readonly(cval, c + 1)) {
> + set_bit(c + 1, cval->cached);
> + cval->cache_val[cnt] = val;
> + set_bit(c + 1, cval->pending);
> + mod_delayed_work(system_wq,
> + &cval->head.mixer->flush_work,
> + MIXER_FLUSH_DELAY);
> + }
> + } else {
> + err = snd_usb_set_cur_mix_value(cval, c + 1,
> + cnt, val);
> + if (err < 0)
> + return filter_error(cval, err);
> + }
> changed = 1;
> }
> cnt++;
[Severity: Medium]
Can a concurrent restore_mixer_value() during resume overwrite a new value
recorded here in cval->cache_val[cnt]?
Unlike the direct path, the deferred path in mixer_ctl_feature_put() does
not call snd_usb_lock_shutdown(), and restore_mixer_value() runs in
snd_usb_mixer_resume() without holding mixer->lock:
CPU0 CPU1
snd_usb_mixer_resume()
restore_mixer_value()
val = cval->cache_val[idx] (V1)
snd_usb_set_cur_mix_value(..., V1)
snd_usb_mixer_set_ctl_value()
mixer_ctl_feature_put()
mutex_lock(&mixer->lock)
cval->cache_val[idx] = V2
set_bit(c + 1, cval->pending)
mutex_unlock(&mixer->lock)
cval->cache_val[idx] = V1 <-- overwrites V2
When flush_work later runs flush_ctl_pending(), it writes the stale V1 back
to the device.
> @@ -1650,9 +1937,26 @@ static int mixer_ctl_feature_put(struct snd_kcontrol *kcontrol,
> return -EINVAL;
> val = get_abs_value(cval, val);
> if (val != oval) {
> - err = snd_usb_set_cur_mix_value(cval, 0, 0, val);
> - if (err < 0)
> - return filter_error(cval, err);
> + if (deferred) {
> + /* record only; one flush writes the whole
> + * unit in a single burst. Read-only
> + * masters keep the direct-path behaviour:
> + * no write, no cache update.
> + */
> + if (!mixer_ch_readonly(cval, 0)) {
> + set_bit(0, cval->cached);
> + cval->cache_val[0] = val;
> + set_bit(0, cval->pending);
> + cval->master_explicit = true;
> + mod_delayed_work(system_wq,
> + &cval->head.mixer->flush_work,
> + MIXER_FLUSH_DELAY);
> + }
> + } else {
> + err = snd_usb_set_cur_mix_value(cval, 0, 0, val);
> + if (err < 0)
> + return filter_error(cval, err);
> + }
> changed = 1;
> }
> }
[Severity: Medium]
Does setting cval->master_explicit = true permanently here break per-channel
volume control after alsactl store and alsactl restore?
For Feature Units with both master and per-channel volume controls,
parse_audio_feature_unit() creates both a per-channel kcontrol (index 0) and
a master kcontrol (index 1). When snd_usb_mixer_flush_pending() derives the
master volume from the channels (for example, 35 or 0),
snd_usb_set_cur_mix_value() stores that derived value in
master->cache_val[0]. On shutdown or unplug, alsactl store saves both
kcontrols; on the next boot or replug, init_cur_mix_raw() initializes the
master cache to cval->max (100) under QUIRK_FLAG_MIXER_INIT_VOLUME_MAX, and
alsactl restore writes the saved value back to index 1.
Because val != oval, that restore write sets cval->master_explicit = true.
From that point on, snd_usb_mixer_flush_pending() never derives the master
when PipeWire or PulseAudio adjusts the per-channel control, leaving the
hardware master pinned at the restored value (or silent if it was saved at
0).
[ ... ]
> @@ -3685,8 +3991,12 @@ void snd_usb_mixer_notify_id(struct usb_mixer_interface *mixer, int unitid)
> if (!list->is_std_info)
> continue;
> info = mixer_elem_list_to_info(list);
> - /* invalidate cache, so the value is read from the device */
> - if (!info->get_cur_broken)
> + /* invalidate cache, so the value is read from the device;
> + * under QUIRK_FLAG_MIXER_STATE_REPUSH the cache is the
> + * host-side truth and is never invalidated
> + */
> + if (!info->get_cur_broken &&
> + !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH))
> bitmap_zero(info->cached, MAX_CHANNELS + 1);
> snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
> &list->kctl->id);
> @@ -3783,8 +4093,13 @@ static void snd_usb_mixer_interrupt_v2(struct usb_mixer_interface *mixer,
>
> switch (attribute) {
> case UAC2_CS_CUR:
> - /* invalidate cache, so the value is read from the device */
> - if (!info->get_cur_broken) {
> + /* invalidate cache, so the value is read from the
> + * device; under QUIRK_FLAG_MIXER_STATE_REPUSH the
> + * cache is the host-side truth and is never
> + * invalidated
> + */
> + if (!info->get_cur_broken &&
> + !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH)) {
> if (channel)
> clear_bit(channel, info->cached);
> else /* master channel */
[Severity: Low]
Should the QUIRK_FLAG_MIXER_STATE_REPUSH check in snd_usb_mixer_notify_id()
and snd_usb_mixer_interrupt_v2() be restricted to
is_feature_volume_mute_ctl(info)? As written, it also suppresses cache
invalidation for non-deferred controls on the mixer (such as UAC2 clock
validity or other unit controls), causing their get callbacks to return
stale cached values after a device notification.
[ ... ]
> @@ -3976,6 +4292,7 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
> {
> if (mixer->disconnected)
> return;
> + cancel_delayed_work_sync(&mixer->flush_work);
> if (mixer->urb)
> usb_kill_urb(mixer->urb);
> if (mixer->rc_urb)
> @@ -3985,6 +4302,34 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
> mixer->disconnected = true;
> }
>
> +/**
> + * snd_usb_mixer_stream_opened - notify mixers of a PCM stream open
> + * @chip: the USB audio chip
> + *
> + * Called from the PCM open path. Devices flagged
> + * QUIRK_FLAG_MIXER_STATE_REPUSH request a full-state re-push (the
> + * vendor driver's every-open write pattern, healing writes swallowed
> + * in the post-enumeration loss window), merged into the flush timer
> + * so the burst never observes a half-applied gesture.
> + */
> +void snd_usb_mixer_stream_opened(struct snd_usb_audio *chip)
> +{
> + struct usb_mixer_interface *mixer;
> +
> + if (!(chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH))
> + return;
> +
> + list_for_each_entry(mixer, &chip->mixer_list, list) {
> + if (mixer->disconnected)
> + continue;
> + scoped_guard(mutex, &mixer->lock) {
> + mixer->flush_full = true;
> + mod_delayed_work(system_wq, &mixer->flush_work,
> + MIXER_FLUSH_DELAY);
> + }
> + }
> +}
[Severity: Medium]
Can mixer->flush_work be re-armed during teardown after
cancel_delayed_work_sync() has returned, leading to a use-after-free when
snd_usb_mixer_free() frees mixer?
In snd_usb_mixer_disconnect(), cancel_delayed_work_sync(&mixer->flush_work)
runs before mixer->disconnected is set to true, and in snd_usb_mixer_free()
it runs before snd_ctl_remove() unregisters the kcontrols. Meanwhile, the
deferred path in mixer_ctl_feature_put() neither calls
snd_usb_lock_shutdown() nor checks mixer->disconnected under mixer->lock:
CPU0 CPU1
snd_usb_mixer_free()
snd_usb_mixer_disconnect()
cancel_delayed_work_sync()
...
mixer->disconnected = true
cancel_delayed_work_sync()
mixer_ctl_feature_put()
mutex_lock(&mixer->lock)
mod_delayed_work(..., &mixer->flush_work, ...)
mutex_unlock(&mixer->lock)
snd_ctl_remove()
kfree(mixer)
snd_usb_mixer_flush_work()
mutex_lock(&mixer->lock) <-- use-after-free
snd_usb_mixer_stream_opened() also checks mixer->disconnected outside
mixer->lock, and snd_usb_mixer_resume() calls mod_delayed_work() outside
mixer->lock without checking mixer->disconnected. Setting
mixer->disconnected = true under mixer->lock before
cancel_delayed_work_sync(), and checking !mixer->disconnected under
mixer->lock at every mod_delayed_work() call site, would close this race.
> @@ -4007,6 +4352,14 @@ static int snd_usb_mixer_activate(struct usb_mixer_interface *mixer)
>
> int snd_usb_mixer_suspend(struct usb_mixer_interface *mixer)
> {
> + /* Do not wait for an in-flight flush here: its control writes can
> + * be blocked in runtime-PM resume, waiting for this very suspend
> + * callback to finish - cancel_delayed_work_sync() would deadlock
> + * the PM worker against the flush worker. Cancel without waiting;
> + * values recorded but not yet flushed stay in the cache, and the
> + * resume path requests a full re-push that re-derives them.
> + */
> + cancel_delayed_work(&mixer->flush_work);
> snd_usb_mixer_inactivate(mixer);
> if (mixer->private_suspend)
> mixer->private_suspend(mixer);
[Severity: Medium]
What happens if snd_usb_mixer_flush_work() is already executing when
system suspend calls snd_usb_mixer_suspend()?
During system suspend (or whenever chip->active is already non-zero),
snd_usb_autoresume() returns 0 without blocking in runtime PM. Because
cancel_delayed_work() does not wait for an executing work item,
snd_usb_mixer_flush_work() can continue issuing USB control transfers
concurrently with usb_suspend_both() suspending the device. In addition,
flush_ctl_pending() clears cval->pending before calling
snd_usb_set_cur_mix_value(); if a UAC_FU_MUTE write fails during suspend,
its pending bit is already cleared and the full re-push on resume will not
retry it because snd_usb_mixer_flush_pending() only calls
repush_ctl_cached() for UAC_FU_VOLUME controls.
> @@ -4067,6 +4420,22 @@ int snd_usb_mixer_resume(struct usb_mixer_interface *mixer)
>
> snd_usb_mixer_resume_quirk(mixer);
>
> + /* A suspend may have cancelled a flush that had not fired yet:
> + * the values are restored above, but a master derived only at
> + * flush time may lag behind its channels. Request a full
> + * re-push, which re-derives and re-asserts everything. The
> + * lock is only tried: an in-flight flush whose control write
> + * triggered this very resume holds it and already delivers the
> + * state, so there is nothing to re-arm in that case.
> + */
> + if (mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH &&
> + mutex_trylock(&mixer->lock)) {
> + mixer->flush_full = true;
> + mutex_unlock(&mixer->lock);
> + mod_delayed_work(system_wq, &mixer->flush_work,
> + MIXER_FLUSH_DELAY);
> + }
> +
> return snd_usb_mixer_activate(mixer);
> }
[Severity: Medium]
Can mutex_trylock(&mixer->lock) here fail when mixer->lock is held by a
caller that will not perform a full re-push, dropping the post-resume
recovery?
First, mixer_ctl_feature_get() and the deferred path of
mixer_ctl_feature_put() take mixer->lock without holding
snd_usb_lock_shutdown(), so either can hold mixer->lock on another CPU while
snd_usb_mixer_resume() runs. Second, non-deferred control callbacks (such
as mixer_ctl_feature_info() -> get_min_max_with_quirks()) take mixer->lock
before calling snd_usb_lock_shutdown() -> snd_usb_autoresume(), entering
snd_usb_mixer_resume() on the same thread with mixer->lock already held.
Third, even when snd_usb_mixer_flush_work() itself triggered the resume, it
already latched full = mixer->flush_full and cleared mixer->flush_full
before calling snd_usb_mixer_flush_pending():
sound/usb/mixer.c:snd_usb_mixer_flush_work() {
...
scoped_guard(mutex, &mixer->lock) {
full = mixer->flush_full;
mixer->flush_full = false;
if (mixer->disconnected)
return;
if (full)
usb_audio_dbg(mixer->chip,
"flushing mixer state (stream open)\n");
snd_usb_mixer_flush_pending(mixer, full);
}
}
If snd_usb_mixer_suspend() cancelled an earlier pending flush and a
single-channel put later started snd_usb_mixer_flush_work() with
full == false, the worker triggers runtime resume on its first USB write,
mutex_trylock(&mixer->lock) in snd_usb_mixer_resume() fails, and the worker
only flushes the single pending channel rather than a full re-push.
--
Sashiko AI review · https://sashiko.dev/#/patchset/20261117092532.408981-1-a@pavel.bz?part=2
^ permalink raw reply [flat|nested] 4+ messages in thread
end of thread, other threads:[~2026-11-17 10:02 UTC | newest]
Thread overview: 4+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-17 9:25 [RFC PATCH v3 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897) Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it Pavel Artemev
2026-11-17 9:25 ` [RFC PATCH v3 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag Pavel Artemev
2026-11-17 10:02 ` sashiko-bot
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox