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#include "../cs_dsp.h"
 22
 23KUNIT_DEFINE_ACTION_WRAPPER(_put_device_wrapper, put_device, struct device *);
 24KUNIT_DEFINE_ACTION_WRAPPER(_cs_dsp_remove_wrapper, cs_dsp_remove, struct cs_dsp *);
 25
 26struct 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
 34struct cs_dsp_bin_test_param {
 35	int block_type;
 36};
 37
 38static 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. */
 49static 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,
 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,
 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,
 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,
 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. */
105static 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. */
151static 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. */
174static 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. */
223static 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 */
261static 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,
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 */
296static 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,
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 */
327static 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,
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
383static 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
390static 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
492static 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
511static 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
530static 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
549static 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 */
556static 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
566KUNIT_ARRAY_PARAM(bin_test_block_types,
567		  bin_test_block_types_cases,
568		  cs_dsp_bin_err_block_types_desc);
569
570static 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
584static 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
591static 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
598static 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
605kunit_test_suites(&cs_dsp_bin_err_test_halo,
606		  &cs_dsp_bin_err_test_adsp2_32bit,
607		  &cs_dsp_bin_err_test_adsp2_16bit);