1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // KUnit tests for cs_dsp. 4 // 5 // Copyright (C) 2024 Cirrus Logic, Inc. and 6 // Cirrus Logic International Semiconductor Ltd. 7 // 8 9 #include <kunit/device.h> 10 #include <kunit/resource.h> 11 #include <kunit/test.h> 12 #include <linux/build_bug.h> 13 #include <linux/firmware/cirrus/cs_dsp.h> 14 #include <linux/firmware/cirrus/cs_dsp_test_utils.h> 15 #include <linux/firmware/cirrus/wmfw.h> 16 #include <linux/random.h> 17 #include <linux/regmap.h> 18 #include <linux/string.h> 19 #include <linux/vmalloc.h> 20 21 KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *); 22 KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *); 23 24 struct cs_dsp_test_local { 25 struct cs_dsp_mock_bin_builder *bin_builder; 26 struct cs_dsp_mock_xm_header *xm_header; 27 struct cs_dsp_mock_wmfw_builder *wmfw_builder; 28 struct firmware *wmfw; 29 int wmfw_version; 30 }; 31 32 struct cs_dsp_bin_test_param { 33 int block_type; 34 }; 35 36 static const struct cs_dsp_mock_alg_def cs_dsp_bin_err_test_mock_algs[] = { 37 { 38 .id = 0xfafa, 39 .ver = 0x100000, 40 .xm_size_words = 164, 41 .ym_size_words = 164, 42 .zm_size_words = 164, 43 }, 44 }; 45 46 /* Load a bin containing unknown blocks. They should be skipped. */ 47 static void bin_load_with_unknown_blocks(struct kunit *test) 48 { 49 struct cs_dsp_test *priv = test->priv; 50 struct cs_dsp_test_local *local = priv->local; 51 struct firmware *bin; 52 unsigned int reg_addr; 53 u8 *payload_data, *readback; 54 u8 random_data[8]; 55 const unsigned int payload_size_bytes = 64; 56 57 payload_data = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL); 58 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data); 59 get_random_bytes(payload_data, payload_size_bytes); 60 61 readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL); 62 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback); 63 64 /* Add some unknown blocks at the start of the bin */ 65 get_random_bytes(random_data, sizeof(random_data)); 66 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 67 cs_dsp_bin_err_test_mock_algs[0].id, 68 cs_dsp_bin_err_test_mock_algs[0].ver, 69 0xf5, 0, 70 random_data, sizeof(random_data)); 71 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 72 cs_dsp_bin_err_test_mock_algs[0].id, 73 cs_dsp_bin_err_test_mock_algs[0].ver, 74 0xf500, 0, 75 random_data, sizeof(random_data)); 76 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 77 cs_dsp_bin_err_test_mock_algs[0].id, 78 cs_dsp_bin_err_test_mock_algs[0].ver, 79 0xc300, 0, 80 random_data, sizeof(random_data)); 81 82 /* Add a single payload to be written to DSP memory */ 83 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 84 cs_dsp_bin_err_test_mock_algs[0].id, 85 cs_dsp_bin_err_test_mock_algs[0].ver, 86 WMFW_ADSP2_YM, 0, 87 payload_data, payload_size_bytes); 88 89 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 90 KUNIT_EXPECT_EQ(test, 91 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 92 0); 93 94 /* Check that the payload was written to memory */ 95 reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_YM); 96 KUNIT_EXPECT_EQ(test, 97 regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes), 98 0); 99 KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes); 100 } 101 102 /* Load a bin that doesn't have a valid magic marker. */ 103 static void bin_err_wrong_magic(struct kunit *test) 104 { 105 struct cs_dsp_test *priv = test->priv; 106 struct cs_dsp_test_local *local = priv->local; 107 struct firmware *bin; 108 109 /* Sanity-check that the wmfw loads ok without the bin */ 110 KUNIT_EXPECT_EQ(test, 111 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 112 0); 113 cs_dsp_power_down(priv->dsp); 114 115 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 116 117 memcpy((void *)bin->data, "WMFW", 4); 118 KUNIT_EXPECT_LT(test, 119 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 120 0); 121 122 memcpy((void *)bin->data, "xMDR", 4); 123 KUNIT_EXPECT_LT(test, 124 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 125 0); 126 127 memcpy((void *)bin->data, "WxDR", 4); 128 KUNIT_EXPECT_LT(test, 129 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 130 0); 131 132 memcpy((void *)bin->data, "WMxR", 4); 133 KUNIT_EXPECT_LT(test, 134 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 135 0); 136 137 memcpy((void *)bin->data, "WMDx", 4); 138 KUNIT_EXPECT_LT(test, 139 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 140 0); 141 142 memset((void *)bin->data, 0, 4); 143 KUNIT_EXPECT_LT(test, 144 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 145 0); 146 } 147 148 /* Load a bin that is too short for a valid header. */ 149 static void bin_err_too_short_for_header(struct kunit *test) 150 { 151 struct cs_dsp_test *priv = test->priv; 152 struct cs_dsp_test_local *local = priv->local; 153 struct firmware *bin; 154 155 /* Sanity-check that the wmfw loads ok without the bin */ 156 KUNIT_EXPECT_EQ(test, 157 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 158 0); 159 cs_dsp_power_down(priv->dsp); 160 161 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 162 do { 163 bin->size--; 164 165 KUNIT_EXPECT_LT(test, 166 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 167 0); 168 } while (bin->size > 0); 169 } 170 171 /* Header length field isn't a valid header length. */ 172 static void bin_err_bad_header_length(struct kunit *test) 173 { 174 struct cs_dsp_test *priv = test->priv; 175 struct cs_dsp_test_local *local = priv->local; 176 struct firmware *bin; 177 struct wmfw_coeff_hdr *header; 178 unsigned int real_len, len; 179 180 /* Sanity-check that the wmfw loads ok without the bin */ 181 KUNIT_EXPECT_EQ(test, 182 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 183 0); 184 cs_dsp_power_down(priv->dsp); 185 186 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 187 header = (struct wmfw_coeff_hdr *)bin->data; 188 real_len = le32_to_cpu(header->len); 189 190 for (len = 0; len < real_len; len++) { 191 header->len = cpu_to_le32(len); 192 KUNIT_EXPECT_LT(test, 193 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 194 0); 195 } 196 197 for (len = real_len + 1; len < real_len + 7; len++) { 198 header->len = cpu_to_le32(len); 199 KUNIT_EXPECT_LT(test, 200 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 201 0); 202 } 203 204 header->len = cpu_to_le32(0xffffffff); 205 KUNIT_EXPECT_LT(test, 206 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 207 0); 208 209 header->len = cpu_to_le32(0x80000000); 210 KUNIT_EXPECT_LT(test, 211 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 212 0); 213 214 header->len = cpu_to_le32(0x7fffffff); 215 KUNIT_EXPECT_LT(test, 216 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 217 0); 218 } 219 220 /* Wrong core type in header. */ 221 static void bin_err_bad_core_type(struct kunit *test) 222 { 223 struct cs_dsp_test *priv = test->priv; 224 struct cs_dsp_test_local *local = priv->local; 225 struct firmware *bin; 226 struct wmfw_coeff_hdr *header; 227 228 /* Sanity-check that the wmfw loads ok without the bin */ 229 KUNIT_EXPECT_EQ(test, 230 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 231 0); 232 cs_dsp_power_down(priv->dsp); 233 234 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 235 header = (struct wmfw_coeff_hdr *)bin->data; 236 237 header->core_ver = cpu_to_le32(0); 238 KUNIT_EXPECT_LT(test, 239 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 240 0); 241 242 header->core_ver = cpu_to_le32(1); 243 KUNIT_EXPECT_LT(test, 244 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 245 0); 246 247 header->core_ver = cpu_to_le32(priv->dsp->type + 1); 248 KUNIT_EXPECT_LT(test, 249 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 250 0); 251 252 header->core_ver = cpu_to_le32(0xff); 253 KUNIT_EXPECT_LT(test, 254 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 255 0); 256 } 257 258 /* File too short to contain a full block header */ 259 static void bin_too_short_for_block_header(struct kunit *test) 260 { 261 const struct cs_dsp_bin_test_param *param = test->param_value; 262 struct cs_dsp_test *priv = test->priv; 263 struct cs_dsp_test_local *local = priv->local; 264 struct firmware *bin; 265 unsigned int header_length; 266 267 /* Sanity-check that the wmfw loads ok without the bin */ 268 KUNIT_EXPECT_EQ(test, 269 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 270 0); 271 cs_dsp_power_down(priv->dsp); 272 273 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 274 header_length = bin->size; 275 kunit_kfree(test, bin); 276 277 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 278 cs_dsp_bin_err_test_mock_algs[0].id, 279 cs_dsp_bin_err_test_mock_algs[0].ver, 280 param->block_type, 0, 281 NULL, 0); 282 283 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 284 KUNIT_ASSERT_GT(test, bin->size, header_length); 285 286 for (bin->size--; bin->size > header_length; bin->size--) { 287 KUNIT_EXPECT_LT(test, 288 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 289 0); 290 } 291 } 292 293 /* File too short to contain the block payload */ 294 static void bin_too_short_for_block_payload(struct kunit *test) 295 { 296 const struct cs_dsp_bin_test_param *param = test->param_value; 297 struct cs_dsp_test *priv = test->priv; 298 struct cs_dsp_test_local *local = priv->local; 299 struct firmware *bin; 300 static const u8 payload[256] = { }; 301 int i; 302 303 /* Sanity-check that the wmfw loads ok without the bin */ 304 KUNIT_EXPECT_EQ(test, 305 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 306 0); 307 cs_dsp_power_down(priv->dsp); 308 309 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 310 cs_dsp_bin_err_test_mock_algs[0].id, 311 cs_dsp_bin_err_test_mock_algs[0].ver, 312 param->block_type, 0, 313 payload, sizeof(payload)); 314 315 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 316 for (i = 0; i < sizeof(payload); i++) { 317 bin->size--; 318 KUNIT_EXPECT_LT(test, 319 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 320 0); 321 } 322 } 323 324 /* Block payload length is a garbage value */ 325 static void bin_block_payload_len_garbage(struct kunit *test) 326 { 327 const struct cs_dsp_bin_test_param *param = test->param_value; 328 struct cs_dsp_test *priv = test->priv; 329 struct cs_dsp_test_local *local = priv->local; 330 struct firmware *bin; 331 struct wmfw_coeff_hdr *header; 332 struct wmfw_coeff_item *block; 333 u32 payload = 0; 334 335 /* Sanity-check that the wmfw loads ok without the bin */ 336 KUNIT_EXPECT_EQ(test, 337 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"), 338 0); 339 cs_dsp_power_down(priv->dsp); 340 341 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 342 cs_dsp_bin_err_test_mock_algs[0].id, 343 cs_dsp_bin_err_test_mock_algs[0].ver, 344 param->block_type, 0, 345 &payload, sizeof(payload)); 346 347 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); 348 header = (struct wmfw_coeff_hdr *)bin->data; 349 block = (struct wmfw_coeff_item *)&bin->data[le32_to_cpu(header->len)]; 350 351 /* Sanity check that we're looking at the correct part of the bin */ 352 KUNIT_ASSERT_EQ(test, le16_to_cpu(block->type), param->block_type); 353 KUNIT_ASSERT_EQ(test, le32_to_cpu(block->len), sizeof(payload)); 354 355 block->len = cpu_to_le32(0x8000); 356 KUNIT_EXPECT_LT(test, 357 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 358 0); 359 360 block->len = cpu_to_le32(0xffff); 361 KUNIT_EXPECT_LT(test, 362 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 363 0); 364 365 block->len = cpu_to_le32(0x7fffffff); 366 KUNIT_EXPECT_LT(test, 367 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 368 0); 369 370 block->len = cpu_to_le32(0x80000000); 371 KUNIT_EXPECT_LT(test, 372 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 373 0); 374 375 block->len = cpu_to_le32(0xffffffff); 376 KUNIT_EXPECT_LT(test, 377 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"), 378 0); 379 } 380 381 static void cs_dsp_bin_err_test_exit(struct kunit *test) 382 { 383 /* 384 * Testing error conditions can produce a lot of log output 385 * from cs_dsp error messages, so rate limit the test cases. 386 */ 387 usleep_range(200, 500); 388 } 389 390 static int cs_dsp_bin_err_test_common_init(struct kunit *test, struct cs_dsp *dsp, 391 int wmfw_version) 392 { 393 struct cs_dsp_test *priv; 394 struct cs_dsp_test_local *local; 395 struct device *test_dev; 396 int ret; 397 398 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL); 399 if (!priv) 400 return -ENOMEM; 401 402 local = kunit_kzalloc(test, sizeof(struct cs_dsp_test_local), GFP_KERNEL); 403 if (!local) 404 return -ENOMEM; 405 406 priv->test = test; 407 priv->dsp = dsp; 408 test->priv = priv; 409 priv->local = local; 410 priv->local->wmfw_version = wmfw_version; 411 412 /* Create dummy struct device */ 413 test_dev = kunit_device_register(test, "cs_dsp_test_drv"); 414 if (IS_ERR(test_dev)) 415 return PTR_ERR(test_dev); 416 417 dsp->dev = get_device(test_dev); 418 if (!dsp->dev) 419 return -ENODEV; 420 421 ret = kunit_add_action_or_reset(test, _put_device_wrapper, dsp->dev); 422 if (ret) 423 return ret; 424 425 dev_set_drvdata(dsp->dev, priv); 426 427 /* Allocate regmap */ 428 ret = cs_dsp_mock_regmap_init(priv); 429 if (ret) 430 return ret; 431 432 /* 433 * There must always be a XM header with at least 1 algorithm, so create 434 * a dummy one that tests can use and extract it to a data payload. 435 */ 436 local->xm_header = cs_dsp_create_mock_xm_header(priv, 437 cs_dsp_bin_err_test_mock_algs, 438 ARRAY_SIZE(cs_dsp_bin_err_test_mock_algs)); 439 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->xm_header); 440 441 local->wmfw_builder = cs_dsp_mock_wmfw_init(priv, priv->local->wmfw_version); 442 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->wmfw_builder); 443 444 /* Add dummy XM header payload to wmfw */ 445 cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder, 446 WMFW_ADSP2_XM, 0, 447 local->xm_header->blob_data, 448 local->xm_header->blob_size_bytes); 449 450 local->wmfw = cs_dsp_mock_wmfw_get_firmware(priv->local->wmfw_builder); 451 452 local->bin_builder = 453 cs_dsp_mock_bin_init(priv, 1, 454 cs_dsp_mock_xm_header_get_fw_version_from_regmap(priv)); 455 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->bin_builder); 456 457 /* Init cs_dsp */ 458 dsp->client_ops = kunit_kzalloc(test, sizeof(*dsp->client_ops), GFP_KERNEL); 459 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp->client_ops); 460 461 switch (dsp->type) { 462 case WMFW_ADSP2: 463 ret = cs_dsp_adsp2_init(dsp); 464 break; 465 case WMFW_HALO: 466 ret = cs_dsp_halo_init(dsp); 467 break; 468 default: 469 KUNIT_FAIL(test, "Untested DSP type %d\n", dsp->type); 470 return -EINVAL; 471 } 472 473 if (ret) 474 return ret; 475 476 /* Automatically call cs_dsp_remove() when test case ends */ 477 return kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp); 478 } 479 480 static int cs_dsp_bin_err_test_halo_init(struct kunit *test) 481 { 482 struct cs_dsp *dsp; 483 484 /* Fill in cs_dsp and initialize */ 485 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL); 486 if (!dsp) 487 return -ENOMEM; 488 489 dsp->num = 1; 490 dsp->type = WMFW_HALO; 491 dsp->mem = cs_dsp_mock_halo_dsp1_regions; 492 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_halo_dsp1_region_sizes); 493 dsp->base = cs_dsp_mock_halo_core_base; 494 dsp->base_sysinfo = cs_dsp_mock_halo_sysinfo_base; 495 496 return cs_dsp_bin_err_test_common_init(test, dsp, 3); 497 } 498 499 static int cs_dsp_bin_err_test_adsp2_32bit_init(struct kunit *test) 500 { 501 struct cs_dsp *dsp; 502 503 /* Fill in cs_dsp and initialize */ 504 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL); 505 if (!dsp) 506 return -ENOMEM; 507 508 dsp->num = 1; 509 dsp->type = WMFW_ADSP2; 510 dsp->rev = 1; 511 dsp->mem = cs_dsp_mock_adsp2_32bit_dsp1_regions; 512 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_32bit_dsp1_region_sizes); 513 dsp->base = cs_dsp_mock_adsp2_32bit_sysbase; 514 515 return cs_dsp_bin_err_test_common_init(test, dsp, 2); 516 } 517 518 static int cs_dsp_bin_err_test_adsp2_16bit_init(struct kunit *test) 519 { 520 struct cs_dsp *dsp; 521 522 /* Fill in cs_dsp and initialize */ 523 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL); 524 if (!dsp) 525 return -ENOMEM; 526 527 dsp->num = 1; 528 dsp->type = WMFW_ADSP2; 529 dsp->rev = 0; 530 dsp->mem = cs_dsp_mock_adsp2_16bit_dsp1_regions; 531 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_16bit_dsp1_region_sizes); 532 dsp->base = cs_dsp_mock_adsp2_16bit_sysbase; 533 534 return cs_dsp_bin_err_test_common_init(test, dsp, 1); 535 } 536 537 static struct kunit_case cs_dsp_bin_err_test_cases_halo[] = { 538 539 { } /* terminator */ 540 }; 541 542 static void cs_dsp_bin_err_block_types_desc(const struct cs_dsp_bin_test_param *param, 543 char *desc) 544 { 545 snprintf(desc, KUNIT_PARAM_DESC_SIZE, "block_type:%#x", param->block_type); 546 } 547 548 /* Some block types to test against, including illegal types */ 549 static const struct cs_dsp_bin_test_param bin_test_block_types_cases[] = { 550 { .block_type = WMFW_INFO_TEXT << 8 }, 551 { .block_type = WMFW_METADATA << 8 }, 552 { .block_type = WMFW_ADSP2_PM }, 553 { .block_type = WMFW_ADSP2_XM }, 554 { .block_type = 0x33 }, 555 { .block_type = 0xf500 }, 556 { .block_type = 0xc000 }, 557 }; 558 559 KUNIT_ARRAY_PARAM(bin_test_block_types, 560 bin_test_block_types_cases, 561 cs_dsp_bin_err_block_types_desc); 562 563 static struct kunit_case cs_dsp_bin_err_test_cases_adsp2[] = { 564 KUNIT_CASE(bin_load_with_unknown_blocks), 565 KUNIT_CASE(bin_err_wrong_magic), 566 KUNIT_CASE(bin_err_too_short_for_header), 567 KUNIT_CASE(bin_err_bad_header_length), 568 KUNIT_CASE(bin_err_bad_core_type), 569 570 KUNIT_CASE_PARAM(bin_too_short_for_block_header, bin_test_block_types_gen_params), 571 KUNIT_CASE_PARAM(bin_too_short_for_block_payload, bin_test_block_types_gen_params), 572 KUNIT_CASE_PARAM(bin_block_payload_len_garbage, bin_test_block_types_gen_params), 573 574 { } /* terminator */ 575 }; 576 577 static struct kunit_suite cs_dsp_bin_err_test_halo = { 578 .name = "cs_dsp_bin_err_halo", 579 .init = cs_dsp_bin_err_test_halo_init, 580 .exit = cs_dsp_bin_err_test_exit, 581 .test_cases = cs_dsp_bin_err_test_cases_halo, 582 }; 583 584 static struct kunit_suite cs_dsp_bin_err_test_adsp2_32bit = { 585 .name = "cs_dsp_bin_err_adsp2_32bit", 586 .init = cs_dsp_bin_err_test_adsp2_32bit_init, 587 .exit = cs_dsp_bin_err_test_exit, 588 .test_cases = cs_dsp_bin_err_test_cases_adsp2, 589 }; 590 591 static struct kunit_suite cs_dsp_bin_err_test_adsp2_16bit = { 592 .name = "cs_dsp_bin_err_adsp2_16bit", 593 .init = cs_dsp_bin_err_test_adsp2_16bit_init, 594 .exit = cs_dsp_bin_err_test_exit, 595 .test_cases = cs_dsp_bin_err_test_cases_adsp2, 596 }; 597 598 kunit_test_suites(&cs_dsp_bin_err_test_halo, 599 &cs_dsp_bin_err_test_adsp2_32bit, 600 &cs_dsp_bin_err_test_adsp2_16bit); 601