Commit | Line | Data |
---|---|---|
d2458baa PU |
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 "sof-priv.h" | |
10 | #include "sof-audio.h" | |
11 | #include "ipc3-priv.h" | |
d2458baa PU |
12 | #include "ops.h" |
13 | ||
14 | static int ipc3_fw_ext_man_get_version(struct snd_sof_dev *sdev, | |
15 | const struct sof_ext_man_elem_header *hdr) | |
16 | { | |
17 | const struct sof_ext_man_fw_version *v = | |
18 | container_of(hdr, struct sof_ext_man_fw_version, hdr); | |
19 | ||
20 | memcpy(&sdev->fw_ready.version, &v->version, sizeof(v->version)); | |
21 | sdev->fw_ready.flags = v->flags; | |
22 | ||
23 | /* log ABI versions and check FW compatibility */ | |
24 | return sof_ipc3_validate_fw_version(sdev); | |
25 | } | |
26 | ||
27 | static int ipc3_fw_ext_man_get_windows(struct snd_sof_dev *sdev, | |
28 | const struct sof_ext_man_elem_header *hdr) | |
29 | { | |
30 | const struct sof_ext_man_window *w; | |
31 | ||
32 | w = container_of(hdr, struct sof_ext_man_window, hdr); | |
33 | ||
34 | return sof_ipc3_get_ext_windows(sdev, &w->ipc_window.ext_hdr); | |
35 | } | |
36 | ||
37 | static int ipc3_fw_ext_man_get_cc_info(struct snd_sof_dev *sdev, | |
38 | const struct sof_ext_man_elem_header *hdr) | |
39 | { | |
40 | const struct sof_ext_man_cc_version *cc; | |
41 | ||
42 | cc = container_of(hdr, struct sof_ext_man_cc_version, hdr); | |
43 | ||
44 | return sof_ipc3_get_cc_info(sdev, &cc->cc_version.ext_hdr); | |
45 | } | |
46 | ||
47 | static int ipc3_fw_ext_man_get_dbg_abi_info(struct snd_sof_dev *sdev, | |
48 | const struct sof_ext_man_elem_header *hdr) | |
49 | { | |
50 | const struct ext_man_dbg_abi *dbg_abi = | |
51 | container_of(hdr, struct ext_man_dbg_abi, hdr); | |
52 | ||
53 | if (sdev->first_boot) | |
54 | dev_dbg(sdev->dev, | |
55 | "Firmware: DBG_ABI %d:%d:%d\n", | |
56 | SOF_ABI_VERSION_MAJOR(dbg_abi->dbg_abi.abi_dbg_version), | |
57 | SOF_ABI_VERSION_MINOR(dbg_abi->dbg_abi.abi_dbg_version), | |
58 | SOF_ABI_VERSION_PATCH(dbg_abi->dbg_abi.abi_dbg_version)); | |
59 | ||
60 | return 0; | |
61 | } | |
62 | ||
63 | static int ipc3_fw_ext_man_get_config_data(struct snd_sof_dev *sdev, | |
64 | const struct sof_ext_man_elem_header *hdr) | |
65 | { | |
66 | const struct sof_ext_man_config_data *config = | |
67 | container_of(hdr, struct sof_ext_man_config_data, hdr); | |
68 | const struct sof_config_elem *elem; | |
69 | int elems_counter; | |
70 | int elems_size; | |
71 | int ret = 0; | |
72 | int i; | |
73 | ||
74 | /* calculate elements counter */ | |
75 | elems_size = config->hdr.size - sizeof(struct sof_ext_man_elem_header); | |
76 | elems_counter = elems_size / sizeof(struct sof_config_elem); | |
77 | ||
e16809a7 | 78 | dev_dbg(sdev->dev, "manifest can hold up to %d config elements\n", elems_counter); |
d2458baa PU |
79 | |
80 | for (i = 0; i < elems_counter; ++i) { | |
81 | elem = &config->elems[i]; | |
e16809a7 PLB |
82 | dev_dbg(sdev->dev, "get index %d token %d val %d\n", |
83 | i, elem->token, elem->value); | |
d2458baa PU |
84 | switch (elem->token) { |
85 | case SOF_EXT_MAN_CONFIG_EMPTY: | |
86 | /* unused memory space is zero filled - mapped to EMPTY elements */ | |
87 | break; | |
88 | case SOF_EXT_MAN_CONFIG_IPC_MSG_SIZE: | |
89 | /* TODO: use ipc msg size from config data */ | |
90 | break; | |
91 | case SOF_EXT_MAN_CONFIG_MEMORY_USAGE_SCAN: | |
92 | if (sdev->first_boot && elem->value) | |
93 | ret = snd_sof_dbg_memory_info_init(sdev); | |
94 | break; | |
95 | default: | |
96 | dev_info(sdev->dev, | |
97 | "Unknown firmware configuration token %d value %d", | |
98 | elem->token, elem->value); | |
99 | break; | |
100 | } | |
101 | if (ret < 0) { | |
102 | dev_err(sdev->dev, | |
103 | "%s: processing failed for token %d value %#x, %d\n", | |
104 | __func__, elem->token, elem->value, ret); | |
105 | return ret; | |
106 | } | |
107 | } | |
108 | ||
109 | return 0; | |
110 | } | |
111 | ||
b9cb044f | 112 | static ssize_t ipc3_fw_ext_man_size(struct snd_sof_dev *sdev, const struct firmware *fw) |
d2458baa PU |
113 | { |
114 | const struct sof_ext_man_header *head; | |
115 | ||
116 | head = (struct sof_ext_man_header *)fw->data; | |
117 | ||
118 | /* | |
119 | * assert fw size is big enough to contain extended manifest header, | |
120 | * it prevents from reading unallocated memory from `head` in following | |
121 | * step. | |
122 | */ | |
123 | if (fw->size < sizeof(*head)) | |
124 | return -EINVAL; | |
125 | ||
126 | /* | |
127 | * When fw points to extended manifest, | |
128 | * then first u32 must be equal SOF_EXT_MAN_MAGIC_NUMBER. | |
129 | */ | |
130 | if (head->magic == SOF_EXT_MAN_MAGIC_NUMBER) | |
131 | return head->full_size; | |
132 | ||
133 | /* otherwise given fw don't have an extended manifest */ | |
b9cb044f PU |
134 | dev_dbg(sdev->dev, "Unexpected extended manifest magic number: %#x\n", |
135 | head->magic); | |
d2458baa PU |
136 | return 0; |
137 | } | |
138 | ||
139 | static size_t sof_ipc3_fw_parse_ext_man(struct snd_sof_dev *sdev) | |
140 | { | |
4f373ccf | 141 | const struct firmware *fw = sdev->basefw.fw; |
d2458baa PU |
142 | const struct sof_ext_man_elem_header *elem_hdr; |
143 | const struct sof_ext_man_header *head; | |
144 | ssize_t ext_man_size; | |
145 | ssize_t remaining; | |
146 | uintptr_t iptr; | |
147 | int ret = 0; | |
148 | ||
149 | head = (struct sof_ext_man_header *)fw->data; | |
150 | remaining = head->full_size - head->header_size; | |
b9cb044f | 151 | ext_man_size = ipc3_fw_ext_man_size(sdev, fw); |
d2458baa PU |
152 | |
153 | /* Assert firmware starts with extended manifest */ | |
154 | if (ext_man_size <= 0) | |
155 | return ext_man_size; | |
156 | ||
157 | /* incompatible version */ | |
158 | if (SOF_EXT_MAN_VERSION_INCOMPATIBLE(SOF_EXT_MAN_VERSION, | |
159 | head->header_version)) { | |
160 | dev_err(sdev->dev, | |
161 | "extended manifest version %#x differ from used %#x\n", | |
162 | head->header_version, SOF_EXT_MAN_VERSION); | |
163 | return -EINVAL; | |
164 | } | |
165 | ||
166 | /* get first extended manifest element header */ | |
167 | iptr = (uintptr_t)fw->data + head->header_size; | |
168 | ||
169 | while (remaining > sizeof(*elem_hdr)) { | |
170 | elem_hdr = (struct sof_ext_man_elem_header *)iptr; | |
171 | ||
172 | dev_dbg(sdev->dev, "found sof_ext_man header type %d size %#x\n", | |
173 | elem_hdr->type, elem_hdr->size); | |
174 | ||
175 | if (elem_hdr->size < sizeof(*elem_hdr) || | |
176 | elem_hdr->size > remaining) { | |
177 | dev_err(sdev->dev, | |
178 | "invalid sof_ext_man header size, type %d size %#x\n", | |
179 | elem_hdr->type, elem_hdr->size); | |
180 | return -EINVAL; | |
181 | } | |
182 | ||
183 | /* process structure data */ | |
184 | switch (elem_hdr->type) { | |
185 | case SOF_EXT_MAN_ELEM_FW_VERSION: | |
186 | ret = ipc3_fw_ext_man_get_version(sdev, elem_hdr); | |
187 | break; | |
188 | case SOF_EXT_MAN_ELEM_WINDOW: | |
189 | ret = ipc3_fw_ext_man_get_windows(sdev, elem_hdr); | |
190 | break; | |
191 | case SOF_EXT_MAN_ELEM_CC_VERSION: | |
192 | ret = ipc3_fw_ext_man_get_cc_info(sdev, elem_hdr); | |
193 | break; | |
194 | case SOF_EXT_MAN_ELEM_DBG_ABI: | |
195 | ret = ipc3_fw_ext_man_get_dbg_abi_info(sdev, elem_hdr); | |
196 | break; | |
197 | case SOF_EXT_MAN_ELEM_CONFIG_DATA: | |
198 | ret = ipc3_fw_ext_man_get_config_data(sdev, elem_hdr); | |
199 | break; | |
200 | case SOF_EXT_MAN_ELEM_PLATFORM_CONFIG_DATA: | |
201 | ret = snd_sof_dsp_parse_platform_ext_manifest(sdev, elem_hdr); | |
202 | break; | |
203 | default: | |
204 | dev_info(sdev->dev, | |
205 | "unknown sof_ext_man header type %d size %#x\n", | |
206 | elem_hdr->type, elem_hdr->size); | |
207 | break; | |
208 | } | |
209 | ||
210 | if (ret < 0) { | |
211 | dev_err(sdev->dev, | |
212 | "failed to parse sof_ext_man header type %d size %#x\n", | |
213 | elem_hdr->type, elem_hdr->size); | |
214 | return ret; | |
215 | } | |
216 | ||
217 | remaining -= elem_hdr->size; | |
218 | iptr += elem_hdr->size; | |
219 | } | |
220 | ||
221 | if (remaining) { | |
222 | dev_err(sdev->dev, "error: sof_ext_man header is inconsistent\n"); | |
223 | return -EINVAL; | |
224 | } | |
225 | ||
226 | return ext_man_size; | |
227 | } | |
228 | ||
229 | /* generic module parser for mmaped DSPs */ | |
230 | static int sof_ipc3_parse_module_memcpy(struct snd_sof_dev *sdev, | |
231 | struct snd_sof_mod_hdr *module) | |
232 | { | |
233 | struct snd_sof_blk_hdr *block; | |
234 | int count, ret; | |
235 | u32 offset; | |
236 | size_t remaining; | |
237 | ||
238 | dev_dbg(sdev->dev, "new module size %#x blocks %#x type %#x\n", | |
239 | module->size, module->num_blocks, module->type); | |
240 | ||
241 | block = (struct snd_sof_blk_hdr *)((u8 *)module + sizeof(*module)); | |
242 | ||
243 | /* module->size doesn't include header size */ | |
244 | remaining = module->size; | |
245 | for (count = 0; count < module->num_blocks; count++) { | |
246 | /* check for wrap */ | |
247 | if (remaining < sizeof(*block)) { | |
248 | dev_err(sdev->dev, "not enough data remaining\n"); | |
249 | return -EINVAL; | |
250 | } | |
251 | ||
252 | /* minus header size of block */ | |
253 | remaining -= sizeof(*block); | |
254 | ||
255 | if (block->size == 0) { | |
256 | dev_warn(sdev->dev, | |
257 | "warning: block %d size zero\n", count); | |
258 | dev_warn(sdev->dev, " type %#x offset %#x\n", | |
259 | block->type, block->offset); | |
260 | continue; | |
261 | } | |
262 | ||
263 | switch (block->type) { | |
264 | case SOF_FW_BLK_TYPE_RSRVD0: | |
265 | case SOF_FW_BLK_TYPE_ROM...SOF_FW_BLK_TYPE_RSRVD14: | |
266 | continue; /* not handled atm */ | |
267 | case SOF_FW_BLK_TYPE_IRAM: | |
268 | case SOF_FW_BLK_TYPE_DRAM: | |
269 | case SOF_FW_BLK_TYPE_SRAM: | |
270 | offset = block->offset; | |
271 | break; | |
272 | default: | |
273 | dev_err(sdev->dev, "%s: bad type %#x for block %#x\n", | |
274 | __func__, block->type, count); | |
275 | return -EINVAL; | |
276 | } | |
277 | ||
278 | dev_dbg(sdev->dev, "block %d type %#x size %#x ==> offset %#x\n", | |
279 | count, block->type, block->size, offset); | |
280 | ||
281 | /* checking block->size to avoid unaligned access */ | |
282 | if (block->size % sizeof(u32)) { | |
283 | dev_err(sdev->dev, "%s: invalid block size %#x\n", | |
284 | __func__, block->size); | |
285 | return -EINVAL; | |
286 | } | |
287 | ret = snd_sof_dsp_block_write(sdev, block->type, offset, | |
288 | block + 1, block->size); | |
289 | if (ret < 0) { | |
290 | dev_err(sdev->dev, "%s: write to block type %#x failed\n", | |
291 | __func__, block->type); | |
292 | return ret; | |
293 | } | |
294 | ||
295 | if (remaining < block->size) { | |
296 | dev_err(sdev->dev, "%s: not enough data remaining\n", __func__); | |
297 | return -EINVAL; | |
298 | } | |
299 | ||
300 | /* minus body size of block */ | |
301 | remaining -= block->size; | |
302 | /* next block */ | |
303 | block = (struct snd_sof_blk_hdr *)((u8 *)block + sizeof(*block) | |
304 | + block->size); | |
305 | } | |
306 | ||
307 | return 0; | |
308 | } | |
309 | ||
310 | static int sof_ipc3_load_fw_to_dsp(struct snd_sof_dev *sdev) | |
311 | { | |
4f373ccf PU |
312 | u32 payload_offset = sdev->basefw.payload_offset; |
313 | const struct firmware *fw = sdev->basefw.fw; | |
d2458baa PU |
314 | struct snd_sof_fw_header *header; |
315 | struct snd_sof_mod_hdr *module; | |
316 | int (*load_module)(struct snd_sof_dev *sof_dev, struct snd_sof_mod_hdr *hdr); | |
317 | size_t remaining; | |
318 | int ret, count; | |
319 | ||
4f373ccf | 320 | if (!fw) |
d2458baa PU |
321 | return -EINVAL; |
322 | ||
4f373ccf | 323 | header = (struct snd_sof_fw_header *)(fw->data + payload_offset); |
d2458baa PU |
324 | load_module = sof_ops(sdev)->load_module; |
325 | if (!load_module) { | |
e16809a7 | 326 | dev_dbg(sdev->dev, "Using generic module loading\n"); |
d2458baa PU |
327 | load_module = sof_ipc3_parse_module_memcpy; |
328 | } else { | |
e16809a7 | 329 | dev_dbg(sdev->dev, "Using custom module loading\n"); |
d2458baa PU |
330 | } |
331 | ||
332 | /* parse each module */ | |
4f373ccf PU |
333 | module = (struct snd_sof_mod_hdr *)(fw->data + payload_offset + sizeof(*header)); |
334 | remaining = fw->size - sizeof(*header) - payload_offset; | |
d2458baa PU |
335 | /* check for wrap */ |
336 | if (remaining > fw->size) { | |
337 | dev_err(sdev->dev, "%s: fw size smaller than header size\n", __func__); | |
338 | return -EINVAL; | |
339 | } | |
340 | ||
341 | for (count = 0; count < header->num_modules; count++) { | |
342 | /* check for wrap */ | |
343 | if (remaining < sizeof(*module)) { | |
344 | dev_err(sdev->dev, "%s: not enough data for a module\n", | |
345 | __func__); | |
346 | return -EINVAL; | |
347 | } | |
348 | ||
349 | /* minus header size of module */ | |
350 | remaining -= sizeof(*module); | |
351 | ||
352 | /* module */ | |
353 | ret = load_module(sdev, module); | |
354 | if (ret < 0) { | |
355 | dev_err(sdev->dev, "%s: invalid module %d\n", __func__, count); | |
356 | return ret; | |
357 | } | |
358 | ||
359 | if (remaining < module->size) { | |
360 | dev_err(sdev->dev, "%s: not enough data remaining\n", __func__); | |
361 | return -EINVAL; | |
362 | } | |
363 | ||
364 | /* minus body size of module */ | |
365 | remaining -= module->size; | |
366 | module = (struct snd_sof_mod_hdr *)((u8 *)module + | |
367 | sizeof(*module) + module->size); | |
368 | } | |
369 | ||
370 | return 0; | |
371 | } | |
372 | ||
373 | static int sof_ipc3_validate_firmware(struct snd_sof_dev *sdev) | |
374 | { | |
4f373ccf PU |
375 | u32 payload_offset = sdev->basefw.payload_offset; |
376 | const struct firmware *fw = sdev->basefw.fw; | |
d2458baa | 377 | struct snd_sof_fw_header *header; |
4f373ccf | 378 | size_t fw_size = fw->size - payload_offset; |
d2458baa | 379 | |
4f373ccf | 380 | if (fw->size <= payload_offset) { |
d2458baa PU |
381 | dev_err(sdev->dev, |
382 | "firmware size must be greater than firmware offset\n"); | |
383 | return -EINVAL; | |
384 | } | |
385 | ||
386 | /* Read the header information from the data pointer */ | |
4f373ccf | 387 | header = (struct snd_sof_fw_header *)(fw->data + payload_offset); |
d2458baa PU |
388 | |
389 | /* verify FW sig */ | |
390 | if (strncmp(header->sig, SND_SOF_FW_SIG, SND_SOF_FW_SIG_SIZE) != 0) { | |
391 | dev_err(sdev->dev, "invalid firmware signature\n"); | |
392 | return -EINVAL; | |
393 | } | |
394 | ||
395 | /* check size is valid */ | |
396 | if (fw_size != header->file_size + sizeof(*header)) { | |
397 | dev_err(sdev->dev, | |
398 | "invalid filesize mismatch got 0x%zx expected 0x%zx\n", | |
399 | fw_size, header->file_size + sizeof(*header)); | |
400 | return -EINVAL; | |
401 | } | |
402 | ||
403 | dev_dbg(sdev->dev, "header size=0x%x modules=0x%x abi=0x%x size=%zu\n", | |
404 | header->file_size, header->num_modules, | |
405 | header->abi, sizeof(*header)); | |
406 | ||
407 | return 0; | |
408 | } | |
409 | ||
410 | const struct sof_ipc_fw_loader_ops ipc3_loader_ops = { | |
411 | .validate = sof_ipc3_validate_firmware, | |
412 | .parse_ext_manifest = sof_ipc3_fw_parse_ext_man, | |
413 | .load_fw_to_dsp = sof_ipc3_load_fw_to_dsp, | |
414 | }; |