| // SPDX-License-Identifier: GPL-2.0-only | |
| // | |
| // Mock regmap for cs_dsp KUnit tests. | |
| // | |
| // Copyright (C) 2024 Cirrus Logic, Inc. and | |
| // Cirrus Logic International Semiconductor Ltd. | |
| #include <kunit/test.h> | |
| #include <linux/firmware/cirrus/cs_dsp.h> | |
| #include <linux/firmware/cirrus/cs_dsp_test_utils.h> | |
| #include <linux/firmware/cirrus/wmfw.h> | |
| #include <linux/regmap.h> | |
| static int cs_dsp_mock_regmap_read(void *context, const void *reg_buf, | |
| const size_t reg_size, void *val_buf, | |
| size_t val_size) | |
| { | |
| struct cs_dsp_test *priv = context; | |
| /* Should never get here because the regmap is cache-only */ | |
| KUNIT_FAIL(priv->test, "Unexpected bus read @%#x", *(u32 *)reg_buf); | |
| return -EIO; | |
| } | |
| static int cs_dsp_mock_regmap_gather_write(void *context, | |
| const void *reg_buf, size_t reg_size, | |
| const void *val_buf, size_t val_size) | |
| { | |
| struct cs_dsp_test *priv = context; | |
| priv->saw_bus_write = true; | |
| /* Should never get here because the regmap is cache-only */ | |
| KUNIT_FAIL(priv->test, "Unexpected bus gather_write @%#x", *(u32 *)reg_buf); | |
| return -EIO; | |
| } | |
| static int cs_dsp_mock_regmap_write(void *context, const void *val_buf, size_t val_size) | |
| { | |
| struct cs_dsp_test *priv = context; | |
| priv->saw_bus_write = true; | |
| /* Should never get here because the regmap is cache-only */ | |
| KUNIT_FAIL(priv->test, "Unexpected bus write @%#x", *(u32 *)val_buf); | |
| return -EIO; | |
| } | |
| static const struct regmap_bus cs_dsp_mock_regmap_bus = { | |
| .read = cs_dsp_mock_regmap_read, | |
| .write = cs_dsp_mock_regmap_write, | |
| .gather_write = cs_dsp_mock_regmap_gather_write, | |
| .reg_format_endian_default = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian_default = REGMAP_ENDIAN_LITTLE, | |
| }; | |
| static const struct reg_default adsp2_32bit_register_defaults[] = { | |
| { 0xffe00, 0x0000 }, /* CONTROL */ | |
| { 0xffe02, 0x0000 }, /* CLOCKING */ | |
| { 0xffe04, 0x0001 }, /* STATUS1: RAM_RDY=1 */ | |
| { 0xffe30, 0x0000 }, /* WDMW_CONFIG_1 */ | |
| { 0xffe32, 0x0000 }, /* WDMA_CONFIG_2 */ | |
| { 0xffe34, 0x0000 }, /* RDMA_CONFIG_1 */ | |
| { 0xffe40, 0x0000 }, /* SCRATCH_0_1 */ | |
| { 0xffe42, 0x0000 }, /* SCRATCH_2_3 */ | |
| }; | |
| static const struct regmap_range adsp2_32bit_registers[] = { | |
| regmap_reg_range(0x80000, 0x88ffe), /* PM */ | |
| regmap_reg_range(0xa0000, 0xa9ffe), /* XM */ | |
| regmap_reg_range(0xc0000, 0xc1ffe), /* YM */ | |
| regmap_reg_range(0xe0000, 0xe1ffe), /* ZM */ | |
| regmap_reg_range(0xffe00, 0xffe7c), /* CORE CTRL */ | |
| }; | |
| const unsigned int cs_dsp_mock_adsp2_32bit_sysbase = 0xffe00; | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_adsp2_32bit_sysbase, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| static const struct regmap_access_table adsp2_32bit_rw = { | |
| .yes_ranges = adsp2_32bit_registers, | |
| .n_yes_ranges = ARRAY_SIZE(adsp2_32bit_registers), | |
| }; | |
| static const struct regmap_config cs_dsp_mock_regmap_adsp2_32bit = { | |
| .reg_bits = 32, | |
| .val_bits = 32, | |
| .reg_stride = 2, | |
| .reg_format_endian = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian = REGMAP_ENDIAN_BIG, | |
| .wr_table = &adsp2_32bit_rw, | |
| .rd_table = &adsp2_32bit_rw, | |
| .max_register = 0xffe7c, | |
| .reg_defaults = adsp2_32bit_register_defaults, | |
| .num_reg_defaults = ARRAY_SIZE(adsp2_32bit_register_defaults), | |
| .cache_type = REGCACHE_MAPLE, | |
| }; | |
| static const struct reg_default adsp2_16bit_register_defaults[] = { | |
| { 0x1100, 0x0000 }, /* CONTROL */ | |
| { 0x1101, 0x0000 }, /* CLOCKING */ | |
| { 0x1104, 0x0001 }, /* STATUS1: RAM_RDY=1 */ | |
| { 0x1130, 0x0000 }, /* WDMW_CONFIG_1 */ | |
| { 0x1131, 0x0000 }, /* WDMA_CONFIG_2 */ | |
| { 0x1134, 0x0000 }, /* RDMA_CONFIG_1 */ | |
| { 0x1140, 0x0000 }, /* SCRATCH_0 */ | |
| { 0x1141, 0x0000 }, /* SCRATCH_1 */ | |
| { 0x1142, 0x0000 }, /* SCRATCH_2 */ | |
| { 0x1143, 0x0000 }, /* SCRATCH_3 */ | |
| }; | |
| static const struct regmap_range adsp2_16bit_registers[] = { | |
| regmap_reg_range(0x001100, 0x001143), /* CORE CTRL */ | |
| regmap_reg_range(0x100000, 0x105fff), /* PM */ | |
| regmap_reg_range(0x180000, 0x1807ff), /* ZM */ | |
| regmap_reg_range(0x190000, 0x1947ff), /* XM */ | |
| regmap_reg_range(0x1a8000, 0x1a97ff), /* YM */ | |
| }; | |
| const unsigned int cs_dsp_mock_adsp2_16bit_sysbase = 0x001100; | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_adsp2_16bit_sysbase, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| static const struct regmap_access_table adsp2_16bit_rw = { | |
| .yes_ranges = adsp2_16bit_registers, | |
| .n_yes_ranges = ARRAY_SIZE(adsp2_16bit_registers), | |
| }; | |
| static const struct regmap_config cs_dsp_mock_regmap_adsp2_16bit = { | |
| .reg_bits = 32, | |
| .val_bits = 16, | |
| .reg_stride = 1, | |
| .reg_format_endian = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian = REGMAP_ENDIAN_BIG, | |
| .wr_table = &adsp2_16bit_rw, | |
| .rd_table = &adsp2_16bit_rw, | |
| .max_register = 0x1a97ff, | |
| .reg_defaults = adsp2_16bit_register_defaults, | |
| .num_reg_defaults = ARRAY_SIZE(adsp2_16bit_register_defaults), | |
| .cache_type = REGCACHE_MAPLE, | |
| }; | |
| static const struct reg_default halo_register_defaults[] = { | |
| /* CORE */ | |
| { 0x2b80010, 0 }, /* HALO_CORE_SOFT_RESET */ | |
| { 0x2b805c0, 0 }, /* HALO_SCRATCH1 */ | |
| { 0x2b805c8, 0 }, /* HALO_SCRATCH2 */ | |
| { 0x2b805d0, 0 }, /* HALO_SCRATCH3 */ | |
| { 0x2b805d8, 0 }, /* HALO_SCRATCH4 */ | |
| { 0x2bc1000, 0 }, /* HALO_CCM_CORE_CONTROL */ | |
| { 0x2bc7000, 0 }, /* HALO_WDT_CONTROL */ | |
| /* SYSINFO */ | |
| { 0x25e2040, 0 }, /* HALO_AHBM_WINDOW_DEBUG_0 */ | |
| { 0x25e2044, 0 }, /* HALO_AHBM_WINDOW_DEBUG_1 */ | |
| }; | |
| static const struct regmap_range halo_readable_registers[] = { | |
| regmap_reg_range(0x2000000, 0x208fff0), /* XM_PACKED */ | |
| regmap_reg_range(0x25e0000, 0x25e004f), /* SYSINFO */ | |
| regmap_reg_range(0x25e2000, 0x25e2047), /* SYSINFO */ | |
| regmap_reg_range(0x2800000, 0x28bfff4), /* XM */ | |
| regmap_reg_range(0x2b80000, 0x2bc700b), /* CORE CTRL */ | |
| regmap_reg_range(0x2c00000, 0x2c8fff0), /* YM_PACKED */ | |
| regmap_reg_range(0x3400000, 0x34bfff4), /* YM */ | |
| regmap_reg_range(0x3800000, 0x3804fff), /* PM_PACKED */ | |
| }; | |
| static const struct regmap_range halo_writeable_registers[] = { | |
| regmap_reg_range(0x2000000, 0x208fff0), /* XM_PACKED */ | |
| regmap_reg_range(0x2800000, 0x28bfff4), /* XM */ | |
| regmap_reg_range(0x2b80000, 0x2bc700b), /* CORE CTRL */ | |
| regmap_reg_range(0x2c00000, 0x2c8fff0), /* YM_PACKED */ | |
| regmap_reg_range(0x3400000, 0x34bfff4), /* YM */ | |
| regmap_reg_range(0x3800000, 0x3804fff), /* PM_PACKED */ | |
| }; | |
| const unsigned int cs_dsp_mock_halo_core_base = 0x2b80000; | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_halo_core_base, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| const unsigned int cs_dsp_mock_halo_sysinfo_base = 0x25e0000; | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_halo_sysinfo_base, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| static const struct regmap_access_table halo_readable = { | |
| .yes_ranges = halo_readable_registers, | |
| .n_yes_ranges = ARRAY_SIZE(halo_readable_registers), | |
| }; | |
| static const struct regmap_access_table halo_writeable = { | |
| .yes_ranges = halo_writeable_registers, | |
| .n_yes_ranges = ARRAY_SIZE(halo_writeable_registers), | |
| }; | |
| static const struct regmap_config cs_dsp_mock_regmap_halo = { | |
| .reg_bits = 32, | |
| .val_bits = 32, | |
| .reg_stride = 4, | |
| .reg_format_endian = REGMAP_ENDIAN_LITTLE, | |
| .val_format_endian = REGMAP_ENDIAN_BIG, | |
| .wr_table = &halo_writeable, | |
| .rd_table = &halo_readable, | |
| .max_register = 0x3804ffc, | |
| .reg_defaults = halo_register_defaults, | |
| .num_reg_defaults = ARRAY_SIZE(halo_register_defaults), | |
| .cache_type = REGCACHE_MAPLE, | |
| }; | |
| /** | |
| * cs_dsp_mock_regmap_drop_range() - drop a range of registers from the cache. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. | |
| * @first_reg: Address of first register to drop. | |
| * @last_reg: Address of last register to drop. | |
| */ | |
| void cs_dsp_mock_regmap_drop_range(struct cs_dsp_test *priv, | |
| unsigned int first_reg, unsigned int last_reg) | |
| { | |
| regcache_drop_region(priv->dsp->regmap, first_reg, last_reg); | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_drop_range, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| /** | |
| * cs_dsp_mock_regmap_drop_regs() - drop a number of registers from the cache. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. | |
| * @first_reg: Address of first register to drop. | |
| * @num_regs: Number of registers to drop. | |
| */ | |
| void cs_dsp_mock_regmap_drop_regs(struct cs_dsp_test *priv, | |
| unsigned int first_reg, size_t num_regs) | |
| { | |
| int stride = regmap_get_reg_stride(priv->dsp->regmap); | |
| unsigned int last = first_reg + (stride * (num_regs - 1)); | |
| cs_dsp_mock_regmap_drop_range(priv, first_reg, last); | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_drop_regs, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| /** | |
| * cs_dsp_mock_regmap_drop_bytes() - drop a number of bytes from the cache. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. | |
| * @first_reg: Address of first register to drop. | |
| * @num_bytes: Number of bytes to drop from the cache. Will be rounded | |
| * down to a whole number of registers. Trailing bytes that | |
| * are not a multiple of the register size will not be dropped. | |
| * (This is intended to help detect math errors in test code.) | |
| */ | |
| void cs_dsp_mock_regmap_drop_bytes(struct cs_dsp_test *priv, | |
| unsigned int first_reg, size_t num_bytes) | |
| { | |
| size_t num_regs = num_bytes / regmap_get_val_bytes(priv->dsp->regmap); | |
| cs_dsp_mock_regmap_drop_regs(priv, first_reg, num_regs); | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_drop_bytes, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| /** | |
| * cs_dsp_mock_regmap_drop_system_regs() - Drop DSP system registers from the cache. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. | |
| * | |
| * Drops all DSP system registers from the regmap cache. | |
| */ | |
| void cs_dsp_mock_regmap_drop_system_regs(struct cs_dsp_test *priv) | |
| { | |
| switch (priv->dsp->type) { | |
| case WMFW_ADSP2: | |
| if (priv->dsp->base) { | |
| regcache_drop_region(priv->dsp->regmap, | |
| priv->dsp->base, | |
| priv->dsp->base + 0x7c); | |
| } | |
| return; | |
| case WMFW_HALO: | |
| if (priv->dsp->base) { | |
| regcache_drop_region(priv->dsp->regmap, | |
| priv->dsp->base, | |
| priv->dsp->base + 0x47000); | |
| } | |
| /* sysinfo registers are read-only so don't drop them */ | |
| return; | |
| default: | |
| return; | |
| } | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_drop_system_regs, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| /** | |
| * cs_dsp_mock_regmap_is_dirty() - Test for dirty registers in the cache. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. | |
| * @drop_system_regs: If true the DSP system regs will be dropped from | |
| * the cache before checking for dirty. | |
| * | |
| * All registers that are expected to be written must have been dropped | |
| * from the cache (DSP system registers can be dropped by passing | |
| * drop_system_regs == true). If any unexpected registers were written | |
| * there will still be dirty entries in the cache and a cache sync will | |
| * cause a write. | |
| * | |
| * Returns: true if there were dirty entries, false if not. | |
| */ | |
| bool cs_dsp_mock_regmap_is_dirty(struct cs_dsp_test *priv, bool drop_system_regs) | |
| { | |
| if (drop_system_regs) | |
| cs_dsp_mock_regmap_drop_system_regs(priv); | |
| priv->saw_bus_write = false; | |
| regcache_cache_only(priv->dsp->regmap, false); | |
| regcache_sync(priv->dsp->regmap); | |
| regcache_cache_only(priv->dsp->regmap, true); | |
| return priv->saw_bus_write; | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_is_dirty, "FW_CS_DSP_KUNIT_TEST_UTILS"); | |
| /** | |
| * cs_dsp_mock_regmap_init() - Initialize a mock regmap. | |
| * | |
| * @priv: Pointer to struct cs_dsp_test object. This must have a | |
| * valid pointer to a struct cs_dsp in which the type and | |
| * rev fields are set to the type of DSP to be simulated. | |
| * | |
| * On success the priv->dsp->regmap will point to the created | |
| * regmap instance. | |
| * | |
| * Return: zero on success, else negative error code. | |
| */ | |
| int cs_dsp_mock_regmap_init(struct cs_dsp_test *priv) | |
| { | |
| const struct regmap_config *config; | |
| int ret; | |
| switch (priv->dsp->type) { | |
| case WMFW_HALO: | |
| config = &cs_dsp_mock_regmap_halo; | |
| break; | |
| case WMFW_ADSP2: | |
| if (priv->dsp->rev == 0) | |
| config = &cs_dsp_mock_regmap_adsp2_16bit; | |
| else | |
| config = &cs_dsp_mock_regmap_adsp2_32bit; | |
| break; | |
| default: | |
| config = NULL; | |
| break; | |
| } | |
| priv->dsp->regmap = devm_regmap_init(priv->dsp->dev, | |
| &cs_dsp_mock_regmap_bus, | |
| priv, | |
| config); | |
| if (IS_ERR(priv->dsp->regmap)) { | |
| ret = PTR_ERR(priv->dsp->regmap); | |
| kunit_err(priv->test, "Failed to allocate register map: %d\n", ret); | |
| return ret; | |
| } | |
| /* Put regmap in cache-only so it accumulates the writes done by cs_dsp */ | |
| regcache_cache_only(priv->dsp->regmap, true); | |
| return 0; | |
| } | |
| EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_regmap_init, "FW_CS_DSP_KUNIT_TEST_UTILS"); |