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. All rights reserved.
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 fw_lib->modules = devm_kmalloc_array(dev: sdev->dev, n: fw_header->num_module_entries,
84 size: sizeof(*fw_module), GFP_KERNEL);
85 if (!fw_lib->modules)
86 return -ENOMEM;
87
88 fw_lib->name = fw_header->name;
89 fw_lib->num_modules = fw_header->num_module_entries;
90 fw_module = fw_lib->modules;
91
92 fm_entry = (struct sof_man4_module *)((u8 *)fw_header + fw_header->len);
93 remaining -= fw_header->len;
94
95 if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {
96 dev_err(sdev->dev, "Invalid num_module_entries %u\n",
97 fw_header->num_module_entries);
98 return -EINVAL;
99 }
100
101 fm_config = (struct sof_man4_module_config *)
102 (fm_entry + fw_header->num_module_entries);
103 remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));
104 for (i = 0; i < fw_header->num_module_entries; i++) {
105 memcpy(&fw_module->man4_module_entry, fm_entry, sizeof(*fm_entry));
106
107 if (fm_entry->cfg_count) {
108 if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *
109 sizeof(*fm_config)) {
110 dev_err(sdev->dev, "Invalid module cfg_offset %u\n",
111 fm_entry->cfg_offset);
112 return -EINVAL;
113 }
114
115 fw_module->fw_mod_cfg = &fm_config[fm_entry->cfg_offset];
116
117 dev_dbg(sdev->dev,
118 "module %s: UUID %pUL cfg_count: %u, bss_size: %#x\n",
119 fm_entry->name, &fm_entry->uuid, fm_entry->cfg_count,
120 fm_config[fm_entry->cfg_offset].is_bytes);
121 } else {
122 dev_dbg(sdev->dev, "module %s: UUID %pUL\n", fm_entry->name,
123 &fm_entry->uuid);
124 }
125
126 fw_module->man4_module_entry.id = i;
127 ida_init(ida: &fw_module->m_ida);
128 fw_module->private = NULL;
129
130 fw_module++;
131 fm_entry++;
132 }
133
134 return ext_man_hdr->len;
135}
136
137static size_t sof_ipc4_fw_parse_basefw_ext_man(struct snd_sof_dev *sdev)
138{
139 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
140 struct sof_ipc4_fw_library *fw_lib;
141 ssize_t payload_offset;
142 int ret;
143
144 fw_lib = devm_kzalloc(dev: sdev->dev, size: sizeof(*fw_lib), GFP_KERNEL);
145 if (!fw_lib)
146 return -ENOMEM;
147
148 fw_lib->sof_fw.fw = sdev->basefw.fw;
149
150 payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
151 if (payload_offset > 0) {
152 fw_lib->sof_fw.payload_offset = payload_offset;
153
154 /* basefw ID is 0 */
155 fw_lib->id = 0;
156 ret = xa_insert(xa: &ipc4_data->fw_lib_xa, index: 0, entry: fw_lib, GFP_KERNEL);
157 if (ret)
158 return ret;
159 }
160
161 return payload_offset;
162}
163
164static int sof_ipc4_load_library_by_uuid(struct snd_sof_dev *sdev,
165 unsigned long lib_id, const guid_t *uuid)
166{
167 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
168 struct sof_ipc4_fw_library *fw_lib;
169 const char *fw_filename;
170 ssize_t payload_offset;
171 int ret, i, err;
172
173 if (!sdev->pdata->fw_lib_prefix) {
174 dev_err(sdev->dev,
175 "Library loading is not supported due to not set library path\n");
176 return -EINVAL;
177 }
178
179 if (!ipc4_data->load_library) {
180 dev_err(sdev->dev, "Library loading is not supported on this platform\n");
181 return -EOPNOTSUPP;
182 }
183
184 fw_lib = devm_kzalloc(dev: sdev->dev, size: sizeof(*fw_lib), GFP_KERNEL);
185 if (!fw_lib)
186 return -ENOMEM;
187
188 fw_filename = kasprintf(GFP_KERNEL, fmt: "%s/%pUL.bin",
189 sdev->pdata->fw_lib_prefix, uuid);
190 if (!fw_filename) {
191 ret = -ENOMEM;
192 goto free_fw_lib;
193 }
194
195 ret = request_firmware(fw: &fw_lib->sof_fw.fw, name: fw_filename, device: sdev->dev);
196 if (ret < 0) {
197 dev_err(sdev->dev, "Library file '%s' is missing\n", fw_filename);
198 goto free_filename;
199 } else {
200 dev_dbg(sdev->dev, "Library file '%s' loaded\n", fw_filename);
201 }
202
203 payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
204 if (payload_offset <= 0) {
205 if (!payload_offset)
206 ret = -EINVAL;
207 else
208 ret = payload_offset;
209
210 goto release;
211 }
212
213 fw_lib->sof_fw.payload_offset = payload_offset;
214 fw_lib->id = lib_id;
215
216 /* Fix up the module ID numbers within the library */
217 for (i = 0; i < fw_lib->num_modules; i++)
218 fw_lib->modules[i].man4_module_entry.id |= (lib_id << SOF_IPC4_MOD_LIB_ID_SHIFT);
219
220 /*
221 * Make sure that the DSP is booted and stays up while attempting the
222 * loading the library for the first time
223 */
224 ret = pm_runtime_resume_and_get(dev: sdev->dev);
225 if (ret < 0 && ret != -EACCES) {
226 dev_err_ratelimited(sdev->dev, "%s: pm_runtime resume failed: %d\n",
227 __func__, ret);
228 goto release;
229 }
230
231 ret = ipc4_data->load_library(sdev, fw_lib, false);
232
233 pm_runtime_mark_last_busy(dev: sdev->dev);
234 err = pm_runtime_put_autosuspend(dev: sdev->dev);
235 if (err < 0)
236 dev_err_ratelimited(sdev->dev, "%s: pm_runtime idle failed: %d\n",
237 __func__, err);
238
239 if (ret)
240 goto release;
241
242 ret = xa_insert(xa: &ipc4_data->fw_lib_xa, index: lib_id, entry: fw_lib, GFP_KERNEL);
243 if (unlikely(ret))
244 goto release;
245
246 kfree(objp: fw_filename);
247
248 return 0;
249
250release:
251 release_firmware(fw: fw_lib->sof_fw.fw);
252 /* Allocated within sof_ipc4_fw_parse_ext_man() */
253 devm_kfree(dev: sdev->dev, p: fw_lib->modules);
254free_filename:
255 kfree(objp: fw_filename);
256free_fw_lib:
257 devm_kfree(dev: sdev->dev, p: fw_lib);
258
259 return ret;
260}
261
262struct sof_ipc4_fw_module *sof_ipc4_find_module_by_uuid(struct snd_sof_dev *sdev,
263 const guid_t *uuid)
264{
265 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
266 struct sof_ipc4_fw_library *fw_lib;
267 unsigned long lib_id;
268 int i, ret;
269
270 if (guid_is_null(guid: uuid))
271 return NULL;
272
273 xa_for_each(&ipc4_data->fw_lib_xa, lib_id, fw_lib) {
274 for (i = 0; i < fw_lib->num_modules; i++) {
275 if (guid_equal(u1: uuid, u2: &fw_lib->modules[i].man4_module_entry.uuid))
276 return &fw_lib->modules[i];
277 }
278 }
279
280 /*
281 * Do not attempt to load external library in case the maximum number of
282 * firmware libraries have been already loaded
283 */
284 if ((lib_id + 1) == ipc4_data->max_libs_count) {
285 dev_err(sdev->dev,
286 "%s: Maximum allowed number of libraries reached (%u)\n",
287 __func__, ipc4_data->max_libs_count);
288 return NULL;
289 }
290
291 /* The module cannot be found, try to load it as a library */
292 ret = sof_ipc4_load_library_by_uuid(sdev, lib_id: lib_id + 1, uuid);
293 if (ret)
294 return NULL;
295
296 /* Look for the module in the newly loaded library, it should be available now */
297 xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, lib_id) {
298 for (i = 0; i < fw_lib->num_modules; i++) {
299 if (guid_equal(u1: uuid, u2: &fw_lib->modules[i].man4_module_entry.uuid))
300 return &fw_lib->modules[i];
301 }
302 }
303
304 return NULL;
305}
306
307static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
308{
309 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
310 u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
311 struct sof_man4_fw_binary_header *fw_header;
312 const struct firmware *fw = sdev->basefw.fw;
313 struct sof_ext_manifest4_hdr *ext_man_hdr;
314
315 ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
316 fw_header = (struct sof_man4_fw_binary_header *)
317 (fw->data + ext_man_hdr->len + fw_hdr_offset);
318
319 /* TODO: Add firmware verification code here */
320
321 dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
322 fw_header->major_version, fw_header->minor_version,
323 fw_header->hotfix_version, fw_header->build_version);
324
325 return 0;
326}
327
328int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
329{
330 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
331 const struct sof_ipc_ops *iops = sdev->ipc->ops;
332 struct sof_ipc4_fw_version *fw_ver;
333 struct sof_ipc4_tuple *tuple;
334 struct sof_ipc4_msg msg;
335 size_t offset = 0;
336 int ret;
337
338 /* Get the firmware configuration */
339 msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
340 msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
341 msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
342 msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
343 msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
344
345 msg.data_size = sdev->ipc->max_payload_size;
346 msg.data_ptr = kzalloc(size: msg.data_size, GFP_KERNEL);
347 if (!msg.data_ptr)
348 return -ENOMEM;
349
350 ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
351 if (ret)
352 goto out;
353
354 while (offset < msg.data_size) {
355 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
356
357 switch (tuple->type) {
358 case SOF_IPC4_FW_CFG_FW_VERSION:
359 fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
360
361 dev_info(sdev->dev,
362 "Booted firmware version: %u.%u.%u.%u\n",
363 fw_ver->major, fw_ver->minor, fw_ver->hotfix,
364 fw_ver->build);
365 break;
366 case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
367 trace_sof_ipc4_fw_config(sdev, key: "DL mailbox size", value: *tuple->value);
368 break;
369 case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
370 trace_sof_ipc4_fw_config(sdev, key: "UL mailbox size", value: *tuple->value);
371 break;
372 case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
373 trace_sof_ipc4_fw_config(sdev, key: "Trace log size", value: *tuple->value);
374 ipc4_data->mtrace_log_bytes = *tuple->value;
375 break;
376 case SOF_IPC4_FW_CFG_MAX_LIBS_COUNT:
377 trace_sof_ipc4_fw_config(sdev, key: "maximum number of libraries",
378 value: *tuple->value);
379 ipc4_data->max_libs_count = *tuple->value;
380 if (!ipc4_data->max_libs_count)
381 ipc4_data->max_libs_count = 1;
382 break;
383 case SOF_IPC4_FW_CFG_MAX_PPL_COUNT:
384 ipc4_data->max_num_pipelines = *tuple->value;
385 trace_sof_ipc4_fw_config(sdev, key: "Max PPL count %d",
386 value: ipc4_data->max_num_pipelines);
387 if (ipc4_data->max_num_pipelines <= 0) {
388 dev_err(sdev->dev, "Invalid max_num_pipelines %d",
389 ipc4_data->max_num_pipelines);
390 ret = -EINVAL;
391 goto out;
392 }
393 break;
394 case SOF_IPC4_FW_CONTEXT_SAVE:
395 ipc4_data->fw_context_save = *tuple->value;
396 break;
397 default:
398 break;
399 }
400
401 offset += sizeof(*tuple) + tuple->size;
402 }
403
404out:
405 kfree(objp: msg.data_ptr);
406
407 return ret;
408}
409
410int sof_ipc4_reload_fw_libraries(struct snd_sof_dev *sdev)
411{
412 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
413 struct sof_ipc4_fw_library *fw_lib;
414 unsigned long lib_id;
415 int ret = 0;
416
417 xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, 1) {
418 ret = ipc4_data->load_library(sdev, fw_lib, true);
419 if (ret) {
420 dev_err(sdev->dev, "%s: Failed to reload library: %s, %d\n",
421 __func__, fw_lib->name, ret);
422 break;
423 }
424 }
425
426 return ret;
427}
428
429/**
430 * sof_ipc4_update_cpc_from_manifest - Update the cpc in base config from manifest
431 * @sdev: SOF device
432 * @fw_module: pointer struct sof_ipc4_fw_module to parse
433 * @basecfg: Pointer to the base_config to update
434 */
435void sof_ipc4_update_cpc_from_manifest(struct snd_sof_dev *sdev,
436 struct sof_ipc4_fw_module *fw_module,
437 struct sof_ipc4_base_module_cfg *basecfg)
438{
439 const struct sof_man4_module_config *fw_mod_cfg;
440 u32 cpc_pick = 0;
441 u32 max_cpc = 0;
442 const char *msg;
443 int i;
444
445 if (!fw_module->fw_mod_cfg) {
446 msg = "No mod_cfg available for CPC lookup in the firmware file's manifest";
447 goto no_cpc;
448 }
449
450 /*
451 * Find the best matching (highest) CPC value based on the module's
452 * IBS/OBS configuration inferred from the audio format selection.
453 *
454 * The CPC value in each module config entry has been measured and
455 * recorded as a IBS/OBS/CPC triplet and stored in the firmware file's
456 * manifest
457 */
458 fw_mod_cfg = fw_module->fw_mod_cfg;
459 for (i = 0; i < fw_module->man4_module_entry.cfg_count; i++) {
460 if (basecfg->obs == fw_mod_cfg[i].obs &&
461 basecfg->ibs == fw_mod_cfg[i].ibs &&
462 cpc_pick < fw_mod_cfg[i].cpc)
463 cpc_pick = fw_mod_cfg[i].cpc;
464
465 if (max_cpc < fw_mod_cfg[i].cpc)
466 max_cpc = fw_mod_cfg[i].cpc;
467 }
468
469 basecfg->cpc = cpc_pick;
470
471 /* We have a matching configuration for CPC */
472 if (basecfg->cpc)
473 return;
474
475 /*
476 * No matching IBS/OBS found, the firmware manifest is missing
477 * information in the module's module configuration table.
478 */
479 if (!max_cpc)
480 msg = "No CPC value available in the firmware file's manifest";
481 else if (!cpc_pick)
482 msg = "No CPC match in the firmware file's manifest";
483
484no_cpc:
485 dev_dbg(sdev->dev, "%s (UUID: %pUL): %s (ibs/obs: %u/%u)\n",
486 fw_module->man4_module_entry.name,
487 &fw_module->man4_module_entry.uuid, msg, basecfg->ibs,
488 basecfg->obs);
489}
490
491const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
492 .validate = sof_ipc4_validate_firmware,
493 .parse_ext_manifest = sof_ipc4_fw_parse_basefw_ext_man,
494};
495

source code of linux/sound/soc/sof/ipc4-loader.c