From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mail-wm2-f12.google.com (mail-wm2-f12.google.com [74.125.225.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 71F3D47AF5D for ; Sat, 3 Oct 2026 19:42:10 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=74.125.225.140 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1791056534; cv=none; b=S6d9AQS0R62nXEd8OuUWVvQ/9NCwbUzGYbOTl9bS5gqrm00XBvPM6CG3ae3FUKABH1lBH/MMUP0W00DsBDmguXUCdQiKMuxjtzup7Xy56FULSa1z8bsvdgyRm8Q5u1wuzAo8sWqsDu0Ybc54Z9/ntLokC89cmOXvewrUKl2dOUQ= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1791056534; c=relaxed/simple; bh=47zjjG7TKOK+bhxjRPjwgfNYkloG0mT/+JCbSk2vMss=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=FGqjrQG0US2/LLFEtt0Xt+1yBf4jkHt4HpQyUY0A83HuiJm5KehP++kRn8eRjYVtpO5VhUjmHYvXjaNkQHPfoPXvsot5zojH2o89VMsfUUOM1xBNmmYFmSMI5exDdl4WqJmQ/hrEBA1UDKu0gwbQryTxjX7NWXMrLN3ayyYLZDo= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=Mzddq+fC; arc=none smtp.client-ip=74.125.225.140 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="Mzddq+fC" Received: by mail-wm2-f12.google.com with SMTP id 5b1f17b1804b1-49cd5462b69so4388025e9.1 for ; Sat, 03 Oct 2026 12:42:10 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1791056529; x=1791661329; darn=vger.kernel.org; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:cc:to:from:from:to:cc:subject :date:message-id:reply-to:content-type; bh=XmMO2G0+qJaCvhpxYJ0Dq1gwYWxAlewT/Pow/1rFR3Q=; b=Mzddq+fCpstPjNiwV7JxoFiWzGBgsH7EHryW7nqiq33ZvGTKpGJxkUoL3oAMpE3gM0 QgUrlVJJrXBOyBMPtHqZqUBMI0NbawS3JBdp0peW/3lxaHE0AK2XqtDELurvcD9UfmNp BBSV/z1tuo9g24LLj/SjermCKM8lOjKLJ+mq88PVvWvD7mbfal7wgdqf77NtB2/+n/e+ x3NzAwLdAsZ5Rz4TC/KdqE9WQJvL7KCA/TFWyyXnVCp3ewx3w361RPzTadMnSWOgSmx/ tTFfx/EwnxsTuiWt7x1NUslbRK0brJnVT31bWR3J0ne3+n/AkmUUw60Rr2Cq3rDK6acC B7EA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1791056529; x=1791661329; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:cc:to:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=XmMO2G0+qJaCvhpxYJ0Dq1gwYWxAlewT/Pow/1rFR3Q=; b=cixh4GpWDyOJLVB64c7wO5sm8oUtjvfseKKKid9Umw3CGxHouqDTFZsueIIsLVAWaX /b7M81DJ5x6y/SQe78yJ7OQU0XQmNGhN0gp/oBARl2HDMB+idNzmZmIDeSnzE+9K2Gsk Kx6TXhJc9ix0Z1hEy7yqc9B09HEMHksKE8tvoR1GWzQQ8ZLIcI69s9F/cpbjNyP5pS5B UuIynkcvxzwFZr4PrQCtVlPNZB0y51a4MWCeIbJtiYV9vv2RGDc6qlGsVIZPbrRCOPPW EEzN7hmdby9OYRKikeiGFL+ELtKRZpvq8/Qcnx0IhuH94Tq/dcbcYT6jN+S37W2jKa1w JmpA== X-Forwarded-Encrypted: i=1; AKwUvBzqhSQChx5Ju91NCqk4hXDGpI6xqtcUnc+9e2h0aSatyXLnlyY/KBGHNDiWb7yKWaThmg+7zMoO4RR9iNg=@vger.kernel.org X-Gm-Message-State: AFuF++lhKzXLAGoTSk0gs1covJ2Wm8TH6SqQWtCXXoW4/cJVaD+Zjrb9 uJzOqbPfe5pkkybYbDG4gPWpv8pXts47nif6F4bi6I85RHV5nfHABngO X-Gm-Gg: AYBFou1pMgh+y2qqIfWcbRshMkalOpRKxBmlbHkY/6GTc8FrweBNP/OqRmEf2zKU21s trEqDj8N2NWkldhWvzGh8lZUlCfOmFy/OT2PQ0Ur1yDThdm6E7VNzD6bgIF/Mg14ShBbfqVmU20 qkjZ4osqqAzbSBVB+HJ4upL9UVijtrfz7J1xElqxYFeVSpuwtfzriBUNO2wsz7cW5abbUPZRdoz Qs27SCqmCPVU1J7XNqyLLjTa2nlLE5tJRdJOx0uHSJI2LLfrl7C+NUYuZNsFBXbEt4bZad6hMo2 kGGADdSa9x3fuAKzzQ5cU6bS61JIVbcqKytkpCqpwZFcfFLfT9pzqRYpwNO329lpepWv16xrWZG hFMN1UVlk5UtaskAmMuNuBx3ALebm9+bmZMfnno1gKGKdOK7IQsTjcuJNPuTdFtHXztEbpkNHvU ZQlqt3z+jTRWyn1vZ7fln7ktH2BBlI6YCSwcj0zjsnePTGZGJk7WNhZqMPPVaAvnAtwnXLe/NPg 7Jrug4jBXOgOHRlLPJxKlXrbdyYiw9lGKj70FkzwP8AZ88NgUrZBp4xD21KNC897NnN3LMzA5tN l0sU7GJ9h3wZOCF49RjlgrVx X-Received: by 2002:a05:600c:b85:b0:4a0:313:3a12 with SMTP id 5b1f17b1804b1-4a02759b47amr102124795e9.20.1791056528299; Sat, 03 Oct 2026 12:42:08 -0700 (PDT) Received: from cachyos.home (2a01cb0c82caf900a186612f304bfea5.ipv6.abo.wanadoo.fr. [2a01:cb0c:82ca:f900:a186:612f:304b:fea5]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-4a162e867e8sm161520495e9.15.2026.10.03.12.42.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sat, 03 Oct 2026 12:42:07 -0700 (PDT) From: =?UTF-8?q?Isma=C3=AFl=20Bahloul?= To: linux-sound@vger.kernel.org Cc: tiwai@suse.com, perex@perex.cz, linux-usb@vger.kernel.org, alsa-devel@alsa-project.org, linux-kernel@vger.kernel.org, corbet@lwn.net, skhan@linuxfoundation.org, rdunlap@infradead.org, linux-doc@vger.kernel.org, =?UTF-8?q?Isma=C3=AFl=20Bahloul?= , David Fredman Subject: [RFC PATCH v6 2/8] ALSA: usb: babyfacepro: add output masters and crosspoint routing Date: Sat, 3 Oct 2026 21:41:31 +0200 Message-ID: <20261003194137.86176-3-i.bahloul01@gmail.com> X-Mailer: git-send-email 2.56.0 In-Reply-To: <20261003194137.86176-1-i.bahloul01@gmail.com> References: <20261003194137.86176-1-i.bahloul01@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Add the first mixer controls: the six output masters (volume + mute) and the 6x14 crosspoint matrix. The device has no readback for any of them, so the driver keeps the state host-side and the controls read that cache. The probe's cold init clears the mixer registers, so probe writes a power-on default: every playback channel into every output at 0 dB, the hardware inputs off until a mixer raises them, and the two analog outputs (AN1/2, PH3/4) at -20 dB, the level the hardware DIM button uses. The AN1/2 output sums from its own "low map" registers, so its crosspoints are written to both maps. A volume change leaves a muted output muted. A userspace usbfs claim (PipeWire, a libusb mixer daemon) detaches and re-probes the interface, and the cold init of the re-probe would wipe the settings, so the mixer state is saved at disconnect and restored at the next probe instead of the default. Co-developed-by: David Fredman Signed-off-by: David Fredman Signed-off-by: Ismaïl Bahloul --- sound/usb/babyfacepro/Makefile | 2 +- sound/usb/babyfacepro/babyfacepro-ctl.c | 710 ++++++++++++++++++++++++ sound/usb/babyfacepro/babyfacepro.c | 177 +++++- sound/usb/babyfacepro/babyfacepro.h | 123 +++- 4 files changed, 1008 insertions(+), 4 deletions(-) create mode 100644 sound/usb/babyfacepro/babyfacepro-ctl.c diff --git a/sound/usb/babyfacepro/Makefile b/sound/usb/babyfacepro/Makefile index 5adc6d474..a50647a06 100644 --- a/sound/usb/babyfacepro/Makefile +++ b/sound/usb/babyfacepro/Makefile @@ -1,4 +1,4 @@ # SPDX-License-Identifier: GPL-2.0-only -snd-usb-babyface-pro-y := babyfacepro.o +snd-usb-babyface-pro-y := babyfacepro.o babyfacepro-ctl.o obj-$(CONFIG_SND_USB_BABYFACE_PRO) += snd-usb-babyface-pro.o diff --git a/sound/usb/babyfacepro/babyfacepro-ctl.c b/sound/usb/babyfacepro/babyfacepro-ctl.c new file mode 100644 index 000000000..6ef29aa27 --- /dev/null +++ b/sound/usb/babyfacepro/babyfacepro-ctl.c @@ -0,0 +1,710 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * RME Babyface Pro / Pro FS - proprietary-mode USB audio driver + * + * ALSA control surface: the hardware mixer (output masters and mutes, + * the crosspoint matrix, preamps, routing flags, varispeed pitch). + * + * See babyfacepro.h for the shared device state and register map, + * and babyfacepro.c for the core driver (protocol, PCM streaming, + * state persistence, card lifecycle). + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "babyfacepro.h" + +/* The flag-cycle counter, its writer and the per-block crosspoint + * "cross" register clear are crosspoint/mixer-only, so they live here + * rather than in the core driver file. + */ + +/* The transaction-flag counter cycle on 16-bit writes. */ +const u16 bf_flag_cycle[4] = { 0xc000, 0x4000, 0x8000, 0x0000 }; + +/* Write with the per-transaction flag-cycle word OR'd into idx. The + * device wants the flag word (0xc000/0x4000/0x8000/0x0000, rotating) + * set on every 0x12/0x1a write; this is the hot path for the mixer + * puts, so it is factored out. + */ +int bf_vendor_write_cycle(struct snd_usb_babyface *chip, u8 req, u16 val, u16 idx) +{ + u16 flag = bf_flag_cycle[chip->flag_cnt]; + + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + return bf_vendor_write(chip, req, val, idx | flag); +} + +/* The 0x16 cold-init clear covers only 0x00-0x3D - the "cross" + * registers of a block (L-reg odd / R-reg even of the stereo + * sources) survive from the previous session and would sum L+R into + * BOTH channels of the output (mono). Zero them explicitly: 10 odd + * L-registers (5,7,...23) + 10 even R-registers (4,6,...22). + */ +int bf_crosspoint_clear_cross(struct snd_usb_babyface *chip, + unsigned int blk) +{ + int ret, k; + + for (k = BF_CROSS_L_FIRST; k <= BF_CROSS_L_LAST; k += 2) { + ret = bf_vendor_write_cycle(chip, BF_REQ_CROSSPOINT, 0x0000, + BF_REG_CROSS_BASE_L + + BF_REG_CROSS_STRIDE * blk + k); + if (ret < 0) + return ret; + } + for (k = BF_CROSS_R_FIRST; k <= BF_CROSS_R_LAST; k += 2) { + ret = bf_vendor_write_cycle(chip, BF_REQ_CROSSPOINT, 0x0000, + BF_REG_CROSS_BASE_R + + BF_REG_CROSS_STRIDE * blk + k); + if (ret < 0) + return ret; + } + return 0; +} + +const struct bf_source bf_sources[14] = { + { "AN1", 0, 0 }, + { "AN2", 1, 1 }, + { "AN3", 2, 2 }, + { "AN4", 3, 3 }, + { "AS1/2", 4, 5 }, + { "ADAT3/4", 6, 7 }, + { "ADAT5/6", 8, 9 }, + { "ADAT7/8", 10, 11 }, + { "PB1", 12, 13 }, + { "PB2", 14, 15 }, + { "PB3", 16, 17 }, + { "PB4", 18, 19 }, + { "PB5", 20, 21 }, + { "PB6", 22, 23 }, +}; + +/* Crosspoint-map output order vs the master-map order - HARDWARE- + * VERIFIED 2026-08-24: the block that feeds the Phones is the FIRST + * crosspoint block (0x34), while the Phones master is the SECOND + * (0x03E2/0x0006). The crosspoint map lists the Phones first (the + * monitor output); the master map lists AN1/2 first. Control index = + * the canonical order (AN1/2=0, PH3/4=1, ...) so the crosspoint and + * master controls line up; this table maps to the register block. + */ +const u8 bf_xpoint_block[6] = { 1, 0, 2, 3, 4, 5 }; + +/* Master-register output order - the master map lists AN1/2 first + * (0x03E0) and the Phones master SECOND (0x03E2, HARDWARE-VERIFIED + * 2026-08-24); the crosspoint blocks are in the opposite order + * (Phones = block 0x34 first, hence bf_xpoint_block above). Control + * index -> canonical output (AN1/2=0, PH3/4=1, ...) = the master + * register position directly: the names 'AN1/2 Playback Volume' etc. + * must match the register they write (corrected 2026-08-26 - the + * previous {1,0,...} swap made 'AN1/2' drive the Phones and 'PH3/4' + * drive the AN1/2 analog out). + */ +static const u8 bf_master_out[6] = { 0, 1, 2, 3, 4, 5 }; + +/* The 16-bit master value -> the 8-bit companion code (0.5 dB/step). + * Integer-only: half_db = 12*log2(v/0x2000) via ilog2 + an 8-bit + * fractional-octave table (12*log2(1 + n/256), ~0.05 dB resolution - + * fine enough for the +/-0.5 dB panel wheel to track the round-trip). + */ +static const u8 bf_lg2_frac[256] = { + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, + 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, + 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, + 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, + 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, + 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, + 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, + 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, + 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, + 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +}; + +/* 16-bit master -> dBx2 (12 half-dB per octave; 0x2000 = 0 dB). + * Shared by the 8-bit companion and the front-panel OUT wheel. + */ +int bf_master_half_db(u16 vol16) +{ + unsigned int k, frac; + + vol16 = clamp(vol16, 1, 0x4000); + k = ilog2(vol16); + frac = ((vol16 - (1u << k)) << 8) >> k; + return 12 * (int)k - 156 + bf_lg2_frac[frac]; +} + +/* dBx2 -> 16-bit master (0x2000*2^(half_db/12), rounded). The + * inverse of bf_master_half_db - the 12th-root table 2^(n/12). + */ +static const u16 bf_twelfth[12] = { + 0x1000, 0x10f4, 0x11f6, 0x1307, 0x1429, 0x155c, + 0x16a1, 0x17f9, 0x1966, 0x1ae9, 0x1c82, 0x1e34, +}; + +int bf_master_16bit(int half_db) +{ + int k = half_db / 12; + int n = half_db % 12; + u32 v; + + if (n < 0) { + n += 12; + k--; + } + v = (u32)bf_twelfth[n] << 1; /* 0x2000*2^(n/12) */ + if (k >= 0) { + v <<= k; + } else { + v += 1u << (-k - 1); /* round-half-up */ + v >>= -k; + } + return (u16)clamp(v, 1, 0x4000); +} + +u8 bf_master_8bit(u16 vol16) +{ + if (vol16 == 0) + return BF_MASTER_MUTE; + return (u8)clamp(0xf3 + bf_master_half_db(vol16), BF_MASTER_8_MIN, 0xff); +} + +/* The cold-init register clear zeroes the mixer registers TotalMix + * re-uploads afterwards. The kernel driver has no saved scene (no + * readback for faders), so on a probe with no saved state it applies a + * factory routing so the card makes sound without any user-space mixer: + * the six playback channels feed every output at unity, and the + * hardware inputs (AN1-4, AS1/2, ADAT) are NOT routed - raising an + * input's crosspoint in a mixer is what monitors it. + * + * The inputs are left out deliberately. Routing all 14 sources into + * every output at unity (the earlier default) summed a live mic or line + * input straight into the main out and the headphones the moment the + * module loaded, before alsa-restore had a chance to put the user's own + * levels back - the feedback/level hazard issue #4 raised, and the "mic + * audible in the phones" surprise. The failure is asymmetric: a + * default that is too quiet is turned up in a second, one that is too + * loud cannot be taken back. + * + * The two analog masters (AN1/2, the main out; PH3/4, the headphone + * out) come up at -20 dB rather than TotalMix's 0 dB, for the same + * reason - the six playback channels into an output at unity sum, and + * -20 dB is plainly audible but safe. It is not an invented number: it + * is the exact 8-bit/16-bit pair the hardware's own DIM button writes. + * + * The other four outputs (AS1/2, ADAT3/4, ADAT5/6, ADAT7/8) are all + * digital, carried over the single optical port - nothing downstream + * of them can be damaged by a loud signal the way a speaker or a pair + * of headphones can, so there is no hazard to mitigate, only a + * digital feed that would otherwise arrive 20 dB quiet for no reason + * a downstream device could infer. They keep TotalMix's own 0 dB + * default (raised 2026-09-15 after David Fredman pointed out the + * blanket -20 dB reached them too, on his report of the AN1/2/PH3/4 + * default - issue #4). + */ +int babyface_write_default_mixer(struct snd_usb_babyface *chip) +{ + int out, src, ret; + u16 flag; + u16 level; + + /* Output masters: the two analog outputs at -20 dB, the four + * digital ones at 0 dB (see the comment above). Unmuted either + * way. + */ + for (out = 0; out < 6; out++) { + bool analog = out < 2; + u8 gain8 = analog ? BF_MASTER_MINUS20_8 : BF_MASTER_UNMUTE; + u16 gain16 = analog ? BF_MASTER_MINUS20_16 : BF_MASTER_0DB; + + ret = bf_vendor_write(chip, BF_REQ_GAIN, gain8, + BF_REG_MASTER_8 + 2 * out); + if (ret < 0) + return ret; + ret = bf_vendor_write(chip, BF_REQ_GAIN, gain8, + BF_REG_MASTER_8 + 2 * out + 1); + if (ret < 0) + return ret; + flag = bf_flag_cycle[chip->flag_cnt]; + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, gain16, + (BF_REG_MASTER_16 + 2 * out) | flag); + if (ret < 0) + return ret; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, gain16, + (BF_REG_MASTER_16 + 2 * out + 1) | flag); + if (ret < 0) + return ret; + chip->master[out][0] = gain16; + chip->master[out][1] = gain16; + chip->muted[out] = false; + } + + /* Every playback source into every output pair, L and R, at 0 dB, + * and the hardware inputs off (the standard map, plus the low map + * on AN1/2 - see bf_xpoint_write's own comment for why AN1/2 needs + * both). The addresses use the source's idx_l/idx_r on the + * canonical block - writing the raw index on both bases would put + * PB1 R on the L side and PB1 L on the R side (L+R on both = mono). + * The "cross" registers (L-reg idx_r / R-reg idx_l) are cleared. + */ + for (out = 0; out < 6; out++) { + unsigned int blk = bf_xpoint_block[out]; + + for (src = 0; src < 14; src++) { + /* Only the playback channels are routed out of the + * box; a hardware input stays out of every output + * until a mixer raises its crosspoint. + */ + level = src < BF_SRC_PB1 ? 0 : BF_FADER_0DB; + ret = bf_xpoint_write(chip, out, src, level, level); + if (ret < 0) + return ret; + } + ret = bf_crosspoint_clear_cross(chip, blk); + if (ret < 0) + return ret; + } + + /* Mirror the defaults into the control cache (14 controls/output). */ + for (out = 0; out < 6; out++) + for (src = 0; src < 14; src++) { + level = src < BF_SRC_PB1 ? 0 : BF_FADER_0DB; + chip->xpoint[out][src][0] = level; + chip->xpoint[out][src][1] = level; + } + + /* Host settings word (clock source Internal). */ + return bf_settings_write(chip); +} + +/* The cold init's 0x16 clear leaves the 8-bit masters muted: the + * output stays silent until a master write lands (hardware-verified + * 2026-08-24 - only a write un-mutes the 8-bit register). Re-apply + * the six output masters + mutes from the cache; used by the state + * restore that follows the cold init. + */ +int bf_apply_masters(struct snd_usb_babyface *chip) +{ + int out, ret; + u16 flag; + + for (out = 0; out < 6; out++) { + u16 l = chip->muted[out] ? 0 : chip->master[out][0]; + u16 r = chip->muted[out] ? 0 : chip->master[out][1]; + u8 l8 = chip->muted[out] ? BF_MASTER_MUTE : bf_master_8bit(l); + u8 r8 = chip->muted[out] ? BF_MASTER_MUTE : bf_master_8bit(r); + + ret = bf_vendor_write(chip, BF_REQ_GAIN, l8, + BF_REG_MASTER_8 + 2 * out); + if (ret < 0) + return ret; + ret = bf_vendor_write(chip, BF_REQ_GAIN, r8, + BF_REG_MASTER_8 + 2 * out + 1); + if (ret < 0) + return ret; + flag = bf_flag_cycle[chip->flag_cnt]; + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, l, + (BF_REG_MASTER_16 + 2 * out) | flag); + if (ret < 0) + return ret; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, r, + (BF_REG_MASTER_16 + 2 * out + 1) | flag); + if (ret < 0) + return ret; + } + return 0; +} + +/* -- mixer controls ------------------------ */ + +/* dB TLV for the output masters: 0x2000 = 0 dB, 0x4000 = +6 dB + * (CALIBRATION.md) with the hardware 20*log10(v/0x2000) law - the raw + * 16-bit value IS the linear amplitude. WirePlumber needs this to map + * the volume 1:1 to the hardware control instead of applying a software + * volume on top (which left the output ~30 dB down). + */ +static const DECLARE_TLV_DB_RANGE(bf_master_tlv, + 0, 0x2000, TLV_DB_LINEAR_ITEM(-6500, 0), + 0x2000, 0x4000, TLV_DB_LINEAR_ITEM(0, 600) +); + +static int bf_master_info(struct snd_kcontrol *kctl, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 2; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = 0x4000; /* +6 dB = 2 x 0dB(0x2000) */ + uinfo->value.integer.step = 1; + return 0; +} + +static int bf_master_get(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = bf_master_out[kctl->private_value]; + + ucontrol->value.integer.value[0] = chip->master[out][0]; + ucontrol->value.integer.value[1] = chip->master[out][1]; + return 0; +} + +static int bf_master_put(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = bf_master_out[kctl->private_value]; + long nl = ucontrol->value.integer.value[0]; + long nr = ucontrol->value.integer.value[1]; + u16 l, r, wire_l, wire_r, flag; + int ret = 0; + + /* The control is declared 0..0x4000 (+6 dB); reject anything outside + * so the 16-bit companion register and the cache stay in spec (the + * ALSA core only enforces this with CONFIG_SND_CTL_INPUT_VALIDATION). + * Check before narrowing: .value.integer.value[] is a long, so a + * value of 0x10000 or more would wrap to a passing u16. + */ + if (nl < 0 || nl > 0x4000 || nr < 0 || nr > 0x4000) + return -EINVAL; + l = nl; + r = nr; + + mutex_lock(&chip->mutex); + if (l == chip->master[out][0] && r == chip->master[out][1]) + goto out; + + wire_l = chip->muted[out] ? 0 : l; + wire_r = chip->muted[out] ? 0 : r; + flag = bf_flag_cycle[chip->flag_cnt]; + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + + /* The 8-bit register is the real volume; the 16-bit is its + * companion (kept in sync like TotalMix). + */ + ret = bf_vendor_write(chip, BF_REQ_GAIN, bf_master_8bit(wire_l), + BF_REG_MASTER_8 + 2 * out); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_GAIN, bf_master_8bit(wire_r), + BF_REG_MASTER_8 + 2 * out + 1); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, wire_l, + (BF_REG_MASTER_16 + 2 * out) | flag); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, wire_r, + (BF_REG_MASTER_16 + 2 * out + 1) | flag); + if (ret < 0) + goto out; + + chip->master[out][0] = l; + chip->master[out][1] = r; + ret = 1; +out: + mutex_unlock(&chip->mutex); + return ret; +} + +static int bf_mute_info(struct snd_kcontrol *kctl, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; + uinfo->count = 2; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = 1; + return 0; +} + +static int bf_mute_get(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = bf_master_out[kctl->private_value]; + + /* ALSA convention: 1 = enabled (sound on) = not muted. */ + ucontrol->value.integer.value[0] = !chip->muted[out]; + ucontrol->value.integer.value[1] = !chip->muted[out]; + return 0; +} + +static int bf_mute_put(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = bf_master_out[kctl->private_value]; + bool muted = !ucontrol->value.integer.value[0]; + u16 flag; + int ret = 0; + + mutex_lock(&chip->mutex); + if (muted == chip->muted[out]) + goto out; + + flag = bf_flag_cycle[chip->flag_cnt]; + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + + if (muted) { + ret = bf_vendor_write(chip, BF_REQ_GAIN, BF_MASTER_MUTE, + BF_REG_MASTER_8 + 2 * out); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_GAIN, BF_MASTER_MUTE, + BF_REG_MASTER_8 + 2 * out + 1); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, 0x0000, + (BF_REG_MASTER_16 + 2 * out) | flag); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, 0x0000, + (BF_REG_MASTER_16 + 2 * out + 1) | flag); + if (ret < 0) + goto out; + } else { + /* Unmute restores the cached volume (TotalMix keeps the + * pre-mute fader value host-side), 8-bit + 16-bit. + */ + ret = bf_vendor_write(chip, BF_REQ_GAIN, + bf_master_8bit(chip->master[out][0]), + BF_REG_MASTER_8 + 2 * out); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_GAIN, + bf_master_8bit(chip->master[out][1]), + BF_REG_MASTER_8 + 2 * out + 1); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, + chip->master[out][0], + (BF_REG_MASTER_16 + 2 * out) | flag); + if (ret < 0) + goto out; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, + chip->master[out][1], + (BF_REG_MASTER_16 + 2 * out + 1) | flag); + if (ret < 0) + goto out; + } + chip->muted[out] = muted; + ret = 1; +out: + mutex_unlock(&chip->mutex); + return ret; +} + +/* -- crosspoint matrix (6 outputs x 14 sources) -------------- */ + +/* The crosspoint fader is linear in amplitude: BF_FADER_0DB (0x16a0) is + * unity and BF_FADER_TOP (0x2d41) is exactly twice that, i.e. +6 dB; the + * whole fader span follows raw = BF_FADER_0DB * 10^(dB/20). Raw 0 is + * off. + */ +static const DECLARE_TLV_DB_LINEAR(bf_xpoint_tlv, TLV_DB_GAIN_MUTE, 600); + +/* Write a crosspoint slot on the wire: the standard map always, and - + * for the AN1/2 output only - the low map as well. + * + * HARDWARE-VERIFIED 2026-09-14: AN1/2 is not just another output with + * a redundant "shadow" register, despite what this file used to say. + * Sweeping only the standard map (BF_REG_CROSS_BASE_*) into AN1/2 + * produced no audible change at all, off through +6 dB, with two + * independent sources (a generated tone via PB1, a live mic via AN2); + * the exact same code path targeting any other output (verified on + * PH3/4) tracked the fader correctly, off to +6 dB within 0.6 dB. + * PROTOCOL.md's "Scene load" capture explains why: the vendor software + * always writes BOTH the standard map and the low map + * (BF_REG_LOWMAP_BASE_*) together for AN1/2's own crosspoints, at the + * same value - the low map is what actually feeds that output's sum; + * the standard map alone is not enough. Every other output only has a + * standard map. + */ +int bf_xpoint_write(struct snd_usb_babyface *chip, int out, int src, + u16 l, u16 r) +{ + unsigned int blk = bf_xpoint_block[out]; + const struct bf_source *s = &bf_sources[src]; + u16 flag; + int ret; + + if (out == 0) { + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, l, + BF_REG_LOWMAP_BASE_L + s->idx_l); + if (ret < 0) + return ret; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, r, + BF_REG_LOWMAP_BASE_R + s->idx_r); + if (ret < 0) + return ret; + } + + flag = bf_flag_cycle[chip->flag_cnt]; + chip->flag_cnt = (chip->flag_cnt + 1) & 3; + ret = bf_vendor_write(chip, BF_REQ_CROSSPOINT, l, + (BF_REG_CROSS_BASE_L + BF_REG_CROSS_STRIDE * blk + + s->idx_l) | flag); + if (ret < 0) + return ret; + return bf_vendor_write(chip, BF_REQ_CROSSPOINT, r, + (BF_REG_CROSS_BASE_R + BF_REG_CROSS_STRIDE * blk + + s->idx_r) | flag); +} + +static int bf_xpoint_info(struct snd_kcontrol *kctl, + struct snd_ctl_elem_info *uinfo) +{ + uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; + uinfo->count = 2; + uinfo->value.integer.min = 0; + uinfo->value.integer.max = BF_FADER_TOP; /* +6 dB fader top */ + uinfo->value.integer.step = 1; + return 0; +} + +static int bf_xpoint_get(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = kctl->private_value >> 8; + int src = kctl->private_value & 0xff; + + ucontrol->value.integer.value[0] = chip->xpoint[out][src][0]; + ucontrol->value.integer.value[1] = chip->xpoint[out][src][1]; + return 0; +} + +static int bf_xpoint_put(struct snd_kcontrol *kctl, + struct snd_ctl_elem_value *ucontrol) +{ + struct snd_usb_babyface *chip = snd_kcontrol_chip(kctl); + int out = kctl->private_value >> 8; + int src = kctl->private_value & 0xff; + long nl = ucontrol->value.integer.value[0]; + long nr = ucontrol->value.integer.value[1]; + u16 l, r; + int ret = 0; + + /* Check before narrowing: a value of 0x10000 or more would wrap to a + * passing u16 (see the note in bf_master_put()). + */ + if (nl < 0 || nl > BF_FADER_TOP || nr < 0 || nr > BF_FADER_TOP) + return -EINVAL; + l = nl; + r = nr; + + mutex_lock(&chip->mutex); + if (l == chip->xpoint[out][src][0] && r == chip->xpoint[out][src][1]) + goto out; + + ret = bf_xpoint_write(chip, out, src, l, r); + if (ret < 0) + goto out; + + chip->xpoint[out][src][0] = l; + chip->xpoint[out][src][1] = r; + ret = 1; +out: + mutex_unlock(&chip->mutex); + return ret; +} + +int babyface_create_xpoints(struct snd_usb_babyface *chip) +{ + struct snd_kcontrol *kctl; + int out, src, err; + + for (out = 0; out < 6; out++) { + for (src = 0; src < 14; src++) { + kctl = snd_ctl_new1(&(struct snd_kcontrol_new){ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = "Playback Volume", + .index = out * 14 + src, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | + SNDRV_CTL_ELEM_ACCESS_TLV_READ, + .info = bf_xpoint_info, + .get = bf_xpoint_get, + .put = bf_xpoint_put, + .tlv.p = bf_xpoint_tlv, + .private_value = (out << 8) | src, + }, chip); + /* Name the control by its source: "AN1 Playback Volume", + * "PB1 Playback Volume"... with a unique index. + */ + strscpy(kctl->id.name, bf_sources[src].name, + sizeof(kctl->id.name)); + strlcat(kctl->id.name, " Playback Volume", + sizeof(kctl->id.name)); + err = snd_ctl_add(chip->card, kctl); + if (err < 0) + return err; + } + } + + return 0; +} + +int babyface_create_masters(struct snd_usb_babyface *chip) +{ + static const char * const out_names[6] = { + "AN1/2", "PH3/4", "AS1/2", "ADAT3/4", "ADAT5/6", "ADAT7/8" + }; + struct snd_kcontrol *kctl; + int i, err; + + for (i = 0; i < 6; i++) { + kctl = snd_ctl_new1(&(struct snd_kcontrol_new){ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = out_names[i], + .index = i, + .access = SNDRV_CTL_ELEM_ACCESS_READWRITE | + SNDRV_CTL_ELEM_ACCESS_TLV_READ, + .info = bf_master_info, + .get = bf_master_get, + .put = bf_master_put, + .tlv.p = bf_master_tlv, + .private_value = i, + }, chip); + strlcat(kctl->id.name, " Playback Volume", sizeof(kctl->id.name)); + err = snd_ctl_add(chip->card, kctl); + if (err < 0) + return err; + chip->master_kctl[i] = kctl; + + kctl = snd_ctl_new1(&(struct snd_kcontrol_new){ + .iface = SNDRV_CTL_ELEM_IFACE_MIXER, + .name = out_names[i], + .index = i, + .info = bf_mute_info, + .get = bf_mute_get, + .put = bf_mute_put, + .private_value = i, + }, chip); + strlcat(kctl->id.name, " Playback Switch", sizeof(kctl->id.name)); + err = snd_ctl_add(chip->card, kctl); + if (err < 0) + return err; + + dev_dbg(&chip->dev->dev, "output %d = %s\n", i, out_names[i]); + } + + return 0; +} + diff --git a/sound/usb/babyfacepro/babyfacepro.c b/sound/usb/babyfacepro/babyfacepro.c index 8f8667083..82ec98346 100644 --- a/sound/usb/babyfacepro/babyfacepro.c +++ b/sound/usb/babyfacepro/babyfacepro.c @@ -3,9 +3,11 @@ * RME Babyface Pro / Pro FS - proprietary-mode USB audio driver * * Core driver: USB vendor requests + cold init, interrupt-URB PCM - * streaming, and the card lifecycle (probe/disconnect/module entry). + * streaming, mixer-state persistence across re-probes, and the card + * lifecycle (probe/disconnect/module entry). * - * See babyfacepro.h for the shared device state and register map. + * See babyfacepro.h for the shared device state and register map, + * and babyfacepro-ctl.c for the ALSA control surface. */ #include #include @@ -253,6 +255,135 @@ int bf_cold_init(struct snd_usb_babyface *chip) return 0; } +/* -- mixer-state persistence across interface re-probes -------- + * A userspace client can claim the proprietary interface via usbfs + * (USBDEVFS_DISCONNECT_CLAIM - seen with PipeWire grabbing the + * device when a stream targets the sink, and with the TuxMix + * user-space daemon's libusb). That detaches us and the card + * disappears for the duration; on release the interface re-probes. + * The device keeps its registers across the detach, but our cold + * init clears them - so save the mixer state at disconnect and + * restore it at the next probe. + */ + +static LIST_HEAD(bf_saved_list); +static DEFINE_MUTEX(bf_saved_mutex); + +/* Re-apply the whole cached mixer state to the device, whose registers + * the cold init cleared. Caller holds chip->mutex. + */ +int babyface_restore_state(struct snd_usb_babyface *chip) +{ + int out, src, ret; + + /* Masters (8-bit = the real volume) + mutes. */ + ret = bf_apply_masters(chip); + if (ret < 0) + return ret; + + /* Crosspoints (canonical out -> register block; AN1/2 also needs + * the low map, see bf_xpoint_write's own comment). + */ + for (out = 0; out < 6; out++) { + unsigned int blk = bf_xpoint_block[out]; + + for (src = 0; src < 14; src++) { + ret = bf_xpoint_write(chip, out, src, + chip->xpoint[out][src][0], + chip->xpoint[out][src][1]); + if (ret < 0) + return ret; + } + ret = bf_crosspoint_clear_cross(chip, blk); + if (ret < 0) + return ret; + } + + /* The rate (family register), then the varispeed ratio, which is + * sticky in the device and so must be re-sent even at pitch 0 in + * case something else wrote it while we were detached. + */ + ret = bf_clock_write(chip); + if (ret < 0) + return ret; + return bf_pitch_write(chip, chip->pitch); +} + +void bf_state_save(struct snd_usb_babyface *chip) +{ + struct bf_saved *s; + const char *key = chip->dev->serial ? chip->dev->serial : + dev_name(&chip->dev->dev); + bool found = false; + + mutex_lock(&bf_saved_mutex); + list_for_each_entry(s, &bf_saved_list, list) { + if (strcmp(s->key, key)) + continue; + found = true; + break; + } + if (!found) { + s = kzalloc_obj(*s, GFP_KERNEL); + if (!s) { + mutex_unlock(&bf_saved_mutex); + return; + } + strscpy(s->key, key, sizeof(s->key)); + list_add_tail(&s->list, &bf_saved_list); + } + + s->flag_cnt = chip->flag_cnt; + memcpy(s->master, chip->master, sizeof(s->master)); + memcpy(s->muted, chip->muted, sizeof(s->muted)); + memcpy(s->xpoint, chip->xpoint, sizeof(s->xpoint)); + mutex_unlock(&bf_saved_mutex); +} + +/* Copy a saved state (if any) into a freshly probed chip and push it + * to the device. Returns 1 when restored, -ENOENT when there is none, + * or a negative error from the vendor writes. + */ +int bf_state_restore(struct snd_usb_babyface *chip) +{ + struct bf_saved *s; + const char *key = chip->dev->serial ? chip->dev->serial : + dev_name(&chip->dev->dev); + int ret = -ENOENT; + + mutex_lock(&bf_saved_mutex); + list_for_each_entry(s, &bf_saved_list, list) { + if (strcmp(s->key, key)) + continue; + chip->flag_cnt = s->flag_cnt; + memcpy(chip->master, s->master, sizeof(chip->master)); + memcpy(chip->muted, s->muted, sizeof(chip->muted)); + memcpy(chip->xpoint, s->xpoint, sizeof(chip->xpoint)); + ret = 1; + break; + } + mutex_unlock(&bf_saved_mutex); + if (ret != 1) + return ret; + + mutex_lock(&chip->mutex); + ret = babyface_restore_state(chip); + mutex_unlock(&chip->mutex); + return ret ? ret : 1; +} + +void bf_state_purge(void) +{ + struct bf_saved *s, *tmp; + + mutex_lock(&bf_saved_mutex); + list_for_each_entry_safe(s, tmp, &bf_saved_list, list) { + list_del(&s->list); + kfree(s); + } + mutex_unlock(&bf_saved_mutex); +} + /* -- PCM data path ------------------------- */ static bool babyface_capture_copy(struct snd_usb_babyface *chip, @@ -1393,6 +1524,26 @@ static int babyface_probe(struct usb_interface *intf, goto error; } + /* Restore the mixer state saved at the last disconnect (if any); + * the device keeps its registers across a usbfs detach, but the + * cold init above cleared them, so push the user's settings back. + */ + err = bf_state_restore(chip); + if (err == -ENOENT) { + /* No saved state: the 0x16 clear zeroed the mixer registers, + * so restore the factory default routing to keep the outputs + * live out of the box. + */ + err = babyface_write_default_mixer(chip); + if (err < 0) { + dev_err(&intf->dev, "default mixer restore failed: %d\n", err); + goto error; + } + } else if (err < 0) { + dev_err(&intf->dev, "mixer state restore failed: %d\n", err); + goto error; + } + /* Keep the allocation size independent of the active USB mode. */ urbsize = BF_WORDS_PER_FRAME * sizeof(u32) * chip->frames_per_urb; chip->urbs_in = kcalloc(chip->nurbs, sizeof(*chip->urbs_in), GFP_KERNEL); @@ -1437,6 +1588,18 @@ static int babyface_probe(struct usb_interface *intf, goto error; } + err = babyface_create_masters(chip); + if (err < 0) { + dev_err(&intf->dev, "master control creation failed: %d\n", err); + goto error; + } + + err = babyface_create_xpoints(chip); + if (err < 0) { + dev_err(&intf->dev, "crosspoint creation failed: %d\n", err); + goto error; + } + err = snd_card_register(chip->card); if (err < 0) { dev_err(&intf->dev, "snd_card_register failed: %d\n", err); @@ -1485,6 +1648,11 @@ static void babyface_disconnect(struct usb_interface *intf) babyface_stream_kill(chip); mutex_unlock(&chip->mutex); cancel_work_sync(&chip->stream_work); + /* Keep the mixer state for the next probe: a userspace usbfs claim + * (PipeWire sink grab, TuxMix daemon) detaches us and the cold init + * of the re-probe would otherwise wipe the settings. + */ + bf_state_save(chip); /* Balance the probe()-time usb_disable_autosuspend(): the usb_device * outlives this interface claim (a usbfs detach re-probes without * the physical device ever disconnecting), so leaving autosuspend @@ -1524,7 +1692,12 @@ static int __init babyface_init(void) static void __exit babyface_exit(void) { + /* Deregister first: each disconnect() calls bf_state_save(), which + * allocates a node for a device it has not seen before. Purging + * before that frees the list and then leaks those fresh nodes. + */ usb_deregister(&babyface_driver); + bf_state_purge(); } module_init(babyface_init); diff --git a/sound/usb/babyfacepro/babyfacepro.h b/sound/usb/babyfacepro/babyfacepro.h index 60ab0c387..9694cb9a7 100644 --- a/sound/usb/babyfacepro/babyfacepro.h +++ b/sound/usb/babyfacepro/babyfacepro.h @@ -11,7 +11,10 @@ * standalone (snd-usb-caiaq-style interrupt streaming) instead of an * snd-usb-audio quirk. * - * babyfacepro.c holds the card lifecycle and the PCM stream. + * babyfacepro.c holds the card lifecycle, the PCM stream and the + * mixer-state persistence across re-probes; + * babyfacepro-ctl.c holds the ALSA control surface - the hardware + * mixer. * * The protocol (vendor requests + 14x32-bit frame layout) was * reverse-engineered from Windows captures and validated on hardware - @@ -90,8 +93,10 @@ /* Vendor requests (bmRequestType 0x40, value in wValue, no data phase). */ #define BF_REQ_KEEPALIVE 0x10 /* settings word / stream trigger */ +#define BF_REQ_CROSSPOINT 0x12 /* 16-bit crosspoint / master */ #define BF_REQ_REG_CLEAR 0x16 /* cold-init register clear */ #define BF_REQ_PREAMP 0x17 /* 48V/PAD state + readback */ +#define BF_REQ_GAIN 0x1a /* 8-bit gain / master companion */ #define BF_REQ_DDS 0x1b /* clock quads */ #define BF_REQ_STATUS_2 0x1c /* read 4 B */ #define BF_REQ_SESSION_START 0x1d @@ -114,6 +119,80 @@ */ #define BF_SETTINGS_CLOCK_INTERNAL 0x0001 +/* Register addresses (masters + crosspoint matrix). */ +#define BF_REG_MASTER_16 0x03e0 /* + 2*out (bReq 0x12) */ +#define BF_REG_MASTER_8 0x0004 /* + 2*out (bReq 0x1a) */ +#define BF_REG_CROSS_BASE_L 0x0034 /* + 0x34*out + src (bReq 0x12) */ +#define BF_REG_CROSS_BASE_R 0x004e /* + 0x34*out + src */ +#define BF_REG_CROSS_STRIDE 0x0034 +/* Low map (the AN1/2 monitor bus's own per-source registers, one set + * shared across every output - not one per output block like the + * standard crosspoint map above). NOT a shadow/mirror of the standard + * map for AN1/2: it is what that output actually sums from, and the + * standard map alone has no audible effect on it (hardware-verified + * 2026-09-14, see bf_xpoint_write's own comment and KERNEL-DRIVER.md). + */ +#define BF_REG_LOWMAP_BASE_L 0x0000 /* + idx_l */ +#define BF_REG_LOWMAP_BASE_R 0x001a /* + idx_r */ + +/* The "cross" register block within each output: the L-registers sit at + * odd offsets 5..23 and the R-registers at even offsets 4..22 (the stereo + * source pairs that can be cross-linked). bf_crosspoint_clear_cross() + * zeroes them because the cold-init clear does not cover them. + */ +#define BF_CROSS_L_FIRST 5 +#define BF_CROSS_L_LAST 23 +#define BF_CROSS_R_FIRST 4 +#define BF_CROSS_R_LAST 22 + +/* Calibrated master value: 0 dB = 0x2000 (+6 dB = 0x4000). See + * CALIBRATION.md. The crosspoint fader curve is DIFFERENT (0 dB = + * 0x16a0, top 0x2d41 - see below). + */ +#define BF_MASTER_0DB 0x2000 + +/* The 8-bit master is the REAL output volume (hardware-verified + * 2026-08-24: writing it changes the level, the 16-bit does not). + * Scale: 0.5 dB per step, 0xf3 = 0 dB (the scene-load default), + * bottom 0x73 = -64 dB (silence), top 0xff = +6 dB. The 16-bit + * register is a companion kept in sync (TotalMix writes both). + * The mute value is 0x3B. + */ +#define BF_MASTER_8_0DB 0xf3 +#define BF_MASTER_8_MIN 0x73 +#define BF_MASTER_MUTE 0x3b +#define BF_MASTER_UNMUTE 0xf3 +/* -20 dB master, 8-bit and 16-bit: the exact pair the hardware DIM + * button writes (cap_dim2.pcap), reused as the power-on default. + */ +#define BF_MASTER_MINUS20_8 0xcb +#define BF_MASTER_MINUS20_16 0x0333 + +/* Crosspoint fader curve: 0 dB = 0x16a0, +6 dB = 0x2d41 (fader curve, + * DIFFERENT from the master 0x4000 top - see CALIBRATION.md). + */ +#define BF_FADER_0DB 0x16a0 +#define BF_FADER_TOP 0x2d41 + +/* The crosspoint matrix sources (14 controls per output). */ +struct bf_source { + const char *name; + u8 idx_l; + u8 idx_r; +}; + +/* Crosspoint-source order + register block maps (babyfacepro-ctl.c). */ +extern const struct bf_source bf_sources[14]; +extern const u8 bf_xpoint_block[6]; + +/* The first playback source in bf_sources[]: the four analog inputs, the + * optical input and the three ADAT pairs come first, the six playback + * channels last. babyface_write_default_mixer() routes only the + * playback out of the box; a hardware input is not monitored into any + * output until a mixer raises its crosspoint. + */ +#define BF_SRC_PB1 8 + struct snd_usb_babyface { struct snd_card *card; struct usb_device *dev; @@ -160,6 +239,25 @@ struct snd_usb_babyface { */ ktime_t in_done; unsigned int out_inflight; + + /* mixer state (no gain readback exists - host-side mirror) */ + u8 flag_cnt; /* 0xc000/0x4000/0x8000/0x0000 */ + struct snd_kcontrol *master_kctl[6]; + u16 master[6][2]; /* cached 16-bit masters */ + bool muted[6]; + u16 xpoint[6][14][2]; /* cached crosspoints (out, src, L/R) */ +}; + +/* The mixer state cached across interface re-probes (see + * babyfacepro.c's own comment on bf_state_save/bf_state_restore). + */ +struct bf_saved { + struct list_head list; + char key[32]; + u8 flag_cnt; + u16 master[6][2]; + bool muted[6]; + u16 xpoint[6][14][2]; }; struct bf_rate { @@ -185,3 +283,26 @@ void babyface_stream_kill(struct snd_usb_babyface *chip); void babyface_pcm_stop_both(struct snd_usb_babyface *chip, snd_pcm_state_t state); void babyface_stream_work(struct work_struct *work); extern const struct snd_pcm_hw_constraint_list bf_rates_constraint; + +/* Mixer-state persistence across interface re-probes. */ +void bf_state_save(struct snd_usb_babyface *chip); +int bf_state_restore(struct snd_usb_babyface *chip); +void bf_state_purge(void); +int babyface_restore_state(struct snd_usb_babyface *chip); + +/* -- babyfacepro-ctl.c ----------------------- */ +extern const u16 bf_flag_cycle[4]; +int bf_vendor_write_cycle(struct snd_usb_babyface *chip, u8 req, u16 val, u16 idx); +int bf_crosspoint_clear_cross(struct snd_usb_babyface *chip, + unsigned int blk); +int babyface_write_default_mixer(struct snd_usb_babyface *chip); +int bf_apply_masters(struct snd_usb_babyface *chip); +int bf_xpoint_write(struct snd_usb_babyface *chip, int out, int src, + u16 l, u16 r); +int babyface_create_masters(struct snd_usb_babyface *chip); +int babyface_create_xpoints(struct snd_usb_babyface *chip); + +/* Master gain-law helpers (babyfacepro-ctl.c). */ +int bf_master_half_db(u16 vol16); /* 16-bit master -> dBx2 */ +int bf_master_16bit(int half_db); /* dBx2 -> 16-bit master */ +u8 bf_master_8bit(u16 vol16); /* 16-bit master -> 8-bit companion */ -- 2.56.0