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. */
bin_load_with_unknown_blocks(struct kunit * test)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. */
bin_err_wrong_magic(struct kunit * test)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. */
bin_err_too_short_for_header(struct kunit * test)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. */
bin_err_bad_header_length(struct kunit * test)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. */
bin_err_bad_core_type(struct kunit * test)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 */
bin_too_short_for_block_header(struct kunit * test)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 */
bin_too_short_for_block_payload(struct kunit * test)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 */
bin_block_payload_len_garbage(struct kunit * test)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
cs_dsp_bin_err_test_exit(struct kunit * test)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
cs_dsp_bin_err_test_common_init(struct kunit * test,struct cs_dsp * dsp,int wmfw_version)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(local->xm_header));
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
cs_dsp_bin_err_test_halo_init(struct kunit * test)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
cs_dsp_bin_err_test_adsp2_32bit_init(struct kunit * test)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
cs_dsp_bin_err_test_adsp2_16bit_init(struct kunit * test)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
cs_dsp_bin_err_block_types_desc(const struct cs_dsp_bin_test_param * param,char * desc)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