1 // SPDX-License-Identifier: GPL-2.0-only 1 2 // 3 // KUnit test for the Cirrus common amplifier 4 // 5 // Copyright (C) 2024 Cirrus Logic, Inc. and 6 // Cirrus Logic Internation 7 8 #include <kunit/test.h> 9 #include <kunit/static_stub.h> 10 #include <linux/firmware/cirrus/cs_dsp.h> 11 #include <linux/firmware/cirrus/wmfw.h> 12 #include <linux/gpio/driver.h> 13 #include <linux/list.h> 14 #include <linux/module.h> 15 #include <linux/platform_device.h> 16 #include <linux/random.h> 17 #include <sound/cs-amp-lib.h> 18 19 struct cs_amp_lib_test_priv { 20 struct platform_device amp_pdev; 21 22 struct cirrus_amp_efi_data *cal_blob; 23 struct list_head ctl_write_list; 24 }; 25 26 struct cs_amp_lib_test_ctl_write_entry { 27 struct list_head list; 28 unsigned int value; 29 char name[16]; 30 }; 31 32 struct cs_amp_lib_test_param { 33 int num_amps; 34 int amp_index; 35 }; 36 37 static void cs_amp_lib_test_init_dummy_cal_blo 38 { 39 struct cs_amp_lib_test_priv *priv = te 40 unsigned int blob_size; 41 42 blob_size = offsetof(struct cirrus_amp 43 sizeof(struct cirrus_amp_c 44 45 priv->cal_blob = kunit_kzalloc(test, b 46 KUNIT_ASSERT_NOT_NULL(test, priv->cal_ 47 48 priv->cal_blob->size = blob_size; 49 priv->cal_blob->count = num_amps; 50 51 get_random_bytes(priv->cal_blob->data, 52 } 53 54 static u64 cs_amp_lib_test_get_target_uid(stru 55 { 56 struct cs_amp_lib_test_priv *priv = te 57 const struct cs_amp_lib_test_param *pa 58 u64 uid; 59 60 uid = priv->cal_blob->data[param->amp_ 61 uid <<= 32; 62 uid |= priv->cal_blob->data[param->amp 63 64 return uid; 65 } 66 67 /* Redirected get_efi_variable to simulate tha 68 static efi_status_t cs_amp_lib_test_get_efi_va 69 70 71 72 { 73 if (!buf) { 74 *size = offsetof(struct cirrus 75 return EFI_BUFFER_TOO_SMALL; 76 } 77 78 return EFI_NOT_FOUND; 79 } 80 81 /* Should return -EOVERFLOW if the header is l 82 static void cs_amp_lib_test_cal_data_too_short 83 { 84 struct cs_amp_lib_test_priv *priv = te 85 struct cirrus_amp_cal_data result_data 86 int ret; 87 88 /* Redirect calls to get EFI data */ 89 kunit_activate_static_stub(test, 90 cs_amp_test 91 cs_amp_lib_ 92 93 ret = cs_amp_get_efi_calibration_data( 94 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW) 95 96 kunit_deactivate_static_stub(test, cs_ 97 } 98 99 /* Redirected get_efi_variable to simulate tha 100 static efi_status_t cs_amp_lib_test_get_efi_va 101 102 103 104 { 105 struct kunit *test = kunit_get_current 106 struct cs_amp_lib_test_priv *priv = te 107 108 if (!buf) { 109 /* 110 * Return a size that is short 111 * declared number of entries. 112 */ 113 *size = priv->cal_blob->size - 114 return EFI_BUFFER_TOO_SMALL; 115 } 116 117 memcpy(buf, priv->cal_blob, priv->cal_ 118 119 return EFI_SUCCESS; 120 } 121 122 /* Should return -EOVERFLOW if the entry count 123 static void cs_amp_lib_test_cal_count_too_big_ 124 { 125 struct cs_amp_lib_test_priv *priv = te 126 struct cirrus_amp_cal_data result_data 127 int ret; 128 129 cs_amp_lib_test_init_dummy_cal_blob(te 130 131 /* Redirect calls to get EFI data */ 132 kunit_activate_static_stub(test, 133 cs_amp_test 134 cs_amp_lib_ 135 136 ret = cs_amp_get_efi_calibration_data( 137 KUNIT_EXPECT_EQ(test, ret, -EOVERFLOW) 138 139 kunit_deactivate_static_stub(test, cs_ 140 } 141 142 /* Redirected get_efi_variable to simulate tha 143 static efi_status_t cs_amp_lib_test_get_efi_va 144 145 146 147 { 148 return EFI_NOT_FOUND; 149 } 150 151 /* If EFI doesn't contain a cal data variable 152 static void cs_amp_lib_test_no_cal_data_test(s 153 { 154 struct cs_amp_lib_test_priv *priv = te 155 struct cirrus_amp_cal_data result_data 156 int ret; 157 158 /* Redirect calls to get EFI data */ 159 kunit_activate_static_stub(test, 160 cs_amp_test 161 cs_amp_lib_ 162 163 ret = cs_amp_get_efi_calibration_data( 164 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 165 166 kunit_deactivate_static_stub(test, cs_ 167 } 168 169 /* Redirected get_efi_variable to simulate rea 170 static efi_status_t cs_amp_lib_test_get_efi_va 171 172 173 174 { 175 static const efi_char16_t expected_nam 176 static const efi_guid_t expected_guid 177 EFI_GUID(0x02f9af02, 0x7734, 0 178 struct kunit *test = kunit_get_current 179 struct cs_amp_lib_test_priv *priv = te 180 181 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, nam 182 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, gui 183 KUNIT_EXPECT_NOT_ERR_OR_NULL(test, siz 184 185 KUNIT_EXPECT_MEMEQ(test, name, expecte 186 KUNIT_EXPECT_MEMEQ(test, guid, &expect 187 188 if (!buf) { 189 *size = priv->cal_blob->size; 190 return EFI_BUFFER_TOO_SMALL; 191 } 192 193 KUNIT_ASSERT_GE_MSG(test, ksize(buf), 194 195 memcpy(buf, priv->cal_blob, priv->cal_ 196 197 return EFI_SUCCESS; 198 } 199 200 /* Get cal data block for a given amp, matched 201 static void cs_amp_lib_test_get_efi_cal_by_uid 202 { 203 struct cs_amp_lib_test_priv *priv = te 204 const struct cs_amp_lib_test_param *pa 205 struct cirrus_amp_cal_data result_data 206 u64 target_uid; 207 int ret; 208 209 cs_amp_lib_test_init_dummy_cal_blob(te 210 211 /* Redirect calls to get EFI data */ 212 kunit_activate_static_stub(test, 213 cs_amp_test 214 cs_amp_lib_ 215 216 target_uid = cs_amp_lib_test_get_targe 217 ret = cs_amp_get_efi_calibration_data( 218 KUNIT_EXPECT_EQ(test, ret, 0); 219 220 kunit_deactivate_static_stub(test, cs_ 221 222 KUNIT_EXPECT_EQ(test, result_data.calT 223 KUNIT_EXPECT_EQ(test, result_data.calT 224 KUNIT_EXPECT_EQ(test, result_data.calT 225 priv->cal_blob-> 226 KUNIT_EXPECT_EQ(test, result_data.calT 227 priv->cal_blob-> 228 KUNIT_EXPECT_EQ(test, result_data.calA 229 priv->cal_blob-> 230 KUNIT_EXPECT_EQ(test, result_data.calS 231 priv->cal_blob-> 232 KUNIT_EXPECT_EQ(test, result_data.calR 233 priv->cal_blob-> 234 } 235 236 /* Get cal data block for a given amp index wi 237 static void cs_amp_lib_test_get_efi_cal_by_ind 238 { 239 struct cs_amp_lib_test_priv *priv = te 240 const struct cs_amp_lib_test_param *pa 241 struct cirrus_amp_cal_data result_data 242 int ret; 243 244 cs_amp_lib_test_init_dummy_cal_blob(te 245 246 /* Redirect calls to get EFI data */ 247 kunit_activate_static_stub(test, 248 cs_amp_test 249 cs_amp_lib_ 250 251 ret = cs_amp_get_efi_calibration_data( 252 253 KUNIT_EXPECT_EQ(test, ret, 0); 254 255 kunit_deactivate_static_stub(test, cs_ 256 257 KUNIT_EXPECT_EQ(test, result_data.calT 258 priv->cal_blob-> 259 KUNIT_EXPECT_EQ(test, result_data.calT 260 priv->cal_blob-> 261 KUNIT_EXPECT_EQ(test, result_data.calA 262 priv->cal_blob-> 263 KUNIT_EXPECT_EQ(test, result_data.calS 264 priv->cal_blob-> 265 KUNIT_EXPECT_EQ(test, result_data.calR 266 priv->cal_blob-> 267 } 268 269 /* Get cal data block for a given amp index wi 270 static void cs_amp_lib_test_get_efi_cal_by_ind 271 { 272 struct cs_amp_lib_test_priv *priv = te 273 const struct cs_amp_lib_test_param *pa 274 struct cirrus_amp_cal_data result_data 275 u64 target_uid; 276 int ret; 277 278 cs_amp_lib_test_init_dummy_cal_blob(te 279 280 /* Redirect calls to get EFI data */ 281 kunit_activate_static_stub(test, 282 cs_amp_test 283 cs_amp_lib_ 284 285 target_uid = cs_amp_lib_test_get_targe 286 ret = cs_amp_get_efi_calibration_data( 287 288 KUNIT_EXPECT_EQ(test, ret, 0); 289 290 kunit_deactivate_static_stub(test, cs_ 291 292 KUNIT_EXPECT_EQ(test, result_data.calT 293 priv->cal_blob-> 294 KUNIT_EXPECT_EQ(test, result_data.calT 295 priv->cal_blob-> 296 KUNIT_EXPECT_EQ(test, result_data.calA 297 priv->cal_blob-> 298 KUNIT_EXPECT_EQ(test, result_data.calS 299 priv->cal_blob-> 300 KUNIT_EXPECT_EQ(test, result_data.calR 301 priv->cal_blob-> 302 } 303 304 /* 305 * Get cal data block for a given amp index wi 306 * The UID does not match so the result should 307 */ 308 static void cs_amp_lib_test_get_efi_cal_by_ind 309 { 310 struct cs_amp_lib_test_priv *priv = te 311 const struct cs_amp_lib_test_param *pa 312 struct cirrus_amp_cal_data result_data 313 u64 target_uid; 314 int ret; 315 316 cs_amp_lib_test_init_dummy_cal_blob(te 317 318 /* Redirect calls to get EFI data */ 319 kunit_activate_static_stub(test, 320 cs_amp_test 321 cs_amp_lib_ 322 323 /* Get a target UID that won't match t 324 target_uid = ~cs_amp_lib_test_get_targ 325 ret = cs_amp_get_efi_calibration_data( 326 327 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 328 329 kunit_deactivate_static_stub(test, cs_ 330 } 331 332 /* 333 * Get cal data block for a given amp, where t 334 * specify calTarget so the lookup falls back 335 */ 336 static void cs_amp_lib_test_get_efi_cal_by_ind 337 { 338 struct cs_amp_lib_test_priv *priv = te 339 const struct cs_amp_lib_test_param *pa 340 struct cirrus_amp_cal_data result_data 341 static const u64 bad_target_uid = 0xBA 342 int i, ret; 343 344 cs_amp_lib_test_init_dummy_cal_blob(te 345 346 /* Make all the target values zero so 347 for (i = 0; i < priv->cal_blob->count; 348 priv->cal_blob->data[i].calTar 349 priv->cal_blob->data[i].calTar 350 } 351 352 /* Redirect calls to get EFI data */ 353 kunit_activate_static_stub(test, 354 cs_amp_test 355 cs_amp_lib_ 356 357 ret = cs_amp_get_efi_calibration_data( 358 359 KUNIT_EXPECT_EQ(test, ret, 0); 360 361 kunit_deactivate_static_stub(test, cs_ 362 363 KUNIT_EXPECT_EQ(test, result_data.calT 364 priv->cal_blob-> 365 KUNIT_EXPECT_EQ(test, result_data.calT 366 priv->cal_blob-> 367 KUNIT_EXPECT_EQ(test, result_data.calA 368 priv->cal_blob-> 369 KUNIT_EXPECT_EQ(test, result_data.calS 370 priv->cal_blob-> 371 KUNIT_EXPECT_EQ(test, result_data.calR 372 priv->cal_blob-> 373 } 374 375 /* 376 * If the target UID isn't present in the cal 377 * index to fall back do, the result should be 378 */ 379 static void cs_amp_lib_test_get_efi_cal_uid_no 380 { 381 struct cs_amp_lib_test_priv *priv = te 382 struct cirrus_amp_cal_data result_data 383 static const u64 bad_target_uid = 0xBA 384 int i, ret; 385 386 cs_amp_lib_test_init_dummy_cal_blob(te 387 388 /* Make all the target values != bad_t 389 for (i = 0; i < priv->cal_blob->count; 390 priv->cal_blob->data[i].calTar 391 priv->cal_blob->data[i].calTar 392 } 393 394 /* Redirect calls to get EFI data */ 395 kunit_activate_static_stub(test, 396 cs_amp_test 397 cs_amp_lib_ 398 399 ret = cs_amp_get_efi_calibration_data( 400 401 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 402 403 kunit_deactivate_static_stub(test, cs_ 404 } 405 406 /* 407 * If the target UID isn't present in the cal 408 * out of range, the result should be -ENOENT. 409 */ 410 static void cs_amp_lib_test_get_efi_cal_uid_no 411 { 412 struct cs_amp_lib_test_priv *priv = te 413 struct cirrus_amp_cal_data result_data 414 static const u64 bad_target_uid = 0xBA 415 int i, ret; 416 417 cs_amp_lib_test_init_dummy_cal_blob(te 418 419 /* Make all the target values != bad_t 420 for (i = 0; i < priv->cal_blob->count; 421 priv->cal_blob->data[i].calTar 422 priv->cal_blob->data[i].calTar 423 } 424 425 /* Redirect calls to get EFI data */ 426 kunit_activate_static_stub(test, 427 cs_amp_test 428 cs_amp_lib_ 429 430 ret = cs_amp_get_efi_calibration_data( 431 432 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 433 434 kunit_deactivate_static_stub(test, cs_ 435 } 436 437 /* 438 * If the target UID isn't given, and the inde 439 * result should be -ENOENT. 440 */ 441 static void cs_amp_lib_test_get_efi_cal_no_uid 442 { 443 struct cs_amp_lib_test_priv *priv = te 444 struct cirrus_amp_cal_data result_data 445 int ret; 446 447 cs_amp_lib_test_init_dummy_cal_blob(te 448 449 /* Redirect calls to get EFI data */ 450 kunit_activate_static_stub(test, 451 cs_amp_test 452 cs_amp_lib_ 453 454 ret = cs_amp_get_efi_calibration_data( 455 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 456 457 kunit_deactivate_static_stub(test, cs_ 458 } 459 460 /* If neither the target UID or the index is g 461 static void cs_amp_lib_test_get_efi_cal_no_uid 462 { 463 struct cs_amp_lib_test_priv *priv = te 464 struct cirrus_amp_cal_data result_data 465 int ret; 466 467 cs_amp_lib_test_init_dummy_cal_blob(te 468 469 /* Redirect calls to get EFI data */ 470 kunit_activate_static_stub(test, 471 cs_amp_test 472 cs_amp_lib_ 473 474 ret = cs_amp_get_efi_calibration_data( 475 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 476 477 kunit_deactivate_static_stub(test, cs_ 478 } 479 480 /* 481 * If the UID is passed as 0 this must not mat 482 * unpopulated calTarget 483 */ 484 static void cs_amp_lib_test_get_efi_cal_zero_n 485 { 486 struct cs_amp_lib_test_priv *priv = te 487 struct cirrus_amp_cal_data result_data 488 int i, ret; 489 490 cs_amp_lib_test_init_dummy_cal_blob(te 491 492 /* Make all the target values zero so 493 for (i = 0; i < priv->cal_blob->count; 494 priv->cal_blob->data[i].calTar 495 priv->cal_blob->data[i].calTar 496 } 497 498 /* Redirect calls to get EFI data */ 499 kunit_activate_static_stub(test, 500 cs_amp_test 501 cs_amp_lib_ 502 503 ret = cs_amp_get_efi_calibration_data( 504 KUNIT_EXPECT_EQ(test, ret, -ENOENT); 505 506 kunit_deactivate_static_stub(test, cs_ 507 } 508 509 static const struct cirrus_amp_cal_controls cs 510 .alg_id = 0x9f210, 511 .mem_region = WMFW_ADSP2_YM, 512 .ambient = "CAL_AMBIENT", 513 .calr = "CAL_R", 514 .status = "CAL_STATUS", 515 .checksum = "CAL_CHECKSUM", 516 }; 517 518 static int cs_amp_lib_test_write_cal_coeff(str 519 con 520 con 521 { 522 struct kunit *test = kunit_get_current 523 struct cs_amp_lib_test_priv *priv = te 524 struct cs_amp_lib_test_ctl_write_entry 525 526 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctl 527 KUNIT_EXPECT_PTR_EQ(test, controls, &c 528 529 entry = kunit_kzalloc(test, sizeof(*en 530 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ent 531 532 INIT_LIST_HEAD(&entry->list); 533 strscpy(entry->name, ctl_name, sizeof( 534 entry->value = val; 535 536 list_add_tail(&entry->list, &priv->ctl 537 538 return 0; 539 } 540 541 static void cs_amp_lib_test_write_cal_data_tes 542 { 543 struct cs_amp_lib_test_priv *priv = te 544 struct cs_amp_lib_test_ctl_write_entry 545 struct cirrus_amp_cal_data data; 546 struct cs_dsp *dsp; 547 int ret; 548 549 dsp = kunit_kzalloc(test, sizeof(*dsp) 550 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, dsp 551 dsp->dev = &priv->amp_pdev.dev; 552 553 get_random_bytes(&data, sizeof(data)); 554 555 /* Redirect calls to write firmware co 556 kunit_activate_static_stub(test, 557 cs_amp_test 558 cs_amp_lib_ 559 560 ret = cs_amp_write_cal_coeffs(dsp, &cs 561 KUNIT_EXPECT_EQ(test, ret, 0); 562 563 kunit_deactivate_static_stub(test, cs_ 564 565 KUNIT_EXPECT_EQ(test, list_count_nodes 566 567 /* Checksum control must be written la 568 entry = list_last_entry(&priv->ctl_wri 569 KUNIT_EXPECT_STREQ(test, entry->name, 570 KUNIT_EXPECT_EQ(test, entry->value, da 571 list_del(&entry->list); 572 573 entry = list_first_entry(&priv->ctl_wr 574 KUNIT_EXPECT_STREQ(test, entry->name, 575 KUNIT_EXPECT_EQ(test, entry->value, da 576 list_del(&entry->list); 577 578 entry = list_first_entry(&priv->ctl_wr 579 KUNIT_EXPECT_STREQ(test, entry->name, 580 KUNIT_EXPECT_EQ(test, entry->value, da 581 list_del(&entry->list); 582 583 entry = list_first_entry(&priv->ctl_wr 584 KUNIT_EXPECT_STREQ(test, entry->name, 585 KUNIT_EXPECT_EQ(test, entry->value, da 586 } 587 588 static void cs_amp_lib_test_dev_release(struct 589 { 590 } 591 592 static int cs_amp_lib_test_case_init(struct ku 593 { 594 struct cs_amp_lib_test_priv *priv; 595 int ret; 596 597 KUNIT_ASSERT_NOT_NULL(test, cs_amp_tes 598 599 priv = kunit_kzalloc(test, sizeof(*pri 600 if (!priv) 601 return -ENOMEM; 602 603 test->priv = priv; 604 INIT_LIST_HEAD(&priv->ctl_write_list); 605 606 /* Create dummy amp driver dev */ 607 priv->amp_pdev.name = "cs_amp_lib_test 608 priv->amp_pdev.id = -1; 609 priv->amp_pdev.dev.release = cs_amp_li 610 ret = platform_device_register(&priv-> 611 KUNIT_ASSERT_GE_MSG(test, ret, 0, "Fai 612 613 return 0; 614 } 615 616 static void cs_amp_lib_test_case_exit(struct k 617 { 618 struct cs_amp_lib_test_priv *priv = te 619 620 if (priv->amp_pdev.name) 621 platform_device_unregister(&pr 622 } 623 624 static const struct cs_amp_lib_test_param cs_a 625 { .num_amps = 2, .amp_index = 0 }, 626 { .num_amps = 2, .amp_index = 1 }, 627 628 { .num_amps = 3, .amp_index = 0 }, 629 { .num_amps = 3, .amp_index = 1 }, 630 { .num_amps = 3, .amp_index = 2 }, 631 632 { .num_amps = 4, .amp_index = 0 }, 633 { .num_amps = 4, .amp_index = 1 }, 634 { .num_amps = 4, .amp_index = 2 }, 635 { .num_amps = 4, .amp_index = 3 }, 636 637 { .num_amps = 5, .amp_index = 0 }, 638 { .num_amps = 5, .amp_index = 1 }, 639 { .num_amps = 5, .amp_index = 2 }, 640 { .num_amps = 5, .amp_index = 3 }, 641 { .num_amps = 5, .amp_index = 4 }, 642 643 { .num_amps = 6, .amp_index = 0 }, 644 { .num_amps = 6, .amp_index = 1 }, 645 { .num_amps = 6, .amp_index = 2 }, 646 { .num_amps = 6, .amp_index = 3 }, 647 { .num_amps = 6, .amp_index = 4 }, 648 { .num_amps = 6, .amp_index = 5 }, 649 650 { .num_amps = 8, .amp_index = 0 }, 651 { .num_amps = 8, .amp_index = 1 }, 652 { .num_amps = 8, .amp_index = 2 }, 653 { .num_amps = 8, .amp_index = 3 }, 654 { .num_amps = 8, .amp_index = 4 }, 655 { .num_amps = 8, .amp_index = 5 }, 656 { .num_amps = 8, .amp_index = 6 }, 657 { .num_amps = 8, .amp_index = 7 }, 658 }; 659 660 static void cs_amp_lib_test_get_cal_param_desc 661 662 { 663 snprintf(desc, KUNIT_PARAM_DESC_SIZE, 664 param->num_amps, param->amp_i 665 } 666 667 KUNIT_ARRAY_PARAM(cs_amp_lib_test_get_cal, cs_ 668 cs_amp_lib_test_get_cal_para 669 670 static struct kunit_case cs_amp_lib_test_cases 671 /* Tests for getting calibration data 672 KUNIT_CASE(cs_amp_lib_test_cal_data_to 673 KUNIT_CASE(cs_amp_lib_test_cal_count_t 674 KUNIT_CASE(cs_amp_lib_test_no_cal_data 675 KUNIT_CASE(cs_amp_lib_test_get_efi_cal 676 KUNIT_CASE(cs_amp_lib_test_get_efi_cal 677 KUNIT_CASE(cs_amp_lib_test_get_efi_cal 678 KUNIT_CASE(cs_amp_lib_test_get_efi_cal 679 KUNIT_CASE(cs_amp_lib_test_get_efi_cal 680 KUNIT_CASE_PARAM(cs_amp_lib_test_get_e 681 cs_amp_lib_test_get_c 682 KUNIT_CASE_PARAM(cs_amp_lib_test_get_e 683 cs_amp_lib_test_get_c 684 KUNIT_CASE_PARAM(cs_amp_lib_test_get_e 685 cs_amp_lib_test_get_c 686 KUNIT_CASE_PARAM(cs_amp_lib_test_get_e 687 cs_amp_lib_test_get_c 688 KUNIT_CASE_PARAM(cs_amp_lib_test_get_e 689 cs_amp_lib_test_get_c 690 691 /* Tests for writing calibration data 692 KUNIT_CASE(cs_amp_lib_test_write_cal_d 693 694 { } /* terminator */ 695 }; 696 697 static struct kunit_suite cs_amp_lib_test_suit 698 .name = "snd-soc-cs-amp-lib-test", 699 .init = cs_amp_lib_test_case_init, 700 .exit = cs_amp_lib_test_case_exit, 701 .test_cases = cs_amp_lib_test_cases, 702 }; 703 704 kunit_test_suite(cs_amp_lib_test_suite); 705 706 MODULE_IMPORT_NS(SND_SOC_CS_AMP_LIB); 707 MODULE_DESCRIPTION("KUnit test for Cirrus Logi 708 MODULE_AUTHOR("Richard Fitzgerald <rf@opensour 709 MODULE_LICENSE("GPL"); 710
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.