From: Richard Fitzgerald <rf@opensource.cirrus.com>
To: broonie@kernel.org
Cc: linux-sound@vger.kernel.org, linux-kernel@vger.kernel.org,
patches@opensource.cirrus.com
Subject: [PATCH 1/2] ASoC: cs35l56: Add KUnit test that widget init doesn't write ASP registers
Date: Tue, 17 Nov 2026 12:59:36 +0000 [thread overview]
Message-ID: <20261117125937.658976-2-rf@opensource.cirrus.com> (raw)
In-Reply-To: <20261117125937.658976-1-rf@opensource.cirrus.com>
Add a test case to check that the ASP config and input mixer registers
are not written when the ASP DAI is not part of a DAI link.
This is to test the fixes made in commit 0085428e834c ("ASoC: cs35l56:
Only write ASP1TXn registers when widget is powered-up").
These registers have multiple owners, so the driver must not write to
them if it doesn't own them.
A write can be inadvertently caused by reading a register, which populates
the value in the cache, then doing a regcache_sync() of a dirty cache. The
test includes testing direct writes during probe, and writes during a
subsequent cache-sync.
Some mock infrastructure is needed to enable this:
1. The test must supply dummy regulators. The automatic provision of dummy
regulators by the regulator framework is a system-level decision, not a
Kconfig flag that can be depended on. Not all systems can be relied on
to supply dummy regulators automatically.
2. A simple simulation of a set of chip registers is done by a regmap that
is always in cache-only mode. Around this is a small regmap bus wrapper.
The order of creating struct cs35l56_priv and the faux device had to be
swapped in cs35l56_test_case_init_common() to ensure that devm cleanup of
the faux device happens before the cs35l56_priv data is freed by KUnit.
Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
---
sound/soc/codecs/cs35l56-test.c | 322 +++++++++++++++++++++++++++++++-
1 file changed, 317 insertions(+), 5 deletions(-)
diff --git a/sound/soc/codecs/cs35l56-test.c b/sound/soc/codecs/cs35l56-test.c
index b58df099bf72..eda2f8ae6f21 100644
--- a/sound/soc/codecs/cs35l56-test.c
+++ b/sound/soc/codecs/cs35l56-test.c
@@ -17,8 +17,13 @@
#include <linux/overflow.h>
#include <linux/pci_ids.h>
#include <linux/property.h>
+#include <linux/range.h>
+#include <linux/regmap.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
#include <linux/seq_buf.h>
#include <linux/soundwire/sdw.h>
+#include <linux/unaligned.h>
#include <sound/cs35l56.h>
#include <sound/cs-amp-lib.h>
#include <sound/sdca_function.h>
@@ -39,14 +44,25 @@ KUNIT_DEFINE_ACTION_WRAPPER(device_remove_software_node_wrapper,
device_remove_software_node,
struct device *)
+KUNIT_DEFINE_ACTION_WRAPPER(cs35l56_remove_wrapper, cs35l56_remove,
+ struct cs35l56_private *)
+
+KUNIT_DEFINE_ACTION_WRAPPER(snd_soc_unregister_card_wrapper, snd_soc_unregister_card,
+ struct snd_soc_card *)
+
struct cs35l56_test_priv {
struct faux_device *amp_dev;
struct cs35l56_private *cs35l56_priv;
+ const struct regmap_config *regmap_config;
+ struct regmap *registers;
const char *ssidexv2;
bool read_onchip_spkid_called;
bool configure_onchip_spkid_pads_called;
+
+ bool asp_config_regs_written;
+ bool asp_mixer_regs_written;
};
struct cs35l56_test_param {
@@ -79,6 +95,211 @@ static const struct software_node *cs35l56_test_dev_and_af01_node_group[] = {
NULL
};
+/* Some mocked registers need default values for driver init to work */
+static const struct reg_default cs35l56_test_mock_reg_defaults[] = {
+ { CS35L56_OTPID, 0x00000003 },
+ { CS35L56_IRQ1_STATUS, 0x00000000 },
+ { CS35L56_IRQ1_MASK_1, 0x83ffffff },
+ { CS35L56_IRQ1_MASK_8, 0xfc000fff },
+ { CS35L56_DSP_VIRTUAL1_MBOX_1, 0x00000000 },
+ { CS35L56_DIE_STS1, 0x00000000 },
+ { CS35L56_DIE_STS2, 0x00000000 },
+ { CS35L56_DSP_RESTRICT_STS1, 0x00000000 },
+ { CS35L56_OTP_MEM_53, 0x00000000 },
+ { CS35L56_OTP_MEM_54, 0x00000000 },
+ { CS35L56_OTP_MEM_55, 0x00000000 },
+ { CS35L56_DSP1_FW_VER, 0x00040710 },
+ { CS35L63_PROTECTION_STATUS, 0x00000000 },
+ { CS35L56_PROTECTION_STATUS, 0x00000000 },
+};
+
+/* Trap the entire ASP address space, not only particular registers */
+static const struct range cs35l56_test_asp_config_registers_range = {
+ .start = 0x4800,
+ .end = 0x48ff,
+};
+
+static const struct range cs35l56_test_asp_mixer_registers_range = {
+ .start = CS35L56_ASP1TX1_INPUT,
+ .end = CS35L56_ASP1TX4_INPUT,
+};
+
+
+static int cs35l56_test_mock_registers_read(void *context,
+ const void *reg_buf, size_t reg_size,
+ void *val_buf, size_t val_size)
+{
+ struct kunit *test = context;
+ struct cs35l56_test_priv *priv = test->priv;
+ u8 *buf = val_buf;
+ unsigned int reg = get_unaligned_be32(reg_buf);
+ unsigned int val;
+ size_t i;
+ int ret;
+
+ KUNIT_ASSERT_EQ(test, reg_size, sizeof(u32));
+ KUNIT_ASSERT_EQ(test, val_size % sizeof(u32), 0);
+
+ if (priv->regmap_config)
+ reg -= priv->regmap_config->reg_base;
+
+ switch (reg) {
+ case CS35L56_DSP_VIRTUAL1_MBOX_1:
+ /* MBOX must return 0 to indicate that the value was written */
+ put_unaligned_be32(0, val_buf);
+ return 0;
+ case CS35L56_DSP1_HALO_STATE:
+ case CS35L63_DSP1_HALO_STATE:
+ case CS35L56_B2_DSP1_HALO_STATE:
+ /* Driver zeros this and we must simulate the firmware rewriting it */
+ put_unaligned_be32(CS35L56_HALO_STATE_BOOT_DONE, buf);
+ return 0;
+ default:
+ break;
+ }
+
+ for (i = 0; i < val_size; i += sizeof(u32), reg += sizeof(u32)) {
+ ret = regmap_read(priv->registers, reg, &val);
+ if (ret)
+ return ret;
+
+ put_unaligned_be32(val, buf + i);
+ }
+
+ return 0;
+}
+
+static int cs35l56_test_mock_registers_write(void *context, const void *data, size_t count)
+{
+ struct kunit *test = context;
+ struct cs35l56_test_priv *priv = test->priv;
+ struct range addr_range;
+ unsigned int reg, val;
+ const u8 *buf = data;
+ size_t i;
+ int ret;
+
+ KUNIT_ASSERT_GE(test, count, 2 * sizeof(u32));
+ KUNIT_ASSERT_EQ(test, count % sizeof(u32), 0);
+
+ reg = get_unaligned_be32(buf);
+ buf += sizeof(u32);
+ count -= sizeof(u32);
+ if (priv->regmap_config)
+ reg -= priv->regmap_config->reg_base;
+
+ addr_range = DEFINE_RANGE(reg, reg + count - 1);
+ if (range_overlaps(&addr_range, &cs35l56_test_asp_config_registers_range))
+ priv->asp_config_regs_written = true;
+
+ if (range_overlaps(&addr_range, &cs35l56_test_asp_mixer_registers_range))
+ priv->asp_mixer_regs_written = true;
+
+ for (i = 0; i < count; i += sizeof(u32)) {
+ val = get_unaligned_be32(buf + i);
+ ret = regmap_write(priv->registers, reg + i, val);
+ if (ret)
+ return ret;
+ }
+
+ return 0;
+}
+
+static const struct regmap_bus cs35l56_test_mock_registers_regmap_bus = {
+ /* Always in cache-only so no handlers needed */
+};
+
+static const struct regmap_config cs35l56_test_mock_registers_regmap_config = {
+ .name = "cs35l56_mock_registers",
+ .reg_bits = 32,
+ .val_bits = 32,
+ .reg_stride = 4,
+ .max_register = CS35L56_DSP1_PMEM_5114,
+ .cache_type = REGCACHE_MAPLE,
+ .reg_defaults = cs35l56_test_mock_reg_defaults,
+ .num_reg_defaults = ARRAY_SIZE(cs35l56_test_mock_reg_defaults),
+ .reg_format_endian = REGMAP_ENDIAN_BIG,
+ .val_format_endian = REGMAP_ENDIAN_BIG,
+};
+
+static const struct regmap_bus cs35l56_test_mock_registers_client_regmap_bus = {
+ .read = cs35l56_test_mock_registers_read,
+ .write = cs35l56_test_mock_registers_write,
+};
+
+/* Simulated device registers using a mock bus backed by a cache-only regmap */
+static void cs35l56_test_create_mock_device_registers(struct kunit *test)
+{
+ struct cs35l56_test_priv *priv = test->priv;
+ struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
+ unsigned int devid = 0x35a00 | cs35l56->base.type;
+
+ priv->registers = devm_regmap_init(cs35l56->base.dev,
+ &cs35l56_test_mock_registers_regmap_bus,
+ test, &cs35l56_test_mock_registers_regmap_config);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->registers);
+ regcache_cache_only(priv->registers, true);
+
+ switch (cs35l56->base.type) {
+ case 0x54:
+ case 0x56:
+ case 0x57:
+ break;
+ default:
+ devid <<= 4;
+ break;
+ }
+ KUNIT_ASSERT_EQ(test, 0, regmap_write(priv->registers, CS35L56_DEVID, devid));
+ KUNIT_ASSERT_EQ(test, 0, regmap_write(priv->registers, CS35L56_REVID, cs35l56->base.rev));
+}
+
+/*
+ * Not all systems supply dummy regulators for missing regulators, and
+ * this behaviour is a system-level decision, not a KConfig symbol we can
+ * depend on. So we have to provide our own dummy regulators.
+ */
+static const struct regulator_ops cs35l56_test_mock_regulator_ops;
+static const struct regulator_desc cs35l56_test_mock_regulator_desc = {
+ .name = "cs35l56_test_regulators",
+ .type = REGULATOR_VOLTAGE,
+ .owner = THIS_MODULE,
+ .ops = &cs35l56_test_mock_regulator_ops,
+};
+
+static struct regulator_consumer_supply cs35l56_test_mock_supplies[] = {
+ REGULATOR_SUPPLY("VDD_P", NULL),
+ REGULATOR_SUPPLY("VDD_IO", NULL),
+ REGULATOR_SUPPLY("VDD_A", NULL),
+ REGULATOR_SUPPLY("VDD_B", NULL),
+ REGULATOR_SUPPLY("VDD_AMP", NULL),
+};
+
+static const struct regulator_init_data cs35l56_test_mock_init_data = {
+ .constraints.always_on = 1,
+ .num_consumer_supplies = ARRAY_SIZE(cs35l56_test_mock_supplies),
+ .consumer_supplies = cs35l56_test_mock_supplies,
+};
+
+static void cs35l56_test_create_mock_supplies(struct kunit *test)
+{
+ struct cs35l56_test_priv *priv = test->priv;
+ struct regulator_config config = { };
+ int i;
+
+ if (!IS_ENABLED(CONFIG_REGULATOR))
+ return;
+
+ config.dev = &priv->amp_dev->dev;
+ config.init_data = &cs35l56_test_mock_init_data;
+ for (i = 0; i < ARRAY_SIZE(cs35l56_test_mock_supplies); i++)
+ cs35l56_test_mock_supplies[i].dev_name = dev_name(config.dev);
+
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
+ devm_regulator_register(config.dev,
+ &cs35l56_test_mock_regulator_desc,
+ &config));
+}
+
static const char *cs35l56_test_devm_get_vendor_specific_variant_id_none(struct device *dev,
int ssid_vendor,
int ssid_device)
@@ -611,6 +832,83 @@ static void cs35l56_test_set_fw_name_preserves_spkid_without_onchip_gpios(struct
KUNIT_EXPECT_EQ(test, cs35l56->speaker_id, 15);
}
+static void cs35l56_test_dummy_dsp_work(struct work_struct *work)
+{
+}
+
+/*
+ * Probing the component must not access the ASP1 registers. The driver does
+ * not necessarily own them.
+ */
+static void cs35l56_test_component_probe_omits_asp(struct kunit *test)
+{
+ struct cs35l56_test_priv *priv = test->priv;
+ struct cs35l56_private *cs35l56 = priv->cs35l56_priv;
+ struct snd_soc_card *card = cs35l56->component->card;
+ struct snd_soc_aux_dev *aux;
+ struct faux_device *card_dev;
+
+ cs35l56_test_create_mock_supplies(test);
+ cs35l56_test_create_mock_device_registers(test);
+
+ KUNIT_ASSERT_NOT_NULL(test, priv->regmap_config);
+ cs35l56->base.regmap = devm_regmap_init(cs35l56->base.dev,
+ &cs35l56_test_mock_registers_client_regmap_bus,
+ test, priv->regmap_config);
+ KUNIT_ASSERT_NOT_ERR_OR_NULL(test, cs35l56->base.regmap);
+
+ KUNIT_ASSERT_EQ(test, 0, cs35l56_common_probe(cs35l56, 0));
+ KUNIT_ASSERT_EQ(test, 0,
+ kunit_add_action_or_reset(test, cs35l56_remove_wrapper, cs35l56));
+
+ /* Prevent real dsp_work */
+ INIT_WORK(&cs35l56->dsp_work, cs35l56_test_dummy_dsp_work);
+
+ /* Simulate first attachment and re-attachment after the soft reset. */
+ regcache_cache_only(cs35l56->base.regmap, false);
+ KUNIT_ASSERT_EQ(test, 0, cs35l56_init(cs35l56));
+ KUNIT_ASSERT_EQ(test, 0, cs35l56_init(cs35l56));
+ KUNIT_ASSERT_TRUE(test, cs35l56->base.init_done);
+ flush_work(&cs35l56->component_register_work);
+ KUNIT_ASSERT_TRUE(test, cs35l56->component_registered);
+
+ card_dev = faux_device_create("cs35l56_test_card", NULL, NULL);
+ KUNIT_ASSERT_NOT_NULL(test, card_dev);
+ KUNIT_ASSERT_EQ(test, 0,
+ kunit_add_action_or_reset(test, faux_device_destroy_wrapper, card_dev));
+
+ /* Bind as an auxiliary component so the ASP DAI is never probed. */
+ aux = kunit_kzalloc(test, sizeof(*aux), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, aux);
+ aux->dlc.name = dev_name(cs35l56->base.dev);
+ card->name = "cs35l56-test";
+ card->dev = &card_dev->dev;
+ card->owner = THIS_MODULE;
+ card->aux_dev = aux;
+ card->num_aux_devs = 1;
+ KUNIT_ASSERT_EQ(test, 0, snd_soc_register_card(card));
+ KUNIT_ASSERT_EQ(test, 0,
+ kunit_add_action_or_reset(test, snd_soc_unregister_card_wrapper, card));
+ KUNIT_ASSERT_TRUE(test, card->instantiated);
+
+ /*
+ * Flush cache to ensure there aren't cached values for the ASP registers.
+ * The first case without regcache_mark_dirty() tests flushing when
+ * hardware registers have not reset, and requires a dummy write to
+ * the cache to make it dirty.
+ */
+ regcache_cache_only(cs35l56->base.regmap, true);
+ KUNIT_ASSERT_EQ(test, 0, regmap_write(cs35l56->base.regmap,
+ CS35L56_DSP_VIRTUAL1_MBOX_1, 0));
+ regcache_cache_only(cs35l56->base.regmap, false);
+ KUNIT_ASSERT_EQ(test, 0, regcache_sync(cs35l56->base.regmap));
+ regcache_mark_dirty(cs35l56->base.regmap);
+ KUNIT_ASSERT_EQ(test, 0, regcache_sync(cs35l56->base.regmap));
+
+ KUNIT_EXPECT_FALSE(test, priv->asp_config_regs_written);
+ KUNIT_EXPECT_FALSE(test, priv->asp_mixer_regs_written);
+}
+
static int cs35l56_test_case_init_common(struct kunit *test)
{
struct cs35l56_test_priv *priv;
@@ -625,6 +923,11 @@ static int cs35l56_test_case_init_common(struct kunit *test)
test->priv = priv;
+ /* Construct minimal set of driver structs */
+ priv->cs35l56_priv = kunit_kzalloc(test, sizeof(*priv->cs35l56_priv), GFP_KERNEL);
+ KUNIT_ASSERT_NOT_NULL(test, priv->cs35l56_priv);
+ cs35l56 = priv->cs35l56_priv;
+
/* Create dummy amp driver dev */
priv->amp_dev = faux_device_create("cs35l56_test_drv", NULL, NULL);
KUNIT_ASSERT_NOT_NULL(test, priv->amp_dev);
@@ -632,11 +935,6 @@ static int cs35l56_test_case_init_common(struct kunit *test)
kunit_add_action_or_reset(test,
faux_device_destroy_wrapper,
priv->amp_dev));
-
- /* Construct minimal set of driver structs */
- priv->cs35l56_priv = kunit_kzalloc(test, sizeof(*priv->cs35l56_priv), GFP_KERNEL);
- KUNIT_ASSERT_NOT_NULL(test, priv->cs35l56_priv);
- cs35l56 = priv->cs35l56_priv;
cs35l56->base.dev = &priv->amp_dev->dev;
cs35l56->component = kunit_kzalloc(test, sizeof(*cs35l56->component), GFP_KERNEL);
@@ -653,6 +951,17 @@ static int cs35l56_test_case_init_common(struct kunit *test)
cs35l56->base.rev = param->rev;
cs35l56->feid = param->feid;
cs35l56->fev = param->fev;
+
+ switch (param->type) {
+ case 0x54:
+ case 0x56:
+ case 0x57:
+ priv->regmap_config = &cs35l56_regmap_i2c;
+ break;
+ default:
+ priv->regmap_config = &cs35l63_regmap_i2c;
+ break;
+ }
}
return 0;
@@ -902,6 +1211,8 @@ static struct kunit_case cs35l56_test_cases_soundwire[] = {
KUNIT_CASE(cs35l56_test_set_fw_name_reads_onchip_spkid),
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_with_onchip_gpios),
KUNIT_CASE(cs35l56_test_set_fw_name_preserves_spkid_without_onchip_gpios),
+ KUNIT_CASE_PARAM(cs35l56_test_component_probe_omits_asp,
+ cs35l56_test_type_rev_all_gen_params),
{ } /* terminator */
};
@@ -942,6 +1253,7 @@ kunit_test_suites(
);
MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
+MODULE_IMPORT_NS("SND_SOC_CS35L56_CORE");
MODULE_IMPORT_NS("SND_SOC_CS35L56_SHARED");
MODULE_IMPORT_NS("EXPORTED_FOR_KUNIT_TESTING");
MODULE_DESCRIPTION("KUnit test for Cirrus Logic cs35l56 codec driver");
--
2.47.3
next prev parent reply other threads:[~2026-11-17 13:00 UTC|newest]
Thread overview: 3+ messages / expand[flat|nested] mbox.gz Atom feed top
2026-11-17 12:59 [PATCH 0/2] ASoC: cs35l56: KUnit tests for ASP register write blocking Richard Fitzgerald
2026-11-17 12:59 ` Richard Fitzgerald [this message]
2026-11-17 12:59 ` [PATCH 2/2] ASoC: cs35l56-shared: Add KUnit test cases for ASP config register writes Richard Fitzgerald
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20261117125937.658976-2-rf@opensource.cirrus.com \
--to=rf@opensource.cirrus.com \
--cc=broonie@kernel.org \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-sound@vger.kernel.org \
--cc=patches@opensource.cirrus.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox