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 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 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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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. */ 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. */ 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. */ 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. */ 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 */ 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 */ 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 */ 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 */ 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 */ 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. */ 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 */ 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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