tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

firmware: cs_dsp: test_bin: Make patch function a test parameter

Make the call to cs_dsp_mock_bin_add_patch() a function pointer in
the test case parameters, instead of calling it directly.

This is to allow for future parameterization by which function to
call to add a patch.

Signed-off-by: Richard Fitzgerald <rf@opensource.cirrus.com>
Link: https://patch.msgid.link/20251231172711.450024-4-rf@opensource.cirrus.com
Signed-off-by: Mark Brown <broonie@kernel.org>

authored by

Richard Fitzgerald and committed by
Mark Brown a01816ed afcbb046

+357 -351
+357 -351
drivers/firmware/cirrus/test/cs_dsp_test_bin.c
··· 69 69 int mem_type; 70 70 unsigned int offset_words; 71 71 int alg_idx; 72 + void (*add_patch)(struct cs_dsp_mock_bin_builder *builder, 73 + unsigned int alg_id, unsigned int alg_ver, 74 + int mem_region, unsigned int reg_addr_offset, 75 + const void *payload_data, size_t payload_len_bytes); 72 76 }; 73 77 74 78 static const struct cs_dsp_mock_alg_def bin_test_mock_algs[] = { ··· 132 128 bin_test_mock_algs[param->alg_idx].id, 133 129 param->mem_type); 134 130 135 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 136 - bin_test_mock_algs[param->alg_idx].id, 137 - bin_test_mock_algs[param->alg_idx].ver, 138 - param->mem_type, 139 - param->offset_words * reg_inc_per_word, 140 - &payload_data, sizeof(payload_data)); 131 + param->add_patch(priv->local->bin_builder, 132 + bin_test_mock_algs[param->alg_idx].id, 133 + bin_test_mock_algs[param->alg_idx].ver, 134 + param->mem_type, 135 + param->offset_words * reg_inc_per_word, 136 + &payload_data, sizeof(payload_data)); 141 137 142 138 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 143 139 KUNIT_ASSERT_EQ(test, ··· 181 177 bin_test_mock_algs[param->alg_idx].id, 182 178 param->mem_type); 183 179 184 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 185 - bin_test_mock_algs[param->alg_idx].id, 186 - bin_test_mock_algs[param->alg_idx].ver, 187 - param->mem_type, 188 - param->offset_words * reg_inc_per_word, 189 - payload_data, sizeof(payload_data)); 180 + param->add_patch(priv->local->bin_builder, 181 + bin_test_mock_algs[param->alg_idx].id, 182 + bin_test_mock_algs[param->alg_idx].ver, 183 + param->mem_type, 184 + param->offset_words * reg_inc_per_word, 185 + payload_data, sizeof(payload_data)); 190 186 191 187 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 192 188 KUNIT_ASSERT_EQ(test, ··· 232 228 233 229 /* Add one payload per word */ 234 230 for (i = 0; i < ARRAY_SIZE(payload_data); ++i) { 235 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 236 - bin_test_mock_algs[param->alg_idx].id, 237 - bin_test_mock_algs[param->alg_idx].ver, 238 - param->mem_type, 239 - (param->offset_words + i) * reg_inc_per_word, 240 - &payload_data[i], sizeof(payload_data[i])); 231 + param->add_patch(priv->local->bin_builder, 232 + bin_test_mock_algs[param->alg_idx].id, 233 + bin_test_mock_algs[param->alg_idx].ver, 234 + param->mem_type, 235 + (param->offset_words + i) * reg_inc_per_word, 236 + &payload_data[i], sizeof(payload_data[i])); 241 237 } 242 238 243 239 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 289 285 290 286 /* Add one payload per word */ 291 287 for (i = 0; i < ARRAY_SIZE(word_order); ++i) { 292 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 293 - bin_test_mock_algs[param->alg_idx].id, 294 - bin_test_mock_algs[param->alg_idx].ver, 295 - param->mem_type, 296 - (param->offset_words + word_order[i]) * 297 - reg_inc_per_word, 298 - &payload_data[word_order[i]], sizeof(payload_data[0])); 288 + param->add_patch(priv->local->bin_builder, 289 + bin_test_mock_algs[param->alg_idx].id, 290 + bin_test_mock_algs[param->alg_idx].ver, 291 + param->mem_type, 292 + (param->offset_words + word_order[i]) * 293 + reg_inc_per_word, 294 + &payload_data[word_order[i]], sizeof(payload_data[0])); 299 295 } 300 296 301 297 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 350 346 351 347 /* Add one payload per word */ 352 348 for (i = 0; i < ARRAY_SIZE(word_offsets); ++i) { 353 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 354 - bin_test_mock_algs[param->alg_idx].id, 355 - bin_test_mock_algs[param->alg_idx].ver, 356 - param->mem_type, 357 - word_offsets[i] * reg_inc_per_word, 358 - &payload_data[i], sizeof(payload_data[i])); 349 + param->add_patch(priv->local->bin_builder, 350 + bin_test_mock_algs[param->alg_idx].id, 351 + bin_test_mock_algs[param->alg_idx].ver, 352 + param->mem_type, 353 + word_offsets[i] * reg_inc_per_word, 354 + &payload_data[i], sizeof(payload_data[i])); 359 355 } 360 356 361 357 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 417 413 } 418 414 419 415 /* Add words to XM, YM and ZM */ 420 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 421 - bin_test_mock_algs[param->alg_idx].id, 422 - bin_test_mock_algs[param->alg_idx].ver, 423 - WMFW_ADSP2_XM, 424 - param->offset_words * reg_inc_per_word, 425 - &payload_data[0], sizeof(payload_data[0])); 416 + param->add_patch(priv->local->bin_builder, 417 + bin_test_mock_algs[param->alg_idx].id, 418 + bin_test_mock_algs[param->alg_idx].ver, 419 + WMFW_ADSP2_XM, 420 + param->offset_words * reg_inc_per_word, 421 + &payload_data[0], sizeof(payload_data[0])); 426 422 427 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 428 - bin_test_mock_algs[param->alg_idx].id, 429 - bin_test_mock_algs[param->alg_idx].ver, 430 - WMFW_ADSP2_YM, 431 - param->offset_words * reg_inc_per_word, 432 - &payload_data[1], sizeof(payload_data[1])); 423 + param->add_patch(priv->local->bin_builder, 424 + bin_test_mock_algs[param->alg_idx].id, 425 + bin_test_mock_algs[param->alg_idx].ver, 426 + WMFW_ADSP2_YM, 427 + param->offset_words * reg_inc_per_word, 428 + &payload_data[1], sizeof(payload_data[1])); 433 429 434 430 if (cs_dsp_mock_has_zm(priv)) { 435 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 436 - bin_test_mock_algs[param->alg_idx].id, 437 - bin_test_mock_algs[param->alg_idx].ver, 438 - WMFW_ADSP2_ZM, 439 - param->offset_words * reg_inc_per_word, 440 - &payload_data[2], sizeof(payload_data[2])); 431 + param->add_patch(priv->local->bin_builder, 432 + bin_test_mock_algs[param->alg_idx].id, 433 + bin_test_mock_algs[param->alg_idx].ver, 434 + WMFW_ADSP2_ZM, 435 + param->offset_words * reg_inc_per_word, 436 + &payload_data[2], sizeof(payload_data[2])); 441 437 } 442 438 443 439 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 506 502 for (i = 0; i < ARRAY_SIZE(bin_test_mock_algs); ++i) { 507 503 reg_inc_per_word = cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv); 508 504 509 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 510 - bin_test_mock_algs[i].id, 511 - bin_test_mock_algs[i].ver, 512 - param->mem_type, 513 - param->offset_words * reg_inc_per_word, 514 - &payload_data[i], sizeof(payload_data[i])); 505 + param->add_patch(priv->local->bin_builder, 506 + bin_test_mock_algs[i].id, 507 + bin_test_mock_algs[i].ver, 508 + param->mem_type, 509 + param->offset_words * reg_inc_per_word, 510 + &payload_data[i], sizeof(payload_data[i])); 515 511 } 516 512 517 513 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 569 565 alg_idx = alg_order[i]; 570 566 reg_inc_per_word = cs_dsp_mock_reg_addr_inc_per_unpacked_word(priv); 571 567 572 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 573 - bin_test_mock_algs[alg_idx].id, 574 - bin_test_mock_algs[alg_idx].ver, 575 - param->mem_type, 576 - param->offset_words * reg_inc_per_word, 577 - &payload_data[i], sizeof(payload_data[i])); 568 + param->add_patch(priv->local->bin_builder, 569 + bin_test_mock_algs[alg_idx].id, 570 + bin_test_mock_algs[alg_idx].ver, 571 + param->mem_type, 572 + param->offset_words * reg_inc_per_word, 573 + &payload_data[i], sizeof(payload_data[i])); 578 574 } 579 575 580 576 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 632 628 patch_pos_words = round_up(alg_base_words + param->offset_words, 4); 633 629 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 634 630 635 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 636 - bin_test_mock_algs[param->alg_idx].id, 637 - bin_test_mock_algs[param->alg_idx].ver, 638 - param->mem_type, 639 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 640 - packed_payload, sizeof(packed_payload)); 631 + param->add_patch(priv->local->bin_builder, 632 + bin_test_mock_algs[param->alg_idx].id, 633 + bin_test_mock_algs[param->alg_idx].ver, 634 + param->mem_type, 635 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 636 + packed_payload, sizeof(packed_payload)); 641 637 642 638 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 643 639 KUNIT_ASSERT_EQ(test, ··· 692 688 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 693 689 694 690 /* Patch packed block */ 695 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 696 - bin_test_mock_algs[param->alg_idx].id, 697 - bin_test_mock_algs[param->alg_idx].ver, 698 - param->mem_type, 699 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 700 - &packed_payload, sizeof(packed_payload)); 691 + param->add_patch(priv->local->bin_builder, 692 + bin_test_mock_algs[param->alg_idx].id, 693 + bin_test_mock_algs[param->alg_idx].ver, 694 + param->mem_type, 695 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 696 + &packed_payload, sizeof(packed_payload)); 701 697 702 698 /* ... and the unpacked word following that */ 703 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 704 - bin_test_mock_algs[param->alg_idx].id, 705 - bin_test_mock_algs[param->alg_idx].ver, 706 - unpacked_mem_type, 707 - ((patch_pos_words + 4) - alg_base_words) * 4, 708 - unpacked_payload, sizeof(unpacked_payload)); 699 + param->add_patch(priv->local->bin_builder, 700 + bin_test_mock_algs[param->alg_idx].id, 701 + bin_test_mock_algs[param->alg_idx].ver, 702 + unpacked_mem_type, 703 + ((patch_pos_words + 4) - alg_base_words) * 4, 704 + unpacked_payload, sizeof(unpacked_payload)); 709 705 710 706 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 711 707 KUNIT_ASSERT_EQ(test, ··· 772 768 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 773 769 774 770 /* Patch packed block */ 775 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 776 - bin_test_mock_algs[param->alg_idx].id, 777 - bin_test_mock_algs[param->alg_idx].ver, 778 - param->mem_type, 779 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 780 - &packed_payload, sizeof(packed_payload)); 771 + param->add_patch(priv->local->bin_builder, 772 + bin_test_mock_algs[param->alg_idx].id, 773 + bin_test_mock_algs[param->alg_idx].ver, 774 + param->mem_type, 775 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 776 + &packed_payload, sizeof(packed_payload)); 781 777 782 778 /* ... and the unpacked words following that */ 783 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 784 - bin_test_mock_algs[param->alg_idx].id, 785 - bin_test_mock_algs[param->alg_idx].ver, 786 - unpacked_mem_type, 787 - ((patch_pos_words + 4) - alg_base_words) * 4, 788 - &unpacked_payloads[0], sizeof(unpacked_payloads[0])); 779 + param->add_patch(priv->local->bin_builder, 780 + bin_test_mock_algs[param->alg_idx].id, 781 + bin_test_mock_algs[param->alg_idx].ver, 782 + unpacked_mem_type, 783 + ((patch_pos_words + 4) - alg_base_words) * 4, 784 + &unpacked_payloads[0], sizeof(unpacked_payloads[0])); 789 785 790 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 791 - bin_test_mock_algs[param->alg_idx].id, 792 - bin_test_mock_algs[param->alg_idx].ver, 793 - unpacked_mem_type, 794 - ((patch_pos_words + 5) - alg_base_words) * 4, 795 - &unpacked_payloads[1], sizeof(unpacked_payloads[1])); 786 + param->add_patch(priv->local->bin_builder, 787 + bin_test_mock_algs[param->alg_idx].id, 788 + bin_test_mock_algs[param->alg_idx].ver, 789 + unpacked_mem_type, 790 + ((patch_pos_words + 5) - alg_base_words) * 4, 791 + &unpacked_payloads[1], sizeof(unpacked_payloads[1])); 796 792 797 793 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 798 794 KUNIT_ASSERT_EQ(test, ··· 861 857 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 862 858 863 859 /* Patch packed block */ 864 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 865 - bin_test_mock_algs[param->alg_idx].id, 866 - bin_test_mock_algs[param->alg_idx].ver, 867 - param->mem_type, 868 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 869 - &packed_payload, sizeof(packed_payload)); 860 + param->add_patch(priv->local->bin_builder, 861 + bin_test_mock_algs[param->alg_idx].id, 862 + bin_test_mock_algs[param->alg_idx].ver, 863 + param->mem_type, 864 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 865 + &packed_payload, sizeof(packed_payload)); 870 866 871 867 /* ... and the unpacked words following that */ 872 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 873 - bin_test_mock_algs[param->alg_idx].id, 874 - bin_test_mock_algs[param->alg_idx].ver, 875 - unpacked_mem_type, 876 - ((patch_pos_words + 4) - alg_base_words) * 4, 877 - &unpacked_payloads[0], sizeof(unpacked_payloads[0])); 868 + param->add_patch(priv->local->bin_builder, 869 + bin_test_mock_algs[param->alg_idx].id, 870 + bin_test_mock_algs[param->alg_idx].ver, 871 + unpacked_mem_type, 872 + ((patch_pos_words + 4) - alg_base_words) * 4, 873 + &unpacked_payloads[0], sizeof(unpacked_payloads[0])); 878 874 879 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 880 - bin_test_mock_algs[param->alg_idx].id, 881 - bin_test_mock_algs[param->alg_idx].ver, 882 - unpacked_mem_type, 883 - ((patch_pos_words + 5) - alg_base_words) * 4, 884 - &unpacked_payloads[1], sizeof(unpacked_payloads[1])); 875 + param->add_patch(priv->local->bin_builder, 876 + bin_test_mock_algs[param->alg_idx].id, 877 + bin_test_mock_algs[param->alg_idx].ver, 878 + unpacked_mem_type, 879 + ((patch_pos_words + 5) - alg_base_words) * 4, 880 + &unpacked_payloads[1], sizeof(unpacked_payloads[1])); 885 881 886 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 887 - bin_test_mock_algs[param->alg_idx].id, 888 - bin_test_mock_algs[param->alg_idx].ver, 889 - unpacked_mem_type, 890 - ((patch_pos_words + 6) - alg_base_words) * 4, 891 - &unpacked_payloads[2], sizeof(unpacked_payloads[2])); 882 + param->add_patch(priv->local->bin_builder, 883 + bin_test_mock_algs[param->alg_idx].id, 884 + bin_test_mock_algs[param->alg_idx].ver, 885 + unpacked_mem_type, 886 + ((patch_pos_words + 6) - alg_base_words) * 4, 887 + &unpacked_payloads[2], sizeof(unpacked_payloads[2])); 892 888 893 889 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 894 890 KUNIT_ASSERT_EQ(test, ··· 957 953 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 958 954 959 955 /* Patch packed block */ 960 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 961 - bin_test_mock_algs[param->alg_idx].id, 962 - bin_test_mock_algs[param->alg_idx].ver, 963 - param->mem_type, 964 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 965 - &packed_payload, sizeof(packed_payload)); 956 + param->add_patch(priv->local->bin_builder, 957 + bin_test_mock_algs[param->alg_idx].id, 958 + bin_test_mock_algs[param->alg_idx].ver, 959 + param->mem_type, 960 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 961 + &packed_payload, sizeof(packed_payload)); 966 962 967 963 /* ... and the unpacked words following that */ 968 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 969 - bin_test_mock_algs[param->alg_idx].id, 970 - bin_test_mock_algs[param->alg_idx].ver, 971 - unpacked_mem_type, 972 - ((patch_pos_words + 4) - alg_base_words) * 4, 973 - unpacked_payload, sizeof(unpacked_payload)); 964 + param->add_patch(priv->local->bin_builder, 965 + bin_test_mock_algs[param->alg_idx].id, 966 + bin_test_mock_algs[param->alg_idx].ver, 967 + unpacked_mem_type, 968 + ((patch_pos_words + 4) - alg_base_words) * 4, 969 + unpacked_payload, sizeof(unpacked_payload)); 974 970 975 971 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 976 972 KUNIT_ASSERT_EQ(test, ··· 1039 1035 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 1040 1036 1041 1037 /* Patch packed block */ 1042 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1043 - bin_test_mock_algs[param->alg_idx].id, 1044 - bin_test_mock_algs[param->alg_idx].ver, 1045 - param->mem_type, 1046 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1047 - &packed_payload, sizeof(packed_payload)); 1038 + param->add_patch(priv->local->bin_builder, 1039 + bin_test_mock_algs[param->alg_idx].id, 1040 + bin_test_mock_algs[param->alg_idx].ver, 1041 + param->mem_type, 1042 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1043 + &packed_payload, sizeof(packed_payload)); 1048 1044 1049 1045 /* ... and the unpacked words following that */ 1050 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1051 - bin_test_mock_algs[param->alg_idx].id, 1052 - bin_test_mock_algs[param->alg_idx].ver, 1053 - unpacked_mem_type, 1054 - ((patch_pos_words + 4) - alg_base_words) * 4, 1055 - unpacked_payload, sizeof(unpacked_payload)); 1046 + param->add_patch(priv->local->bin_builder, 1047 + bin_test_mock_algs[param->alg_idx].id, 1048 + bin_test_mock_algs[param->alg_idx].ver, 1049 + unpacked_mem_type, 1050 + ((patch_pos_words + 4) - alg_base_words) * 4, 1051 + unpacked_payload, sizeof(unpacked_payload)); 1056 1052 1057 1053 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1058 1054 KUNIT_ASSERT_EQ(test, ··· 1121 1117 packed_patch_pos_words = round_up(alg_base_words + param->offset_words, 4) + 4; 1122 1118 1123 1119 /* Patch the leading unpacked word */ 1124 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1125 - bin_test_mock_algs[param->alg_idx].id, 1126 - bin_test_mock_algs[param->alg_idx].ver, 1127 - unpacked_mem_type, 1128 - ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1129 - unpacked_payload, sizeof(unpacked_payload)); 1120 + param->add_patch(priv->local->bin_builder, 1121 + bin_test_mock_algs[param->alg_idx].id, 1122 + bin_test_mock_algs[param->alg_idx].ver, 1123 + unpacked_mem_type, 1124 + ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1125 + unpacked_payload, sizeof(unpacked_payload)); 1130 1126 /* ... then the packed block */ 1131 1127 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(packed_patch_pos_words); 1132 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1133 - bin_test_mock_algs[param->alg_idx].id, 1134 - bin_test_mock_algs[param->alg_idx].ver, 1135 - param->mem_type, 1136 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1137 - &packed_payload, sizeof(packed_payload)); 1128 + param->add_patch(priv->local->bin_builder, 1129 + bin_test_mock_algs[param->alg_idx].id, 1130 + bin_test_mock_algs[param->alg_idx].ver, 1131 + param->mem_type, 1132 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1133 + &packed_payload, sizeof(packed_payload)); 1138 1134 1139 1135 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1140 1136 KUNIT_ASSERT_EQ(test, ··· 1200 1196 packed_patch_pos_words = round_up(alg_base_words + param->offset_words, 4) + 4; 1201 1197 1202 1198 /* Patch the leading unpacked words */ 1203 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1204 - bin_test_mock_algs[param->alg_idx].id, 1205 - bin_test_mock_algs[param->alg_idx].ver, 1206 - unpacked_mem_type, 1207 - ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1208 - &unpacked_payload[0], sizeof(unpacked_payload[0])); 1209 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1210 - bin_test_mock_algs[param->alg_idx].id, 1211 - bin_test_mock_algs[param->alg_idx].ver, 1212 - unpacked_mem_type, 1213 - ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1214 - &unpacked_payload[1], sizeof(unpacked_payload[1])); 1199 + param->add_patch(priv->local->bin_builder, 1200 + bin_test_mock_algs[param->alg_idx].id, 1201 + bin_test_mock_algs[param->alg_idx].ver, 1202 + unpacked_mem_type, 1203 + ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1204 + &unpacked_payload[0], sizeof(unpacked_payload[0])); 1205 + param->add_patch(priv->local->bin_builder, 1206 + bin_test_mock_algs[param->alg_idx].id, 1207 + bin_test_mock_algs[param->alg_idx].ver, 1208 + unpacked_mem_type, 1209 + ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1210 + &unpacked_payload[1], sizeof(unpacked_payload[1])); 1215 1211 /* ... then the packed block */ 1216 1212 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(packed_patch_pos_words); 1217 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1218 - bin_test_mock_algs[param->alg_idx].id, 1219 - bin_test_mock_algs[param->alg_idx].ver, 1220 - param->mem_type, 1221 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1222 - &packed_payload, sizeof(packed_payload)); 1213 + param->add_patch(priv->local->bin_builder, 1214 + bin_test_mock_algs[param->alg_idx].id, 1215 + bin_test_mock_algs[param->alg_idx].ver, 1216 + param->mem_type, 1217 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1218 + &packed_payload, sizeof(packed_payload)); 1223 1219 1224 1220 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1225 1221 KUNIT_ASSERT_EQ(test, ··· 1287 1283 packed_patch_pos_words = round_up(alg_base_words + param->offset_words, 4) + 4; 1288 1284 1289 1285 /* Patch the leading unpacked words */ 1290 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1291 - bin_test_mock_algs[param->alg_idx].id, 1292 - bin_test_mock_algs[param->alg_idx].ver, 1293 - unpacked_mem_type, 1294 - ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1295 - unpacked_payload, sizeof(unpacked_payload)); 1286 + param->add_patch(priv->local->bin_builder, 1287 + bin_test_mock_algs[param->alg_idx].id, 1288 + bin_test_mock_algs[param->alg_idx].ver, 1289 + unpacked_mem_type, 1290 + ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1291 + unpacked_payload, sizeof(unpacked_payload)); 1296 1292 /* ... then the packed block */ 1297 1293 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(packed_patch_pos_words); 1298 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1299 - bin_test_mock_algs[param->alg_idx].id, 1300 - bin_test_mock_algs[param->alg_idx].ver, 1301 - param->mem_type, 1302 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1303 - &packed_payload, sizeof(packed_payload)); 1294 + param->add_patch(priv->local->bin_builder, 1295 + bin_test_mock_algs[param->alg_idx].id, 1296 + bin_test_mock_algs[param->alg_idx].ver, 1297 + param->mem_type, 1298 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1299 + &packed_payload, sizeof(packed_payload)); 1304 1300 1305 1301 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1306 1302 KUNIT_ASSERT_EQ(test, ··· 1368 1364 packed_patch_pos_words = round_up(alg_base_words + param->offset_words, 4) + 4; 1369 1365 1370 1366 /* Patch the leading unpacked words */ 1371 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1372 - bin_test_mock_algs[param->alg_idx].id, 1373 - bin_test_mock_algs[param->alg_idx].ver, 1374 - unpacked_mem_type, 1375 - ((packed_patch_pos_words - 3) - alg_base_words) * 4, 1376 - &unpacked_payload[0], sizeof(unpacked_payload[0])); 1377 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1378 - bin_test_mock_algs[param->alg_idx].id, 1379 - bin_test_mock_algs[param->alg_idx].ver, 1380 - unpacked_mem_type, 1381 - ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1382 - &unpacked_payload[1], sizeof(unpacked_payload[1])); 1383 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1384 - bin_test_mock_algs[param->alg_idx].id, 1385 - bin_test_mock_algs[param->alg_idx].ver, 1386 - unpacked_mem_type, 1387 - ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1388 - &unpacked_payload[2], sizeof(unpacked_payload[2])); 1367 + param->add_patch(priv->local->bin_builder, 1368 + bin_test_mock_algs[param->alg_idx].id, 1369 + bin_test_mock_algs[param->alg_idx].ver, 1370 + unpacked_mem_type, 1371 + ((packed_patch_pos_words - 3) - alg_base_words) * 4, 1372 + &unpacked_payload[0], sizeof(unpacked_payload[0])); 1373 + param->add_patch(priv->local->bin_builder, 1374 + bin_test_mock_algs[param->alg_idx].id, 1375 + bin_test_mock_algs[param->alg_idx].ver, 1376 + unpacked_mem_type, 1377 + ((packed_patch_pos_words - 2) - alg_base_words) * 4, 1378 + &unpacked_payload[1], sizeof(unpacked_payload[1])); 1379 + param->add_patch(priv->local->bin_builder, 1380 + bin_test_mock_algs[param->alg_idx].id, 1381 + bin_test_mock_algs[param->alg_idx].ver, 1382 + unpacked_mem_type, 1383 + ((packed_patch_pos_words - 1) - alg_base_words) * 4, 1384 + &unpacked_payload[2], sizeof(unpacked_payload[2])); 1389 1385 /* ... then the packed block */ 1390 1386 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(packed_patch_pos_words); 1391 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1392 - bin_test_mock_algs[param->alg_idx].id, 1393 - bin_test_mock_algs[param->alg_idx].ver, 1394 - param->mem_type, 1395 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1396 - &packed_payload, sizeof(packed_payload)); 1387 + param->add_patch(priv->local->bin_builder, 1388 + bin_test_mock_algs[param->alg_idx].id, 1389 + bin_test_mock_algs[param->alg_idx].ver, 1390 + param->mem_type, 1391 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1392 + &packed_payload, sizeof(packed_payload)); 1397 1393 1398 1394 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1399 1395 KUNIT_ASSERT_EQ(test, ··· 1461 1457 packed_patch_pos_words = round_up(alg_base_words + param->offset_words, 4) + 4; 1462 1458 1463 1459 /* Patch the leading unpacked words */ 1464 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1465 - bin_test_mock_algs[param->alg_idx].id, 1466 - bin_test_mock_algs[param->alg_idx].ver, 1467 - unpacked_mem_type, 1468 - ((packed_patch_pos_words - 3) - alg_base_words) * 4, 1469 - unpacked_payload, sizeof(unpacked_payload)); 1460 + param->add_patch(priv->local->bin_builder, 1461 + bin_test_mock_algs[param->alg_idx].id, 1462 + bin_test_mock_algs[param->alg_idx].ver, 1463 + unpacked_mem_type, 1464 + ((packed_patch_pos_words - 3) - alg_base_words) * 4, 1465 + unpacked_payload, sizeof(unpacked_payload)); 1470 1466 /* ... then the packed block */ 1471 1467 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(packed_patch_pos_words); 1472 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1473 - bin_test_mock_algs[param->alg_idx].id, 1474 - bin_test_mock_algs[param->alg_idx].ver, 1475 - param->mem_type, 1476 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1477 - &packed_payload, sizeof(packed_payload)); 1468 + param->add_patch(priv->local->bin_builder, 1469 + bin_test_mock_algs[param->alg_idx].id, 1470 + bin_test_mock_algs[param->alg_idx].ver, 1471 + param->mem_type, 1472 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1473 + &packed_payload, sizeof(packed_payload)); 1478 1474 1479 1475 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1480 1476 KUNIT_ASSERT_EQ(test, ··· 1541 1537 for (i = 0; i < ARRAY_SIZE(packed_payloads); ++i) { 1542 1538 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words + (i * 4)); 1543 1539 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 1544 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1545 - bin_test_mock_algs[param->alg_idx].id, 1546 - bin_test_mock_algs[param->alg_idx].ver, 1547 - param->mem_type, 1548 - payload_offset, 1549 - &packed_payloads[i], sizeof(packed_payloads[i])); 1540 + param->add_patch(priv->local->bin_builder, 1541 + bin_test_mock_algs[param->alg_idx].id, 1542 + bin_test_mock_algs[param->alg_idx].ver, 1543 + param->mem_type, 1544 + payload_offset, 1545 + &packed_payloads[i], sizeof(packed_payloads[i])); 1550 1546 } 1551 1547 1552 1548 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 1606 1602 patch_pos_in_packed_regs = 1607 1603 _num_words_to_num_packed_regs(patch_pos_words + (payload_order[i] * 4)); 1608 1604 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 1609 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1610 - bin_test_mock_algs[param->alg_idx].id, 1611 - bin_test_mock_algs[param->alg_idx].ver, 1612 - param->mem_type, 1613 - payload_offset, 1614 - &packed_payloads[payload_order[i]], 1615 - sizeof(packed_payloads[0])); 1605 + param->add_patch(priv->local->bin_builder, 1606 + bin_test_mock_algs[param->alg_idx].id, 1607 + bin_test_mock_algs[param->alg_idx].ver, 1608 + param->mem_type, 1609 + payload_offset, 1610 + &packed_payloads[payload_order[i]], 1611 + sizeof(packed_payloads[0])); 1616 1612 } 1617 1613 1618 1614 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 1669 1665 patch_pos_words = round_up(alg_base_words + word_offsets[i], 4); 1670 1666 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 1671 1667 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 1672 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1673 - bin_test_mock_algs[param->alg_idx].id, 1674 - bin_test_mock_algs[param->alg_idx].ver, 1675 - param->mem_type, 1676 - payload_offset, 1677 - &packed_payloads[i], 1678 - sizeof(packed_payloads[0])); 1668 + param->add_patch(priv->local->bin_builder, 1669 + bin_test_mock_algs[param->alg_idx].id, 1670 + bin_test_mock_algs[param->alg_idx].ver, 1671 + param->mem_type, 1672 + payload_offset, 1673 + &packed_payloads[i], 1674 + sizeof(packed_payloads[0])); 1679 1675 } 1680 1676 1681 1677 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 1741 1737 /* Add XM and YM patches */ 1742 1738 alg_base_in_packed_regs = _num_words_to_num_packed_regs(alg_xm_base_words); 1743 1739 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(xm_patch_pos_words); 1744 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1745 - bin_test_mock_algs[param->alg_idx].id, 1746 - bin_test_mock_algs[param->alg_idx].ver, 1747 - WMFW_HALO_XM_PACKED, 1748 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1749 - packed_xm_payload, sizeof(packed_xm_payload)); 1740 + param->add_patch(priv->local->bin_builder, 1741 + bin_test_mock_algs[param->alg_idx].id, 1742 + bin_test_mock_algs[param->alg_idx].ver, 1743 + WMFW_HALO_XM_PACKED, 1744 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1745 + packed_xm_payload, sizeof(packed_xm_payload)); 1750 1746 1751 1747 alg_base_in_packed_regs = _num_words_to_num_packed_regs(alg_ym_base_words); 1752 1748 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(ym_patch_pos_words); 1753 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1754 - bin_test_mock_algs[param->alg_idx].id, 1755 - bin_test_mock_algs[param->alg_idx].ver, 1756 - WMFW_HALO_YM_PACKED, 1757 - (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1758 - packed_ym_payload, sizeof(packed_ym_payload)); 1749 + param->add_patch(priv->local->bin_builder, 1750 + bin_test_mock_algs[param->alg_idx].id, 1751 + bin_test_mock_algs[param->alg_idx].ver, 1752 + WMFW_HALO_YM_PACKED, 1753 + (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4, 1754 + packed_ym_payload, sizeof(packed_ym_payload)); 1759 1755 1760 1756 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); 1761 1757 KUNIT_ASSERT_EQ(test, ··· 1825 1821 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 1826 1822 1827 1823 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 1828 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1829 - bin_test_mock_algs[i].id, 1830 - bin_test_mock_algs[i].ver, 1831 - param->mem_type, 1832 - payload_offset, 1833 - packed_payload[i], sizeof(packed_payload[i])); 1824 + param->add_patch(priv->local->bin_builder, 1825 + bin_test_mock_algs[i].id, 1826 + bin_test_mock_algs[i].ver, 1827 + param->mem_type, 1828 + payload_offset, 1829 + packed_payload[i], sizeof(packed_payload[i])); 1834 1830 } 1835 1831 1836 1832 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 1911 1907 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 1912 1908 1913 1909 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 1914 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 1915 - bin_test_mock_algs[alg_idx].id, 1916 - bin_test_mock_algs[alg_idx].ver, 1917 - param->mem_type, 1918 - payload_offset, 1919 - packed_payload[i], sizeof(packed_payload[i])); 1910 + param->add_patch(priv->local->bin_builder, 1911 + bin_test_mock_algs[alg_idx].id, 1912 + bin_test_mock_algs[alg_idx].ver, 1913 + param->mem_type, 1914 + payload_offset, 1915 + packed_payload[i], sizeof(packed_payload[i])); 1920 1916 } 1921 1917 1922 1918 fw = cs_dsp_mock_bin_get_firmware(priv->local->bin_builder); ··· 2008 2004 alg_base_in_packed_regs = _num_words_to_num_packed_regs(alg_base_words); 2009 2005 patch_pos_in_packed_regs = _num_words_to_num_packed_regs(patch_pos_words); 2010 2006 payload_offset = (patch_pos_in_packed_regs - alg_base_in_packed_regs) * 4; 2011 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 2012 - bin_test_mock_algs[0].id, 2013 - bin_test_mock_algs[0].ver, 2014 - param->mem_type, 2015 - payload_offset, 2016 - payload->packed[i], 2017 - sizeof(payload->packed[i])); 2007 + param->add_patch(priv->local->bin_builder, 2008 + bin_test_mock_algs[0].id, 2009 + bin_test_mock_algs[0].ver, 2010 + param->mem_type, 2011 + payload_offset, 2012 + payload->packed[i], 2013 + sizeof(payload->packed[i])); 2018 2014 } else { 2019 2015 payload_offset = offset_words[i] * 4; 2020 - cs_dsp_mock_bin_add_patch(priv->local->bin_builder, 2021 - bin_test_mock_algs[0].id, 2022 - bin_test_mock_algs[0].ver, 2023 - unpacked_mem_type, 2024 - payload_offset, 2025 - &payload->unpacked[i], 2026 - sizeof(payload->unpacked[i])); 2016 + param->add_patch(priv->local->bin_builder, 2017 + bin_test_mock_algs[0].id, 2018 + bin_test_mock_algs[0].ver, 2019 + unpacked_mem_type, 2020 + payload_offset, 2021 + &payload->unpacked[i], 2022 + sizeof(payload->unpacked[i])); 2027 2023 } 2028 2024 } 2029 2025 ··· 2299 2295 return cs_dsp_bin_test_common_init(test, dsp, 1); 2300 2296 } 2301 2297 2298 + #define WMDR_PATCH_SHORT .add_patch = cs_dsp_mock_bin_add_patch 2299 + 2302 2300 /* Parameterize on choice of XM or YM with a range of word offsets */ 2303 2301 static const struct bin_test_param x_or_y_and_offset_param_cases[] = { 2304 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 0 }, 2305 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 1 }, 2306 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 2 }, 2307 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 3 }, 2308 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 4 }, 2309 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 23 }, 2310 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 22 }, 2311 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 21 }, 2312 - { .mem_type = WMFW_ADSP2_XM, .offset_words = 20 }, 2302 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0, WMDR_PATCH_SHORT }, 2303 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 1, WMDR_PATCH_SHORT }, 2304 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 2, WMDR_PATCH_SHORT }, 2305 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 3, WMDR_PATCH_SHORT }, 2306 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 4, WMDR_PATCH_SHORT }, 2307 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 23, WMDR_PATCH_SHORT }, 2308 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 22, WMDR_PATCH_SHORT }, 2309 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 21, WMDR_PATCH_SHORT }, 2310 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 20, WMDR_PATCH_SHORT }, 2313 2311 2314 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 0 }, 2315 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 1 }, 2316 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 2 }, 2317 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 3 }, 2318 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 4 }, 2319 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 23 }, 2320 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 22 }, 2321 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 21 }, 2322 - { .mem_type = WMFW_ADSP2_YM, .offset_words = 20 }, 2312 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0, WMDR_PATCH_SHORT }, 2313 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 1, WMDR_PATCH_SHORT }, 2314 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 2, WMDR_PATCH_SHORT }, 2315 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 3, WMDR_PATCH_SHORT }, 2316 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 4, WMDR_PATCH_SHORT }, 2317 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 23, WMDR_PATCH_SHORT }, 2318 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 22, WMDR_PATCH_SHORT }, 2319 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 21, WMDR_PATCH_SHORT }, 2320 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 20, WMDR_PATCH_SHORT }, 2323 2321 }; 2324 2322 2325 2323 /* Parameterize on ZM with a range of word offsets */ 2326 2324 static const struct bin_test_param z_and_offset_param_cases[] = { 2327 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 0 }, 2328 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 1 }, 2329 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 2 }, 2330 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 3 }, 2331 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 4 }, 2332 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 23 }, 2333 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 22 }, 2334 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 21 }, 2335 - { .mem_type = WMFW_ADSP2_ZM, .offset_words = 20 }, 2325 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 0, WMDR_PATCH_SHORT }, 2326 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 1, WMDR_PATCH_SHORT }, 2327 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 2, WMDR_PATCH_SHORT }, 2328 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 3, WMDR_PATCH_SHORT }, 2329 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 4, WMDR_PATCH_SHORT }, 2330 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 23, WMDR_PATCH_SHORT }, 2331 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 22, WMDR_PATCH_SHORT }, 2332 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 21, WMDR_PATCH_SHORT }, 2333 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 20, WMDR_PATCH_SHORT }, 2336 2334 }; 2337 2335 2338 2336 /* Parameterize on choice of packed XM or YM with a range of word offsets */ 2339 2337 static const struct bin_test_param packed_x_or_y_and_offset_param_cases[] = { 2340 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0 }, 2341 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 4 }, 2342 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 8 }, 2343 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 12 }, 2338 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2339 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 4, WMDR_PATCH_SHORT }, 2340 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 8, WMDR_PATCH_SHORT }, 2341 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 12, WMDR_PATCH_SHORT }, 2344 2342 2345 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0 }, 2346 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 4 }, 2347 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 8 }, 2348 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 12 }, 2343 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2344 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 4, WMDR_PATCH_SHORT }, 2345 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 8, WMDR_PATCH_SHORT }, 2346 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 12, WMDR_PATCH_SHORT }, 2349 2347 }; 2350 2348 2351 2349 static void x_or_y_or_z_and_offset_param_desc(const struct bin_test_param *param, ··· 2372 2366 2373 2367 /* Parameterize on choice of packed XM or YM */ 2374 2368 static const struct bin_test_param packed_x_or_y_param_cases[] = { 2375 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0 }, 2376 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0 }, 2369 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2370 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2377 2371 }; 2378 2372 2379 2373 static void x_or_y_or_z_param_desc(const struct bin_test_param *param, ··· 2385 2379 KUNIT_ARRAY_PARAM(packed_x_or_y, packed_x_or_y_param_cases, x_or_y_or_z_param_desc); 2386 2380 2387 2381 static const struct bin_test_param offset_param_cases[] = { 2388 - { .offset_words = 0 }, 2389 - { .offset_words = 1 }, 2390 - { .offset_words = 2 }, 2391 - { .offset_words = 3 }, 2392 - { .offset_words = 4 }, 2393 - { .offset_words = 23 }, 2394 - { .offset_words = 22 }, 2395 - { .offset_words = 21 }, 2396 - { .offset_words = 20 }, 2382 + { .offset_words = 0, WMDR_PATCH_SHORT }, 2383 + { .offset_words = 1, WMDR_PATCH_SHORT }, 2384 + { .offset_words = 2, WMDR_PATCH_SHORT }, 2385 + { .offset_words = 3, WMDR_PATCH_SHORT }, 2386 + { .offset_words = 4, WMDR_PATCH_SHORT }, 2387 + { .offset_words = 23, WMDR_PATCH_SHORT }, 2388 + { .offset_words = 22, WMDR_PATCH_SHORT }, 2389 + { .offset_words = 21, WMDR_PATCH_SHORT }, 2390 + { .offset_words = 20, WMDR_PATCH_SHORT }, 2397 2391 }; 2398 2392 2399 2393 static void offset_param_desc(const struct bin_test_param *param, char *desc) ··· 2404 2398 KUNIT_ARRAY_PARAM(offset, offset_param_cases, offset_param_desc); 2405 2399 2406 2400 static const struct bin_test_param alg_param_cases[] = { 2407 - { .alg_idx = 0 }, 2408 - { .alg_idx = 1 }, 2409 - { .alg_idx = 2 }, 2410 - { .alg_idx = 3 }, 2401 + { .alg_idx = 0, WMDR_PATCH_SHORT }, 2402 + { .alg_idx = 1, WMDR_PATCH_SHORT }, 2403 + { .alg_idx = 2, WMDR_PATCH_SHORT }, 2404 + { .alg_idx = 3, WMDR_PATCH_SHORT }, 2411 2405 }; 2412 2406 2413 2407 static void alg_param_desc(const struct bin_test_param *param, char *desc) ··· 2421 2415 KUNIT_ARRAY_PARAM(alg, alg_param_cases, alg_param_desc); 2422 2416 2423 2417 static const struct bin_test_param x_or_y_and_alg_param_cases[] = { 2424 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 0 }, 2425 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 1 }, 2426 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 2 }, 2427 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 3 }, 2418 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2419 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2420 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2421 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2428 2422 2429 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 0 }, 2430 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 1 }, 2431 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 2 }, 2432 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 3 }, 2423 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2424 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2425 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2426 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2433 2427 }; 2434 2428 2435 2429 static void x_or_y_or_z_and_alg_param_desc(const struct bin_test_param *param, char *desc) ··· 2444 2438 KUNIT_ARRAY_PARAM(x_or_y_and_alg, x_or_y_and_alg_param_cases, x_or_y_or_z_and_alg_param_desc); 2445 2439 2446 2440 static const struct bin_test_param z_and_alg_param_cases[] = { 2447 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 0 }, 2448 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 1 }, 2449 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 2 }, 2450 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 3 }, 2441 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2442 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2443 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2444 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2451 2445 }; 2452 2446 2453 2447 KUNIT_ARRAY_PARAM(z_and_alg, z_and_alg_param_cases, x_or_y_or_z_and_alg_param_desc); 2454 2448 2455 2449 static const struct bin_test_param packed_x_or_y_and_alg_param_cases[] = { 2456 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 0 }, 2457 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 1 }, 2458 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 2 }, 2459 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 3 }, 2450 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 0, WMDR_PATCH_SHORT }, 2451 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 1, WMDR_PATCH_SHORT }, 2452 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 2, WMDR_PATCH_SHORT }, 2453 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 3, WMDR_PATCH_SHORT }, 2460 2454 2461 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 0 }, 2462 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 1 }, 2463 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 2 }, 2464 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 3 }, 2455 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 0, WMDR_PATCH_SHORT }, 2456 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 1, WMDR_PATCH_SHORT }, 2457 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 2, WMDR_PATCH_SHORT }, 2458 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 3, WMDR_PATCH_SHORT }, 2465 2459 }; 2466 2460 2467 2461 KUNIT_ARRAY_PARAM(packed_x_or_y_and_alg, packed_x_or_y_and_alg_param_cases,