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) 2018 Intel Corporation. All rights reserved. 7 // 8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com> 9 // 10 // Generic firmware loader. 11 // 12 13 #include <linux/firmware.h> 14 #include <sound/sof.h> 15 #include <sound/sof/ext_manifest.h> 16 #include "ops.h" 17 18 static int get_ext_windows(struct snd_sof_dev *sdev, 19 const struct sof_ipc_ext_data_hdr *ext_hdr) 20 { 21 const struct sof_ipc_window *w = 22 container_of(ext_hdr, struct sof_ipc_window, ext_hdr); 23 24 if (w->num_windows == 0 || w->num_windows > SOF_IPC_MAX_ELEMS) 25 return -EINVAL; 26 27 if (sdev->info_window) { 28 if (memcmp(sdev->info_window, w, ext_hdr->hdr.size)) { 29 dev_err(sdev->dev, "error: mismatch between window descriptor from extended manifest and mailbox"); 30 return -EINVAL; 31 } 32 return 0; 33 } 34 35 /* keep a local copy of the data */ 36 sdev->info_window = devm_kmemdup(sdev->dev, w, ext_hdr->hdr.size, 37 GFP_KERNEL); 38 if (!sdev->info_window) 39 return -ENOMEM; 40 41 return 0; 42 } 43 44 static int get_cc_info(struct snd_sof_dev *sdev, 45 const struct sof_ipc_ext_data_hdr *ext_hdr) 46 { 47 int ret; 48 49 const struct sof_ipc_cc_version *cc = 50 container_of(ext_hdr, struct sof_ipc_cc_version, ext_hdr); 51 52 if (sdev->cc_version) { 53 if (memcmp(sdev->cc_version, cc, cc->ext_hdr.hdr.size)) { 54 dev_err(sdev->dev, "error: receive diverged cc_version descriptions"); 55 return -EINVAL; 56 } 57 return 0; 58 } 59 60 dev_dbg(sdev->dev, "Firmware info: used compiler %s %d:%d:%d%s used optimization flags %s\n", 61 cc->name, cc->major, cc->minor, cc->micro, cc->desc, 62 cc->optim); 63 64 /* create read-only cc_version debugfs to store compiler version info */ 65 /* use local copy of the cc_version to prevent data corruption */ 66 if (sdev->first_boot) { 67 sdev->cc_version = devm_kmalloc(sdev->dev, cc->ext_hdr.hdr.size, 68 GFP_KERNEL); 69 70 if (!sdev->cc_version) 71 return -ENOMEM; 72 73 memcpy(sdev->cc_version, cc, cc->ext_hdr.hdr.size); 74 ret = snd_sof_debugfs_buf_item(sdev, sdev->cc_version, 75 cc->ext_hdr.hdr.size, 76 "cc_version", 0444); 77 78 /* errors are only due to memory allocation, not debugfs */ 79 if (ret < 0) { 80 dev_err(sdev->dev, "error: snd_sof_debugfs_buf_item failed\n"); 81 return ret; 82 } 83 } 84 85 return 0; 86 } 87 88 /* parse the extended FW boot data structures from FW boot message */ 89 int snd_sof_fw_parse_ext_data(struct snd_sof_dev *sdev, u32 bar, u32 offset) 90 { 91 struct sof_ipc_ext_data_hdr *ext_hdr; 92 void *ext_data; 93 int ret = 0; 94 95 ext_data = kzalloc(PAGE_SIZE, GFP_KERNEL); 96 if (!ext_data) 97 return -ENOMEM; 98 99 /* get first header */ 100 snd_sof_dsp_block_read(sdev, bar, offset, ext_data, 101 sizeof(*ext_hdr)); 102 ext_hdr = ext_data; 103 104 while (ext_hdr->hdr.cmd == SOF_IPC_FW_READY) { 105 /* read in ext structure */ 106 snd_sof_dsp_block_read(sdev, bar, offset + sizeof(*ext_hdr), 107 (void *)((u8 *)ext_data + sizeof(*ext_hdr)), 108 ext_hdr->hdr.size - sizeof(*ext_hdr)); 109 110 dev_dbg(sdev->dev, "found ext header type %d size 0x%x\n", 111 ext_hdr->type, ext_hdr->hdr.size); 112 113 /* process structure data */ 114 switch (ext_hdr->type) { 115 case SOF_IPC_EXT_WINDOW: 116 ret = get_ext_windows(sdev, ext_hdr); 117 break; 118 case SOF_IPC_EXT_CC_INFO: 119 ret = get_cc_info(sdev, ext_hdr); 120 break; 121 case SOF_IPC_EXT_UNUSED: 122 case SOF_IPC_EXT_PROBE_INFO: 123 case SOF_IPC_EXT_USER_ABI_INFO: 124 /* They are supported but we don't do anything here */ 125 break; 126 default: 127 dev_info(sdev->dev, "unknown ext header type %d size 0x%x\n", 128 ext_hdr->type, ext_hdr->hdr.size); 129 ret = 0; 130 break; 131 } 132 133 if (ret < 0) { 134 dev_err(sdev->dev, "error: failed to parse ext data type %d\n", 135 ext_hdr->type); 136 break; 137 } 138 139 /* move to next header */ 140 offset += ext_hdr->hdr.size; 141 snd_sof_dsp_block_read(sdev, bar, offset, ext_data, 142 sizeof(*ext_hdr)); 143 ext_hdr = ext_data; 144 } 145 146 kfree(ext_data); 147 return ret; 148 } 149 EXPORT_SYMBOL(snd_sof_fw_parse_ext_data); 150 151 static int ext_man_get_fw_version(struct snd_sof_dev *sdev, 152 const struct sof_ext_man_elem_header *hdr) 153 { 154 const struct sof_ext_man_fw_version *v = 155 container_of(hdr, struct sof_ext_man_fw_version, hdr); 156 157 memcpy(&sdev->fw_ready.version, &v->version, sizeof(v->version)); 158 sdev->fw_ready.flags = v->flags; 159 160 /* log ABI versions and check FW compatibility */ 161 return snd_sof_ipc_valid(sdev); 162 } 163 164 static int ext_man_get_windows(struct snd_sof_dev *sdev, 165 const struct sof_ext_man_elem_header *hdr) 166 { 167 const struct sof_ext_man_window *w; 168 169 w = container_of(hdr, struct sof_ext_man_window, hdr); 170 171 return get_ext_windows(sdev, &w->ipc_window.ext_hdr); 172 } 173 174 static int ext_man_get_cc_info(struct snd_sof_dev *sdev, 175 const struct sof_ext_man_elem_header *hdr) 176 { 177 const struct sof_ext_man_cc_version *cc; 178 179 cc = container_of(hdr, struct sof_ext_man_cc_version, hdr); 180 181 return get_cc_info(sdev, &cc->cc_version.ext_hdr); 182 } 183 184 static int ext_man_get_dbg_abi_info(struct snd_sof_dev *sdev, 185 const struct sof_ext_man_elem_header *hdr) 186 { 187 const struct ext_man_dbg_abi *dbg_abi = 188 container_of(hdr, struct ext_man_dbg_abi, hdr); 189 190 if (sdev->first_boot) 191 dev_dbg(sdev->dev, 192 "Firmware: DBG_ABI %d:%d:%d\n", 193 SOF_ABI_VERSION_MAJOR(dbg_abi->dbg_abi.abi_dbg_version), 194 SOF_ABI_VERSION_MINOR(dbg_abi->dbg_abi.abi_dbg_version), 195 SOF_ABI_VERSION_PATCH(dbg_abi->dbg_abi.abi_dbg_version)); 196 197 return 0; 198 } 199 200 static int ext_man_get_config_data(struct snd_sof_dev *sdev, 201 const struct sof_ext_man_elem_header *hdr) 202 { 203 const struct sof_ext_man_config_data *config = 204 container_of(hdr, struct sof_ext_man_config_data, hdr); 205 const struct sof_config_elem *elem; 206 int elems_counter; 207 int elems_size; 208 int ret = 0; 209 int i; 210 211 /* calculate elements counter */ 212 elems_size = config->hdr.size - sizeof(struct sof_ext_man_elem_header); 213 elems_counter = elems_size / sizeof(struct sof_config_elem); 214 215 dev_dbg(sdev->dev, "%s can hold up to %d config elements\n", 216 __func__, elems_counter); 217 218 for (i = 0; i < elems_counter; ++i) { 219 elem = &config->elems[i]; 220 dev_dbg(sdev->dev, "%s get index %d token %d val %d\n", 221 __func__, i, elem->token, elem->value); 222 switch (elem->token) { 223 case SOF_EXT_MAN_CONFIG_EMPTY: 224 /* unused memory space is zero filled - mapped to EMPTY elements */ 225 break; 226 case SOF_EXT_MAN_CONFIG_IPC_MSG_SIZE: 227 /* TODO: use ipc msg size from config data */ 228 break; 229 case SOF_EXT_MAN_CONFIG_MEMORY_USAGE_SCAN: 230 if (sdev->first_boot && elem->value) 231 ret = snd_sof_dbg_memory_info_init(sdev); 232 break; 233 default: 234 dev_info(sdev->dev, "Unknown firmware configuration token %d value %d", 235 elem->token, elem->value); 236 break; 237 } 238 if (ret < 0) { 239 dev_err(sdev->dev, "error: processing sof_ext_man_config_data failed for token %d value 0x%x, %d\n", 240 elem->token, elem->value, ret); 241 return ret; 242 } 243 } 244 245 return 0; 246 } 247 248 static ssize_t snd_sof_ext_man_size(const struct firmware *fw) 249 { 250 const struct sof_ext_man_header *head; 251 252 head = (struct sof_ext_man_header *)fw->data; 253 254 /* 255 * assert fw size is big enough to contain extended manifest header, 256 * it prevents from reading unallocated memory from `head` in following 257 * step. 258 */ 259 if (fw->size < sizeof(*head)) 260 return -EINVAL; 261 262 /* 263 * When fw points to extended manifest, 264 * then first u32 must be equal SOF_EXT_MAN_MAGIC_NUMBER. 265 */ 266 if (head->magic == SOF_EXT_MAN_MAGIC_NUMBER) 267 return head->full_size; 268 269 /* otherwise given fw don't have an extended manifest */ 270 return 0; 271 } 272 273 /* parse extended FW manifest data structures */ 274 static int snd_sof_fw_ext_man_parse(struct snd_sof_dev *sdev, 275 const struct firmware *fw) 276 { 277 const struct sof_ext_man_elem_header *elem_hdr; 278 const struct sof_ext_man_header *head; 279 ssize_t ext_man_size; 280 ssize_t remaining; 281 uintptr_t iptr; 282 int ret = 0; 283 284 head = (struct sof_ext_man_header *)fw->data; 285 remaining = head->full_size - head->header_size; 286 ext_man_size = snd_sof_ext_man_size(fw); 287 288 /* Assert firmware starts with extended manifest */ 289 if (ext_man_size <= 0) 290 return ext_man_size; 291 292 /* incompatible version */ 293 if (SOF_EXT_MAN_VERSION_INCOMPATIBLE(SOF_EXT_MAN_VERSION, 294 head->header_version)) { 295 dev_err(sdev->dev, "error: extended manifest version 0x%X differ from used 0x%X\n", 296 head->header_version, SOF_EXT_MAN_VERSION); 297 return -EINVAL; 298 } 299 300 /* get first extended manifest element header */ 301 iptr = (uintptr_t)fw->data + head->header_size; 302 303 while (remaining > sizeof(*elem_hdr)) { 304 elem_hdr = (struct sof_ext_man_elem_header *)iptr; 305 306 dev_dbg(sdev->dev, "found sof_ext_man header type %d size 0x%X\n", 307 elem_hdr->type, elem_hdr->size); 308 309 if (elem_hdr->size < sizeof(*elem_hdr) || 310 elem_hdr->size > remaining) { 311 dev_err(sdev->dev, "error: invalid sof_ext_man header size, type %d size 0x%X\n", 312 elem_hdr->type, elem_hdr->size); 313 return -EINVAL; 314 } 315 316 /* process structure data */ 317 switch (elem_hdr->type) { 318 case SOF_EXT_MAN_ELEM_FW_VERSION: 319 ret = ext_man_get_fw_version(sdev, elem_hdr); 320 break; 321 case SOF_EXT_MAN_ELEM_WINDOW: 322 ret = ext_man_get_windows(sdev, elem_hdr); 323 break; 324 case SOF_EXT_MAN_ELEM_CC_VERSION: 325 ret = ext_man_get_cc_info(sdev, elem_hdr); 326 break; 327 case SOF_EXT_MAN_ELEM_DBG_ABI: 328 ret = ext_man_get_dbg_abi_info(sdev, elem_hdr); 329 break; 330 case SOF_EXT_MAN_ELEM_CONFIG_DATA: 331 ret = ext_man_get_config_data(sdev, elem_hdr); 332 break; 333 case SOF_EXT_MAN_ELEM_PLATFORM_CONFIG_DATA: 334 ret = snd_sof_dsp_parse_platform_ext_manifest(sdev, elem_hdr); 335 break; 336 default: 337 dev_info(sdev->dev, "unknown sof_ext_man header type %d size 0x%X\n", 338 elem_hdr->type, elem_hdr->size); 339 break; 340 } 341 342 if (ret < 0) { 343 dev_err(sdev->dev, "error: failed to parse sof_ext_man header type %d size 0x%X\n", 344 elem_hdr->type, elem_hdr->size); 345 return ret; 346 } 347 348 remaining -= elem_hdr->size; 349 iptr += elem_hdr->size; 350 } 351 352 if (remaining) { 353 dev_err(sdev->dev, "error: sof_ext_man header is inconsistent\n"); 354 return -EINVAL; 355 } 356 357 return ext_man_size; 358 } 359 360 /* 361 * IPC Firmware ready. 362 */ 363 static void sof_get_windows(struct snd_sof_dev *sdev) 364 { 365 struct sof_ipc_window_elem *elem; 366 u32 outbox_offset = 0; 367 u32 stream_offset = 0; 368 u32 inbox_offset = 0; 369 u32 outbox_size = 0; 370 u32 stream_size = 0; 371 u32 inbox_size = 0; 372 u32 debug_size = 0; 373 u32 debug_offset = 0; 374 int window_offset; 375 int bar; 376 int i; 377 378 if (!sdev->info_window) { 379 dev_err(sdev->dev, "error: have no window info\n"); 380 return; 381 } 382 383 bar = snd_sof_dsp_get_bar_index(sdev, SOF_FW_BLK_TYPE_SRAM); 384 if (bar < 0) { 385 dev_err(sdev->dev, "error: have no bar mapping\n"); 386 return; 387 } 388 389 for (i = 0; i < sdev->info_window->num_windows; i++) { 390 elem = &sdev->info_window->window[i]; 391 392 window_offset = snd_sof_dsp_get_window_offset(sdev, elem->id); 393 if (window_offset < 0) { 394 dev_warn(sdev->dev, "warn: no offset for window %d\n", 395 elem->id); 396 continue; 397 } 398 399 switch (elem->type) { 400 case SOF_IPC_REGION_UPBOX: 401 inbox_offset = window_offset + elem->offset; 402 inbox_size = elem->size; 403 snd_sof_debugfs_io_item(sdev, 404 sdev->bar[bar] + 405 inbox_offset, 406 elem->size, "inbox", 407 SOF_DEBUGFS_ACCESS_D0_ONLY); 408 break; 409 case SOF_IPC_REGION_DOWNBOX: 410 outbox_offset = window_offset + elem->offset; 411 outbox_size = elem->size; 412 snd_sof_debugfs_io_item(sdev, 413 sdev->bar[bar] + 414 outbox_offset, 415 elem->size, "outbox", 416 SOF_DEBUGFS_ACCESS_D0_ONLY); 417 break; 418 case SOF_IPC_REGION_TRACE: 419 snd_sof_debugfs_io_item(sdev, 420 sdev->bar[bar] + 421 window_offset + 422 elem->offset, 423 elem->size, "etrace", 424 SOF_DEBUGFS_ACCESS_D0_ONLY); 425 break; 426 case SOF_IPC_REGION_DEBUG: 427 debug_offset = window_offset + elem->offset; 428 debug_size = elem->size; 429 snd_sof_debugfs_io_item(sdev, 430 sdev->bar[bar] + 431 window_offset + 432 elem->offset, 433 elem->size, "debug", 434 SOF_DEBUGFS_ACCESS_D0_ONLY); 435 break; 436 case SOF_IPC_REGION_STREAM: 437 stream_offset = window_offset + elem->offset; 438 stream_size = elem->size; 439 snd_sof_debugfs_io_item(sdev, 440 sdev->bar[bar] + 441 stream_offset, 442 elem->size, "stream", 443 SOF_DEBUGFS_ACCESS_D0_ONLY); 444 break; 445 case SOF_IPC_REGION_REGS: 446 snd_sof_debugfs_io_item(sdev, 447 sdev->bar[bar] + 448 window_offset + 449 elem->offset, 450 elem->size, "regs", 451 SOF_DEBUGFS_ACCESS_D0_ONLY); 452 break; 453 case SOF_IPC_REGION_EXCEPTION: 454 sdev->dsp_oops_offset = window_offset + elem->offset; 455 snd_sof_debugfs_io_item(sdev, 456 sdev->bar[bar] + 457 window_offset + 458 elem->offset, 459 elem->size, "exception", 460 SOF_DEBUGFS_ACCESS_D0_ONLY); 461 break; 462 default: 463 dev_err(sdev->dev, "error: get illegal window info\n"); 464 return; 465 } 466 } 467 468 if (outbox_size == 0 || inbox_size == 0) { 469 dev_err(sdev->dev, "error: get illegal mailbox window\n"); 470 return; 471 } 472 473 snd_sof_dsp_mailbox_init(sdev, inbox_offset, inbox_size, 474 outbox_offset, outbox_size); 475 sdev->stream_box.offset = stream_offset; 476 sdev->stream_box.size = stream_size; 477 478 sdev->debug_box.offset = debug_offset; 479 sdev->debug_box.size = debug_size; 480 481 dev_dbg(sdev->dev, " mailbox upstream 0x%x - size 0x%x\n", 482 inbox_offset, inbox_size); 483 dev_dbg(sdev->dev, " mailbox downstream 0x%x - size 0x%x\n", 484 outbox_offset, outbox_size); 485 dev_dbg(sdev->dev, " stream region 0x%x - size 0x%x\n", 486 stream_offset, stream_size); 487 dev_dbg(sdev->dev, " debug region 0x%x - size 0x%x\n", 488 debug_offset, debug_size); 489 } 490 491 /* check for ABI compatibility and create memory windows on first boot */ 492 int sof_fw_ready(struct snd_sof_dev *sdev, u32 msg_id) 493 { 494 struct sof_ipc_fw_ready *fw_ready = &sdev->fw_ready; 495 int offset; 496 int bar; 497 int ret; 498 499 /* mailbox must be on 4k boundary */ 500 offset = snd_sof_dsp_get_mailbox_offset(sdev); 501 if (offset < 0) { 502 dev_err(sdev->dev, "error: have no mailbox offset\n"); 503 return offset; 504 } 505 506 bar = snd_sof_dsp_get_bar_index(sdev, SOF_FW_BLK_TYPE_SRAM); 507 if (bar < 0) { 508 dev_err(sdev->dev, "error: have no bar mapping\n"); 509 return -EINVAL; 510 } 511 512 dev_dbg(sdev->dev, "ipc: DSP is ready 0x%8.8x offset 0x%x\n", 513 msg_id, offset); 514 515 /* no need to re-check version/ABI for subsequent boots */ 516 if (!sdev->first_boot) 517 return 0; 518 519 /* copy data from the DSP FW ready offset */ 520 snd_sof_dsp_block_read(sdev, bar, offset, fw_ready, sizeof(*fw_ready)); 521 522 /* make sure ABI version is compatible */ 523 ret = snd_sof_ipc_valid(sdev); 524 if (ret < 0) 525 return ret; 526 527 /* now check for extended data */ 528 snd_sof_fw_parse_ext_data(sdev, bar, offset + 529 sizeof(struct sof_ipc_fw_ready)); 530 531 sof_get_windows(sdev); 532 533 return 0; 534 } 535 EXPORT_SYMBOL(sof_fw_ready); 536 537 /* generic module parser for mmaped DSPs */ 538 int snd_sof_parse_module_memcpy(struct snd_sof_dev *sdev, 539 struct snd_sof_mod_hdr *module) 540 { 541 struct snd_sof_blk_hdr *block; 542 int count, bar; 543 u32 offset; 544 size_t remaining; 545 546 dev_dbg(sdev->dev, "new module size 0x%x blocks 0x%x type 0x%x\n", 547 module->size, module->num_blocks, module->type); 548 549 block = (struct snd_sof_blk_hdr *)((u8 *)module + sizeof(*module)); 550 551 /* module->size doesn't include header size */ 552 remaining = module->size; 553 for (count = 0; count < module->num_blocks; count++) { 554 /* check for wrap */ 555 if (remaining < sizeof(*block)) { 556 dev_err(sdev->dev, "error: not enough data remaining\n"); 557 return -EINVAL; 558 } 559 560 /* minus header size of block */ 561 remaining -= sizeof(*block); 562 563 if (block->size == 0) { 564 dev_warn(sdev->dev, 565 "warning: block %d size zero\n", count); 566 dev_warn(sdev->dev, " type 0x%x offset 0x%x\n", 567 block->type, block->offset); 568 continue; 569 } 570 571 switch (block->type) { 572 case SOF_FW_BLK_TYPE_RSRVD0: 573 case SOF_FW_BLK_TYPE_ROM...SOF_FW_BLK_TYPE_RSRVD14: 574 continue; /* not handled atm */ 575 case SOF_FW_BLK_TYPE_IRAM: 576 case SOF_FW_BLK_TYPE_DRAM: 577 case SOF_FW_BLK_TYPE_SRAM: 578 offset = block->offset; 579 bar = snd_sof_dsp_get_bar_index(sdev, block->type); 580 if (bar < 0) { 581 dev_err(sdev->dev, 582 "error: no BAR mapping for block type 0x%x\n", 583 block->type); 584 return bar; 585 } 586 break; 587 default: 588 dev_err(sdev->dev, "error: bad type 0x%x for block 0x%x\n", 589 block->type, count); 590 return -EINVAL; 591 } 592 593 dev_dbg(sdev->dev, 594 "block %d type 0x%x size 0x%x ==> offset 0x%x\n", 595 count, block->type, block->size, offset); 596 597 /* checking block->size to avoid unaligned access */ 598 if (block->size % sizeof(u32)) { 599 dev_err(sdev->dev, "error: invalid block size 0x%x\n", 600 block->size); 601 return -EINVAL; 602 } 603 snd_sof_dsp_block_write(sdev, bar, offset, 604 block + 1, block->size); 605 606 if (remaining < block->size) { 607 dev_err(sdev->dev, "error: not enough data remaining\n"); 608 return -EINVAL; 609 } 610 611 /* minus body size of block */ 612 remaining -= block->size; 613 /* next block */ 614 block = (struct snd_sof_blk_hdr *)((u8 *)block + sizeof(*block) 615 + block->size); 616 } 617 618 return 0; 619 } 620 EXPORT_SYMBOL(snd_sof_parse_module_memcpy); 621 622 static int check_header(struct snd_sof_dev *sdev, const struct firmware *fw, 623 size_t fw_offset) 624 { 625 struct snd_sof_fw_header *header; 626 size_t fw_size = fw->size - fw_offset; 627 628 if (fw->size <= fw_offset) { 629 dev_err(sdev->dev, "error: firmware size must be greater than firmware offset\n"); 630 return -EINVAL; 631 } 632 633 /* Read the header information from the data pointer */ 634 header = (struct snd_sof_fw_header *)(fw->data + fw_offset); 635 636 /* verify FW sig */ 637 if (strncmp(header->sig, SND_SOF_FW_SIG, SND_SOF_FW_SIG_SIZE) != 0) { 638 dev_err(sdev->dev, "error: invalid firmware signature\n"); 639 return -EINVAL; 640 } 641 642 /* check size is valid */ 643 if (fw_size != header->file_size + sizeof(*header)) { 644 dev_err(sdev->dev, "error: invalid filesize mismatch got 0x%zx expected 0x%zx\n", 645 fw_size, header->file_size + sizeof(*header)); 646 return -EINVAL; 647 } 648 649 dev_dbg(sdev->dev, "header size=0x%x modules=0x%x abi=0x%x size=%zu\n", 650 header->file_size, header->num_modules, 651 header->abi, sizeof(*header)); 652 653 return 0; 654 } 655 656 static int load_modules(struct snd_sof_dev *sdev, const struct firmware *fw, 657 size_t fw_offset) 658 { 659 struct snd_sof_fw_header *header; 660 struct snd_sof_mod_hdr *module; 661 int (*load_module)(struct snd_sof_dev *sof_dev, 662 struct snd_sof_mod_hdr *hdr); 663 int ret, count; 664 size_t remaining; 665 666 header = (struct snd_sof_fw_header *)(fw->data + fw_offset); 667 load_module = sof_ops(sdev)->load_module; 668 if (!load_module) 669 return -EINVAL; 670 671 /* parse each module */ 672 module = (struct snd_sof_mod_hdr *)(fw->data + fw_offset + 673 sizeof(*header)); 674 remaining = fw->size - sizeof(*header) - fw_offset; 675 /* check for wrap */ 676 if (remaining > fw->size) { 677 dev_err(sdev->dev, "error: fw size smaller than header size\n"); 678 return -EINVAL; 679 } 680 681 for (count = 0; count < header->num_modules; count++) { 682 /* check for wrap */ 683 if (remaining < sizeof(*module)) { 684 dev_err(sdev->dev, "error: not enough data remaining\n"); 685 return -EINVAL; 686 } 687 688 /* minus header size of module */ 689 remaining -= sizeof(*module); 690 691 /* module */ 692 ret = load_module(sdev, module); 693 if (ret < 0) { 694 dev_err(sdev->dev, "error: invalid module %d\n", count); 695 return ret; 696 } 697 698 if (remaining < module->size) { 699 dev_err(sdev->dev, "error: not enough data remaining\n"); 700 return -EINVAL; 701 } 702 703 /* minus body size of module */ 704 remaining -= module->size; 705 module = (struct snd_sof_mod_hdr *)((u8 *)module 706 + sizeof(*module) + module->size); 707 } 708 709 return 0; 710 } 711 712 int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev) 713 { 714 struct snd_sof_pdata *plat_data = sdev->pdata; 715 const char *fw_filename; 716 ssize_t ext_man_size; 717 int ret; 718 719 /* Don't request firmware again if firmware is already requested */ 720 if (plat_data->fw) 721 return 0; 722 723 fw_filename = kasprintf(GFP_KERNEL, "%s/%s", 724 plat_data->fw_filename_prefix, 725 plat_data->fw_filename); 726 if (!fw_filename) 727 return -ENOMEM; 728 729 ret = request_firmware(&plat_data->fw, fw_filename, sdev->dev); 730 731 if (ret < 0) { 732 dev_err(sdev->dev, "error: request firmware %s failed err: %d\n", 733 fw_filename, ret); 734 dev_err(sdev->dev, 735 "you may need to download the firmware from https://github.com/thesofproject/sof-bin/\n"); 736 goto err; 737 } else { 738 dev_dbg(sdev->dev, "request_firmware %s successful\n", 739 fw_filename); 740 } 741 742 /* check for extended manifest */ 743 ext_man_size = snd_sof_fw_ext_man_parse(sdev, plat_data->fw); 744 if (ext_man_size > 0) { 745 /* when no error occurred, drop extended manifest */ 746 plat_data->fw_offset = ext_man_size; 747 } else if (!ext_man_size) { 748 /* No extended manifest, so nothing to skip during FW load */ 749 dev_dbg(sdev->dev, "firmware doesn't contain extended manifest\n"); 750 } else { 751 ret = ext_man_size; 752 dev_err(sdev->dev, "error: firmware %s contains unsupported or invalid extended manifest: %d\n", 753 fw_filename, ret); 754 } 755 756 err: 757 kfree(fw_filename); 758 759 return ret; 760 } 761 EXPORT_SYMBOL(snd_sof_load_firmware_raw); 762 763 int snd_sof_load_firmware_memcpy(struct snd_sof_dev *sdev) 764 { 765 struct snd_sof_pdata *plat_data = sdev->pdata; 766 int ret; 767 768 ret = snd_sof_load_firmware_raw(sdev); 769 if (ret < 0) 770 return ret; 771 772 /* make sure the FW header and file is valid */ 773 ret = check_header(sdev, plat_data->fw, plat_data->fw_offset); 774 if (ret < 0) { 775 dev_err(sdev->dev, "error: invalid FW header\n"); 776 goto error; 777 } 778 779 /* prepare the DSP for FW loading */ 780 ret = snd_sof_dsp_reset(sdev); 781 if (ret < 0) { 782 dev_err(sdev->dev, "error: failed to reset DSP\n"); 783 goto error; 784 } 785 786 /* parse and load firmware modules to DSP */ 787 ret = load_modules(sdev, plat_data->fw, plat_data->fw_offset); 788 if (ret < 0) { 789 dev_err(sdev->dev, "error: invalid FW modules\n"); 790 goto error; 791 } 792 793 return 0; 794 795 error: 796 release_firmware(plat_data->fw); 797 plat_data->fw = NULL; 798 return ret; 799 800 } 801 EXPORT_SYMBOL(snd_sof_load_firmware_memcpy); 802 803 int snd_sof_load_firmware(struct snd_sof_dev *sdev) 804 { 805 dev_dbg(sdev->dev, "loading firmware\n"); 806 807 if (sof_ops(sdev)->load_firmware) 808 return sof_ops(sdev)->load_firmware(sdev); 809 return 0; 810 } 811 EXPORT_SYMBOL(snd_sof_load_firmware); 812 813 int snd_sof_run_firmware(struct snd_sof_dev *sdev) 814 { 815 int ret; 816 817 init_waitqueue_head(&sdev->boot_wait); 818 819 /* create read-only fw_version debugfs to store boot version info */ 820 if (sdev->first_boot) { 821 ret = snd_sof_debugfs_buf_item(sdev, &sdev->fw_version, 822 sizeof(sdev->fw_version), 823 "fw_version", 0444); 824 /* errors are only due to memory allocation, not debugfs */ 825 if (ret < 0) { 826 dev_err(sdev->dev, "error: snd_sof_debugfs_buf_item failed\n"); 827 return ret; 828 } 829 } 830 831 /* perform pre fw run operations */ 832 ret = snd_sof_dsp_pre_fw_run(sdev); 833 if (ret < 0) { 834 dev_err(sdev->dev, "error: failed pre fw run op\n"); 835 return ret; 836 } 837 838 dev_dbg(sdev->dev, "booting DSP firmware\n"); 839 840 /* boot the firmware on the DSP */ 841 ret = snd_sof_dsp_run(sdev); 842 if (ret < 0) { 843 dev_err(sdev->dev, "error: failed to reset DSP\n"); 844 return ret; 845 } 846 847 /* 848 * now wait for the DSP to boot. There are 3 possible outcomes: 849 * 1. Boot wait times out indicating FW boot failure. 850 * 2. FW boots successfully and fw_ready op succeeds. 851 * 3. FW boots but fw_ready op fails. 852 */ 853 ret = wait_event_timeout(sdev->boot_wait, 854 sdev->fw_state > SOF_FW_BOOT_IN_PROGRESS, 855 msecs_to_jiffies(sdev->boot_timeout)); 856 if (ret == 0) { 857 dev_err(sdev->dev, "error: firmware boot failure\n"); 858 snd_sof_dsp_dbg_dump(sdev, SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX | 859 SOF_DBG_DUMP_TEXT | SOF_DBG_DUMP_PCI | SOF_DBG_DUMP_FORCE_ERR_LEVEL); 860 sdev->fw_state = SOF_FW_BOOT_FAILED; 861 return -EIO; 862 } 863 864 if (sdev->fw_state == SOF_FW_BOOT_COMPLETE) 865 dev_dbg(sdev->dev, "firmware boot complete\n"); 866 else 867 return -EIO; /* FW boots but fw_ready op failed */ 868 869 /* perform post fw run operations */ 870 ret = snd_sof_dsp_post_fw_run(sdev); 871 if (ret < 0) { 872 dev_err(sdev->dev, "error: failed post fw run op\n"); 873 return ret; 874 } 875 876 return 0; 877 } 878 EXPORT_SYMBOL(snd_sof_run_firmware); 879 880 void snd_sof_fw_unload(struct snd_sof_dev *sdev) 881 { 882 /* TODO: support module unloading at runtime */ 883 } 884 EXPORT_SYMBOL(snd_sof_fw_unload); 885