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