ipc4-loader.c

  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, err;
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	/*
227	 * Make sure that the DSP is booted and stays up while attempting the
228	 * loading the library for the first time
229	 */
230	ret = pm_runtime_resume_and_get(sdev->dev);
231	if (ret < 0 && ret != -EACCES) {
232		dev_err_ratelimited(sdev->dev, "%s: pm_runtime resume failed: %d\n",
233				    __func__, ret);
234		goto release;
235	}
236
237	ret = ipc4_data->load_library(sdev, fw_lib, false);
238
239	err = pm_runtime_put_autosuspend(sdev->dev);
240	if (err < 0)
241		dev_err_ratelimited(sdev->dev, "%s: pm_runtime idle failed: %d\n",
242				    __func__, err);
243
244	if (ret)
245		goto release;
246
247	ret = xa_insert(&ipc4_data->fw_lib_xa, lib_id, fw_lib, GFP_KERNEL);
248	if (unlikely(ret))
249		goto release;
250
251	return 0;
252
253release:
254	release_firmware(fw_lib->sof_fw.fw);
255	/* Allocated within sof_ipc4_fw_parse_ext_man() */
256	devm_kfree(sdev->dev, fw_lib->modules);
257free_fw_lib:
258	devm_kfree(sdev->dev, fw_lib);
259
260	return ret;
261}
262
263/**
264 * sof_ipc4_complete_split_release - loads the library parts of a split firmware
265 * @sdev: SOF device
266 *
267 * With IPC4 the firmware can be a single binary or a split release.
268 * - single binary: only the basefw
269 * - split release: basefw and two libraries (openmodules, debug)
270 *
271 * With split firmware release it is also allowed that for example only the
272 * debug library is present (the openmodules content is built in the basefw).
273 *
274 * To handle the permutations try to load the openmodules then the debug
275 * libraries as optional ones after the basefw boot.
276 *
277 * The libraries for the split release are stored alongside the basefw on the
278 * filesystem.
279 */
280int sof_ipc4_complete_split_release(struct snd_sof_dev *sdev)
281{
282	static const char * const lib_bundle[] = { "openmodules", "debug" };
283	const char *fw_filename = sdev->pdata->fw_filename;
284	const char *lib_filename, *p;
285	size_t lib_name_base_size;
286	unsigned long lib_id = 1;
287	char *lib_name_base;
288	int i;
289
290	p = strstr(fw_filename, ".ri");
291	if (!p || strlen(p) != 3) {
292		dev_info(sdev->dev,
293			 "%s: Firmware name '%s' is missing .ri extension\n",
294			 __func__, fw_filename);
295		return 0;
296	}
297
298	/* Space for the firmware basename + '\0', without the extension */
299	lib_name_base_size = strlen(fw_filename) - 2;
300	lib_name_base = kzalloc(lib_name_base_size, GFP_KERNEL);
301	if (!lib_name_base)
302		return -ENOMEM;
303
304	/*
305	 * strscpy will 0 terminate the copied string, removing the '.ri' from
306	 * the end of the fw_filename, for example:
307	 * fw_filename:		"sof-ptl.ri\0"
308	 * lib_name_base:	"sof-ptl\0"
309	 */
310	strscpy(lib_name_base, fw_filename, lib_name_base_size);
311
312	for (i = 0; i < ARRAY_SIZE(lib_bundle); i++) {
313		int ret;
314
315		lib_filename = kasprintf(GFP_KERNEL, "%s/%s-%s.ri",
316					 sdev->pdata->fw_filename_prefix,
317					 lib_name_base, lib_bundle[i]);
318		if (!lib_filename) {
319			kfree(lib_name_base);
320			return -ENOMEM;
321		}
322
323		ret = sof_ipc4_load_library(sdev, lib_id, lib_filename, true);
324		if (ret)
325			dev_warn(sdev->dev, "%s: Failed to load %s: %d\n",
326				 __func__, lib_filename, ret);
327		else
328			lib_id++;
329
330		kfree(lib_filename);
331	}
332
333	kfree(lib_name_base);
334
335	return 0;
336}
337
338static int sof_ipc4_load_library_by_uuid(struct snd_sof_dev *sdev,
339					 unsigned long lib_id, const guid_t *uuid)
340{
341	const char *lib_filename;
342	int ret;
343
344	if (!sdev->pdata->fw_lib_prefix) {
345		dev_err(sdev->dev,
346			"Library loading is not supported due to not set library path\n");
347		return -EINVAL;
348	}
349
350	lib_filename = kasprintf(GFP_KERNEL, "%s/%pUL.bin",
351				 sdev->pdata->fw_lib_prefix, uuid);
352	if (!lib_filename)
353		return -ENOMEM;
354
355	ret = sof_ipc4_load_library(sdev, lib_id, lib_filename, false);
356
357	kfree(lib_filename);
358
359	return ret;
360}
361
362struct sof_ipc4_fw_module *sof_ipc4_find_module_by_uuid(struct snd_sof_dev *sdev,
363							const guid_t *uuid)
364{
365	struct sof_ipc4_fw_data *ipc4_data = sdev->private;
366	struct sof_ipc4_fw_library *fw_lib;
367	unsigned long lib_id;
368	int i, ret;
369
370	if (guid_is_null(uuid))
371		return NULL;
372
373	xa_for_each(&ipc4_data->fw_lib_xa, lib_id, fw_lib) {
374		for (i = 0; i < fw_lib->num_modules; i++) {
375			if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
376				return &fw_lib->modules[i];
377		}
378	}
379
380	/*
381	 * Do not attempt to load external library in case the maximum number of
382	 * firmware libraries have been already loaded
383	 */
384	if ((lib_id + 1) == ipc4_data->max_libs_count) {
385		dev_err(sdev->dev,
386			"%s: Maximum allowed number of libraries reached (%u)\n",
387			__func__, ipc4_data->max_libs_count);
388		return NULL;
389	}
390
391	/* The module cannot be found, try to load it as a library */
392	ret = sof_ipc4_load_library_by_uuid(sdev, lib_id + 1, uuid);
393	if (ret)
394		return NULL;
395
396	/* Look for the module in the newly loaded library, it should be available now */
397	xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, lib_id) {
398		for (i = 0; i < fw_lib->num_modules; i++) {
399			if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
400				return &fw_lib->modules[i];
401		}
402	}
403
404	return NULL;
405}
406
407static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
408{
409	struct sof_ipc4_fw_data *ipc4_data = sdev->private;
410	u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
411	struct sof_man4_fw_binary_header *fw_header;
412	const struct firmware *fw = sdev->basefw.fw;
413	struct sof_ext_manifest4_hdr *ext_man_hdr;
414
415	ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
416	fw_header = (struct sof_man4_fw_binary_header *)
417				(fw->data + ext_man_hdr->len + fw_hdr_offset);
418
419	/* TODO: Add firmware verification code here */
420
421	dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
422		fw_header->major_version, fw_header->minor_version,
423		fw_header->hotfix_version, fw_header->build_version);
424
425	return 0;
426}
427
428int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
429{
430	struct sof_ipc4_fw_data *ipc4_data = sdev->private;
431	const struct sof_ipc_ops *iops = sdev->ipc->ops;
432	struct sof_ipc4_fw_version *fw_ver;
433	struct sof_ipc4_tuple *tuple;
434	struct sof_ipc4_msg msg;
435	size_t offset = 0;
436	int ret;
437
438	/* Get the firmware configuration */
439	msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
440	msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
441	msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
442	msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
443	msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
444
445	msg.data_size = sdev->ipc->max_payload_size;
446	msg.data_ptr = kzalloc(msg.data_size, GFP_KERNEL);
447	if (!msg.data_ptr)
448		return -ENOMEM;
449
450	ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
451	if (ret)
452		goto out;
453
454	while (offset < msg.data_size) {
455		tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
456
457		switch (tuple->type) {
458		case SOF_IPC4_FW_CFG_FW_VERSION:
459			fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
460
461			dev_info(sdev->dev,
462				 "Booted firmware version: %u.%u.%u.%u\n",
463				 fw_ver->major, fw_ver->minor, fw_ver->hotfix,
464				 fw_ver->build);
465			break;
466		case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
467			trace_sof_ipc4_fw_config(sdev, "DL mailbox size", *tuple->value);
468			break;
469		case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
470			trace_sof_ipc4_fw_config(sdev, "UL mailbox size", *tuple->value);
471			break;
472		case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
473			trace_sof_ipc4_fw_config(sdev, "Trace log size", *tuple->value);
474			ipc4_data->mtrace_log_bytes = *tuple->value;
475			break;
476		case SOF_IPC4_FW_CFG_MAX_LIBS_COUNT:
477			trace_sof_ipc4_fw_config(sdev, "maximum number of libraries",
478						 *tuple->value);
479			ipc4_data->max_libs_count = *tuple->value;
480			if (!ipc4_data->max_libs_count)
481				ipc4_data->max_libs_count = 1;
482			break;
483		case SOF_IPC4_FW_CFG_MAX_PPL_COUNT:
484			ipc4_data->max_num_pipelines = *tuple->value;
485			trace_sof_ipc4_fw_config(sdev, "Max PPL count %d",
486						 ipc4_data->max_num_pipelines);
487			if (ipc4_data->max_num_pipelines <= 0) {
488				dev_err(sdev->dev, "Invalid max_num_pipelines %d",
489					ipc4_data->max_num_pipelines);
490				ret = -EINVAL;
491				goto out;
492			}
493			break;
494		case SOF_IPC4_FW_CONTEXT_SAVE:
495			ipc4_data->fw_context_save = *tuple->value;
496			/*
497			 * Set the default libraries_restored value - if full
498			 * context save is supported then it means that
499			 * libraries are restored
500			 */
501			ipc4_data->libraries_restored = ipc4_data->fw_context_save;
502			break;
503		default:
504			break;
505		}
506
507		offset += sizeof(*tuple) + tuple->size;
508	}
509
510	/* Get the hardware configuration */
511	msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
512	msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
513	msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
514	msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
515	msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_HW_CONFIG_GET);
516
517	msg.data_size = sdev->ipc->max_payload_size;
518
519	ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
520	if (ret)
521		goto out;
522
523	offset = 0;
524	while (offset < msg.data_size) {
525		tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
526
527		switch (tuple->type) {
528		case SOF_IPC4_HW_CFG_INTEL_MIC_PRIVACY_CAPS:
529			if (ipc4_data->intel_configure_mic_privacy) {
530				struct sof_ipc4_intel_mic_privacy_cap *caps;
531
532				caps = (struct sof_ipc4_intel_mic_privacy_cap *)tuple->value;
533				ipc4_data->intel_configure_mic_privacy(sdev, caps);
534			}
535			break;
536		default:
537			break;
538		}
539
540		offset += sizeof(*tuple) + tuple->size;
541	}
542
543out:
544	kfree(msg.data_ptr);
545
546	return ret;
547}
548
549int sof_ipc4_reload_fw_libraries(struct snd_sof_dev *sdev)
550{
551	struct sof_ipc4_fw_data *ipc4_data = sdev->private;
552	struct sof_ipc4_fw_library *fw_lib;
553	unsigned long lib_id;
554	int ret = 0;
555
556	xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, 1) {
557		ret = ipc4_data->load_library(sdev, fw_lib, true);
558		if (ret) {
559			dev_err(sdev->dev, "%s: Failed to reload library: %s, %d\n",
560				__func__, fw_lib->name, ret);
561			break;
562		}
563	}
564
565	return ret;
566}
567
568/**
569 * sof_ipc4_update_cpc_from_manifest - Update the cpc in base config from manifest
570 * @sdev: SOF device
571 * @fw_module: pointer struct sof_ipc4_fw_module to parse
572 * @basecfg: Pointer to the base_config to update
573 */
574void sof_ipc4_update_cpc_from_manifest(struct snd_sof_dev *sdev,
575				       struct sof_ipc4_fw_module *fw_module,
576				       struct sof_ipc4_base_module_cfg *basecfg)
577{
578	const struct sof_man4_module_config *fw_mod_cfg;
579	u32 cpc_pick = 0;
580	u32 max_cpc = 0;
581	const char *msg;
582	int i;
583
584	if (!fw_module->fw_mod_cfg) {
585		msg = "No mod_cfg available for CPC lookup in the firmware file's manifest";
586		goto no_cpc;
587	}
588
589	/*
590	 * Find the best matching (highest) CPC value based on the module's
591	 * IBS/OBS configuration inferred from the audio format selection.
592	 *
593	 * The CPC value in each module config entry has been measured and
594	 * recorded as a IBS/OBS/CPC triplet and stored in the firmware file's
595	 * manifest
596	 */
597	fw_mod_cfg = fw_module->fw_mod_cfg;
598	for (i = 0; i < fw_module->man4_module_entry.cfg_count; i++) {
599		if (basecfg->obs == fw_mod_cfg[i].obs &&
600		    basecfg->ibs == fw_mod_cfg[i].ibs &&
601		    cpc_pick < fw_mod_cfg[i].cpc)
602			cpc_pick = fw_mod_cfg[i].cpc;
603
604		if (max_cpc < fw_mod_cfg[i].cpc)
605			max_cpc = fw_mod_cfg[i].cpc;
606	}
607
608	basecfg->cpc = cpc_pick;
609
610	/* We have a matching configuration for CPC */
611	if (basecfg->cpc)
612		return;
613
614	/*
615	 * No matching IBS/OBS found, the firmware manifest is missing
616	 * information in the module's module configuration table.
617	 */
618	if (!max_cpc)
619		msg = "No CPC value available in the firmware file's manifest";
620	else if (!cpc_pick)
621		msg = "No CPC match in the firmware file's manifest";
622
623no_cpc:
624	dev_dbg(sdev->dev, "%s (UUID: %pUL): %s (ibs/obs: %u/%u)\n",
625		fw_module->man4_module_entry.name,
626		&fw_module->man4_module_entry.uuid, msg, basecfg->ibs,
627		basecfg->obs);
628}
629
630const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
631	.validate = sof_ipc4_validate_firmware,
632	.parse_ext_manifest = sof_ipc4_fw_parse_basefw_ext_man,
633};