cs-amp-lib-test.c

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