Debian Codegraph @

drivers/firmware/cirrus/test/cs_dsp_test_wmfw_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_xm_header *xm_header;
28 struct cs_dsp_mock_wmfw_builder *wmfw_builder;
29 int wmfw_version;
30 };
31
32 struct cs_dsp_wmfw_test_param {
33 int block_type;
34 };
35
36 static const struct cs_dsp_mock_alg_def cs_dsp_wmfw_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 static const struct cs_dsp_mock_coeff_def mock_coeff_template = {
47 .shortname = "Dummy Coeff",
48 .type = WMFW_CTL_TYPE_BYTES,
49 .mem_type = WMFW_ADSP2_YM,
50 .flags = WMFW_CTL_FLAG_VOLATILE,
51 .length_bytes = 4,
52 };
53
54 /* Load a wmfw containing unknown blocks. They should be skipped. */
55 static void wmfw_load_with_unknown_blocks(struct kunit *test)
56 {
57 struct cs_dsp_test *priv = test->priv;
58 struct cs_dsp_test_local *local = priv->local;
59 struct firmware *wmfw;
60 unsigned int reg_addr;
61 u8 *payload_data, *readback;
62 u8 random_data[8];
63 const unsigned int payload_size_bytes = 64;
64
65 /* Add dummy XM header payload to wmfw */
66 cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
67 WMFW_ADSP2_XM, 0,
68 local->xm_header->blob_data,
69 local->xm_header->blob_size_bytes);
70
71 payload_data = kunit_kmalloc(test, payload_size_bytes, GFP_KERNEL);
72 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, payload_data);
73 get_random_bytes(payload_data, payload_size_bytes);
74
75 readback = kunit_kzalloc(test, payload_size_bytes, GFP_KERNEL);
76 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, readback);
77
78 /* Add some unknown blocks at the start of the wmfw */
79 get_random_bytes(random_data, sizeof(random_data));
80 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, 0xf5, 0,
81 random_data, sizeof(random_data));
82 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, 0xc0, 0, random_data,
83 sizeof(random_data));
84 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, 0x33, 0, NULL, 0);
85
86 /* Add a single payload to be written to DSP memory */
87 cs_dsp_mock_wmfw_add_data_block(local->wmfw_builder,
88 WMFW_ADSP2_YM, 0,
89 payload_data, payload_size_bytes);
90
91 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
92
93 /* Sanity-check that the good wmfw loads ok */
94 KUNIT_EXPECT_EQ(test,
95 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
96 0);
97 cs_dsp_power_down(priv->dsp);
98
99 KUNIT_EXPECT_EQ(test,
100 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
101 0);
102
103 /* Check that the payload was written to memory */
104 reg_addr = cs_dsp_mock_base_addr_for_mem(priv, WMFW_ADSP2_YM);
105 KUNIT_EXPECT_EQ(test,
106 regmap_raw_read(priv->dsp->regmap, reg_addr, readback, payload_size_bytes),
107 0);
108 KUNIT_EXPECT_MEMEQ(test, readback, payload_data, payload_size_bytes);
109 }
110
111 /* Load a wmfw that doesn't have a valid magic marker. */
112 static void wmfw_err_wrong_magic(struct kunit *test)
113 {
114 struct cs_dsp_test *priv = test->priv;
115 struct cs_dsp_test_local *local = priv->local;
116 struct firmware *wmfw;
117
118 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
119
120 /* Sanity-check that the good wmfw loads ok */
121 KUNIT_EXPECT_EQ(test,
122 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
123 0);
124 cs_dsp_power_down(priv->dsp);
125
126 memcpy((void *)wmfw->data, "WMDR", 4);
127 KUNIT_EXPECT_LT(test,
128 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
129 0);
130
131 memcpy((void *)wmfw->data, "xMFW", 4);
132 KUNIT_EXPECT_LT(test,
133 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
134 0);
135
136 memcpy((void *)wmfw->data, "WxFW", 4);
137 KUNIT_EXPECT_LT(test,
138 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
139 0);
140
141 memcpy((void *)wmfw->data, "WMxW", 4);
142 KUNIT_EXPECT_LT(test,
143 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
144 0);
145
146 memcpy((void *)wmfw->data, "WMFx", 4);
147 KUNIT_EXPECT_LT(test,
148 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
149 0);
150
151 memset((void *)wmfw->data, 0, 4);
152 KUNIT_EXPECT_LT(test,
153 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
154 0);
155 }
156
157 /* Load a wmfw that is too short for a valid header. */
158 static void wmfw_err_too_short_for_header(struct kunit *test)
159 {
160 struct cs_dsp_test *priv = test->priv;
161 struct cs_dsp_test_local *local = priv->local;
162 struct firmware *wmfw;
163
164 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
165
166 /* Sanity-check that the good wmfw loads ok */
167 KUNIT_EXPECT_EQ(test,
168 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
169 0);
170 cs_dsp_power_down(priv->dsp);
171
172 do {
173 wmfw->size--;
174
175 KUNIT_EXPECT_EQ(test,
176 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
177 -EOVERFLOW);
178 } while (wmfw->size > 0);
179 }
180
181 /* Header length field isn't a valid header length. */
182 static void wmfw_err_bad_header_length(struct kunit *test)
183 {
184 struct cs_dsp_test *priv = test->priv;
185 struct cs_dsp_test_local *local = priv->local;
186 struct firmware *wmfw;
187 struct wmfw_header *header;
188 unsigned int real_len, len;
189
190 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
191
192 /* Sanity-check that the good wmfw loads ok */
193 KUNIT_EXPECT_EQ(test,
194 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
195 0);
196 cs_dsp_power_down(priv->dsp);
197
198 header = (struct wmfw_header *)wmfw->data;
199 real_len = le32_to_cpu(header->len);
200
201 for (len = 0; len < real_len; len++) {
202 header->len = cpu_to_le32(len);
203 KUNIT_EXPECT_EQ(test,
204 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
205 -EOVERFLOW);
206 }
207
208 for (len = real_len + 1; len < real_len + 7; len++) {
209 header->len = cpu_to_le32(len);
210 KUNIT_EXPECT_EQ(test,
211 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
212 -EOVERFLOW);
213 }
214
215 header->len = cpu_to_le32(0xffffffff);
216 KUNIT_EXPECT_EQ(test,
217 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
218 -EOVERFLOW);
219
220 header->len = cpu_to_le32(0x80000000);
221 KUNIT_EXPECT_EQ(test,
222 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
223 -EOVERFLOW);
224
225 header->len = cpu_to_le32(0x7fffffff);
226 KUNIT_EXPECT_EQ(test,
227 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
228 -EOVERFLOW);
229 }
230
231 /* Wrong core type in header. */
232 static void wmfw_err_bad_core_type(struct kunit *test)
233 {
234 struct cs_dsp_test *priv = test->priv;
235 struct cs_dsp_test_local *local = priv->local;
236 struct firmware *wmfw;
237 struct wmfw_header *header;
238
239 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
240
241 /* Sanity-check that the good wmfw loads ok */
242 KUNIT_EXPECT_EQ(test,
243 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
244 0);
245 cs_dsp_power_down(priv->dsp);
246
247 header = (struct wmfw_header *)wmfw->data;
248
249 header->core = 0;
250 KUNIT_EXPECT_LT(test,
251 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
252 0);
253
254 header->core = 1;
255 KUNIT_EXPECT_LT(test,
256 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
257 0);
258
259 header->core = priv->dsp->type + 1;
260 KUNIT_EXPECT_LT(test,
261 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
262 0);
263
264 header->core = 0xff;
265 KUNIT_EXPECT_LT(test,
266 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
267 0);
268 }
269
270 /* File too short to contain a full block header */
271 static void wmfw_too_short_for_block_header(struct kunit *test)
272 {
273 const struct cs_dsp_wmfw_test_param *param = test->param_value;
274 struct cs_dsp_test *priv = test->priv;
275 struct cs_dsp_test_local *local = priv->local;
276 struct firmware *wmfw;
277 unsigned int header_length;
278 u32 dummy_payload = 0;
279
280 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
281 header_length = wmfw->size;
282 kunit_kfree(test, wmfw);
283
284 /* Add the block. A block must have at least 4 bytes of payload */
285 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, param->block_type, 0,
286 &dummy_payload, sizeof(dummy_payload));
287
288 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
289 KUNIT_ASSERT_GT(test, wmfw->size, header_length);
290
291 /* Sanity-check that the good wmfw loads ok */
292 KUNIT_EXPECT_EQ(test,
293 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
294 0);
295 cs_dsp_power_down(priv->dsp);
296
297 for (wmfw->size--; wmfw->size > header_length; wmfw->size--) {
298 KUNIT_EXPECT_EQ(test,
299 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
300 -EOVERFLOW);
301 }
302 }
303
304 /* File too short to contain the block payload */
305 static void wmfw_too_short_for_block_payload(struct kunit *test)
306 {
307 const struct cs_dsp_wmfw_test_param *param = test->param_value;
308 struct cs_dsp_test *priv = test->priv;
309 struct cs_dsp_test_local *local = priv->local;
310 struct firmware *wmfw;
311 static const u8 payload[256] = { };
312 int i;
313
314 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, param->block_type, 0,
315 payload, sizeof(payload));
316
317 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
318
319 /* Sanity-check that the good wmfw loads ok */
320 KUNIT_EXPECT_EQ(test,
321 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
322 0);
323 cs_dsp_power_down(priv->dsp);
324
325 for (i = 0; i < sizeof(payload); i++) {
326 wmfw->size--;
327 KUNIT_EXPECT_EQ(test,
328 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
329 -EOVERFLOW);
330 }
331 }
332
333 /* Block payload length is a garbage value */
334 static void wmfw_block_payload_len_garbage(struct kunit *test)
335 {
336 const struct cs_dsp_wmfw_test_param *param = test->param_value;
337 struct cs_dsp_test *priv = test->priv;
338 struct cs_dsp_test_local *local = priv->local;
339 struct firmware *wmfw;
340 struct wmfw_header *header;
341 struct wmfw_region *region;
342 u32 payload = 0;
343
344
345 cs_dsp_mock_wmfw_add_raw_block(local->wmfw_builder, param->block_type, 0,
346 &payload, sizeof(payload));
347
348 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
349
350 /* Sanity-check that the good wmfw loads ok */
351 KUNIT_EXPECT_EQ(test,
352 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
353 0);
354 cs_dsp_power_down(priv->dsp);
355
356 header = (struct wmfw_header *)wmfw->data;
357 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
358
359 /* Sanity check that we're looking at the correct part of the wmfw */
360 KUNIT_ASSERT_EQ(test, le32_to_cpu(region->offset) >> 24, param->block_type);
361 KUNIT_ASSERT_EQ(test, le32_to_cpu(region->len), sizeof(payload));
362
363 region->len = cpu_to_le32(0x8000);
364 KUNIT_EXPECT_EQ(test,
365 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
366 -EOVERFLOW);
367
368 region->len = cpu_to_le32(0xffff);
369 KUNIT_EXPECT_EQ(test,
370 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
371 -EOVERFLOW);
372
373 region->len = cpu_to_le32(0x7fffffff);
374 KUNIT_EXPECT_EQ(test,
375 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
376 -EOVERFLOW);
377
378 region->len = cpu_to_le32(0x80000000);
379 KUNIT_EXPECT_EQ(test,
380 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
381 -EOVERFLOW);
382
383 region->len = cpu_to_le32(0xffffffff);
384 KUNIT_EXPECT_EQ(test,
385 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
386 -EOVERFLOW);
387 }
388
389 /* File too short to contain an algorithm header */
390 static void wmfw_too_short_for_alg_header(struct kunit *test)
391 {
392 struct cs_dsp_test *priv = test->priv;
393 struct cs_dsp_test_local *local = priv->local;
394 struct firmware *wmfw;
395 unsigned int header_length;
396
397 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
398 header_length = wmfw->size;
399 kunit_kfree(test, wmfw);
400
401 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
402 cs_dsp_wmfw_err_test_mock_algs[0].id,
403 NULL, NULL);
404 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
405
406 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
407 KUNIT_ASSERT_GT(test, wmfw->size, header_length);
408
409 /* Sanity-check that the good wmfw loads ok */
410 KUNIT_EXPECT_EQ(test,
411 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
412 0);
413 cs_dsp_power_down(priv->dsp);
414
415 for (wmfw->size--; wmfw->size > header_length; wmfw->size--) {
416 KUNIT_EXPECT_EQ(test,
417 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
418 -EOVERFLOW);
419 }
420 }
421
422 /* V1 algorithm name does not have NUL terminator */
423 static void wmfw_v1_alg_name_unterminated(struct kunit *test)
424 {
425 struct cs_dsp_test *priv = test->priv;
426 struct cs_dsp_test_local *local = priv->local;
427 struct firmware *wmfw;
428 struct wmfw_header *header;
429 struct wmfw_region *region;
430 struct wmfw_adsp_alg_data *alg_data;
431 struct cs_dsp_coeff_ctl *ctl;
432
433 /* Create alg info block with a coefficient */
434 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
435 cs_dsp_wmfw_err_test_mock_algs[0].id,
436 "abc", "de");
437 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
438 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
439
440 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
441
442 header = (struct wmfw_header *)wmfw->data;
443 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
444 alg_data = (struct wmfw_adsp_alg_data *)region->data;
445
446 /* Sanity check we're pointing at the alg header */
447 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data->id), cs_dsp_wmfw_err_test_mock_algs[0].id);
448
449 /* Write a string to the alg name that overflows the array */
450 memset(alg_data->descr, 0, sizeof(alg_data->descr));
451 memset(alg_data->name, 'A', sizeof(alg_data->name));
452 memset(alg_data->descr, 'A', sizeof(alg_data->descr) - 1);
453
454 /*
455 * Sanity-check that a strlen would overflow alg_data->name.
456 * FORTIFY_STRING obstructs testing what strlen() would actually
457 * return, so instead verify that a strnlen() returns
458 * sizeof(alg_data->name[]), therefore it doesn't have a NUL.
459 */
460 KUNIT_ASSERT_EQ(test, strnlen(alg_data->name, sizeof(alg_data->name)),
461 sizeof(alg_data->name));
462
463 /*
464 * The alg name isn't stored, but cs_dsp parses the name field.
465 * It should load the file successfully and create the control.
466 * If FORTIFY_STRING is enabled it will detect a buffer overflow
467 * if cs_dsp string length walks past end of alg name array.
468 */
469 KUNIT_EXPECT_EQ(test,
470 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
471 0);
472 ctl = list_first_entry_or_null(&priv->dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
473 KUNIT_ASSERT_NOT_NULL(test, ctl);
474 KUNIT_EXPECT_EQ(test, ctl->subname_len, 0);
475 }
476
477 /* V2+ algorithm name exceeds length of containing block */
478 static void wmfw_v2_alg_name_exceeds_block(struct kunit *test)
479 {
480 struct cs_dsp_test *priv = test->priv;
481 struct cs_dsp_test_local *local = priv->local;
482 struct firmware *wmfw;
483 struct wmfw_header *header;
484 struct wmfw_region *region;
485 __le32 *alg_data;
486
487 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
488 cs_dsp_wmfw_err_test_mock_algs[0].id,
489 "abc", NULL);
490 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
491
492 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
493
494 /* Sanity-check that the good wmfw loads ok */
495 KUNIT_EXPECT_EQ(test,
496 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
497 0);
498 cs_dsp_power_down(priv->dsp);
499
500 header = (struct wmfw_header *)wmfw->data;
501 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
502 alg_data = (__force __le32 *)region->data;
503
504 /*
505 * Sanity check we're pointing at the alg header of
506 * [ alg_id ][name_len]abc
507 */
508 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
509 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[1]), 3 | ('a' << 8) | ('b' << 16) | ('c' << 24));
510 KUNIT_ASSERT_EQ(test, *(u8 *)&alg_data[1], 3);
511
512 /* Set name string length longer than available space */
513 *(u8 *)&alg_data[1] = 4;
514 KUNIT_EXPECT_EQ(test,
515 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
516 -EOVERFLOW);
517
518 *(u8 *)&alg_data[1] = 7;
519 KUNIT_EXPECT_EQ(test,
520 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
521 -EOVERFLOW);
522
523 *(u8 *)&alg_data[1] = 0x80;
524 KUNIT_EXPECT_EQ(test,
525 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
526 -EOVERFLOW);
527
528 *(u8 *)&alg_data[1] = 0xff;
529 KUNIT_EXPECT_EQ(test,
530 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
531 -EOVERFLOW);
532 }
533
534 /* V2+ algorithm description exceeds length of containing block */
535 static void wmfw_v2_alg_description_exceeds_block(struct kunit *test)
536 {
537 struct cs_dsp_test *priv = test->priv;
538 struct cs_dsp_test_local *local = priv->local;
539 struct firmware *wmfw;
540 struct wmfw_header *header;
541 struct wmfw_region *region;
542 __le32 *alg_data;
543
544 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
545 cs_dsp_wmfw_err_test_mock_algs[0].id,
546 "abc", "de");
547 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
548
549 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
550
551 /* Sanity-check that the good wmfw loads ok */
552 KUNIT_EXPECT_EQ(test,
553 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
554 0);
555 cs_dsp_power_down(priv->dsp);
556
557 header = (struct wmfw_header *)wmfw->data;
558 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
559 alg_data = (__force __le32 *)region->data;
560
561 /*
562 * Sanity check we're pointing at the alg header of
563 * [ alg_id ][name_len]abc[desc_len]de
564 */
565 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
566 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[2]), 2 | ('d' << 16) | ('e' << 24));
567 KUNIT_ASSERT_EQ(test, le16_to_cpu(*(__le16 *)&alg_data[2]), 2);
568
569 /* Set name string length longer than available space */
570 *(__le16 *)&alg_data[2] = cpu_to_le16(4);
571 KUNIT_EXPECT_EQ(test,
572 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
573 -EOVERFLOW);
574
575 *(__le16 *)&alg_data[2] = cpu_to_le16(7);
576 KUNIT_EXPECT_EQ(test,
577 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
578 -EOVERFLOW);
579
580 *(__le16 *)&alg_data[2] = cpu_to_le16(0x80);
581 KUNIT_EXPECT_EQ(test,
582 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
583 -EOVERFLOW);
584
585 *(__le16 *)&alg_data[2] = cpu_to_le16(0xff);
586 KUNIT_EXPECT_EQ(test,
587 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
588 -EOVERFLOW);
589
590 *(__le16 *)&alg_data[2] = cpu_to_le16(0x8000);
591 KUNIT_EXPECT_EQ(test,
592 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
593 -EOVERFLOW);
594
595 *(__le16 *)&alg_data[2] = cpu_to_le16(0xffff);
596 KUNIT_EXPECT_EQ(test,
597 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
598 -EOVERFLOW);
599 }
600
601 /* V1 coefficient count exceeds length of containing block */
602 static void wmfw_v1_coeff_count_exceeds_block(struct kunit *test)
603 {
604 struct cs_dsp_test *priv = test->priv;
605 struct cs_dsp_test_local *local = priv->local;
606 struct firmware *wmfw;
607 struct wmfw_header *header;
608 struct wmfw_region *region;
609 struct wmfw_adsp_alg_data *alg_data;
610
611 /* Create alg info block with a coefficient */
612 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
613 cs_dsp_wmfw_err_test_mock_algs[0].id,
614 "abc", "de");
615 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
616 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
617
618 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
619
620 /* Sanity-check that the good wmfw loads ok */
621 KUNIT_EXPECT_EQ(test,
622 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
623 0);
624 cs_dsp_power_down(priv->dsp);
625
626 header = (struct wmfw_header *)wmfw->data;
627 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
628 alg_data = (struct wmfw_adsp_alg_data *)region->data;
629
630 /* Sanity check we're pointing at the alg header */
631 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data->id), cs_dsp_wmfw_err_test_mock_algs[0].id);
632
633 /* Add one to the coefficient count */
634 alg_data->ncoeff = cpu_to_le32(le32_to_cpu(alg_data->ncoeff) + 1);
635 KUNIT_EXPECT_EQ(test,
636 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
637 -EOVERFLOW);
638
639 /* Make the coefficient count garbage */
640 alg_data->ncoeff = cpu_to_le32(0xffffffff);
641 KUNIT_EXPECT_EQ(test,
642 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
643 -EOVERFLOW);
644
645 alg_data->ncoeff = cpu_to_le32(0x7fffffff);
646 KUNIT_EXPECT_EQ(test,
647 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
648 -EOVERFLOW);
649
650 alg_data->ncoeff = cpu_to_le32(0x80000000);
651 KUNIT_EXPECT_EQ(test,
652 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
653 -EOVERFLOW);
654 }
655
656 /* V2+ coefficient count exceeds length of containing block */
657 static void wmfw_v2_coeff_count_exceeds_block(struct kunit *test)
658 {
659 struct cs_dsp_test *priv = test->priv;
660 struct cs_dsp_test_local *local = priv->local;
661 struct firmware *wmfw;
662 struct wmfw_header *header;
663 struct wmfw_region *region;
664 __le32 *alg_data, *ncoeff;
665
666 /* Create alg info block with a coefficient */
667 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
668 cs_dsp_wmfw_err_test_mock_algs[0].id,
669 "abc", "de");
670 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
671 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
672
673 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
674
675 /* Sanity-check that the good wmfw loads ok */
676 KUNIT_EXPECT_EQ(test,
677 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
678 0);
679 cs_dsp_power_down(priv->dsp);
680
681 header = (struct wmfw_header *)wmfw->data;
682 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
683 alg_data = (__force __le32 *)region->data;
684
685 /* Sanity check we're pointing at the alg header */
686 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
687
688 ncoeff = (__force __le32 *)&alg_data[3];
689 KUNIT_ASSERT_EQ(test, le32_to_cpu(*ncoeff), 1);
690
691 /* Add one to the coefficient count */
692 *ncoeff = cpu_to_le32(2);
693 KUNIT_EXPECT_EQ(test,
694 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
695 -EOVERFLOW);
696
697 /* Make the coefficient count garbage */
698 *ncoeff = cpu_to_le32(0xffffffff);
699 KUNIT_EXPECT_EQ(test,
700 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
701 -EOVERFLOW);
702
703 *ncoeff = cpu_to_le32(0x7fffffff);
704 KUNIT_EXPECT_EQ(test,
705 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
706 -EOVERFLOW);
707
708 *ncoeff = cpu_to_le32(0x80000000);
709 KUNIT_EXPECT_EQ(test,
710 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
711 -EOVERFLOW);
712 }
713
714 /* V2+ coefficient block size exceeds length of containing block */
715 static void wmfw_v2_coeff_block_size_exceeds_block(struct kunit *test)
716 {
717 struct cs_dsp_test *priv = test->priv;
718 struct cs_dsp_test_local *local = priv->local;
719 struct firmware *wmfw;
720 struct wmfw_header *header;
721 struct wmfw_region *region;
722 __le32 *alg_data, *coeff;
723
724 /* Create alg info block with a coefficient */
725 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
726 cs_dsp_wmfw_err_test_mock_algs[0].id,
727 "abc", "de");
728 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
729 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
730
731 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
732
733 /* Sanity-check that the good wmfw loads ok */
734 KUNIT_EXPECT_EQ(test,
735 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
736 0);
737 cs_dsp_power_down(priv->dsp);
738
739 header = (struct wmfw_header *)wmfw->data;
740 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
741 alg_data = (__force __le32 *)region->data;
742
743 /* Sanity check we're pointing at the alg header */
744 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
745
746 /* Sanity check we're pointing at the coeff block */
747 coeff = (__force __le32 *)&alg_data[4];
748 KUNIT_ASSERT_EQ(test, le32_to_cpu(coeff[0]), mock_coeff_template.mem_type << 16);
749
750 /* Add one to the block size */
751 coeff[1] = cpu_to_le32(le32_to_cpu(coeff[1]) + 1);
752 KUNIT_EXPECT_EQ(test,
753 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
754 -EOVERFLOW);
755
756 /* Make the block size garbage */
757 coeff[1] = cpu_to_le32(0xffffffff);
758 KUNIT_EXPECT_EQ(test,
759 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
760 -EOVERFLOW);
761
762 coeff[1] = cpu_to_le32(0x7fffffff);
763 KUNIT_EXPECT_EQ(test,
764 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
765 -EOVERFLOW);
766
767 coeff[1] = cpu_to_le32(0x80000000);
768 KUNIT_EXPECT_EQ(test,
769 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
770 -EOVERFLOW);
771 }
772
773 /* V1 coeff name does not have NUL terminator */
774 static void wmfw_v1_coeff_name_unterminated(struct kunit *test)
775 {
776 struct cs_dsp_test *priv = test->priv;
777 struct cs_dsp_test_local *local = priv->local;
778 struct firmware *wmfw;
779 struct wmfw_header *header;
780 struct wmfw_region *region;
781 struct wmfw_adsp_alg_data *alg_data;
782 struct wmfw_adsp_coeff_data *coeff;
783 struct cs_dsp_coeff_ctl *ctl;
784
785 /* Create alg info block with a coefficient */
786 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
787 cs_dsp_wmfw_err_test_mock_algs[0].id,
788 "abc", "de");
789 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
790 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
791
792 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
793
794 header = (struct wmfw_header *)wmfw->data;
795 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
796 alg_data = (struct wmfw_adsp_alg_data *)region->data;
797
798 /* Sanity check we're pointing at the alg header */
799 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data->id), cs_dsp_wmfw_err_test_mock_algs[0].id);
800 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data->ncoeff), 1);
801
802 coeff = (void *)alg_data->data;
803
804 /* Write a string to the coeff name that overflows the array */
805 memset(coeff->descr, 0, sizeof(coeff->descr));
806 memset(coeff->name, 'A', sizeof(coeff->name));
807 memset(coeff->descr, 'A', sizeof(coeff->descr) - 1);
808
809 /*
810 * Sanity-check that a strlen would overflow coeff->name.
811 * FORTIFY_STRING obstructs testing what strlen() would actually
812 * return, so instead verify that a strnlen() returns
813 * sizeof(coeff->name[]), therefore it doesn't have a NUL.
814 */
815 KUNIT_ASSERT_EQ(test, strnlen(coeff->name, sizeof(coeff->name)),
816 sizeof(coeff->name));
817
818 /*
819 * V1 controls do not have names, but cs_dsp parses the name
820 * field. It should load the file successfully and create the
821 * control.
822 * If FORTIFY_STRING is enabled it will detect a buffer overflow
823 * if cs_dsp string length walks past end of coeff name array.
824 */
825 KUNIT_EXPECT_EQ(test,
826 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
827 0);
828 ctl = list_first_entry_or_null(&priv->dsp->ctl_list, struct cs_dsp_coeff_ctl, list);
829 KUNIT_ASSERT_NOT_NULL(test, ctl);
830 KUNIT_EXPECT_EQ(test, ctl->subname_len, 0);
831 }
832
833 /* V2+ coefficient shortname exceeds length of coeff block */
834 static void wmfw_v2_coeff_shortname_exceeds_block(struct kunit *test)
835 {
836 struct cs_dsp_test *priv = test->priv;
837 struct cs_dsp_test_local *local = priv->local;
838 struct firmware *wmfw;
839 struct wmfw_header *header;
840 struct wmfw_region *region;
841 __le32 *alg_data, *coeff;
842
843 /* Create alg info block with a coefficient */
844 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
845 cs_dsp_wmfw_err_test_mock_algs[0].id,
846 "abc", "de");
847 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
848 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
849
850 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
851
852 /* Sanity-check that the good wmfw loads ok */
853 KUNIT_EXPECT_EQ(test,
854 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
855 0);
856 cs_dsp_power_down(priv->dsp);
857
858 header = (struct wmfw_header *)wmfw->data;
859 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
860 alg_data = (__force __le32 *)region->data;
861
862 /* Sanity check we're pointing at the alg header */
863 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
864
865 /* Sanity check we're pointing at the coeff block */
866 coeff = (__force __le32 *)&alg_data[4];
867 KUNIT_ASSERT_EQ(test, le32_to_cpu(coeff[0]), mock_coeff_template.mem_type << 16);
868
869 /* Add one to the shortname length */
870 coeff[2] = cpu_to_le32(le32_to_cpu(coeff[2]) + 1);
871 KUNIT_EXPECT_EQ(test,
872 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
873 -EOVERFLOW);
874
875 /* Maximum shortname length */
876 coeff[2] = cpu_to_le32(255);
877 KUNIT_EXPECT_EQ(test,
878 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
879 -EOVERFLOW);
880 }
881
882 /* V2+ coefficient fullname exceeds length of coeff block */
883 static void wmfw_v2_coeff_fullname_exceeds_block(struct kunit *test)
884 {
885 struct cs_dsp_test *priv = test->priv;
886 struct cs_dsp_test_local *local = priv->local;
887 struct firmware *wmfw;
888 struct wmfw_header *header;
889 struct wmfw_region *region;
890 __le32 *alg_data, *coeff, *fullname;
891 size_t shortlen;
892
893 /* Create alg info block with a coefficient */
894 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
895 cs_dsp_wmfw_err_test_mock_algs[0].id,
896 "abc", "de");
897 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
898 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
899
900 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
901
902 /* Sanity-check that the good wmfw loads ok */
903 KUNIT_EXPECT_EQ(test,
904 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
905 0);
906 cs_dsp_power_down(priv->dsp);
907
908 header = (struct wmfw_header *)wmfw->data;
909 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
910 alg_data = (__force __le32 *)region->data;
911
912 /* Sanity check we're pointing at the alg header */
913 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
914
915 /* Sanity check we're pointing at the coeff block */
916 coeff = (__force __le32 *)&alg_data[4];
917 KUNIT_ASSERT_EQ(test, le32_to_cpu(coeff[0]), mock_coeff_template.mem_type << 16);
918
919 /* Fullname follows the shortname rounded up to a __le32 boundary */
920 shortlen = round_up(le32_to_cpu(coeff[2]) & 0xff, sizeof(__le32));
921 fullname = &coeff[2] + (shortlen / sizeof(*coeff));
922
923 /* Fullname increases in blocks of __le32 so increase past the current __le32 */
924 fullname[0] = cpu_to_le32(round_up(le32_to_cpu(fullname[0]) + 1, sizeof(__le32)));
925 KUNIT_EXPECT_EQ(test,
926 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
927 -EOVERFLOW);
928
929 /* Maximum fullname length */
930 fullname[0] = cpu_to_le32(255);
931 KUNIT_EXPECT_EQ(test,
932 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
933 -EOVERFLOW);
934 }
935
936 /* V2+ coefficient description exceeds length of coeff block */
937 static void wmfw_v2_coeff_description_exceeds_block(struct kunit *test)
938 {
939 struct cs_dsp_test *priv = test->priv;
940 struct cs_dsp_test_local *local = priv->local;
941 struct firmware *wmfw;
942 struct wmfw_header *header;
943 struct wmfw_region *region;
944 __le32 *alg_data, *coeff, *fullname, *description;
945 size_t namelen;
946
947 /* Create alg info block with a coefficient */
948 cs_dsp_mock_wmfw_start_alg_info_block(local->wmfw_builder,
949 cs_dsp_wmfw_err_test_mock_algs[0].id,
950 "abc", "de");
951 cs_dsp_mock_wmfw_add_coeff_desc(local->wmfw_builder, &mock_coeff_template);
952 cs_dsp_mock_wmfw_end_alg_info_block(local->wmfw_builder);
953
954 wmfw = cs_dsp_mock_wmfw_get_firmware(local->wmfw_builder);
955
956 /* Sanity-check that the good wmfw loads ok */
957 KUNIT_EXPECT_EQ(test,
958 cs_dsp_power_up(priv->dsp, wmfw, "wmfw", NULL, NULL, "misc"),
959 0);
960 cs_dsp_power_down(priv->dsp);
961
962 header = (struct wmfw_header *)wmfw->data;
963 region = (struct wmfw_region *)&wmfw->data[le32_to_cpu(header->len)];
964 alg_data = (__force __le32 *)region->data;
965
966 /* Sanity check we're pointing at the alg header */
967 KUNIT_ASSERT_EQ(test, le32_to_cpu(alg_data[0]), cs_dsp_wmfw_err_test_mock_algs[0].id);
968
969 /* Sanity check we're pointing at the coeff block */
970 coeff = (__force __le32 *)&alg_data[4];
971 KUNIT_ASSERT_EQ(test, le32_to_cpu(coeff[0]), mock_coeff_template.mem_type << 16);
972
973 /* Description follows the shortname and fullname rounded up to __le32 boundaries */
974 namelen = round_up(le32_to_cpu(coeff[2]) & 0xff, sizeof(__le32));
975 fullname = &coeff[2] + (namelen / sizeof(*coeff));
976 namelen = round_up(le32_to_cpu(fullname[0]) & 0xff, sizeof(__le32));
977 description = fullname + (namelen / sizeof(*fullname));
978
979 /* Description increases in blocks of __le32 so increase past the current __le32 */
980 description[0] = cpu_to_le32(round_up(le32_to_cpu(fullname[0]) + 1, sizeof(__le32)));
981 KUNIT_EXPECT_EQ(test,
982 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
983 -EOVERFLOW);
984
985 /* Maximum description length */
986 fullname[0] = cpu_to_le32(0xffff);
987 KUNIT_EXPECT_EQ(test,
988 cs_dsp_power_up(priv->dsp, wmfw, "mock_wmfw", NULL, NULL, "misc"),
989 -EOVERFLOW);
990 }
991
992 static void cs_dsp_wmfw_err_test_exit(struct kunit *test)
993 {
994 cs_dsp_suppress_err_messages = false;
995 cs_dsp_suppress_warn_messages = false;
996 cs_dsp_suppress_info_messages = false;
997 }
998
999 static int cs_dsp_wmfw_err_test_common_init(struct kunit *test, struct cs_dsp *dsp,
1000 int wmfw_version)
1001 {
1002 struct cs_dsp_test *priv;
1003 struct cs_dsp_test_local *local;
1004 struct device *test_dev;
1005 int ret;
1006
1007 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
1008 if (!priv)
1009 return -ENOMEM;
1010
1011 local = kunit_kzalloc(test, sizeof(struct cs_dsp_test_local), GFP_KERNEL);
1012 if (!local)
1013 return -ENOMEM;
1014
1015 priv->test = test;
1016 priv->dsp = dsp;
1017 test->priv = priv;
1018 priv->local = local;
1019 local->wmfw_version = wmfw_version;
1020
1021 /* Create dummy struct device */
1022 test_dev = kunit_device_register(test, "cs_dsp_test_drv");
1023 if (IS_ERR(test_dev))
1024 return PTR_ERR(test_dev);
1025
1026 dsp->dev = get_device(test_dev);
1027 if (!dsp->dev)
1028 return -ENODEV;
1029
1030 ret = kunit_add_action_or_reset(test, _put_device_wrapper, dsp->dev);
1031 if (ret)
1032 return ret;
1033
1034 dev_set_drvdata(dsp->dev, priv);
1035
1036 /* Allocate regmap */
1037 ret = cs_dsp_mock_regmap_init(priv);
1038 if (ret)
1039 return ret;
1040
1041 /*
1042 * There must always be a XM header with at least 1 algorithm,
1043 * so create a dummy one and pre-populate XM so the wmfw doesn't
1044 * have to contain an XM blob.
1045 */
1046 local->xm_header = cs_dsp_create_mock_xm_header(priv,
1047 cs_dsp_wmfw_err_test_mock_algs,
1048 ARRAY_SIZE(cs_dsp_wmfw_err_test_mock_algs));
1049 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->xm_header);
1050 cs_dsp_mock_xm_header_write_to_regmap(local->xm_header);
1051
1052 local->wmfw_builder = cs_dsp_mock_wmfw_init(priv, local->wmfw_version);
1053 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, local->wmfw_builder);
1054
1055 /* Init cs_dsp */
1056 dsp->client_ops = kunit_kzalloc(test, sizeof(*dsp->client_ops), GFP_KERNEL);
1057 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp->client_ops);
1058
1059 switch (dsp->type) {
1060 case WMFW_ADSP2:
1061 ret = cs_dsp_adsp2_init(dsp);
1062 break;
1063 case WMFW_HALO:
1064 ret = cs_dsp_halo_init(dsp);
1065 break;
1066 default:
1067 KUNIT_FAIL(test, "Untested DSP type %d\n", dsp->type);
1068 return -EINVAL;
1069 }
1070
1071 if (ret)
1072 return ret;
1073
1074 /* Automatically call cs_dsp_remove() when test case ends */
1075 ret = kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp);
1076 if (ret)
1077 return ret;
1078
1079 /*
1080 * Testing error conditions can produce a lot of log output
1081 * from cs_dsp error messages, so suppress messages.
1082 */
1083 cs_dsp_suppress_err_messages = true;
1084 cs_dsp_suppress_warn_messages = true;
1085 cs_dsp_suppress_info_messages = true;
1086
1087 return 0;
1088 }
1089
1090 static int cs_dsp_wmfw_err_test_halo_init(struct kunit *test)
1091 {
1092 struct cs_dsp *dsp;
1093
1094 /* Fill in cs_dsp and initialize */
1095 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
1096 if (!dsp)
1097 return -ENOMEM;
1098
1099 dsp->num = 1;
1100 dsp->type = WMFW_HALO;
1101 dsp->mem = cs_dsp_mock_halo_dsp1_regions;
1102 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_halo_dsp1_region_sizes);
1103 dsp->base = cs_dsp_mock_halo_core_base;
1104 dsp->base_sysinfo = cs_dsp_mock_halo_sysinfo_base;
1105
1106 return cs_dsp_wmfw_err_test_common_init(test, dsp, 3);
1107 }
1108
1109 static int cs_dsp_wmfw_err_test_adsp2_32bit_init(struct kunit *test, int wmfw_ver)
1110 {
1111 struct cs_dsp *dsp;
1112
1113 /* Fill in cs_dsp and initialize */
1114 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
1115 if (!dsp)
1116 return -ENOMEM;
1117
1118 dsp->num = 1;
1119 dsp->type = WMFW_ADSP2;
1120 dsp->rev = 1;
1121 dsp->mem = cs_dsp_mock_adsp2_32bit_dsp1_regions;
1122 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_32bit_dsp1_region_sizes);
1123 dsp->base = cs_dsp_mock_adsp2_32bit_sysbase;
1124
1125 return cs_dsp_wmfw_err_test_common_init(test, dsp, wmfw_ver);
1126 }
1127
1128 static int cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0_init(struct kunit *test)
1129 {
1130 return cs_dsp_wmfw_err_test_adsp2_32bit_init(test, 0);
1131 }
1132
1133 static int cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1_init(struct kunit *test)
1134 {
1135 return cs_dsp_wmfw_err_test_adsp2_32bit_init(test, 1);
1136 }
1137
1138 static int cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2_init(struct kunit *test)
1139 {
1140 return cs_dsp_wmfw_err_test_adsp2_32bit_init(test, 2);
1141 }
1142
1143 static int cs_dsp_wmfw_err_test_adsp2_16bit_init(struct kunit *test, int wmfw_ver)
1144 {
1145 struct cs_dsp *dsp;
1146
1147 /* Fill in cs_dsp and initialize */
1148 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
1149 if (!dsp)
1150 return -ENOMEM;
1151
1152 dsp->num = 1;
1153 dsp->type = WMFW_ADSP2;
1154 dsp->rev = 0;
1155 dsp->mem = cs_dsp_mock_adsp2_16bit_dsp1_regions;
1156 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_16bit_dsp1_region_sizes);
1157 dsp->base = cs_dsp_mock_adsp2_16bit_sysbase;
1158
1159 return cs_dsp_wmfw_err_test_common_init(test, dsp, wmfw_ver);
1160 }
1161
1162 static int cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0_init(struct kunit *test)
1163 {
1164 return cs_dsp_wmfw_err_test_adsp2_16bit_init(test, 0);
1165 }
1166
1167 static int cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1_init(struct kunit *test)
1168 {
1169 return cs_dsp_wmfw_err_test_adsp2_16bit_init(test, 1);
1170 }
1171
1172 static int cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2_init(struct kunit *test)
1173 {
1174 return cs_dsp_wmfw_err_test_adsp2_16bit_init(test, 2);
1175 }
1176
1177 static void cs_dsp_wmfw_err_block_types_desc(const struct cs_dsp_wmfw_test_param *param,
1178 char *desc)
1179 {
1180 snprintf(desc, KUNIT_PARAM_DESC_SIZE, "block_type:%#x", param->block_type);
1181 }
1182
1183 static const struct cs_dsp_wmfw_test_param wmfw_valid_block_types_adsp2_cases[] = {
1184 { .block_type = WMFW_INFO_TEXT },
1185 { .block_type = WMFW_ADSP2_PM },
1186 { .block_type = WMFW_ADSP2_YM },
1187 };
1188
1189 KUNIT_ARRAY_PARAM(wmfw_valid_block_types_adsp2,
1190 wmfw_valid_block_types_adsp2_cases,
1191 cs_dsp_wmfw_err_block_types_desc);
1192
1193 static const struct cs_dsp_wmfw_test_param wmfw_valid_block_types_halo_cases[] = {
1194 { .block_type = WMFW_INFO_TEXT },
1195 { .block_type = WMFW_HALO_PM_PACKED },
1196 { .block_type = WMFW_ADSP2_YM },
1197 };
1198
1199 KUNIT_ARRAY_PARAM(wmfw_valid_block_types_halo,
1200 wmfw_valid_block_types_halo_cases,
1201 cs_dsp_wmfw_err_block_types_desc);
1202
1203 static const struct cs_dsp_wmfw_test_param wmfw_invalid_block_types_cases[] = {
1204 { .block_type = 0x33 },
1205 { .block_type = 0xf5 },
1206 { .block_type = 0xc0 },
1207 };
1208
1209 KUNIT_ARRAY_PARAM(wmfw_invalid_block_types,
1210 wmfw_invalid_block_types_cases,
1211 cs_dsp_wmfw_err_block_types_desc);
1212
1213 static struct kunit_case cs_dsp_wmfw_err_test_cases_v0[] = {
1214 KUNIT_CASE(wmfw_load_with_unknown_blocks),
1215 KUNIT_CASE(wmfw_err_wrong_magic),
1216 KUNIT_CASE(wmfw_err_too_short_for_header),
1217 KUNIT_CASE(wmfw_err_bad_header_length),
1218 KUNIT_CASE(wmfw_err_bad_core_type),
1219
1220 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_valid_block_types_adsp2_gen_params),
1221 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1222 KUNIT_CASE_PARAM(wmfw_too_short_for_block_payload, wmfw_valid_block_types_adsp2_gen_params),
1223 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1224 KUNIT_CASE_PARAM(wmfw_block_payload_len_garbage, wmfw_valid_block_types_adsp2_gen_params),
1225 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1226
1227 { } /* terminator */
1228 };
1229
1230 static struct kunit_case cs_dsp_wmfw_err_test_cases_v1[] = {
1231 KUNIT_CASE(wmfw_load_with_unknown_blocks),
1232 KUNIT_CASE(wmfw_err_wrong_magic),
1233 KUNIT_CASE(wmfw_err_too_short_for_header),
1234 KUNIT_CASE(wmfw_err_bad_header_length),
1235 KUNIT_CASE(wmfw_err_bad_core_type),
1236
1237 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_valid_block_types_adsp2_gen_params),
1238 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1239 KUNIT_CASE_PARAM(wmfw_too_short_for_block_payload, wmfw_valid_block_types_adsp2_gen_params),
1240 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1241 KUNIT_CASE_PARAM(wmfw_block_payload_len_garbage, wmfw_valid_block_types_adsp2_gen_params),
1242 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1243
1244 KUNIT_CASE(wmfw_too_short_for_alg_header),
1245 KUNIT_CASE(wmfw_v1_alg_name_unterminated),
1246 KUNIT_CASE(wmfw_v1_coeff_count_exceeds_block),
1247 KUNIT_CASE(wmfw_v1_coeff_name_unterminated),
1248
1249 { } /* terminator */
1250 };
1251
1252 static struct kunit_case cs_dsp_wmfw_err_test_cases_v2[] = {
1253 KUNIT_CASE(wmfw_load_with_unknown_blocks),
1254 KUNIT_CASE(wmfw_err_wrong_magic),
1255 KUNIT_CASE(wmfw_err_too_short_for_header),
1256 KUNIT_CASE(wmfw_err_bad_header_length),
1257 KUNIT_CASE(wmfw_err_bad_core_type),
1258
1259 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_valid_block_types_adsp2_gen_params),
1260 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1261 KUNIT_CASE_PARAM(wmfw_too_short_for_block_payload, wmfw_valid_block_types_adsp2_gen_params),
1262 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1263 KUNIT_CASE_PARAM(wmfw_block_payload_len_garbage, wmfw_valid_block_types_adsp2_gen_params),
1264 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1265
1266 KUNIT_CASE(wmfw_too_short_for_alg_header),
1267 KUNIT_CASE(wmfw_v2_alg_name_exceeds_block),
1268 KUNIT_CASE(wmfw_v2_alg_description_exceeds_block),
1269 KUNIT_CASE(wmfw_v2_coeff_count_exceeds_block),
1270 KUNIT_CASE(wmfw_v2_coeff_block_size_exceeds_block),
1271 KUNIT_CASE(wmfw_v2_coeff_shortname_exceeds_block),
1272 KUNIT_CASE(wmfw_v2_coeff_fullname_exceeds_block),
1273 KUNIT_CASE(wmfw_v2_coeff_description_exceeds_block),
1274
1275 { } /* terminator */
1276 };
1277
1278 static struct kunit_case cs_dsp_wmfw_err_test_cases_v3[] = {
1279 KUNIT_CASE(wmfw_load_with_unknown_blocks),
1280 KUNIT_CASE(wmfw_err_wrong_magic),
1281 KUNIT_CASE(wmfw_err_too_short_for_header),
1282 KUNIT_CASE(wmfw_err_bad_header_length),
1283 KUNIT_CASE(wmfw_err_bad_core_type),
1284
1285 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_valid_block_types_halo_gen_params),
1286 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1287 KUNIT_CASE_PARAM(wmfw_too_short_for_block_payload, wmfw_valid_block_types_halo_gen_params),
1288 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1289 KUNIT_CASE_PARAM(wmfw_block_payload_len_garbage, wmfw_valid_block_types_halo_gen_params),
1290 KUNIT_CASE_PARAM(wmfw_too_short_for_block_header, wmfw_invalid_block_types_gen_params),
1291
1292 KUNIT_CASE(wmfw_too_short_for_alg_header),
1293 KUNIT_CASE(wmfw_v2_alg_name_exceeds_block),
1294 KUNIT_CASE(wmfw_v2_alg_description_exceeds_block),
1295 KUNIT_CASE(wmfw_v2_coeff_count_exceeds_block),
1296 KUNIT_CASE(wmfw_v2_coeff_block_size_exceeds_block),
1297 KUNIT_CASE(wmfw_v2_coeff_shortname_exceeds_block),
1298 KUNIT_CASE(wmfw_v2_coeff_fullname_exceeds_block),
1299 KUNIT_CASE(wmfw_v2_coeff_description_exceeds_block),
1300
1301 { } /* terminator */
1302 };
1303
1304 static struct kunit_suite cs_dsp_wmfw_err_test_halo = {
1305 .name = "cs_dsp_wmfwV3_err_halo",
1306 .init = cs_dsp_wmfw_err_test_halo_init,
1307 .exit = cs_dsp_wmfw_err_test_exit,
1308 .test_cases = cs_dsp_wmfw_err_test_cases_v3,
1309 };
1310
1311 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0 = {
1312 .name = "cs_dsp_wmfwV0_err_adsp2_32bit",
1313 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0_init,
1314 .exit = cs_dsp_wmfw_err_test_exit,
1315 .test_cases = cs_dsp_wmfw_err_test_cases_v0,
1316 };
1317
1318 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1 = {
1319 .name = "cs_dsp_wmfwV1_err_adsp2_32bit",
1320 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1_init,
1321 .exit = cs_dsp_wmfw_err_test_exit,
1322 .test_cases = cs_dsp_wmfw_err_test_cases_v1,
1323 };
1324
1325 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2 = {
1326 .name = "cs_dsp_wmfwV2_err_adsp2_32bit",
1327 .init = cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2_init,
1328 .exit = cs_dsp_wmfw_err_test_exit,
1329 .test_cases = cs_dsp_wmfw_err_test_cases_v2,
1330 };
1331
1332 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0 = {
1333 .name = "cs_dsp_wmfwV0_err_adsp2_16bit",
1334 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0_init,
1335 .exit = cs_dsp_wmfw_err_test_exit,
1336 .test_cases = cs_dsp_wmfw_err_test_cases_v0,
1337 };
1338
1339 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1 = {
1340 .name = "cs_dsp_wmfwV1_err_adsp2_16bit",
1341 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1_init,
1342 .exit = cs_dsp_wmfw_err_test_exit,
1343 .test_cases = cs_dsp_wmfw_err_test_cases_v1,
1344 };
1345
1346 static struct kunit_suite cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2 = {
1347 .name = "cs_dsp_wmfwV2_err_adsp2_16bit",
1348 .init = cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2_init,
1349 .exit = cs_dsp_wmfw_err_test_exit,
1350 .test_cases = cs_dsp_wmfw_err_test_cases_v2,
1351 };
1352
1353 kunit_test_suites(&cs_dsp_wmfw_err_test_halo,
1354 &cs_dsp_wmfw_err_test_adsp2_32bit_wmfw0,
1355 &cs_dsp_wmfw_err_test_adsp2_32bit_wmfw1,
1356 &cs_dsp_wmfw_err_test_adsp2_32bit_wmfw2,
1357 &cs_dsp_wmfw_err_test_adsp2_16bit_wmfw0,
1358 &cs_dsp_wmfw_err_test_adsp2_16bit_wmfw1,
1359 &cs_dsp_wmfw_err_test_adsp2_16bit_wmfw2);