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
sof_ipc4_fw_parse_ext_man(struct snd_sof_dev * sdev)17 static size_t sof_ipc4_fw_parse_ext_man(struct snd_sof_dev *sdev)
18 {
19 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
20 struct snd_sof_pdata *plat_data = sdev->pdata;
21 struct sof_man4_fw_binary_header *fw_header;
22 const struct firmware *fw = plat_data->fw;
23 struct sof_ext_manifest4_hdr *ext_man_hdr;
24 struct sof_man4_module_config *fm_config;
25 struct sof_ipc4_fw_module *fw_module;
26 struct sof_man4_module *fm_entry;
27 ssize_t remaining;
28 u32 fw_hdr_offset;
29 int i;
30
31 if (!ipc4_data) {
32 dev_err(sdev->dev, "%s: ipc4_data is not available\n", __func__);
33 return -EINVAL;
34 }
35
36 remaining = fw->size;
37 if (remaining <= sizeof(*ext_man_hdr)) {
38 dev_err(sdev->dev, "Firmware size is too small: %zu\n", remaining);
39 return -EINVAL;
40 }
41
42 ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
43
44 /*
45 * At the start of the firmware image we must have an extended manifest.
46 * Verify that the magic number is correct.
47 */
48 if (ext_man_hdr->id != SOF_EXT_MAN4_MAGIC_NUMBER) {
49 dev_err(sdev->dev,
50 "Unexpected extended manifest magic number: %#x\n",
51 ext_man_hdr->id);
52 return -EINVAL;
53 }
54
55 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
56 if (!fw_hdr_offset)
57 return -EINVAL;
58
59 if (remaining <= ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header)) {
60 dev_err(sdev->dev, "Invalid firmware size %zu, should be at least %zu\n",
61 remaining, ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header));
62 return -EINVAL;
63 }
64
65 fw_header = (struct sof_man4_fw_binary_header *)
66 (fw->data + ext_man_hdr->len + fw_hdr_offset);
67 remaining -= (ext_man_hdr->len + fw_hdr_offset);
68
69 if (remaining <= fw_header->len) {
70 dev_err(sdev->dev, "Invalid fw_header->len %u\n", fw_header->len);
71 return -EINVAL;
72 }
73
74 dev_info(sdev->dev, "Loaded firmware version: %u.%u.%u.%u\n",
75 fw_header->major_version, fw_header->minor_version,
76 fw_header->hotfix_version, fw_header->build_version);
77 dev_dbg(sdev->dev, "Firmware name: %s, header length: %u, module count: %u\n",
78 fw_header->name, fw_header->len, fw_header->num_module_entries);
79
80 ipc4_data->fw_modules = devm_kmalloc_array(sdev->dev,
81 fw_header->num_module_entries,
82 sizeof(*fw_module), GFP_KERNEL);
83 if (!ipc4_data->fw_modules)
84 return -ENOMEM;
85
86 ipc4_data->num_fw_modules = fw_header->num_module_entries;
87 fw_module = ipc4_data->fw_modules;
88
89 fm_entry = (struct sof_man4_module *)((u8 *)fw_header + fw_header->len);
90 remaining -= fw_header->len;
91
92 if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {
93 dev_err(sdev->dev, "Invalid num_module_entries %u\n",
94 fw_header->num_module_entries);
95 return -EINVAL;
96 }
97
98 fm_config = (struct sof_man4_module_config *)
99 (fm_entry + fw_header->num_module_entries);
100 remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));
101 for (i = 0; i < fw_header->num_module_entries; i++) {
102 memcpy(&fw_module->man4_module_entry, fm_entry, sizeof(*fm_entry));
103
104 if (fm_entry->cfg_count) {
105 if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *
106 sizeof(*fm_config)) {
107 dev_err(sdev->dev, "Invalid module cfg_offset %u\n",
108 fm_entry->cfg_offset);
109 return -EINVAL;
110 }
111
112 /* a module's config is always the same size */
113 fw_module->bss_size = fm_config[fm_entry->cfg_offset].is_bytes;
114
115 dev_dbg(sdev->dev,
116 "module %s: UUID %pUL cfg_count: %u, bss_size: %#x\n",
117 fm_entry->name, &fm_entry->uuid, fm_entry->cfg_count,
118 fw_module->bss_size);
119 } else {
120 fw_module->bss_size = 0;
121
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(&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
sof_ipc4_validate_firmware(struct snd_sof_dev * sdev)137 static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
138 {
139 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
140 u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
141 struct snd_sof_pdata *plat_data = sdev->pdata;
142 struct sof_man4_fw_binary_header *fw_header;
143 const struct firmware *fw = plat_data->fw;
144 struct sof_ext_manifest4_hdr *ext_man_hdr;
145
146 ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
147 fw_header = (struct sof_man4_fw_binary_header *)
148 (fw->data + ext_man_hdr->len + fw_hdr_offset);
149
150 /* TODO: Add firmware verification code here */
151
152 dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
153 fw_header->major_version, fw_header->minor_version,
154 fw_header->hotfix_version, fw_header->build_version);
155
156 return 0;
157 }
158
sof_ipc4_query_fw_configuration(struct snd_sof_dev * sdev)159 static int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
160 {
161 struct sof_ipc4_fw_data *ipc4_data = sdev->private;
162 const struct sof_ipc_ops *iops = sdev->ipc->ops;
163 struct sof_ipc4_fw_version *fw_ver;
164 struct sof_ipc4_tuple *tuple;
165 struct sof_ipc4_msg msg;
166 size_t offset = 0;
167 int ret;
168
169 /* Get the firmware configuration */
170 msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
171 msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
172 msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
173 msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
174 msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
175
176 msg.data_size = sdev->ipc->max_payload_size;
177 msg.data_ptr = kzalloc(msg.data_size, GFP_KERNEL);
178 if (!msg.data_ptr)
179 return -ENOMEM;
180
181 ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
182 if (ret)
183 goto out;
184
185 while (offset < msg.data_size) {
186 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
187
188 switch (tuple->type) {
189 case SOF_IPC4_FW_CFG_FW_VERSION:
190 fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
191
192 dev_info(sdev->dev,
193 "Booted firmware version: %u.%u.%u.%u\n",
194 fw_ver->major, fw_ver->minor, fw_ver->hotfix,
195 fw_ver->build);
196 break;
197 case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
198 trace_sof_ipc4_fw_config(sdev, "DL mailbox size", *tuple->value);
199 break;
200 case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
201 trace_sof_ipc4_fw_config(sdev, "UL mailbox size", *tuple->value);
202 break;
203 case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
204 trace_sof_ipc4_fw_config(sdev, "Trace log size", *tuple->value);
205 ipc4_data->mtrace_log_bytes = *tuple->value;
206 break;
207 default:
208 break;
209 }
210
211 offset += sizeof(*tuple) + tuple->size;
212 }
213
214 out:
215 kfree(msg.data_ptr);
216
217 return ret;
218 }
219
220 const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
221 .validate = sof_ipc4_validate_firmware,
222 .parse_ext_manifest = sof_ipc4_fw_parse_ext_man,
223 .query_fw_configuration = sof_ipc4_query_fw_configuration,
224 };
225
