mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/chenhuacai/linux-loongson
synced 2025-09-01 06:39:05 +00:00
dae29b678b
This structure is really too larget to be allocated on the stack: linux/sound/soc/soc-ops-test.c:520:1: error: the frame size of\ 1304 bytes is larger than 1280 bytes [-Werror=frame-larger-than=] Change the function to dynamically allocate it instead. Signed-off-by: Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> Link: https://patch.msgid.link/87sek489l8.wl-kuninori.morimoto.gx@renesas.com Signed-off-by: Mark Brown <broonie@kernel.org>
549 lines
24 KiB
C
549 lines
24 KiB
C
// 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,
|
|
};
|
|
unsigned int val;
|
|
int ret;
|
|
/* it is too large struct. use kzalloc() */
|
|
struct snd_ctl_elem_value *result;
|
|
|
|
result = kzalloc(sizeof(*result), GFP_KERNEL);
|
|
if (!result)
|
|
return;
|
|
|
|
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)
|
|
goto end;
|
|
|
|
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);
|
|
end:
|
|
kfree(result);
|
|
}
|
|
|
|
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");
|