Lines Matching +full:cal +full:- +full:blob
1 // SPDX-License-Identifier: GPL-2.0-only
20 #include <sound/cs-amp-lib.h>
53 struct cs_amp_lib_test_priv *priv = test->priv;
57 blob_size = struct_size(priv->cal_blob, data, num_amps);
59 priv->cal_blob = kunit_kzalloc(test, blob_size, GFP_KERNEL);
60 KUNIT_ASSERT_NOT_NULL(test, priv->cal_blob);
62 priv->cal_blob->size = blob_size;
63 priv->cal_blob->count = num_amps;
65 get_random_bytes(priv->cal_blob->data, flex_array_size(priv->cal_blob, data, num_amps));
67 /* Ensure all timestamps are non-zero to mark the entry valid. */
69 priv->cal_blob->data[i].calTime[0] |= 1;
71 /* Ensure that all UIDs are non-zero and unique. */
73 *(u8 *)&priv->cal_blob->data[i].calTarget[0] = i + 1;
78 struct cs_amp_lib_test_priv *priv = test->priv;
79 const struct cs_amp_lib_test_param *param = test->param_value;
82 uid = priv->cal_blob->data[param->amp_index].calTarget[1];
84 uid |= priv->cal_blob->data[param->amp_index].calTarget[0];
96 *size = offsetof(struct cirrus_amp_efi_data, data) - 1;
103 /* Should return -EOVERFLOW if the header is larger than the EFI data */
106 struct cs_amp_lib_test_priv *priv = test->priv;
112 cs_amp_test_hooks->get_efi_variable,
115 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
116 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW);
118 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
128 struct cs_amp_lib_test_priv *priv = test->priv;
135 *size = priv->cal_blob->size - 1;
139 memcpy(buf, priv->cal_blob, priv->cal_blob->size - 1);
144 /* Should return -EOVERFLOW if the entry count is larger than the EFI data */
147 struct cs_amp_lib_test_priv *priv = test->priv;
155 cs_amp_test_hooks->get_efi_variable,
158 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
159 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW);
161 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
173 /* If EFI doesn't contain a cal data variable the result should be -ENOENT */
176 struct cs_amp_lib_test_priv *priv = test->priv;
182 cs_amp_test_hooks->get_efi_variable,
185 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
186 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
188 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
191 /* Redirected get_efi_variable to simulate reading a cal data blob */
201 struct cs_amp_lib_test_priv *priv = test->priv;
209 return -EFI_NOT_FOUND;
212 *size = priv->cal_blob->size;
216 KUNIT_ASSERT_GE_MSG(test, ksize(buf), priv->cal_blob->size, "Buffer to small");
218 memcpy(buf, priv->cal_blob, priv->cal_blob->size);
232 struct cs_amp_lib_test_priv *priv = test->priv;
240 return -EFI_NOT_FOUND;
243 *size = priv->cal_blob->size;
247 KUNIT_ASSERT_GE_MSG(test, ksize(buf), priv->cal_blob->size, "Buffer to small");
249 memcpy(buf, priv->cal_blob, priv->cal_blob->size);
254 /* Get cal data block from HP variable. */
257 struct cs_amp_lib_test_priv *priv = test->priv;
264 cs_amp_test_hooks->get_efi_variable,
267 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 0, &result_data);
270 KUNIT_EXPECT_MEMEQ(test, &result_data, &priv->cal_blob->data[0], sizeof(result_data));
273 /* Get cal data block for a given amp, matched by target UID. */
276 struct cs_amp_lib_test_priv *priv = test->priv;
277 const struct cs_amp_lib_test_param *param = test->param_value;
282 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
286 cs_amp_test_hooks->get_efi_variable,
290 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid, -1, &result_data);
293 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
298 priv->cal_blob->data[param->amp_index].calTime[0]);
300 priv->cal_blob->data[param->amp_index].calTime[1]);
302 priv->cal_blob->data[param->amp_index].calAmbient);
304 priv->cal_blob->data[param->amp_index].calStatus);
306 priv->cal_blob->data[param->amp_index].calR);
309 /* Get cal data block for a given amp index without checking target UID. */
312 struct cs_amp_lib_test_priv *priv = test->priv;
313 const struct cs_amp_lib_test_param *param = test->param_value;
317 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
321 cs_amp_test_hooks->get_efi_variable,
324 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0,
325 param->amp_index, &result_data);
328 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
331 priv->cal_blob->data[param->amp_index].calTime[0]);
333 priv->cal_blob->data[param->amp_index].calTime[1]);
335 priv->cal_blob->data[param->amp_index].calAmbient);
337 priv->cal_blob->data[param->amp_index].calStatus);
339 priv->cal_blob->data[param->amp_index].calR);
342 /* Get cal data block for a given amp index with checked target UID. */
345 struct cs_amp_lib_test_priv *priv = test->priv;
346 const struct cs_amp_lib_test_param *param = test->param_value;
351 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
355 cs_amp_test_hooks->get_efi_variable,
359 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid,
360 param->amp_index, &result_data);
363 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
366 priv->cal_blob->data[param->amp_index].calTime[0]);
368 priv->cal_blob->data[param->amp_index].calTime[1]);
370 priv->cal_blob->data[param->amp_index].calAmbient);
372 priv->cal_blob->data[param->amp_index].calStatus);
374 priv->cal_blob->data[param->amp_index].calR);
378 * Get cal data block for a given amp index with checked target UID.
379 * The UID does not match so the result should be -ENOENT.
383 struct cs_amp_lib_test_priv *priv = test->priv;
384 const struct cs_amp_lib_test_param *param = test->param_value;
389 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
393 cs_amp_test_hooks->get_efi_variable,
398 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, target_uid,
399 param->amp_index, &result_data);
400 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
402 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
406 * Get cal data block for a given amp, where the cal data does not
411 struct cs_amp_lib_test_priv *priv = test->priv;
412 const struct cs_amp_lib_test_param *param = test->param_value;
417 cs_amp_lib_test_init_dummy_cal_blob(test, param->num_amps);
420 for (i = 0; i < priv->cal_blob->count; ++i) {
421 priv->cal_blob->data[i].calTarget[0] = 0;
422 priv->cal_blob->data[i].calTarget[1] = 0;
427 cs_amp_test_hooks->get_efi_variable,
430 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid,
431 param->amp_index, &result_data);
434 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
437 priv->cal_blob->data[param->amp_index].calTime[0]);
439 priv->cal_blob->data[param->amp_index].calTime[1]);
441 priv->cal_blob->data[param->amp_index].calAmbient);
443 priv->cal_blob->data[param->amp_index].calStatus);
445 priv->cal_blob->data[param->amp_index].calR);
449 * If the target UID isn't present in the cal data, and there isn't an
450 * index to fall back do, the result should be -ENOENT.
454 struct cs_amp_lib_test_priv *priv = test->priv;
462 for (i = 0; i < priv->cal_blob->count; ++i) {
463 priv->cal_blob->data[i].calTarget[0] &= ~(bad_target_uid & 0xFFFFFFFFULL);
464 priv->cal_blob->data[i].calTarget[1] &= ~(bad_target_uid >> 32);
469 cs_amp_test_hooks->get_efi_variable,
472 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid, -1,
474 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
476 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
480 * If the target UID isn't present in the cal data, and the index is
481 * out of range, the result should be -ENOENT.
485 struct cs_amp_lib_test_priv *priv = test->priv;
493 for (i = 0; i < priv->cal_blob->count; ++i) {
494 priv->cal_blob->data[i].calTarget[0] &= ~(bad_target_uid & 0xFFFFFFFFULL);
495 priv->cal_blob->data[i].calTarget[1] &= ~(bad_target_uid >> 32);
500 cs_amp_test_hooks->get_efi_variable,
503 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, bad_target_uid, 99,
505 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
507 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
512 * result should be -ENOENT.
516 struct cs_amp_lib_test_priv *priv = test->priv;
524 cs_amp_test_hooks->get_efi_variable,
527 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, 99, &result_data);
528 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
530 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
533 /* If neither the target UID or the index is given the result should be -ENOENT. */
536 struct cs_amp_lib_test_priv *priv = test->priv;
544 cs_amp_test_hooks->get_efi_variable,
547 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, -1, &result_data);
548 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
550 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
559 struct cs_amp_lib_test_priv *priv = test->priv;
566 for (i = 0; i < priv->cal_blob->count; ++i) {
567 priv->cal_blob->data[i].calTarget[0] = 0;
568 priv->cal_blob->data[i].calTarget[1] = 0;
573 cs_amp_test_hooks->get_efi_variable,
576 ret = cs_amp_get_efi_calibration_data(&priv->amp_dev->dev, 0, -1, &result_data);
577 KUNIT_EXPECT_EQ(test, ret, -ENOENT);
579 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
588 struct cs_amp_lib_test_priv *priv = test->priv;
595 priv->cal_blob->data[2].calTime[0] = 0;
596 priv->cal_blob->data[2].calTime[1] = 0;
599 uid = priv->cal_blob->data[2].calTarget[1];
601 uid |= priv->cal_blob->data[2].calTarget[0];
605 cs_amp_test_hooks->get_efi_variable,
610 cs_amp_get_efi_calibration_data(&priv->amp_dev->dev,
611 uid, -1,
613 -ENOENT);
617 cs_amp_get_efi_calibration_data(&priv->amp_dev->dev,
620 -ENOENT);
622 kunit_deactivate_static_stub(test, cs_amp_test_hooks->get_efi_variable);
639 struct cs_amp_lib_test_priv *priv = test->priv;
648 INIT_LIST_HEAD(&entry->list);
649 strscpy(entry->name, ctl_name, sizeof(entry->name));
650 entry->value = val;
652 list_add_tail(&entry->list, &priv->ctl_write_list);
659 struct cs_amp_lib_test_priv *priv = test->priv;
667 dsp->dev = &priv->amp_dev->dev;
673 cs_amp_test_hooks->write_cal_coeff,
679 kunit_deactivate_static_stub(test, cs_amp_test_hooks->write_cal_coeff);
681 KUNIT_EXPECT_EQ(test, list_count_nodes(&priv->ctl_write_list), 4);
684 entry = list_last_entry(&priv->ctl_write_list, typeof(*entry), list);
685 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.checksum);
686 KUNIT_EXPECT_EQ(test, entry->value, data.calR + 1);
687 list_del(&entry->list);
689 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
690 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.ambient);
691 KUNIT_EXPECT_EQ(test, entry->value, data.calAmbient);
692 list_del(&entry->list);
694 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
695 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.calr);
696 KUNIT_EXPECT_EQ(test, entry->value, data.calR);
697 list_del(&entry->list);
699 entry = list_first_entry(&priv->ctl_write_list, typeof(*entry), list);
700 KUNIT_EXPECT_STREQ(test, entry->name, cs_amp_lib_test_calibration_controls.status);
701 KUNIT_EXPECT_EQ(test, entry->value, data.calStatus);
706 struct cs_amp_lib_test_priv *priv = test->priv;
707 struct device *dev = &priv->amp_dev->dev;
710 cs_amp_test_hooks->get_efi_variable,
713 KUNIT_EXPECT_EQ(test, -ENOENT, cs_amp_get_vendor_spkid(dev));
769 struct cs_amp_lib_test_priv *priv = test->priv;
770 struct device *dev = &priv->amp_dev->dev;
773 cs_amp_test_hooks->get_efi_variable,
781 struct cs_amp_lib_test_priv *priv = test->priv;
782 struct device *dev = &priv->amp_dev->dev;
785 cs_amp_test_hooks->get_efi_variable,
793 struct cs_amp_lib_test_priv *priv = test->priv;
794 struct device *dev = &priv->amp_dev->dev;
797 cs_amp_test_hooks->get_efi_variable,
813 struct cs_amp_lib_test_priv *priv = test->priv;
814 struct device *dev = &priv->amp_dev->dev;
817 cs_amp_test_hooks->get_efi_variable,
861 struct cs_amp_lib_test_priv *priv = test->priv;
862 struct device *dev = &priv->amp_dev->dev;
865 cs_amp_test_hooks->get_efi_variable,
873 struct cs_amp_lib_test_priv *priv = test->priv;
874 struct device *dev = &priv->amp_dev->dev;
877 cs_amp_test_hooks->get_efi_variable,
891 return -ENOMEM;
893 test->priv = priv;
894 INIT_LIST_HEAD(&priv->ctl_write_list);
897 priv->amp_dev = faux_device_create("cs_amp_lib_test_drv", NULL, NULL);
898 KUNIT_ASSERT_NOT_NULL(test, priv->amp_dev);
902 priv->amp_dev));
947 param->num_amps, param->amp_index);
992 .name = "snd-soc-cs-amp-lib-test",