Debian Codegraph @

drivers/firmware/cirrus/test/cs_dsp_test_bin_error.c

raw
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 #include "../cs_dsp.h"
22
23 KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *);
24 KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *);
25
26 struct cs_dsp_test_local {
27 struct cs_dsp_mock_bin_builder *bin_builder;
28 struct cs_dsp_mock_xm_header *xm_header;
29 struct cs_dsp_mock_wmfw_builder *wmfw_builder;
30 struct firmware *wmfw;
31 int wmfw_version;
32 };
33
34 struct cs_dsp_bin_test_param {
35 int block_type;
36 };
37
38 static const struct cs_dsp_mock_alg_def cs_dsp_bin_err_test_mock_algs[] = {
39 {
40 .id = 0xfafa,
41 .ver = 0x100000,
42 .xm_size_words = 164,
43 .ym_size_words = 164,
44 .zm_size_words = 164,
45 },
46 };
47
48 /* Load a bin containing unknown blocks. They should be skipped. */
49 static void bin_load_with_unknown_blocks(struct kunit *test)
50 {
51 struct cs_dsp_test *priv = test->priv;
52 struct cs_dsp_test_local *local = priv->local;
53 struct firmware *bin;
54 unsigned int reg_addr;
55 u8 *payload_data, *readback;
56 u8 random_data[8];
57 const unsigned int payload_size_bytes = 64;
58
59 payload_data = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
60 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
61 get_random_bytes(payload_data, payload_size_bytes);
62
63 readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
64 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);
65
66 /* Add some unknown blocks at the start of the bin */
67 get_random_bytes(random_data, sizeof(random_data));
68 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
69 cs_dsp_bin_err_test_mock_algs[0].id,
70 cs_dsp_bin_err_test_mock_algs[0].ver,
71 0xf5, 0, 0,
72 random_data, sizeof(random_data));
73 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
74 cs_dsp_bin_err_test_mock_algs[0].id,
75 cs_dsp_bin_err_test_mock_algs[0].ver,
76 0xf500, 0, 0,
77 random_data, sizeof(random_data));
78 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
79 cs_dsp_bin_err_test_mock_algs[0].id,
80 cs_dsp_bin_err_test_mock_algs[0].ver,
81 0xc300, 0, 0,
82 random_data, sizeof(random_data));
83
84 /* Add a single payload to be written to DSP memory */
85 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
86 cs_dsp_bin_err_test_mock_algs[0].id,
87 cs_dsp_bin_err_test_mock_algs[0].ver,
88 WMFW_ADSP2_YM, 0, 0,
89 payload_data, payload_size_bytes);
90
91 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
92 KUNIT_EXPECT_EQ(test,
93 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
94 0);
95
96 /* Check that the payload was written to memory */
97 reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_YM);
98 KUNIT_EXPECT_EQ(test,
99 regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
100 0);
101 KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);
102 }
103
104 /* Load a bin that doesn't have a valid magic marker. */
105 static void bin_err_wrong_magic(struct kunit *test)
106 {
107 struct cs_dsp_test *priv = test->priv;
108 struct cs_dsp_test_local *local = priv->local;
109 struct firmware *bin;
110
111 /* Sanity-check that the wmfw loads ok without the bin */
112 KUNIT_EXPECT_EQ(test,
113 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
114 0);
115 cs_dsp_power_down(priv->dsp);
116
117 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
118
119 memcpy((void *)bin->data, "WMFW", 4);
120 KUNIT_EXPECT_LT(test,
121 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
122 0);
123
124 memcpy((void *)bin->data, "xMDR", 4);
125 KUNIT_EXPECT_LT(test,
126 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
127 0);
128
129 memcpy((void *)bin->data, "WxDR", 4);
130 KUNIT_EXPECT_LT(test,
131 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
132 0);
133
134 memcpy((void *)bin->data, "WMxR", 4);
135 KUNIT_EXPECT_LT(test,
136 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
137 0);
138
139 memcpy((void *)bin->data, "WMDx", 4);
140 KUNIT_EXPECT_LT(test,
141 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
142 0);
143
144 memset((void *)bin->data, 0, 4);
145 KUNIT_EXPECT_LT(test,
146 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
147 0);
148 }
149
150 /* Load a bin that is too short for a valid header. */
151 static void bin_err_too_short_for_header(struct kunit *test)
152 {
153 struct cs_dsp_test *priv = test->priv;
154 struct cs_dsp_test_local *local = priv->local;
155 struct firmware *bin;
156
157 /* Sanity-check that the wmfw loads ok without the bin */
158 KUNIT_EXPECT_EQ(test,
159 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
160 0);
161 cs_dsp_power_down(priv->dsp);
162
163 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
164 do {
165 bin->size--;
166
167 KUNIT_EXPECT_LT(test,
168 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
169 0);
170 } while (bin->size > 0);
171 }
172
173 /* Header length field isn't a valid header length. */
174 static void bin_err_bad_header_length(struct kunit *test)
175 {
176 struct cs_dsp_test *priv = test->priv;
177 struct cs_dsp_test_local *local = priv->local;
178 struct firmware *bin;
179 struct wmfw_coeff_hdr *header;
180 unsigned int real_len, len;
181
182 /* Sanity-check that the wmfw loads ok without the bin */
183 KUNIT_EXPECT_EQ(test,
184 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
185 0);
186 cs_dsp_power_down(priv->dsp);
187
188 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
189 header = (struct wmfw_coeff_hdr *)bin->data;
190 real_len = le32_to_cpu(header->len);
191
192 for (len = 0; len < real_len; len++) {
193 header->len = cpu_to_le32(len);
194 KUNIT_EXPECT_LT(test,
195 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
196 0);
197 }
198
199 for (len = real_len + 1; len < real_len + 7; len++) {
200 header->len = cpu_to_le32(len);
201 KUNIT_EXPECT_LT(test,
202 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
203 0);
204 }
205
206 header->len = cpu_to_le32(0xffffffff);
207 KUNIT_EXPECT_LT(test,
208 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
209 0);
210
211 header->len = cpu_to_le32(0x80000000);
212 KUNIT_EXPECT_LT(test,
213 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
214 0);
215
216 header->len = cpu_to_le32(0x7fffffff);
217 KUNIT_EXPECT_LT(test,
218 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
219 0);
220 }
221
222 /* Wrong core type in header. */
223 static void bin_err_bad_core_type(struct kunit *test)
224 {
225 struct cs_dsp_test *priv = test->priv;
226 struct cs_dsp_test_local *local = priv->local;
227 struct firmware *bin;
228 struct wmfw_coeff_hdr *header;
229
230 /* Sanity-check that the wmfw loads ok without the bin */
231 KUNIT_EXPECT_EQ(test,
232 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
233 0);
234 cs_dsp_power_down(priv->dsp);
235
236 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
237 header = (struct wmfw_coeff_hdr *)bin->data;
238
239 header->core_ver = cpu_to_le32(0);
240 KUNIT_EXPECT_LT(test,
241 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
242 0);
243
244 header->core_ver = cpu_to_le32(1);
245 KUNIT_EXPECT_LT(test,
246 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
247 0);
248
249 header->core_ver = cpu_to_le32(priv->dsp->type + 1);
250 KUNIT_EXPECT_LT(test,
251 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
252 0);
253
254 header->core_ver = cpu_to_le32(0xff);
255 KUNIT_EXPECT_LT(test,
256 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
257 0);
258 }
259
260 /* File too short to contain a full block header */
261 static void bin_too_short_for_block_header(struct kunit *test)
262 {
263 const struct cs_dsp_bin_test_param *param = test->param_value;
264 struct cs_dsp_test *priv = test->priv;
265 struct cs_dsp_test_local *local = priv->local;
266 struct firmware *bin;
267 unsigned int header_length;
268
269 /* Sanity-check that the wmfw loads ok without the bin */
270 KUNIT_EXPECT_EQ(test,
271 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
272 0);
273 cs_dsp_power_down(priv->dsp);
274
275 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
276 header_length = bin->size;
277 kunit_kfree(test, bin);
278
279 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
280 cs_dsp_bin_err_test_mock_algs[0].id,
281 cs_dsp_bin_err_test_mock_algs[0].ver,
282 param->block_type, 0, 0,
283 NULL, 0);
284
285 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
286 KUNIT_ASSERT_GT(test, bin->size, header_length);
287
288 for (bin->size--; bin->size > header_length; bin->size--) {
289 KUNIT_EXPECT_LT(test,
290 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
291 0);
292 }
293 }
294
295 /* File too short to contain the block payload */
296 static void bin_too_short_for_block_payload(struct kunit *test)
297 {
298 const struct cs_dsp_bin_test_param *param = test->param_value;
299 struct cs_dsp_test *priv = test->priv;
300 struct cs_dsp_test_local *local = priv->local;
301 struct firmware *bin;
302 static const u8 payload[256] = { };
303 int i;
304
305 /* Sanity-check that the wmfw loads ok without the bin */
306 KUNIT_EXPECT_EQ(test,
307 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
308 0);
309 cs_dsp_power_down(priv->dsp);
310
311 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
312 cs_dsp_bin_err_test_mock_algs[0].id,
313 cs_dsp_bin_err_test_mock_algs[0].ver,
314 param->block_type, 0, 0,
315 payload, sizeof(payload));
316
317 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
318 for (i = 0; i < sizeof(payload); i++) {
319 bin->size--;
320 KUNIT_EXPECT_LT(test,
321 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
322 0);
323 }
324 }
325
326 /* Block payload length is a garbage value */
327 static void bin_block_payload_len_garbage(struct kunit *test)
328 {
329 const struct cs_dsp_bin_test_param *param = test->param_value;
330 struct cs_dsp_test *priv = test->priv;
331 struct cs_dsp_test_local *local = priv->local;
332 struct firmware *bin;
333 struct wmfw_coeff_hdr *header;
334 struct wmfw_coeff_item *block;
335 u32 payload = 0;
336
337 /* Sanity-check that the wmfw loads ok without the bin */
338 KUNIT_EXPECT_EQ(test,
339 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", NULL, NULL, "misc"),
340 0);
341 cs_dsp_power_down(priv->dsp);
342
343 cs_dsp_mock_bin_add_raw_block(local->bin_builder,
344 cs_dsp_bin_err_test_mock_algs[0].id,
345 cs_dsp_bin_err_test_mock_algs[0].ver,
346 param->block_type, 0, 0,
347 &payload, sizeof(payload));
348
349 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
350 header = (struct wmfw_coeff_hdr *)bin->data;
351 block = (struct wmfw_coeff_item *)&bin->data[le32_to_cpu(header->len)];
352
353 /* Sanity check that we're looking at the correct part of the bin */
354 KUNIT_ASSERT_EQ(test, le16_to_cpu(block->type), param->block_type);
355 KUNIT_ASSERT_EQ(test, le32_to_cpu(block->len), sizeof(payload));
356
357 block->len = cpu_to_le32(0x8000);
358 KUNIT_EXPECT_LT(test,
359 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
360 0);
361
362 block->len = cpu_to_le32(0xffff);
363 KUNIT_EXPECT_LT(test,
364 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
365 0);
366
367 block->len = cpu_to_le32(0x7fffffff);
368 KUNIT_EXPECT_LT(test,
369 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
370 0);
371
372 block->len = cpu_to_le32(0x80000000);
373 KUNIT_EXPECT_LT(test,
374 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
375 0);
376
377 block->len = cpu_to_le32(0xffffffff);
378 KUNIT_EXPECT_LT(test,
379 cs_dsp_power_up(priv->dsp, local->wmfw, "wmfw", bin, "bin", "misc"),
380 0);
381 }
382
383 static void cs_dsp_bin_err_test_exit(struct kunit *test)
384 {
385 cs_dsp_suppress_err_messages = false;
386 cs_dsp_suppress_warn_messages = false;
387 cs_dsp_suppress_info_messages = false;
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(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 ret = kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp);
478 if (ret)
479 return ret;
480
481 /*
482 * Testing error conditions can produce a lot of log output
483 * from cs_dsp error messages, so suppress messages.
484 */
485 cs_dsp_suppress_err_messages = true;
486 cs_dsp_suppress_warn_messages = true;
487 cs_dsp_suppress_info_messages = true;
488
489 return 0;
490 }
491
492 static int cs_dsp_bin_err_test_halo_init(struct kunit *test)
493 {
494 struct cs_dsp *dsp;
495
496 /* Fill in cs_dsp and initialize */
497 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
498 if (!dsp)
499 return -ENOMEM;
500
501 dsp->num = 1;
502 dsp->type = WMFW_HALO;
503 dsp->mem = cs_dsp_mock_halo_dsp1_regions;
504 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_halo_dsp1_region_sizes);
505 dsp->base = cs_dsp_mock_halo_core_base;
506 dsp->base_sysinfo = cs_dsp_mock_halo_sysinfo_base;
507
508 return cs_dsp_bin_err_test_common_init(test, dsp, 3);
509 }
510
511 static int cs_dsp_bin_err_test_adsp2_32bit_init(struct kunit *test)
512 {
513 struct cs_dsp *dsp;
514
515 /* Fill in cs_dsp and initialize */
516 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
517 if (!dsp)
518 return -ENOMEM;
519
520 dsp->num = 1;
521 dsp->type = WMFW_ADSP2;
522 dsp->rev = 1;
523 dsp->mem = cs_dsp_mock_adsp2_32bit_dsp1_regions;
524 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_32bit_dsp1_region_sizes);
525 dsp->base = cs_dsp_mock_adsp2_32bit_sysbase;
526
527 return cs_dsp_bin_err_test_common_init(test, dsp, 2);
528 }
529
530 static int cs_dsp_bin_err_test_adsp2_16bit_init(struct kunit *test)
531 {
532 struct cs_dsp *dsp;
533
534 /* Fill in cs_dsp and initialize */
535 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
536 if (!dsp)
537 return -ENOMEM;
538
539 dsp->num = 1;
540 dsp->type = WMFW_ADSP2;
541 dsp->rev = 0;
542 dsp->mem = cs_dsp_mock_adsp2_16bit_dsp1_regions;
543 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_16bit_dsp1_region_sizes);
544 dsp->base = cs_dsp_mock_adsp2_16bit_sysbase;
545
546 return cs_dsp_bin_err_test_common_init(test, dsp, 1);
547 }
548
549 static void cs_dsp_bin_err_block_types_desc(const struct cs_dsp_bin_test_param *param,
550 char *desc)
551 {
552 snprintf(desc, KUNIT_PARAM_DESC_SIZE, "block_type:%#x", param->block_type);
553 }
554
555 /* Some block types to test against, including illegal types */
556 static const struct cs_dsp_bin_test_param bin_test_block_types_cases[] = {
557 { .block_type = WMFW_INFO_TEXT << 8 },
558 { .block_type = WMFW_METADATA << 8 },
559 { .block_type = WMFW_ADSP2_PM },
560 { .block_type = WMFW_ADSP2_XM },
561 { .block_type = 0x33 },
562 { .block_type = 0xf500 },
563 { .block_type = 0xc000 },
564 };
565
566 KUNIT_ARRAY_PARAM(bin_test_block_types,
567 bin_test_block_types_cases,
568 cs_dsp_bin_err_block_types_desc);
569
570 static struct kunit_case cs_dsp_bin_err_test_cases[] = {
571 KUNIT_CASE(bin_load_with_unknown_blocks),
572 KUNIT_CASE(bin_err_wrong_magic),
573 KUNIT_CASE(bin_err_too_short_for_header),
574 KUNIT_CASE(bin_err_bad_header_length),
575 KUNIT_CASE(bin_err_bad_core_type),
576
577 KUNIT_CASE_PARAM(bin_too_short_for_block_header, bin_test_block_types_gen_params),
578 KUNIT_CASE_PARAM(bin_too_short_for_block_payload, bin_test_block_types_gen_params),
579 KUNIT_CASE_PARAM(bin_block_payload_len_garbage, bin_test_block_types_gen_params),
580
581 { } /* terminator */
582 };
583
584 static struct kunit_suite cs_dsp_bin_err_test_halo = {
585 .name = "cs_dsp_bin_err_halo",
586 .init = cs_dsp_bin_err_test_halo_init,
587 .exit = cs_dsp_bin_err_test_exit,
588 .test_cases = cs_dsp_bin_err_test_cases,
589 };
590
591 static struct kunit_suite cs_dsp_bin_err_test_adsp2_32bit = {
592 .name = "cs_dsp_bin_err_adsp2_32bit",
593 .init = cs_dsp_bin_err_test_adsp2_32bit_init,
594 .exit = cs_dsp_bin_err_test_exit,
595 .test_cases = cs_dsp_bin_err_test_cases,
596 };
597
598 static struct kunit_suite cs_dsp_bin_err_test_adsp2_16bit = {
599 .name = "cs_dsp_bin_err_adsp2_16bit",
600 .init = cs_dsp_bin_err_test_adsp2_16bit_init,
601 .exit = cs_dsp_bin_err_test_exit,
602 .test_cases = cs_dsp_bin_err_test_cases,
603 };
604
605 kunit_test_suites(&cs_dsp_bin_err_test_halo,
606 &cs_dsp_bin_err_test_adsp2_32bit,
607 &cs_dsp_bin_err_test_adsp2_16bit);