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