| // 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 <kunit/test-bug.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> | |
| #define ADSP2_LOCK_REGION_CTRL 0x7A | |
| #define ADSP2_WDT_TIMEOUT_STS_MASK 0x2000 | |
| KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *) | |
| KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *) | |
| struct cs_dsp_test_local { | |
| struct cs_dsp_mock_wmfw_builder *wmfw_builder; | |
| int num_control_add; | |
| int num_control_remove; | |
| int num_pre_run; | |
| int num_post_run; | |
| int num_pre_stop; | |
| int num_post_stop; | |
| int num_watchdog_expired; | |
| struct cs_dsp_coeff_ctl *passed_ctl[16]; | |
| struct cs_dsp *passed_dsp; | |
| }; | |
| struct cs_dsp_callbacks_test_param { | |
| const struct cs_dsp_client_ops *ops; | |
| const char *case_name; | |
| }; | |
| static const struct cs_dsp_mock_alg_def cs_dsp_callbacks_test_mock_algs[] = { | |
| { | |
| .id = 0xfafa, | |
| .ver = 0x100000, | |
| .xm_size_words = 164, | |
| .ym_size_words = 164, | |
| .zm_size_words = 164, | |
| }, | |
| }; | |
| static const struct cs_dsp_mock_coeff_def mock_coeff_template = { | |
| .shortname = "Dummy Coeff", | |
| .type = WMFW_CTL_TYPE_BYTES, | |
| .mem_type = WMFW_ADSP2_YM, | |
| .flags = WMFW_CTL_FLAG_VOLATILE, | |
| .length_bytes = 4, | |
| }; | |
| static int cs_dsp_test_control_add_callback(struct cs_dsp_coeff_ctl *ctl) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_ctl[local->num_control_add] = ctl; | |
| local->num_control_add++; | |
| return 0; | |
| } | |
| static void cs_dsp_test_control_remove_callback(struct cs_dsp_coeff_ctl *ctl) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_ctl[local->num_control_remove] = ctl; | |
| local->num_control_remove++; | |
| } | |
| static int cs_dsp_test_pre_run_callback(struct cs_dsp *dsp) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_dsp = dsp; | |
| local->num_pre_run++; | |
| return 0; | |
| } | |
| static int cs_dsp_test_post_run_callback(struct cs_dsp *dsp) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_dsp = dsp; | |
| local->num_post_run++; | |
| return 0; | |
| } | |
| static void cs_dsp_test_pre_stop_callback(struct cs_dsp *dsp) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_dsp = dsp; | |
| local->num_pre_stop++; | |
| } | |
| static void cs_dsp_test_post_stop_callback(struct cs_dsp *dsp) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_dsp = dsp; | |
| local->num_post_stop++; | |
| } | |
| static void cs_dsp_test_watchdog_expired_callback(struct cs_dsp *dsp) | |
| { | |
| struct kunit *test = kunit_get_current_test(); | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| local->passed_dsp = dsp; | |
| local->num_watchdog_expired++; | |
| } | |
| static const struct cs_dsp_client_ops cs_dsp_callback_test_client_ops = { | |
| .control_add = cs_dsp_test_control_add_callback, | |
| .control_remove = cs_dsp_test_control_remove_callback, | |
| .pre_run = cs_dsp_test_pre_run_callback, | |
| .post_run = cs_dsp_test_post_run_callback, | |
| .pre_stop = cs_dsp_test_pre_stop_callback, | |
| .post_stop = cs_dsp_test_post_stop_callback, | |
| .watchdog_expired = cs_dsp_test_watchdog_expired_callback, | |
| }; | |
| static const struct cs_dsp_client_ops cs_dsp_callback_test_empty_client_ops = { | |
| /* No entries */ | |
| }; | |
| static void cs_dsp_test_run_stop_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct firmware *wmfw; | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_run, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_post_run, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_stop, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_post_stop, 0); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| local->passed_dsp = NULL; | |
| cs_dsp_stop(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_run, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_post_run, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_stop, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_post_stop, 1); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| local->passed_dsp = NULL; | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_run, 2); | |
| KUNIT_EXPECT_EQ(test, local->num_post_run, 2); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_stop, 1); | |
| KUNIT_EXPECT_EQ(test, local->num_post_stop, 1); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| local->passed_dsp = NULL; | |
| cs_dsp_stop(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_run, 2); | |
| KUNIT_EXPECT_EQ(test, local->num_post_run, 2); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_stop, 2); | |
| KUNIT_EXPECT_EQ(test, local->num_post_stop, 2); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| local->passed_dsp = NULL; | |
| } | |
| static void cs_dsp_test_ctl_v1_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct cs_dsp_mock_coeff_def def = mock_coeff_template; | |
| struct cs_dsp_coeff_ctl *ctl; | |
| struct firmware *wmfw; | |
| int i; | |
| /* Add a control for each memory */ | |
| cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder, | |
| cs_dsp_callbacks_test_mock_algs[0].id, | |
| "dummyalg", NULL); | |
| def.shortname = "zm"; | |
| def.mem_type = WMFW_ADSP2_ZM; | |
| cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def); | |
| def.shortname = "ym"; | |
| def.mem_type = WMFW_ADSP2_YM; | |
| cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def); | |
| def.shortname = "xm"; | |
| def.mem_type = WMFW_ADSP2_XM; | |
| cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def); | |
| cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder); | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| /* There should have been an add callback for each control */ | |
| KUNIT_EXPECT_EQ(test, list_count_nodes(&priv->dsp->ctl_list), 3); | |
| KUNIT_EXPECT_EQ(test, local->num_control_add, 3); | |
| KUNIT_EXPECT_EQ(test, local->num_control_remove, 0); | |
| i = 0; | |
| list_for_each_entry_reverse(ctl, &priv->dsp->ctl_list, list) | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_ctl[i++], ctl); | |
| /* | |
| * Call cs_dsp_remove() and there should be a remove callback | |
| * for each control | |
| */ | |
| memset(local->passed_ctl, 0, sizeof(local->passed_ctl)); | |
| cs_dsp_remove(priv->dsp); | |
| /* Prevent double cleanup */ | |
| kunit_remove_action(priv->test, _cs_dsp_remove_wrapper, priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_control_add, 3); | |
| KUNIT_EXPECT_EQ(test, local->num_control_remove, 3); | |
| i = 0; | |
| list_for_each_entry_reverse(ctl, &priv->dsp->ctl_list, list) | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_ctl[i++], ctl); | |
| } | |
| static void cs_dsp_test_ctl_v2_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct cs_dsp_mock_coeff_def def = mock_coeff_template; | |
| struct cs_dsp_coeff_ctl *ctl; | |
| struct firmware *wmfw; | |
| char name[2] = { }; | |
| int i; | |
| /* Add some controls */ | |
| def.shortname = name; | |
| cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder, | |
| cs_dsp_callbacks_test_mock_algs[0].id, | |
| "dummyalg", NULL); | |
| for (i = 0; i < ARRAY_SIZE(local->passed_ctl); ++i) { | |
| name[0] = 'A' + i; | |
| def.offset_dsp_words = i; | |
| cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def); | |
| } | |
| cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder); | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| /* There should have been an add callback for each control */ | |
| KUNIT_EXPECT_EQ(test, list_count_nodes(&priv->dsp->ctl_list), | |
| ARRAY_SIZE(local->passed_ctl)); | |
| KUNIT_EXPECT_EQ(test, local->num_control_add, ARRAY_SIZE(local->passed_ctl)); | |
| KUNIT_EXPECT_EQ(test, local->num_control_remove, 0); | |
| i = 0; | |
| list_for_each_entry_reverse(ctl, &priv->dsp->ctl_list, list) | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_ctl[i++], ctl); | |
| /* | |
| * Call cs_dsp_remove() and there should be a remove callback | |
| * for each control | |
| */ | |
| memset(local->passed_ctl, 0, sizeof(local->passed_ctl)); | |
| cs_dsp_remove(priv->dsp); | |
| /* Prevent double cleanup */ | |
| kunit_remove_action(priv->test, _cs_dsp_remove_wrapper, priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_control_add, ARRAY_SIZE(local->passed_ctl)); | |
| KUNIT_EXPECT_EQ(test, local->num_control_remove, ARRAY_SIZE(local->passed_ctl)); | |
| i = 0; | |
| list_for_each_entry_reverse(ctl, &priv->dsp->ctl_list, list) | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_ctl[i++], ctl); | |
| } | |
| static void cs_dsp_test_no_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct cs_dsp_mock_coeff_def def = mock_coeff_template; | |
| struct firmware *wmfw; | |
| /* Add a controls */ | |
| def.shortname = "A"; | |
| cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder, | |
| cs_dsp_callbacks_test_mock_algs[0].id, | |
| "dummyalg", NULL); | |
| cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &def); | |
| cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder); | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| /* Run a sequence of ops that would invoke callbacks */ | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| cs_dsp_stop(priv->dsp); | |
| cs_dsp_remove(priv->dsp); | |
| /* Prevent double cleanup */ | |
| kunit_remove_action(priv->test, _cs_dsp_remove_wrapper, priv->dsp); | |
| /* Something went very wrong if any of our callbacks were called */ | |
| KUNIT_EXPECT_EQ(test, local->num_control_add, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_control_remove, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_run, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_post_run, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_pre_stop, 0); | |
| KUNIT_EXPECT_EQ(test, local->num_post_stop, 0); | |
| } | |
| static void cs_dsp_test_adsp2v2_watchdog_callback(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct firmware *wmfw; | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| /* Set the watchdog timeout bit */ | |
| regmap_write(priv->dsp->regmap, priv->dsp->base + ADSP2_LOCK_REGION_CTRL, | |
| ADSP2_WDT_TIMEOUT_STS_MASK); | |
| /* Notify an interrupt and the watchdog callback should be called */ | |
| cs_dsp_adsp2_bus_error(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_watchdog_expired, 1); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| } | |
| static void cs_dsp_test_adsp2v2_watchdog_no_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct firmware *wmfw; | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| /* Set the watchdog timeout bit */ | |
| regmap_write(priv->dsp->regmap, priv->dsp->base + ADSP2_LOCK_REGION_CTRL, | |
| ADSP2_WDT_TIMEOUT_STS_MASK); | |
| /* Notify an interrupt, which will look for a watchdog callback */ | |
| cs_dsp_adsp2_bus_error(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_watchdog_expired, 0); | |
| } | |
| static void cs_dsp_test_halo_watchdog_callback(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct firmware *wmfw; | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| /* Notify an interrupt and the watchdog callback should be called */ | |
| cs_dsp_halo_wdt_expire(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_watchdog_expired, 1); | |
| KUNIT_EXPECT_PTR_EQ(test, local->passed_dsp, priv->dsp); | |
| } | |
| static void cs_dsp_test_halo_watchdog_no_callbacks(struct kunit *test) | |
| { | |
| struct cs_dsp_test *priv = test->priv; | |
| struct cs_dsp_test_local *local = priv->local; | |
| struct firmware *wmfw; | |
| wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder); | |
| KUNIT_EXPECT_EQ(test, | |
| cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"), | |
| 0); | |
| KUNIT_EXPECT_EQ(test, cs_dsp_run(priv->dsp), 0); | |
| /* Notify an interrupt, which will look for a watchdog callback */ | |
| cs_dsp_halo_wdt_expire(priv->dsp); | |
| KUNIT_EXPECT_EQ(test, local->num_watchdog_expired, 0); | |
| } | |
| static int cs_dsp_callbacks_test_common_init(struct kunit *test, struct cs_dsp *dsp, | |
| int wmfw_version) | |
| { | |
| const struct cs_dsp_callbacks_test_param *param = test->param_value; | |
| struct cs_dsp_test *priv; | |
| struct cs_dsp_test_local *local; | |
| struct device *test_dev; | |
| struct cs_dsp_mock_xm_header *xm_header; | |
| 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; | |
| /* 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 and pre-populate XM so the wmfw doesn't | |
| * have to contain an XM blob. | |
| */ | |
| xm_header = cs_dsp_create_mock_xm_header(priv, | |
| cs_dsp_callbacks_test_mock_algs, | |
| ARRAY_SIZE(cs_dsp_callbacks_test_mock_algs)); | |
| KUNIT_ASSERT_NOT_ERR_OR_NULL(test, xm_header); | |
| cs_dsp_mock_xm_header_write_to_regmap(xm_header); | |
| local->wmfw_builder = cs_dsp_mock_wmfw_init(priv, 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, | |
| xm_header->blob_data, | |
| xm_header->blob_size_bytes); | |
| /* Init cs_dsp */ | |
| dsp->client_ops = param->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 */ | |
| return kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp); | |
| } | |
| static int cs_dsp_callbacks_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_callbacks_test_common_init(test, dsp, 3); | |
| } | |
| static int cs_dsp_callbacks_test_adsp2_32bit_init(struct kunit *test, int rev) | |
| { | |
| 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 = rev; | |
| 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_callbacks_test_common_init(test, dsp, 2); | |
| } | |
| static int cs_dsp_callbacks_test_adsp2v2_32bit_init(struct kunit *test) | |
| { | |
| return cs_dsp_callbacks_test_adsp2_32bit_init(test, 2); | |
| } | |
| static int cs_dsp_callbacks_test_adsp2v1_32bit_init(struct kunit *test) | |
| { | |
| return cs_dsp_callbacks_test_adsp2_32bit_init(test, 1); | |
| } | |
| static int cs_dsp_callbacks_test_adsp2_16bit_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_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_callbacks_test_common_init(test, dsp, 1); | |
| } | |
| static void cs_dsp_callbacks_param_desc(const struct cs_dsp_callbacks_test_param *param, | |
| char *desc) | |
| { | |
| snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s", param->case_name); | |
| } | |
| /* Parameterize on different client callback ops tables */ | |
| static const struct cs_dsp_callbacks_test_param cs_dsp_callbacks_ops_cases[] = { | |
| { .ops = &cs_dsp_callback_test_client_ops, .case_name = "all ops" }, | |
| }; | |
| KUNIT_ARRAY_PARAM(cs_dsp_callbacks_ops, | |
| cs_dsp_callbacks_ops_cases, | |
| cs_dsp_callbacks_param_desc); | |
| static const struct cs_dsp_callbacks_test_param cs_dsp_no_callbacks_cases[] = { | |
| { .ops = &cs_dsp_callback_test_empty_client_ops, .case_name = "empty ops" }, | |
| { .ops = NULL, .case_name = "NULL ops" }, | |
| }; | |
| KUNIT_ARRAY_PARAM(cs_dsp_no_callbacks, | |
| cs_dsp_no_callbacks_cases, | |
| cs_dsp_callbacks_param_desc); | |
| static struct kunit_case cs_dsp_callbacks_adsp2_wmfwv1_test_cases[] = { | |
| KUNIT_CASE_PARAM(cs_dsp_test_run_stop_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_ctl_v1_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_no_callbacks, cs_dsp_no_callbacks_gen_params), | |
| { } /* terminator */ | |
| }; | |
| static struct kunit_case cs_dsp_callbacks_adsp2_wmfwv2_test_cases[] = { | |
| KUNIT_CASE_PARAM(cs_dsp_test_run_stop_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_ctl_v2_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_no_callbacks, cs_dsp_no_callbacks_gen_params), | |
| { } /* terminator */ | |
| }; | |
| static struct kunit_case cs_dsp_callbacks_halo_test_cases[] = { | |
| KUNIT_CASE_PARAM(cs_dsp_test_run_stop_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_ctl_v2_callbacks, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_no_callbacks, cs_dsp_no_callbacks_gen_params), | |
| { } /* terminator */ | |
| }; | |
| static struct kunit_case cs_dsp_watchdog_adsp2v2_test_cases[] = { | |
| KUNIT_CASE_PARAM(cs_dsp_test_adsp2v2_watchdog_callback, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_adsp2v2_watchdog_no_callbacks, cs_dsp_no_callbacks_gen_params), | |
| { } /* terminator */ | |
| }; | |
| static struct kunit_case cs_dsp_watchdog_halo_test_cases[] = { | |
| KUNIT_CASE_PARAM(cs_dsp_test_halo_watchdog_callback, cs_dsp_callbacks_ops_gen_params), | |
| KUNIT_CASE_PARAM(cs_dsp_test_halo_watchdog_no_callbacks, cs_dsp_no_callbacks_gen_params), | |
| { } /* terminator */ | |
| }; | |
| static struct kunit_suite cs_dsp_callbacks_test_halo = { | |
| .name = "cs_dsp_callbacks_halo", | |
| .init = cs_dsp_callbacks_test_halo_init, | |
| .test_cases = cs_dsp_callbacks_halo_test_cases, | |
| }; | |
| static struct kunit_suite cs_dsp_callbacks_test_adsp2v2_32bit = { | |
| .name = "cs_dsp_callbacks_adsp2v2_32bit_wmfwv2", | |
| .init = cs_dsp_callbacks_test_adsp2v2_32bit_init, | |
| .test_cases = cs_dsp_callbacks_adsp2_wmfwv2_test_cases, | |
| }; | |
| static struct kunit_suite cs_dsp_callbacks_test_adsp2v1_32bit = { | |
| .name = "cs_dsp_callbacks_adsp2v1_32bit_wmfwv2", | |
| .init = cs_dsp_callbacks_test_adsp2v1_32bit_init, | |
| .test_cases = cs_dsp_callbacks_adsp2_wmfwv2_test_cases, | |
| }; | |
| static struct kunit_suite cs_dsp_callbacks_test_adsp2_16bit = { | |
| .name = "cs_dsp_callbacks_adsp2_16bit_wmfwv1", | |
| .init = cs_dsp_callbacks_test_adsp2_16bit_init, | |
| .test_cases = cs_dsp_callbacks_adsp2_wmfwv1_test_cases, | |
| }; | |
| static struct kunit_suite cs_dsp_watchdog_test_adsp2v2_32bit = { | |
| .name = "cs_dsp_watchdog_adsp2v2_32bit", | |
| .init = cs_dsp_callbacks_test_adsp2v2_32bit_init, | |
| .test_cases = cs_dsp_watchdog_adsp2v2_test_cases, | |
| }; | |
| static struct kunit_suite cs_dsp_watchdog_test_halo_32bit = { | |
| .name = "cs_dsp_watchdog_halo", | |
| .init = cs_dsp_callbacks_test_halo_init, | |
| .test_cases = cs_dsp_watchdog_halo_test_cases, | |
| }; | |
| kunit_test_suites(&cs_dsp_callbacks_test_halo, | |
| &cs_dsp_callbacks_test_adsp2v2_32bit, | |
| &cs_dsp_callbacks_test_adsp2v1_32bit, | |
| &cs_dsp_callbacks_test_adsp2_16bit, | |
| &cs_dsp_watchdog_test_adsp2v2_32bit, | |
| &cs_dsp_watchdog_test_halo_32bit); |