drivers/firmware/cirrus/test/cs_dsp_test_bin_error.c

   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);