* [PATCH v4 1/3] ASoC: codecs: add SN624x SDCA SoundWire driver
2026-08-18 2:08 [PATCH v4 0/3] ASoC: add Senary SN624x SoundWire SDCA support Qianghua Wang
@ 2026-08-18 2:08 ` Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 2/3] ASoC: sdw_utils: add Senary SN624x helpers and codec_info Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 3/3] ASoC: Intel: soc-acpi: add SN624x entries for ARL/LNL/MTL/PTL Qianghua Wang
2 siblings, 0 replies; 4+ messages in thread
From: Qianghua Wang @ 2026-08-18 2:08 UTC (permalink / raw)
To: linux-sound
Cc: Qianghua Wang, Mark Brown, Pierre-Louis Bossart, Bard Liao,
Liam Girdwood, Peter Ujfalusi, Kai Vehmanen, Cezary Rojewski,
Charles Keepax, bo liu
Add a SoundWire SDCA driver for Senary SN624x multi-function codecs
(jack, speaker amp, and DMIC). Program SDCA SampleFreqIndex in
hw_params, keep SDCA jack IRQs masked with poll-based detection, and
extend the Senary MAINTAINERS entry for the new codec files only.
Signed-off-by: Qianghua Wang <qianghua.wang@senarytech.com>
---
MAINTAINERS | 3 +
sound/soc/codecs/Kconfig | 13 +
sound/soc/codecs/Makefile | 2 +
sound/soc/codecs/sn624x-sdca-sdw.c | 1888 ++++++++++++++++++++++++++++
sound/soc/codecs/sn624x-sdca.h | 152 +++
5 files changed, 2058 insertions(+)
create mode 100644 sound/soc/codecs/sn624x-sdca-sdw.c
create mode 100644 sound/soc/codecs/sn624x-sdca.h
diff --git a/MAINTAINERS b/MAINTAINERS
index 716acfc3d7c1..0bcfd4332932 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -29832,9 +29832,12 @@ F: tools/testing/selftests/cgroup/test_zswap.c
SENARYTECH AUDIO CODEC DRIVER
M: bo liu <bo.liu@senarytech.com>
+M: qianghua.wang <qianghua.wang@senarytech.com>
S: Maintained
T: git git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound.git
F: sound/hda/codecs/senarytech.c
+F: sound/soc/codecs/sn624x*
+F: sound/soc/sdw_utils/soc_sdw_senary*
THE REST
M: Linus Torvalds <torvalds@linux-foundation.org>
diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig
index 18e34899566e..af3ea0fbea6a 100644
--- a/sound/soc/codecs/Kconfig
+++ b/sound/soc/codecs/Kconfig
@@ -254,6 +254,7 @@ config SND_SOC_ALL_CODECS
imply SND_SOC_SIMPLE_MUX
imply SND_SOC_SMA1303
imply SND_SOC_SMA1307
+ imply SND_SOC_SN624X_SDCA_SDW
imply SND_SOC_SPDIF
imply SND_SOC_SRC4XXX_I2C
imply SND_SOC_SSM2305
@@ -2087,6 +2088,18 @@ config SND_SOC_SMA1307
If you are using a system with an SMA1307 amplifier connected
via I2C, enable this option.
+config SND_SOC_SN624X_SDCA_SDW
+ tristate "Senary SN624x SDCA Codec - SDW"
+ depends on SND_SOC_SDCA
+ depends on SOUNDWIRE
+ select REGMAP_SOUNDWIRE
+ select REGMAP_SOUNDWIRE_MBQ
+ help
+ Enable support for Senary SN624x SDCA SoundWire codecs.
+ These multi-function devices provide headset jack, speaker
+ amplifier, and digital microphone endpoints on the SoundWire
+ bus.
+
config SND_SOC_SPDIF
tristate "S/PDIF CODEC"
diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile
index d2a689006d69..ec7e65ca4783 100644
--- a/sound/soc/codecs/Makefile
+++ b/sound/soc/codecs/Makefile
@@ -300,6 +300,7 @@ snd-soc-sigmadsp-regmap-y := sigmadsp-regmap.o
snd-soc-si476x-y := si476x.o
snd-soc-sma1303-y := sma1303.o
snd-soc-sma1307-y := sma1307.o
+snd-soc-sn624x-sdca-y := sn624x-sdca-sdw.o
snd-soc-spdif-tx-y := spdif_transmitter.o
snd-soc-spdif-rx-y := spdif_receiver.o
snd-soc-src4xxx-y := src4xxx.o
@@ -739,6 +740,7 @@ obj-$(CONFIG_SND_SOC_SIGMADSP_REGMAP) += snd-soc-sigmadsp-regmap.o
obj-$(CONFIG_SND_SOC_SI476X) += snd-soc-si476x.o
obj-$(CONFIG_SND_SOC_SMA1303) += snd-soc-sma1303.o
obj-$(CONFIG_SND_SOC_SMA1307) += snd-soc-sma1307.o
+obj-$(CONFIG_SND_SOC_SN624X_SDCA_SDW) += snd-soc-sn624x-sdca.o
obj-$(CONFIG_SND_SOC_SPDIF) += snd-soc-spdif-rx.o snd-soc-spdif-tx.o
obj-$(CONFIG_SND_SOC_SRC4XXX) += snd-soc-src4xxx.o
obj-$(CONFIG_SND_SOC_SRC4XXX_I2C) += snd-soc-src4xxx-i2c.o
diff --git a/sound/soc/codecs/sn624x-sdca-sdw.c b/sound/soc/codecs/sn624x-sdca-sdw.c
new file mode 100644
index 000000000000..c9e690482e8e
--- /dev/null
+++ b/sound/soc/codecs/sn624x-sdca-sdw.c
@@ -0,0 +1,1888 @@
+// SPDX-License-Identifier: GPL-2.0-only
+//
+// sn624x-sdw-sdca.c -- SN624X SDCA ALSA SoC SoundWire audio driver
+//
+// Copyright(c) 2025 Senary Semiconductor Corp.
+//
+
+#include <linux/bitops.h>
+#include <linux/delay.h>
+#include <linux/find.h>
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/jiffies.h>
+#include <linux/module.h>
+#include <linux/pm.h>
+#include <linux/pm_runtime.h>
+#include <linux/regmap.h>
+#include <linux/soundwire/sdw.h>
+#include <linux/soundwire/sdw_registers.h>
+#include <linux/soundwire/sdw_type.h>
+
+#include <sound/jack.h>
+#include <sound/pcm.h>
+#include <sound/pcm_params.h>
+#include <sound/sdca.h>
+#include <sound/sdca_asoc.h>
+#include <sound/sdca_function.h>
+#include <sound/sdca_regmap.h>
+#include <sound/sdw.h>
+#include <sound/soc.h>
+#include <sound/soc-dapm.h>
+
+#include "sn624x-sdca.h"
+
+/* Resume wait after bus re-enumeration (rt722-style probe timeout) */
+#define SN624X_PROBE_TIMEOUT_MS 5000U
+#define SN624X_PWR_D0 SDCA_PDE_PS0
+#define SN624X_PWR_D3 SDCA_PDE_PS3
+#define SN624X_MUTE_ON 1
+/*
+ * Budget for ACTUAL_PS poll via sdca_asoc_pde_poll_actual_ps() (100 polls).
+ * Matches previous ~2s hand-rolled loop for slow PDE transitions.
+ */
+#define SN624X_PDE_PS_POLL_BUDGET_US 2000000U
+
+/*
+ * Prefer ACPI mipi-sdca-function-initialization-table via
+ * sdca_regmap_write_init(). If absent or DisCo parse is incomplete,
+ * a temporary vendor-window OEM fallback is used until firmware tables land.
+ *
+ * Jack detection is poll-driven (UAJ pulse + GE35); SDCA INTMASK bits stay
+ * masked so interrupt storms cannot schedule extra work.
+ */
+
+struct sn624x_sdca_priv;
+
+static void sn624x_sdca_sdca_irq_mask_all(struct sn624x_sdca_priv *sn624x);
+static int sn624x_uaj_ge35_apply_detected_mode(struct device *dev,
+ struct sn624x_sdca_priv *sn624x);
+#define SN624X_DBG(dev, fmt, ...) dev_dbg(dev, "sn624x: " fmt, ##__VA_ARGS__)
+
+/*
+ * SDCA control addresses via SDW_SDCA_CTL(fun, ent, ctl, ch).
+ * Pass ch=0 for single-value controls (power/rate/status); use CH_L/CH_R
+ * only for multi-channel FU mute/volume. CH_ENABLE_* are not SDCA Control
+ * Prefix addresses — keep as raw windows.
+ */
+/* Speaker amp (function 4) — PDE/FU power/mute/vol; rate on CS01 */
+#define SN624X_REG_PWR_STATE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_ACTUAL_PS, 0)
+#define SN624X_REG_PWR_STATE_WRITE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_REQUESTED_PS, 0)
+#define SN624X_REG_RATE_SEL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_CS01, \
+ SN624X_SDCA_CTL_SAMPLE_FREQ_INDEX, 0)
+#define SN624X_REG_CH_ENABLE_A 0x00000220u
+#define SN624X_REG_CH_ENABLE_B 0x00000230u
+#define SN624X_REG_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_USER_FU10, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_L)
+#define SN624X_REG_CHR_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_USER_FU10, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_R)
+#define SN624X_REG_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_USER_FU10, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_L)
+#define SN624X_REG_RIGHT_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_SPEAKER_AMP, SN624X_SDCA_ENT_USER_FU10, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_R)
+
+/* Jack playback (function 1) */
+#define SN624X_REG_JACK_OUT_PWR_STATE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_ACTUAL_PS, 0)
+#define SN624X_REG_JACK_OUT_PWR_STATE_WRITE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_REQUESTED_PS, 0)
+#define SN624X_REG_JACK_OUT_RATE_SEL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_CS01, \
+ SN624X_SDCA_CTL_SAMPLE_FREQ_INDEX, 0)
+#define SN624X_REG_JACK_OUT_CH_ENABLE_A 0x00000120u
+#define SN624X_REG_JACK_OUT_CH_ENABLE_B 0x00000130u
+#define SN624X_REG_JACK_OUT_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_L)
+#define SN624X_REG_JACK_OUT_CHR_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_R)
+#define SN624X_REG_JACK_OUT_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_L)
+#define SN624X_REG_JACK_OUT_CLUSTER_INDEX \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_CRU05, \
+ SN624X_SDCA_CTL_CLUSTER_INDEX, 0)
+
+/* Jack headset capture (function 1) */
+#define SN624X_REG_JACK_CAP_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU1E, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_L)
+#define SN624X_REG_JACK_CAP_CHR_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU1E, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_R)
+#define SN624X_REG_JACK_CAP_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_USER_FU1E, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_L)
+#define SN624X_REG_JACK_CAP_PWR_STATE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_PDE04, \
+ SDCA_CTL_PDE_ACTUAL_PS, 0)
+#define SN624X_REG_JACK_CAP_PWR_STATE_WRITE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_PDE04, \
+ SDCA_CTL_PDE_REQUESTED_PS, 0)
+#define SN624X_REG_JACK_CAP_RATE_SEL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_CS02, \
+ SN624X_SDCA_CTL_SAMPLE_FREQ_INDEX, 0)
+#define SN624X_REG_JACK_CAP_CH_ENABLE_A 0x00000420u /* low bits: 0x3=both */
+#define SN624X_REG_JACK_CAP_CH_ENABLE_B 0x00000430u
+
+#define SN624X_REG_JACK_FUN_STATUS_CTL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_ENTITY0, \
+ SN624X_SDCA_CTL_FUNCTION_STATUS, 0)
+#define SN624X_JACK_FUN_NEEDS_INIT BIT(5)
+#define SN624X_JACK_FUN_HAS_BEEN_RESET BIT(6)
+
+/* DMIC capture (function 2) */
+#define SN624X_REG_DMIC_CAP_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_L)
+#define SN624X_REG_DMIC_CAP_CHR_VOL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_VOLUME, SN624X_SDCA_CH_R)
+/* Q7.8 channel volume: integer in bits 15:8, fraction in bits 7:0 */
+#define SN624X_VOL_Q78(int_part, frac_part) \
+ ((((unsigned int)(int_part) & 0xff) << 8) | ((unsigned int)(frac_part) & 0xff))
+#define SN624X_REG_DMIC_CAP_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_L)
+#define SN624X_REG_DMIC_CAP_CHR_MUTE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_USER_FU14, \
+ SN624X_SDCA_CTL_FU_MUTE, SN624X_SDCA_CH_R)
+#define SN624X_REG_DMIC_CAP_RATE_SEL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_CS02, \
+ SN624X_SDCA_CTL_SAMPLE_FREQ_INDEX, 0)
+/* OEM sheet used ctl=0; SDCA Actual PS is 0x10 — poll the standard selector */
+#define SN624X_REG_DMIC_CAP_PWR_STATE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_ACTUAL_PS, 0)
+#define SN624X_REG_DMIC_CAP_PWR_STATE_WRITE \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_PDE03, \
+ SDCA_CTL_PDE_REQUESTED_PS, 0)
+#define SN624X_REG_DMIC_CAP_CH_ENABLE_A 0x00000520u /* low bits: 0x3=both */
+#define SN624X_REG_DMIC_CAP_CH_ENABLE_B 0x00000530u
+
+#define SN624X_REG_DMIC_FUN_STATUS_CTL \
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_MIC_ARRAY, SN624X_SDCA_ENT_ENTITY0, \
+ SN624X_SDCA_CTL_FUNCTION_STATUS, 0)
+
+/*
+ * Write REQUESTED_PS then poll ACTUAL_PS with the shared SDCA helper
+ * (sdca_asoc_pde_poll_actual_ps). Caller must not hand-roll ACTUAL_PS waits.
+ */
+static int sn624x_pde_request_ps(struct device *dev, struct regmap *regmap,
+ unsigned int fun, unsigned int ent,
+ unsigned int ps);
+
+/*
+ * DAPM PDE supplies (rt711/rt712 style): write REQUESTED_PS then poll ACTUAL_PS.
+ * Mute-before-D3 is handled by FU widget PRE_PMD, which runs before SUPPLY PRE_PMD
+ * when the FU lists the PDE as a dependency.
+ */
+static int sn624x_dapm_pde_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event,
+ unsigned int fun, unsigned int ent)
+{
+ struct snd_soc_component *component =
+ snd_soc_dapm_to_component(w->dapm);
+ struct sn624x_sdca_priv *sn624x =
+ snd_soc_component_get_drvdata(component);
+ struct device *dev = component->dev;
+ int ret;
+
+ if (!sn624x || !sn624x->regmap)
+ return -ENODEV;
+
+ switch (event) {
+ case SND_SOC_DAPM_POST_PMU:
+ ret = sn624x_pde_request_ps(dev, sn624x->regmap, fun, ent,
+ SN624X_PWR_D0);
+ if (ret < 0)
+ dev_warn(dev,
+ "sn624x: DAPM %s PDE fun=%u ent=0x%x -> PS0 failed (%d)\n",
+ w->name, fun, ent, ret);
+ break;
+ case SND_SOC_DAPM_PRE_PMD:
+ ret = sn624x_pde_request_ps(dev, sn624x->regmap, fun, ent,
+ SN624X_PWR_D3);
+ if (ret < 0)
+ dev_warn(dev,
+ "sn624x: DAPM %s PDE fun=%u ent=0x%x -> PS3 failed (%d)\n",
+ w->name, fun, ent, ret);
+ break;
+ default:
+ return 0;
+ }
+ return ret;
+}
+
+static int sn624x_pde_hp_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_dapm_pde_event(w, kcontrol, event,
+ SN624X_FUNC_NUM_JACK_CODEC,
+ SN624X_SDCA_ENT_PDE03);
+}
+
+static int sn624x_pde_spk_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_dapm_pde_event(w, kcontrol, event,
+ SN624X_FUNC_NUM_SPEAKER_AMP,
+ SN624X_SDCA_ENT_PDE03);
+}
+
+static int sn624x_pde_mic2_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_dapm_pde_event(w, kcontrol, event,
+ SN624X_FUNC_NUM_JACK_CODEC,
+ SN624X_SDCA_ENT_PDE04);
+}
+
+static int sn624x_pde_dmic_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_dapm_pde_event(w, kcontrol, event,
+ SN624X_FUNC_NUM_MIC_ARRAY,
+ SN624X_SDCA_ENT_PDE03);
+}
+
+static int sn624x_fu_mute_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event,
+ unsigned int mute_l, unsigned int mute_r,
+ unsigned int vol_l, unsigned int vol_r,
+ unsigned int vol_val)
+{
+ struct snd_soc_component *component =
+ snd_soc_dapm_to_component(w->dapm);
+ struct sn624x_sdca_priv *sn624x =
+ snd_soc_component_get_drvdata(component);
+ struct device *dev = component->dev;
+ int ret;
+
+ if (!sn624x || !sn624x->regmap)
+ return -ENODEV;
+
+ switch (event) {
+ case SND_SOC_DAPM_POST_PMU:
+ if (vol_l) {
+ ret = regmap_write(sn624x->regmap, vol_l, vol_val);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s vol(L) failed (%d)\n",
+ w->name, ret);
+ }
+ if (vol_r) {
+ ret = regmap_write(sn624x->regmap, vol_r, vol_val);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s vol(R) failed (%d)\n",
+ w->name, ret);
+ }
+ ret = regmap_write(sn624x->regmap, mute_l, 0);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s unmute(L) failed (%d)\n",
+ w->name, ret);
+ if (mute_r) {
+ ret = regmap_write(sn624x->regmap, mute_r, 0);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s unmute(R) failed (%d)\n",
+ w->name, ret);
+ }
+ break;
+ case SND_SOC_DAPM_PRE_PMD:
+ /* Mute and settle before PDE SUPPLY PRE_PMD takes the domain to PS3 */
+ ret = regmap_write(sn624x->regmap, mute_l, SN624X_MUTE_ON);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s mute(L) failed (%d)\n",
+ w->name, ret);
+ if (mute_r) {
+ ret = regmap_write(sn624x->regmap, mute_r, SN624X_MUTE_ON);
+ if (ret < 0)
+ dev_warn(dev, "sn624x: DAPM %s mute(R) failed (%d)\n",
+ w->name, ret);
+ }
+ usleep_range(SN624X_ROUTE_AFTER_MUTE_US_MIN,
+ SN624X_ROUTE_AFTER_MUTE_US_MAX);
+ break;
+ default:
+ break;
+ }
+ return 0;
+}
+
+static int sn624x_fu_hp_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_fu_mute_event(w, kcontrol, event,
+ SN624X_REG_JACK_OUT_MUTE, 0,
+ SN624X_REG_JACK_OUT_VOL,
+ SN624X_REG_JACK_OUT_CHR_VOL, 0);
+}
+
+static int sn624x_fu_spk_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_fu_mute_event(w, kcontrol, event,
+ SN624X_REG_MUTE, SN624X_REG_RIGHT_MUTE,
+ SN624X_REG_VOL, SN624X_REG_CHR_VOL, 0);
+}
+
+static int sn624x_fu_mic2_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ struct snd_soc_component *component =
+ snd_soc_dapm_to_component(w->dapm);
+ struct sn624x_sdca_priv *sn624x =
+ snd_soc_component_get_drvdata(component);
+ int ret;
+
+ if (event == SND_SOC_DAPM_POST_PMU && sn624x)
+ sn624x_uaj_ge35_apply_detected_mode(component->dev, sn624x);
+
+ ret = sn624x_fu_mute_event(w, kcontrol, event,
+ SN624X_REG_JACK_CAP_MUTE, 0,
+ SN624X_REG_JACK_CAP_VOL,
+ SN624X_REG_JACK_CAP_CHR_VOL,
+ SN624X_VOL_Q78(6, 0));
+ return ret;
+}
+
+static int sn624x_fu_dmic_event(struct snd_soc_dapm_widget *w,
+ struct snd_kcontrol *kcontrol, int event)
+{
+ return sn624x_fu_mute_event(w, kcontrol, event,
+ SN624X_REG_DMIC_CAP_MUTE,
+ SN624X_REG_DMIC_CAP_CHR_MUTE,
+ SN624X_REG_DMIC_CAP_VOL,
+ SN624X_REG_DMIC_CAP_CHR_VOL,
+ SN624X_VOL_Q78(6, 0));
+}
+
+static int sn624x_pde_request_ps(struct device *dev, struct regmap *regmap,
+ unsigned int fun, unsigned int ent,
+ unsigned int ps)
+{
+ static const struct sdca_pde_delay delays[] = {
+ { .from_ps = SDCA_PDE_PS0, .to_ps = SDCA_PDE_PS3,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ { .from_ps = SDCA_PDE_PS3, .to_ps = SDCA_PDE_PS0,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ { .from_ps = SDCA_PDE_PS1, .to_ps = SDCA_PDE_PS0,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ { .from_ps = SDCA_PDE_PS2, .to_ps = SDCA_PDE_PS0,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ { .from_ps = SDCA_PDE_PS0, .to_ps = SDCA_PDE_PS0,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ { .from_ps = SDCA_PDE_PS3, .to_ps = SDCA_PDE_PS3,
+ .us = SN624X_PDE_PS_POLL_BUDGET_US },
+ };
+ unsigned int req = SDW_SDCA_CTL(fun, ent, SDCA_CTL_PDE_REQUESTED_PS, 0);
+ unsigned int act = SDW_SDCA_CTL(fun, ent, SDCA_CTL_PDE_ACTUAL_PS, 0);
+ unsigned int from_ps = SDCA_PDE_PS3;
+ int ret;
+
+ ret = regmap_read(regmap, act, &from_ps);
+ if (ret < 0) {
+ dev_warn(dev,
+ "sn624x: PDE fun=%u ent=0x%x ACTUAL_PS read failed (%d)\n",
+ fun, ent, ret);
+ from_ps = (ps == SN624X_PWR_D0) ? SN624X_PWR_D3 : SN624X_PWR_D0;
+ } else {
+ from_ps &= 0xffu;
+ }
+
+ ret = regmap_write(regmap, req, ps);
+ if (ret < 0) {
+ dev_warn(dev,
+ "sn624x: PDE fun=%u ent=0x%x REQUESTED_PS=%u write failed (%d)\n",
+ fun, ent, ps, ret);
+ return ret;
+ }
+
+ ret = sdca_asoc_pde_poll_actual_ps(regmap, fun, ent,
+ from_ps, ps,
+ delays, ARRAY_SIZE(delays));
+ if (ret < 0)
+ dev_warn(dev,
+ "sn624x: PDE fun=%u ent=0x%x ACTUAL_PS poll failed (%d; want %u)\n",
+ fun, ent, ret, ps);
+ return ret;
+}
+
+static void sn624x_jack_type_from_det_mode(struct sn624x_sdca_priv *sn624x,
+ unsigned int det_mode)
+{
+ switch (det_mode) {
+ case 0x00:
+ sn624x->jack_type = 0;
+ break;
+ case 0x03:
+ sn624x->jack_type = SND_JACK_HEADPHONE;
+ break;
+ case 0x05:
+ sn624x->jack_type = SND_JACK_HEADSET;
+ break;
+ default:
+ SN624X_DBG(&sn624x->slave->dev,
+ "unknown GE35 detected_mode 0x%x\n", det_mode);
+ sn624x->jack_type = 0;
+ break;
+ }
+}
+
+static int sn624x_uaj_ge35_select_mode(struct device *dev,
+ struct sn624x_sdca_priv *sn624x,
+ unsigned int mode)
+{
+ int ret;
+
+ ret = regmap_write(sn624x->regmap,
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC,
+ SN624X_SDCA_ENT_GE35,
+ SN624X_SDCA_CTL_SELECTED_MODE, 0),
+ mode);
+ if (ret < 0)
+ dev_warn(dev,
+ "sn624x: jack_cap: GE35 SELECTED_MODE=0x%x failed (%d)\n",
+ mode, ret);
+ else
+ dev_dbg(dev,
+ "sn624x: jack_cap: GE35 SELECTED_MODE=0x%x\n",
+ mode);
+ return ret;
+}
+
+/*
+ * Follow DETECTED_MODE → SELECTED_MODE (rt711/rt722 pattern). Never force
+ * headset: mic path is only valid when the jack hardware reports one.
+ * Also updates sn624x->jack_type from DETECTED_MODE.
+ */
+static int sn624x_uaj_ge35_apply_detected_mode(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ unsigned int det_mode = 0;
+ int ret;
+
+ ret = regmap_read(sn624x->regmap,
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC,
+ SN624X_SDCA_ENT_GE35,
+ SN624X_SDCA_CTL_DETECTED_MODE, 0),
+ &det_mode);
+ if (ret < 0) {
+ dev_warn(dev,
+ "sn624x: jack_cap: GE35 DETECTED_MODE read failed (%d)\n",
+ ret);
+ return ret;
+ }
+
+ dev_dbg(dev, "sn624x: jack_cap: GE35 DETECTED_MODE=0x%x\n", det_mode);
+ sn624x_jack_type_from_det_mode(sn624x, det_mode);
+
+ if (!det_mode) {
+ dev_dbg(dev,
+ "sn624x: jack_cap: no jack detected — skip SELECTED_MODE\n");
+ return 0;
+ }
+
+ return sn624x_uaj_ge35_select_mode(dev, sn624x, det_mode);
+}
+
+static const char *sn624x_status_str(enum sdw_slave_status status)
+{
+ switch (status) {
+ case SDW_SLAVE_UNATTACHED:
+ return "UNATTACHED";
+ case SDW_SLAVE_ATTACHED:
+ return "ATTACHED";
+ case SDW_SLAVE_ALERT:
+ return "ALERT";
+ case SDW_SLAVE_RESERVED:
+ return "RESERVED";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+static int sn624x_sdca_mbq_size(struct device *dev, unsigned int reg)
+{
+ if (!SDW_SDCA_VALID_CTL(reg))
+ return 1;
+
+ /*
+ * FU_VOLUME and GE35 DETECTED_MODE share control selector 0x02.
+ * Only list known FU volume addresses as 16-bit MBQ — matching
+ * DETECTED_MODE by csel alone makes GE35 use SDW_SDCA_MBQ_CTL and
+ * fails with -ENODATA (-61), which breaks jack plug/unplug.
+ */
+ switch (reg) {
+ case SN624X_REG_VOL:
+ case SN624X_REG_CHR_VOL:
+ case SN624X_REG_JACK_OUT_VOL:
+ case SN624X_REG_JACK_OUT_CHR_VOL:
+ case SN624X_REG_JACK_CAP_VOL:
+ case SN624X_REG_JACK_CAP_CHR_VOL:
+ case SN624X_REG_DMIC_CAP_VOL:
+ case SN624X_REG_DMIC_CAP_CHR_VOL:
+ return 2;
+ default:
+ return 1;
+ }
+}
+
+static bool sn624x_sdca_volatile_register(struct device *dev, unsigned int reg)
+{
+ if (!SDW_SDCA_VALID_CTL(reg))
+ return true;
+
+ switch (reg) {
+ case SN624X_REG_PWR_STATE:
+ case SN624X_REG_JACK_OUT_PWR_STATE:
+ case SN624X_REG_JACK_CAP_PWR_STATE:
+ case SN624X_REG_DMIC_CAP_PWR_STATE:
+ case SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_SDCA_ENT_GE35,
+ SN624X_SDCA_CTL_DETECTED_MODE, 0):
+ return true;
+ default:
+ if (SDW_SDCA_CTL_CSEL(reg) == SDCA_CTL_PDE_ACTUAL_PS)
+ return true;
+ return false;
+ }
+}
+
+static const struct regmap_sdw_mbq_cfg sn624x_sdca_mbq_cfg = {
+ .mbq_size = sn624x_sdca_mbq_size,
+};
+
+static const struct regmap_config sn624x_sdca_regmap = {
+ .reg_bits = 32,
+ .val_bits = 16,
+ .volatile_reg = sn624x_sdca_volatile_register,
+ .max_register = 0xffffffff,
+ .cache_type = REGCACHE_MAPLE,
+ .use_single_read = true,
+ .use_single_write = true,
+};
+
+/*
+ * Prefer ACPI mipi-sdca-function-initialization-table (sdca_regmap_write_init).
+ * sdca_parse_function() loads that table before entity parsing, so a later
+ * DisCo parse failure can still leave fn->num_init_table usable.
+ */
+static int sn624x_write_sdca_init_table(struct device *dev,
+ struct sn624x_sdca_priv *sn624x,
+ struct sdca_function_data *fn,
+ const char *label)
+{
+ int ret;
+
+ if (!fn || !fn->num_init_table)
+ return -ENOENT;
+
+ ret = sdca_regmap_write_init(dev, sn624x->regmap, fn);
+ if (ret < 0) {
+ dev_warn(dev,
+ "sn624x: %s function-initialization-table write failed (%d)\n",
+ label, ret);
+ return ret;
+ }
+
+ dev_info(dev,
+ "sn624x: applied %s function-initialization-table (%d writes)\n",
+ label, fn->num_init_table);
+ return 0;
+}
+
+/*
+ * Temporary vendor-window fallback when ACPI has no init table.
+ * Validated on current platforms; remove once DisCo init tables are complete.
+ */
+static int sn624x_jack_oem_fallback_init(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ static const struct reg_sequence jack_oem_table[] = {
+ REG_SEQ0(SN624X_UAJ_CTL_IT33_MIC_BIAS, 0x06),
+ REG_SEQ0(SN624X_UAJ_CTL_IT31_MIC_BIAS, 0x06),
+ REG_SEQ0(SN624X_UAJ_CTL_FU41_CH1_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU41_CH2_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU31_CH0_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU32_CH0_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU33_CH0_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU36_CH1_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU36_CH2_MUTE, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU31_CH0_GAIN_HIGH, 0x12),
+ REG_SEQ0(SN624X_UAJ_CTL_FU31_CH0_GAIN_LOW, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU32_CH0_GAIN_HIGH, 0x0C),
+ REG_SEQ0(SN624X_UAJ_CTL_FU32_CH0_GAIN_LOW, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_FU33_CH0_GAIN_HIGH, 0x12),
+ REG_SEQ0(SN624X_UAJ_CTL_FU33_CH0_GAIN_LOW, 0x00),
+ REG_SEQ0(SN624X_UAJ_CTL_INPUT_DELAY_TIME, 0x0F),
+ REG_SEQ0(SN624X_UAJ_CTL_PORTA_CHARGE_PUMP, 0x0B),
+ };
+ int ret;
+
+ dev_warn_once(dev,
+ "sn624x: using temporary jack OEM init fallback (no ACPI init table)\n");
+ ret = regmap_multi_reg_write_bypassed(sn624x->regmap, jack_oem_table,
+ ARRAY_SIZE(jack_oem_table));
+ if (ret < 0) {
+ dev_warn(dev, "sn624x: jack OEM fallback failed (%d)\n", ret);
+ return ret;
+ }
+ usleep_range(1000, 1500);
+ return 0;
+}
+
+static int sn624x_dmic_oem_fallback_init(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ static const struct reg_sequence dmic_oem_table[] = {
+ REG_SEQ0(0x00002041, 0x00),
+ REG_SEQ0(SN624X_UAJ_DMIC_PPU11, 0x30),
+ REG_SEQ0(0x00002105, 0x66),
+ REG_SEQ0(0x00002107, 0x26),
+ REG_SEQ0(0x00002109, 0x62),
+ REG_SEQ0(0x40800a09, 0x00),
+ REG_SEQ0(0x40800a0a, 0x00),
+ REG_SEQ0(0x40802a11, 0x00),
+ REG_SEQ0(0x40800a11, 0x00),
+ REG_SEQ0(0x40802a12, 0x00),
+ REG_SEQ0(0x40800a12, 0x00),
+ REG_SEQ0(0x40802a13, 0x00),
+ REG_SEQ0(0x40800a13, 0x00),
+ REG_SEQ0(0x40802a14, 0x00),
+ REG_SEQ0(0x40800a14, 0x00),
+ REG_SEQ0(0x408029d8, 0x0c),
+ REG_SEQ0(0x408009d8, 0x00),
+ REG_SEQ0(0x408029d9, 0x0c),
+ REG_SEQ0(0x408009d9, 0x00),
+ REG_SEQ0(0x00002140, 0x18),
+ REG_SEQ0(0x00002045, 0x01),
+ };
+ int ret;
+
+ dev_warn_once(dev,
+ "sn624x: using temporary dmic OEM init fallback (no ACPI init table)\n");
+ ret = regmap_multi_reg_write_bypassed(sn624x->regmap, dmic_oem_table,
+ ARRAY_SIZE(dmic_oem_table));
+ if (ret < 0) {
+ dev_warn(dev, "sn624x: dmic OEM fallback failed (%d)\n", ret);
+ return ret;
+ }
+ usleep_range(1000, 1500);
+ return 0;
+}
+
+static void sn624x_uaj_apply_io_defaults(struct sn624x_sdca_priv *sn624x)
+{
+ struct device *dev = &sn624x->slave->dev;
+ int ret;
+
+ ret = sn624x_write_sdca_init_table(dev, sn624x, sn624x->jack_func,
+ "jack");
+ if (ret)
+ sn624x_jack_oem_fallback_init(dev, sn624x);
+}
+
+static int sn624x_parse_sdca_functions(struct sn624x_sdca_priv *sn624x)
+{
+ struct sdw_slave *slave = sn624x->slave;
+ struct device *dev = &slave->dev;
+ int i, ret;
+
+ if (!slave->sdca_data.num_functions) {
+ dev_dbg(dev, "sn624x: no SDCA function descriptors from DisCo\n");
+ return 0;
+ }
+
+ for (i = 0; i < slave->sdca_data.num_functions; i++) {
+ struct sdca_function_desc *desc = &slave->sdca_data.function[i];
+ struct sdca_function_data *fn;
+ bool is_jack = false, is_mic = false, is_amp = false;
+
+ switch (desc->type) {
+ case SDCA_FUNCTION_TYPE_UAJ:
+ case SDCA_FUNCTION_TYPE_SIMPLE_JACK:
+ case SDCA_FUNCTION_TYPE_RJ:
+ is_jack = true;
+ break;
+ case SDCA_FUNCTION_TYPE_SMART_MIC:
+ case SDCA_FUNCTION_TYPE_SIMPLE_MIC:
+ is_mic = true;
+ break;
+ case SDCA_FUNCTION_TYPE_SMART_AMP:
+ case SDCA_FUNCTION_TYPE_SIMPLE_AMP:
+ case SDCA_FUNCTION_TYPE_SPEAKER_MIC:
+ is_amp = true;
+ break;
+ default:
+ break;
+ }
+
+ if (desc->adr == SN624X_FUNC_NUM_JACK_CODEC)
+ is_jack = true;
+ else if (desc->adr == SN624X_FUNC_NUM_MIC_ARRAY)
+ is_mic = true;
+ else if (desc->adr == SN624X_FUNC_NUM_SPEAKER_AMP)
+ is_amp = true;
+
+ if (!is_jack && !is_mic && !is_amp)
+ continue;
+
+ fn = devm_kzalloc(dev, sizeof(*fn), GFP_KERNEL);
+ if (!fn)
+ return -ENOMEM;
+
+ fn->desc = desc;
+ ret = sdca_parse_function(dev, fn);
+ if (ret) {
+ /*
+ * sdca_parse_function() reads the ACPI
+ * mipi-sdca-function-initialization-table first,
+ * then parses entities/controls. On some platforms
+ * DisCo entity data is incomplete so the later
+ * steps fail (-EINVAL), but fn->init_table is
+ * already filled. Keep that partial function so
+ * io_init can still apply the ACPI table; if the
+ * table was never loaded, drop this function and
+ * let the OEM register fallback run instead.
+ */
+ dev_warn(dev,
+ "sn624x: sdca_parse_function(%s adr=%u) failed (%d)%s\n",
+ desc->name ? desc->name : "?", desc->adr, ret,
+ fn->num_init_table ?
+ ", keeping ACPI init table" : "");
+ if (!fn->num_init_table)
+ continue;
+ } else {
+ dev_dbg(dev,
+ "sn624x: parsed SDCA function %s type=%u adr=%u init_writes=%d\n",
+ desc->name ? desc->name : "?", desc->type,
+ desc->adr, fn->num_init_table);
+ }
+
+ if (is_jack && !sn624x->jack_func)
+ sn624x->jack_func = fn;
+ else if (is_mic && !sn624x->mic_func)
+ sn624x->mic_func = fn;
+ else if (is_amp && !sn624x->amp_func)
+ sn624x->amp_func = fn;
+ }
+
+ return 0;
+}
+
+/*
+ * Poll-driven jack detect: pulse UAJ jack-detect, then apply GE35
+ * DETECTED_MODE → SELECTED_MODE via sn624x_uaj_ge35_apply_detected_mode().
+ */
+static int sn624x_sdca_headset_detect(struct sn624x_sdca_priv *sn624x)
+{
+ struct device *dev = &sn624x->slave->dev;
+ int ret;
+
+ SN624X_DBG(dev, "headset_detect: pulse UAJ jack-detect, read GE35\n");
+ ret = regmap_write(sn624x->regmap,
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC,
+ SN624X_UAJ_ENT_BLOCK,
+ SN624X_UAJ_CTL_JACK_DETECT, 0),
+ 0x08);
+ if (ret < 0)
+ goto io_error;
+
+ usleep_range(5000, 5500);
+
+ ret = sn624x_uaj_ge35_apply_detected_mode(dev, sn624x);
+
+ /* Clear the detect pulse even if GE35 apply failed. */
+ regmap_write(sn624x->regmap,
+ SDW_SDCA_CTL(SN624X_FUNC_NUM_JACK_CODEC, SN624X_UAJ_ENT_BLOCK,
+ SN624X_UAJ_CTL_JACK_DETECT, 0),
+ 0x00);
+
+ if (ret < 0)
+ goto io_error;
+
+ SN624X_DBG(dev, "headset_detect: jack_type=0x%x\n", sn624x->jack_type);
+ return 0;
+
+io_error:
+ if (ret == -ENODATA)
+ SN624X_DBG(dev, "%s: UAJ/GE35 access ignored (-ENODATA)\n",
+ __func__);
+ else
+ dev_err_ratelimited(dev, "%s failed (%d)\n", __func__, ret);
+ return ret;
+}
+
+static void sn624x_sdca_sdca_irq_mask_all(struct sn624x_sdca_priv *sn624x)
+{
+ if (!sn624x->slave)
+ return;
+
+ sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INTMASK1, 0);
+ sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INTMASK2, 0);
+ sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INTMASK3, 0);
+ sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INTMASK4, 0);
+ SN624X_DBG(&sn624x->slave->dev,
+ "SDCA INTMASK1-4 = 0 (all SDCA sources masked)\n");
+}
+
+static void sn624x_sdca_jack_irq_unmask(struct sn624x_sdca_priv *sn624x)
+{
+ /* Jack detection is poll-driven; SDCA jack IRQs remain masked. */
+ (void)sn624x;
+}
+
+static void sn624x_sdca_jack_irq_mask(struct sn624x_sdca_priv *sn624x)
+{
+ if (!sn624x->slave)
+ return;
+
+ sn624x_sdca_sdca_irq_mask_all(sn624x);
+}
+
+/*
+ * Hold a runtime PM reference for the lifetime of jack detection so the
+ * device cannot autosuspend while the poll worker needs register access.
+ */
+static int sn624x_jack_rpm_get(struct sn624x_sdca_priv *sn624x)
+{
+ struct device *dev;
+ int ret;
+
+ if (!sn624x)
+ return -EINVAL;
+ if (sn624x->jack_rpm)
+ return 0;
+ if (!sn624x->component)
+ return -ENODEV;
+
+ dev = sn624x->component->dev;
+ ret = pm_runtime_resume_and_get(dev);
+ if (ret < 0) {
+ if (ret != -EACCES) {
+ dev_err(dev, "sn624x: jack rpm get failed (%d)\n", ret);
+ return ret;
+ }
+ /* pm_runtime not enabled yet (before first ATTACHED io_init) */
+ return 0;
+ }
+
+ sn624x->jack_rpm = true;
+ return 0;
+}
+
+static void sn624x_jack_rpm_put(struct sn624x_sdca_priv *sn624x)
+{
+ if (!sn624x || !sn624x->jack_rpm || !sn624x->component)
+ return;
+
+ pm_runtime_mark_last_busy(sn624x->component->dev);
+ pm_runtime_put_autosuspend(sn624x->component->dev);
+ sn624x->jack_rpm = false;
+}
+
+static void sn624x_jack_schedule_poll(struct sn624x_sdca_priv *sn624x)
+{
+ if (!sn624x || !sn624x->hs_jack || !sn624x->slave)
+ return;
+
+ mod_delayed_work(system_power_efficient_wq, &sn624x->jack_detect_work,
+ msecs_to_jiffies(SN624X_JACK_POLL_MS));
+}
+
+static void sn624x_sdca_jack_poll_and_report(struct sn624x_sdca_priv *sn624x)
+{
+ struct device *dev;
+
+ if (!sn624x->hs_jack || !sn624x->slave)
+ return;
+
+ dev = &sn624x->slave->dev;
+ if (sn624x_sdca_headset_detect(sn624x) < 0)
+ return;
+
+ snd_soc_jack_report(sn624x->hs_jack, sn624x->jack_type,
+ SND_JACK_HEADSET | SND_JACK_HEADPHONE);
+ sn624x->jack_type_last = sn624x->jack_type;
+ dev_dbg(dev, "sn624x: jack polled: detected_mode -> jack_type=0x%x\n",
+ sn624x->jack_type);
+}
+
+static void sn624x_sdca_jack_detect_handler(struct work_struct *work)
+{
+ struct sn624x_sdca_priv *sn624x =
+ container_of(work, struct sn624x_sdca_priv, jack_detect_work.work);
+ struct device *dev;
+
+ if (!sn624x->slave) {
+ sn624x_jack_schedule_poll(sn624x);
+ return;
+ }
+
+ dev = &sn624x->slave->dev;
+
+ if (!sn624x->hs_jack) {
+ SN624X_DBG(dev, "jack_work: skip (no hs_jack)\n");
+ goto out_reschedule;
+ }
+
+ /* Registers are only valid after ATTACHED → io_init (hw_init). */
+ if (!sn624x->hw_init) {
+ SN624X_DBG(dev, "jack_work: skip (hw_init not ready)\n");
+ goto out_reschedule;
+ }
+
+ /* Poll GE35 every interval; do not rely on SDCA_0 IRQ or PCM activity */
+ sn624x_sdca_headset_detect(sn624x);
+
+ if (sn624x->jack_type != sn624x->jack_type_last) {
+ dev_dbg(dev,
+ "sn624x: jack event: %s (jack_type=0x%x; HP=0x%x HS=0x%x)\n",
+ sn624x->jack_type ? "plug" : "unplug",
+ sn624x->jack_type, SND_JACK_HEADPHONE, SND_JACK_HEADSET);
+ sn624x->jack_type_last = sn624x->jack_type;
+
+ snd_soc_jack_report(sn624x->hs_jack, sn624x->jack_type,
+ SND_JACK_HEADSET | SND_JACK_HEADPHONE);
+ }
+
+out_reschedule:
+ sn624x_jack_schedule_poll(sn624x);
+}
+
+static void sn624x_sdca_jack_init(struct sn624x_sdca_priv *sn624x)
+{
+ /* No machine set_jack() yet — not "jack unsupported". */
+ if (!sn624x->hs_jack)
+ return;
+
+ sn624x_sdca_jack_irq_unmask(sn624x);
+ sn624x_sdca_jack_poll_and_report(sn624x);
+ sn624x_jack_schedule_poll(sn624x);
+
+ dev_dbg(&sn624x->slave->dev,
+ "sn624x: jack_init: poll scheduled every %ums\n", SN624X_JACK_POLL_MS);
+}
+
+static int sn624x_sdca_set_jack_detect(struct snd_soc_component *component,
+ struct snd_soc_jack *hs_jack, void *data)
+{
+ struct sn624x_sdca_priv *sn624x = snd_soc_component_get_drvdata(component);
+ int ret;
+
+ dev_dbg(component->dev,
+ "sn624x: set_jack: hs_jack=%p first_hw_init=%d hw_init=%d\n",
+ hs_jack, sn624x->first_hw_init, sn624x->hw_init);
+
+ if (!hs_jack) {
+ cancel_delayed_work_sync(&sn624x->jack_detect_work);
+ sn624x->hs_jack = NULL;
+ sn624x_jack_rpm_put(sn624x);
+ return 0;
+ }
+
+ /*
+ * Component registration happens before runtime PM is enabled (RPM is
+ * enabled from io_init on first ATTACHED). Do not touch runtime PM
+ * until then, or get/put counts can go out of sync.
+ */
+ if (!sn624x->first_hw_init) {
+ sn624x->hs_jack = hs_jack;
+ sn624x->jack_type_last = -1;
+ sn624x_jack_schedule_poll(sn624x);
+ return 0;
+ }
+
+ /*
+ * Take the runtime PM reference before publishing hs_jack, so a
+ * failed get cannot leave jack detection marked as enabled.
+ */
+ ret = sn624x_jack_rpm_get(sn624x);
+ if (ret < 0)
+ return ret;
+
+ sn624x->hs_jack = hs_jack;
+ sn624x->jack_type_last = -1;
+ sn624x_sdca_jack_init(sn624x);
+ return 0;
+}
+
+/* Prefer ACPI init table; OEM vendor-window fallback only if absent. */
+static int sn624x_jack_apply_defaults(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ int ret;
+
+ if (!sn624x || !sn624x->regmap || !sn624x->slave)
+ return -ENODEV;
+
+ ret = sn624x_write_sdca_init_table(dev, sn624x, sn624x->jack_func,
+ "jack");
+ if (ret == 0) {
+ usleep_range(1000, 1500);
+ return 0;
+ }
+
+ return sn624x_jack_oem_fallback_init(dev, sn624x);
+}
+
+static int sn624x_dmic_apply_defaults(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ int ret;
+
+ if (!sn624x || !sn624x->regmap || !sn624x->slave)
+ return -ENODEV;
+
+ ret = sn624x_write_sdca_init_table(dev, sn624x, sn624x->mic_func,
+ "dmic");
+ if (ret == 0) {
+ usleep_range(1000, 1500);
+ return 0;
+ }
+
+ return sn624x_dmic_oem_fallback_init(dev, sn624x);
+}
+
+static int sn624x_sdca_jack_function_init(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ unsigned int jack_func_status;
+ const struct reg_sequence clear_status =
+ REG_SEQ0(SN624X_REG_JACK_FUN_STATUS_CTL, 0x61);
+ int ret;
+
+ ret = regmap_read_bypassed(sn624x->regmap,
+ SN624X_REG_JACK_FUN_STATUS_CTL,
+ &jack_func_status);
+ if (ret < 0)
+ return ret;
+
+ if (!(jack_func_status & (SN624X_JACK_FUN_NEEDS_INIT |
+ SN624X_JACK_FUN_HAS_BEEN_RESET)))
+ return 0;
+
+ ret = sn624x_jack_apply_defaults(dev, sn624x);
+ if (ret < 0)
+ return ret;
+
+ ret = regmap_multi_reg_write_bypassed(sn624x->regmap, &clear_status, 1);
+ if (ret < 0)
+ return ret;
+
+ usleep_range(1000, 1500);
+ return 0;
+}
+
+static int sn624x_sdca_dmic_function_init(struct device *dev,
+ struct sn624x_sdca_priv *sn624x)
+{
+ unsigned int dmic_func_status;
+ const struct reg_sequence clear_status =
+ REG_SEQ0(SN624X_REG_DMIC_FUN_STATUS_CTL, 0x61);
+ int ret;
+
+ ret = regmap_read_bypassed(sn624x->regmap,
+ SN624X_REG_DMIC_FUN_STATUS_CTL,
+ &dmic_func_status);
+ if (ret < 0)
+ return ret;
+
+ if (!(dmic_func_status & (SN624X_JACK_FUN_NEEDS_INIT |
+ SN624X_JACK_FUN_HAS_BEEN_RESET)))
+ return 0;
+
+ ret = sn624x_dmic_apply_defaults(dev, sn624x);
+ if (ret < 0)
+ return ret;
+
+ ret = regmap_multi_reg_write_bypassed(sn624x->regmap, &clear_status, 1);
+ if (ret < 0)
+ return ret;
+
+ usleep_range(1000, 1500);
+ return 0;
+}
+
+static int sn624x_sdca_io_init(struct device *dev, struct sdw_slave *slave)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(dev);
+ int ret;
+
+ if (sn624x->hw_init) {
+ SN624X_DBG(dev, "io_init: skip (hw_init already true)\n");
+ return 0;
+ }
+
+ SN624X_DBG(dev, "io_init: start (first hardware bring-up)\n");
+ sn624x->disable_irq = false;
+
+ sn624x_sdca_sdca_irq_mask_all(sn624x);
+
+ regcache_cache_only(sn624x->regmap, false);
+ if (!sn624x->first_hw_init) {
+ /*
+ * PM runtime is only enabled when a Slave reports as Attached
+ * (same pattern as rt722).
+ */
+ pm_runtime_set_autosuspend_delay(dev, 3000);
+ pm_runtime_use_autosuspend(dev);
+ pm_runtime_set_active(dev);
+ pm_runtime_mark_last_busy(dev);
+ pm_runtime_enable(dev);
+ }
+
+ pm_runtime_get_noresume(dev);
+
+ sn624x_uaj_apply_io_defaults(sn624x);
+
+ /*
+ * set_jack() may have run before RPM was enabled (-EACCES). Take the
+ * long-lived jack PM ref now that runtime PM is active.
+ */
+ if (sn624x->hs_jack) {
+ sn624x_jack_rpm_get(sn624x);
+ sn624x_sdca_jack_init(sn624x);
+ }
+
+ ret = sn624x_sdca_jack_function_init(dev, sn624x);
+ if (ret < 0) {
+ dev_err(dev, "sn624x: jack function init failed (%d)\n", ret);
+ goto err;
+ }
+
+ ret = sn624x_sdca_dmic_function_init(dev, sn624x);
+ if (ret < 0) {
+ dev_err(dev, "sn624x: dmic function init failed (%d)\n", ret);
+ goto err;
+ }
+
+ /*
+ * Re-attach after bus reset: force a full cache write-back on the
+ * following resume/sync path (same idea as rt722).
+ */
+ if (sn624x->first_hw_init)
+ regcache_mark_dirty(sn624x->regmap);
+
+ sn624x->hw_init = true;
+ sn624x->first_hw_init = true;
+
+ pm_runtime_put_autosuspend(dev);
+
+ SN624X_DBG(dev, "io_init: complete (hw_init set), jack %s\n",
+ sn624x->hs_jack ? "registered" : "not registered yet");
+ return 0;
+
+err:
+ pm_runtime_put_noidle(dev);
+ return ret;
+}
+
+/*
+ * Bus lifecycle (same as rt722): enumerate → assign dev_num → ATTACHED →
+ * io_init(). Do not poll enumeration/init around each register access; after
+ * unattach, resume uses sdw_slave_wait_for_init() then regcache_sync.
+ */
+static int sn624x_sdca_update_status(struct sdw_slave *slave,
+ enum sdw_slave_status status)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(&slave->dev);
+ bool need_io_init;
+ int ret;
+
+ SN624X_DBG(&slave->dev, "update_status: %s hw_init=%d dev_num=%u\n",
+ sn624x_status_str(status), sn624x->hw_init, slave->dev_num);
+
+ if (status == SDW_SLAVE_UNATTACHED) {
+ cancel_delayed_work_sync(&sn624x->jack_detect_work);
+ sn624x->hw_init = false;
+ SN624X_DBG(&slave->dev,
+ "slave UNATTACHED: cleared hw_init, jack work cancelled\n");
+ }
+
+ if (status != SDW_SLAVE_ATTACHED)
+ return 0;
+
+ sn624x_sdca_sdca_irq_mask_all(sn624x);
+
+ need_io_init = !sn624x->hw_init;
+ if (need_io_init) {
+ dev_notice(&slave->dev, "sn624x: update_status ATTACHED -> io_init()\n");
+ ret = sn624x_sdca_io_init(&slave->dev, slave);
+ if (ret < 0)
+ return ret;
+ } else {
+ dev_dbg(&slave->dev,
+ "sn624x: update_status ATTACHED: io_init already done\n");
+ }
+
+ /* Re-ATTACHED without io_init: restore jack detect after bus is up. */
+ if (sn624x->hs_jack && sn624x->hw_init && !need_io_init) {
+ sn624x_sdca_jack_irq_unmask(sn624x);
+ sn624x_sdca_jack_poll_and_report(sn624x);
+ sn624x_jack_schedule_poll(sn624x);
+ }
+
+ return 0;
+}
+
+static int sn624x_sdca_read_prop(struct sdw_slave *slave)
+{
+ struct sdw_slave_prop *prop = &slave->prop;
+ struct sdw_dpn_prop *dpn;
+ unsigned long addr;
+ unsigned int bit;
+ int nval;
+ int i, j;
+
+ sdw_slave_read_lane_mapping(slave);
+ prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
+ prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
+ prop->paging_support = true;
+ prop->use_domain_irq = true;
+ prop->wake_capable = true;
+
+ prop->source_ports = BIT(SN624X_PORT_JACK_CAPTURE) |
+ BIT(SN624X_PORT_DMIC_CAPTURE);
+ prop->sink_ports = BIT(SN624X_PORT_JACK_PLAYBACK) |
+ BIT(SN624X_PORT_SPEAKER_PLAYBACK);
+
+ nval = hweight32(prop->source_ports);
+ prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
+ sizeof(*prop->src_dpn_prop), GFP_KERNEL);
+ if (!prop->src_dpn_prop)
+ return -ENOMEM;
+ i = 0;
+ dpn = prop->src_dpn_prop;
+ addr = prop->source_ports;
+ for_each_set_bit(bit, &addr, 32) {
+ dpn[i].num = bit;
+ dpn[i].type = SDW_DPN_FULL;
+ dpn[i].simple_ch_prep_sm = true;
+ dpn[i].ch_prep_timeout = 10;
+ i++;
+ }
+ nval = hweight32(prop->sink_ports);
+ prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
+ sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
+ if (!prop->sink_dpn_prop)
+ return -ENOMEM;
+ j = 0;
+ dpn = prop->sink_dpn_prop;
+ addr = prop->sink_ports;
+ for_each_set_bit(bit, &addr, 32) {
+ dpn[j].num = bit;
+ dpn[j].type = SDW_DPN_FULL;
+ dpn[j].simple_ch_prep_sm = true;
+ dpn[j].ch_prep_timeout = 10;
+ j++;
+ }
+ prop->clk_stop_timeout = 900;
+ prop->simple_clk_stop_capable = true;
+ prop->lane_control_support = true;
+ SN624X_DBG(&slave->dev,
+ "read_prop: src_ports=0x%x sink_ports=0x%x lane irq paging\n",
+ prop->source_ports, prop->sink_ports);
+
+ return 0;
+}
+
+/*
+ * Clear SDCA INT1/2 only. DP0_INT standard fields (PORT_READY, etc.) are
+ * owned by the SoundWire bus core; cascade clears when SDCA status is clear.
+ * Pending SDCA IRQs can block clock-stop prepare (CLK_STP_NF -> -ETIMEDOUT).
+ */
+static int sn624x_sdca_flush_pending_irqs(struct sn624x_sdca_priv *sn624x,
+ struct device *dev)
+{
+ int ret, stat = 0;
+ int count = 0;
+ const int retry = 3;
+ unsigned int scp_sdca_stat1, scp_sdca_stat2 = 0;
+
+ if (!sn624x || !sn624x->slave)
+ return 0;
+
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT1);
+ if (ret < 0)
+ return ret;
+ sn624x->scp_sdca_stat1 = ret;
+
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT2);
+ if (ret < 0)
+ return ret;
+ sn624x->scp_sdca_stat2 = ret;
+
+ do {
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT1);
+ if (ret < 0)
+ return ret;
+ if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) {
+ ret = sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INT1,
+ SDW_SCP_SDCA_INTMASK_SDCA_0);
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT2);
+ if (ret < 0)
+ return ret;
+ if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) {
+ ret = sdw_write_no_pm(sn624x->slave, SDW_SCP_SDCA_INT2,
+ SDW_SCP_SDCA_INTMASK_SDCA_8);
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT1);
+ if (ret < 0)
+ return ret;
+ scp_sdca_stat1 = ret & SDW_SCP_SDCA_INTMASK_SDCA_0;
+
+ ret = sdw_read_no_pm(sn624x->slave, SDW_SCP_SDCA_INT2);
+ if (ret < 0)
+ return ret;
+ scp_sdca_stat2 = ret & SDW_SCP_SDCA_INTMASK_SDCA_8;
+
+ stat = scp_sdca_stat1 || scp_sdca_stat2;
+ count++;
+ } while (stat != 0 && count < retry);
+
+ if (stat && dev)
+ dev_warn(dev,
+ "sn624x: SDCA IRQ flush incomplete (stat=%u)\n", stat);
+
+ return stat ? -EBUSY : 0;
+}
+
+static int sn624x_sdca_interrupt_callback(struct sdw_slave *slave,
+ struct sdw_slave_intr_status *status)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(&slave->dev);
+ int ret;
+
+ if (!sn624x)
+ return 0;
+
+ /*
+ * Bus expects the codec to clear SCP SDCA INT1/2 when cascade is set.
+ * Leaving them set can stall alert handling.
+ */
+
+ SN624X_DBG(&slave->dev,
+ "irq: control_port=%#x sdca_cascade=%u disable_irq=%d\n",
+ status->control_port, status->sdca_cascade, sn624x->disable_irq);
+
+ cancel_delayed_work_sync(&sn624x->jack_detect_work);
+
+ mutex_lock(&sn624x->disable_irq_lock);
+
+ ret = sn624x_sdca_flush_pending_irqs(sn624x, &slave->dev);
+ if (ret < 0 && ret != -EBUSY)
+ goto io_error;
+
+ SN624X_DBG(&slave->dev, "irq: INT1=0x%x INT2=0x%x\n",
+ sn624x->scp_sdca_stat1, sn624x->scp_sdca_stat2);
+
+ /*
+ * Always restart the jack poll after IRQ handling so a cancel above
+ * cannot stop detection. SDCA INTMASK stays masked; any residual SCP
+ * IRQ still triggers an early poll. The poll itself does the UAJ
+ * pulse + GE35 read.
+ */
+ if (!sn624x->disable_irq)
+ sn624x_jack_schedule_poll(sn624x);
+
+ mutex_unlock(&sn624x->disable_irq_lock);
+ return 0;
+
+io_error:
+ mutex_unlock(&sn624x->disable_irq_lock);
+ dev_err_ratelimited(&slave->dev, "%s: IO error (%d)\n", __func__, ret);
+ return ret;
+}
+
+static const struct sdw_slave_ops sn624x_sdca_slave_ops = {
+ .read_prop = sn624x_sdca_read_prop,
+ .interrupt_callback = sn624x_sdca_interrupt_callback,
+ .update_status = sn624x_sdca_update_status,
+};
+
+static int sn624x_sdca_probe(struct snd_soc_component *component)
+{
+ struct sn624x_sdca_priv *sn624x = snd_soc_component_get_drvdata(component);
+ int ret;
+
+ sn624x->component = component;
+
+ if (!sn624x->first_hw_init)
+ return 0;
+
+ ret = pm_runtime_resume(component->dev);
+ if (ret < 0 && ret != -EACCES)
+ return ret;
+
+ return 0;
+}
+
+static int sn624x_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_component *component = dai->component;
+ struct sn624x_sdca_priv *sn624x = snd_soc_component_get_drvdata(component);
+ struct sdw_stream_config stream_config = {};
+ struct sdw_port_config port_config = {};
+ struct sdw_stream_runtime *sdw_stream;
+ unsigned int sampling_rate;
+ int port;
+ int ret;
+
+ dev_dbg(dai->dev,
+ "sn624x: hw_params: entered dai=%s id=%d stream=%s\n",
+ dai->name, dai->id, snd_pcm_stream_str(substream));
+
+ sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
+ if (!sdw_stream) {
+ dev_warn(dai->dev,
+ "sn624x: hw_params: no SDW stream (set_stream not run yet?)\n");
+ return -EINVAL;
+ }
+ if (!sn624x->slave) {
+ dev_warn(dai->dev, "sn624x: hw_params: slave NULL\n");
+ return -EINVAL;
+ }
+
+ ret = pm_runtime_resume(component->dev);
+ if (ret < 0 && ret != -EACCES) {
+ dev_err(dai->dev,
+ "sn624x: hw_params: pm_runtime_resume failed (%d)\n", ret);
+ return ret;
+ }
+
+ snd_sdw_params_to_config(substream, params, &stream_config, &port_config);
+
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ if (dai->id == SN624X_DAI_JACK)
+ port = SN624X_PORT_JACK_PLAYBACK;
+ else if (dai->id == SN624X_DAI_SPEAKER)
+ port = SN624X_PORT_SPEAKER_PLAYBACK;
+ else
+ return -EINVAL;
+ } else {
+ if (dai->id == SN624X_DAI_JACK)
+ port = SN624X_PORT_JACK_CAPTURE;
+ else if (dai->id == SN624X_DAI_DMIC)
+ port = SN624X_PORT_DMIC_CAPTURE;
+ else
+ return -EINVAL;
+ }
+ port_config.num = port;
+
+ ret = sdw_stream_add_slave(sn624x->slave, &stream_config,
+ &port_config, 1, sdw_stream);
+ if (ret) {
+ dev_err(dai->dev, "%s: sdw_stream_add_slave port %d failed: %d\n",
+ __func__, port, ret);
+ return ret;
+ }
+
+ /* SDCA SampleFreqIndex (same encoding as other SDCA codecs) */
+ switch (params_rate(params)) {
+ case 44100:
+ sampling_rate = SN624X_SDCA_RATE_44100HZ;
+ break;
+ case 48000:
+ sampling_rate = SN624X_SDCA_RATE_48000HZ;
+ break;
+ case 96000:
+ sampling_rate = SN624X_SDCA_RATE_96000HZ;
+ break;
+ case 192000:
+ sampling_rate = SN624X_SDCA_RATE_192000HZ;
+ break;
+ default:
+ dev_err(dai->dev, "%s: Rate %d is not supported\n",
+ __func__, params_rate(params));
+ return -EINVAL;
+ }
+
+ if (dai->id == SN624X_DAI_JACK) {
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
+ ret = regmap_write(sn624x->regmap,
+ SN624X_REG_JACK_OUT_RATE_SEL,
+ sampling_rate);
+ else
+ ret = regmap_write(sn624x->regmap,
+ SN624X_REG_JACK_CAP_RATE_SEL,
+ sampling_rate);
+ } else if (dai->id == SN624X_DAI_SPEAKER) {
+ ret = regmap_write(sn624x->regmap, SN624X_REG_RATE_SEL,
+ sampling_rate);
+ } else if (dai->id == SN624X_DAI_DMIC) {
+ ret = regmap_write(sn624x->regmap, SN624X_REG_DMIC_CAP_RATE_SEL,
+ sampling_rate);
+ } else {
+ return -EINVAL;
+ }
+
+ return ret;
+}
+
+static int sn624x_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct sn624x_sdca_priv *sn624x = snd_soc_component_get_drvdata(dai->component);
+ struct sdw_stream_runtime *sdw_stream =
+ snd_soc_dai_get_dma_data(dai, substream);
+
+ if (!sn624x->slave)
+ return -EINVAL;
+
+ return sdw_stream_remove_slave(sn624x->slave, sdw_stream);
+}
+
+static int sn624x_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
+ int direction)
+{
+ snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
+ return 0;
+}
+
+static void sn624x_sdca_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ snd_soc_dai_set_dma_data(dai, substream, NULL);
+}
+
+static const struct snd_soc_dapm_widget sn624x_sdca_dapm_widgets[] = {
+ SND_SOC_DAPM_AIF_IN("RX", "Playback", 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_OUT("TX", "Capture", 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_IN("SPK RX", "Speaker Playback", 0, SND_SOC_NOPM, 0, 0),
+ SND_SOC_DAPM_AIF_OUT("DMIC TX", "DMic Capture", 0, SND_SOC_NOPM, 0, 0),
+
+ SND_SOC_DAPM_SUPPLY("PDE HP", SND_SOC_NOPM, 0, 0,
+ sn624x_pde_hp_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_SUPPLY("PDE SPK", SND_SOC_NOPM, 0, 0,
+ sn624x_pde_spk_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_SUPPLY("PDE MIC2", SND_SOC_NOPM, 0, 0,
+ sn624x_pde_mic2_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_SUPPLY("PDE DMIC", SND_SOC_NOPM, 0, 0,
+ sn624x_pde_dmic_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+ SND_SOC_DAPM_DAC_E("FU HP", NULL, SND_SOC_NOPM, 0, 0,
+ sn624x_fu_hp_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_DAC_E("FU SPK", NULL, SND_SOC_NOPM, 0, 0,
+ sn624x_fu_spk_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_ADC_E("FU MIC2", NULL, SND_SOC_NOPM, 0, 0,
+ sn624x_fu_mic2_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+ SND_SOC_DAPM_ADC_E("FU DMIC", NULL, SND_SOC_NOPM, 0, 0,
+ sn624x_fu_dmic_event,
+ SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
+
+ SND_SOC_DAPM_OUTPUT("HP"),
+ SND_SOC_DAPM_OUTPUT("SPK"),
+ SND_SOC_DAPM_INPUT("MIC2"),
+ SND_SOC_DAPM_INPUT("DMIC"),
+};
+
+static const struct snd_soc_dapm_route sn624x_sdca_audio_map[] = {
+ { "FU HP", NULL, "RX" },
+ { "FU HP", NULL, "PDE HP" },
+ { "HP", NULL, "FU HP" },
+
+ { "FU SPK", NULL, "SPK RX" },
+ { "FU SPK", NULL, "PDE SPK" },
+ { "SPK", NULL, "FU SPK" },
+
+ { "FU MIC2", NULL, "MIC2" },
+ { "FU MIC2", NULL, "PDE MIC2" },
+ /* UAJ headset capture also needs jack PDE03 (shared with HP) */
+ { "FU MIC2", NULL, "PDE HP" },
+ { "TX", NULL, "FU MIC2" },
+
+ { "FU DMIC", NULL, "DMIC" },
+ { "FU DMIC", NULL, "PDE DMIC" },
+ { "DMIC TX", NULL, "FU DMIC" },
+};
+
+static const struct snd_soc_dai_ops sn624x_sdca_ops = {
+ .hw_params = sn624x_sdca_pcm_hw_params,
+ .hw_free = sn624x_sdca_pcm_hw_free,
+ .set_stream = sn624x_sdca_set_sdw_stream,
+ .shutdown = sn624x_sdca_shutdown,
+};
+
+static struct snd_soc_dai_driver sn624x_sdca_dai[] = {
+ {
+ .name = "sn624x-sdca-aif",
+ .id = 0,
+ .playback = {
+ .stream_name = "Playback",
+ .channels_min = 1,
+ .channels_max = 2,
+ .rates = SN624X_STEREO_RATES,
+ .formats = SN624X_FORMATS,
+ },
+ .capture = {
+ .stream_name = "Capture",
+ .channels_min = 1,
+ .channels_max = 2,
+ .rates = SN624X_STEREO_RATES,
+ .formats = SN624X_FORMATS,
+ },
+ .ops = &sn624x_sdca_ops,
+ },
+ {
+ .name = "sn624x-sdca-aif2",
+ .id = 1,
+ .playback = {
+ .stream_name = "Speaker Playback",
+ .channels_min = 1,
+ .channels_max = 2,
+ .rates = SN624X_STEREO_RATES,
+ .formats = SN624X_FORMATS,
+ },
+ .ops = &sn624x_sdca_ops,
+ },
+ {
+ .name = "sn624x-sdca-aif3",
+ .id = 2,
+ .capture = {
+ .stream_name = "DMic Capture",
+ .channels_min = 1,
+ .channels_max = 4,
+ .rates = SN624X_STEREO_RATES,
+ .formats = SN624X_FORMATS,
+ },
+ .ops = &sn624x_sdca_ops,
+ },
+};
+
+static const struct snd_soc_component_driver soc_sdca_dev_sn624x = {
+ .probe = sn624x_sdca_probe,
+ .dapm_widgets = sn624x_sdca_dapm_widgets,
+ .num_dapm_widgets = ARRAY_SIZE(sn624x_sdca_dapm_widgets),
+ .dapm_routes = sn624x_sdca_audio_map,
+ .num_dapm_routes = ARRAY_SIZE(sn624x_sdca_audio_map),
+ .set_jack = sn624x_sdca_set_jack_detect,
+ .endianness = 1,
+};
+
+int sn624x_sdca_init(struct device *dev, struct regmap *regmap,
+ struct sdw_slave *slave)
+{
+ struct sn624x_sdca_priv *sn624x;
+ int ret;
+
+ sn624x = devm_kzalloc(dev, sizeof(*sn624x), GFP_KERNEL);
+ if (!sn624x)
+ return -ENOMEM;
+
+ dev_set_drvdata(dev, sn624x);
+ sn624x->slave = slave;
+ sn624x->regmap = regmap;
+
+ ret = sn624x_parse_sdca_functions(sn624x);
+ if (ret < 0)
+ return ret;
+
+ mutex_init(&sn624x->disable_irq_lock);
+ INIT_DELAYED_WORK(&sn624x->jack_detect_work, sn624x_sdca_jack_detect_handler);
+
+ regcache_cache_only(sn624x->regmap, true);
+
+ ret = devm_snd_soc_register_component(dev,
+ &soc_sdca_dev_sn624x, sn624x_sdca_dai,
+ ARRAY_SIZE(sn624x_sdca_dai));
+ if (ret < 0)
+ return ret;
+
+ /*
+ * Do not enable runtime PM here. SoundWire slaves are only powered /
+ * accessible after ATTACHED; enable RPM from io_init() then.
+ */
+ SN624X_DBG(dev, "snd_soc_register_component OK (DAI sn624x-sdca-aif)\n");
+ return 0;
+}
+
+static int sn624x_sdca_sdw_probe(struct sdw_slave *slave,
+ const struct sdw_device_id *id)
+{
+ struct regmap *regmap;
+ int ret;
+
+ SN624X_DBG(&slave->dev, "sdw_probe: dev_num=%u status=%s\n",
+ slave->dev_num, sn624x_status_str(slave->status));
+
+ regmap = devm_regmap_init_sdw_mbq_cfg(&slave->dev, slave,
+ &sn624x_sdca_regmap,
+ &sn624x_sdca_mbq_cfg);
+ if (IS_ERR(regmap)) {
+ dev_err(&slave->dev, "sn624x: devm_regmap_init_sdw_mbq_cfg failed (%ld)\n",
+ PTR_ERR(regmap));
+ return PTR_ERR(regmap);
+ }
+
+ ret = sn624x_sdca_init(&slave->dev, regmap, slave);
+ if (ret < 0)
+ dev_err(&slave->dev, "sn624x: sn624x_sdca_init failed (%d)\n", ret);
+ else {
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(&slave->dev);
+
+ if (sn624x)
+ sn624x_sdca_sdca_irq_mask_all(sn624x);
+ SN624X_DBG(&slave->dev, "SoundWire probe finished OK\n");
+ }
+
+ return ret;
+}
+
+static void sn624x_sdca_sdw_remove(struct sdw_slave *slave)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(&slave->dev);
+
+ SN624X_DBG(&slave->dev, "SoundWire driver remove\n");
+ cancel_delayed_work_sync(&sn624x->jack_detect_work);
+ sn624x_jack_rpm_put(sn624x);
+ if (sn624x->first_hw_init)
+ pm_runtime_disable(&slave->dev);
+ mutex_destroy(&sn624x->disable_irq_lock);
+}
+
+static const struct sdw_device_id sn624x_sdca_id[] = {
+ SDW_SLAVE_ENTRY_EXT(0x0496, 0x6242, 0x3, 0x1, 0),
+ SDW_SLAVE_ENTRY_EXT(0x0496, 0x6244, 0x3, 0x1, 0),
+ SDW_SLAVE_ENTRY_EXT(0x0496, 0x6247, 0x3, 0x1, 0),
+ { }
+};
+MODULE_DEVICE_TABLE(sdw, sn624x_sdca_id);
+
+static int sn624x_sdca_dev_suspend(struct device *dev)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(dev);
+
+ if (!sn624x->first_hw_init)
+ return 0;
+
+ regcache_cache_only(sn624x->regmap, true);
+ /*
+ * Suspend / clock-stop may reset the peripheral. Mark the cache dirty
+ * so resume's regcache_sync restores software state to hardware.
+ */
+ regcache_mark_dirty(sn624x->regmap);
+
+ return 0;
+}
+
+static int sn624x_sdca_dev_system_suspend(struct device *dev)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(dev);
+
+ if (!sn624x->first_hw_init)
+ return 0;
+
+ /* Mask first so IRQ cannot re-schedule work between cancel and disable. */
+ mutex_lock(&sn624x->disable_irq_lock);
+ sn624x->disable_irq = true;
+ sn624x_sdca_jack_irq_mask(sn624x);
+ mutex_unlock(&sn624x->disable_irq_lock);
+
+ cancel_delayed_work_sync(&sn624x->jack_detect_work);
+
+ return sn624x_sdca_dev_suspend(dev);
+}
+
+static int sn624x_sdca_regmap_resume(struct device *dev)
+{
+ struct sdw_slave *slave = dev_to_sdw_dev(dev);
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(dev);
+ int ret;
+
+ if (!sn624x->first_hw_init)
+ return 0;
+
+ SN624X_DBG(dev, "resume: unattach_request=%u\n", slave->unattach_request);
+ if (slave->unattach_request) {
+ ret = sdw_slave_wait_for_init(slave, SN624X_PROBE_TIMEOUT_MS);
+ if (ret) {
+ sdw_show_ping_status(slave->bus, true);
+ return ret;
+ }
+ }
+
+ regcache_cache_only(sn624x->regmap, false);
+ regcache_sync(sn624x->regmap);
+
+ return 0;
+}
+
+static int sn624x_sdca_dev_resume(struct device *dev)
+{
+ return sn624x_sdca_regmap_resume(dev);
+}
+
+static int sn624x_sdca_dev_system_resume(struct device *dev)
+{
+ struct sn624x_sdca_priv *sn624x = dev_get_drvdata(dev);
+ int ret;
+
+ ret = sn624x_sdca_regmap_resume(dev);
+ if (ret < 0)
+ return ret;
+
+ mutex_lock(&sn624x->disable_irq_lock);
+ if (sn624x->disable_irq) {
+ sn624x_sdca_jack_irq_unmask(sn624x);
+ sn624x->disable_irq = false;
+ }
+ mutex_unlock(&sn624x->disable_irq_lock);
+
+ if (sn624x->hs_jack && sn624x->hw_init) {
+ sn624x_sdca_jack_poll_and_report(sn624x);
+ sn624x_jack_schedule_poll(sn624x);
+ }
+
+ return 0;
+}
+
+static const struct dev_pm_ops sn624x_sdca_pm = {
+ SYSTEM_SLEEP_PM_OPS(sn624x_sdca_dev_system_suspend, sn624x_sdca_dev_system_resume)
+ RUNTIME_PM_OPS(sn624x_sdca_dev_suspend, sn624x_sdca_dev_resume, NULL)
+};
+
+static struct sdw_driver sn624x_sdca_sdw_driver = {
+ .driver = {
+ .name = "sn624x-sdca",
+ .pm = pm_ptr(&sn624x_sdca_pm),
+ },
+ .probe = sn624x_sdca_sdw_probe,
+ .remove = sn624x_sdca_sdw_remove,
+ .ops = &sn624x_sdca_slave_ops,
+ .id_table = sn624x_sdca_id,
+};
+module_sdw_driver(sn624x_sdca_sdw_driver);
+
+MODULE_DESCRIPTION("ASoC SN624X SDCA SoundWire driver with UAJ jack support");
+MODULE_AUTHOR("Senary Semiconductor Corp.");
+MODULE_LICENSE("GPL");
+MODULE_IMPORT_NS("SND_SOC_SDCA");
+MODULE_SOFTDEP("pre: snd-soc-sdca");
diff --git a/sound/soc/codecs/sn624x-sdca.h b/sound/soc/codecs/sn624x-sdca.h
new file mode 100644
index 000000000000..6eb588ba2b3b
--- /dev/null
+++ b/sound/soc/codecs/sn624x-sdca.h
@@ -0,0 +1,152 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * sn624x-sdca.h -- SN624X SDCA ALSA SoC audio driver header
+ *
+ * Copyright(c) 2025 Senary Semiconductor Corp.
+ */
+
+#ifndef __SN624X_H__
+#define __SN624X_H__
+
+#include <linux/mutex.h>
+#include <linux/soundwire/sdw.h>
+#include <linux/workqueue.h>
+#include <sound/sdca_function.h>
+#include <sound/soc.h>
+
+struct sn624x_sdca_priv {
+ struct regmap *regmap;
+ struct snd_soc_component *component;
+ struct sdw_slave *slave;
+ /* Parsed DisCo functions (init tables / defaults from ACPI) */
+ struct sdca_function_data *jack_func;
+ struct sdca_function_data *mic_func;
+ struct sdca_function_data *amp_func;
+ bool hw_init;
+ bool first_hw_init;
+ struct snd_soc_jack *hs_jack;
+ struct delayed_work jack_detect_work;
+ struct mutex disable_irq_lock;
+ bool disable_irq;
+ /* Long-lived runtime PM ref while jack detection is enabled */
+ bool jack_rpm;
+ int jack_type;
+ int jack_type_last;
+ unsigned int scp_sdca_stat1;
+ unsigned int scp_sdca_stat2;
+};
+
+/* SoundWire data port numbers (slave prop source/sink port masks) */
+#define SN624X_PORT_JACK_PLAYBACK 1
+#define SN624X_PORT_SPEAKER_PLAYBACK 2
+#define SN624X_PORT_JACK_CAPTURE 4
+#define SN624X_PORT_DMIC_CAPTURE 5
+
+/* Order matches sn624x_sdca_dai[] .id */
+enum sn624x_dai_id {
+ SN624X_DAI_JACK = 0,
+ SN624X_DAI_SPEAKER = 1,
+ SN624X_DAI_DMIC = 2,
+};
+
+/*
+ * SDCA Function Numbers (from platform ACPI / device topology).
+ * Address with SDW_SDCA_CTL(fun, ent, ctl, ch) from sdw_registers.h.
+ */
+#define SN624X_FUNC_NUM_JACK_CODEC 0x01
+#define SN624X_FUNC_NUM_MIC_ARRAY 0x02
+#define SN624X_FUNC_NUM_SPEAKER_AMP 0x04
+
+/* Entity instance IDs (from platform ACPI / SN624X topology) */
+#define SN624X_SDCA_ENT_ENTITY0 0x00
+#define SN624X_SDCA_ENT_CS01 0x01
+#define SN624X_SDCA_ENT_CS02 0x02
+#define SN624X_SDCA_ENT_PDE03 0x03
+#define SN624X_SDCA_ENT_PDE04 0x04
+#define SN624X_SDCA_ENT_CRU05 0x05
+#define SN624X_SDCA_ENT_USER_FU10 0x10
+#define SN624X_SDCA_ENT_USER_FU14 0x14
+#define SN624X_SDCA_ENT_USER_FU1E 0x1e
+#define SN624X_UAJ_ENT_BLOCK 0x20
+#define SN624X_SDCA_ENT_GE35 0x1F
+/* UAJ power domains from ssdt26.dsl AF01 entity list (PDE 34 / PDE 47) */
+#define SN624X_UAJ_ENT_PDE47 SN624X_SDCA_ENT_PDE03
+#define SN624X_UAJ_ENT_PDE34 SN624X_SDCA_ENT_PDE04
+
+/* Control selectors (SDCA; same values as sound/sdca_function.h) */
+/* PDE power state selectors — use standard SDCA defines from sdca_function.h */
+#define SN624X_SDCA_CTL_FU_MUTE 0x01
+#define SN624X_SDCA_CTL_FU_VOLUME 0x02
+#define SN624X_SDCA_CTL_SAMPLE_FREQ_INDEX 0x10
+#define SN624X_SDCA_CTL_CLUSTER_INDEX 0x10
+#define SN624X_SDCA_CTL_FUNCTION_STATUS 0x10 /* Entity 0 */
+#define SN624X_SDCA_CTL_SELECTED_MODE 0x01
+#define SN624X_SDCA_CTL_DETECTED_MODE 0x02
+
+/*
+ * Control Number / channel for multi-channel FU controls (mute/volume).
+ * Single-value controls (PDE power, rate, function status, …) pass 0
+ * directly to SDW_SDCA_CTL — no CH_0 alias.
+ */
+#define SN624X_SDCA_CH_L 0x01
+#define SN624X_SDCA_CH_R 0x02
+
+/* GE35 Selected_Mode / Detected_Mode (SDCA Table 153, UAJ §5.5) */
+#define SN624X_GE35_MODE_HEADPHONE 0x03
+#define SN624X_GE35_MODE_HEADSET 0x05
+
+/* Vendor UAJ SCP windows */
+#define SN624X_UAJ_CTL_INPUT_DELAY 0x30
+#define SN624X_UAJ_CTL_CHARGE_PUMP 0x31
+#define SN624X_UAJ_CTL_JACK_DETECT 0x32
+
+/*
+ * Vendor SCP addresses used only when ACPI
+ * mipi-sdca-function-initialization-table is missing (temporary fallback).
+ * Remove once platform DisCo ships a complete init table.
+ */
+#define SN624X_UAJ_CTL_IT33_MIC_BIAS 0x40400418
+#define SN624X_UAJ_CTL_IT31_MIC_BIAS 0x40400318
+#define SN624X_UAJ_CTL_FU41_CH1_MUTE 0x40400A09
+#define SN624X_UAJ_CTL_FU41_CH2_MUTE 0x40400A0A
+#define SN624X_UAJ_CTL_FU31_CH0_MUTE 0x40400C08
+#define SN624X_UAJ_CTL_FU32_CH0_MUTE 0x40400C88
+#define SN624X_UAJ_CTL_FU33_CH0_MUTE 0x40400D08
+#define SN624X_UAJ_CTL_FU36_CH1_MUTE 0x40400F09
+#define SN624X_UAJ_CTL_FU36_CH2_MUTE 0x40400F0A
+#define SN624X_UAJ_CTL_FU31_CH0_GAIN_HIGH 0x40402C58
+#define SN624X_UAJ_CTL_FU31_CH0_GAIN_LOW 0x40400C58
+#define SN624X_UAJ_CTL_FU32_CH0_GAIN_HIGH 0x40402CD8
+#define SN624X_UAJ_CTL_FU32_CH0_GAIN_LOW 0x40400CD8
+#define SN624X_UAJ_CTL_FU33_CH0_GAIN_HIGH 0x40402D58
+#define SN624X_UAJ_CTL_FU33_CH0_GAIN_LOW 0x40400D58
+#define SN624X_UAJ_CTL_INPUT_DELAY_TIME 0x00002124
+#define SN624X_UAJ_CTL_PORTA_CHARGE_PUMP 0x00002086
+#define SN624X_UAJ_DMIC_PPU11 0x40880380
+
+/* Jack poll interval (ms) */
+#define SN624X_JACK_POLL_MS 1000
+
+/* µs settle times for headphone <-> speaker route switch during active PCM */
+#define SN624X_ROUTE_AFTER_MUTE_US_MIN 5000
+#define SN624X_ROUTE_AFTER_MUTE_US_MAX 8000
+#define SN624X_ROUTE_AFTER_D3_US_MIN 10000
+#define SN624X_ROUTE_AFTER_D3_US_MAX 15000
+#define SN624X_ROUTE_BEFORE_ACTIVE_US_MIN 10000
+#define SN624X_ROUTE_BEFORE_ACTIVE_US_MAX 15000
+
+/* SDCA SampleFreqIndex (same encoding as other SDCA codecs, e.g. rt722) */
+#define SN624X_SDCA_RATE_44100HZ 0x08
+#define SN624X_SDCA_RATE_48000HZ 0x09
+#define SN624X_SDCA_RATE_96000HZ 0x0b
+#define SN624X_SDCA_RATE_192000HZ 0x0d
+
+#define SN624X_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \
+ SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
+#define SN624X_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
+ SNDRV_PCM_FMTBIT_S24_LE)
+
+int sn624x_sdca_init(struct device *dev, struct regmap *regmap,
+ struct sdw_slave *slave);
+
+#endif /* __SN624X_H__ */
--
2.47.3
^ permalink raw reply related [flat|nested] 4+ messages in thread* [PATCH v4 2/3] ASoC: sdw_utils: add Senary SN624x helpers and codec_info
2026-08-18 2:08 [PATCH v4 0/3] ASoC: add Senary SN624x SoundWire SDCA support Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 1/3] ASoC: codecs: add SN624x SDCA SoundWire driver Qianghua Wang
@ 2026-08-18 2:08 ` Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 3/3] ASoC: Intel: soc-acpi: add SN624x entries for ARL/LNL/MTL/PTL Qianghua Wang
2 siblings, 0 replies; 4+ messages in thread
From: Qianghua Wang @ 2026-08-18 2:08 UTC (permalink / raw)
To: linux-sound
Cc: Qianghua Wang, Mark Brown, Pierre-Louis Bossart, Bard Liao,
Liam Girdwood, Peter Ujfalusi, Kai Vehmanen, Cezary Rojewski,
Charles Keepax, bo liu
Add sof_sdw helpers for SN624x jack, amp, and DMIC, and register the
codec_info entries used by the Intel SOF SoundWire machine driver.
Use name_prefix "sn624x" to match UCM and DAI widget naming.
Signed-off-by: Qianghua Wang <qianghua.wang@senarytech.com>
---
include/sound/soc_sdw_utils.h | 20 ++
sound/soc/sdw_utils/Makefile | 4 +-
sound/soc/sdw_utils/soc_sdw_senary_amp.c | 80 +++++++
sound/soc/sdw_utils/soc_sdw_senary_dmic.c | 49 +++++
sound/soc/sdw_utils/soc_sdw_senary_sdca.c | 63 ++++++
.../soc_sdw_senary_sdca_jack_common.c | 197 ++++++++++++++++++
sound/soc/sdw_utils/soc_sdw_utils.c | 166 +++++++++++++++
7 files changed, 578 insertions(+), 1 deletion(-)
create mode 100644 sound/soc/sdw_utils/soc_sdw_senary_amp.c
create mode 100644 sound/soc/sdw_utils/soc_sdw_senary_dmic.c
create mode 100644 sound/soc/sdw_utils/soc_sdw_senary_sdca.c
create mode 100644 sound/soc/sdw_utils/soc_sdw_senary_sdca_jack_common.c
diff --git a/include/sound/soc_sdw_utils.h b/include/sound/soc_sdw_utils.h
index 79c21966220b..e8bdc20a75f6 100644
--- a/include/sound/soc_sdw_utils.h
+++ b/include/sound/soc_sdw_utils.h
@@ -293,4 +293,24 @@ int asoc_sdw_es9356_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai
int asoc_sdw_es9356_spk_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai);
int asoc_sdw_es9356_dmic_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai);
+/* Senary SN624x SDCA */
+int asoc_sdw_senary_sdca_jack_init(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_links,
+ struct asoc_sdw_codec_info *info,
+ bool playback);
+int asoc_sdw_senary_sdca_jack_exit(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_link);
+int asoc_sdw_senary_sdca_jack_rtd_init(struct snd_soc_pcm_runtime *rtd,
+ struct snd_soc_dai *dai);
+int asoc_sdw_senary_amp_init(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_links,
+ struct asoc_sdw_codec_info *info,
+ bool playback);
+int asoc_sdw_senary_amp_exit(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_link);
+int asoc_sdw_senary_sdca_spk_rtd_init(struct snd_soc_pcm_runtime *rtd,
+ struct snd_soc_dai *dai);
+int asoc_sdw_senary_dmic_rtd_init(struct snd_soc_pcm_runtime *rtd,
+ struct snd_soc_dai *dai);
+
#endif
diff --git a/sound/soc/sdw_utils/Makefile b/sound/soc/sdw_utils/Makefile
index 5ae8c69b8b98..1dbc00a2d64a 100644
--- a/sound/soc/sdw_utils/Makefile
+++ b/sound/soc/sdw_utils/Makefile
@@ -10,5 +10,7 @@ snd-soc-sdw-utils-y := soc_sdw_utils.o soc_sdw_dmic.o soc_sdw_rt_dmic.o \
soc_sdw_cs_amp.o \
soc_sdw_es9356.o \
soc_sdw_maxim.o \
- soc_sdw_ti_amp.o
+ soc_sdw_ti_amp.o \
+ soc_sdw_senary_sdca.o soc_sdw_senary_sdca_jack_common.o \
+ soc_sdw_senary_amp.o soc_sdw_senary_dmic.o
obj-$(CONFIG_SND_SOC_SDW_UTILS) += snd-soc-sdw-utils.o
diff --git a/sound/soc/sdw_utils/soc_sdw_senary_amp.c b/sound/soc/sdw_utils/soc_sdw_senary_amp.c
new file mode 100644
index 000000000000..9370402ab4c7
--- /dev/null
+++ b/sound/soc/sdw_utils/soc_sdw_senary_amp.c
@@ -0,0 +1,80 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// This file incorporates work covered by the following copyright notice:
+// Copyright (c) 2022 Intel Corporation
+// Copyright (c) 2024 Advanced Micro Devices, Inc.
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <sound/control.h>
+#include <sound/soc.h>
+#include <sound/soc-acpi.h>
+#include <sound/soc-dapm.h>
+#include <linux/soundwire/sdw.h>
+#include <linux/soundwire/sdw_type.h>
+#include <sound/soc_sdw_utils.h>
+
+static int senary_amp_add_device_props(struct device *sdw_dev)
+{
+ return 0;
+}
+
+int asoc_sdw_senary_amp_exit(struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
+{
+ struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
+
+ if (ctx->amp_dev1) {
+ device_remove_software_node(ctx->amp_dev1);
+ put_device(ctx->amp_dev1);
+ }
+
+ if (ctx->amp_dev2) {
+ device_remove_software_node(ctx->amp_dev2);
+ put_device(ctx->amp_dev2);
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_amp_exit, "SND_SOC_SDW_UTILS");
+
+int asoc_sdw_senary_amp_init(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_links,
+ struct asoc_sdw_codec_info *info,
+ bool playback)
+{
+ struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
+ struct device *sdw_dev1, *sdw_dev2;
+ int ret;
+
+ /* Count amp number and do init on playback link only. */
+ if (!playback)
+ return 0;
+
+ info->amp_num++;
+
+ if (info->amp_num == 2) {
+ sdw_dev1 = bus_find_device_by_name(&sdw_bus_type, NULL, dai_links->codecs[0].name);
+ if (!sdw_dev1)
+ return -EPROBE_DEFER;
+
+ ret = senary_amp_add_device_props(sdw_dev1);
+ if (ret < 0) {
+ put_device(sdw_dev1);
+ return ret;
+ }
+ ctx->amp_dev1 = sdw_dev1;
+
+ sdw_dev2 = bus_find_device_by_name(&sdw_bus_type, NULL, dai_links->codecs[1].name);
+ if (!sdw_dev2)
+ return -EPROBE_DEFER;
+
+ ret = senary_amp_add_device_props(sdw_dev2);
+ if (ret < 0) {
+ put_device(sdw_dev2);
+ return ret;
+ }
+ ctx->amp_dev2 = sdw_dev2;
+ }
+
+ return 0;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_amp_init, "SND_SOC_SDW_UTILS");
diff --git a/sound/soc/sdw_utils/soc_sdw_senary_dmic.c b/sound/soc/sdw_utils/soc_sdw_senary_dmic.c
new file mode 100644
index 000000000000..7481706561f9
--- /dev/null
+++ b/sound/soc/sdw_utils/soc_sdw_senary_dmic.c
@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// This file incorporates work covered by the following copyright notice:
+// Copyright (c) 2024 Intel Corporation
+// Copyright (c) 2024 Advanced Micro Devices, Inc.
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <sound/soc.h>
+#include <sound/soc-acpi.h>
+#include <sound/soc-dapm.h>
+#include <sound/soc_sdw_utils.h>
+
+/* Card pin "Dmic" → codec input (name_prefix + " DMIC") */
+static const struct snd_soc_dapm_route senary_dmic_map[] = {
+ { "sn624x DMIC", NULL, "Dmic" },
+};
+
+int asoc_sdw_senary_dmic_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai)
+{
+ struct snd_soc_card *card = rtd->card;
+ struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
+ struct snd_soc_component *component;
+ char *mic_name;
+ int ret;
+
+ component = dai->component;
+
+ ret = snd_soc_dapm_add_routes(dapm, senary_dmic_map,
+ ARRAY_SIZE(senary_dmic_map));
+ if (ret) {
+ dev_err(card->dev, "senary dmic map addition failed: %d\n", ret);
+ return ret;
+ }
+
+ mic_name = devm_kasprintf(card->dev, GFP_KERNEL, "%s", component->name_prefix);
+ if (!mic_name)
+ return -ENOMEM;
+
+ card->components = devm_kasprintf(card->dev, GFP_KERNEL,
+ "%s mic:%s-dmic", card->components,
+ mic_name);
+ if (!card->components)
+ return -ENOMEM;
+
+ dev_dbg(card->dev, "card->components: %s\n", card->components);
+
+ return 0;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_dmic_rtd_init, "SND_SOC_SDW_UTILS");
diff --git a/sound/soc/sdw_utils/soc_sdw_senary_sdca.c b/sound/soc/sdw_utils/soc_sdw_senary_sdca.c
new file mode 100644
index 000000000000..5c2cd75307c9
--- /dev/null
+++ b/sound/soc/sdw_utils/soc_sdw_senary_sdca.c
@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// This file incorporates work covered by the following copyright notice:
+// Copyright (c) 2024 Intel Corporation.
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/string.h>
+#include <linux/soundwire/sdw.h>
+#include <linux/soundwire/sdw_type.h>
+#include <sound/control.h>
+#include <sound/soc.h>
+#include <sound/soc-acpi.h>
+#include <sound/soc-dapm.h>
+#include <sound/soc_sdw_utils.h>
+
+/* dapm routes for SPK will be registered dynamically */
+static const struct snd_soc_dapm_route sn624x_spk_map[] = {
+ { "Speaker", NULL, "sn624x SPK" },
+};
+
+/* Structure to map codec names to respective route arrays and sizes */
+struct codec_route_map {
+ const char *codec_name;
+ const struct snd_soc_dapm_route *route_map;
+ size_t route_size;
+};
+
+/* Codec route maps array */
+static const struct codec_route_map codec_routes[] = {
+ { "sn624x", sn624x_spk_map, ARRAY_SIZE(sn624x_spk_map) },
+};
+
+static const struct codec_route_map *get_codec_route_map(const char *dai_name)
+{
+ for (size_t i = 0; i < ARRAY_SIZE(codec_routes); i++) {
+ if (str_has_prefix(dai_name, codec_routes[i].codec_name))
+ return &codec_routes[i];
+ }
+ return NULL;
+}
+
+int asoc_sdw_senary_sdca_spk_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai)
+{
+ struct snd_soc_card *card = rtd->card;
+ struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
+ int ret;
+
+ /* Match by DAI name prefix (e.g. sn624x-sdca-aif2). */
+ const struct codec_route_map *route_map = get_codec_route_map(dai->name);
+
+ if (!route_map) {
+ dev_err(rtd->dev, "failed to get codec name and route map\n");
+ return -EINVAL;
+ }
+
+ /* Add routes */
+ ret = snd_soc_dapm_add_routes(dapm, route_map->route_map, route_map->route_size);
+ if (ret)
+ dev_err(rtd->dev, "failed to add rt sdca spk map: %d\n", ret);
+
+ return ret;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_sdca_spk_rtd_init, "SND_SOC_SDW_UTILS");
diff --git a/sound/soc/sdw_utils/soc_sdw_senary_sdca_jack_common.c b/sound/soc/sdw_utils/soc_sdw_senary_sdca_jack_common.c
new file mode 100644
index 000000000000..1dab6f99877d
--- /dev/null
+++ b/sound/soc/sdw_utils/soc_sdw_senary_sdca_jack_common.c
@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// This file incorporates work covered by the following copyright notice:
+// Copyright (c) 2020 Intel Corporation
+// Copyright (c) 2024 Advanced Micro Devices, Inc.
+
+#include <linux/device.h>
+#include <linux/errno.h>
+#include <linux/input.h>
+#include <linux/soundwire/sdw.h>
+#include <linux/soundwire/sdw_type.h>
+#include <sound/control.h>
+#include <sound/soc.h>
+#include <sound/soc-acpi.h>
+#include <sound/soc-dapm.h>
+#include <sound/jack.h>
+#include <sound/soc_sdw_utils.h>
+
+/*
+ * jack_init / jack_exit / most of rtd_init follow soc_sdw_rt_sdca_jack_common.c
+ * (same SDCA headset machine-helper pattern). Vendor-specific pieces here are
+ * mainly the "senarytech,jd-src" property name and senary_sdca_jack_map[].
+ *
+ * Keep a Senary-local file for now to mirror the existing RT layout. Sharing
+ * parameterised SDCA jack helpers in snd-soc-sdw-utils (jd-src key + common
+ * init/exit/rtd_init boilerplate) is intentional follow-up work, out of scope
+ * for the sn624x codec series.
+ */
+
+/*
+ * Note this MUST be called before snd_soc_register_card(), so that the props
+ * are in place before the codec component driver's probe function parses them.
+ */
+static int senary_sdca_jack_add_codec_device_props(struct device *sdw_dev, unsigned long quirk)
+{
+ struct property_entry props[SOC_SDW_MAX_NO_PROPS] = {};
+ struct fwnode_handle *fwnode;
+ int ret;
+
+ if (!SOC_SDW_JACK_JDSRC(quirk))
+ return 0;
+
+ props[0] = PROPERTY_ENTRY_U32("senarytech,jd-src", SOC_SDW_JACK_JDSRC(quirk));
+
+ fwnode = fwnode_create_software_node(props, NULL);
+ if (IS_ERR(fwnode))
+ return PTR_ERR(fwnode);
+
+ ret = device_add_software_node(sdw_dev, to_software_node(fwnode));
+
+ fwnode_handle_put(fwnode);
+
+ return ret;
+}
+
+static const struct snd_soc_dapm_route senary_sdca_jack_map[] = {
+ { "Headphone", NULL, "sn624x HP" },
+ { "sn624x MIC2", NULL, "Headset Mic" },
+};
+
+static struct snd_soc_jack_pin senary_sdca_jack_pins[] = {
+ {
+ .pin = "Headphone",
+ .mask = SND_JACK_HEADPHONE,
+ },
+ {
+ .pin = "Headset Mic",
+ .mask = SND_JACK_MICROPHONE,
+ },
+};
+
+static const char * const need_sdca_suffix[] = {
+ "sn624x"
+};
+
+int asoc_sdw_senary_sdca_jack_rtd_init(struct snd_soc_pcm_runtime *rtd, struct snd_soc_dai *dai)
+{
+ struct snd_soc_card *card = rtd->card;
+ struct snd_soc_dapm_context *dapm = snd_soc_card_to_dapm(card);
+ struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
+ struct snd_soc_component *component;
+ struct snd_soc_jack *jack;
+ int ret;
+ int i;
+
+ component = dai->component;
+ card->components = devm_kasprintf(card->dev, GFP_KERNEL,
+ "%s hs:%s",
+ card->components, component->name_prefix);
+ if (!card->components)
+ return -ENOMEM;
+
+ for (i = 0; i < ARRAY_SIZE(need_sdca_suffix); i++) {
+ if (!strstr(component->name_prefix, need_sdca_suffix[i]))
+ continue;
+
+ card->components = devm_kasprintf(card->dev, GFP_KERNEL,
+ "%s-sdca", card->components);
+ if (!card->components)
+ return -ENOMEM;
+
+ ret = snd_soc_dapm_add_routes(dapm, senary_sdca_jack_map,
+ ARRAY_SIZE(senary_sdca_jack_map));
+ if (ret) {
+ dev_err(card->dev,
+ "senary sdca jack map addition failed: %d\n", ret);
+ return ret;
+ }
+ break;
+ }
+
+ if (i == ARRAY_SIZE(need_sdca_suffix)) {
+ dev_err(card->dev, "%s is not supported\n", component->name_prefix);
+ return -EINVAL;
+ }
+
+ ret = snd_soc_card_jack_new_pins(rtd->card, "Headset Jack",
+ SND_JACK_HEADSET | SND_JACK_BTN_0 |
+ SND_JACK_BTN_1 | SND_JACK_BTN_2 |
+ SND_JACK_BTN_3,
+ &ctx->sdw_headset,
+ senary_sdca_jack_pins,
+ ARRAY_SIZE(senary_sdca_jack_pins));
+ if (ret) {
+ dev_err(rtd->card->dev, "Headset Jack creation failed: %d\n",
+ ret);
+ return ret;
+ }
+
+ jack = &ctx->sdw_headset;
+
+ snd_jack_set_key(jack->jack, SND_JACK_BTN_0, KEY_PLAYPAUSE);
+ snd_jack_set_key(jack->jack, SND_JACK_BTN_1, KEY_VOICECOMMAND);
+ snd_jack_set_key(jack->jack, SND_JACK_BTN_2, KEY_VOLUMEUP);
+ snd_jack_set_key(jack->jack, SND_JACK_BTN_3, KEY_VOLUMEDOWN);
+
+ ret = snd_soc_component_set_jack(component, jack, NULL);
+
+ if (ret)
+ dev_err(rtd->card->dev, "Headset Jack call-back failed: %d\n",
+ ret);
+
+ return ret;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_sdca_jack_rtd_init, "SND_SOC_SDW_UTILS");
+
+int asoc_sdw_senary_sdca_jack_exit(struct snd_soc_card *card, struct snd_soc_dai_link *dai_link)
+{
+ struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
+
+ if (!ctx->headset_codec_dev)
+ return 0;
+
+ if (!SOC_SDW_JACK_JDSRC(ctx->mc_quirk))
+ return 0;
+
+ device_remove_software_node(ctx->headset_codec_dev);
+ put_device(ctx->headset_codec_dev);
+ ctx->headset_codec_dev = NULL;
+
+ return 0;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_sdca_jack_exit, "SND_SOC_SDW_UTILS");
+
+/*
+ * Same control flow as asoc_sdw_rt_sdca_jack_init(); see file comment above
+ * about deferred helper sharing in snd-soc-sdw-utils.
+ */
+int asoc_sdw_senary_sdca_jack_init(struct snd_soc_card *card,
+ struct snd_soc_dai_link *dai_links,
+ struct asoc_sdw_codec_info *info,
+ bool playback)
+{
+ struct asoc_sdw_mc_private *ctx = snd_soc_card_get_drvdata(card);
+ struct device *sdw_dev;
+ int ret;
+
+ /*
+ * Jack detection should be only initialized once for headsets since
+ * the playback/capture is sharing the same jack
+ */
+ if (ctx->headset_codec_dev)
+ return 0;
+
+ sdw_dev = bus_find_device_by_name(&sdw_bus_type, NULL, dai_links->codecs[0].name);
+ if (!sdw_dev)
+ return -EPROBE_DEFER;
+
+ ret = senary_sdca_jack_add_codec_device_props(sdw_dev, ctx->mc_quirk);
+ if (ret < 0) {
+ put_device(sdw_dev);
+ return ret;
+ }
+ ctx->headset_codec_dev = sdw_dev;
+
+ return 0;
+}
+EXPORT_SYMBOL_NS(asoc_sdw_senary_sdca_jack_init, "SND_SOC_SDW_UTILS");
diff --git a/sound/soc/sdw_utils/soc_sdw_utils.c b/sound/soc/sdw_utils/soc_sdw_utils.c
index d8db8fc5313e..cbbf9252b393 100644
--- a/sound/soc/sdw_utils/soc_sdw_utils.c
+++ b/sound/soc/sdw_utils/soc_sdw_utils.c
@@ -17,6 +17,15 @@ static const struct snd_soc_dapm_widget generic_dmic_widgets[] = {
SND_SOC_DAPM_MIC("DMIC", NULL),
};
+/* Senary SN624x UCM uses CaptureMixerElem "Dmic"; keep separate from generic DMIC. */
+static const struct snd_soc_dapm_widget sn624x_dmic_widgets[] = {
+ SND_SOC_DAPM_MIC("Dmic", NULL),
+};
+
+static const struct snd_kcontrol_new sn624x_dmic_controls[] = {
+ SOC_DAPM_PIN_SWITCH("Dmic"),
+};
+
static const struct snd_soc_dapm_widget generic_jack_widgets[] = {
SND_SOC_DAPM_HP("Headphone", NULL),
SND_SOC_DAPM_MIC("Headset Mic", NULL),
@@ -1228,6 +1237,163 @@ struct asoc_sdw_codec_info codec_info_list[] = {
},
.dai_num = 1,
},
+ /*
+ * Senary SN6242/6244/6247: same SDCA jack/amp/mic topology; only part_id
+ * differs. name_prefix stays "sn624x" for UCM/DAI naming.
+ */
+ {
+ .vendor_id = 0x0496,
+ .part_id = 0x6244,
+ .name_prefix = "sn624x",
+ .ignore_internal_dmic = true,
+ .dais = {
+ {
+ .direction = {true, true},
+ .dai_name = "sn624x-sdca-aif",
+ .dai_type = SOC_SDW_DAI_TYPE_JACK,
+ .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID},
+ .init = asoc_sdw_senary_sdca_jack_init,
+ .exit = asoc_sdw_senary_sdca_jack_exit,
+ .rtd_init = asoc_sdw_senary_sdca_jack_rtd_init,
+ .controls = generic_jack_controls,
+ .num_controls = ARRAY_SIZE(generic_jack_controls),
+ .widgets = generic_jack_widgets,
+ .num_widgets = ARRAY_SIZE(generic_jack_widgets),
+ },
+ {
+ .direction = {true, false},
+ .dai_name = "sn624x-sdca-aif2",
+ .component_name = "sn624x",
+ .dai_type = SOC_SDW_DAI_TYPE_AMP,
+ .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID},
+ .init = asoc_sdw_senary_amp_init,
+ .exit = asoc_sdw_senary_amp_exit,
+ .rtd_init = asoc_sdw_senary_sdca_spk_rtd_init,
+ .controls = generic_spk_controls,
+ .num_controls = ARRAY_SIZE(generic_spk_controls),
+ .widgets = generic_spk_widgets,
+ .num_widgets = ARRAY_SIZE(generic_spk_widgets),
+ .quirk = SOC_SDW_CODEC_SPKR,
+ .quirk_exclude = true,
+ },
+ {
+ .direction = {false, true},
+ .dai_name = "sn624x-sdca-aif3",
+ .dai_type = SOC_SDW_DAI_TYPE_MIC,
+ .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID},
+ .rtd_init = asoc_sdw_senary_dmic_rtd_init,
+ .widgets = sn624x_dmic_widgets,
+ .num_widgets = ARRAY_SIZE(sn624x_dmic_widgets),
+ .controls = sn624x_dmic_controls,
+ .num_controls = ARRAY_SIZE(sn624x_dmic_controls),
+ .quirk = SOC_SDW_CODEC_MIC,
+ .quirk_exclude = true,
+ },
+ },
+ .dai_num = 3,
+ },
+ {
+ .vendor_id = 0x0496,
+ .part_id = 0x6247,
+ .name_prefix = "sn624x",
+ .ignore_internal_dmic = true,
+ .dais = {
+ {
+ .direction = {true, true},
+ .dai_name = "sn624x-sdca-aif",
+ .dai_type = SOC_SDW_DAI_TYPE_JACK,
+ .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID},
+ .init = asoc_sdw_senary_sdca_jack_init,
+ .exit = asoc_sdw_senary_sdca_jack_exit,
+ .rtd_init = asoc_sdw_senary_sdca_jack_rtd_init,
+ .controls = generic_jack_controls,
+ .num_controls = ARRAY_SIZE(generic_jack_controls),
+ .widgets = generic_jack_widgets,
+ .num_widgets = ARRAY_SIZE(generic_jack_widgets),
+ },
+ {
+ .direction = {true, false},
+ .dai_name = "sn624x-sdca-aif2",
+ .component_name = "sn624x",
+ .dai_type = SOC_SDW_DAI_TYPE_AMP,
+ .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID},
+ .init = asoc_sdw_senary_amp_init,
+ .exit = asoc_sdw_senary_amp_exit,
+ .rtd_init = asoc_sdw_senary_sdca_spk_rtd_init,
+ .controls = generic_spk_controls,
+ .num_controls = ARRAY_SIZE(generic_spk_controls),
+ .widgets = generic_spk_widgets,
+ .num_widgets = ARRAY_SIZE(generic_spk_widgets),
+ .quirk = SOC_SDW_CODEC_SPKR,
+ .quirk_exclude = true,
+ },
+ {
+ .direction = {false, true},
+ .dai_name = "sn624x-sdca-aif3",
+ .dai_type = SOC_SDW_DAI_TYPE_MIC,
+ .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID},
+ .rtd_init = asoc_sdw_senary_dmic_rtd_init,
+ .widgets = sn624x_dmic_widgets,
+ .num_widgets = ARRAY_SIZE(sn624x_dmic_widgets),
+ .controls = sn624x_dmic_controls,
+ .num_controls = ARRAY_SIZE(sn624x_dmic_controls),
+ .quirk = SOC_SDW_CODEC_MIC,
+ .quirk_exclude = true,
+ },
+ },
+ .dai_num = 3,
+ },
+ {
+ .vendor_id = 0x0496,
+ .part_id = 0x6242,
+ .name_prefix = "sn624x",
+ .ignore_internal_dmic = true,
+ .dais = {
+ {
+ .direction = {true, true},
+ .dai_name = "sn624x-sdca-aif",
+ .dai_type = SOC_SDW_DAI_TYPE_JACK,
+ .dailink = {SOC_SDW_JACK_OUT_DAI_ID, SOC_SDW_JACK_IN_DAI_ID},
+ .init = asoc_sdw_senary_sdca_jack_init,
+ .exit = asoc_sdw_senary_sdca_jack_exit,
+ .rtd_init = asoc_sdw_senary_sdca_jack_rtd_init,
+ .controls = generic_jack_controls,
+ .num_controls = ARRAY_SIZE(generic_jack_controls),
+ .widgets = generic_jack_widgets,
+ .num_widgets = ARRAY_SIZE(generic_jack_widgets),
+ },
+ {
+ .direction = {true, false},
+ .dai_name = "sn624x-sdca-aif2",
+ .component_name = "sn624x",
+ .dai_type = SOC_SDW_DAI_TYPE_AMP,
+ .dailink = {SOC_SDW_AMP_OUT_DAI_ID, SOC_SDW_UNUSED_DAI_ID},
+ .init = asoc_sdw_senary_amp_init,
+ .exit = asoc_sdw_senary_amp_exit,
+ .rtd_init = asoc_sdw_senary_sdca_spk_rtd_init,
+ .controls = generic_spk_controls,
+ .num_controls = ARRAY_SIZE(generic_spk_controls),
+ .widgets = generic_spk_widgets,
+ .num_widgets = ARRAY_SIZE(generic_spk_widgets),
+ .quirk = SOC_SDW_CODEC_SPKR,
+ .quirk_exclude = true,
+ },
+ {
+ .direction = {false, true},
+ .dai_name = "sn624x-sdca-aif3",
+ .dai_type = SOC_SDW_DAI_TYPE_MIC,
+ .dailink = {SOC_SDW_UNUSED_DAI_ID, SOC_SDW_DMIC_DAI_ID},
+ .rtd_init = asoc_sdw_senary_dmic_rtd_init,
+ .widgets = sn624x_dmic_widgets,
+ .num_widgets = ARRAY_SIZE(sn624x_dmic_widgets),
+ .controls = sn624x_dmic_controls,
+ .num_controls = ARRAY_SIZE(sn624x_dmic_controls),
+ .quirk = SOC_SDW_CODEC_MIC,
+ .quirk_exclude = true,
+ },
+ },
+ .dai_num = 3,
+ },
};
EXPORT_SYMBOL_NS(codec_info_list, "SND_SOC_SDW_UTILS");
--
2.47.3
^ permalink raw reply related [flat|nested] 4+ messages in thread* [PATCH v4 3/3] ASoC: Intel: soc-acpi: add SN624x entries for ARL/LNL/MTL/PTL
2026-08-18 2:08 [PATCH v4 0/3] ASoC: add Senary SN624x SoundWire SDCA support Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 1/3] ASoC: codecs: add SN624x SDCA SoundWire driver Qianghua Wang
2026-08-18 2:08 ` [PATCH v4 2/3] ASoC: sdw_utils: add Senary SN624x helpers and codec_info Qianghua Wang
@ 2026-08-18 2:08 ` Qianghua Wang
2 siblings, 0 replies; 4+ messages in thread
From: Qianghua Wang @ 2026-08-18 2:08 UTC (permalink / raw)
To: linux-sound
Cc: Qianghua Wang, Mark Brown, Pierre-Louis Bossart, Bard Liao,
Liam Girdwood, Peter Ujfalusi, Kai Vehmanen, Cezary Rojewski,
Charles Keepax, bo liu
Add SoundWire machine match entries for Senary SN624x on Arrow Lake,
Lunar Lake, Meteor Lake, and Panther Lake, and select the SN624x SDCA
codec from the SOF SoundWire machine Kconfig. Each part ID uses a
separate mach entry; name_prefix is "sn624x".
Signed-off-by: Qianghua Wang <qianghua.wang@senarytech.com>
---
sound/soc/intel/boards/Kconfig | 1 +
.../intel/common/soc-acpi-intel-arl-match.c | 71 ++++++++++++++++
.../intel/common/soc-acpi-intel-lnl-match.c | 71 ++++++++++++++++
.../intel/common/soc-acpi-intel-mtl-match.c | 71 ++++++++++++++++
.../intel/common/soc-acpi-intel-ptl-match.c | 82 +++++++++++++++++++
5 files changed, 296 insertions(+)
diff --git a/sound/soc/intel/boards/Kconfig b/sound/soc/intel/boards/Kconfig
index cddbd2aa424e..5b80b1770ff0 100644
--- a/sound/soc/intel/boards/Kconfig
+++ b/sound/soc/intel/boards/Kconfig
@@ -535,6 +535,7 @@ config SND_SOC_INTEL_SOUNDWIRE_SOF_MACH
select SND_SOC_ES9356
select SND_SOC_DMIC
select SND_SOC_INTEL_HDA_DSP_COMMON
+ select SND_SOC_SN624X_SDCA_SDW
imply SND_SOC_SDW_MOCKUP
help
Add support for Intel SoundWire-based platforms connected to
diff --git a/sound/soc/intel/common/soc-acpi-intel-arl-match.c b/sound/soc/intel/common/soc-acpi-intel-arl-match.c
index 59bfd5248819..43e20b74adb8 100644
--- a/sound/soc/intel/common/soc-acpi-intel-arl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-arl-match.c
@@ -531,6 +531,63 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_arl_machines[] = {
EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_arl_machines);
/* this table is used when there is no I2S codec present */
+
+/*
+ * Senary SN624x on Arrow Lake: one multi-function device on link 0.
+ * Separate mach entries per part ID (adr_d[] is AND, not OR). Amp endpoint
+ * is aggregated like the generic SOC_SDW_DAI_TYPE_AMP shape from
+ * find_acpi_adr_device().
+ */
+static const struct snd_soc_acpi_endpoint sn624x_endpoints[] = {
+ /* Jack */
+ {
+ .num = 0,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+ /* Amp */
+ {
+ .num = 1,
+ .aggregated = 1,
+ .group_position = 1,
+ .group_id = 1,
+ },
+ /* DMIC */
+ {
+ .num = 2,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+};
+
+#define SN624X_ARL_SINGLE_ADR(_sym, _adr) \
+static const struct snd_soc_acpi_adr_device _sym[] = { \
+ { \
+ .adr = (_adr), \
+ .num_endpoints = ARRAY_SIZE(sn624x_endpoints), \
+ .endpoints = sn624x_endpoints, \
+ .name_prefix = "sn624x", \
+ }, \
+}
+
+#define SN624X_ARL_LINK(_sym, _adr_arr) \
+static const struct snd_soc_acpi_link_adr _sym[] = { \
+ { \
+ .mask = BIT(0), \
+ .num_adr = ARRAY_SIZE(_adr_arr), \
+ .adr_d = _adr_arr, \
+ }, \
+ {} \
+}
+
+SN624X_ARL_SINGLE_ADR(sn6242_single_adr, 0x0000000496624201ull);
+SN624X_ARL_SINGLE_ADR(sn6244_single_adr, 0x0000000496624401ull);
+
+SN624X_ARL_LINK(arl_link_sn6242, sn6242_single_adr);
+SN624X_ARL_LINK(arl_link_sn6244, sn6244_single_adr);
+
struct snd_soc_acpi_mach snd_soc_acpi_intel_arl_sdw_machines[] = {
{
.link_mask = BIT(0) | BIT(2) | BIT(3),
@@ -621,6 +678,20 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_arl_sdw_machines[] = {
.sof_tplg_filename = "sof-arl-es9356.tplg",
.get_function_tplg_files = sof_sdw_get_tplg_files,
},
+ {
+ .link_mask = BIT(0),
+ .links = arl_link_sn6242,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-arl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
+ {
+ .link_mask = BIT(0),
+ .links = arl_link_sn6244,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-arl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
{},
};
EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_arl_sdw_machines);
diff --git a/sound/soc/intel/common/soc-acpi-intel-lnl-match.c b/sound/soc/intel/common/soc-acpi-intel-lnl-match.c
index 937a74a5d523..547ee4bbca5b 100644
--- a/sound/soc/intel/common/soc-acpi-intel-lnl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-lnl-match.c
@@ -685,6 +685,63 @@ static const struct snd_soc_acpi_link_adr lnl_sdw_rt712_vb_l2_rt1320_l1[] = {
};
/* this table is used when there is no I2S codec present */
+
+/*
+ * Senary SN624x on Lunar Lake: one multi-function device on link 0.
+ * Separate mach entries per part ID (adr_d[] is AND, not OR). Amp endpoint
+ * is aggregated like the generic SOC_SDW_DAI_TYPE_AMP shape from
+ * find_acpi_adr_device().
+ */
+static const struct snd_soc_acpi_endpoint sn624x_endpoints[] = {
+ /* Jack */
+ {
+ .num = 0,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+ /* Amp */
+ {
+ .num = 1,
+ .aggregated = 1,
+ .group_position = 1,
+ .group_id = 1,
+ },
+ /* DMIC */
+ {
+ .num = 2,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+};
+
+#define SN624X_LNL_SINGLE_ADR(_sym, _adr) \
+static const struct snd_soc_acpi_adr_device _sym[] = { \
+ { \
+ .adr = (_adr), \
+ .num_endpoints = ARRAY_SIZE(sn624x_endpoints), \
+ .endpoints = sn624x_endpoints, \
+ .name_prefix = "sn624x", \
+ }, \
+}
+
+#define SN624X_LNL_LINK(_sym, _adr_arr) \
+static const struct snd_soc_acpi_link_adr _sym[] = { \
+ { \
+ .mask = BIT(0), \
+ .num_adr = ARRAY_SIZE(_adr_arr), \
+ .adr_d = _adr_arr, \
+ }, \
+ {} \
+}
+
+SN624X_LNL_SINGLE_ADR(sn6242_single_adr, 0x0000000496624201ull);
+SN624X_LNL_SINGLE_ADR(sn6244_single_adr, 0x0000000496624401ull);
+
+SN624X_LNL_LINK(lnl_link_sn6242, sn6242_single_adr);
+SN624X_LNL_LINK(lnl_link_sn6244, sn6244_single_adr);
+
/* this table is used when there is no I2S codec present */
struct snd_soc_acpi_mach snd_soc_acpi_intel_lnl_sdw_machines[] = {
/* mockup tests need to be first */
@@ -796,6 +853,20 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_lnl_sdw_machines[] = {
.sof_tplg_filename = "sof-lnl-rt713-l2-rt1320-l13.tplg",
.get_function_tplg_files = sof_sdw_get_tplg_files,
},
+ {
+ .link_mask = BIT(0),
+ .links = lnl_link_sn6242,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-lnl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
+ {
+ .link_mask = BIT(0),
+ .links = lnl_link_sn6244,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-lnl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
{},
};
EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_lnl_sdw_machines);
diff --git a/sound/soc/intel/common/soc-acpi-intel-mtl-match.c b/sound/soc/intel/common/soc-acpi-intel-mtl-match.c
index 2e4222456f27..2fb0669ae008 100644
--- a/sound/soc/intel/common/soc-acpi-intel-mtl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-mtl-match.c
@@ -1296,6 +1296,63 @@ static const struct snd_soc_acpi_link_adr mtl_cs35l63_x2_link1_link3_fb[] = {
};
/* this table is used when there is no I2S codec present */
+
+/*
+ * Senary SN624x on Meteor Lake: one multi-function device on link 0.
+ * Separate mach entries per part ID (adr_d[] is AND, not OR). Amp endpoint
+ * is aggregated like the generic SOC_SDW_DAI_TYPE_AMP shape from
+ * find_acpi_adr_device().
+ */
+static const struct snd_soc_acpi_endpoint sn624x_endpoints[] = {
+ /* Jack */
+ {
+ .num = 0,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+ /* Amp */
+ {
+ .num = 1,
+ .aggregated = 1,
+ .group_position = 1,
+ .group_id = 1,
+ },
+ /* DMIC */
+ {
+ .num = 2,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+};
+
+#define SN624X_MTL_SINGLE_ADR(_sym, _adr) \
+static const struct snd_soc_acpi_adr_device _sym[] = { \
+ { \
+ .adr = (_adr), \
+ .num_endpoints = ARRAY_SIZE(sn624x_endpoints), \
+ .endpoints = sn624x_endpoints, \
+ .name_prefix = "sn624x", \
+ }, \
+}
+
+#define SN624X_MTL_LINK(_sym, _adr_arr) \
+static const struct snd_soc_acpi_link_adr _sym[] = { \
+ { \
+ .mask = BIT(0), \
+ .num_adr = ARRAY_SIZE(_adr_arr), \
+ .adr_d = _adr_arr, \
+ }, \
+ {} \
+}
+
+SN624X_MTL_SINGLE_ADR(sn6242_single_adr, 0x0000000496624201ull);
+SN624X_MTL_SINGLE_ADR(sn6244_single_adr, 0x0000000496624401ull);
+
+SN624X_MTL_LINK(mtl_link_sn6242, sn6242_single_adr);
+SN624X_MTL_LINK(mtl_link_sn6244, sn6244_single_adr);
+
struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_sdw_machines[] = {
/* mockup tests need to be first */
{
@@ -1487,6 +1544,20 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_mtl_sdw_machines[] = {
.drv_name = "sof_sdw",
.sof_tplg_filename = "sof-mtl-sdw-cs42l42-l0-max98363-l2.tplg",
},
+ {
+ .link_mask = BIT(0),
+ .links = mtl_link_sn6242,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-mtl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
+ {
+ .link_mask = BIT(0),
+ .links = mtl_link_sn6244,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-mtl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
{},
};
EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_mtl_sdw_machines);
diff --git a/sound/soc/intel/common/soc-acpi-intel-ptl-match.c b/sound/soc/intel/common/soc-acpi-intel-ptl-match.c
index f7694b2a2b02..6af699f02f5d 100644
--- a/sound/soc/intel/common/soc-acpi-intel-ptl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-ptl-match.c
@@ -438,6 +438,66 @@ static const struct snd_soc_acpi_link_adr ptl_sdw_rt712_vb_l3_rt1320_l3[] = {
};
/* this table is used when there is no I2S codec present */
+
+/*
+ * Senary SN624x on Panther Lake: one multi-function device on link 3.
+ * Separate mach entries per part ID (adr_d[] is AND, not OR). ADR version
+ * nibble 0x3 matches the silicon SoundWire version. Amp endpoint is
+ * aggregated like the generic SOC_SDW_DAI_TYPE_AMP shape from
+ * find_acpi_adr_device().
+ */
+static const struct snd_soc_acpi_endpoint sn624x_endpoints[] = {
+ /* Jack */
+ {
+ .num = 0,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+ /* Amp */
+ {
+ .num = 1,
+ .aggregated = 1,
+ .group_position = 1,
+ .group_id = 1,
+ },
+ /* DMIC */
+ {
+ .num = 2,
+ .aggregated = 0,
+ .group_position = 0,
+ .group_id = 0,
+ },
+};
+
+#define SN624X_PTL_SINGLE_ADR(_sym, _adr) \
+static const struct snd_soc_acpi_adr_device _sym[] = { \
+ { \
+ .adr = (_adr), \
+ .num_endpoints = ARRAY_SIZE(sn624x_endpoints), \
+ .endpoints = sn624x_endpoints, \
+ .name_prefix = "sn624x", \
+ }, \
+}
+
+#define SN624X_PTL_LINK(_sym, _adr_arr) \
+static const struct snd_soc_acpi_link_adr _sym[] = { \
+ { \
+ .mask = BIT(3), \
+ .num_adr = ARRAY_SIZE(_adr_arr), \
+ .adr_d = _adr_arr, \
+ }, \
+ {} \
+}
+
+SN624X_PTL_SINGLE_ADR(sn6242_single_adr, 0x0003300496624201ull);
+SN624X_PTL_SINGLE_ADR(sn6244_single_adr, 0x0003300496624401ull);
+SN624X_PTL_SINGLE_ADR(sn6247_single_adr, 0x0003300496624701ull);
+
+SN624X_PTL_LINK(ptl_link_sn6242, sn6242_single_adr);
+SN624X_PTL_LINK(ptl_link_sn6244, sn6244_single_adr);
+SN624X_PTL_LINK(ptl_link_sn6247, sn6247_single_adr);
+
struct snd_soc_acpi_mach snd_soc_acpi_intel_ptl_sdw_machines[] = {
/* Order Priority: mockup > most links > most bit link-mask > alphabetical */
{
@@ -531,6 +591,28 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_ptl_sdw_machines[] = {
.sof_tplg_filename = "sof-ptl-rt712-l3-rt1320-l3.tplg",
.get_function_tplg_files = sof_sdw_get_tplg_files,
},
+
+ {
+ .link_mask = BIT(3),
+ .links = ptl_link_sn6242,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-ptl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
+ {
+ .link_mask = BIT(3),
+ .links = ptl_link_sn6244,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-ptl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
+ {
+ .link_mask = BIT(3),
+ .links = ptl_link_sn6247,
+ .drv_name = "sof_sdw",
+ .sof_tplg_filename = "sof-ptl-sn624x.tplg",
+ .get_function_tplg_files = sof_sdw_get_tplg_files,
+ },
{},
};
EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_ptl_sdw_machines);
--
2.47.3
^ permalink raw reply related [flat|nested] 4+ messages in thread