projects/linux·blob master · refs

616 lines · 17.4 KiB

1// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2//
3// This file is provided under a dual BSD/GPLv2 license. When using or
4// redistributing this file, you may do so under either license.
5//
6// Copyright(c) 2022 Intel Corporation
7
8#include <linux/firmware.h>
9#include <sound/sof/ext_manifest4.h>
10#include <sound/sof/ipc4/header.h>
11#include <trace/events/sof.h>
12#include "ipc4-priv.h"
13#include "sof-audio.h"
14#include "sof-priv.h"
15#include "ops.h"
16
17/* The module ID includes the id of the library it is part of at offset 12 */
18#define SOF_IPC4_MOD_LIB_ID_SHIFT 12
19
20static ssize_t sof_ipc4_fw_parse_ext_man(struct snd_sof_dev *sdev,
21 struct sof_ipc4_fw_library *fw_lib)
22{
23 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
24 const struct firmware *fw = fw_lib->sof_fw.fw;
25 struct sof_man4_fw_binary_header *fw_header;
26 struct sof_ext_manifest4_hdr *ext_man_hdr;
27 struct sof_man4_module_config *fm_config;
28 struct sof_ipc4_fw_module *fw_module;
29 struct sof_man4_module *fm_entry;
30 ssize_t remaining;
31 u32 fw_hdr_offset;
32 int i;
33
34 if (!ipc4_data) {
35 dev_err(sdev->dev, "%s: ipc4_data is not available\n", __func__);
36 return -EINVAL;
37 }
38
39 remaining = fw->size;
40 if (remaining <= sizeof(*ext_man_hdr)) {
41 dev_err(sdev->dev, "Firmware size is too small: %zu\n", remaining);
42 return -EINVAL;
43 }
44
45 ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
46
47 /*
48 * At the start of the firmware image we must have an extended manifest.
49 * Verify that the magic number is correct.
50 */
51 if (ext_man_hdr->id != SOF_EXT_MAN4_MAGIC_NUMBER) {
52 dev_err(sdev->dev,
53 "Unexpected extended manifest magic number: %#x\n",
54 ext_man_hdr->id);
55 return -EINVAL;
56 }
57
58 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
59 if (!fw_hdr_offset)
60 return -EINVAL;
61
62 if (remaining <= ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header)) {
63 dev_err(sdev->dev, "Invalid firmware size %zu, should be at least %zu\n",
64 remaining, ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header));
65 return -EINVAL;
66 }
67
68 fw_header = (struct sof_man4_fw_binary_header *)
69 (fw->data + ext_man_hdr->len + fw_hdr_offset);
70 remaining -= (ext_man_hdr->len + fw_hdr_offset);
71
72 if (remaining <= fw_header->len) {
73 dev_err(sdev->dev, "Invalid fw_header->len %u\n", fw_header->len);
74 return -EINVAL;
75 }
76
77 dev_info(sdev->dev, "Loaded firmware library: %s, version: %u.%u.%u.%u\n",
78 fw_header->name, fw_header->major_version, fw_header->minor_version,
79 fw_header->hotfix_version, fw_header->build_version);
80 dev_dbg(sdev->dev, "Header length: %u, module count: %u\n",
81 fw_header->len, fw_header->num_module_entries);
82
83 /* copy the fw_version of basefw into debugfs at first boot */
84 if (fw == sdev->basefw.fw) {
85 sdev->fw_version.major = fw_header->major_version;
86 sdev->fw_version.minor = fw_header->minor_version;
87 sdev->fw_version.micro = fw_header->hotfix_version;
88 sdev->fw_version.build = fw_header->build_version;
89 }
90
91 fw_lib->modules = devm_kmalloc_array(sdev->dev, fw_header->num_module_entries,
92 sizeof(*fw_module), GFP_KERNEL);
93 if (!fw_lib->modules)
94 return -ENOMEM;
95
96 fw_lib->name = fw_header->name;
97 fw_lib->num_modules = fw_header->num_module_entries;
98 fw_module = fw_lib->modules;
99
100 fm_entry = (struct sof_man4_module *)((u8 *)fw_header + fw_header->len);
101 remaining -= fw_header->len;
102
103 if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {
104 dev_err(sdev->dev, "Invalid num_module_entries %u\n",
105 fw_header->num_module_entries);
106 return -EINVAL;
107 }
108
109 fm_config = (struct sof_man4_module_config *)
110 (fm_entry + fw_header->num_module_entries);
111 remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));
112 for (i = 0; i < fw_header->num_module_entries; i++) {
113 memcpy(&fw_module->man4_module_entry, fm_entry, sizeof(*fm_entry));
114
115 if (fm_entry->cfg_count) {
116 if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *
117 sizeof(*fm_config)) {
118 dev_err(sdev->dev, "Invalid module cfg_offset %u\n",
119 fm_entry->cfg_offset);
120 return -EINVAL;
121 }
122
123 fw_module->fw_mod_cfg = &fm_config[fm_entry->cfg_offset];
124
125 dev_dbg(sdev->dev,
126 "module %s: UUID %pUL cfg_count: %u, bss_size: %#x\n",
127 fm_entry->name, &fm_entry->uuid, fm_entry->cfg_count,
128 fm_config[fm_entry->cfg_offset].is_bytes);
129 } else {
130 dev_dbg(sdev->dev, "module %s: UUID %pUL\n", fm_entry->name,
131 &fm_entry->uuid);
132 }
133
134 fw_module->man4_module_entry.id = i;
135 ida_init(&fw_module->m_ida);
136 fw_module->private = NULL;
137
138 fw_module++;
139 fm_entry++;
140 }
141
142 return ext_man_hdr->len;
143}
144
145static size_t sof_ipc4_fw_parse_basefw_ext_man(struct snd_sof_dev *sdev)
146{
147 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
148 struct sof_ipc4_fw_library *fw_lib;
149 ssize_t payload_offset;
150 int ret;
151
152 fw_lib = devm_kzalloc(sdev->dev, sizeof(*fw_lib), GFP_KERNEL);
153 if (!fw_lib)
154 return -ENOMEM;
155
156 fw_lib->sof_fw.fw = sdev->basefw.fw;
157
158 payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
159 if (payload_offset > 0) {
160 fw_lib->sof_fw.payload_offset = payload_offset;
161
162 /* basefw ID is 0 */
163 fw_lib->id = 0;
164 ret = xa_insert(&ipc4_data->fw_lib_xa, 0, fw_lib, GFP_KERNEL);
165 if (ret)
166 return ret;
167 }
168
169 return payload_offset;
170}
171
172static int sof_ipc4_load_library(struct snd_sof_dev *sdev, unsigned long lib_id,
173 const char *lib_filename, bool optional)
174{
175 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
176 struct sof_ipc4_fw_library *fw_lib;
177 ssize_t payload_offset;
178 int ret, i;
179
180 if (!ipc4_data->load_library) {
181 dev_err(sdev->dev, "Library loading is not supported on this platform\n");
182 return -EOPNOTSUPP;
183 }
184
185 fw_lib = devm_kzalloc(sdev->dev, sizeof(*fw_lib), GFP_KERNEL);
186 if (!fw_lib)
187 return -ENOMEM;
188
189 if (optional) {
190 ret = firmware_request_nowarn(&fw_lib->sof_fw.fw, lib_filename,
191 sdev->dev);
192 if (ret < 0) {
193 /* optional library, override the error */
194 ret = 0;
195 goto free_fw_lib;
196 }
197 } else {
198 ret = request_firmware(&fw_lib->sof_fw.fw, lib_filename,
199 sdev->dev);
200 if (ret < 0) {
201 dev_err(sdev->dev, "Library file '%s' is missing\n",
202 lib_filename);
203 goto free_fw_lib;
204 }
205 }
206
207 dev_dbg(sdev->dev, "Library file '%s' loaded\n", lib_filename);
208
209 payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
210 if (payload_offset <= 0) {
211 if (!payload_offset)
212 ret = -EINVAL;
213 else
214 ret = payload_offset;
215
216 goto release;
217 }
218
219 fw_lib->sof_fw.payload_offset = payload_offset;
220 fw_lib->id = lib_id;
221
222 /* Fix up the module ID numbers within the library */
223 for (i = 0; i < fw_lib->num_modules; i++)
224 fw_lib->modules[i].man4_module_entry.id |= (lib_id << SOF_IPC4_MOD_LIB_ID_SHIFT);
225
226 ret = ipc4_data->load_library(sdev, fw_lib, false);
227 if (ret)
228 goto release;
229
230 ret = xa_insert(&ipc4_data->fw_lib_xa, lib_id, fw_lib, GFP_KERNEL);
231 if (unlikely(ret))
232 goto release;
233
234 return 0;
235
236release:
237 release_firmware(fw_lib->sof_fw.fw);
238 /* Allocated within sof_ipc4_fw_parse_ext_man() */
239 devm_kfree(sdev->dev, fw_lib->modules);
240free_fw_lib:
241 devm_kfree(sdev->dev, fw_lib);
242
243 return ret;
244}
245
246/**
247 * sof_ipc4_complete_split_release - loads the library parts of a split firmware
248 * @sdev: SOF device
249 *
250 * With IPC4 the firmware can be a single binary or a split release.
251 * - single binary: only the basefw
252 * - split release: basefw and two libraries (openmodules, debug)
253 *
254 * With split firmware release it is also allowed that for example only the
255 * debug library is present (the openmodules content is built in the basefw).
256 *
257 * To handle the permutations try to load the openmodules then the debug
258 * libraries as optional ones after the basefw boot.
259 *
260 * The libraries for the split release are stored alongside the basefw on the
261 * filesystem.
262 */
263int sof_ipc4_complete_split_release(struct snd_sof_dev *sdev)
264{
265 static const char * const lib_bundle[] = { "openmodules", "debug" };
266 const char *fw_filename = sdev->pdata->fw_filename;
267 const char *lib_filename, *p;
268 size_t lib_name_base_size;
269 unsigned long lib_id = 1;
270 char *lib_name_base;
271 int i;
272
273 p = strstr(fw_filename, ".ri");
274 if (!p || strlen(p) != 3) {
275 dev_info(sdev->dev,
276 "%s: Firmware name '%s' is missing .ri extension\n",
277 __func__, fw_filename);
278 return 0;
279 }
280
281 /* Space for the firmware basename + '\0', without the extension */
282 lib_name_base_size = strlen(fw_filename) - 2;
283 lib_name_base = kzalloc(lib_name_base_size, GFP_KERNEL);
284 if (!lib_name_base)
285 return -ENOMEM;
286
287 /*
288 * strscpy will 0 terminate the copied string, removing the '.ri' from
289 * the end of the fw_filename, for example:
290 * fw_filename: "sof-ptl.ri\0"
291 * lib_name_base: "sof-ptl\0"
292 */
293 strscpy(lib_name_base, fw_filename, lib_name_base_size);
294
295 for (i = 0; i < ARRAY_SIZE(lib_bundle); i++) {
296 int ret;
297
298 lib_filename = kasprintf(GFP_KERNEL, "%s/%s-%s.ri",
299 sdev->pdata->fw_filename_prefix,
300 lib_name_base, lib_bundle[i]);
301 if (!lib_filename) {
302 kfree(lib_name_base);
303 return -ENOMEM;
304 }
305
306 ret = sof_ipc4_load_library(sdev, lib_id, lib_filename, true);
307 if (ret)
308 dev_warn(sdev->dev, "%s: Failed to load %s: %d\n",
309 __func__, lib_filename, ret);
310 else
311 lib_id++;
312
313 kfree(lib_filename);
314 }
315
316 kfree(lib_name_base);
317
318 return 0;
319}
320
321static int sof_ipc4_load_library_by_uuid(struct snd_sof_dev *sdev,
322 unsigned long lib_id, const guid_t *uuid)
323{
324 const char *lib_filename;
325 int ret;
326
327 if (!sdev->pdata->fw_lib_prefix) {
328 dev_err(sdev->dev,
329 "Library loading is not supported due to not set library path\n");
330 return -EINVAL;
331 }
332
333 lib_filename = kasprintf(GFP_KERNEL, "%s/%pUL.bin",
334 sdev->pdata->fw_lib_prefix, uuid);
335 if (!lib_filename)
336 return -ENOMEM;
337
338 ret = sof_ipc4_load_library(sdev, lib_id, lib_filename, false);
339
340 kfree(lib_filename);
341
342 return ret;
343}
344
345struct sof_ipc4_fw_module *sof_ipc4_find_module_by_uuid(struct snd_sof_dev *sdev,
346 const guid_t *uuid)
347{
348 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
349 struct sof_ipc4_fw_library *fw_lib;
350 unsigned long lib_id;
351 int i, ret;
352
353 if (guid_is_null(uuid))
354 return NULL;
355
356 xa_for_each(&ipc4_data->fw_lib_xa, lib_id, fw_lib) {
357 for (i = 0; i < fw_lib->num_modules; i++) {
358 if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
359 return &fw_lib->modules[i];
360 }
361 }
362
363 /*
364 * Do not attempt to load external library in case the maximum number of
365 * firmware libraries have been already loaded
366 */
367 if ((lib_id + 1) == ipc4_data->max_libs_count) {
368 dev_err(sdev->dev,
369 "%s: Maximum allowed number of libraries reached (%u)\n",
370 __func__, ipc4_data->max_libs_count);
371 return NULL;
372 }
373
374 /* The module cannot be found, try to load it as a library */
375 ret = sof_ipc4_load_library_by_uuid(sdev, lib_id + 1, uuid);
376 if (ret)
377 return NULL;
378
379 /* Look for the module in the newly loaded library, it should be available now */
380 xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, lib_id) {
381 for (i = 0; i < fw_lib->num_modules; i++) {
382 if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
383 return &fw_lib->modules[i];
384 }
385 }
386
387 return NULL;
388}
389
390static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
391{
392 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
393 u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
394 struct sof_man4_fw_binary_header *fw_header;
395 const struct firmware *fw = sdev->basefw.fw;
396 struct sof_ext_manifest4_hdr *ext_man_hdr;
397
398 ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
399 fw_header = (struct sof_man4_fw_binary_header *)
400 (fw->data + ext_man_hdr->len + fw_hdr_offset);
401
402 /* TODO: Add firmware verification code here */
403
404 dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
405 fw_header->major_version, fw_header->minor_version,
406 fw_header->hotfix_version, fw_header->build_version);
407
408 return 0;
409}
410
411int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
412{
413 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
414 const struct sof_ipc_ops *iops = sdev->ipc->ops;
415 struct sof_ipc4_fw_version *fw_ver;
416 struct sof_ipc4_tuple *tuple;
417 struct sof_ipc4_msg msg;
418 size_t offset = 0;
419 int ret;
420
421 /* Get the firmware configuration */
422 msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
423 msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
424 msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
425 msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
426 msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
427
428 msg.data_size = sdev->ipc->max_payload_size;
429 msg.data_ptr = kzalloc(msg.data_size, GFP_KERNEL);
430 if (!msg.data_ptr)
431 return -ENOMEM;
432
433 ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
434 if (ret)
435 goto out;
436
437 while (offset < msg.data_size) {
438 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
439
440 switch (tuple->type) {
441 case SOF_IPC4_FW_CFG_FW_VERSION:
442 fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
443
444 dev_info(sdev->dev,
445 "Booted firmware version: %u.%u.%u.%u\n",
446 fw_ver->major, fw_ver->minor, fw_ver->hotfix,
447 fw_ver->build);
448 break;
449 case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
450 trace_sof_ipc4_fw_config(sdev, "DL mailbox size", *tuple->value);
451 break;
452 case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
453 trace_sof_ipc4_fw_config(sdev, "UL mailbox size", *tuple->value);
454 break;
455 case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
456 trace_sof_ipc4_fw_config(sdev, "Trace log size", *tuple->value);
457 ipc4_data->mtrace_log_bytes = *tuple->value;
458 break;
459 case SOF_IPC4_FW_CFG_MAX_LIBS_COUNT:
460 trace_sof_ipc4_fw_config(sdev, "maximum number of libraries",
461 *tuple->value);
462 ipc4_data->max_libs_count = *tuple->value;
463 if (!ipc4_data->max_libs_count)
464 ipc4_data->max_libs_count = 1;
465 break;
466 case SOF_IPC4_FW_CFG_MAX_PPL_COUNT:
467 ipc4_data->max_num_pipelines = *tuple->value;
468 trace_sof_ipc4_fw_config(sdev, "Max PPL count %d",
469 ipc4_data->max_num_pipelines);
470 if (ipc4_data->max_num_pipelines <= 0) {
471 dev_err(sdev->dev, "Invalid max_num_pipelines %d",
472 ipc4_data->max_num_pipelines);
473 ret = -EINVAL;
474 goto out;
475 }
476 break;
477 case SOF_IPC4_FW_CONTEXT_SAVE:
478 ipc4_data->fw_context_save = *tuple->value;
479 /*
480 * Set the default libraries_restored value - if full
481 * context save is supported then it means that
482 * libraries are restored
483 */
484 ipc4_data->libraries_restored = ipc4_data->fw_context_save;
485 break;
486 default:
487 break;
488 }
489
490 offset += sizeof(*tuple) + tuple->size;
491 }
492
493 /* Get the hardware configuration */
494 msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
495 msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
496 msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
497 msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
498 msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_HW_CONFIG_GET);
499
500 msg.data_size = sdev->ipc->max_payload_size;
501
502 ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
503 if (ret)
504 goto out;
505
506 offset = 0;
507 while (offset < msg.data_size) {
508 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
509
510 switch (tuple->type) {
511 case SOF_IPC4_HW_CFG_INTEL_MIC_PRIVACY_CAPS:
512 if (ipc4_data->intel_configure_mic_privacy) {
513 struct sof_ipc4_intel_mic_privacy_cap *caps;
514
515 caps = (struct sof_ipc4_intel_mic_privacy_cap *)tuple->value;
516 ipc4_data->intel_configure_mic_privacy(sdev, caps);
517 }
518 break;
519 default:
520 break;
521 }
522
523 offset += sizeof(*tuple) + tuple->size;
524 }
525
526out:
527 kfree(msg.data_ptr);
528
529 return ret;
530}
531
532int sof_ipc4_reload_fw_libraries(struct snd_sof_dev *sdev)
533{
534 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
535 struct sof_ipc4_fw_library *fw_lib;
536 unsigned long lib_id;
537 int ret = 0;
538
539 xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, 1) {
540 ret = ipc4_data->load_library(sdev, fw_lib, true);
541 if (ret) {
542 dev_err(sdev->dev, "%s: Failed to reload library: %s, %d\n",
543 __func__, fw_lib->name, ret);
544 break;
545 }
546 }
547
548 return ret;
549}
550
551/**
552 * sof_ipc4_update_cpc_from_manifest - Update the cpc in base config from manifest
553 * @sdev: SOF device
554 * @fw_module: pointer struct sof_ipc4_fw_module to parse
555 * @basecfg: Pointer to the base_config to update
556 */
557void sof_ipc4_update_cpc_from_manifest(struct snd_sof_dev *sdev,
558 struct sof_ipc4_fw_module *fw_module,
559 struct sof_ipc4_base_module_cfg *basecfg)
560{
561 const struct sof_man4_module_config *fw_mod_cfg;
562 u32 cpc_pick = 0;
563 u32 max_cpc = 0;
564 const char *msg;
565 int i;
566
567 if (!fw_module->fw_mod_cfg) {
568 msg = "No mod_cfg available for CPC lookup in the firmware file's manifest";
569 goto no_cpc;
570 }
571
572 /*
573 * Find the best matching (highest) CPC value based on the module's
574 * IBS/OBS configuration inferred from the audio format selection.
575 *
576 * The CPC value in each module config entry has been measured and
577 * recorded as a IBS/OBS/CPC triplet and stored in the firmware file's
578 * manifest
579 */
580 fw_mod_cfg = fw_module->fw_mod_cfg;
581 for (i = 0; i < fw_module->man4_module_entry.cfg_count; i++) {
582 if (basecfg->obs == fw_mod_cfg[i].obs &&
583 basecfg->ibs == fw_mod_cfg[i].ibs &&
584 cpc_pick < fw_mod_cfg[i].cpc)
585 cpc_pick = fw_mod_cfg[i].cpc;
586
587 if (max_cpc < fw_mod_cfg[i].cpc)
588 max_cpc = fw_mod_cfg[i].cpc;
589 }
590
591 basecfg->cpc = cpc_pick;
592
593 /* We have a matching configuration for CPC */
594 if (basecfg->cpc)
595 return;
596
597 /*
598 * No matching IBS/OBS found, the firmware manifest is missing
599 * information in the module's module configuration table.
600 */
601 if (!max_cpc)
602 msg = "No CPC value available in the firmware file's manifest";
603 else if (!cpc_pick)
604 msg = "No CPC match in the firmware file's manifest";
605
606no_cpc:
607 dev_dbg(sdev->dev, "%s (UUID: %pUL): %s (ibs/obs: %u/%u)\n",
608 fw_module->man4_module_entry.name,
609 &fw_module->man4_module_entry.uuid, msg, basecfg->ibs,
610 basecfg->obs);
611}
612
613const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
614 .validate = sof_ipc4_validate_firmware,
615 .parse_ext_manifest = sof_ipc4_fw_parse_basefw_ext_man,
616};