// SPDX-License-Identifier: GPL-2.0-only
//
// KUnit tests for cs_dsp.
//
// Copyright (C) 2024 Cirrus Logic, Inc. and
//                    Cirrus Logic International Semiconductor Ltd.
//

#include <kunit/device.h>
#include <kunit/resource.h>
#include <kunit/test.h>
#include <linux/build_bug.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/random.h>
#include <linux/regmap.h>
#include <linux/string.h>
#include <linux/vmalloc.h>

#include "../cs_dsp.h"

/*
 * Test method is:
 *
 * 1) Create a mock regmap in cache-only mode so that all writes will be cached.
 * 2) Create dummy wmfw file.
 * 3) Call cs_dsp_power_up() with the bin file.
 * 4) Readback the cached value of registers that should have been written and
 *    check they have the correct value.
 * 5) All the registers that are expected to have been written are dropped from
 *    the cache. This should leave the cache clean.
 * 6) If the cache is still dirty there have been unexpected writes.
 */

KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *)
KUNIT_DEFINE_ACTION_WRAPPER(_vfree_wrapper, vfree, void *)
KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *)

struct cs_dsp_test_local {
        struct cs_dsp_mock_xm_header *xm_header;
        struct cs_dsp_mock_wmfw_builder *wmfw_builder;
        int wmfw_version;
};

struct cs_dsp_wmfw_test_param {
        unsigned int num_blocks;
        int mem_type;
};

static const struct cs_dsp_mock_alg_def cs_dsp_wmfw_test_mock_algs[] = {
        {
                .id = 0xfafa,
                .ver = 0x100000,
                .xm_size_words = 164,
                .ym_size_words = 164,
                .zm_size_words = 164,
        },
};

/*
 * wmfw that writes the XM header.
 * cs_dsp always reads this back from unpacked XM.
 */
static void wmfw_write_xm_header_unpacked(struct kunit *test)
{
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        unsigned int reg_addr;
        u8 *readback;

        /* XM header payload was added to wmfw by test case init function */

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        /* Read raw so endianness and register width don't matter */
        readback = kunit_kzalloc(test, local->xm_header->blob_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_XM);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        local->xm_header->blob_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, local->xm_header->blob_data,
                           local->xm_header->blob_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/* Write one payload of length param->num_blocks */
static void wmfw_write_one_payload(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int mem_offset_dsp_words = 0;
        unsigned int payload_size_bytes;

        payload_size_bytes = param->num_blocks *
                             cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);

        /* payloads must be a multiple of 4 bytes and a whole number of DSP registers */
        do {
                payload_size_bytes += cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);
        } while (payload_size_bytes % 4);

        payload_data = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
        get_random_bytes(payload_data, payload_size_bytes);

        readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        /* Tests on XM must be after the XM header */
        if (param->mem_type == WMFW_ADSP2_XM)
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

        /* Add a single payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        param->mem_type, mem_offset_dsp_words,
                                        payload_data, payload_size_bytes);

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
        reg_addr += cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv) * mem_offset_dsp_words;
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/* Write several smallest possible payloads for the given memory type */
static void wmfw_write_multiple_oneblock_payloads(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int mem_offset_dsp_words = 0;
        unsigned int payload_size_bytes, payload_size_dsp_words;
        const unsigned int num_payloads = param->num_blocks;
        int i;

        /* payloads must be a multiple of 4 bytes and a whole number of DSP registers */
        payload_size_dsp_words = 0;
        payload_size_bytes = 0;
        do {
                payload_size_dsp_words += cs_dsp_mock_reg_block_length_dsp_words(priv,
                                                                                 param->mem_type);
                payload_size_bytes += cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);
        } while (payload_size_bytes % 4);

        payload_data = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);

        readback = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        get_random_bytes(payload_data, num_payloads * payload_size_bytes);

        /* Tests on XM must be after the XM header */
        if (param->mem_type == WMFW_ADSP2_XM)
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / payload_size_bytes;

        /* Add multiple payloads of one block each */
        for (i = 0; i < num_payloads; ++i) {
                cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                                param->mem_type,
                                                mem_offset_dsp_words + (i * payload_size_dsp_words),
                                                &payload_data[i * payload_size_bytes],
                                                payload_size_bytes);
        }

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
        reg_addr += cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv) * mem_offset_dsp_words;
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        num_payloads * payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, num_payloads * payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, num_payloads * payload_size_bytes);
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write several smallest possible payloads of the given memory type
 * in reverse address order
 */
static void wmfw_write_multiple_oneblock_payloads_reverse(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int mem_offset_dsp_words = 0;
        unsigned int payload_size_bytes, payload_size_dsp_words;
        const unsigned int num_payloads = param->num_blocks;
        int i;

        /* payloads must be a multiple of 4 bytes and a whole number of DSP registers */
        payload_size_dsp_words = 0;
        payload_size_bytes = 0;
        do {
                payload_size_dsp_words += cs_dsp_mock_reg_block_length_dsp_words(priv,
                                                                                 param->mem_type);
                payload_size_bytes += cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);
        } while (payload_size_bytes % 4);

        payload_data = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);

        readback = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        get_random_bytes(payload_data, num_payloads * payload_size_bytes);

        /* Tests on XM must be after the XM header */
        if (param->mem_type == WMFW_ADSP2_XM)
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / payload_size_bytes;

        /* Add multiple payloads of one block each */
        for (i = num_payloads - 1; i >= 0; --i) {
                cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                                param->mem_type,
                                                mem_offset_dsp_words + (i * payload_size_dsp_words),
                                                &payload_data[i * payload_size_bytes],
                                                payload_size_bytes);
        }

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
        reg_addr += cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv) * mem_offset_dsp_words;
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        num_payloads * payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, num_payloads * payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, num_payloads * payload_size_bytes);
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write multiple payloads of length param->num_blocks.
 * The payloads are not in address order and collectively do not patch
 * a contiguous block of memory.
 */
static void wmfw_write_multiple_payloads_sparse_unordered(struct kunit *test)
{
        static const unsigned int random_offsets[] = {
                11, 69, 59, 61, 32, 75, 4, 38, 70, 13, 79, 47, 46, 53, 18, 44,
                54, 35, 51, 21, 26, 45, 27, 41, 66, 2, 17, 56, 40, 9, 8, 20,
                29, 19, 63, 42, 12, 16, 43, 3, 5, 55, 52, 22
        };
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int mem_offset_dsp_words = 0;
        unsigned int payload_size_bytes, payload_size_dsp_words;
        const int num_payloads = ARRAY_SIZE(random_offsets);
        int i;

        payload_size_bytes = param->num_blocks *
                             cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);
        payload_size_dsp_words = param->num_blocks *
                                 cs_dsp_mock_reg_block_length_dsp_words(priv, param->mem_type);

        /* payloads must be a multiple of 4 bytes and a whole number of DSP registers */
        do {
                payload_size_dsp_words += cs_dsp_mock_reg_block_length_dsp_words(priv,
                                                                                 param->mem_type);
                payload_size_bytes += cs_dsp_mock_reg_block_length_bytes(priv, param->mem_type);
        } while (payload_size_bytes % 4);

        payload_data = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
        get_random_bytes(payload_data, payload_size_bytes);

        readback = kunit_kcalloc(test, num_payloads, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        /* Tests on XM must be after the XM header */
        if (param->mem_type == WMFW_ADSP2_XM)
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / payload_size_bytes;

        /* Add multiple payloads of one block each at "random" locations */
        for (i = 0; i < num_payloads; ++i) {
                unsigned int offset = random_offsets[i] * payload_size_dsp_words;

                cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                                param->mem_type,
                                                mem_offset_dsp_words + offset,
                                                &payload_data[i * payload_size_bytes],
                                                payload_size_bytes);
        }

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        for (i = 0; i < num_payloads; ++i) {
                unsigned int offset_num_regs = (random_offsets[i] * payload_size_bytes) /
                                                regmap_get_val_bytes(priv->dsp->regmap);
                reg_addr = cs_dsp_mock_base_addr_for_mem(priv, param->mem_type);
                reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
                reg_addr += cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv) * mem_offset_dsp_words;
                KUNIT_EXPECT_EQ(test,
                                regmap_raw_read(priv->dsp->regmap, reg_addr,
                                                &readback[i * payload_size_bytes],
                                                payload_size_bytes),
                                0);

                cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        }

        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/* Write the whole of PM in a single unpacked payload */
static void wmfw_write_all_unpacked_pm(struct kunit *test)
{
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int payload_size_bytes;

        payload_size_bytes = cs_dsp_mock_size_of_region(priv->dsp, WMFW_ADSP2_PM);
        payload_data = vmalloc(payload_size_bytes);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
        kunit_add_action_or_reset(priv->test, _vfree_wrapper, payload_data);

        readback = vmalloc(payload_size_bytes);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);
        kunit_add_action_or_reset(priv->test, _vfree_wrapper, readback);
        memset(readback, 0, payload_size_bytes);

        /* Add a single PM payload */
        get_random_bytes(payload_data, payload_size_bytes);
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        WMFW_ADSP2_PM, 0,
                                        payload_data, payload_size_bytes);

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_PM);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/* Write the whole of PM in a single packed payload */
static void wmfw_write_all_packed_pm(struct kunit *test)
{
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        unsigned int payload_size_bytes;

        payload_size_bytes = cs_dsp_mock_size_of_region(priv->dsp, WMFW_HALO_PM_PACKED);
        payload_data = vmalloc(payload_size_bytes);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
        kunit_add_action_or_reset(priv->test, _vfree_wrapper, payload_data);

        readback = vmalloc(payload_size_bytes);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);
        kunit_add_action_or_reset(priv->test, _vfree_wrapper, readback);
        memset(readback, 0, payload_size_bytes);

        /* Add a single PM payload */
        get_random_bytes(payload_data, payload_size_bytes);
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        WMFW_HALO_PM_PACKED, 0,
                                        payload_data, payload_size_bytes);

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_HALO_PM_PACKED);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write a series of payloads to various unpacked memory regions.
 * The payloads are of various lengths and offsets, driven by the
 * payload_defs table. The offset and length are both given as a
 * number of minimum-sized register blocks to keep the maths simpler.
 * (Where a minimum-sized register block is the smallest number of
 * registers that contain a whole number of DSP words.)
 */
static void wmfw_write_multiple_unpacked_mem(struct kunit *test)
{
        static const struct {
                int mem_type;
                unsigned int offset_num_blocks;
                unsigned int num_blocks;
        } payload_defs[] = {
                { WMFW_ADSP2_PM, 11, 60 },
                { WMFW_ADSP2_ZM, 69, 8 },
                { WMFW_ADSP2_YM, 32, 74 },
                { WMFW_ADSP2_XM, 70, 38 },
                { WMFW_ADSP2_PM, 84, 48 },
                { WMFW_ADSP2_XM, 46, 18 },
                { WMFW_ADSP2_PM, 0,  8 },
                { WMFW_ADSP2_YM, 0, 30 },
                { WMFW_ADSP2_PM, 160, 50 },
                { WMFW_ADSP2_ZM, 21, 26 },
        };
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int payload_size_bytes, offset_num_dsp_words;
        unsigned int reg_addr, offset_bytes, offset_num_regs;
        void **payload_data;
        void *readback;
        int i, ret;

        payload_data = kunit_kcalloc(test, ARRAY_SIZE(payload_defs), sizeof(*payload_data),
                                     GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);

        for (i = 0; i < ARRAY_SIZE(payload_defs); ++i) {
                payload_size_bytes = payload_defs[i].num_blocks *
                                     cs_dsp_mock_reg_block_length_bytes(priv,
                                                                        payload_defs[i].mem_type);

                payload_data[i] = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data[i]);
                get_random_bytes(payload_data[i], payload_size_bytes);

                offset_num_dsp_words = payload_defs[i].offset_num_blocks *
                                       cs_dsp_mock_reg_block_length_dsp_words(priv,
                                                                         payload_defs[i].mem_type);
                cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                                payload_defs[i].mem_type,
                                                offset_num_dsp_words,
                                                payload_data[i],
                                                payload_size_bytes);
        }

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        for (i = 0; i < ARRAY_SIZE(payload_defs); ++i) {
                payload_size_bytes = payload_defs[i].num_blocks *
                                     cs_dsp_mock_reg_block_length_bytes(priv,
                                                                        payload_defs[i].mem_type);

                readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

                offset_bytes = payload_defs[i].offset_num_blocks *
                               cs_dsp_mock_reg_block_length_bytes(priv, payload_defs[i].mem_type);
                offset_num_regs = offset_bytes / regmap_get_val_bytes(priv->dsp->regmap);
                reg_addr = cs_dsp_mock_base_addr_for_mem(priv, payload_defs[i].mem_type);
                reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
                ret = regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes);
                KUNIT_EXPECT_EQ_MSG(test, ret, 0, "%s @%u num:%u\n",
                                    cs_dsp_mem_region_name(payload_defs[i].mem_type),
                                    payload_defs[i].offset_num_blocks, payload_defs[i].num_blocks);
                KUNIT_EXPECT_MEMEQ_MSG(test, readback, payload_data[i], payload_size_bytes,
                                       "%s @%u num:%u\n",
                                       cs_dsp_mem_region_name(payload_defs[i].mem_type),
                                       payload_defs[i].offset_num_blocks,
                                       payload_defs[i].num_blocks);

                kunit_kfree(test, readback);

                cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        }

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write a series of payloads to various packed and unpacked memory regions.
 * The payloads are of various lengths and offsets, driven by the
 * payload_defs table. The offset and length are both given as a
 * number of minimum-sized register blocks to keep the maths simpler.
 * (Where a minimum-sized register block is the smallest number of
 * registers that contain a whole number of DSP words.)
 */
static void wmfw_write_multiple_packed_unpacked_mem(struct kunit *test)
{
        static const struct {
                int mem_type;
                unsigned int offset_num_blocks;
                unsigned int num_blocks;
        } payload_defs[] = {
                { WMFW_HALO_PM_PACKED,  11, 60 },
                { WMFW_ADSP2_YM,        69, 8 },
                { WMFW_HALO_YM_PACKED,  32, 74 },
                { WMFW_HALO_XM_PACKED,  70, 38 },
                { WMFW_HALO_PM_PACKED,  84, 48 },
                { WMFW_HALO_XM_PACKED,  46, 18 },
                { WMFW_HALO_PM_PACKED,  0,  8 },
                { WMFW_HALO_YM_PACKED,  0, 30 },
                { WMFW_HALO_PM_PACKED,  160, 50 },
                { WMFW_ADSP2_XM,        21, 26 },
        };
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int payload_size_bytes, offset_num_dsp_words;
        unsigned int reg_addr, offset_bytes, offset_num_regs;
        void **payload_data;
        void *readback;
        int i, ret;

        payload_data = kunit_kcalloc(test, ARRAY_SIZE(payload_defs), sizeof(*payload_data),
                                     GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);

        for (i = 0; i < ARRAY_SIZE(payload_defs); ++i) {
                payload_size_bytes = payload_defs[i].num_blocks *
                                     cs_dsp_mock_reg_block_length_bytes(priv,
                                                                        payload_defs[i].mem_type);

                payload_data[i] = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data[i]);
                get_random_bytes(payload_data[i], payload_size_bytes);

                offset_num_dsp_words = payload_defs[i].offset_num_blocks *
                                       cs_dsp_mock_reg_block_length_dsp_words(priv,
                                                                         payload_defs[i].mem_type);
                cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                                payload_defs[i].mem_type,
                                                offset_num_dsp_words,
                                                payload_data[i],
                                                payload_size_bytes);
        }

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        for (i = 0; i < ARRAY_SIZE(payload_defs); ++i) {
                payload_size_bytes = payload_defs[i].num_blocks *
                                     cs_dsp_mock_reg_block_length_bytes(priv,
                                                                        payload_defs[i].mem_type);

                readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

                offset_bytes = payload_defs[i].offset_num_blocks *
                               cs_dsp_mock_reg_block_length_bytes(priv, payload_defs[i].mem_type);
                offset_num_regs = offset_bytes / regmap_get_val_bytes(priv->dsp->regmap);
                reg_addr = cs_dsp_mock_base_addr_for_mem(priv, payload_defs[i].mem_type);
                reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
                ret = regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes);
                KUNIT_EXPECT_EQ_MSG(test, ret, 0, "%s @%u num:%u\n",
                                    cs_dsp_mem_region_name(payload_defs[i].mem_type),
                                    payload_defs[i].offset_num_blocks,
                                    payload_defs[i].num_blocks);
                KUNIT_EXPECT_MEMEQ_MSG(test, readback, payload_data[i], payload_size_bytes,
                                       "%s @%u num:%u\n",
                                       cs_dsp_mem_region_name(payload_defs[i].mem_type),
                                       payload_defs[i].offset_num_blocks,
                                       payload_defs[i].num_blocks);

                kunit_kfree(test, readback);

                cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, payload_size_bytes);
        }

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is one word longer than a packed block multiple,
 * using one packed payload followed by one unpacked word.
 */
static void wmfw_write_packed_1_unpacked_trailing(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int mem_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[1];
        unsigned int packed_payload_size_bytes, packed_payload_size_dsp_words;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);
        packed_payload_size_dsp_words = param->num_blocks * dsp_words_per_packed_block;

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM) {
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

                /* Round up to multiple of packed block length */
                mem_offset_dsp_words = roundup(mem_offset_dsp_words, dsp_words_per_packed_block);
        }

        /* Add a single packed payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type, mem_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);
        /*
         * Add payload of one unpacked word to DSP memory right after
         * the packed payload words.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked word was written correctly and drop
         * it from the regmap cache. The unpacked payload is offset within
         * unpacked register space by the number of DSP words that were
         * written in the packed payload.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        offset_num_regs += (packed_payload_size_dsp_words / dsp_words_per_unpacked_block) *
                           cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is two words longer than a packed block multiple,
 * using one packed payload followed by one payload of two unpacked words.
 */
static void wmfw_write_packed_2_unpacked_trailing(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int mem_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[2];
        unsigned int packed_payload_size_bytes, packed_payload_size_dsp_words;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);
        packed_payload_size_dsp_words = param->num_blocks * dsp_words_per_packed_block;

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM) {
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

                /* Round up to multiple of packed block length */
                mem_offset_dsp_words = roundup(mem_offset_dsp_words, dsp_words_per_packed_block);
        }

        /* Add a single packed payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type, mem_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);
        /*
         * Add payload of two unpacked words to DSP memory right after
         * the packed payload words.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache. The unpacked payload is offset
         * within unpacked register space by the number of DSP words
         * that were written in the packed payload.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        offset_num_regs += (packed_payload_size_dsp_words / dsp_words_per_unpacked_block) *
                           cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is three words longer than a packed block multiple,
 * using one packed payload followed by one payload of three unpacked words.
 */
static void wmfw_write_packed_3_unpacked_trailing(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int mem_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[3];
        unsigned int packed_payload_size_bytes, packed_payload_size_dsp_words;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);
        packed_payload_size_dsp_words = param->num_blocks * dsp_words_per_packed_block;

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM) {
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

                /* Round up to multiple of packed block length */
                mem_offset_dsp_words = roundup(mem_offset_dsp_words, dsp_words_per_packed_block);
        }

        /* Add a single packed payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type, mem_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);
        /*
         * Add payload of three unpacked words to DSP memory right after
         * the packed payload words.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache. The unpacked payload is offset
         * within unpacked register space by the number of DSP words
         * that were written in the packed payload.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        offset_num_regs += (packed_payload_size_dsp_words / dsp_words_per_unpacked_block) *
                           cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is two words longer than a packed block multiple,
 * using one packed payload followed by two payloads of one unpacked word each.
 */
static void wmfw_write_packed_2_single_unpacked_trailing(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int mem_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[2];
        unsigned int packed_payload_size_bytes, packed_payload_size_dsp_words;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);
        packed_payload_size_dsp_words = param->num_blocks * dsp_words_per_packed_block;

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM) {
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

                /* Round up to multiple of packed block length */
                mem_offset_dsp_words = roundup(mem_offset_dsp_words, dsp_words_per_packed_block);
        }

        /* Add a single packed payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type, mem_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);
        /*
         * Add two unpacked words to DSP memory right after the packed
         * payload words. Each unpacked word in its own payload.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words,
                                        &unpacked_payload_data[0],
                                        sizeof(unpacked_payload_data[0]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words + 1,
                                        &unpacked_payload_data[1],
                                        sizeof(unpacked_payload_data[1]));

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);

        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache. The unpacked words are offset
         * within unpacked register space by the number of DSP words
         * that were written in the packed payload.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        offset_num_regs += (packed_payload_size_dsp_words / dsp_words_per_unpacked_block) *
                           cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is three words longer than a packed block multiple,
 * using one packed payload followed by three payloads of one unpacked word each.
 */
static void wmfw_write_packed_3_single_unpacked_trailing(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int mem_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[3];
        unsigned int packed_payload_size_bytes, packed_payload_size_dsp_words;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                 cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);
        packed_payload_size_dsp_words = param->num_blocks * dsp_words_per_packed_block;

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM) {
                mem_offset_dsp_words += local->xm_header->blob_size_bytes / sizeof(u32);

                /* Round up to multiple of packed block length */
                mem_offset_dsp_words = roundup(mem_offset_dsp_words, dsp_words_per_packed_block);
        }

        /* Add a single packed payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type, mem_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);
        /*
         * Add three unpacked words to DSP memory right after the packed
         * payload words. Each unpacked word in its own payload.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words,
                                        &unpacked_payload_data[0],
                                        sizeof(unpacked_payload_data[0]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words + 1,
                                        &unpacked_payload_data[1],
                                        sizeof(unpacked_payload_data[1]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        mem_offset_dsp_words + packed_payload_size_dsp_words + 2,
                                        &unpacked_payload_data[2],
                                        sizeof(unpacked_payload_data[2]));

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache. The unpacked words are offset
         * within unpacked register space by the number of DSP words
         * that were written in the packed payload.
         */
        offset_num_regs = (mem_offset_dsp_words / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        offset_num_regs += (packed_payload_size_dsp_words / dsp_words_per_unpacked_block) *
                           cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is one word longer than a packed block multiple,
 * and does not start on a packed alignment. Use one unpacked word
 * followed by a packed payload.
 */
static void wmfw_write_packed_1_unpacked_leading(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int packed_payload_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[1];
        unsigned int packed_payload_size_bytes;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM)
                packed_payload_offset_dsp_words += local->xm_header->blob_size_bytes /
                                                   sizeof(u32);
        /*
         * Leave space for an unaligned word before the packed block and
         * round the packed block start to multiple of packed block length.
         */
        packed_payload_offset_dsp_words += 1;
        packed_payload_offset_dsp_words = roundup(packed_payload_offset_dsp_words,
                                                  dsp_words_per_packed_block);

        /* Add a single unpacked word right before the first word of packed data */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 1,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Add payload of packed data to the DSP memory after the unpacked word. */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type,
                                        packed_payload_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (packed_payload_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked word was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = ((packed_payload_offset_dsp_words - 1) / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is two words longer than a packed block multiple,
 * and does not start on a packed alignment. Use one payload of two unpacked
 * words followed by a packed payload.
 */
static void wmfw_write_packed_2_unpacked_leading(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int packed_payload_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[2];
        unsigned int packed_payload_size_bytes;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM)
                packed_payload_offset_dsp_words += local->xm_header->blob_size_bytes /
                                                   sizeof(u32);
        /*
         * Leave space for two unaligned words before the packed block and
         * round the packed block start to multiple of packed block length.
         */
        packed_payload_offset_dsp_words += 2;
        packed_payload_offset_dsp_words = roundup(packed_payload_offset_dsp_words,
                                                  dsp_words_per_packed_block);

        /*
         * Add two unpacked words as a single payload right before the
         * first word of packed data
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 2,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Add payload of packed data to the DSP memory after the unpacked words. */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type,
                                        packed_payload_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (packed_payload_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache.
         */
        offset_num_regs = ((packed_payload_offset_dsp_words - 2) / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is three words longer than a packed block multiple,
 * and does not start on a packed alignment. Use one payload of three unpacked
 * words followed by a packed payload.
 */
static void wmfw_write_packed_3_unpacked_leading(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int packed_payload_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[3];
        unsigned int packed_payload_size_bytes;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM)
                packed_payload_offset_dsp_words += local->xm_header->blob_size_bytes /
                                                   sizeof(u32);
        /*
         * Leave space for three unaligned words before the packed block and
         * round the packed block start to multiple of packed block length.
         */
        packed_payload_offset_dsp_words += 3;
        packed_payload_offset_dsp_words = roundup(packed_payload_offset_dsp_words,
                                                  dsp_words_per_packed_block);

        /*
         * Add three unpacked words as a single payload right before the
         * first word of packed data
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 3,
                                        unpacked_payload_data, sizeof(unpacked_payload_data));

        /* Add payload of packed data to the DSP memory after the unpacked words. */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type,
                                        packed_payload_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (packed_payload_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache.
         */
        offset_num_regs = ((packed_payload_offset_dsp_words - 3) / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is two words longer than a packed block multiple,
 * and does not start on a packed alignment. Use two payloads of one unpacked
 * word each, followed by a packed payload.
 */
static void wmfw_write_packed_2_single_unpacked_leading(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int packed_payload_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[2];
        unsigned int packed_payload_size_bytes;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM)
                packed_payload_offset_dsp_words += local->xm_header->blob_size_bytes /
                                                   sizeof(u32);
        /*
         * Leave space for two unaligned words before the packed block and
         * round the packed block start to multiple of packed block length.
         */
        packed_payload_offset_dsp_words += 2;
        packed_payload_offset_dsp_words = roundup(packed_payload_offset_dsp_words,
                                                  dsp_words_per_packed_block);

        /*
         * Add two unpacked words as two payloads each containing a single
         * unpacked word.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 2,
                                        &unpacked_payload_data[0],
                                        sizeof(unpacked_payload_data[0]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 1,
                                        &unpacked_payload_data[1],
                                        sizeof(unpacked_payload_data[1]));

        /* Add payload of packed data to the DSP memory after the unpacked words. */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type,
                                        packed_payload_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (packed_payload_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache.
         */
        offset_num_regs = ((packed_payload_offset_dsp_words - 2) / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/*
 * Write XM/YM data that is three words longer than a packed block multiple,
 * and does not start on a packed alignment. Use three payloads of one unpacked
 * word each, followed by a packed payload.
 */
static void wmfw_write_packed_3_single_unpacked_leading(struct kunit *test)
{
        const struct cs_dsp_wmfw_test_param *param = test->param_value;
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        int packed_mem_type = param->mem_type;
        int unpacked_mem_type = cs_dsp_mock_packed_to_unpacked_mem_type(param->mem_type);
        unsigned int dsp_words_per_packed_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, packed_mem_type);
        unsigned int dsp_words_per_unpacked_block =
                cs_dsp_mock_reg_block_length_dsp_words(priv, unpacked_mem_type);
        unsigned int packed_payload_offset_dsp_words = 0;
        struct firmware *wmfw;
        unsigned int reg_addr;
        void *packed_payload_data, *readback;
        u32 unpacked_payload_data[3];
        unsigned int packed_payload_size_bytes;
        unsigned int offset_num_regs;

        packed_payload_size_bytes = param->num_blocks *
                                    cs_dsp_mock_reg_block_length_bytes(priv, packed_mem_type);

        packed_payload_data = kunit_kmalloc(test, packed_payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, packed_payload_data);
        get_random_bytes(packed_payload_data, packed_payload_size_bytes);

        get_random_bytes(unpacked_payload_data, sizeof(unpacked_payload_data));

        readback = kunit_kzalloc(test, packed_payload_size_bytes, GFP_KERNEL);

        /* Tests on XM must be after the XM header */
        if (unpacked_mem_type == WMFW_ADSP2_XM)
                packed_payload_offset_dsp_words += local->xm_header->blob_size_bytes /
                                                   sizeof(u32);
        /*
         * Leave space for two unaligned words before the packed block and
         * round the packed block start to multiple of packed block length.
         */
        packed_payload_offset_dsp_words += 3;
        packed_payload_offset_dsp_words = roundup(packed_payload_offset_dsp_words,
                                                  dsp_words_per_packed_block);

        /*
         * Add three unpacked words as three payloads each containing a single
         * unpacked word.
         */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 3,
                                        &unpacked_payload_data[0],
                                        sizeof(unpacked_payload_data[0]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 2,
                                        &unpacked_payload_data[1],
                                        sizeof(unpacked_payload_data[1]));
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        unpacked_mem_type,
                                        packed_payload_offset_dsp_words - 1,
                                        &unpacked_payload_data[2],
                                        sizeof(unpacked_payload_data[2]));

        /* Add payload of packed data to the DSP memory after the unpacked words. */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        packed_mem_type,
                                        packed_payload_offset_dsp_words,
                                        packed_payload_data, packed_payload_size_bytes);

        /* Download the wmfw */
        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);
        KUNIT_EXPECT_EQ(test,
                        cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
                        0);
        /*
         * Check that the packed payload was written correctly and drop
         * it from the regmap cache.
         */
        offset_num_regs = (packed_payload_offset_dsp_words / dsp_words_per_packed_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, packed_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, packed_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        packed_payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, packed_payload_data, packed_payload_size_bytes);

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, packed_payload_size_bytes);

        /*
         * Check that the unpacked words were written correctly and drop
         * them from the regmap cache.
         */
        offset_num_regs = ((packed_payload_offset_dsp_words - 3) / dsp_words_per_unpacked_block) *
                          cs_dsp_mock_reg_block_length_registers(priv, unpacked_mem_type);
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, unpacked_mem_type);
        reg_addr += offset_num_regs * regmap_get_reg_stride(priv->dsp->regmap);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback,
                                        sizeof(unpacked_payload_data)),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, unpacked_payload_data, sizeof(unpacked_payload_data));

        cs_dsp_mock_regmap_drop_bytes(priv, reg_addr, sizeof(unpacked_payload_data));

        /* Drop expected writes and the cache should then be clean */
        cs_dsp_mock_xm_header_drop_from_regmap_cache(priv);
        KUNIT_EXPECT_FALSE(test, cs_dsp_mock_regmap_is_dirty(priv, true));
}

/* Load a wmfw containing multiple info blocks */
static void wmfw_load_with_info(struct kunit *test)
{
        struct cs_dsp_test *priv = test->priv;
        struct cs_dsp_test_local *local = priv->local;
        struct firmware *wmfw;
        unsigned int reg_addr;
        u8 *payload_data, *readback;
        char *infobuf;
        const unsigned int payload_size_bytes = 48;
        int ret;

        payload_data = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
        get_random_bytes(payload_data, payload_size_bytes);

        readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);

        /* Add a couple of info blocks at the start of the wmfw */
        cs_dsp_mock_wmfw_add_info(local->wmfw_builder, "This is a timestamp");
        cs_dsp_mock_wmfw_add_info(local->wmfw_builder, "This is some more info");

        /* Add a single payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        WMFW_ADSP2_YM, 0,
                                        payload_data, payload_size_bytes);

        /* Add a bigger info block then another small one*/
        infobuf = kunit_kzalloc(test, 512, GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, infobuf);

        for (; strlcat(infobuf, "Waffle{Blah}\n", 512) < 512;)
                ;

        cs_dsp_mock_wmfw_add_info(local->wmfw_builder, infobuf);
        cs_dsp_mock_wmfw_add_info(local->wmfw_builder, "Another block of info");

        /* Add another payload */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        WMFW_ADSP2_YM, 64,
                                        payload_data, payload_size_bytes);

        wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder);

        ret = cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc");
        KUNIT_EXPECT_EQ_MSG(test, ret, 0, "cs_dsp_power_up failed: %d\n", ret);

        /* Check first payload was written */
        reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_YM);
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);

        /* Check second payload was written */
        reg_addr += cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv) * 64;
        KUNIT_EXPECT_EQ(test,
                        regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
                        0);
        KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);
}

static int cs_dsp_wmfw_test_common_init(struct kunit *test, struct cs_dsp *dsp,
                                        int wmfw_version)
{
        struct cs_dsp_test *priv;
        struct cs_dsp_test_local *local;
        struct device *test_dev;
        int ret;

        priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
        if (!priv)
                return -ENOMEM;

        local = kunit_kzalloc(test, sizeof(struct cs_dsp_test_local), GFP_KERNEL);
        if (!local)
                return -ENOMEM;

        priv->test = test;
        priv->dsp = dsp;
        test->priv = priv;
        priv->local = local;
        priv->local->wmfw_version = wmfw_version;

        /* Create dummy struct device */
        test_dev = kunit_device_register(test, "cs_dsp_test_drv");
        if (IS_ERR(test_dev))
                return PTR_ERR(test_dev);

        dsp->dev = get_device(test_dev);
        if (!dsp->dev)
                return -ENODEV;

        ret = kunit_add_action_or_reset(test, _put_device_wrapper, dsp->dev);
        if (ret)
                return ret;

        dev_set_drvdata(dsp->dev, priv);

        /* Allocate regmap */
        ret = cs_dsp_mock_regmap_init(priv);
        if (ret)
                return ret;

        /*
         * There must always be a XM header with at least 1 algorithm, so create
         * a dummy one that tests can use and extract it to a data payload.
         */
        local->xm_header = cs_dsp_create_mock_xm_header(priv,
                                                        cs_dsp_wmfw_test_mock_algs,
                                                        ARRAY_SIZE(cs_dsp_wmfw_test_mock_algs));
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->xm_header);

        local->wmfw_builder = cs_dsp_mock_wmfw_init(priv, priv->local->wmfw_version);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->wmfw_builder);

        /* Add dummy XM header payload to wmfw */
        cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
                                        WMFW_ADSP2_XM, 0,
                                        local->xm_header->blob_data,
                                        local->xm_header->blob_size_bytes);

        /* Init cs_dsp */
        dsp->client_ops = kunit_kzalloc(test, sizeof(*dsp->client_ops), GFP_KERNEL);
        KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp->client_ops);

        switch (dsp->type) {
        case WMFW_ADSP2:
                ret = cs_dsp_adsp2_init(dsp);
                break;
        case WMFW_HALO:
                ret = cs_dsp_halo_init(dsp);
                break;
        default:
                KUNIT_FAIL(test, "Untested DSP type %d\n", dsp->type);
                return -EINVAL;
        }

        if (ret)
                return ret;

        /* Automatically call cs_dsp_remove() when test case ends */
        ret = kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp);
        if (ret)
                return ret;

        /*
         * The large number of test cases will cause an unusually large amount
         * of dev_info() messages from cs_dsp, so suppress these.
         */
        cs_dsp_suppress_info_messages = true;

        return 0;
}

static void cs_dsp_wmfw_test_exit(struct kunit *test)
{
        cs_dsp_suppress_info_messages = false;
}

static int cs_dsp_wmfw_test_halo_init(struct kunit *test)
{
        struct cs_dsp *dsp;

        /* Fill in cs_dsp and initialize */
        dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
        if (!dsp)
                return -ENOMEM;

        dsp->num = 1;
        dsp->type = WMFW_HALO;
        dsp->mem = cs_dsp_mock_halo_dsp1_regions;
        dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_halo_dsp1_region_sizes);
        dsp->base = cs_dsp_mock_halo_core_base;
        dsp->base_sysinfo = cs_dsp_mock_halo_sysinfo_base;

        return cs_dsp_wmfw_test_common_init(test, dsp, 3);
}

static int cs_dsp_wmfw_test_adsp2_32bit_init(struct kunit *test, int wmfw_ver)
{
        struct cs_dsp *dsp;

        /* Fill in cs_dsp and initialize */
        dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
        if (!dsp)
                return -ENOMEM;

        dsp->num = 1;
        dsp->type = WMFW_ADSP2;
        dsp->rev = 1;
        dsp->mem = cs_dsp_mock_adsp2_32bit_dsp1_regions;
        dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_32bit_dsp1_region_sizes);
        dsp->base = cs_dsp_mock_adsp2_32bit_sysbase;

        return cs_dsp_wmfw_test_common_init(test, dsp, wmfw_ver);
}

static int cs_dsp_wmfw_test_adsp2_32bit_wmfw0_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_32bit_init(test, 0);
}

static int cs_dsp_wmfw_test_adsp2_32bit_wmfw1_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_32bit_init(test, 1);
}

static int cs_dsp_wmfw_test_adsp2_32bit_wmfw2_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_32bit_init(test, 2);
}

static int cs_dsp_wmfw_test_adsp2_16bit_init(struct kunit *test, int wmfw_ver)
{
        struct cs_dsp *dsp;

        /* Fill in cs_dsp and initialize */
        dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
        if (!dsp)
                return -ENOMEM;

        dsp->num = 1;
        dsp->type = WMFW_ADSP2;
        dsp->rev = 0;
        dsp->mem = cs_dsp_mock_adsp2_16bit_dsp1_regions;
        dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_16bit_dsp1_region_sizes);
        dsp->base = cs_dsp_mock_adsp2_16bit_sysbase;

        return cs_dsp_wmfw_test_common_init(test, dsp, wmfw_ver);
}

static int cs_dsp_wmfw_test_adsp2_16bit_wmfw0_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_16bit_init(test, 0);
}

static int cs_dsp_wmfw_test_adsp2_16bit_wmfw1_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_16bit_init(test, 1);
}

static int cs_dsp_wmfw_test_adsp2_16bit_wmfw2_init(struct kunit *test)
{
        return cs_dsp_wmfw_test_adsp2_16bit_init(test, 2);
}

static void cs_dsp_mem_param_desc(const struct cs_dsp_wmfw_test_param *param, char *desc)
{
        snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s num_blocks:%u",
                 cs_dsp_mem_region_name(param->mem_type),
                 param->num_blocks);
}

static const struct cs_dsp_wmfw_test_param adsp2_all_num_blocks_param_cases[] = {
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_PM, .num_blocks = 16 },

        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 16 },

        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 16 },

        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_ZM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 16 },
};

KUNIT_ARRAY_PARAM(adsp2_all_num_blocks,
                  adsp2_all_num_blocks_param_cases,
                  cs_dsp_mem_param_desc);

static const struct cs_dsp_wmfw_test_param halo_all_num_blocks_param_cases[] = {
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 1 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 2 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 3 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 4 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 5 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 6 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 12 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 13 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 14 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 15 },
        { .mem_type = WMFW_HALO_PM_PACKED, .num_blocks = 16 },

        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 1 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 2 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 3 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 4 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 5 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 6 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 12 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 13 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 14 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 15 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 16 },

        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 1 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 2 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 3 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 4 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 5 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 6 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 12 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 13 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 14 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 15 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 16 },

        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_XM, .num_blocks = 16 },

        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 1 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 2 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 3 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 4 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 5 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 6 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 12 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 13 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 14 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 15 },
        { .mem_type = WMFW_ADSP2_YM, .num_blocks = 16 },
};

KUNIT_ARRAY_PARAM(halo_all_num_blocks,
                  halo_all_num_blocks_param_cases,
                  cs_dsp_mem_param_desc);

static const struct cs_dsp_wmfw_test_param packed_xy_num_blocks_param_cases[] = {
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 1 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 2 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 3 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 4 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 5 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 6 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 12 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 13 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 14 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 15 },
        { .mem_type = WMFW_HALO_XM_PACKED, .num_blocks = 16 },

        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 1 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 2 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 3 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 4 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 5 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 6 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 12 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 13 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 14 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 15 },
        { .mem_type = WMFW_HALO_YM_PACKED, .num_blocks = 16 },
};

KUNIT_ARRAY_PARAM(packed_xy_num_blocks,
                  packed_xy_num_blocks_param_cases,
                  cs_dsp_mem_param_desc);

static struct kunit_case cs_dsp_wmfw_test_cases_halo[] = {
        KUNIT_CASE(wmfw_write_xm_header_unpacked),

        KUNIT_CASE_PARAM(wmfw_write_one_payload,
                         halo_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_oneblock_payloads,
                         halo_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_oneblock_payloads_reverse,
                         halo_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_payloads_sparse_unordered,
                         halo_all_num_blocks_gen_params),

        KUNIT_CASE(wmfw_write_all_packed_pm),
        KUNIT_CASE(wmfw_write_multiple_packed_unpacked_mem),

        KUNIT_CASE_PARAM(wmfw_write_packed_1_unpacked_trailing,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_2_unpacked_trailing,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_3_unpacked_trailing,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_2_single_unpacked_trailing,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_3_single_unpacked_trailing,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_1_unpacked_leading,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_2_unpacked_leading,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_3_unpacked_leading,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_2_single_unpacked_leading,
                         packed_xy_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_packed_3_single_unpacked_leading,
                         packed_xy_num_blocks_gen_params),

        KUNIT_CASE(wmfw_load_with_info),

        { } /* terminator */
};

static struct kunit_case cs_dsp_wmfw_test_cases_adsp2[] = {
        KUNIT_CASE(wmfw_write_xm_header_unpacked),
        KUNIT_CASE_PARAM(wmfw_write_one_payload,
                         adsp2_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_oneblock_payloads,
                         adsp2_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_oneblock_payloads_reverse,
                         adsp2_all_num_blocks_gen_params),
        KUNIT_CASE_PARAM(wmfw_write_multiple_payloads_sparse_unordered,
                         adsp2_all_num_blocks_gen_params),

        KUNIT_CASE(wmfw_write_all_unpacked_pm),
        KUNIT_CASE(wmfw_write_multiple_unpacked_mem),

        KUNIT_CASE(wmfw_load_with_info),

        { } /* terminator */
};

static struct kunit_suite cs_dsp_wmfw_test_halo = {
        .name = "cs_dsp_wmfwV3_halo",
        .init = cs_dsp_wmfw_test_halo_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_halo,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw0 = {
        .name = "cs_dsp_wmfwV0_adsp2_32bit",
        .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw0_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw1 = {
        .name = "cs_dsp_wmfwV1_adsp2_32bit",
        .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw1_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_32bit_wmfw2 = {
        .name = "cs_dsp_wmfwV2_adsp2_32bit",
        .init = cs_dsp_wmfw_test_adsp2_32bit_wmfw2_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw0 = {
        .name = "cs_dsp_wmfwV0_adsp2_16bit",
        .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw0_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw1 = {
        .name = "cs_dsp_wmfwV1_adsp2_16bit",
        .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw1_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

static struct kunit_suite cs_dsp_wmfw_test_adsp2_16bit_wmfw2 = {
        .name = "cs_dsp_wmfwV2_adsp2_16bit",
        .init = cs_dsp_wmfw_test_adsp2_16bit_wmfw2_init,
        .exit = cs_dsp_wmfw_test_exit,
        .test_cases = cs_dsp_wmfw_test_cases_adsp2,
};

kunit_test_suites(&cs_dsp_wmfw_test_halo,
                  &cs_dsp_wmfw_test_adsp2_32bit_wmfw0,
                  &cs_dsp_wmfw_test_adsp2_32bit_wmfw1,
                  &cs_dsp_wmfw_test_adsp2_32bit_wmfw2,
                  &cs_dsp_wmfw_test_adsp2_16bit_wmfw0,
                  &cs_dsp_wmfw_test_adsp2_16bit_wmfw1,
                  &cs_dsp_wmfw_test_adsp2_16bit_wmfw2);