1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // KUnit test for the Cirrus common amplifier library.
4 //
5 // Copyright (C) 2024 Cirrus Logic, Inc. and
6 // Cirrus Logic International Semiconductor Ltd.
7
8 #include <kunit/resource.h>
9 #include <kunit/test.h>
10 #include <kunit/test-bug.h>
11 #include <kunit/static_stub.h>
12 #include <linux/device/faux.h>
13 #include <linux/firmware/cirrus/cs_dsp.h>
14 #include <linux/firmware/cirrus/wmfw.h>
15 #include <linux/gpio/driver.h>
16 #include <linux/list.h>
17 #include <linux/module.h>
18 #include <linux/overflow.h>
19 #include <linux/platform_device.h>
20 #include <linux/random.h>
21 #include <sound/cs-amp-lib.h>
22
23 #define CIRRUS_LOGIC_CALIBRATION_EFI_NAME L"CirrusSmartAmpCalibrationData"
24 #define CIRRUS_LOGIC_CALIBRATION_EFI_GUID \
25 EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d, 0x93, 0xfe, 0x5a, 0xa3, 0x5d, 0xb3)
26
27 #define LENOVO_SPEAKER_ID_EFI_NAME L"SdwSpeaker"
28 #define LENOVO_SPEAKER_ID_EFI_GUID \
29 EFI_GUID(0x48df970e, 0xe27f, 0x460a, 0xb5, 0x86, 0x77, 0x19, 0x80, 0x1d, 0x92, 0x82)
30
31 #define HP_SPEAKER_ID_EFI_NAME L"HPSpeakerID"
32 #define HP_SPEAKER_ID_EFI_GUID \
33 EFI_GUID(0xc49593a4, 0xd099, 0x419b, 0xa2, 0xc3, 0x67, 0xe9, 0x80, 0xe6, 0x1d, 0x1e)
34
35 #define HP_CALIBRATION_EFI_NAME L"SmartAmpCalibrationData"
36 #define HP_CALIBRATION_EFI_GUID \
37 EFI_GUID(0x53559579, 0x8753, 0x4f5c, 0x91, 0x30, 0xe8, 0x2a, 0xcf, 0xb8, 0xd8, 0x93)
38
39 KUNIT_DEFINE_ACTION_WRAPPER(faux_device_destroy_wrapper, faux_device_destroy,
40 struct faux_device *)
41
42 struct cs_amp_lib_test_priv {
43 struct faux_device *amp_dev;
44
45 struct cirrus_amp_efi_data *cal_blob;
46 struct list_head ctl_write_list;
47 u32 efi_attr;
48 };
49
50 struct cs_amp_lib_test_ctl_write_entry {
51 struct list_head list;
52 unsigned int value;
53 char name[16];
54 };
55
56 struct cs_amp_lib_test_param {
57 int num_amps;
58 int amp_index;
59 };
60
cs_amp_lib_test_cal_blob_dup(struct kunit * test)61 static struct cirrus_amp_efi_data *cs_amp_lib_test_cal_blob_dup(struct kunit *test)
62 {
63 struct cs_amp_lib_test_priv *priv = test->priv;
64 struct cirrus_amp_efi_data *temp;
65
66 KUNIT_ASSERT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
67 priv->cal_blob->size);
68 temp = kunit_kmalloc(test, priv->cal_blob->size, GFP_KERNEL);
69 KUNIT_ASSERT_NOT_NULL(test, temp);
70 memcpy(temp, priv->cal_blob, priv->cal_blob->size);
71
72 return temp;
73 }
74
cs_amp_lib_test_init_dummy_cal_blob(struct kunit * test,int num_amps)75 static void cs_amp_lib_test_init_dummy_cal_blob(struct kunit *test, int num_amps)
76 {
77 struct cs_amp_lib_test_priv *priv = test->priv;
78 unsigned int blob_size;
79 int i;
80
81 blob_size = struct_size(priv->cal_blob, data, num_amps);
82
83 priv->cal_blob = kunit_kzalloc(test, blob_size, GFP_KERNEL);
84 KUNIT_ASSERT_NOT_NULL(test, priv->cal_blob);
85
86 priv->cal_blob->size = blob_size;
87 priv->cal_blob->count = num_amps;
88
89 get_random_bytes(priv->cal_blob->data, flex_array_size(priv->cal_blob, data, num_amps));
90
91 /* Ensure all timestamps are non-zero to mark the entry valid. */
92 for (i = 0; i < num_amps; i++)
93 priv->cal_blob->data[i].calTime[0] |= 1;
94
95 /*
96 * Ensure that all UIDs are non-zero and unique.
97 * Make both words non-zero and not equal values, so that
98 * tests can verify that both words were checked or changed.
99 */
100 for (i = 0; i < num_amps; i++) {
101 *(u8 *)&priv->cal_blob->data[i].calTarget[0] = i + 1;
102 *(u8 *)&priv->cal_blob->data[i].calTarget[1] = i;
103 }
104 }
105
cs_amp_lib_test_get_target_uid(struct kunit * test)106 static u64 cs_amp_lib_test_get_target_uid(struct kunit *test)
107 {
108 struct cs_amp_lib_test_priv *priv = test->priv;
109 const struct cs_amp_lib_test_param *param = test->param_value;
110 u64 uid;
111
112 uid = priv->cal_blob->data[param->amp_index].calTarget[1];
113 uid <<= 32;
114 uid |= priv->cal_blob->data[param->amp_index].calTarget[0];
115
116 return uid;
117 }
118
119 /* Redirected get_efi_variable to simulate that the file is too short */
cs_amp_lib_test_get_efi_variable_nohead(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)120 static efi_status_t cs_amp_lib_test_get_efi_variable_nohead(efi_char16_t *name,
121 efi_guid_t *guid,
122 u32 *returned_attr,
123 unsigned long *size,
124 void *buf)
125 {
126 if (!buf) {
127 *size = offsetof(struct cirrus_amp_efi_data, data) - 1;
128 return EFI_BUFFER_TOO_SMALL;
129 }
130
131 return EFI_NOT_FOUND;
132 }
133
134 /* Should return -EOVERFLOW if the header is larger than the EFI data */
cs_amp_lib_test_cal_data_too_short_test(struct kunit * test)135 static void cs_amp_lib_test_cal_data_too_short_test(struct kunit *test)
136 {
137 struct cs_amp_lib_test_priv *priv = test->priv;
138 struct cirrus_amp_cal_data result_data;
139 int ret;
140
141 /* Redirect calls to get EFI data */
142 kunit_activate_static_stub(test,
143 cs_amp_test_hooks->get_efi_variable,
144 cs_amp_lib_test_get_efi_variable_nohead);
145
146 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
147 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW);
148 }
149
150 /* Redirected get_efi_variable to simulate that the count is larger than the file */
cs_amp_lib_test_get_efi_variable_bad_count(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)151 static efi_status_t cs_amp_lib_test_get_efi_variable_bad_count(efi_char16_t *name,
152 efi_guid_t *guid,
153 u32 *returned_attr,
154 unsigned long *size,
155 void *buf)
156 {
157 struct kunit *test = kunit_get_current_test();
158 struct cs_amp_lib_test_priv *priv = test->priv;
159
160 if (!buf) {
161 /*
162 * Return a size that is shorter than required for the
163 * declared number of entries.
164 */
165 *size = priv->cal_blob->size - 1;
166 return EFI_BUFFER_TOO_SMALL;
167 }
168
169 memcpy(buf, priv->cal_blob, priv->cal_blob->size - 1);
170
171 return EFI_SUCCESS;
172 }
173
174 /* Should return -EOVERFLOW if the entry count is larger than the EFI data */
cs_amp_lib_test_cal_count_too_big_test(struct kunit * test)175 static void cs_amp_lib_test_cal_count_too_big_test(struct kunit *test)
176 {
177 struct cs_amp_lib_test_priv *priv = test->priv;
178 struct cirrus_amp_cal_data result_data;
179 int ret;
180
181 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
182
183 /* Redirect calls to get EFI data */
184 kunit_activate_static_stub(test,
185 cs_amp_test_hooks->get_efi_variable,
186 cs_amp_lib_test_get_efi_variable_bad_count);
187
188 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
189 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW);
190 }
191
192 /* Redirected get_efi_variable to simulate that the variable not found */
cs_amp_lib_test_get_efi_variable_none(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)193 static efi_status_t cs_amp_lib_test_get_efi_variable_none(efi_char16_t *name,
194 efi_guid_t *guid,
195 u32 *returned_attr,
196 unsigned long *size,
197 void *buf)
198 {
199 return EFI_NOT_FOUND;
200 }
201
202 /* If EFI doesn't contain a cal data variable the result should be -ENOENT */
cs_amp_lib_test_no_cal_data_test(struct kunit * test)203 static void cs_amp_lib_test_no_cal_data_test(struct kunit *test)
204 {
205 struct cs_amp_lib_test_priv *priv = test->priv;
206 struct cirrus_amp_cal_data result_data;
207 int ret;
208
209 /* Redirect calls to get EFI data */
210 kunit_activate_static_stub(test,
211 cs_amp_test_hooks->get_efi_variable,
212 cs_amp_lib_test_get_efi_variable_none);
213
214 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
215 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
216 }
217
218 /* Redirected get_efi_variable to simulate reading a cal data blob */
cs_amp_lib_test_get_efi_variable(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)219 static efi_status_t cs_amp_lib_test_get_efi_variable(efi_char16_t *name,
220 efi_guid_t *guid,
221 u32 *returned_attr,
222 unsigned long *size,
223 void *buf)
224 {
225 static const efi_char16_t expected_name[] = CIRRUS_LOGIC_CALIBRATION_EFI_NAME;
226 static const efi_guid_t expected_guid = CIRRUS_LOGIC_CALIBRATION_EFI_GUID;
227 struct kunit *test = kunit_get_current_test();
228 struct cs_amp_lib_test_priv *priv = test->priv;
229
230 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, name);
231 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, guid);
232 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, size);
233
234 if (memcmp(name, expected_name, sizeof(expected_name)) ||
235 efi_guidcmp(*guid, expected_guid))
236 return -EFI_NOT_FOUND;
237
238 if (!buf) {
239 *size = priv->cal_blob->size;
240 return EFI_BUFFER_TOO_SMALL;
241 }
242
243 KUNIT_ASSERT_GE_MSG(test, ksize(buf), priv->cal_blob->size, "Buffer to small");
244
245 memcpy(buf, priv->cal_blob, priv->cal_blob->size);
246
247 if (returned_attr) {
248 if (priv->efi_attr)
249 *returned_attr = priv->efi_attr;
250 else
251 *returned_attr = EFI_VARIABLE_NON_VOLATILE |
252 EFI_VARIABLE_BOOTSERVICE_ACCESS |
253 EFI_VARIABLE_RUNTIME_ACCESS;
254 }
255
256 return EFI_SUCCESS;
257 }
258
259 #define CS_AMP_LIB_ZERO_FILLED_BLOB_SIZE \
260 struct_size_t(struct cirrus_amp_efi_data, data, 8)
261
262 /* Redirected get_efi_variable to simulate reading a prealloced zero-filled blob */
cs_amp_lib_test_get_efi_variable_all_zeros(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)263 static efi_status_t cs_amp_lib_test_get_efi_variable_all_zeros(efi_char16_t *name,
264 efi_guid_t *guid,
265 u32 *returned_attr,
266 unsigned long *size,
267 void *buf)
268 {
269 static const efi_char16_t expected_name[] = CIRRUS_LOGIC_CALIBRATION_EFI_NAME;
270 static const efi_guid_t expected_guid = CIRRUS_LOGIC_CALIBRATION_EFI_GUID;
271 struct kunit *test = kunit_get_current_test();
272 struct cs_amp_lib_test_priv *priv = test->priv;
273
274 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, name);
275 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, guid);
276
277 if (memcmp(name, expected_name, sizeof(expected_name)) ||
278 efi_guidcmp(*guid, expected_guid))
279 return -EFI_NOT_FOUND;
280
281 if (!buf) {
282 *size = CS_AMP_LIB_ZERO_FILLED_BLOB_SIZE;
283 return EFI_BUFFER_TOO_SMALL;
284 }
285
286 KUNIT_ASSERT_EQ(test, *size, struct_size(priv->cal_blob, data, 8));
287 priv->cal_blob = kunit_kzalloc(test, CS_AMP_LIB_ZERO_FILLED_BLOB_SIZE, GFP_KERNEL);
288 KUNIT_ASSERT_NOT_NULL(test, priv->cal_blob);
289 memset(buf, 0, CS_AMP_LIB_ZERO_FILLED_BLOB_SIZE);
290
291 if (returned_attr) {
292 if (priv->efi_attr)
293 *returned_attr = priv->efi_attr;
294 else
295 *returned_attr = EFI_VARIABLE_NON_VOLATILE |
296 EFI_VARIABLE_BOOTSERVICE_ACCESS |
297 EFI_VARIABLE_RUNTIME_ACCESS;
298 }
299
300 return EFI_SUCCESS;
301 }
302
cs_amp_lib_test_get_hp_cal_efi_variable(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)303 static efi_status_t cs_amp_lib_test_get_hp_cal_efi_variable(efi_char16_t *name,
304 efi_guid_t *guid,
305 u32 *returned_attr,
306 unsigned long *size,
307 void *buf)
308 {
309 static const efi_char16_t expected_name[] = L"SmartAmpCalibrationData";
310 static const efi_guid_t expected_guid =
311 EFI_GUID(0x53559579, 0x8753, 0x4f5c, 0x91, 0x30, 0xe8, 0x2a, 0xcf, 0xb8, 0xd8, 0x93);
312 struct kunit *test = kunit_get_current_test();
313 struct cs_amp_lib_test_priv *priv = test->priv;
314
315 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, name);
316 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, guid);
317 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, size);
318
319 if (memcmp(name, expected_name, sizeof(expected_name)) ||
320 efi_guidcmp(*guid, expected_guid))
321 return -EFI_NOT_FOUND;
322
323 if (!buf) {
324 *size = priv->cal_blob->size;
325 return EFI_BUFFER_TOO_SMALL;
326 }
327
328 KUNIT_ASSERT_GE_MSG(test, ksize(buf), priv->cal_blob->size, "Buffer to small");
329
330 memcpy(buf, priv->cal_blob, priv->cal_blob->size);
331
332 if (returned_attr) {
333 *returned_attr = EFI_VARIABLE_NON_VOLATILE |
334 EFI_VARIABLE_BOOTSERVICE_ACCESS |
335 EFI_VARIABLE_RUNTIME_ACCESS;
336 }
337
338 return EFI_SUCCESS;
339 }
340
341 /* Get cal data block from HP variable. */
cs_amp_lib_test_get_hp_efi_cal(struct kunit * test)342 static void cs_amp_lib_test_get_hp_efi_cal(struct kunit *test)
343 {
344 struct cs_amp_lib_test_priv *priv = test->priv;
345 struct cirrus_amp_cal_data result_data;
346 int ret;
347
348 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
349
350 kunit_activate_static_stub(test,
351 cs_amp_test_hooks->get_efi_variable,
352 cs_amp_lib_test_get_hp_cal_efi_variable);
353
354 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
355 KUNIT_EXPECT_EQ(test, ret, 0);
356
357 KUNIT_EXPECT_MEMEQ(test, &result_data, &priv->cal_blob->data[0], sizeof(result_data));
358 }
359
360 /* Get cal data block for a given amp, matched by target UID. */
cs_amp_lib_test_get_efi_cal_by_uid_test(struct kunit * test)361 static void cs_amp_lib_test_get_efi_cal_by_uid_test(struct kunit *test)
362 {
363 struct cs_amp_lib_test_priv *priv = test->priv;
364 const struct cs_amp_lib_test_param *param = test->param_value;
365 struct cirrus_amp_cal_data result_data;
366 u64 target_uid;
367 int ret;
368
369 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
370
371 /* Redirect calls to get EFI data */
372 kunit_activate_static_stub(test,
373 cs_amp_test_hooks->get_efi_variable,
374 cs_amp_lib_test_get_efi_variable);
375
376 target_uid = cs_amp_lib_test_get_target_uid(test);
377 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid, -1, &result_data);
378 KUNIT_EXPECT_EQ(test, ret, 0);
379
380 KUNIT_EXPECT_EQ(test, result_data.calTarget[0], target_uid & 0xFFFFFFFFULL);
381 KUNIT_EXPECT_EQ(test, result_data.calTarget[1], target_uid >> 32);
382 KUNIT_EXPECT_EQ(test, result_data.calTime[0],
383 priv->cal_blob->data[param->amp_index].calTime[0]);
384 KUNIT_EXPECT_EQ(test, result_data.calTime[1],
385 priv->cal_blob->data[param->amp_index].calTime[1]);
386 KUNIT_EXPECT_EQ(test, result_data.calAmbient,
387 priv->cal_blob->data[param->amp_index].calAmbient);
388 KUNIT_EXPECT_EQ(test, result_data.calStatus,
389 priv->cal_blob->data[param->amp_index].calStatus);
390 KUNIT_EXPECT_EQ(test, result_data.calR,
391 priv->cal_blob->data[param->amp_index].calR);
392 }
393
394 /* Get cal data block for a given amp index without checking target UID. */
cs_amp_lib_test_get_efi_cal_by_index_unchecked_test(struct kunit * test)395 static void cs_amp_lib_test_get_efi_cal_by_index_unchecked_test(struct kunit *test)
396 {
397 struct cs_amp_lib_test_priv *priv = test->priv;
398 const struct cs_amp_lib_test_param *param = test->param_value;
399 struct cirrus_amp_cal_data result_data;
400 int ret;
401
402 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
403
404 /* Redirect calls to get EFI data */
405 kunit_activate_static_stub(test,
406 cs_amp_test_hooks->get_efi_variable,
407 cs_amp_lib_test_get_efi_variable);
408
409 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0,
410 param->amp_index, &result_data);
411 KUNIT_EXPECT_EQ(test, ret, 0);
412
413 KUNIT_EXPECT_EQ(test, result_data.calTime[0],
414 priv->cal_blob->data[param->amp_index].calTime[0]);
415 KUNIT_EXPECT_EQ(test, result_data.calTime[1],
416 priv->cal_blob->data[param->amp_index].calTime[1]);
417 KUNIT_EXPECT_EQ(test, result_data.calAmbient,
418 priv->cal_blob->data[param->amp_index].calAmbient);
419 KUNIT_EXPECT_EQ(test, result_data.calStatus,
420 priv->cal_blob->data[param->amp_index].calStatus);
421 KUNIT_EXPECT_EQ(test, result_data.calR,
422 priv->cal_blob->data[param->amp_index].calR);
423 }
424
425 /* Get cal data block for a given amp index with checked target UID. */
cs_amp_lib_test_get_efi_cal_by_index_checked_test(struct kunit * test)426 static void cs_amp_lib_test_get_efi_cal_by_index_checked_test(struct kunit *test)
427 {
428 struct cs_amp_lib_test_priv *priv = test->priv;
429 const struct cs_amp_lib_test_param *param = test->param_value;
430 struct cirrus_amp_cal_data result_data;
431 u64 target_uid;
432 int ret;
433
434 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
435
436 /* Redirect calls to get EFI data */
437 kunit_activate_static_stub(test,
438 cs_amp_test_hooks->get_efi_variable,
439 cs_amp_lib_test_get_efi_variable);
440
441 target_uid = cs_amp_lib_test_get_target_uid(test);
442 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid,
443 param->amp_index, &result_data);
444 KUNIT_EXPECT_EQ(test, ret, 0);
445
446 KUNIT_EXPECT_EQ(test, result_data.calTime[0],
447 priv->cal_blob->data[param->amp_index].calTime[0]);
448 KUNIT_EXPECT_EQ(test, result_data.calTime[1],
449 priv->cal_blob->data[param->amp_index].calTime[1]);
450 KUNIT_EXPECT_EQ(test, result_data.calAmbient,
451 priv->cal_blob->data[param->amp_index].calAmbient);
452 KUNIT_EXPECT_EQ(test, result_data.calStatus,
453 priv->cal_blob->data[param->amp_index].calStatus);
454 KUNIT_EXPECT_EQ(test, result_data.calR,
455 priv->cal_blob->data[param->amp_index].calR);
456 }
457
458 /*
459 * Get cal data block for a given amp index with checked target UID.
460 * The UID does not match so the result should be -ENOENT.
461 */
cs_amp_lib_test_get_efi_cal_by_index_uid_mismatch_test(struct kunit * test)462 static void cs_amp_lib_test_get_efi_cal_by_index_uid_mismatch_test(struct kunit *test)
463 {
464 struct cs_amp_lib_test_priv *priv = test->priv;
465 const struct cs_amp_lib_test_param *param = test->param_value;
466 struct cirrus_amp_cal_data result_data;
467 u64 target_uid;
468 int ret;
469
470 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
471
472 /* Redirect calls to get EFI data */
473 kunit_activate_static_stub(test,
474 cs_amp_test_hooks->get_efi_variable,
475 cs_amp_lib_test_get_efi_variable);
476
477 /* Get a target UID that won't match the entry */
478 target_uid = ~cs_amp_lib_test_get_target_uid(test);
479 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid,
480 param->amp_index, &result_data);
481 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
482 }
483
484 /*
485 * Get cal data block for a given amp, where the cal data does not
486 * specify calTarget so the lookup falls back to using the index
487 */
cs_amp_lib_test_get_efi_cal_by_index_fallback_test(struct kunit * test)488 static void cs_amp_lib_test_get_efi_cal_by_index_fallback_test(struct kunit *test)
489 {
490 struct cs_amp_lib_test_priv *priv = test->priv;
491 const struct cs_amp_lib_test_param *param = test->param_value;
492 struct cirrus_amp_cal_data result_data;
493 static const u64 bad_target_uid = 0xBADCA100BABABABAULL;
494 int i, ret;
495
496 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
497
498 /* Make all the target values zero so they are ignored */
499 for (i = 0; i < priv->cal_blob->count; ++i) {
500 priv->cal_blob->data[i].calTarget[0] = 0;
501 priv->cal_blob->data[i].calTarget[1] = 0;
502 }
503
504 /* Redirect calls to get EFI data */
505 kunit_activate_static_stub(test,
506 cs_amp_test_hooks->get_efi_variable,
507 cs_amp_lib_test_get_efi_variable);
508
509 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid,
510 param->amp_index, &result_data);
511 KUNIT_EXPECT_EQ(test, ret, 0);
512
513 KUNIT_EXPECT_EQ(test, result_data.calTime[0],
514 priv->cal_blob->data[param->amp_index].calTime[0]);
515 KUNIT_EXPECT_EQ(test, result_data.calTime[1],
516 priv->cal_blob->data[param->amp_index].calTime[1]);
517 KUNIT_EXPECT_EQ(test, result_data.calAmbient,
518 priv->cal_blob->data[param->amp_index].calAmbient);
519 KUNIT_EXPECT_EQ(test, result_data.calStatus,
520 priv->cal_blob->data[param->amp_index].calStatus);
521 KUNIT_EXPECT_EQ(test, result_data.calR,
522 priv->cal_blob->data[param->amp_index].calR);
523 }
524
525 /*
526 * If the target UID isn't present in the cal data, and there isn't an
527 * index to fall back do, the result should be -ENOENT.
528 */
cs_amp_lib_test_get_efi_cal_uid_not_found_noindex_test(struct kunit * test)529 static void cs_amp_lib_test_get_efi_cal_uid_not_found_noindex_test(struct kunit *test)
530 {
531 struct cs_amp_lib_test_priv *priv = test->priv;
532 struct cirrus_amp_cal_data result_data;
533 static const u64 bad_target_uid = 0xBADCA100BABABABAULL;
534 int i, ret;
535
536 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
537
538 /* Make all the target values != bad_target_uid */
539 for (i = 0; i < priv->cal_blob->count; ++i) {
540 priv->cal_blob->data[i].calTarget[0] &= ~(bad_target_uid & 0xFFFFFFFFULL);
541 priv->cal_blob->data[i].calTarget[1] &= ~(bad_target_uid >> 32);
542 }
543
544 /* Redirect calls to get EFI data */
545 kunit_activate_static_stub(test,
546 cs_amp_test_hooks->get_efi_variable,
547 cs_amp_lib_test_get_efi_variable);
548
549 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid, -1,
550 &result_data);
551 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
552 }
553
554 /*
555 * If the target UID isn't present in the cal data, and the index is
556 * out of range, the result should be -ENOENT.
557 */
cs_amp_lib_test_get_efi_cal_uid_not_found_index_not_found_test(struct kunit * test)558 static void cs_amp_lib_test_get_efi_cal_uid_not_found_index_not_found_test(struct kunit *test)
559 {
560 struct cs_amp_lib_test_priv *priv = test->priv;
561 struct cirrus_amp_cal_data result_data;
562 static const u64 bad_target_uid = 0xBADCA100BABABABAULL;
563 int i, ret;
564
565 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
566
567 /* Make all the target values != bad_target_uid */
568 for (i = 0; i < priv->cal_blob->count; ++i) {
569 priv->cal_blob->data[i].calTarget[0] &= ~(bad_target_uid & 0xFFFFFFFFULL);
570 priv->cal_blob->data[i].calTarget[1] &= ~(bad_target_uid >> 32);
571 }
572
573 /* Redirect calls to get EFI data */
574 kunit_activate_static_stub(test,
575 cs_amp_test_hooks->get_efi_variable,
576 cs_amp_lib_test_get_efi_variable);
577
578 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid, 99,
579 &result_data);
580 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
581 }
582
583 /*
584 * If the target UID isn't given, and the index is out of range, the
585 * result should be -ENOENT.
586 */
cs_amp_lib_test_get_efi_cal_no_uid_index_not_found_test(struct kunit * test)587 static void cs_amp_lib_test_get_efi_cal_no_uid_index_not_found_test(struct kunit *test)
588 {
589 struct cs_amp_lib_test_priv *priv = test->priv;
590 struct cirrus_amp_cal_data result_data;
591 int ret;
592
593 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
594
595 /* Redirect calls to get EFI data */
596 kunit_activate_static_stub(test,
597 cs_amp_test_hooks->get_efi_variable,
598 cs_amp_lib_test_get_efi_variable);
599
600 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 99, &result_data);
601 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
602 }
603
604 /* If neither the target UID or the index is given the result should be -ENOENT. */
cs_amp_lib_test_get_efi_cal_no_uid_no_index_test(struct kunit * test)605 static void cs_amp_lib_test_get_efi_cal_no_uid_no_index_test(struct kunit *test)
606 {
607 struct cs_amp_lib_test_priv *priv = test->priv;
608 struct cirrus_amp_cal_data result_data;
609 int ret;
610
611 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
612
613 /* Redirect calls to get EFI data */
614 kunit_activate_static_stub(test,
615 cs_amp_test_hooks->get_efi_variable,
616 cs_amp_lib_test_get_efi_variable);
617
618 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, -1, &result_data);
619 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
620 }
621
622 /*
623 * If the UID is passed as 0 this must not match an entry with an
624 * unpopulated calTarget
625 */
cs_amp_lib_test_get_efi_cal_zero_not_matched_test(struct kunit * test)626 static void cs_amp_lib_test_get_efi_cal_zero_not_matched_test(struct kunit *test)
627 {
628 struct cs_amp_lib_test_priv *priv = test->priv;
629 struct cirrus_amp_cal_data result_data;
630 int i, ret;
631
632 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
633
634 /* Make all the target values zero so they are ignored */
635 for (i = 0; i < priv->cal_blob->count; ++i) {
636 priv->cal_blob->data[i].calTarget[0] = 0;
637 priv->cal_blob->data[i].calTarget[1] = 0;
638 }
639
640 /* Redirect calls to get EFI data */
641 kunit_activate_static_stub(test,
642 cs_amp_test_hooks->get_efi_variable,
643 cs_amp_lib_test_get_efi_variable);
644
645 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, -1, &result_data);
646 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
647 }
648
649 /*
650 * If an entry has a timestamp of 0 it should be ignored even if it has
651 * a matching target UID.
652 */
cs_amp_lib_test_get_efi_cal_empty_entry_test(struct kunit * test)653 static void cs_amp_lib_test_get_efi_cal_empty_entry_test(struct kunit *test)
654 {
655 struct cs_amp_lib_test_priv *priv = test->priv;
656 struct cirrus_amp_cal_data result_data;
657 u64 uid;
658
659 cs_amp_lib_test_init_dummy_cal_blob(test, 8);
660
661 /* Mark the 3rd entry invalid by zeroing calTime */
662 priv->cal_blob->data[2].calTime[0] = 0;
663 priv->cal_blob->data[2].calTime[1] = 0;
664
665 /* Get the UID value of the 3rd entry */
666 uid = priv->cal_blob->data[2].calTarget[1];
667 uid <<= 32;
668 uid |= priv->cal_blob->data[2].calTarget[0];
669
670 /* Redirect calls to get EFI data */
671 kunit_activate_static_stub(test,
672 cs_amp_test_hooks->get_efi_variable,
673 cs_amp_lib_test_get_efi_variable);
674
675 /* Lookup by UID should not find it */
676 KUNIT_EXPECT_EQ(test,
677 cs_amp_get_efi_calibration_data(&priv->amp_dev->dev,
678 uid, -1,
679 &result_data),
680 -ENOENT);
681
682 /* Get by index should ignore it */
683 KUNIT_EXPECT_EQ(test,
684 cs_amp_get_efi_calibration_data(&priv->amp_dev->dev,
685 0, 2,
686 &result_data),
687 -ENOENT);
688 }
689
690 static const struct cirrus_amp_cal_controls cs_amp_lib_test_calibration_controls = {
691 .alg_id = 0x9f210,
692 .mem_region = WMFW_ADSP2_YM,
693 .ambient = "CAL_AMBIENT",
694 .calr = "CAL_R",
695 .status = "CAL_STATUS",
696 .checksum = "CAL_CHECKSUM",
697 };
698
cs_amp_lib_test_write_cal_coeff(struct cs_dsp * dsp,const struct cirrus_amp_cal_controls * controls,const char * ctl_name,u32 val)699 static int cs_amp_lib_test_write_cal_coeff(struct cs_dsp *dsp,
700 const struct cirrus_amp_cal_controls *controls,
701 const char *ctl_name, u32 val)
702 {
703 struct kunit *test = kunit_get_current_test();
704 struct cs_amp_lib_test_priv *priv = test->priv;
705 struct cs_amp_lib_test_ctl_write_entry *entry;
706
707 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctl_name);
708 KUNIT_EXPECT_PTR_EQ(test, controls, &cs_amp_lib_test_calibration_controls);
709
710 entry = kunit_kzalloc(test, sizeof(*entry), GFP_KERNEL);
711 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, entry);
712
713 INIT_LIST_HEAD(&entry->list);
714 strscpy(entry->name, ctl_name, sizeof(entry->name));
715 entry->value = val;
716
717 list_add_tail(&entry->list, &priv->ctl_write_list);
718
719 return 0;
720 }
721
cs_amp_lib_test_write_cal_data_test(struct kunit * test)722 static void cs_amp_lib_test_write_cal_data_test(struct kunit *test)
723 {
724 struct cs_amp_lib_test_priv *priv = test->priv;
725 struct cs_amp_lib_test_ctl_write_entry *entry;
726 struct cirrus_amp_cal_data data;
727 struct cs_dsp *dsp;
728 int ret;
729
730 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
731 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp);
732 dsp->dev = &priv->amp_dev->dev;
733
734 get_random_bytes(&data, sizeof(data));
735
736 /* Redirect calls to write firmware controls */
737 kunit_activate_static_stub(test,
738 cs_amp_test_hooks->write_cal_coeff,
739 cs_amp_lib_test_write_cal_coeff);
740
741 ret = cs_amp_write_cal_coeffs(dsp, &cs_amp_lib_test_calibration_controls, &data);
742 KUNIT_EXPECT_EQ(test, ret, 0);
743 KUNIT_EXPECT_EQ(test, list_count_nodes(&priv->ctl_write_list), 4);
744
745 /* Checksum control must be written last */
746 entry = list_last_entry(&priv->ctl_write_list, typeof(*entry), list);
747 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.checksum);
748 KUNIT_EXPECT_EQ(test, entry->value, data.calR + 1);
749 list_del(&entry->list);
750
751 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
752 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.ambient);
753 KUNIT_EXPECT_EQ(test, entry->value, data.calAmbient);
754 list_del(&entry->list);
755
756 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
757 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.calr);
758 KUNIT_EXPECT_EQ(test, entry->value, data.calR);
759 list_del(&entry->list);
760
761 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
762 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.status);
763 KUNIT_EXPECT_EQ(test, entry->value, data.calStatus);
764 }
765
cs_amp_lib_test_read_cal_coeff(struct cs_dsp * dsp,const struct cirrus_amp_cal_controls * controls,const char * ctl_name,u32 * val)766 static int cs_amp_lib_test_read_cal_coeff(struct cs_dsp *dsp,
767 const struct cirrus_amp_cal_controls *controls,
768 const char *ctl_name, u32 *val)
769 {
770 struct kunit *test = kunit_get_current_test();
771
772 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctl_name);
773 KUNIT_EXPECT_PTR_EQ(test, controls, &cs_amp_lib_test_calibration_controls);
774
775 if (strcmp(ctl_name, controls->ambient) == 0)
776 *val = 19;
777 else if (strcmp(ctl_name, controls->calr) == 0)
778 *val = 1077;
779 else if (strcmp(ctl_name, controls->status) == 0)
780 *val = 2;
781 else
782 kunit_fail_current_test("Bad control '%s'\n", ctl_name);
783
784 return 0;
785 }
786
cs_amp_lib_test_read_cal_data_test(struct kunit * test)787 static void cs_amp_lib_test_read_cal_data_test(struct kunit *test)
788 {
789 struct cs_amp_lib_test_priv *priv = test->priv;
790 struct cirrus_amp_cal_data data = { 0 };
791 struct cs_dsp *dsp;
792 int ret;
793
794 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
795 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp);
796 dsp->dev = &priv->amp_dev->dev;
797
798 kunit_activate_static_stub(test,
799 cs_amp_test_hooks->read_cal_coeff,
800 cs_amp_lib_test_read_cal_coeff);
801
802 ret = cs_amp_read_cal_coeffs(dsp, &cs_amp_lib_test_calibration_controls, &data);
803 KUNIT_EXPECT_EQ(test, ret, 0);
804
805 KUNIT_EXPECT_EQ(test, 19, data.calAmbient);
806 KUNIT_EXPECT_EQ(test, 1077, data.calR);
807 KUNIT_EXPECT_EQ(test, 2, data.calStatus);
808 KUNIT_EXPECT_NE(test, 0, data.calTime[0] | data.calTime[1]);
809 }
810
cs_amp_lib_test_write_ambient_test(struct kunit * test)811 static void cs_amp_lib_test_write_ambient_test(struct kunit *test)
812 {
813 struct cs_amp_lib_test_priv *priv = test->priv;
814 struct cs_amp_lib_test_ctl_write_entry *entry;
815 struct cs_dsp *dsp;
816 int ret;
817
818 dsp = kunit_kzalloc(test, sizeof(*dsp), GFP_KERNEL);
819 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp);
820 dsp->dev = &priv->amp_dev->dev;
821
822 /* Redirect calls to write firmware controls */
823 kunit_activate_static_stub(test,
824 cs_amp_test_hooks->write_cal_coeff,
825 cs_amp_lib_test_write_cal_coeff);
826
827 ret = cs_amp_write_ambient_temp(dsp, &cs_amp_lib_test_calibration_controls, 18);
828 KUNIT_EXPECT_EQ(test, ret, 0);
829
830 KUNIT_EXPECT_EQ(test, list_count_nodes(&priv->ctl_write_list), 1);
831
832 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
833 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.ambient);
834 KUNIT_EXPECT_EQ(test, entry->value, 18);
835 }
836
cs_amp_lib_test_set_efi_variable(efi_char16_t * name,efi_guid_t * guid,u32 attr,unsigned long size,void * buf)837 static efi_status_t cs_amp_lib_test_set_efi_variable(efi_char16_t *name,
838 efi_guid_t *guid,
839 u32 attr,
840 unsigned long size,
841 void *buf)
842 {
843 static const efi_char16_t expected_name[] = CIRRUS_LOGIC_CALIBRATION_EFI_NAME;
844 static const efi_guid_t expected_guid = CIRRUS_LOGIC_CALIBRATION_EFI_GUID;
845 struct kunit *test = kunit_get_current_test();
846 struct cs_amp_lib_test_priv *priv = test->priv;
847
848 KUNIT_ASSERT_NOT_NULL(test, name);
849 KUNIT_ASSERT_NOT_NULL(test, guid);
850
851 if (memcmp(name, expected_name, sizeof(expected_name)) ||
852 efi_guidcmp(*guid, expected_guid))
853 return -EFI_NOT_FOUND;
854
855 KUNIT_ASSERT_NOT_NULL(test, buf);
856 KUNIT_ASSERT_NE(test, 0, size);
857
858 kunit_kfree(test, priv->cal_blob);
859 priv->cal_blob = kunit_kmalloc(test, size, GFP_KERNEL);
860 KUNIT_ASSERT_NOT_NULL(test, priv->cal_blob);
861 memcpy(priv->cal_blob, buf, size);
862 priv->efi_attr = attr;
863
864 return EFI_SUCCESS;
865 }
866
cs_amp_lib_test_set_efi_variable_denied(efi_char16_t * name,efi_guid_t * guid,u32 attr,unsigned long size,void * buf)867 static efi_status_t cs_amp_lib_test_set_efi_variable_denied(efi_char16_t *name,
868 efi_guid_t *guid,
869 u32 attr,
870 unsigned long size,
871 void *buf)
872 {
873 return EFI_WRITE_PROTECTED;
874 }
875
876 #define CS_AMP_CAL_DEFAULT_EFI_ATTR \
877 (EFI_VARIABLE_NON_VOLATILE | \
878 EFI_VARIABLE_BOOTSERVICE_ACCESS | \
879 EFI_VARIABLE_RUNTIME_ACCESS)
880
cs_amp_lib_test_create_new_cal_efi(struct kunit * test)881 static void cs_amp_lib_test_create_new_cal_efi(struct kunit *test)
882 {
883 struct cs_amp_lib_test_priv *priv = test->priv;
884 struct device *dev = &priv->amp_dev->dev;
885 struct cirrus_amp_cal_data data;
886 int i;
887
888 kunit_activate_static_stub(test,
889 cs_amp_test_hooks->get_efi_variable,
890 cs_amp_lib_test_get_efi_variable_none);
891 kunit_activate_static_stub(test,
892 cs_amp_test_hooks->set_efi_variable,
893 cs_amp_lib_test_set_efi_variable);
894
895 /* For unspecified number of amps */
896 get_random_bytes(&data, sizeof(data));
897 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
898 KUNIT_EXPECT_EQ(test, CS_AMP_CAL_DEFAULT_EFI_ATTR, priv->efi_attr);
899 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 1);
900 KUNIT_EXPECT_LE(test, priv->cal_blob->count, 8);
901 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
902 priv->cal_blob->size);
903 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
904 for (i = 1; i < priv->cal_blob->count; i++)
905 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
906
907 /* For 2 amps */
908 priv->cal_blob = NULL;
909 get_random_bytes(&data, sizeof(data));
910 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 2, &data));
911 KUNIT_EXPECT_EQ(test, CS_AMP_CAL_DEFAULT_EFI_ATTR, priv->efi_attr);
912 KUNIT_EXPECT_EQ(test, 2, priv->cal_blob->count);
913 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 2), priv->cal_blob->size);
914 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
915 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
916
917 /* For 4 amps */
918 priv->cal_blob = NULL;
919 get_random_bytes(&data, sizeof(data));
920 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 4, &data));
921 KUNIT_EXPECT_EQ(test, 4, priv->cal_blob->count);
922 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 4), priv->cal_blob->size);
923 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
924 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
925 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
926 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
927
928 /* For 6 amps */
929 priv->cal_blob = NULL;
930 get_random_bytes(&data, sizeof(data));
931 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 6, &data));
932 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
933 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
934 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
935 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
936 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
937 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
938 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
939 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
940 }
941
cs_amp_lib_test_create_new_cal_efi_indexed(struct kunit * test)942 static void cs_amp_lib_test_create_new_cal_efi_indexed(struct kunit *test)
943 {
944 struct cs_amp_lib_test_priv *priv = test->priv;
945 struct device *dev = &priv->amp_dev->dev;
946 struct cirrus_amp_cal_data data;
947
948 kunit_activate_static_stub(test,
949 cs_amp_test_hooks->get_efi_variable,
950 cs_amp_lib_test_get_efi_variable_none);
951 kunit_activate_static_stub(test,
952 cs_amp_test_hooks->set_efi_variable,
953 cs_amp_lib_test_set_efi_variable);
954
955 /* In slot 0 */
956 priv->cal_blob = NULL;
957 get_random_bytes(&data, sizeof(data));
958 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 0, 6, &data));
959 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
960 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
961 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
962 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
963 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
964 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
965 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
966 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
967
968 /* In slot 1 */
969 priv->cal_blob = NULL;
970 get_random_bytes(&data, sizeof(data));
971 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, 6, &data));
972 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
973 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
974 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
975 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[0], sizeof(data)));
976 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
977 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
978 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
979 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
980
981 /* In slot 5 */
982 priv->cal_blob = NULL;
983 get_random_bytes(&data, sizeof(data));
984 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 5, 6, &data));
985 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
986 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
987 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[5], sizeof(data));
988 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[0], sizeof(data)));
989 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
990 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
991 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
992 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
993 }
994
cs_amp_lib_test_create_new_cal_efi_indexed_no_max(struct kunit * test)995 static void cs_amp_lib_test_create_new_cal_efi_indexed_no_max(struct kunit *test)
996 {
997 struct cs_amp_lib_test_priv *priv = test->priv;
998 struct device *dev = &priv->amp_dev->dev;
999 struct cirrus_amp_cal_data data;
1000 int i;
1001
1002 kunit_activate_static_stub(test,
1003 cs_amp_test_hooks->get_efi_variable,
1004 cs_amp_lib_test_get_efi_variable_none);
1005 kunit_activate_static_stub(test,
1006 cs_amp_test_hooks->set_efi_variable,
1007 cs_amp_lib_test_set_efi_variable);
1008
1009 /* In slot 0 with unspecified number of amps */
1010 priv->cal_blob = NULL;
1011 get_random_bytes(&data, sizeof(data));
1012 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 0, -1, &data));
1013 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 1);
1014 KUNIT_EXPECT_LE(test, priv->cal_blob->count, 8);
1015 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1016 priv->cal_blob->size);
1017 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1018 for (i = 1; i < priv->cal_blob->count; i++)
1019 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1020
1021 /* In slot 1 with unspecified number of amps */
1022 priv->cal_blob = NULL;
1023 get_random_bytes(&data, sizeof(data));
1024 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, -1, &data));
1025 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 2);
1026 KUNIT_EXPECT_LE(test, priv->cal_blob->count, 8);
1027 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1028 priv->cal_blob->size);
1029 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1030 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[0], sizeof(data)));
1031 for (i = 2; i < priv->cal_blob->count; i++)
1032 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1033
1034 /* In slot 5 with unspecified number of amps */
1035 priv->cal_blob = NULL;
1036 get_random_bytes(&data, sizeof(data));
1037 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 5, -1, &data));
1038 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 6);
1039 KUNIT_EXPECT_LE(test, priv->cal_blob->count, 8);
1040 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1041 priv->cal_blob->size);
1042 for (i = 0; (i < 5) && (i < priv->cal_blob->count); i++)
1043 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1044
1045 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[5], sizeof(data));
1046 for (i = 6; i < priv->cal_blob->count; i++)
1047 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1048 }
1049
cs_amp_lib_test_grow_append_cal_efi(struct kunit * test)1050 static void cs_amp_lib_test_grow_append_cal_efi(struct kunit *test)
1051 {
1052 struct cs_amp_lib_test_priv *priv = test->priv;
1053 struct device *dev = &priv->amp_dev->dev;
1054 const struct cirrus_amp_efi_data *original_blob;
1055 struct cirrus_amp_cal_data data;
1056
1057 kunit_activate_static_stub(test,
1058 cs_amp_test_hooks->get_efi_variable,
1059 cs_amp_lib_test_get_efi_variable);
1060 kunit_activate_static_stub(test,
1061 cs_amp_test_hooks->set_efi_variable,
1062 cs_amp_lib_test_set_efi_variable);
1063
1064 /* Initially 1 used entry grown to 2 entries */
1065 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1066 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1067 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1068 get_random_bytes(&data, sizeof(data));
1069 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1070 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 2, &data));
1071 KUNIT_EXPECT_EQ(test, CS_AMP_CAL_DEFAULT_EFI_ATTR, priv->efi_attr);
1072 KUNIT_EXPECT_EQ(test, 2, priv->cal_blob->count);
1073 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 2), priv->cal_blob->size);
1074 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1075 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1076
1077 /* Initially 1 entry grown to 4 entries */
1078 priv->cal_blob = NULL;
1079 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1080 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1081 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1082 get_random_bytes(&data, sizeof(data));
1083 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1084 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 4, &data));
1085 KUNIT_EXPECT_EQ(test, 4, priv->cal_blob->count);
1086 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 4), priv->cal_blob->size);
1087 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1088 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1089 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1090 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1091
1092 /* Initially 2 entries grown to 4 entries */
1093 priv->cal_blob = NULL;
1094 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1095 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1096 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1097 get_random_bytes(&data, sizeof(data));
1098 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1099 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 4, &data));
1100 KUNIT_EXPECT_EQ(test, 4, priv->cal_blob->count);
1101 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 4), priv->cal_blob->size);
1102 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1103 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1104 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[2], sizeof(data));
1105 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1106
1107 /* Initially 1 entry grown to 6 entries */
1108 priv->cal_blob = NULL;
1109 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1110 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1111 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1112 get_random_bytes(&data, sizeof(data));
1113 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1114 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 6, &data));
1115 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1116 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1117 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1118 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1119 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1120 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1121 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1122 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1123
1124 /* Initially 4 entries grown to 6 entries */
1125 priv->cal_blob = NULL;
1126 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1127 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1128 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1129 get_random_bytes(&data, sizeof(data));
1130 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1131 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 6, &data));
1132 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1133 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1134 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1135 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1136 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1137 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1138 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1139 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1140 }
1141
cs_amp_lib_test_grow_append_cal_efi_indexed(struct kunit * test)1142 static void cs_amp_lib_test_grow_append_cal_efi_indexed(struct kunit *test)
1143 {
1144 struct cs_amp_lib_test_priv *priv = test->priv;
1145 struct device *dev = &priv->amp_dev->dev;
1146 const struct cirrus_amp_efi_data *original_blob;
1147 struct cirrus_amp_cal_data data;
1148
1149 kunit_activate_static_stub(test,
1150 cs_amp_test_hooks->get_efi_variable,
1151 cs_amp_lib_test_get_efi_variable);
1152 kunit_activate_static_stub(test,
1153 cs_amp_test_hooks->set_efi_variable,
1154 cs_amp_lib_test_set_efi_variable);
1155
1156 /* Initially 1 entry grown to 2 entries using slot 1 */
1157 priv->cal_blob = NULL;
1158 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1159 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1160 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1161 get_random_bytes(&data, sizeof(data));
1162 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1163 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, 2, &data));
1164 KUNIT_EXPECT_EQ(test, 2, priv->cal_blob->count);
1165 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 2), priv->cal_blob->size);
1166 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1167 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1168
1169 /* Initially 1 entry grown to 6 entries using slot 1 */
1170 priv->cal_blob = NULL;
1171 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1172 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1173 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1174 get_random_bytes(&data, sizeof(data));
1175 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1176 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, 6, &data));
1177 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1178 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1179 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1180 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1181 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1182 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1183 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1184 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1185
1186 /* Initially 2 entries grown to 6 entries using slot 2 */
1187 priv->cal_blob = NULL;
1188 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1189 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1190 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1191 get_random_bytes(&data, sizeof(data));
1192 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1193 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 2, 6, &data));
1194 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1195 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1196 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1197 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1198 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[2], sizeof(data));
1199 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1200 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1201 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1202
1203 /* Initially 2 entries grown to 6 entries using slot 4 */
1204 kunit_kfree(test, original_blob);
1205 kunit_kfree(test, priv->cal_blob);
1206 priv->cal_blob = NULL;
1207 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1208 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1209 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1210 get_random_bytes(&data, sizeof(data));
1211 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1212 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 4, 6, &data));
1213 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1214 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1215 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1216 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1217 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1218 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1219 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1220 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1221 }
1222
cs_amp_lib_test_cal_efi_all_zeros_add_first(struct kunit * test)1223 static void cs_amp_lib_test_cal_efi_all_zeros_add_first(struct kunit *test)
1224 {
1225 struct cs_amp_lib_test_priv *priv = test->priv;
1226 struct device *dev = &priv->amp_dev->dev;
1227 struct cirrus_amp_cal_data data;
1228 int i;
1229
1230 /* Simulate a BIOS reserving EFI space that is entirely zero-filled. */
1231 kunit_activate_static_stub(test,
1232 cs_amp_test_hooks->get_efi_variable,
1233 cs_amp_lib_test_get_efi_variable_all_zeros);
1234 kunit_activate_static_stub(test,
1235 cs_amp_test_hooks->set_efi_variable,
1236 cs_amp_lib_test_set_efi_variable);
1237
1238 /*
1239 * Add an entry. The header should be filled in to match the
1240 * original EFI variable size.
1241 */
1242 get_random_bytes(&data, sizeof(data));
1243 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1244 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1245 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1246 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1247 for (i = 1; i < priv->cal_blob->count; i++) {
1248 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[0]);
1249 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[1]);
1250 }
1251 }
1252
cs_amp_lib_test_cal_efi_all_zeros_add_first_no_shrink(struct kunit * test)1253 static void cs_amp_lib_test_cal_efi_all_zeros_add_first_no_shrink(struct kunit *test)
1254 {
1255 struct cs_amp_lib_test_priv *priv = test->priv;
1256 struct device *dev = &priv->amp_dev->dev;
1257 struct cirrus_amp_cal_data data;
1258 int i;
1259
1260 /* Simulate a BIOS reserving EFI space that is entirely zero-filled. */
1261 kunit_activate_static_stub(test,
1262 cs_amp_test_hooks->get_efi_variable,
1263 cs_amp_lib_test_get_efi_variable_all_zeros);
1264 kunit_activate_static_stub(test,
1265 cs_amp_test_hooks->set_efi_variable,
1266 cs_amp_lib_test_set_efi_variable);
1267
1268 /*
1269 * Add an entry. The header should be filled in to match the
1270 * original EFI variable size. A number of amps less than the
1271 * available preallocated space does not shrink the EFI variable.
1272 */
1273 get_random_bytes(&data, sizeof(data));
1274 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 4, &data));
1275 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1276 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1277 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1278 for (i = 1; i < priv->cal_blob->count; i++) {
1279 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[0]);
1280 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[1]);
1281 }
1282 }
1283
cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed(struct kunit * test)1284 static void cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed(struct kunit *test)
1285 {
1286 struct cs_amp_lib_test_priv *priv = test->priv;
1287 struct device *dev = &priv->amp_dev->dev;
1288 struct cirrus_amp_cal_data data;
1289 int i;
1290
1291 /* Simulate a BIOS reserving EFI space that is entirely zero-filled. */
1292 kunit_activate_static_stub(test,
1293 cs_amp_test_hooks->get_efi_variable,
1294 cs_amp_lib_test_get_efi_variable_all_zeros);
1295 kunit_activate_static_stub(test,
1296 cs_amp_test_hooks->set_efi_variable,
1297 cs_amp_lib_test_set_efi_variable);
1298
1299 /*
1300 * Write entry to slot 2. The header should be filled in to match
1301 * the original EFI variable size.
1302 */
1303 get_random_bytes(&data, sizeof(data));
1304 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 2, -1, &data));
1305 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1306 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1307 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[0]);
1308 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[1]);
1309 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[0]);
1310 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[1]);
1311 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[2], sizeof(data));
1312 for (i = 3; i < priv->cal_blob->count; i++) {
1313 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[0]);
1314 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[1]);
1315 }
1316 }
1317
cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed_no_shrink(struct kunit * test)1318 static void cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed_no_shrink(struct kunit *test)
1319 {
1320 struct cs_amp_lib_test_priv *priv = test->priv;
1321 struct device *dev = &priv->amp_dev->dev;
1322 struct cirrus_amp_cal_data data;
1323 int i;
1324
1325 /* Simulate a BIOS reserving EFI space that is entirely zero-filled. */
1326 kunit_activate_static_stub(test,
1327 cs_amp_test_hooks->get_efi_variable,
1328 cs_amp_lib_test_get_efi_variable_all_zeros);
1329 kunit_activate_static_stub(test,
1330 cs_amp_test_hooks->set_efi_variable,
1331 cs_amp_lib_test_set_efi_variable);
1332
1333 /*
1334 * Write entry to slot 2. The header should be filled in to match
1335 * the original EFI variable size. A number of amps less than the
1336 * available preallocated space does not shrink the EFI variable.
1337 */
1338 get_random_bytes(&data, sizeof(data));
1339 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 2, 4, &data));
1340 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1341 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1342 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[0]);
1343 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[1]);
1344 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[0]);
1345 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[1]);
1346 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[2], sizeof(data));
1347 for (i = 3; i < priv->cal_blob->count; i++) {
1348 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[0]);
1349 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[i].calTime[1]);
1350 }
1351 }
1352
cs_amp_lib_test_grow_append_cal_efi_indexed_no_max(struct kunit * test)1353 static void cs_amp_lib_test_grow_append_cal_efi_indexed_no_max(struct kunit *test)
1354 {
1355 struct cs_amp_lib_test_priv *priv = test->priv;
1356 struct device *dev = &priv->amp_dev->dev;
1357 const struct cirrus_amp_efi_data *original_blob;
1358 struct cirrus_amp_cal_data data;
1359 int i;
1360
1361 kunit_activate_static_stub(test,
1362 cs_amp_test_hooks->get_efi_variable,
1363 cs_amp_lib_test_get_efi_variable);
1364 kunit_activate_static_stub(test,
1365 cs_amp_test_hooks->set_efi_variable,
1366 cs_amp_lib_test_set_efi_variable);
1367
1368 /* Initially 1 entry adding slot 1 */
1369 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1370 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1371 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1372 get_random_bytes(&data, sizeof(data));
1373 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1374 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, -1, &data));
1375 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 2);
1376 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1377 priv->cal_blob->size);
1378 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1379 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1380 for (i = 2; i < priv->cal_blob->count; i++)
1381 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1382
1383 /* Initially 1 entry adding slot 3 */
1384 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1385 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1386 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1387 get_random_bytes(&data, sizeof(data));
1388 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1389 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 3, -1, &data));
1390 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 4);
1391 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1392 priv->cal_blob->size);
1393 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1394 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
1395 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1396 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1397 for (i = 4; i < priv->cal_blob->count; i++)
1398 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1399
1400 /* Initially 2 entries adding slot 3 */
1401 priv->cal_blob = NULL;
1402 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1403 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1404 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1405 get_random_bytes(&data, sizeof(data));
1406 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1407 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 3, -1, &data));
1408 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 1);
1409 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1410 priv->cal_blob->size);
1411 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1412 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1413 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1414 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1415 for (i = 4; i < priv->cal_blob->count; i++)
1416 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1417
1418 /* Initially 4 entries adding slot 4 */
1419 priv->cal_blob = NULL;
1420 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1421 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1422 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1423 get_random_bytes(&data, sizeof(data));
1424 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1425 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 4, -1, &data));
1426 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 1);
1427 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1428 priv->cal_blob->size);
1429 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1430 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1431 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1432 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1433 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1434 for (i = 5; i < priv->cal_blob->count; i++)
1435 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1436
1437 /* Initially 4 entries adding slot 6 */
1438 priv->cal_blob = NULL;
1439 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1440 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1441 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1442 get_random_bytes(&data, sizeof(data));
1443 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1444 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 6, -1, &data));
1445 KUNIT_EXPECT_GE(test, priv->cal_blob->count, 1);
1446 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, priv->cal_blob->count),
1447 priv->cal_blob->size);
1448 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1449 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1450 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1451 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1452 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1453 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1454 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[6], sizeof(data));
1455 for (i = 7; i < priv->cal_blob->count; i++)
1456 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[i], sizeof(data)));
1457 }
1458
cs_amp_lib_test_grow_cal_efi_replace_indexed(struct kunit * test)1459 static void cs_amp_lib_test_grow_cal_efi_replace_indexed(struct kunit *test)
1460 {
1461 struct cs_amp_lib_test_priv *priv = test->priv;
1462 struct device *dev = &priv->amp_dev->dev;
1463 const struct cirrus_amp_efi_data *original_blob;
1464 struct cirrus_amp_cal_data data;
1465
1466 kunit_activate_static_stub(test,
1467 cs_amp_test_hooks->get_efi_variable,
1468 cs_amp_lib_test_get_efi_variable);
1469 kunit_activate_static_stub(test,
1470 cs_amp_test_hooks->set_efi_variable,
1471 cs_amp_lib_test_set_efi_variable);
1472
1473 /* Initially 1 entry grown to 2 entries overwriting slot 0 */
1474 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1475 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1476 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1477 get_random_bytes(&data, sizeof(data));
1478 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1479 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 0, 2, &data));
1480 KUNIT_EXPECT_EQ(test, 2, priv->cal_blob->count);
1481 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 2), priv->cal_blob->size);
1482 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1483 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
1484
1485 /* Initially 2 entries grown to 4 entries overwriting slot 1 */
1486 priv->cal_blob = NULL;
1487 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1488 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1489 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1490 get_random_bytes(&data, sizeof(data));
1491 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1492 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, 4, &data));
1493 KUNIT_EXPECT_EQ(test, 4, priv->cal_blob->count);
1494 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 4), priv->cal_blob->size);
1495 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1496 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1497 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1498 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1499
1500 /* Initially 4 entries grown to 6 entries overwriting slot 1 */
1501 priv->cal_blob = NULL;
1502 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1503 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1504 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1505 get_random_bytes(&data, sizeof(data));
1506 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1507 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, 6, &data));
1508 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1509 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1510 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1511 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1512 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1513 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1514 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1515 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1516
1517 /* Initially 4 entries grown to 6 entries overwriting slot 3 */
1518 priv->cal_blob = NULL;
1519 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1520 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1521 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1522 get_random_bytes(&data, sizeof(data));
1523 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1524 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 3, 6, &data));
1525 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1526 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1527 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1528 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1529 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1530 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1531 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1532 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1533
1534 /* Initially 6 entries grown to 8 entries overwriting slot 4 */
1535 priv->cal_blob = NULL;
1536 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
1537 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
1538 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1539 get_random_bytes(&data, sizeof(data));
1540 data.calTarget[0] = 0xaaaaaaaa; /* won't match */
1541 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 4, 8, &data));
1542 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1543 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1544 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1545 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1546 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1547 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1548 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1549 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1550 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[6], sizeof(data)));
1551 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[7], sizeof(data)));
1552 }
1553
cs_amp_lib_test_grow_cal_efi_replace_by_uid(struct kunit * test)1554 static void cs_amp_lib_test_grow_cal_efi_replace_by_uid(struct kunit *test)
1555 {
1556 struct cs_amp_lib_test_priv *priv = test->priv;
1557 struct device *dev = &priv->amp_dev->dev;
1558 const struct cirrus_amp_efi_data *original_blob;
1559 struct cirrus_amp_cal_data data;
1560
1561 kunit_activate_static_stub(test,
1562 cs_amp_test_hooks->get_efi_variable,
1563 cs_amp_lib_test_get_efi_variable);
1564 kunit_activate_static_stub(test,
1565 cs_amp_test_hooks->set_efi_variable,
1566 cs_amp_lib_test_set_efi_variable);
1567
1568 /* Initially 1 entry grown to 2 entries overwriting slot 0 */
1569 cs_amp_lib_test_init_dummy_cal_blob(test, 1);
1570 KUNIT_ASSERT_EQ(test, 1, priv->cal_blob->count);
1571 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1572 get_random_bytes(&data, sizeof(data));
1573 memcpy(data.calTarget, priv->cal_blob->data[0].calTarget, sizeof(data.calTarget));
1574 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 2, &data));
1575 KUNIT_EXPECT_EQ(test, 2, priv->cal_blob->count);
1576 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 2), priv->cal_blob->size);
1577 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1578 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[1], sizeof(data)));
1579
1580 /* Initially 2 entries grown to 4 entries overwriting slot 1 */
1581 priv->cal_blob = NULL;
1582 cs_amp_lib_test_init_dummy_cal_blob(test, 2);
1583 KUNIT_ASSERT_EQ(test, 2, priv->cal_blob->count);
1584 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1585 get_random_bytes(&data, sizeof(data));
1586 memcpy(data.calTarget, priv->cal_blob->data[1].calTarget, sizeof(data.calTarget));
1587 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 4, &data));
1588 KUNIT_EXPECT_EQ(test, 4, priv->cal_blob->count);
1589 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 4), priv->cal_blob->size);
1590 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1591 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1592 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[2], sizeof(data)));
1593 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[3], sizeof(data)));
1594
1595 /* Initially 4 entries grown to 6 entries overwriting slot 1 */
1596 priv->cal_blob = NULL;
1597 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1598 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1599 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1600 get_random_bytes(&data, sizeof(data));
1601 memcpy(data.calTarget, priv->cal_blob->data[1].calTarget, sizeof(data.calTarget));
1602 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 6, &data));
1603 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1604 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1605 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1606 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1607 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1608 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1609 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1610 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1611
1612 /* Initially 4 entries grown to 6 entries overwriting slot 3 */
1613 priv->cal_blob = NULL;
1614 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1615 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1616 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1617 get_random_bytes(&data, sizeof(data));
1618 memcpy(data.calTarget, priv->cal_blob->data[3].calTarget, sizeof(data.calTarget));
1619 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 6, &data));
1620 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1621 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1622 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1623 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1624 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1625 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1626 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[4], sizeof(data)));
1627 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[5], sizeof(data)));
1628
1629 /* Initially 6 entries grown to 8 entries overwriting slot 4 */
1630 priv->cal_blob = NULL;
1631 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
1632 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
1633 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1634 get_random_bytes(&data, sizeof(data));
1635 memcpy(data.calTarget, priv->cal_blob->data[4].calTarget, sizeof(data.calTarget));
1636 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, 8, &data));
1637 KUNIT_EXPECT_EQ(test, 8, priv->cal_blob->count);
1638 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 8), priv->cal_blob->size);
1639 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1640 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1641 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1642 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1643 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1644 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1645 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[6], sizeof(data)));
1646 KUNIT_EXPECT_TRUE(test, mem_is_zero(&priv->cal_blob->data[7], sizeof(data)));
1647 }
1648
cs_amp_lib_test_cal_efi_replace_by_uid(struct kunit * test)1649 static void cs_amp_lib_test_cal_efi_replace_by_uid(struct kunit *test)
1650 {
1651 struct cs_amp_lib_test_priv *priv = test->priv;
1652 struct device *dev = &priv->amp_dev->dev;
1653 const struct cirrus_amp_efi_data *original_blob;
1654 struct cirrus_amp_cal_data data;
1655
1656 kunit_activate_static_stub(test,
1657 cs_amp_test_hooks->get_efi_variable,
1658 cs_amp_lib_test_get_efi_variable);
1659 kunit_activate_static_stub(test,
1660 cs_amp_test_hooks->set_efi_variable,
1661 cs_amp_lib_test_set_efi_variable);
1662
1663 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
1664 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
1665
1666 /* Replace entry matching slot 0 */
1667 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1668 get_random_bytes(&data, sizeof(data));
1669 memcpy(data.calTarget, priv->cal_blob->data[0].calTarget, sizeof(data.calTarget));
1670 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1671 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1672 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1673 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1674 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1675 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1676 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1677 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1678 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1679
1680 /* Replace entry matching slot 4 */
1681 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1682 get_random_bytes(&data, sizeof(data));
1683 memcpy(data.calTarget, priv->cal_blob->data[4].calTarget, sizeof(data.calTarget));
1684 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1685 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1686 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1687 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1688 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1689 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1690 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1691 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1692 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1693
1694 /* Replace entry matching slot 3 */
1695 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1696 get_random_bytes(&data, sizeof(data));
1697 memcpy(data.calTarget, priv->cal_blob->data[3].calTarget, sizeof(data.calTarget));
1698 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1699 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1700 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1701 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1702 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1703 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1704 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1705 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1706 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1707
1708 /* Replace entry matching slot 5 */
1709 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1710 get_random_bytes(&data, sizeof(data));
1711 memcpy(data.calTarget, priv->cal_blob->data[5].calTarget, sizeof(data.calTarget));
1712 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1713 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1714 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1715 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1716 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1717 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1718 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1719 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1720 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[5], sizeof(data));
1721 }
1722
cs_amp_lib_test_cal_efi_replace_by_index(struct kunit * test)1723 static void cs_amp_lib_test_cal_efi_replace_by_index(struct kunit *test)
1724 {
1725 struct cs_amp_lib_test_priv *priv = test->priv;
1726 struct device *dev = &priv->amp_dev->dev;
1727 const struct cirrus_amp_efi_data *original_blob;
1728 struct cirrus_amp_cal_data data;
1729
1730 kunit_activate_static_stub(test,
1731 cs_amp_test_hooks->get_efi_variable,
1732 cs_amp_lib_test_get_efi_variable);
1733 kunit_activate_static_stub(test,
1734 cs_amp_test_hooks->set_efi_variable,
1735 cs_amp_lib_test_set_efi_variable);
1736
1737 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
1738 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
1739
1740 /*
1741 * Replace entry matching slot 0.
1742 * data.calTarget is deliberately set different to current calTarget
1743 * of the slot to check that the index forces that slot to be used.
1744 */
1745 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1746 get_random_bytes(&data, sizeof(data));
1747 data.calTarget[0] = ~priv->cal_blob->data[0].calTarget[0];
1748 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 0, -1, &data));
1749 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1750 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1751 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1752 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1753 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1754 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1755 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1756 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1757
1758 /* Replace entry matching slot 4 */
1759 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1760 get_random_bytes(&data, sizeof(data));
1761 data.calTarget[0] = ~priv->cal_blob->data[4].calTarget[0];
1762 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 4, -1, &data));
1763 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1764 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1765 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1766 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1767 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1768 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1769 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1770 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1771
1772 /* Replace entry matching slot 3 */
1773 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1774 get_random_bytes(&data, sizeof(data));
1775 data.calTarget[0] = ~priv->cal_blob->data[3].calTarget[0];
1776 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 3, -1, &data));
1777 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1778 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1779 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1780 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1781 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1782 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1783 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1784 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1785
1786 /* Replace entry matching slot 5 */
1787 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1788 get_random_bytes(&data, sizeof(data));
1789 data.calTarget[0] = ~priv->cal_blob->data[5].calTarget[0];
1790 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 5, -1, &data));
1791 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1792 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1793 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1794 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1795 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1796 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1797 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1798 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[5], sizeof(data));
1799 }
1800
cs_amp_lib_test_cal_efi_deduplicate(struct kunit * test)1801 static void cs_amp_lib_test_cal_efi_deduplicate(struct kunit *test)
1802 {
1803 struct cs_amp_lib_test_priv *priv = test->priv;
1804 struct device *dev = &priv->amp_dev->dev;
1805 const struct cirrus_amp_efi_data *original_blob;
1806 struct cirrus_amp_cal_data data;
1807 int i;
1808
1809 kunit_activate_static_stub(test,
1810 cs_amp_test_hooks->get_efi_variable,
1811 cs_amp_lib_test_get_efi_variable);
1812 kunit_activate_static_stub(test,
1813 cs_amp_test_hooks->set_efi_variable,
1814 cs_amp_lib_test_set_efi_variable);
1815
1816 /*
1817 * Replace entry matching slot 0.
1818 * An active entry in slot 1 for the same UID should be marked empty.
1819 * Other entries are unaltered.
1820 */
1821 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1822 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1823 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1824 get_random_bytes(&data, sizeof(data));
1825 memcpy(data.calTarget, priv->cal_blob->data[1].calTarget, sizeof(data.calTarget));
1826 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 0, -1, &data));
1827 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1828 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[0]);
1829 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[1]);
1830 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1831 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1832
1833 /*
1834 * Replace entry matching slot 1.
1835 * An active entry in slot 0 for the same UID should be marked empty.
1836 * Other entries are unaltered.
1837 */
1838 priv->cal_blob = NULL;
1839 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1840 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1841 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1842 get_random_bytes(&data, sizeof(data));
1843 memcpy(data.calTarget, priv->cal_blob->data[0].calTarget, sizeof(data.calTarget));
1844 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, -1, &data));
1845 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[0]);
1846 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[1]);
1847 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1848 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1849 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1850
1851 /*
1852 * Replace entry matching slot 1.
1853 * An active entry in slot 3 for the same UID should be marked empty.
1854 * Other entries are unaltered.
1855 */
1856 priv->cal_blob = NULL;
1857 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1858 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1859 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1860 get_random_bytes(&data, sizeof(data));
1861 memcpy(data.calTarget, priv->cal_blob->data[3].calTarget, sizeof(data.calTarget));
1862 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 1, -1, &data));
1863 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1864 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[1], sizeof(data));
1865 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1866 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[3].calTime[0]);
1867 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[3].calTime[1]);
1868
1869 /*
1870 * Worst case, all entries have the same UID
1871 */
1872 priv->cal_blob = NULL;
1873 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1874 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
1875 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1876 get_random_bytes(&data, sizeof(data));
1877 for (i = 0; i < priv->cal_blob->count; i++) {
1878 priv->cal_blob->data[i].calTarget[0] = 0xe5e5e5e5;
1879 priv->cal_blob->data[i].calTarget[1] = 0xa7a7a7a7;
1880 }
1881 memcpy(data.calTarget, priv->cal_blob->data[2].calTarget, sizeof(data.calTarget));
1882 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 2, -1, &data));
1883 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[0]);
1884 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[0].calTime[1]);
1885 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[0]);
1886 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[1].calTime[1]);
1887 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[2], sizeof(data));
1888 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[3].calTime[0]);
1889 KUNIT_EXPECT_EQ(test, 0, priv->cal_blob->data[3].calTime[1]);
1890 }
1891
cs_amp_lib_test_cal_efi_find_free(struct kunit * test)1892 static void cs_amp_lib_test_cal_efi_find_free(struct kunit *test)
1893 {
1894 struct cs_amp_lib_test_priv *priv = test->priv;
1895 struct device *dev = &priv->amp_dev->dev;
1896 const struct cirrus_amp_efi_data *original_blob;
1897 struct cirrus_amp_cal_data data;
1898
1899 kunit_activate_static_stub(test,
1900 cs_amp_test_hooks->get_efi_variable,
1901 cs_amp_lib_test_get_efi_variable);
1902 kunit_activate_static_stub(test,
1903 cs_amp_test_hooks->set_efi_variable,
1904 cs_amp_lib_test_set_efi_variable);
1905
1906 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
1907 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
1908
1909 /*
1910 * Slot 0 is empty.
1911 * data.calTarget is set to a value that won't match any existing entry.
1912 */
1913 memset(&priv->cal_blob->data[0].calTime, 0, sizeof(priv->cal_blob->data[0].calTime));
1914 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1915 get_random_bytes(&data, sizeof(data));
1916 data.calTarget[0] = 0xaaaaaaaa;
1917 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1918 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1919 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1920 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
1921 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1922 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1923 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1924 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1925 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1926
1927 /* Slot 4 is empty */
1928 memset(&priv->cal_blob->data[4].calTime, 0, sizeof(priv->cal_blob->data[4].calTime));
1929 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1930 get_random_bytes(&data, sizeof(data));
1931 data.calTarget[0] = 0xaaaaaaaa;
1932 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1933 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1934 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1935 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1936 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1937 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1938 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1939 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
1940 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1941
1942 /* Slot 3 is empty */
1943 memset(&priv->cal_blob->data[3].calTime, 0, sizeof(priv->cal_blob->data[3].calTime));
1944 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1945 get_random_bytes(&data, sizeof(data));
1946 data.calTarget[0] = 0xaaaaaaaa;
1947 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1948 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1949 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1950 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1951 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1952 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1953 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[3], sizeof(data));
1954 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1955 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
1956
1957 /* Replace entry matching slot 5 */
1958 memset(&priv->cal_blob->data[5].calTime, 0, sizeof(priv->cal_blob->data[5].calTime));
1959 original_blob = cs_amp_lib_test_cal_blob_dup(test);
1960 get_random_bytes(&data, sizeof(data));
1961 data.calTarget[0] = 0xaaaaaaaa;
1962 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
1963 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
1964 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
1965 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
1966 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
1967 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
1968 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
1969 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[4], &priv->cal_blob->data[4], sizeof(data));
1970 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[5], sizeof(data));
1971 }
1972
cs_amp_lib_test_cal_efi_bad_cal_target(struct kunit * test)1973 static void cs_amp_lib_test_cal_efi_bad_cal_target(struct kunit *test)
1974 {
1975 struct cs_amp_lib_test_priv *priv = test->priv;
1976 struct device *dev = &priv->amp_dev->dev;
1977 struct cirrus_amp_cal_data data;
1978
1979 kunit_activate_static_stub(test,
1980 cs_amp_test_hooks->get_efi_variable,
1981 cs_amp_lib_test_get_efi_variable);
1982 kunit_activate_static_stub(test,
1983 cs_amp_test_hooks->set_efi_variable,
1984 cs_amp_lib_test_set_efi_variable);
1985
1986 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
1987
1988 /* Zero calTarget is illegal */
1989 get_random_bytes(&data, sizeof(data));
1990 memset(data.calTarget, 0, sizeof(data.calTarget));
1991 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, -1, -1, &data), 0);
1992 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, 0, -1, &data), 0);
1993 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, 0, 2, &data), 0);
1994 }
1995
cs_amp_lib_test_cal_efi_write_denied(struct kunit * test)1996 static void cs_amp_lib_test_cal_efi_write_denied(struct kunit *test)
1997 {
1998 struct cs_amp_lib_test_priv *priv = test->priv;
1999 struct device *dev = &priv->amp_dev->dev;
2000 const struct cirrus_amp_efi_data *original_blob;
2001 struct cirrus_amp_cal_data data;
2002
2003 kunit_activate_static_stub(test,
2004 cs_amp_test_hooks->get_efi_variable,
2005 cs_amp_lib_test_get_efi_variable);
2006 kunit_activate_static_stub(test,
2007 cs_amp_test_hooks->set_efi_variable,
2008 cs_amp_lib_test_set_efi_variable_denied);
2009
2010 cs_amp_lib_test_init_dummy_cal_blob(test, 4);
2011 KUNIT_ASSERT_EQ(test, 4, priv->cal_blob->count);
2012 original_blob = cs_amp_lib_test_cal_blob_dup(test);
2013 get_random_bytes(&data, sizeof(data));
2014
2015 /* Unspecified slot */
2016 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, -1, -1, &data), 0);
2017 KUNIT_EXPECT_MEMEQ(test, original_blob, priv->cal_blob, original_blob->size);
2018
2019 /* Unspecified slot with size */
2020 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, -1, 6, &data), 0);
2021 KUNIT_EXPECT_MEMEQ(test, original_blob, priv->cal_blob, original_blob->size);
2022
2023 /* Specified slot */
2024 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, 1, -1, &data), 0);
2025 KUNIT_EXPECT_MEMEQ(test, original_blob, priv->cal_blob, original_blob->size);
2026
2027 /* Specified slot with size */
2028 KUNIT_EXPECT_LT(test, cs_amp_set_efi_calibration_data(dev, 1, 6, &data), 0);
2029 KUNIT_EXPECT_MEMEQ(test, original_blob, priv->cal_blob, original_blob->size);
2030 }
2031
cs_amp_lib_test_cal_efi_attr_preserved(struct kunit * test)2032 static void cs_amp_lib_test_cal_efi_attr_preserved(struct kunit *test)
2033 {
2034 struct cs_amp_lib_test_priv *priv = test->priv;
2035 struct device *dev = &priv->amp_dev->dev;
2036 struct cirrus_amp_cal_data data;
2037
2038 kunit_activate_static_stub(test,
2039 cs_amp_test_hooks->get_efi_variable,
2040 cs_amp_lib_test_get_efi_variable);
2041 kunit_activate_static_stub(test,
2042 cs_amp_test_hooks->set_efi_variable,
2043 cs_amp_lib_test_set_efi_variable);
2044
2045 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
2046 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
2047 memset(&priv->cal_blob->data[0], 0, sizeof(priv->cal_blob->data[0]));
2048 get_random_bytes(&data, sizeof(data));
2049
2050 /* Set a non-standard attr to return from get_efi_variable() */
2051 priv->efi_attr = EFI_VARIABLE_HARDWARE_ERROR_RECORD;
2052
2053 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, -1, -1, &data));
2054 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[0], sizeof(data));
2055 KUNIT_EXPECT_EQ(test, priv->efi_attr, EFI_VARIABLE_HARDWARE_ERROR_RECORD);
2056 }
2057
cs_amp_lib_test_set_hp_efi_cal_variable(efi_char16_t * name,efi_guid_t * guid,u32 attr,unsigned long size,void * buf)2058 static efi_status_t cs_amp_lib_test_set_hp_efi_cal_variable(efi_char16_t *name,
2059 efi_guid_t *guid,
2060 u32 attr,
2061 unsigned long size,
2062 void *buf)
2063 {
2064 static const efi_char16_t expected_name[] = HP_CALIBRATION_EFI_NAME;
2065 static const efi_guid_t expected_guid = HP_CALIBRATION_EFI_GUID;
2066 struct kunit *test = kunit_get_current_test();
2067 struct cs_amp_lib_test_priv *priv = test->priv;
2068
2069 KUNIT_ASSERT_NOT_NULL(test, name);
2070 KUNIT_ASSERT_NOT_NULL(test, guid);
2071
2072 if (memcmp(name, expected_name, sizeof(expected_name)) ||
2073 efi_guidcmp(*guid, expected_guid))
2074 return -EFI_ACCESS_DENIED;
2075
2076 KUNIT_ASSERT_NOT_NULL(test, buf);
2077 KUNIT_ASSERT_NE(test, 0, size);
2078
2079 kunit_kfree(test, priv->cal_blob);
2080 priv->cal_blob = kunit_kmalloc(test, size, GFP_KERNEL);
2081 KUNIT_ASSERT_NOT_NULL(test, priv->cal_blob);
2082 memcpy(priv->cal_blob, buf, size);
2083 priv->efi_attr = attr;
2084
2085 return EFI_SUCCESS;
2086 }
2087
2088 /*
2089 * If the HP EFI exists it should be the one that is updated.
2090 */
cs_amp_lib_test_cal_efi_update_hp(struct kunit * test)2091 static void cs_amp_lib_test_cal_efi_update_hp(struct kunit *test)
2092 {
2093 struct cs_amp_lib_test_priv *priv = test->priv;
2094 struct device *dev = &priv->amp_dev->dev;
2095 const struct cirrus_amp_efi_data *original_blob;
2096 struct cirrus_amp_cal_data data;
2097
2098 kunit_activate_static_stub(test,
2099 cs_amp_test_hooks->get_efi_variable,
2100 cs_amp_lib_test_get_hp_cal_efi_variable);
2101 kunit_activate_static_stub(test,
2102 cs_amp_test_hooks->set_efi_variable,
2103 cs_amp_lib_test_set_hp_efi_cal_variable);
2104
2105 cs_amp_lib_test_init_dummy_cal_blob(test, 6);
2106 KUNIT_ASSERT_EQ(test, 6, priv->cal_blob->count);
2107
2108 /* Replace entry matching slot 4 */
2109 original_blob = cs_amp_lib_test_cal_blob_dup(test);
2110 get_random_bytes(&data, sizeof(data));
2111 data.calTarget[0] = ~priv->cal_blob->data[4].calTarget[0];
2112 KUNIT_EXPECT_EQ(test, 0, cs_amp_set_efi_calibration_data(dev, 4, -1, &data));
2113 KUNIT_EXPECT_EQ(test, 6, priv->cal_blob->count);
2114 KUNIT_EXPECT_EQ(test, struct_size(priv->cal_blob, data, 6), priv->cal_blob->size);
2115 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[0], &priv->cal_blob->data[0], sizeof(data));
2116 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[1], &priv->cal_blob->data[1], sizeof(data));
2117 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[2], &priv->cal_blob->data[2], sizeof(data));
2118 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[3], &priv->cal_blob->data[3], sizeof(data));
2119 KUNIT_EXPECT_MEMEQ(test, &data, &priv->cal_blob->data[4], sizeof(data));
2120 KUNIT_EXPECT_MEMEQ(test, &original_blob->data[5], &priv->cal_blob->data[5], sizeof(data));
2121 }
2122
cs_amp_lib_test_spkid_lenovo_not_present(struct kunit * test)2123 static void cs_amp_lib_test_spkid_lenovo_not_present(struct kunit *test)
2124 {
2125 struct cs_amp_lib_test_priv *priv = test->priv;
2126 struct device *dev = &priv->amp_dev->dev;
2127
2128 kunit_activate_static_stub(test,
2129 cs_amp_test_hooks->get_efi_variable,
2130 cs_amp_lib_test_get_efi_variable_none);
2131
2132 KUNIT_EXPECT_EQ(test, -ENOENT, cs_amp_get_vendor_spkid(dev));
2133 }
2134
cs_amp_lib_test_get_efi_variable_lenovo_d0(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2135 static efi_status_t cs_amp_lib_test_get_efi_variable_lenovo_d0(efi_char16_t *name,
2136 efi_guid_t *guid,
2137 u32 *returned_attr,
2138 unsigned long *size,
2139 void *buf)
2140 {
2141 struct kunit *test = kunit_get_current_test();
2142
2143 if (efi_guidcmp(*guid, LENOVO_SPEAKER_ID_EFI_GUID) ||
2144 memcmp(name, LENOVO_SPEAKER_ID_EFI_NAME, sizeof(LENOVO_SPEAKER_ID_EFI_NAME)))
2145 return EFI_NOT_FOUND;
2146
2147 KUNIT_ASSERT_EQ(test, *size, 1);
2148 *size = 1;
2149 *(u8 *)buf = 0xd0;
2150
2151 return EFI_SUCCESS;
2152 }
2153
cs_amp_lib_test_get_efi_variable_lenovo_d1(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2154 static efi_status_t cs_amp_lib_test_get_efi_variable_lenovo_d1(efi_char16_t *name,
2155 efi_guid_t *guid,
2156 u32 *returned_attr,
2157 unsigned long *size,
2158 void *buf)
2159 {
2160 struct kunit *test = kunit_get_current_test();
2161
2162 if (efi_guidcmp(*guid, LENOVO_SPEAKER_ID_EFI_GUID) ||
2163 memcmp(name, LENOVO_SPEAKER_ID_EFI_NAME, sizeof(LENOVO_SPEAKER_ID_EFI_NAME)))
2164 return EFI_NOT_FOUND;
2165
2166 KUNIT_ASSERT_EQ(test, *size, 1);
2167 *size = 1;
2168 *(u8 *)buf = 0xd1;
2169
2170 return EFI_SUCCESS;
2171 }
2172
cs_amp_lib_test_get_efi_variable_lenovo_00(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2173 static efi_status_t cs_amp_lib_test_get_efi_variable_lenovo_00(efi_char16_t *name,
2174 efi_guid_t *guid,
2175 u32 *returned_attr,
2176 unsigned long *size,
2177 void *buf)
2178 {
2179 struct kunit *test = kunit_get_current_test();
2180
2181 KUNIT_ASSERT_EQ(test, 0, efi_guidcmp(*guid, LENOVO_SPEAKER_ID_EFI_GUID));
2182 KUNIT_ASSERT_EQ(test, *size, 1);
2183 *size = 1;
2184 *(u8 *)buf = 0;
2185
2186 return EFI_SUCCESS;
2187 }
2188
cs_amp_lib_test_spkid_lenovo_d0(struct kunit * test)2189 static void cs_amp_lib_test_spkid_lenovo_d0(struct kunit *test)
2190 {
2191 struct cs_amp_lib_test_priv *priv = test->priv;
2192 struct device *dev = &priv->amp_dev->dev;
2193
2194 kunit_activate_static_stub(test,
2195 cs_amp_test_hooks->get_efi_variable,
2196 cs_amp_lib_test_get_efi_variable_lenovo_d0);
2197
2198 KUNIT_EXPECT_EQ(test, 0, cs_amp_get_vendor_spkid(dev));
2199 }
2200
cs_amp_lib_test_spkid_lenovo_d1(struct kunit * test)2201 static void cs_amp_lib_test_spkid_lenovo_d1(struct kunit *test)
2202 {
2203 struct cs_amp_lib_test_priv *priv = test->priv;
2204 struct device *dev = &priv->amp_dev->dev;
2205
2206 kunit_activate_static_stub(test,
2207 cs_amp_test_hooks->get_efi_variable,
2208 cs_amp_lib_test_get_efi_variable_lenovo_d1);
2209
2210 KUNIT_EXPECT_EQ(test, 1, cs_amp_get_vendor_spkid(dev));
2211 }
2212
cs_amp_lib_test_spkid_lenovo_illegal(struct kunit * test)2213 static void cs_amp_lib_test_spkid_lenovo_illegal(struct kunit *test)
2214 {
2215 struct cs_amp_lib_test_priv *priv = test->priv;
2216 struct device *dev = &priv->amp_dev->dev;
2217
2218 kunit_activate_static_stub(test,
2219 cs_amp_test_hooks->get_efi_variable,
2220 cs_amp_lib_test_get_efi_variable_lenovo_00);
2221
2222 KUNIT_EXPECT_LT(test, cs_amp_get_vendor_spkid(dev), 0);
2223 }
2224
cs_amp_lib_test_get_efi_variable_buf_too_small(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2225 static efi_status_t cs_amp_lib_test_get_efi_variable_buf_too_small(efi_char16_t *name,
2226 efi_guid_t *guid,
2227 u32 *returned_attr,
2228 unsigned long *size,
2229 void *buf)
2230 {
2231 return EFI_BUFFER_TOO_SMALL;
2232 }
2233
cs_amp_lib_test_spkid_lenovo_oversize(struct kunit * test)2234 static void cs_amp_lib_test_spkid_lenovo_oversize(struct kunit *test)
2235 {
2236 struct cs_amp_lib_test_priv *priv = test->priv;
2237 struct device *dev = &priv->amp_dev->dev;
2238
2239 kunit_activate_static_stub(test,
2240 cs_amp_test_hooks->get_efi_variable,
2241 cs_amp_lib_test_get_efi_variable_buf_too_small);
2242
2243 KUNIT_EXPECT_LT(test, cs_amp_get_vendor_spkid(dev), 0);
2244 }
2245
cs_amp_lib_test_get_efi_variable_hp_30(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2246 static efi_status_t cs_amp_lib_test_get_efi_variable_hp_30(efi_char16_t *name,
2247 efi_guid_t *guid,
2248 u32 *returned_attr,
2249 unsigned long *size,
2250 void *buf)
2251 {
2252 struct kunit *test = kunit_get_current_test();
2253
2254 if (efi_guidcmp(*guid, HP_SPEAKER_ID_EFI_GUID) ||
2255 memcmp(name, HP_SPEAKER_ID_EFI_NAME, sizeof(HP_SPEAKER_ID_EFI_NAME)))
2256 return EFI_NOT_FOUND;
2257
2258 KUNIT_ASSERT_EQ(test, *size, 1);
2259 *size = 1;
2260 *(u8 *)buf = 0x30;
2261
2262 return EFI_SUCCESS;
2263 }
2264
cs_amp_lib_test_get_efi_variable_hp_31(efi_char16_t * name,efi_guid_t * guid,u32 * returned_attr,unsigned long * size,void * buf)2265 static efi_status_t cs_amp_lib_test_get_efi_variable_hp_31(efi_char16_t *name,
2266 efi_guid_t *guid,
2267 u32 *returned_attr,
2268 unsigned long *size,
2269 void *buf)
2270 {
2271 struct kunit *test = kunit_get_current_test();
2272
2273 if (efi_guidcmp(*guid, HP_SPEAKER_ID_EFI_GUID) ||
2274 memcmp(name, HP_SPEAKER_ID_EFI_NAME, sizeof(HP_SPEAKER_ID_EFI_NAME)))
2275 return EFI_NOT_FOUND;
2276
2277 KUNIT_ASSERT_EQ(test, *size, 1);
2278 *size = 1;
2279 *(u8 *)buf = 0x31;
2280
2281 return EFI_SUCCESS;
2282 }
2283
cs_amp_lib_test_spkid_hp_30(struct kunit * test)2284 static void cs_amp_lib_test_spkid_hp_30(struct kunit *test)
2285 {
2286 struct cs_amp_lib_test_priv *priv = test->priv;
2287 struct device *dev = &priv->amp_dev->dev;
2288
2289 kunit_activate_static_stub(test,
2290 cs_amp_test_hooks->get_efi_variable,
2291 cs_amp_lib_test_get_efi_variable_hp_30);
2292
2293 KUNIT_EXPECT_EQ(test, 0, cs_amp_get_vendor_spkid(dev));
2294 }
2295
cs_amp_lib_test_spkid_hp_31(struct kunit * test)2296 static void cs_amp_lib_test_spkid_hp_31(struct kunit *test)
2297 {
2298 struct cs_amp_lib_test_priv *priv = test->priv;
2299 struct device *dev = &priv->amp_dev->dev;
2300
2301 kunit_activate_static_stub(test,
2302 cs_amp_test_hooks->get_efi_variable,
2303 cs_amp_lib_test_get_efi_variable_hp_31);
2304
2305 KUNIT_EXPECT_EQ(test, 1, cs_amp_get_vendor_spkid(dev));
2306 }
2307
cs_amp_lib_test_case_init(struct kunit * test)2308 static int cs_amp_lib_test_case_init(struct kunit *test)
2309 {
2310 struct cs_amp_lib_test_priv *priv;
2311
2312 KUNIT_ASSERT_NOT_NULL(test, cs_amp_test_hooks);
2313
2314 priv = kunit_kzalloc(test, sizeof(*priv), GFP_KERNEL);
2315 if (!priv)
2316 return -ENOMEM;
2317
2318 test->priv = priv;
2319 INIT_LIST_HEAD(&priv->ctl_write_list);
2320
2321 /* Create dummy amp driver dev */
2322 priv->amp_dev = faux_device_create("cs_amp_lib_test_drv", NULL, NULL);
2323 KUNIT_ASSERT_NOT_NULL(test, priv->amp_dev);
2324 KUNIT_ASSERT_EQ(test, 0,
2325 kunit_add_action_or_reset(test,
2326 faux_device_destroy_wrapper,
2327 priv->amp_dev));
2328
2329 return 0;
2330 }
2331
2332 static const struct cs_amp_lib_test_param cs_amp_lib_test_get_cal_param_cases[] = {
2333 { .num_amps = 2, .amp_index = 0 },
2334 { .num_amps = 2, .amp_index = 1 },
2335
2336 { .num_amps = 3, .amp_index = 0 },
2337 { .num_amps = 3, .amp_index = 1 },
2338 { .num_amps = 3, .amp_index = 2 },
2339
2340 { .num_amps = 4, .amp_index = 0 },
2341 { .num_amps = 4, .amp_index = 1 },
2342 { .num_amps = 4, .amp_index = 2 },
2343 { .num_amps = 4, .amp_index = 3 },
2344
2345 { .num_amps = 5, .amp_index = 0 },
2346 { .num_amps = 5, .amp_index = 1 },
2347 { .num_amps = 5, .amp_index = 2 },
2348 { .num_amps = 5, .amp_index = 3 },
2349 { .num_amps = 5, .amp_index = 4 },
2350
2351 { .num_amps = 6, .amp_index = 0 },
2352 { .num_amps = 6, .amp_index = 1 },
2353 { .num_amps = 6, .amp_index = 2 },
2354 { .num_amps = 6, .amp_index = 3 },
2355 { .num_amps = 6, .amp_index = 4 },
2356 { .num_amps = 6, .amp_index = 5 },
2357
2358 { .num_amps = 8, .amp_index = 0 },
2359 { .num_amps = 8, .amp_index = 1 },
2360 { .num_amps = 8, .amp_index = 2 },
2361 { .num_amps = 8, .amp_index = 3 },
2362 { .num_amps = 8, .amp_index = 4 },
2363 { .num_amps = 8, .amp_index = 5 },
2364 { .num_amps = 8, .amp_index = 6 },
2365 { .num_amps = 8, .amp_index = 7 },
2366 };
2367
cs_amp_lib_test_get_cal_param_desc(const struct cs_amp_lib_test_param * param,char * desc)2368 static void cs_amp_lib_test_get_cal_param_desc(const struct cs_amp_lib_test_param *param,
2369 char *desc)
2370 {
2371 snprintf(desc, KUNIT_PARAM_DESC_SIZE, "num_amps:%d amp_index:%d",
2372 param->num_amps, param->amp_index);
2373 }
2374
2375 KUNIT_ARRAY_PARAM(cs_amp_lib_test_get_cal, cs_amp_lib_test_get_cal_param_cases,
2376 cs_amp_lib_test_get_cal_param_desc);
2377
2378 static struct kunit_case cs_amp_lib_test_cases[] = {
2379 /* Tests for getting calibration data from EFI */
2380 KUNIT_CASE(cs_amp_lib_test_cal_data_too_short_test),
2381 KUNIT_CASE(cs_amp_lib_test_cal_count_too_big_test),
2382 KUNIT_CASE(cs_amp_lib_test_no_cal_data_test),
2383 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_uid_not_found_noindex_test),
2384 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_uid_not_found_index_not_found_test),
2385 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_no_uid_index_not_found_test),
2386 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_no_uid_no_index_test),
2387 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_zero_not_matched_test),
2388 KUNIT_CASE(cs_amp_lib_test_get_hp_efi_cal),
2389 KUNIT_CASE_PARAM(cs_amp_lib_test_get_efi_cal_by_uid_test,
2390 cs_amp_lib_test_get_cal_gen_params),
2391 KUNIT_CASE_PARAM(cs_amp_lib_test_get_efi_cal_by_index_unchecked_test,
2392 cs_amp_lib_test_get_cal_gen_params),
2393 KUNIT_CASE_PARAM(cs_amp_lib_test_get_efi_cal_by_index_checked_test,
2394 cs_amp_lib_test_get_cal_gen_params),
2395 KUNIT_CASE_PARAM(cs_amp_lib_test_get_efi_cal_by_index_uid_mismatch_test,
2396 cs_amp_lib_test_get_cal_gen_params),
2397 KUNIT_CASE_PARAM(cs_amp_lib_test_get_efi_cal_by_index_fallback_test,
2398 cs_amp_lib_test_get_cal_gen_params),
2399 KUNIT_CASE(cs_amp_lib_test_get_efi_cal_empty_entry_test),
2400
2401 /* Tests for writing and reading calibration data */
2402 KUNIT_CASE(cs_amp_lib_test_write_cal_data_test),
2403 KUNIT_CASE(cs_amp_lib_test_read_cal_data_test),
2404 KUNIT_CASE(cs_amp_lib_test_write_ambient_test),
2405
2406 /* Test cases for writing cal data to UEFI */
2407 KUNIT_CASE(cs_amp_lib_test_create_new_cal_efi),
2408 KUNIT_CASE(cs_amp_lib_test_create_new_cal_efi_indexed),
2409 KUNIT_CASE(cs_amp_lib_test_create_new_cal_efi_indexed_no_max),
2410 KUNIT_CASE(cs_amp_lib_test_cal_efi_all_zeros_add_first),
2411 KUNIT_CASE(cs_amp_lib_test_cal_efi_all_zeros_add_first_no_shrink),
2412 KUNIT_CASE(cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed),
2413 KUNIT_CASE(cs_amp_lib_test_cal_efi_all_zeros_add_first_indexed_no_shrink),
2414 KUNIT_CASE(cs_amp_lib_test_grow_append_cal_efi),
2415 KUNIT_CASE(cs_amp_lib_test_grow_append_cal_efi_indexed),
2416 KUNIT_CASE(cs_amp_lib_test_grow_append_cal_efi_indexed_no_max),
2417 KUNIT_CASE(cs_amp_lib_test_grow_cal_efi_replace_indexed),
2418 KUNIT_CASE(cs_amp_lib_test_grow_cal_efi_replace_by_uid),
2419 KUNIT_CASE(cs_amp_lib_test_cal_efi_replace_by_uid),
2420 KUNIT_CASE(cs_amp_lib_test_cal_efi_replace_by_index),
2421 KUNIT_CASE(cs_amp_lib_test_cal_efi_deduplicate),
2422 KUNIT_CASE(cs_amp_lib_test_cal_efi_find_free),
2423 KUNIT_CASE(cs_amp_lib_test_cal_efi_bad_cal_target),
2424 KUNIT_CASE(cs_amp_lib_test_cal_efi_write_denied),
2425 KUNIT_CASE(cs_amp_lib_test_cal_efi_attr_preserved),
2426 KUNIT_CASE(cs_amp_lib_test_cal_efi_update_hp),
2427
2428 /* Test cases for speaker ID */
2429 KUNIT_CASE(cs_amp_lib_test_spkid_lenovo_not_present),
2430 KUNIT_CASE(cs_amp_lib_test_spkid_lenovo_d0),
2431 KUNIT_CASE(cs_amp_lib_test_spkid_lenovo_d1),
2432 KUNIT_CASE(cs_amp_lib_test_spkid_lenovo_illegal),
2433 KUNIT_CASE(cs_amp_lib_test_spkid_lenovo_oversize),
2434 KUNIT_CASE(cs_amp_lib_test_spkid_hp_30),
2435 KUNIT_CASE(cs_amp_lib_test_spkid_hp_31),
2436
2437 { } /* terminator */
2438 };
2439
2440 static struct kunit_suite cs_amp_lib_test_suite = {
2441 .name = "snd-soc-cs-amp-lib-test",
2442 .init = cs_amp_lib_test_case_init,
2443 .test_cases = cs_amp_lib_test_cases,
2444 };
2445
2446 kunit_test_suite(cs_amp_lib_test_suite);
2447
2448 MODULE_IMPORT_NS("SND_SOC_CS_AMP_LIB");
2449 MODULE_DESCRIPTION("KUnit test for Cirrus Logic amplifier library");
2450 MODULE_AUTHOR("Richard Fitzgerald <rf@opensource.cirrus.com>");
2451 MODULE_LICENSE("GPL");
2452