From: Pavel Artemev <a@pavel.bz>
To: Takashi Iwai <tiwai@suse.com>
Cc: Jaroslav Kysela <perex@perex.cz>,
linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org
Subject: [RFC PATCH v4 2/2] ALSA: usb-audio: add MIXER_STATE_REPUSH quirk flag
Date: Tue, 17 Nov 2026 19:42:42 +0700 [thread overview]
Message-ID: <20261117124242.12237-3-a@pavel.bz> (raw)
In-Reply-To: <20261117124242.12237-1-a@pavel.bz>
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. The
last writer owns the master: an explicit master put stops
derivation for that unit until user space writes one of its
channels again, so a value saved and restored by alsactl does
not pin the volume forever;
* 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. A resume re-push also re-asserts cached mute
switches, taking over the job restore_mixer_value() usually does
at resume: restore runs without the mixer lock, so writing the
deferred controls there could clobber values a concurrent
deferred put just recorded, and would re-send a derived master
from a cache that lags its channels.
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.
Re-push requests are lock-free atomic bits, because neither PM
callback may block on that lock: a control write inside a flush can
trigger the runtime resume whose callback then runs on the very
thread holding it. Suspend marks the mixer and cancels the flush
timer 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 - and a flush already running stops at the next unit, with
writes that failed mid-suspend kept pending for retry. Resume
requests a re-push and arms the worker without taking the lock; the
worker re-checks the request bits after every run, so a request
raised while it runs is never lost, and the disarm ordering against
disconnect (disconnected flag under the mixer lock before the
synchronizing cancel) keeps the teardown race-free.
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, as do
the caches of non-deferred controls on notification; 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, or at a
resume re-push: 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 each produced exactly one burst of one write per
channel in the master-first order, with no readbacks and no writes to
the capture unit. The changes over the previous revision are also
wire-verified against 7.3.4: a deferred put issued while the device
is runtime-suspended produces no bus traffic and its value is
delivered by the resume re-push, which re-asserts the cached volume
and mute controls; a stream-open re-push re-sends volumes only; an
explicit master put is followed again by derivation once user space
writes a channel of the unit; and the derived master equal to the
cached value is not re-sent (no endpoint notification without a user
arrival).
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/20261117092532.408981-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 | 510 ++++++++++++++++++++-
sound/usb/mixer.h | 19 +
sound/usb/pcm.c | 4 +
sound/usb/quirks.c | 2 +
sound/usb/usbaudio.h | 18 +
6 files changed, 543 insertions(+), 15 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..e9f256df7 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,18 +1618,342 @@ 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 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. The PM callbacks
+ * must not block on that lock, though: a control write inside a flush
+ * can trigger the runtime resume whose callback then runs on the very
+ * thread holding it. Re-push requests are therefore lock-free atomic
+ * bits; whoever cannot take the lock (the resume callback) only sets
+ * them and arms the worker, and the worker re-checks the bits after
+ * every run so no request is lost.
+ */
+
+/* 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)
+
+/* mixer->flush_flags bits */
+#define MIXER_FLUSH_FULL 0 /* re-push all cached volume values */
+#define MIXER_FLUSH_RESUME 1 /* resume: also re-assert cached mutes */
+#define MIXER_FLUSH_SUSPENDED 2 /* suspend in flight: stop writing */
+
+/* flush levels latched from the flags by the worker */
+enum {
+ FLUSH_TOUCHED, /* only channels user space changed */
+ FLUSH_FULL_STATE, /* plus every cached volume value */
+ FLUSH_RESUME_STATE, /* plus every cached mute switch */
+};
+
+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) {
+ /* keep the channel pending so the next
+ * flush (stream open, resume) retries it
+ */
+ set_bit(c + 1, cval->pending);
+ 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) {
+ set_bit(0, cval->pending);
+ 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.
+ * level FLUSH_FULL_STATE re-pushes every cached volume value (the
+ * stream-open heal); FLUSH_RESUME_STATE additionally re-asserts
+ * cached mute switches (restore_mixer_value() leaves them to the
+ * flush under this quirk, and nothing is playing yet at resume, so
+ * the write cannot chop a stream). Otherwise only the channels user
+ * space changed since the last flush are written. The master is
+ * written first and derived as the loudest cached channel - never
+ * asserted from its own (possibly stale) cache. An explicit master
+ * put owns the master until user space writes a channel of the unit
+ * 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 (or at
+ * resume re-push): 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,
+ int level)
+{
+ 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++) {
+ if (test_bit(MIXER_FLUSH_SUSPENDED, &mixer->flush_flags)) {
+ /* A suspend landed mid-run: stop writing (the
+ * writes would race the port suspend, and a
+ * failed one only stays pending anyway) and
+ * request the strongest re-push, which the
+ * resume path delivers.
+ */
+ set_bit(MIXER_FLUSH_RESUME, &mixer->flush_flags);
+ return;
+ }
+ 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 || level != FLUSH_TOUCHED) &&
+ (!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 && level != FLUSH_TOUCHED && !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 && cval->cmask &&
+ level != FLUSH_TOUCHED) {
+ bitmap_zero(cval->pending, MAX_CHANNELS + 1);
+ repush_ctl_cached(cval);
+ continue;
+ }
+ if (cval->control == UAC_FU_MUTE &&
+ level == FLUSH_RESUME_STATE) {
+ 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);
+ int level;
+
+ scoped_guard(mutex, &mixer->lock) {
+ level = FLUSH_TOUCHED;
+ if (test_and_clear_bit(MIXER_FLUSH_FULL,
+ &mixer->flush_flags))
+ level = FLUSH_FULL_STATE;
+ if (test_and_clear_bit(MIXER_FLUSH_RESUME,
+ &mixer->flush_flags))
+ level = FLUSH_RESUME_STATE;
+ if (mixer->disconnected)
+ return;
+ if (level != FLUSH_TOUCHED)
+ usb_audio_dbg(mixer->chip,
+ "re-pushing mixer state (level %d)\n",
+ level);
+ snd_usb_mixer_flush_pending(mixer, level);
+ }
+ /* A request may have arrived while we ran - from a stream open,
+ * or from the resume callback, which cannot take this lock (see
+ * the comment in snd_usb_mixer_resume()). Re-arm so it gets
+ * its own run; arming here is safe against teardown because the
+ * disconnect path cancels this work only after this function
+ * has returned. While suspended, the resume callback does the
+ * arming: re-arming here would only loop on failing writes.
+ */
+ if (!test_bit(MIXER_FLUSH_SUSPENDED, &mixer->flush_flags) &&
+ (test_bit(MIXER_FLUSH_FULL, &mixer->flush_flags) ||
+ test_bit(MIXER_FLUSH_RESUME, &mixer->flush_flags)))
+ mod_delayed_work(system_wq, &mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+}
+
/* 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) {
+ bool ch_put = false;
+
cnt = 0;
for (c = 0; c < MAX_CHANNELS; c++) {
if (!(cval->cmask & BIT(c)))
@@ -1632,14 +1966,50 @@ 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);
+ ch_put = true;
+ }
+ } else {
+ err = snd_usb_set_cur_mix_value(cval, c + 1,
+ cnt, val);
+ if (err < 0)
+ return filter_error(cval, err);
+ }
changed = 1;
}
cnt++;
}
+ /* The last writer owns the master: a channel write (the
+ * way audio servers drive this unit) re-claims master
+ * derivation, so a master saved and restored by e.g.
+ * alsactl does not pin the volume forever.
+ */
+ if (ch_put) {
+ struct usb_mixer_elem_list *ml;
+
+ for_each_mixer_elem(ml, cval->head.mixer,
+ cval->head.id) {
+ struct usb_mixer_elem_info *m =
+ mixer_elem_list_to_info(ml);
+
+ if (is_feature_volume_mute_ctl(m) &&
+ m->control == UAC_FU_VOLUME && !m->cmask)
+ m->master_explicit = false;
+ }
+ }
} else {
/* master channel */
err = snd_usb_get_cur_mix_value(cval, 0, 0, &oval);
@@ -1650,9 +2020,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 +3646,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 +4074,14 @@ 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 deferred controls
+ * own their cache as the host-side truth and are never
+ * invalidated
+ */
+ if (!info->get_cur_broken &&
+ !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH &&
+ is_feature_volume_mute_ctl(info)))
bitmap_zero(info->cached, MAX_CHANNELS + 1);
snd_ctl_notify(mixer->chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
&list->kctl->id);
@@ -3783,8 +4178,14 @@ 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
+ * deferred controls own their cache as the
+ * host-side truth and are never invalidated
+ */
+ if (!info->get_cur_broken &&
+ !(mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH &&
+ is_feature_volume_mute_ctl(info))) {
if (channel)
clear_bit(channel, info->cached);
else /* master channel */
@@ -3914,6 +4315,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,13 +4378,51 @@ void snd_usb_mixer_disconnect(struct usb_mixer_interface *mixer)
{
if (mixer->disconnected)
return;
+ /* Every mod_delayed_work() call site either holds this lock and
+ * re-checks ->disconnected inside it, or runs from a PM callback
+ * (which completes before the USB core calls driver->disconnect),
+ * or is the flush worker itself before it returns. Marking the
+ * mixer disconnected under the lock before cancelling therefore
+ * guarantees no flush can be armed after the cancel returns.
+ */
+ scoped_guard(mutex, &mixer->lock) {
+ mixer->disconnected = true;
+ }
+ cancel_delayed_work_sync(&mixer->flush_work);
if (mixer->urb)
usb_kill_urb(mixer->urb);
if (mixer->rc_urb)
usb_kill_urb(mixer->rc_urb);
if (mixer->private_free)
mixer->private_free(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) {
+ scoped_guard(mutex, &mixer->lock) {
+ if (mixer->disconnected)
+ continue;
+ set_bit(MIXER_FLUSH_FULL, &mixer->flush_flags);
+ mod_delayed_work(system_wq, &mixer->flush_work,
+ MIXER_FLUSH_DELAY);
+ }
+ }
}
/* stop any bus activity of a mixer */
@@ -4007,6 +4447,16 @@ 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
+ * and mark the mixer suspended; a flush already in flight stops
+ * at the next unit (failed writes keep their values pending),
+ * and the resume path re-pushes the complete state.
+ */
+ set_bit(MIXER_FLUSH_SUSPENDED, &mixer->flush_flags);
+ cancel_delayed_work(&mixer->flush_work);
snd_usb_mixer_inactivate(mixer);
if (mixer->private_suspend)
mixer->private_suspend(mixer);
@@ -4021,6 +4471,17 @@ static int restore_mixer_value(struct usb_mixer_elem_list *list)
if (cval->val_type == USB_MIXER_BESPOKEN)
return 0;
+ /* Deferred controls belong to the flush mechanism: restore runs
+ * without the mixer lock, so writing them here could clobber
+ * values a concurrent deferred put just recorded, and it would
+ * re-send a derived master from a cache that lags its channels.
+ * The resume path requests a re-push that re-derives and
+ * re-asserts all of them instead.
+ */
+ if (cval->head.mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH &&
+ is_feature_volume_mute_ctl(cval))
+ return 0;
+
if (cval->cmask) {
idx = 0;
for (c = 0; c < MAX_CHANNELS; c++) {
@@ -4067,6 +4528,25 @@ 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,
+ * and restore_mixer_value() leaves the deferred controls to the
+ * flush: request the re-push that re-derives and re-asserts all
+ * of them. No lock is taken here, not even trylock: a flush
+ * whose control write triggered this very resume holds the lock
+ * and must not be blocked or silently skipped - the worker
+ * re-checks the request bits after every run, so this never
+ * gets lost. Arming without the lock is safe against teardown:
+ * the USB core autoresumes the device before calling the
+ * driver's disconnect, so this callback always runs before the
+ * flush work is cancelled for good.
+ */
+ if (mixer->chip->quirk_flags & QUIRK_FLAG_MIXER_STATE_REPUSH) {
+ clear_bit(MIXER_FLUSH_SUSPENDED, &mixer->flush_flags);
+ set_bit(MIXER_FLUSH_RESUME, &mixer->flush_flags);
+ 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..813a1694c 100644
--- a/sound/usb/mixer.h
+++ b/sound/usb/mixer.h
@@ -41,6 +41,15 @@ struct usb_mixer_interface {
bool disconnected;
+ /* atomic write bursts (QUIRK_FLAG_MIXER_STATE_REPUSH) */
+ struct delayed_work flush_work;
+ /* flush requests, atomic bit ops only (see mixer.c):
+ * 0 - re-push all cached volume values at the next flush
+ * 1 - resume: also re-assert cached mute switches
+ * 2 - suspend in flight: stop writing, retry after resume
+ */
+ unsigned long flush_flags;
+
void *private_data;
void (*private_free)(struct usb_mixer_interface *mixer);
void (*private_suspend)(struct usb_mixer_interface *mixer);
@@ -95,6 +104,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 +146,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
prev parent reply other threads:[~2026-11-17 12:43 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-17 12:42 [RFC PATCH v4 0/2] ALSA: usb-audio: working hardware volume for XiiSound headsets (040b:0897) Pavel Artemev
2026-11-17 12:42 ` [RFC PATCH v4 1/2] ALSA: usb-audio: drive XiiSound playback volume instead of skipping it Pavel Artemev
2026-11-17 12:42 ` Pavel Artemev [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261117124242.12237-3-a@pavel.bz \
--to=a@pavel.bz \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-sound@vger.kernel.org \
--cc=perex@perex.cz \
--cc=tiwai@suse.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®