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: cirrus: cs_dsp: Add long-offset WMDR

Merge series from Richard Fitzgerald <rf@opensource.cirrus.com>:

Version 3 of the WMDR file format introduces a new block type that has a
32-bit address offset.

The first patch of this series adds the support to the cs_dsp driver.

The rest of the series is adding KUnit tests for this.

Mark Brown d7e36da6 49d3bd9f

+731 -394
+15 -4
drivers/firmware/cirrus/cs_dsp.c
··· 2138 2138 const struct cs_dsp_region *mem; 2139 2139 struct cs_dsp_alg_region *alg_region; 2140 2140 const char *region_name; 2141 - int ret, pos, blocks, type, offset, reg, version; 2141 + int ret, pos, blocks, type, version; 2142 + unsigned int offset, reg; 2142 2143 u8 *buf = NULL; 2143 2144 size_t buf_len = 0; 2144 2145 size_t region_len; ··· 2164 2163 switch (be32_to_cpu(hdr->rev) & 0xff) { 2165 2164 case 1: 2166 2165 case 2: 2166 + case 3: 2167 2167 break; 2168 2168 default: 2169 2169 cs_dsp_err(dsp, "%s: Unsupported coefficient file format %d\n", ··· 2173 2171 goto out_fw; 2174 2172 } 2175 2173 2176 - cs_dsp_info(dsp, "%s: v%d.%d.%d\n", file, 2174 + cs_dsp_info(dsp, "%s (v%d): v%d.%d.%d\n", file, 2175 + be32_to_cpu(hdr->rev) & 0xff, 2177 2176 (le32_to_cpu(hdr->ver) >> 16) & 0xff, 2178 2177 (le32_to_cpu(hdr->ver) >> 8) & 0xff, 2179 2178 le32_to_cpu(hdr->ver) & 0xff); ··· 2205 2202 (le32_to_cpu(blk->ver) >> 16) & 0xff, 2206 2203 (le32_to_cpu(blk->ver) >> 8) & 0xff, 2207 2204 le32_to_cpu(blk->ver) & 0xff); 2208 - cs_dsp_dbg(dsp, "%s.%d: %d bytes at 0x%x in %x\n", 2209 - file, blocks, le32_to_cpu(blk->len), offset, type); 2205 + cs_dsp_dbg(dsp, "%s.%d: %d bytes off:%#x off32:%#x in %#x\n", 2206 + file, blocks, le32_to_cpu(blk->len), offset, 2207 + le32_to_cpu(blk->offset32), type); 2210 2208 2211 2209 reg = 0; 2212 2210 region_name = "Unknown"; ··· 2240 2236 } 2241 2237 break; 2242 2238 2239 + case WMFW_ADSP2_XM_LONG: 2240 + case WMFW_ADSP2_YM_LONG: 2241 + case WMFW_HALO_XM_PACKED_LONG: 2242 + case WMFW_HALO_YM_PACKED_LONG: 2243 + offset = le32_to_cpu(blk->offset32); 2244 + type &= 0xff; /* strip extended block type flags */ 2245 + fallthrough; 2243 2246 case WMFW_ADSP1_DM: 2244 2247 case WMFW_ADSP1_ZM: 2245 2248 case WMFW_ADSP2_XM:
+34 -4
drivers/firmware/cirrus/test/cs_dsp_mock_bin.c
··· 56 56 * @alg_id: Algorithm ID. 57 57 * @alg_ver: Algorithm version. 58 58 * @type: Type of the block. 59 - * @offset: Offset. 59 + * @offset: 16-bit offset. 60 + * @offset32: 32-bit offset (sample rate on V1 and V2 file formats). 60 61 * @payload_data: Pointer to buffer containing the payload data. 61 62 * @payload_len_bytes: Length of payload data in bytes. 62 63 */ 63 64 void cs_dsp_mock_bin_add_raw_block(struct cs_dsp_mock_bin_builder *builder, 64 65 unsigned int alg_id, unsigned int alg_ver, 65 - int type, unsigned int offset, 66 + int type, u16 offset, u32 offset32, 66 67 const void *payload_data, size_t payload_len_bytes) 67 68 { 68 69 struct wmfw_coeff_item *item; ··· 76 75 item = builder->write_p; 77 76 78 77 item->offset = cpu_to_le16(offset); 78 + item->offset32 = cpu_to_le32(offset32); 79 79 item->type = cpu_to_le16(type); 80 80 item->id = cpu_to_le32(alg_id); 81 81 item->ver = cpu_to_le32(alg_ver << 8); ··· 106 104 info = tmp; 107 105 } 108 106 109 - cs_dsp_mock_bin_add_raw_block(builder, 0, 0, WMFW_INFO_TEXT, 0, info, info_len); 107 + cs_dsp_mock_bin_add_raw_block(builder, 0, 0, WMFW_INFO_TEXT, 0, 0, info, info_len); 110 108 kunit_kfree(builder->test_priv->test, tmp); 111 109 } 112 110 ··· 158 156 KUNIT_ASSERT_EQ(builder->test_priv->test, payload_len_bytes % 4, 0); 159 157 160 158 cs_dsp_mock_bin_add_raw_block(builder, alg_id, alg_ver, 161 - mem_region, reg_addr_offset, 159 + mem_region, (u16)reg_addr_offset, 0, 162 160 payload_data, payload_len_bytes); 163 161 } 164 162 EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_bin_add_patch, "FW_CS_DSP_KUNIT_TEST_UTILS"); 163 + 164 + /** 165 + * cs_dsp_mock_bin_add_patch_off32() - Add a patch data block with 32-bit offset. 166 + * 167 + * @builder: Pointer to struct cs_dsp_mock_bin_builder. 168 + * @alg_id: Algorithm ID for the patch. 169 + * @alg_ver: Algorithm version for the patch. 170 + * @mem_region: Memory region for the patch. 171 + * @reg_addr_offset: Offset to start of data in register addresses. 172 + * @payload_data: Pointer to buffer containing the payload data. 173 + * @payload_len_bytes: Length of payload data in bytes. 174 + */ 175 + void cs_dsp_mock_bin_add_patch_off32(struct cs_dsp_mock_bin_builder *builder, 176 + unsigned int alg_id, unsigned int alg_ver, 177 + int mem_region, unsigned int reg_addr_offset, 178 + const void *payload_data, size_t payload_len_bytes) 179 + { 180 + /* Payload length must be a multiple of 4 */ 181 + KUNIT_ASSERT_EQ(builder->test_priv->test, payload_len_bytes % 4, 0); 182 + 183 + /* Mark the block as using the 32-bit offset */ 184 + mem_region |= 0xf400; 185 + 186 + cs_dsp_mock_bin_add_raw_block(builder, alg_id, alg_ver, 187 + mem_region, 0, reg_addr_offset, 188 + payload_data, payload_len_bytes); 189 + } 190 + EXPORT_SYMBOL_NS_GPL(cs_dsp_mock_bin_add_patch_off32, "FW_CS_DSP_KUNIT_TEST_UTILS"); 165 191 166 192 /** 167 193 * cs_dsp_mock_bin_init() - Initialize a struct cs_dsp_mock_bin_builder.
+4 -4
drivers/firmware/cirrus/test/cs_dsp_mock_mem_maps.c
··· 23 23 /* List of sizes in bytes, for each entry above */ 24 24 const unsigned int cs_dsp_mock_halo_dsp1_region_sizes[] = { 25 25 0x5000, /* PM_PACKED */ 26 - 0x6000, /* XM_PACKED */ 27 - 0x47F4, /* YM_PACKED */ 28 - 0x8000, /* XM_UNPACKED_24 */ 29 - 0x5FF8, /* YM_UNPACKED_24 */ 26 + 0x8fff4, /* XM_PACKED */ 27 + 0x8fff4, /* YM_PACKED */ 28 + 0xbfff8, /* XM_UNPACKED_24 */ 29 + 0xbfff8, /* YM_UNPACKED_24 */ 30 30 31 31 0 /* terminator */ 32 32 };
+8 -8
drivers/firmware/cirrus/test/cs_dsp_mock_regmap.c
··· 157 157 }; 158 158 159 159 static const struct regmap_range halo_readable_registers[] = { 160 - regmap_reg_range(0x2000000, 0x2005fff), /* XM_PACKED */ 160 + regmap_reg_range(0x2000000, 0x208fff0), /* XM_PACKED */ 161 161 regmap_reg_range(0x25e0000, 0x25e004f), /* SYSINFO */ 162 162 regmap_reg_range(0x25e2000, 0x25e2047), /* SYSINFO */ 163 - regmap_reg_range(0x2800000, 0x2807fff), /* XM */ 163 + regmap_reg_range(0x2800000, 0x28bfff4), /* XM */ 164 164 regmap_reg_range(0x2b80000, 0x2bc700b), /* CORE CTRL */ 165 - regmap_reg_range(0x2c00000, 0x2c047f3), /* YM_PACKED */ 166 - regmap_reg_range(0x3400000, 0x3405ff7), /* YM */ 165 + regmap_reg_range(0x2c00000, 0x2c8fff0), /* YM_PACKED */ 166 + regmap_reg_range(0x3400000, 0x34bfff4), /* YM */ 167 167 regmap_reg_range(0x3800000, 0x3804fff), /* PM_PACKED */ 168 168 }; 169 169 170 170 static const struct regmap_range halo_writeable_registers[] = { 171 - regmap_reg_range(0x2000000, 0x2005fff), /* XM_PACKED */ 172 - regmap_reg_range(0x2800000, 0x2807fff), /* XM */ 171 + regmap_reg_range(0x2000000, 0x208fff0), /* XM_PACKED */ 172 + regmap_reg_range(0x2800000, 0x28bfff4), /* XM */ 173 173 regmap_reg_range(0x2b80000, 0x2bc700b), /* CORE CTRL */ 174 - regmap_reg_range(0x2c00000, 0x2c047f3), /* YM_PACKED */ 175 - regmap_reg_range(0x3400000, 0x3405ff7), /* YM */ 174 + regmap_reg_range(0x2c00000, 0x2c8fff0), /* YM_PACKED */ 175 + regmap_reg_range(0x3400000, 0x34bfff4), /* YM */ 176 176 regmap_reg_range(0x3800000, 0x3804fff), /* PM_PACKED */ 177 177 }; 178 178
+652 -365
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 ··· 2153 2149 KUNIT_EXPECT_EQ(test, reg_val, payload_data); 2154 2150 } 2155 2151 2156 - static int cs_dsp_bin_test_common_init(struct kunit *test, struct cs_dsp *dsp) 2152 + static int cs_dsp_bin_test_common_init(struct kunit *test, struct cs_dsp *dsp, 2153 + int wmdr_ver) 2157 2154 { 2158 2155 struct cs_dsp_test *priv; 2159 2156 struct cs_dsp_mock_xm_header *xm_hdr; ··· 2202 2197 KUNIT_ASSERT_EQ(test, ret, 0); 2203 2198 2204 2199 priv->local->bin_builder = 2205 - cs_dsp_mock_bin_init(priv, 1, 2200 + cs_dsp_mock_bin_init(priv, wmdr_ver, 2206 2201 cs_dsp_mock_xm_header_get_fw_version(xm_hdr)); 2207 2202 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, priv->local->bin_builder); 2208 2203 ··· 2232 2227 return kunit_add_action_or_reset(priv->test, _cs_dsp_remove_wrapper, dsp); 2233 2228 } 2234 2229 2235 - static int cs_dsp_bin_test_halo_init(struct kunit *test) 2230 + static int cs_dsp_bin_test_halo_init_common(struct kunit *test, int wmdr_ver) 2236 2231 { 2237 2232 struct cs_dsp *dsp; 2238 2233 ··· 2248 2243 dsp->base = cs_dsp_mock_halo_core_base; 2249 2244 dsp->base_sysinfo = cs_dsp_mock_halo_sysinfo_base; 2250 2245 2251 - return cs_dsp_bin_test_common_init(test, dsp); 2246 + return cs_dsp_bin_test_common_init(test, dsp, wmdr_ver); 2247 + } 2248 + 2249 + static int cs_dsp_bin_test_halo_init(struct kunit *test) 2250 + { 2251 + return cs_dsp_bin_test_halo_init_common(test, 1); 2252 + } 2253 + 2254 + static int cs_dsp_bin_test_halo_wmdr3_init(struct kunit *test) 2255 + { 2256 + return cs_dsp_bin_test_halo_init_common(test, 3); 2252 2257 } 2253 2258 2254 2259 static int cs_dsp_bin_test_adsp2_32bit_init(struct kunit *test) ··· 2277 2262 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_32bit_dsp1_region_sizes); 2278 2263 dsp->base = cs_dsp_mock_adsp2_32bit_sysbase; 2279 2264 2280 - return cs_dsp_bin_test_common_init(test, dsp); 2265 + return cs_dsp_bin_test_common_init(test, dsp, 1); 2281 2266 } 2282 2267 2283 2268 static int cs_dsp_bin_test_adsp2_16bit_init(struct kunit *test) ··· 2296 2281 dsp->num_mems = cs_dsp_mock_count_regions(cs_dsp_mock_adsp2_16bit_dsp1_region_sizes); 2297 2282 dsp->base = cs_dsp_mock_adsp2_16bit_sysbase; 2298 2283 2299 - return cs_dsp_bin_test_common_init(test, dsp); 2284 + return cs_dsp_bin_test_common_init(test, dsp, 1); 2300 2285 } 2286 + 2287 + #define WMDR_PATCH_SHORT .add_patch = cs_dsp_mock_bin_add_patch 2288 + #define WMDR_PATCH_LONG .add_patch = cs_dsp_mock_bin_add_patch_off32 2301 2289 2302 2290 /* Parameterize on choice of XM or YM with a range of word offsets */ 2303 2291 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 }, 2292 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0, WMDR_PATCH_SHORT }, 2293 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 1, WMDR_PATCH_SHORT }, 2294 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 2, WMDR_PATCH_SHORT }, 2295 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 3, WMDR_PATCH_SHORT }, 2296 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 4, WMDR_PATCH_SHORT }, 2297 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 23, WMDR_PATCH_SHORT }, 2298 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 22, WMDR_PATCH_SHORT }, 2299 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 21, WMDR_PATCH_SHORT }, 2300 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 20, WMDR_PATCH_SHORT }, 2313 2301 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 }, 2302 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0, WMDR_PATCH_SHORT }, 2303 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 1, WMDR_PATCH_SHORT }, 2304 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 2, WMDR_PATCH_SHORT }, 2305 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 3, WMDR_PATCH_SHORT }, 2306 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 4, WMDR_PATCH_SHORT }, 2307 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 23, WMDR_PATCH_SHORT }, 2308 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 22, WMDR_PATCH_SHORT }, 2309 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 21, WMDR_PATCH_SHORT }, 2310 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 20, WMDR_PATCH_SHORT }, 2311 + }; 2312 + 2313 + static const struct bin_test_param x_or_y_and_long_offset_param_cases[] = { 2314 + /* Offset < 0xffff in long-offset block type */ 2315 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0, WMDR_PATCH_LONG }, 2316 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 1, WMDR_PATCH_LONG }, 2317 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 2, WMDR_PATCH_LONG }, 2318 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 3, WMDR_PATCH_LONG }, 2319 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 4, WMDR_PATCH_LONG }, 2320 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 23, WMDR_PATCH_LONG }, 2321 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 22, WMDR_PATCH_LONG }, 2322 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 21, WMDR_PATCH_LONG }, 2323 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 20, WMDR_PATCH_LONG }, 2324 + 2325 + /* Offset < 0xffff in long-offset block type */ 2326 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0, WMDR_PATCH_LONG }, 2327 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 1, WMDR_PATCH_LONG }, 2328 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 2, WMDR_PATCH_LONG }, 2329 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 3, WMDR_PATCH_LONG }, 2330 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 4, WMDR_PATCH_LONG }, 2331 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 23, WMDR_PATCH_LONG }, 2332 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 22, WMDR_PATCH_LONG }, 2333 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 21, WMDR_PATCH_LONG }, 2334 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 20, WMDR_PATCH_LONG }, 2335 + 2336 + /* Offset > 0xffff in long-offset block type */ 2337 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x10000, WMDR_PATCH_LONG }, 2338 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x10001, WMDR_PATCH_LONG }, 2339 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x10002, WMDR_PATCH_LONG }, 2340 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x10003, WMDR_PATCH_LONG }, 2341 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x10004, WMDR_PATCH_LONG }, 2342 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x2f003, WMDR_PATCH_LONG }, 2343 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x2f002, WMDR_PATCH_LONG }, 2344 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x2f001, WMDR_PATCH_LONG }, 2345 + { .mem_type = WMFW_ADSP2_XM, .offset_words = 0x2f000, WMDR_PATCH_LONG }, 2346 + 2347 + /* Offset > 0xffff in long-offset block type */ 2348 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x10000, WMDR_PATCH_LONG }, 2349 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x10001, WMDR_PATCH_LONG }, 2350 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x10002, WMDR_PATCH_LONG }, 2351 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x10003, WMDR_PATCH_LONG }, 2352 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x10004, WMDR_PATCH_LONG }, 2353 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x2f003, WMDR_PATCH_LONG }, 2354 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x2f002, WMDR_PATCH_LONG }, 2355 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x2f001, WMDR_PATCH_LONG }, 2356 + { .mem_type = WMFW_ADSP2_YM, .offset_words = 0x2f000, WMDR_PATCH_LONG }, 2323 2357 }; 2324 2358 2325 2359 /* Parameterize on ZM with a range of word offsets */ 2326 2360 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 }, 2361 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 0, WMDR_PATCH_SHORT }, 2362 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 1, WMDR_PATCH_SHORT }, 2363 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 2, WMDR_PATCH_SHORT }, 2364 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 3, WMDR_PATCH_SHORT }, 2365 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 4, WMDR_PATCH_SHORT }, 2366 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 23, WMDR_PATCH_SHORT }, 2367 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 22, WMDR_PATCH_SHORT }, 2368 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 21, WMDR_PATCH_SHORT }, 2369 + { .mem_type = WMFW_ADSP2_ZM, .offset_words = 20, WMDR_PATCH_SHORT }, 2336 2370 }; 2337 2371 2338 2372 /* Parameterize on choice of packed XM or YM with a range of word offsets */ 2339 2373 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 }, 2374 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2375 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 4, WMDR_PATCH_SHORT }, 2376 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 8, WMDR_PATCH_SHORT }, 2377 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 12, WMDR_PATCH_SHORT }, 2344 2378 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 }, 2379 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2380 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 4, WMDR_PATCH_SHORT }, 2381 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 8, WMDR_PATCH_SHORT }, 2382 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 12, WMDR_PATCH_SHORT }, 2383 + }; 2384 + 2385 + static const struct bin_test_param packed_x_or_y_and_long_offset_param_cases[] = { 2386 + /* Offset < 0xffff in long-offset block type */ 2387 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_LONG }, 2388 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 4, WMDR_PATCH_LONG }, 2389 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 8, WMDR_PATCH_LONG }, 2390 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 12, WMDR_PATCH_LONG }, 2391 + 2392 + /* Offset < 0xffff in long-offset block type */ 2393 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_LONG }, 2394 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 4, WMDR_PATCH_LONG }, 2395 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 8, WMDR_PATCH_LONG }, 2396 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 12, WMDR_PATCH_LONG }, 2397 + 2398 + /* Offset > 0xffff in long-offset block type */ 2399 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0x10000, WMDR_PATCH_LONG }, 2400 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0x10004, WMDR_PATCH_LONG }, 2401 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0x10008, WMDR_PATCH_LONG }, 2402 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0x2f000, WMDR_PATCH_LONG }, 2403 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0x2f004, WMDR_PATCH_LONG }, 2404 + 2405 + /* Offset > 0xffff in long-offset block type */ 2406 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0x10000, WMDR_PATCH_LONG }, 2407 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0x10004, WMDR_PATCH_LONG }, 2408 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0x10008, WMDR_PATCH_LONG }, 2409 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0x2f000, WMDR_PATCH_LONG }, 2410 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0x2f004, WMDR_PATCH_LONG }, 2349 2411 }; 2350 2412 2351 2413 static void x_or_y_or_z_and_offset_param_desc(const struct bin_test_param *param, 2352 2414 char *desc) 2353 2415 { 2354 - snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s@%u", 2416 + snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s@%u %s", 2355 2417 cs_dsp_mem_region_name(param->mem_type), 2356 - param->offset_words); 2418 + param->offset_words, 2419 + (param->add_patch == cs_dsp_mock_bin_add_patch_off32) ? "offs32" : ""); 2357 2420 } 2358 2421 2359 2422 KUNIT_ARRAY_PARAM(x_or_y_and_offset, 2360 2423 x_or_y_and_offset_param_cases, 2424 + x_or_y_or_z_and_offset_param_desc); 2425 + 2426 + KUNIT_ARRAY_PARAM(x_or_y_and_long_offset, 2427 + x_or_y_and_long_offset_param_cases, 2361 2428 x_or_y_or_z_and_offset_param_desc); 2362 2429 2363 2430 KUNIT_ARRAY_PARAM(z_and_offset, ··· 2450 2353 packed_x_or_y_and_offset_param_cases, 2451 2354 x_or_y_or_z_and_offset_param_desc); 2452 2355 2356 + KUNIT_ARRAY_PARAM(packed_x_or_y_and_long_offset, 2357 + packed_x_or_y_and_long_offset_param_cases, 2358 + x_or_y_or_z_and_offset_param_desc); 2359 + 2453 2360 /* Parameterize on choice of packed XM or YM */ 2454 2361 static const struct bin_test_param packed_x_or_y_param_cases[] = { 2455 - { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0 }, 2456 - { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0 }, 2362 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2363 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_SHORT }, 2364 + }; 2365 + 2366 + static const struct bin_test_param packed_x_or_y_long_param_cases[] = { 2367 + { .mem_type = WMFW_HALO_XM_PACKED, .offset_words = 0, WMDR_PATCH_LONG }, 2368 + { .mem_type = WMFW_HALO_YM_PACKED, .offset_words = 0, WMDR_PATCH_LONG }, 2457 2369 }; 2458 2370 2459 2371 static void x_or_y_or_z_param_desc(const struct bin_test_param *param, 2460 2372 char *desc) 2461 2373 { 2462 - snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s", cs_dsp_mem_region_name(param->mem_type)); 2374 + snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s %s", 2375 + cs_dsp_mem_region_name(param->mem_type), 2376 + (param->add_patch == cs_dsp_mock_bin_add_patch_off32) ? "offs32" : ""); 2463 2377 } 2464 2378 2465 2379 KUNIT_ARRAY_PARAM(packed_x_or_y, packed_x_or_y_param_cases, x_or_y_or_z_param_desc); 2380 + KUNIT_ARRAY_PARAM(packed_x_or_y_long, packed_x_or_y_long_param_cases, x_or_y_or_z_param_desc); 2466 2381 2467 2382 static const struct bin_test_param offset_param_cases[] = { 2468 - { .offset_words = 0 }, 2469 - { .offset_words = 1 }, 2470 - { .offset_words = 2 }, 2471 - { .offset_words = 3 }, 2472 - { .offset_words = 4 }, 2473 - { .offset_words = 23 }, 2474 - { .offset_words = 22 }, 2475 - { .offset_words = 21 }, 2476 - { .offset_words = 20 }, 2383 + { .offset_words = 0, WMDR_PATCH_SHORT }, 2384 + { .offset_words = 1, WMDR_PATCH_SHORT }, 2385 + { .offset_words = 2, WMDR_PATCH_SHORT }, 2386 + { .offset_words = 3, WMDR_PATCH_SHORT }, 2387 + { .offset_words = 4, WMDR_PATCH_SHORT }, 2388 + { .offset_words = 23, WMDR_PATCH_SHORT }, 2389 + { .offset_words = 22, WMDR_PATCH_SHORT }, 2390 + { .offset_words = 21, WMDR_PATCH_SHORT }, 2391 + { .offset_words = 20, WMDR_PATCH_SHORT }, 2392 + }; 2393 + 2394 + static const struct bin_test_param long_offset_param_cases[] = { 2395 + /* Offset < 0xffff in long-offset block type */ 2396 + { .offset_words = 0, WMDR_PATCH_LONG }, 2397 + { .offset_words = 1, WMDR_PATCH_LONG }, 2398 + { .offset_words = 2, WMDR_PATCH_LONG }, 2399 + { .offset_words = 3, WMDR_PATCH_LONG }, 2400 + { .offset_words = 4, WMDR_PATCH_LONG }, 2401 + { .offset_words = 23, WMDR_PATCH_LONG }, 2402 + { .offset_words = 22, WMDR_PATCH_LONG }, 2403 + { .offset_words = 21, WMDR_PATCH_LONG }, 2404 + { .offset_words = 20, WMDR_PATCH_LONG }, 2405 + 2406 + /* Offset > 0xffff in long-offset block type */ 2407 + { .offset_words = 0x10000, WMDR_PATCH_LONG }, 2408 + { .offset_words = 0x10001, WMDR_PATCH_LONG }, 2409 + { .offset_words = 0x10002, WMDR_PATCH_LONG }, 2410 + { .offset_words = 0x10003, WMDR_PATCH_LONG }, 2411 + { .offset_words = 0x10004, WMDR_PATCH_LONG }, 2412 + { .offset_words = 0x2f000, WMDR_PATCH_LONG }, 2413 + { .offset_words = 0x2f001, WMDR_PATCH_LONG }, 2414 + { .offset_words = 0x2f002, WMDR_PATCH_LONG }, 2415 + { .offset_words = 0x2f003, WMDR_PATCH_LONG }, 2477 2416 }; 2478 2417 2479 2418 static void offset_param_desc(const struct bin_test_param *param, char *desc) 2480 2419 { 2481 - snprintf(desc, KUNIT_PARAM_DESC_SIZE, "@%u", param->offset_words); 2420 + snprintf(desc, KUNIT_PARAM_DESC_SIZE, "@%u %s", 2421 + param->offset_words, 2422 + (param->add_patch == cs_dsp_mock_bin_add_patch_off32) ? "offs32" : ""); 2482 2423 } 2483 2424 2484 2425 KUNIT_ARRAY_PARAM(offset, offset_param_cases, offset_param_desc); 2426 + KUNIT_ARRAY_PARAM(long_offset, long_offset_param_cases, offset_param_desc); 2485 2427 2486 2428 static const struct bin_test_param alg_param_cases[] = { 2487 - { .alg_idx = 0 }, 2488 - { .alg_idx = 1 }, 2489 - { .alg_idx = 2 }, 2490 - { .alg_idx = 3 }, 2429 + { .alg_idx = 0, WMDR_PATCH_SHORT }, 2430 + { .alg_idx = 1, WMDR_PATCH_SHORT }, 2431 + { .alg_idx = 2, WMDR_PATCH_SHORT }, 2432 + { .alg_idx = 3, WMDR_PATCH_SHORT }, 2433 + }; 2434 + 2435 + static const struct bin_test_param alg_long_param_cases[] = { 2436 + { .alg_idx = 0, WMDR_PATCH_LONG }, 2437 + { .alg_idx = 1, WMDR_PATCH_LONG }, 2438 + { .alg_idx = 2, WMDR_PATCH_LONG }, 2439 + { .alg_idx = 3, WMDR_PATCH_LONG }, 2491 2440 }; 2492 2441 2493 2442 static void alg_param_desc(const struct bin_test_param *param, char *desc) 2494 2443 { 2495 2444 WARN_ON(param->alg_idx >= ARRAY_SIZE(bin_test_mock_algs)); 2496 2445 2497 - snprintf(desc, KUNIT_PARAM_DESC_SIZE, "alg[%u] (%#x)", 2498 - param->alg_idx, bin_test_mock_algs[param->alg_idx].id); 2446 + snprintf(desc, KUNIT_PARAM_DESC_SIZE, "alg[%u] (%#x) %s", 2447 + param->alg_idx, bin_test_mock_algs[param->alg_idx].id, 2448 + (param->add_patch == cs_dsp_mock_bin_add_patch_off32) ? "offs32" : ""); 2499 2449 } 2500 2450 2501 2451 KUNIT_ARRAY_PARAM(alg, alg_param_cases, alg_param_desc); 2452 + KUNIT_ARRAY_PARAM(alg_long, alg_long_param_cases, alg_param_desc); 2502 2453 2503 2454 static const struct bin_test_param x_or_y_and_alg_param_cases[] = { 2504 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 0 }, 2505 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 1 }, 2506 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 2 }, 2507 - { .mem_type = WMFW_ADSP2_XM, .alg_idx = 3 }, 2455 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2456 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2457 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2458 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2508 2459 2509 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 0 }, 2510 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 1 }, 2511 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 2 }, 2512 - { .mem_type = WMFW_ADSP2_YM, .alg_idx = 3 }, 2460 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2461 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2462 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2463 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2464 + }; 2465 + 2466 + static const struct bin_test_param x_or_y_and_alg_long_param_cases[] = { 2467 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 0, WMDR_PATCH_LONG }, 2468 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 1, WMDR_PATCH_LONG }, 2469 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 2, WMDR_PATCH_LONG }, 2470 + { .mem_type = WMFW_ADSP2_XM, .alg_idx = 3, WMDR_PATCH_LONG }, 2471 + 2472 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 0, WMDR_PATCH_LONG }, 2473 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 1, WMDR_PATCH_LONG }, 2474 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 2, WMDR_PATCH_LONG }, 2475 + { .mem_type = WMFW_ADSP2_YM, .alg_idx = 3, WMDR_PATCH_LONG }, 2513 2476 }; 2514 2477 2515 2478 static void x_or_y_or_z_and_alg_param_desc(const struct bin_test_param *param, char *desc) 2516 2479 { 2517 2480 WARN_ON(param->alg_idx >= ARRAY_SIZE(bin_test_mock_algs)); 2518 2481 2519 - snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s alg[%u] (%#x)", 2482 + snprintf(desc, KUNIT_PARAM_DESC_SIZE, "%s alg[%u] (%#x) %s", 2520 2483 cs_dsp_mem_region_name(param->mem_type), 2521 - param->alg_idx, bin_test_mock_algs[param->alg_idx].id); 2484 + param->alg_idx, bin_test_mock_algs[param->alg_idx].id, 2485 + (param->add_patch == cs_dsp_mock_bin_add_patch_off32) ? "offs32" : ""); 2522 2486 } 2523 2487 2524 2488 KUNIT_ARRAY_PARAM(x_or_y_and_alg, x_or_y_and_alg_param_cases, x_or_y_or_z_and_alg_param_desc); 2489 + KUNIT_ARRAY_PARAM(x_or_y_and_alg_long, x_or_y_and_alg_long_param_cases, 2490 + x_or_y_or_z_and_alg_param_desc); 2525 2491 2526 2492 static const struct bin_test_param z_and_alg_param_cases[] = { 2527 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 0 }, 2528 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 1 }, 2529 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 2 }, 2530 - { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 3 }, 2493 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 0, WMDR_PATCH_SHORT }, 2494 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 1, WMDR_PATCH_SHORT }, 2495 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 2, WMDR_PATCH_SHORT }, 2496 + { .mem_type = WMFW_ADSP2_ZM, .alg_idx = 3, WMDR_PATCH_SHORT }, 2531 2497 }; 2532 2498 2533 2499 KUNIT_ARRAY_PARAM(z_and_alg, z_and_alg_param_cases, x_or_y_or_z_and_alg_param_desc); 2534 2500 2535 2501 static const struct bin_test_param packed_x_or_y_and_alg_param_cases[] = { 2536 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 0 }, 2537 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 1 }, 2538 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 2 }, 2539 - { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 3 }, 2502 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 0, WMDR_PATCH_SHORT }, 2503 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 1, WMDR_PATCH_SHORT }, 2504 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 2, WMDR_PATCH_SHORT }, 2505 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 3, WMDR_PATCH_SHORT }, 2540 2506 2541 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 0 }, 2542 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 1 }, 2543 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 2 }, 2544 - { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 3 }, 2507 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 0, WMDR_PATCH_SHORT }, 2508 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 1, WMDR_PATCH_SHORT }, 2509 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 2, WMDR_PATCH_SHORT }, 2510 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 3, WMDR_PATCH_SHORT }, 2511 + }; 2512 + 2513 + static const struct bin_test_param packed_x_or_y_and_alg_long_param_cases[] = { 2514 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 0, WMDR_PATCH_LONG }, 2515 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 1, WMDR_PATCH_LONG }, 2516 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 2, WMDR_PATCH_LONG }, 2517 + { .mem_type = WMFW_HALO_XM_PACKED, .alg_idx = 3, WMDR_PATCH_LONG }, 2518 + 2519 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 0, WMDR_PATCH_LONG }, 2520 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 1, WMDR_PATCH_LONG }, 2521 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 2, WMDR_PATCH_LONG }, 2522 + { .mem_type = WMFW_HALO_YM_PACKED, .alg_idx = 3, WMDR_PATCH_LONG }, 2545 2523 }; 2546 2524 2547 2525 KUNIT_ARRAY_PARAM(packed_x_or_y_and_alg, packed_x_or_y_and_alg_param_cases, 2526 + x_or_y_or_z_and_alg_param_desc); 2527 + 2528 + KUNIT_ARRAY_PARAM(packed_x_or_y_and_alg_long, packed_x_or_y_and_alg_long_param_cases, 2548 2529 x_or_y_or_z_and_alg_param_desc); 2549 2530 2550 2531 static struct kunit_case cs_dsp_bin_test_cases_halo[] = { ··· 2680 2505 { } /* terminator */ 2681 2506 }; 2682 2507 2508 + static struct kunit_case cs_dsp_bin_test_cases_halo_wmdr3[] = { 2509 + /* Unpacked memory */ 2510 + KUNIT_CASE_PARAM(bin_patch_one_word, x_or_y_and_offset_gen_params), 2511 + KUNIT_CASE_PARAM(bin_patch_one_multiword, x_or_y_and_offset_gen_params), 2512 + KUNIT_CASE_PARAM(bin_patch_multi_oneword, x_or_y_and_offset_gen_params), 2513 + KUNIT_CASE_PARAM(bin_patch_multi_oneword_unordered, x_or_y_and_offset_gen_params), 2514 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_mems, offset_gen_params), 2515 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_mems, alg_gen_params), 2516 + KUNIT_CASE_PARAM(bin_patch_multi_oneword_sparse_unordered, x_or_y_and_alg_gen_params), 2517 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_algs, x_or_y_and_offset_gen_params), 2518 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_algs_unordered, x_or_y_and_offset_gen_params), 2519 + 2520 + /* Packed memory tests */ 2521 + KUNIT_CASE_PARAM(bin_patch_1_packed, 2522 + packed_x_or_y_and_offset_gen_params), 2523 + KUNIT_CASE_PARAM(bin_patch_1_packed_1_single_trailing, 2524 + packed_x_or_y_and_offset_gen_params), 2525 + KUNIT_CASE_PARAM(bin_patch_1_packed_2_single_trailing, 2526 + packed_x_or_y_and_offset_gen_params), 2527 + KUNIT_CASE_PARAM(bin_patch_1_packed_3_single_trailing, 2528 + packed_x_or_y_and_offset_gen_params), 2529 + KUNIT_CASE_PARAM(bin_patch_1_packed_2_trailing, 2530 + packed_x_or_y_and_offset_gen_params), 2531 + KUNIT_CASE_PARAM(bin_patch_1_packed_3_trailing, 2532 + packed_x_or_y_and_offset_gen_params), 2533 + KUNIT_CASE_PARAM(bin_patch_1_single_leading_1_packed, 2534 + packed_x_or_y_and_offset_gen_params), 2535 + KUNIT_CASE_PARAM(bin_patch_2_single_leading_1_packed, 2536 + packed_x_or_y_and_offset_gen_params), 2537 + KUNIT_CASE_PARAM(bin_patch_2_leading_1_packed, 2538 + packed_x_or_y_and_offset_gen_params), 2539 + KUNIT_CASE_PARAM(bin_patch_3_single_leading_1_packed, 2540 + packed_x_or_y_and_offset_gen_params), 2541 + KUNIT_CASE_PARAM(bin_patch_3_leading_1_packed, 2542 + packed_x_or_y_and_offset_gen_params), 2543 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked, 2544 + packed_x_or_y_and_offset_gen_params), 2545 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked_unordered, 2546 + packed_x_or_y_and_offset_gen_params), 2547 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_mems, offset_gen_params), 2548 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_mems, alg_gen_params), 2549 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked_sparse_unordered, 2550 + packed_x_or_y_and_alg_gen_params), 2551 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_algs, 2552 + packed_x_or_y_and_offset_gen_params), 2553 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_algs_unordered, 2554 + packed_x_or_y_and_offset_gen_params), 2555 + KUNIT_CASE_PARAM(bin_patch_mixed_packed_unpacked_random, 2556 + packed_x_or_y_gen_params), 2557 + 2558 + /* Unpacked memory with long-offset blocks */ 2559 + KUNIT_CASE_PARAM(bin_patch_one_word, x_or_y_and_long_offset_gen_params), 2560 + KUNIT_CASE_PARAM(bin_patch_one_multiword, x_or_y_and_long_offset_gen_params), 2561 + KUNIT_CASE_PARAM(bin_patch_multi_oneword, x_or_y_and_long_offset_gen_params), 2562 + KUNIT_CASE_PARAM(bin_patch_multi_oneword_unordered, x_or_y_and_long_offset_gen_params), 2563 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_mems, long_offset_gen_params), 2564 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_mems, alg_long_gen_params), 2565 + KUNIT_CASE_PARAM(bin_patch_multi_oneword_sparse_unordered, x_or_y_and_alg_long_gen_params), 2566 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_algs, x_or_y_and_long_offset_gen_params), 2567 + KUNIT_CASE_PARAM(bin_patch_one_word_multiple_algs_unordered, 2568 + x_or_y_and_long_offset_gen_params), 2569 + 2570 + /* Packed memory tests with long offset blocks */ 2571 + KUNIT_CASE_PARAM(bin_patch_1_packed, 2572 + packed_x_or_y_and_long_offset_gen_params), 2573 + KUNIT_CASE_PARAM(bin_patch_1_packed_1_single_trailing, 2574 + packed_x_or_y_and_long_offset_gen_params), 2575 + KUNIT_CASE_PARAM(bin_patch_1_packed_2_single_trailing, 2576 + packed_x_or_y_and_long_offset_gen_params), 2577 + KUNIT_CASE_PARAM(bin_patch_1_packed_3_single_trailing, 2578 + packed_x_or_y_and_long_offset_gen_params), 2579 + KUNIT_CASE_PARAM(bin_patch_1_packed_2_trailing, 2580 + packed_x_or_y_and_long_offset_gen_params), 2581 + KUNIT_CASE_PARAM(bin_patch_1_packed_3_trailing, 2582 + packed_x_or_y_and_long_offset_gen_params), 2583 + KUNIT_CASE_PARAM(bin_patch_1_single_leading_1_packed, 2584 + packed_x_or_y_and_long_offset_gen_params), 2585 + KUNIT_CASE_PARAM(bin_patch_2_single_leading_1_packed, 2586 + packed_x_or_y_and_long_offset_gen_params), 2587 + KUNIT_CASE_PARAM(bin_patch_2_leading_1_packed, 2588 + packed_x_or_y_and_long_offset_gen_params), 2589 + KUNIT_CASE_PARAM(bin_patch_3_single_leading_1_packed, 2590 + packed_x_or_y_and_long_offset_gen_params), 2591 + KUNIT_CASE_PARAM(bin_patch_3_leading_1_packed, 2592 + packed_x_or_y_and_long_offset_gen_params), 2593 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked, 2594 + packed_x_or_y_and_long_offset_gen_params), 2595 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked_unordered, 2596 + packed_x_or_y_and_long_offset_gen_params), 2597 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_mems, long_offset_gen_params), 2598 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_mems, alg_long_gen_params), 2599 + KUNIT_CASE_PARAM(bin_patch_multi_onepacked_sparse_unordered, 2600 + packed_x_or_y_and_alg_long_gen_params), 2601 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_algs, 2602 + packed_x_or_y_and_long_offset_gen_params), 2603 + KUNIT_CASE_PARAM(bin_patch_1_packed_multiple_algs_unordered, 2604 + packed_x_or_y_and_long_offset_gen_params), 2605 + KUNIT_CASE_PARAM(bin_patch_mixed_packed_unpacked_random, 2606 + packed_x_or_y_long_gen_params), 2607 + 2608 + KUNIT_CASE(bin_patch_name_and_info), 2609 + 2610 + { } /* terminator */ 2611 + }; 2612 + 2683 2613 static struct kunit_case cs_dsp_bin_test_cases_adsp2[] = { 2684 2614 /* XM and YM */ 2685 2615 KUNIT_CASE_PARAM(bin_patch_one_word, x_or_y_and_offset_gen_params), ··· 2819 2539 .test_cases = cs_dsp_bin_test_cases_halo, 2820 2540 }; 2821 2541 2542 + static struct kunit_suite cs_dsp_bin_test_halo_wmdr3 = { 2543 + .name = "cs_dsp_bin_halo_wmdr_v3", 2544 + .init = cs_dsp_bin_test_halo_wmdr3_init, 2545 + .test_cases = cs_dsp_bin_test_cases_halo_wmdr3, 2546 + }; 2547 + 2822 2548 static struct kunit_suite cs_dsp_bin_test_adsp2_32bit = { 2823 2549 .name = "cs_dsp_bin_adsp2_32bit", 2824 2550 .init = cs_dsp_bin_test_adsp2_32bit_init, ··· 2838 2552 }; 2839 2553 2840 2554 kunit_test_suites(&cs_dsp_bin_test_halo, 2555 + &cs_dsp_bin_test_halo_wmdr3, 2841 2556 &cs_dsp_bin_test_adsp2_32bit, 2842 2557 &cs_dsp_bin_test_adsp2_16bit);
+7 -7
drivers/firmware/cirrus/test/cs_dsp_test_bin_error.c
··· 66 66 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 67 67 cs_dsp_bin_err_test_mock_algs[0].id, 68 68 cs_dsp_bin_err_test_mock_algs[0].ver, 69 - 0xf5, 0, 69 + 0xf5, 0, 0, 70 70 random_data, sizeof(random_data)); 71 71 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 72 72 cs_dsp_bin_err_test_mock_algs[0].id, 73 73 cs_dsp_bin_err_test_mock_algs[0].ver, 74 - 0xf500, 0, 74 + 0xf500, 0, 0, 75 75 random_data, sizeof(random_data)); 76 76 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 77 77 cs_dsp_bin_err_test_mock_algs[0].id, 78 78 cs_dsp_bin_err_test_mock_algs[0].ver, 79 - 0xc300, 0, 79 + 0xc300, 0, 0, 80 80 random_data, sizeof(random_data)); 81 81 82 82 /* Add a single payload to be written to DSP memory */ 83 83 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 84 84 cs_dsp_bin_err_test_mock_algs[0].id, 85 85 cs_dsp_bin_err_test_mock_algs[0].ver, 86 - WMFW_ADSP2_YM, 0, 86 + WMFW_ADSP2_YM, 0, 0, 87 87 payload_data, payload_size_bytes); 88 88 89 89 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); ··· 277 277 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 278 278 cs_dsp_bin_err_test_mock_algs[0].id, 279 279 cs_dsp_bin_err_test_mock_algs[0].ver, 280 - param->block_type, 0, 280 + param->block_type, 0, 0, 281 281 NULL, 0); 282 282 283 283 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); ··· 309 309 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 310 310 cs_dsp_bin_err_test_mock_algs[0].id, 311 311 cs_dsp_bin_err_test_mock_algs[0].ver, 312 - param->block_type, 0, 312 + param->block_type, 0, 0, 313 313 payload, sizeof(payload)); 314 314 315 315 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder); ··· 341 341 cs_dsp_mock_bin_add_raw_block(local->bin_builder, 342 342 cs_dsp_bin_err_test_mock_algs[0].id, 343 343 cs_dsp_bin_err_test_mock_algs[0].ver, 344 - param->block_type, 0, 344 + param->block_type, 0, 0, 345 345 &payload, sizeof(payload)); 346 346 347 347 bin = cs_dsp_mock_bin_get_firmware(local->bin_builder);
+5 -1
include/linux/firmware/cirrus/cs_dsp_test_utils.h
··· 126 126 unsigned int fw_version); 127 127 void cs_dsp_mock_bin_add_raw_block(struct cs_dsp_mock_bin_builder *builder, 128 128 unsigned int alg_id, unsigned int alg_ver, 129 - int type, unsigned int offset, 129 + int type, u16 offset, u32 offset32, 130 130 const void *payload_data, size_t payload_len_bytes); 131 131 void cs_dsp_mock_bin_add_info(struct cs_dsp_mock_bin_builder *builder, 132 132 const char *info); ··· 136 136 unsigned int alg_id, unsigned int alg_ver, 137 137 int mem_region, unsigned int reg_addr_offset, 138 138 const void *payload_data, size_t payload_len_bytes); 139 + void cs_dsp_mock_bin_add_patch_off32(struct cs_dsp_mock_bin_builder *builder, 140 + unsigned int alg_id, unsigned int alg_ver, 141 + int mem_region, unsigned int reg_addr_offset, 142 + const void *payload_data, size_t payload_len_bytes); 139 143 struct firmware *cs_dsp_mock_bin_get_firmware(struct cs_dsp_mock_bin_builder *builder); 140 144 141 145 struct cs_dsp_mock_wmfw_builder *cs_dsp_mock_wmfw_init(struct cs_dsp_test *priv,
+6 -1
include/linux/firmware/cirrus/wmfw.h
··· 172 172 __le16 type; 173 173 __le32 id; 174 174 __le32 ver; 175 - __le32 sr; 175 + __le32 offset32; 176 176 __le32 len; 177 177 u8 data[]; 178 178 } __packed; ··· 199 199 #define WMFW_HALO_PM_PACKED 0x10 200 200 #define WMFW_HALO_XM_PACKED 0x11 201 201 #define WMFW_HALO_YM_PACKED 0x12 202 + 203 + #define WMFW_ADSP2_XM_LONG 0xf405 204 + #define WMFW_ADSP2_YM_LONG 0xf406 205 + #define WMFW_HALO_XM_PACKED_LONG 0xf411 206 + #define WMFW_HALO_YM_PACKED_LONG 0xf412 202 207 203 208 #endif