From: Charles Keepax <ckeepax@opensource.cirrus.com>
To: <broonie@kernel.org>
Cc: <lgirdwood@gmail.com>, <shenghao-ding@ti.com>, <kevin-lu@ti.com>,
<baojun.xu@ti.com>, <linux-sound@vger.kernel.org>,
<linux-kernel@vger.kernel.org>, <patches@opensource.cirrus.com>
Subject: [PATCH 01/15] ASoC: ops-test: Add some basic kunit tests for soc-ops
Date: Tue, 18 Mar 2025 17:14:45 +0000 [thread overview]
Message-ID: <20250318171459.3203730-2-ckeepax@opensource.cirrus.com> (raw)
In-Reply-To: <20250318171459.3203730-1-ckeepax@opensource.cirrus.com>
Add some basic kunit tests for some of the ASoC control put and get
helpers. This will assist in doing some refactoring. Note that presently
some tests fail, but the rest of the series will fix these up.
Signed-off-by: Charles Keepax <ckeepax@opensource.cirrus.com>
---
sound/soc/Kconfig | 7 +
sound/soc/Makefile | 4 +
sound/soc/soc-ops-test.c | 541 +++++++++++++++++++++++++++++++++++++++
3 files changed, 552 insertions(+)
create mode 100644 sound/soc/soc-ops-test.c
diff --git a/sound/soc/Kconfig b/sound/soc/Kconfig
index 5efba76abb31a..8b7d51266f814 100644
--- a/sound/soc/Kconfig
+++ b/sound/soc/Kconfig
@@ -81,6 +81,13 @@ config SND_SOC_UTILS_KUNIT_TEST
help
If you want to perform tests on ALSA SoC utils library say Y here.
+config SND_SOC_OPS_KUNIT_TEST
+ tristate "KUnit tests for SoC ops"
+ depends on KUNIT
+ default KUNIT_ALL_TESTS
+ help
+ If you want to perform tests on ALSA SoC ops library say Y here.
+
config SND_SOC_ACPI
tristate
diff --git a/sound/soc/Makefile b/sound/soc/Makefile
index 08baaa11d8139..358e227c5ab61 100644
--- a/sound/soc/Makefile
+++ b/sound/soc/Makefile
@@ -21,6 +21,10 @@ ifneq ($(CONFIG_SND_SOC_UTILS_KUNIT_TEST),)
obj-$(CONFIG_SND_SOC_UTILS_KUNIT_TEST) += soc-utils-test.o
endif
+ifneq ($(CONFIG_SND_SOC_OPS_KUNIT_TEST),)
+obj-$(CONFIG_SND_SOC_OPS_KUNIT_TEST) += soc-ops-test.o
+endif
+
ifneq ($(CONFIG_SND_SOC_GENERIC_DMAENGINE_PCM),)
snd-soc-core-y += soc-generic-dmaengine-pcm.o
endif
diff --git a/sound/soc/soc-ops-test.c b/sound/soc/soc-ops-test.c
new file mode 100644
index 0000000000000..dc1e482bba6a9
--- /dev/null
+++ b/sound/soc/soc-ops-test.c
@@ -0,0 +1,541 @@
+// SPDX-License-Identifier: GPL-2.0-only
+// Copyright (C) 2025 Cirrus Logic, Inc. and
+// Cirrus Logic International Semiconductor Ltd.
+
+#include <kunit/device.h>
+#include <kunit/test.h>
+#include <linux/module.h>
+#include <linux/regmap.h>
+#include <linux/string.h>
+#include <sound/asound.h>
+#include <sound/control.h>
+#include <sound/soc.h>
+#include <sound/soc-component.h>
+
+enum soc_ops_test_control_layout {
+ SOC_OPS_TEST_SINGLE,
+ SOC_OPS_TEST_DOUBLE,
+ SOC_OPS_TEST_DOUBLE_R,
+};
+
+#define TEST_MC(clayout, xmin, xmax, xpmax, xsign, xinvert) \
+ .mc = { \
+ .min = xmin, .max = xmax, .platform_max = xpmax, \
+ .reg = 0, .shift = 0, .sign_bit = xsign, .invert = xinvert, \
+ .rreg = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE_R ? 1 : 0, \
+ .rshift = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE ? 16 : 0, \
+ }
+
+#define TEST_UINFO(clayout, ctype, cmin, cmax) \
+ .uinfo = { \
+ .type = SNDRV_CTL_ELEM_TYPE_##ctype, \
+ .count = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_SINGLE ? 1 : 2, \
+ .value.integer.min = cmin, \
+ .value.integer.max = cmax, \
+ }
+
+#define ITEST(cname, clayout, ctype, cfunc, cmin, cmax, \
+ xmin, xmax, xpmax, xsign, xinvert) \
+ { \
+ .name = cname, \
+ .func_name = #cfunc, \
+ .layout = SOC_OPS_TEST_##clayout, \
+ .info = snd_soc_info_##cfunc, \
+ TEST_MC(clayout, xmin, xmax, xpmax, xsign, xinvert), \
+ TEST_UINFO(clayout, ctype, cmin, cmax), \
+ }
+
+#define ATEST(clayout, cfunc, cctl, cret, cinit, \
+ xmask, xreg, xmin, xmax, xpmax, xsign, xinvert) \
+ { \
+ .func_name = #cfunc, \
+ .layout = SOC_OPS_TEST_##clayout, \
+ .put = snd_soc_put_##cfunc, \
+ .get = snd_soc_get_##cfunc, \
+ TEST_MC(clayout, xmin, xmax, xpmax, xsign, xinvert), \
+ .lctl = cctl, .rctl = cctl, \
+ .lmask = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE ? \
+ (xmask) | (xmask) << 16 : (xmask), \
+ .rmask = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE_R ? (xmask) : 0, \
+ .init = cinit ? 0xFFFFFFFF : 0x00000000, \
+ .lreg = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE ? \
+ (xreg) | (xreg) << 16 : (xreg), \
+ .rreg = SOC_OPS_TEST_##clayout == SOC_OPS_TEST_DOUBLE_R ? (xreg) : 0, \
+ .ret = cret, \
+ }
+
+struct soc_ops_test_priv {
+ struct kunit *test;
+
+ struct snd_soc_component component;
+};
+
+struct info_test_param {
+ const char * const name;
+ const char * const func_name;
+ enum soc_ops_test_control_layout layout;
+ struct soc_mixer_control mc;
+ int (*info)(struct snd_kcontrol *kctl, struct snd_ctl_elem_info *info);
+
+ struct snd_ctl_elem_info uinfo;
+};
+
+struct access_test_param {
+ const char * const func_name;
+ enum soc_ops_test_control_layout layout;
+ struct soc_mixer_control mc;
+ int (*put)(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *value);
+ int (*get)(struct snd_kcontrol *kctl, struct snd_ctl_elem_value *value);
+
+ unsigned int init;
+ unsigned int lmask;
+ unsigned int rmask;
+ unsigned int lreg;
+ unsigned int rreg;
+ long lctl;
+ long rctl;
+ int ret;
+};
+
+static const struct info_test_param all_info_test_params[] = {
+ // Handling of volume control name for types
+ ITEST("Test Control", SINGLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume Control", SINGLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Control", DOUBLE_R, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume", DOUBLE_R, INTEGER, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume Control", DOUBLE_R, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Control", DOUBLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume", DOUBLE, INTEGER, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Volume Control", DOUBLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 0),
+ ITEST("Test Control", SINGLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Volume Control", SINGLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Control", DOUBLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Volume", DOUBLE, INTEGER, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Volume Control", DOUBLE, BOOLEAN, volsw, 0, 1, 0, 1, 0, 0, 1),
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 2, 0, 2, 0, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw, 0, 2, 0, 2, 0, 0, 0),
+ ITEST("Test Volume Control", SINGLE, INTEGER, volsw, 0, 2, 0, 2, 0, 0, 0),
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 1, 0, 2, 1, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw, 0, 1, 0, 2, 1, 0, 0),
+ ITEST("Test Volume Control", SINGLE, INTEGER, volsw, 0, 1, 0, 2, 1, 0, 0),
+ // Negative minimums
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 20, -10, 10, 0, 4, 0),
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 15, -10, 10, 15, 4, 0),
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 20, -10, 10, 0, 4, 1),
+ ITEST("Test Control", SINGLE, INTEGER, volsw, 0, 15, -10, 10, 15, 4, 1),
+ // SX control volume control naming
+ ITEST("Test Control", SINGLE, BOOLEAN, volsw_sx, 0, 1, 0xF, 1, 0, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw_sx, 0, 1, 0xF, 1, 0, 0, 0),
+ ITEST("Test Volume Control", SINGLE, BOOLEAN, volsw_sx, 0, 1, 0xF, 1, 0, 0, 0),
+ ITEST("Test Control", SINGLE, INTEGER, volsw_sx, 0, 4, 0xE, 4, 0, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw_sx, 0, 4, 0xE, 4, 0, 0, 0),
+ ITEST("Test Volume Control", SINGLE, INTEGER, volsw_sx, 0, 4, 0xE, 4, 0, 0, 0),
+ ITEST("Test Control", SINGLE, INTEGER, volsw_sx, 0, 3, 0xE, 4, 3, 0, 0),
+ ITEST("Test Volume", SINGLE, INTEGER, volsw_sx, 0, 3, 0xE, 4, 3, 0, 0),
+ ITEST("Test Volume Control", SINGLE, INTEGER, volsw_sx, 0, 3, 0xE, 4, 3, 0, 0),
+};
+
+static const struct access_test_param all_access_test_params[] = {
+ // Single positive value controls
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 0, 0, false, 0x1F, 0x00, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 20, 1, false, 0x1F, 0x14, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 15, 0, 0),
+ ATEST(SINGLE, volsw, 25, -22, false, 0x1F, 0x00, 0, 20, 15, 0, 0),
+ ATEST(SINGLE, volsw, 15, 1, false, 0x1F, 0x0F, 0, 20, 15, 0, 0),
+ // Inverted single positive value controls
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 0, 0, 1),
+ ATEST(SINGLE, volsw, 0, 1, false, 0x1F, 0x14, 0, 20, 0, 0, 1),
+ ATEST(SINGLE, volsw, 20, 0, false, 0x1F, 0x00, 0, 20, 0, 0, 1),
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 15, 0, 1),
+ ATEST(SINGLE, volsw, 25, -22, false, 0x1F, 0x00, 0, 20, 15, 0, 1),
+ ATEST(SINGLE, volsw, 15, 1, false, 0x1F, 0x05, 0, 20, 15, 0, 1),
+ ATEST(SINGLE, volsw, 10, 1, true, 0x1F, 0x0A, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 0, 1, true, 0x1F, 0x00, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 20, 1, true, 0x1F, 0x14, 0, 20, 0, 0, 0),
+ ATEST(SINGLE, volsw, 10, 1, true, 0x1F, 0x0A, 0, 20, 15, 0, 0),
+ ATEST(SINGLE, volsw, 25, -22, true, 0x1F, 0x00, 0, 20, 15, 0, 0),
+ ATEST(SINGLE, volsw, 15, 1, true, 0x1F, 0x0F, 0, 20, 15, 0, 0),
+ // Single negative value controls
+ ATEST(SINGLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 0, 4, 0),
+ ATEST(SINGLE, volsw, 0, 1, false, 0x1F, 0x16, -10, 10, 0, 4, 0),
+ ATEST(SINGLE, volsw, 20, 1, false, 0x1F, 0x0A, -10, 10, 0, 4, 0),
+ ATEST(SINGLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(SINGLE, volsw, 25, -22, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(SINGLE, volsw, 15, 1, false, 0x1F, 0x05, -10, 10, 15, 4, 0),
+ // Single non-zero minimum positive value controls
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 0, 0, 0),
+ ATEST(SINGLE, volsw, 0, 1, false, 0x1F, 0x0A, 10, 30, 0, 0, 0),
+ ATEST(SINGLE, volsw, 20, 1, false, 0x1F, 0x1E, 10, 30, 0, 0, 0),
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 15, 0, 0),
+ ATEST(SINGLE, volsw, 25, -22, false, 0x1F, 0x00, 10, 30, 15, 0, 0),
+ ATEST(SINGLE, volsw, 15, 1, false, 0x1F, 0x19, 10, 30, 15, 0, 0),
+ // Inverted single non-zero minimum positive value controls
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 0, 0, 1),
+ ATEST(SINGLE, volsw, 0, 1, false, 0x1F, 0x1E, 10, 30, 0, 0, 1),
+ ATEST(SINGLE, volsw, 20, 1, false, 0x1F, 0x0A, 10, 30, 0, 0, 1),
+ ATEST(SINGLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 15, 0, 1),
+ ATEST(SINGLE, volsw, 25, -22, false, 0x1F, 0x00, 10, 30, 15, 0, 1),
+ ATEST(SINGLE, volsw, 15, 1, false, 0x1F, 0x0F, 10, 30, 15, 0, 1),
+ // Double register positive value controls
+ ATEST(DOUBLE_R, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 0, 0, false, 0x1F, 0x00, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 20, 1, false, 0x1F, 0x14, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 15, 0, 0),
+ ATEST(DOUBLE_R, volsw, 25, -22, false, 0x1F, 0x00, 0, 20, 15, 0, 0),
+ ATEST(DOUBLE_R, volsw, 15, 1, false, 0x1F, 0x0F, 0, 20, 15, 0, 0),
+ // Double register negative value controls
+ ATEST(DOUBLE_R, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 0, 1, false, 0x1F, 0x16, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 20, 1, false, 0x1F, 0x0A, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE_R, volsw, 25, -22, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE_R, volsw, 15, 1, false, 0x1F, 0x05, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE_R, volsw, 10, 1, true, 0x1F, 0x00, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 0, 1, true, 0x1F, 0x16, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 20, 1, true, 0x1F, 0x0A, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE_R, volsw, 10, 1, true, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE_R, volsw, 25, -22, true, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE_R, volsw, 15, 1, true, 0x1F, 0x05, -10, 10, 15, 4, 0),
+ // Inverted double register negative value controls
+ ATEST(DOUBLE_R, volsw, 10, 1, true, 0x1F, 0x00, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE_R, volsw, 0, 1, true, 0x1F, 0x0A, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE_R, volsw, 20, 1, true, 0x1F, 0x16, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE_R, volsw, 10, 1, true, 0x1F, 0x00, -10, 10, 15, 4, 1),
+ ATEST(DOUBLE_R, volsw, 25, -22, true, 0x1F, 0x00, -10, 10, 15, 4, 1),
+ ATEST(DOUBLE_R, volsw, 15, 1, true, 0x1F, 0x1B, -10, 10, 15, 4, 1),
+ // Double register non-zero minimum positive value controls
+ ATEST(DOUBLE_R, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 0, 1, false, 0x1F, 0x0A, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 20, 1, false, 0x1F, 0x1E, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE_R, volsw, 25, -22, false, 0x1F, 0x00, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE_R, volsw, 15, 1, false, 0x1F, 0x19, 10, 30, 15, 0, 0),
+ // Double shift positive value controls
+ ATEST(DOUBLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 0, 0, false, 0x1F, 0x00, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 20, 1, false, 0x1F, 0x14, 0, 20, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 10, 1, false, 0x1F, 0x0A, 0, 20, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 25, -22, false, 0x1F, 0x00, 0, 20, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 15, 1, false, 0x1F, 0x0F, 0, 20, 15, 0, 0),
+ // Double shift negative value controls
+ ATEST(DOUBLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE, volsw, 0, 1, false, 0x1F, 0x16, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE, volsw, 20, 1, false, 0x1F, 0x0A, -10, 10, 0, 4, 0),
+ ATEST(DOUBLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE, volsw, 25, -22, false, 0x1F, 0x00, -10, 10, 15, 4, 0),
+ ATEST(DOUBLE, volsw, 15, 1, false, 0x1F, 0x05, -10, 10, 15, 4, 0),
+ // Inverted double shift negative value controls
+ ATEST(DOUBLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE, volsw, 0, 1, false, 0x1F, 0x0A, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE, volsw, 20, 1, false, 0x1F, 0x16, -10, 10, 0, 4, 1),
+ ATEST(DOUBLE, volsw, 10, 0, false, 0x1F, 0x00, -10, 10, 15, 4, 1),
+ ATEST(DOUBLE, volsw, 25, -22, false, 0x1F, 0x00, -10, 10, 15, 4, 1),
+ ATEST(DOUBLE, volsw, 15, 1, false, 0x1F, 0x1B, -10, 10, 15, 4, 1),
+ // Double shift non-zero minimum positive value controls
+ ATEST(DOUBLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 0, 1, false, 0x1F, 0x0A, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 20, 1, false, 0x1F, 0x1E, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 10, 1, false, 0x1F, 0x14, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 25, -22, false, 0x1F, 0x00, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 15, 1, false, 0x1F, 0x19, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 10, 1, true, 0x1F, 0x14, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 0, 1, true, 0x1F, 0x0A, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 20, 1, true, 0x1F, 0x1E, 10, 30, 0, 0, 0),
+ ATEST(DOUBLE, volsw, 10, 1, true, 0x1F, 0x14, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 25, -22, true, 0x1F, 0x00, 10, 30, 15, 0, 0),
+ ATEST(DOUBLE, volsw, 15, 1, true, 0x1F, 0x19, 10, 30, 15, 0, 0),
+ // Single SX all values
+ ATEST(SINGLE, volsw_sx, 0, 1, false, 0xF, 0x0F, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 1, 0, false, 0xF, 0x00, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 2, 1, false, 0xF, 0x01, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 3, 1, false, 0xF, 0x02, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 4, 1, false, 0xF, 0x03, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 5, -22, false, 0xF, 0x00, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 0, 0, true, 0xF, 0x0F, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 1, 1, true, 0xF, 0x00, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 2, 1, true, 0xF, 0x01, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 3, 1, true, 0xF, 0x02, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 4, 1, true, 0xF, 0x03, 0x0F, 4, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 5, -22, true, 0xF, 0x00, 0x0F, 4, 0, 0, 0),
+ // Inverted single SX all values
+ ATEST(SINGLE, volsw_sx, 0, 1, false, 0x1F, 0x03, 0x0F, 4, 0, 0, 1),
+ ATEST(SINGLE, volsw_sx, 1, 1, false, 0x1F, 0x02, 0x0F, 4, 0, 0, 1),
+ ATEST(SINGLE, volsw_sx, 2, 1, false, 0x1F, 0x01, 0x0F, 4, 0, 0, 1),
+ ATEST(SINGLE, volsw_sx, 3, 0, false, 0x1F, 0x00, 0x0F, 4, 0, 0, 1),
+ ATEST(SINGLE, volsw_sx, 4, 1, false, 0x1F, 0x0F, 0x0F, 4, 0, 0, 1),
+ ATEST(SINGLE, volsw_sx, 5, -22, false, 0x1F, 0x00, 0x0F, 4, 0, 0, 1),
+ // Single SX select values
+ ATEST(SINGLE, volsw_sx, 0, 1, false, 0xFF, 0x88, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 1, 1, false, 0xFF, 0x89, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 119, 1, false, 0xFF, 0xFF, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 120, 0, false, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 121, 1, false, 0xFF, 0x01, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 143, 1, false, 0xFF, 0x17, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 144, 1, false, 0xFF, 0x18, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 145, -22, false, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 0, 1, true, 0xFF, 0x88, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 1, 1, true, 0xFF, 0x89, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 119, 0, true, 0xFF, 0xFF, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 120, 1, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 121, 1, true, 0xFF, 0x01, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 143, 1, true, 0xFF, 0x17, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 144, 1, true, 0xFF, 0x18, 0x88, 144, 0, 0, 0),
+ ATEST(SINGLE, volsw_sx, 145, -22, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ // Double shift SX select values
+ ATEST(DOUBLE, volsw_sx, 0, 1, true, 0xFF, 0x88, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 1, 1, true, 0xFF, 0x89, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 119, 0, true, 0xFF, 0xFF, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 120, 1, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 121, 1, true, 0xFF, 0x01, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 143, 1, true, 0xFF, 0x17, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 144, 1, true, 0xFF, 0x18, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE, volsw_sx, 145, -22, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ // Double register SX select values
+ ATEST(DOUBLE_R, volsw_sx, 0, 1, true, 0xFF, 0x88, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 1, 1, true, 0xFF, 0x89, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 119, 0, true, 0xFF, 0xFF, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 120, 1, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 121, 1, true, 0xFF, 0x01, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 143, 1, true, 0xFF, 0x17, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 144, 1, true, 0xFF, 0x18, 0x88, 144, 0, 0, 0),
+ ATEST(DOUBLE_R, volsw_sx, 145, -22, true, 0xFF, 0x00, 0x88, 144, 0, 0, 0),
+};
+
+static const char *control_type_str(const snd_ctl_elem_type_t type)
+{
+ switch (type) {
+ case SNDRV_CTL_ELEM_TYPE_BOOLEAN:
+ return "bool";
+ case SNDRV_CTL_ELEM_TYPE_INTEGER:
+ return "int";
+ default:
+ return "unknown";
+ }
+}
+
+static const char *control_layout_str(const enum soc_ops_test_control_layout layout)
+{
+ switch (layout) {
+ case SOC_OPS_TEST_SINGLE:
+ return "single";
+ case SOC_OPS_TEST_DOUBLE:
+ return "double";
+ case SOC_OPS_TEST_DOUBLE_R:
+ return "double_r";
+ default:
+ return "unknown";
+ }
+};
+
+static int mock_regmap_read(void *context, const void *reg_buf,
+ const size_t reg_size, void *val_buf,
+ size_t val_size)
+{
+ struct soc_ops_test_priv *priv = context;
+
+ KUNIT_FAIL(priv->test, "Unexpected bus read");
+
+ return -EIO;
+}
+
+static int mock_regmap_gather_write(void *context,
+ const void *reg_buf, size_t reg_size,
+ const void *val_buf, size_t val_size)
+{
+ struct soc_ops_test_priv *priv = context;
+
+ KUNIT_FAIL(priv->test, "Unexpected bus gather_write");
+
+ return -EIO;
+}
+
+static int mock_regmap_write(void *context, const void *val_buf,
+ size_t val_size)
+{
+ struct soc_ops_test_priv *priv = context;
+
+ KUNIT_FAIL(priv->test, "Unexpected bus write");
+
+ return -EIO;
+}
+
+static const struct regmap_bus mock_regmap_bus = {
+ .read = mock_regmap_read,
+ .write = mock_regmap_write,
+ .gather_write = mock_regmap_gather_write,
+ .reg_format_endian_default = REGMAP_ENDIAN_NATIVE,
+ .val_format_endian_default = REGMAP_ENDIAN_NATIVE,
+};
+
+static const struct regmap_config mock_regmap_config = {
+ .reg_bits = 32,
+ .val_bits = 32,
+ .reg_format_endian = REGMAP_ENDIAN_NATIVE,
+ .val_format_endian = REGMAP_ENDIAN_NATIVE,
+ .max_register = 0x1,
+ .cache_type = REGCACHE_FLAT,
+};
+
+static int soc_ops_test_init(struct kunit *test)
+{
+ struct soc_ops_test_priv *priv;
+ struct regmap *regmap;
+ struct device *dev;
+
+ priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->test = test;
+
+ dev = kunit_device_register(test, "soc_ops_test_drv");
+ if (IS_ERR(dev))
+ return PTR_ERR(dev);
+
+ regmap = devm_regmap_init(dev, &mock_regmap_bus, priv, &mock_regmap_config);
+ if (IS_ERR(regmap))
+ return PTR_ERR(regmap);
+
+ /* No actual hardware, we just use the cache */
+ regcache_cache_only(regmap, true);
+
+ priv->component.dev = dev;
+ priv->component.regmap = regmap;
+ mutex_init(&priv->component.io_mutex);
+
+ test->priv = priv;
+
+ return 0;
+}
+
+static void soc_ops_test_exit(struct kunit *test)
+{
+ struct soc_ops_test_priv *priv = test->priv;
+
+ kunit_device_unregister(test, priv->component.dev);
+}
+
+static void info_test_desc(const struct info_test_param *param, char *desc)
+{
+ snprintf(desc, KUNIT_PARAM_DESC_SIZE,
+ "%s %s %s: ctl range: %ld->%ld, reg range: %d->%d(%d), sign: %d, inv: %d",
+ control_layout_str(param->layout), param->func_name,
+ control_type_str(param->uinfo.type),
+ param->uinfo.value.integer.min, param->uinfo.value.integer.max,
+ param->mc.min, param->mc.max, param->mc.platform_max,
+ param->mc.sign_bit, param->mc.invert);
+}
+
+static void soc_ops_test_info(struct kunit *test)
+{
+ struct soc_ops_test_priv *priv = test->priv;
+ const struct info_test_param *param = test->param_value;
+ const struct snd_ctl_elem_info *target = ¶m->uinfo;
+ struct snd_ctl_elem_info result;
+ struct snd_kcontrol kctl = {
+ .private_data = &priv->component,
+ .private_value = (unsigned long)¶m->mc,
+ };
+ int ret;
+
+ strscpy(kctl.id.name, param->name, sizeof(kctl.id.name));
+
+ ret = param->info(&kctl, &result);
+ KUNIT_ASSERT_FALSE(test, ret);
+
+ KUNIT_EXPECT_EQ(test, result.count, target->count);
+ KUNIT_EXPECT_EQ(test, result.type, target->type);
+ KUNIT_EXPECT_EQ(test, result.value.integer.min, target->value.integer.min);
+ KUNIT_EXPECT_EQ(test, result.value.integer.max, target->value.integer.max);
+}
+
+static void access_test_desc(const struct access_test_param *param, char *desc)
+{
+ if (param->ret < 0) {
+ snprintf(desc, KUNIT_PARAM_DESC_SIZE,
+ "%s %s: %ld,%ld -> range: %d->%d(%d), sign: %d, inv: %d -> err: %d",
+ control_layout_str(param->layout), param->func_name,
+ param->lctl, param->rctl,
+ param->mc.min, param->mc.max, param->mc.platform_max,
+ param->mc.sign_bit, param->mc.invert,
+ param->ret);
+ } else {
+ snprintf(desc, KUNIT_PARAM_DESC_SIZE,
+ "%s %s: %ld,%ld -> range: %d->%d(%d), sign: %d, inv: %d -> %#x,%#x",
+ control_layout_str(param->layout), param->func_name,
+ param->lctl, param->rctl,
+ param->mc.min, param->mc.max, param->mc.platform_max,
+ param->mc.sign_bit, param->mc.invert,
+ param->lreg, param->rreg);
+ }
+}
+
+static void soc_ops_test_access(struct kunit *test)
+{
+ struct soc_ops_test_priv *priv = test->priv;
+ const struct access_test_param *param = test->param_value;
+ struct snd_kcontrol kctl = {
+ .private_data = &priv->component,
+ .private_value = (unsigned long)¶m->mc,
+ };
+ struct snd_ctl_elem_value result;
+ unsigned int val;
+ int ret;
+
+ ret = regmap_write(priv->component.regmap, 0x0, param->init);
+ KUNIT_ASSERT_FALSE(test, ret);
+ ret = regmap_write(priv->component.regmap, 0x1, param->init);
+ KUNIT_ASSERT_FALSE(test, ret);
+
+ result.value.integer.value[0] = param->lctl;
+ result.value.integer.value[1] = param->rctl;
+
+ ret = param->put(&kctl, &result);
+ KUNIT_ASSERT_EQ(test, ret, param->ret);
+ if (ret < 0)
+ return;
+
+ ret = regmap_read(priv->component.regmap, 0x0, &val);
+ KUNIT_ASSERT_FALSE(test, ret);
+ KUNIT_EXPECT_EQ(test, val, (param->init & ~param->lmask) | param->lreg);
+
+ ret = regmap_read(priv->component.regmap, 0x1, &val);
+ KUNIT_ASSERT_FALSE(test, ret);
+ KUNIT_EXPECT_EQ(test, val, (param->init & ~param->rmask) | param->rreg);
+
+ result.value.integer.value[0] = 0;
+ result.value.integer.value[1] = 0;
+
+ ret = param->get(&kctl, &result);
+ KUNIT_ASSERT_GE(test, ret, 0);
+
+ KUNIT_EXPECT_EQ(test, result.value.integer.value[0], param->lctl);
+ if (param->layout != SOC_OPS_TEST_SINGLE)
+ KUNIT_EXPECT_EQ(test, result.value.integer.value[1], param->rctl);
+ else
+ KUNIT_EXPECT_EQ(test, result.value.integer.value[1], 0);
+}
+
+KUNIT_ARRAY_PARAM(all_info_tests, all_info_test_params, info_test_desc);
+KUNIT_ARRAY_PARAM(all_access_tests, all_access_test_params, access_test_desc);
+
+static struct kunit_case soc_ops_test_cases[] = {
+ KUNIT_CASE_PARAM(soc_ops_test_info, all_info_tests_gen_params),
+ KUNIT_CASE_PARAM(soc_ops_test_access, all_access_tests_gen_params),
+ {}
+};
+
+static struct kunit_suite soc_ops_test_suite = {
+ .name = "soc-ops",
+ .init = soc_ops_test_init,
+ .exit = soc_ops_test_exit,
+ .test_cases = soc_ops_test_cases,
+};
+
+kunit_test_suites(&soc_ops_test_suite);
+
+MODULE_DESCRIPTION("ASoC soc-ops kunit test");
+MODULE_LICENSE("GPL");
--
2.39.5
next prev parent reply other threads:[~2025-03-18 17:15 UTC|newest]
Thread overview: 20+ messages / expand[flat|nested] mbox.gz Atom feed top
2025-03-18 17:14 [PATCH 00/15] Tidy up ASoC control get and put handlers Charles Keepax
2025-03-18 17:14 ` Charles Keepax [this message]
2025-03-18 17:14 ` [PATCH 02/15] ASoC: ops: Minor formatting fixups Charles Keepax
2025-03-18 17:14 ` [PATCH 03/15] ASoC: ops: Update comments for xr_sx control helpers Charles Keepax
2025-03-18 17:14 ` [PATCH 04/15] ASoC: ops: Update mask generation to use GENMASK Charles Keepax
2025-03-18 17:14 ` [PATCH 05/15] ASoC: ops: Factor out helper to check valid control values Charles Keepax
2025-03-18 17:14 ` [PATCH 06/15] ASoC: ops: Replace snd_soc_read_signed() with new helper Charles Keepax
2025-03-18 17:14 ` [PATCH 07/15] ASoC: ops: Add control to register value helper Charles Keepax
2025-03-18 17:14 ` [PATCH 08/15] ASoC: ops: Remove snd_soc_info_volsw_range() Charles Keepax
2025-03-18 17:14 ` [PATCH 09/15] ASoC: ops: Remove snd_soc_get_volsw_range() Charles Keepax
2025-03-18 17:14 ` [PATCH 10/15] ASoC: ops: Remove snd_soc_put_volsw_range() Charles Keepax
2025-03-18 17:14 ` [PATCH 11/15] ASoC: ops: Factor out common code from info callbacks Charles Keepax
2025-03-18 17:14 ` [PATCH 12/15] ASoC: ops: Factor out common code from put callbacks Charles Keepax
2025-03-18 17:14 ` [PATCH 13/15] ASoC: ops: Factor out common code from get callbacks Charles Keepax
2025-03-19 15:12 ` Mark Brown
2025-03-19 16:04 ` Charles Keepax
2025-03-19 16:08 ` Mark Brown
2025-03-18 17:14 ` [PATCH 14/15] ASoC: ops: Remove some unnecessary local variables Charles Keepax
2025-03-18 17:14 ` [PATCH 15/15] ASoC: ops: Apply platform_max after deciding control type Charles Keepax
2025-03-20 18:45 ` [PATCH 00/15] Tidy up ASoC control get and put handlers Mark Brown
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=20250318171459.3203730-2-ckeepax@opensource.cirrus.com \
--to=ckeepax@opensource.cirrus.com \
--cc=baojun.xu@ti.com \
--cc=broonie@kernel.org \
--cc=kevin-lu@ti.com \
--cc=lgirdwood@gmail.com \
--cc=linux-kernel@vger.kernel.org \
--cc=linux-sound@vger.kernel.org \
--cc=patches@opensource.cirrus.com \
--cc=shenghao-ding@ti.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