1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // Copyright(c) 2021-2022 Intel Corporation 4 // 5 // Authors: Cezary Rojewski <cezary.rojewski@intel.com> 6 // Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com> 7 // 8 9 #include <linux/firmware.h> 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <sound/hdaudio.h> 13 #include <sound/hdaudio_ext.h> 14 #include "avs.h" 15 #include "cldma.h" 16 #include "messages.h" 17 #include "registers.h" 18 #include "topology.h" 19 20 #define AVS_ROM_STS_MASK 0xFF 21 #define AVS_ROM_INIT_DONE 0x1 22 #define SKL_ROM_BASEFW_ENTERED 0xF 23 #define APL_ROM_FW_ENTERED 0x5 24 #define AVS_ROM_INIT_POLLING_US 5 25 #define SKL_ROM_INIT_TIMEOUT_US 1000000 26 #define APL_ROM_INIT_TIMEOUT_US 300000 27 #define APL_ROM_INIT_RETRIES 3 28 29 #define AVS_FW_INIT_POLLING_US 500 30 #define AVS_FW_INIT_TIMEOUT_MS 3000 31 #define AVS_FW_INIT_TIMEOUT_US (AVS_FW_INIT_TIMEOUT_MS * 1000) 32 33 #define AVS_CLDMA_START_DELAY_MS 100 34 35 #define AVS_ROOT_DIR "intel/avs" 36 #define AVS_BASEFW_FILENAME "dsp_basefw.bin" 37 #define AVS_EXT_MANIFEST_MAGIC 0x31454124 38 #define SKL_MANIFEST_MAGIC 0x00000006 39 #define SKL_ADSPFW_OFFSET 0x284 40 #define APL_MANIFEST_MAGIC 0x44504324 41 #define APL_ADSPFW_OFFSET 0x2000 42 43 /* Occasionally, engineering (release candidate) firmware is provided for testing. */ 44 static bool debug_ignore_fw_version; 45 module_param_named(ignore_fw_version, debug_ignore_fw_version, bool, 0444); 46 MODULE_PARM_DESC(ignore_fw_version, "Ignore firmware version check 0=no (default), 1=yes"); 47 48 #define AVS_LIB_NAME_SIZE 8 49 50 struct avs_fw_manifest { 51 u32 id; 52 u32 len; 53 char name[AVS_LIB_NAME_SIZE]; 54 u32 preload_page_count; 55 u32 img_flags; 56 u32 feature_mask; 57 struct avs_fw_version version; 58 } __packed; 59 static_assert(sizeof(struct avs_fw_manifest) == 36); 60 61 struct avs_fw_ext_manifest { 62 u32 id; 63 u32 len; 64 u16 version_major; 65 u16 version_minor; 66 u32 entries; 67 } __packed; 68 static_assert(sizeof(struct avs_fw_ext_manifest) == 16); 69 70 static int avs_fw_ext_manifest_strip(struct firmware *fw) 71 { 72 struct avs_fw_ext_manifest *man; 73 74 if (fw->size < sizeof(*man)) 75 return -EINVAL; 76 77 man = (struct avs_fw_ext_manifest *)fw->data; 78 if (man->id == AVS_EXT_MANIFEST_MAGIC) { 79 fw->data += man->len; 80 fw->size -= man->len; 81 } 82 83 return 0; 84 } 85 86 static int avs_fw_manifest_offset(struct firmware *fw) 87 { 88 /* Header type found in first DWORD of fw binary. */ 89 u32 magic = *(u32 *)fw->data; 90 91 switch (magic) { 92 case SKL_MANIFEST_MAGIC: 93 return SKL_ADSPFW_OFFSET; 94 case APL_MANIFEST_MAGIC: 95 return APL_ADSPFW_OFFSET; 96 default: 97 return -EINVAL; 98 } 99 } 100 101 static int avs_fw_manifest_strip_verify(struct avs_dev *adev, struct firmware *fw, 102 const struct avs_fw_version *min) 103 { 104 struct avs_fw_manifest *man; 105 int offset, ret; 106 107 ret = avs_fw_ext_manifest_strip(fw); 108 if (ret) 109 return ret; 110 111 offset = avs_fw_manifest_offset(fw); 112 if (offset < 0) 113 return offset; 114 115 if (fw->size < offset + sizeof(*man)) 116 return -EINVAL; 117 if (!min) 118 return 0; 119 120 man = (struct avs_fw_manifest *)(fw->data + offset); 121 if (man->version.major != min->major || 122 man->version.minor != min->minor || 123 man->version.hotfix != min->hotfix || 124 man->version.build < min->build) { 125 dev_warn(adev->dev, "bad FW version %d.%d.%d.%d, expected %d.%d.%d.%d or newer\n", 126 man->version.major, man->version.minor, 127 man->version.hotfix, man->version.build, 128 min->major, min->minor, min->hotfix, min->build); 129 130 if (!debug_ignore_fw_version) 131 return -EINVAL; 132 } 133 134 return 0; 135 } 136 137 int avs_cldma_load_basefw(struct avs_dev *adev, struct firmware *fw) 138 { 139 struct hda_cldma *cl = &code_loader; 140 unsigned int reg; 141 int ret; 142 143 ret = avs_dsp_op(adev, power, AVS_MAIN_CORE_MASK, true); 144 if (ret < 0) 145 return ret; 146 147 ret = avs_dsp_op(adev, reset, AVS_MAIN_CORE_MASK, false); 148 if (ret < 0) 149 return ret; 150 151 ret = hda_cldma_reset(cl); 152 if (ret < 0) { 153 dev_err(adev->dev, "cldma reset failed: %d\n", ret); 154 return ret; 155 } 156 hda_cldma_setup(cl); 157 158 ret = avs_dsp_op(adev, stall, AVS_MAIN_CORE_MASK, false); 159 if (ret < 0) 160 return ret; 161 162 reinit_completion(&adev->fw_ready); 163 avs_dsp_op(adev, int_control, true); 164 165 /* await ROM init */ 166 ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg, 167 (reg & AVS_ROM_INIT_DONE) == AVS_ROM_INIT_DONE, 168 AVS_ROM_INIT_POLLING_US, SKL_ROM_INIT_TIMEOUT_US); 169 if (ret < 0) { 170 dev_err(adev->dev, "rom init failed: %d, status: 0x%08x, lec: 0x%08x\n", 171 ret, reg, snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 172 avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 173 return ret; 174 } 175 176 hda_cldma_set_data(cl, (void *)fw->data, fw->size); 177 /* transfer firmware */ 178 hda_cldma_transfer(cl, 0); 179 ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg, 180 (reg & AVS_ROM_STS_MASK) == SKL_ROM_BASEFW_ENTERED, 181 AVS_FW_INIT_POLLING_US, AVS_FW_INIT_TIMEOUT_US); 182 hda_cldma_stop(cl); 183 if (ret < 0) { 184 dev_err(adev->dev, "transfer fw failed: %d, status: 0x%08x, lec: 0x%08x\n", 185 ret, reg, snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 186 avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 187 return ret; 188 } 189 190 return 0; 191 } 192 193 int avs_cldma_load_library(struct avs_dev *adev, struct firmware *lib, u32 id) 194 { 195 struct hda_cldma *cl = &code_loader; 196 int ret; 197 198 hda_cldma_set_data(cl, (void *)lib->data, lib->size); 199 /* transfer modules manifest */ 200 hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS)); 201 202 /* DMA id ignored as there is only ever one code-loader DMA */ 203 ret = avs_ipc_load_library(adev, 0, id); 204 hda_cldma_stop(cl); 205 206 if (ret) { 207 ret = AVS_IPC_RET(ret); 208 dev_err(adev->dev, "transfer lib %d failed: %d\n", id, ret); 209 } 210 211 return ret; 212 } 213 214 static int avs_cldma_load_module(struct avs_dev *adev, struct avs_module_entry *mentry) 215 { 216 struct hda_cldma *cl = &code_loader; 217 const struct firmware *mod; 218 char *mod_name; 219 int ret; 220 221 mod_name = kasprintf(GFP_KERNEL, "%s/%s/dsp_mod_%pUL.bin", AVS_ROOT_DIR, 222 adev->spec->name, mentry->uuid.b); 223 if (!mod_name) 224 return -ENOMEM; 225 226 ret = avs_request_firmware(adev, &mod, mod_name); 227 kfree(mod_name); 228 if (ret < 0) 229 return ret; 230 231 avs_hda_power_gating_enable(adev, false); 232 avs_hda_clock_gating_enable(adev, false); 233 avs_hda_l1sen_enable(adev, false); 234 235 hda_cldma_set_data(cl, (void *)mod->data, mod->size); 236 hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS)); 237 ret = avs_ipc_load_modules(adev, &mentry->module_id, 1); 238 hda_cldma_stop(cl); 239 240 avs_hda_l1sen_enable(adev, true); 241 avs_hda_clock_gating_enable(adev, true); 242 avs_hda_power_gating_enable(adev, true); 243 244 if (ret) { 245 dev_err(adev->dev, "load module %d failed: %d\n", mentry->module_id, ret); 246 avs_release_last_firmware(adev); 247 return AVS_IPC_RET(ret); 248 } 249 250 return 0; 251 } 252 253 int avs_cldma_transfer_modules(struct avs_dev *adev, bool load, 254 struct avs_module_entry *mods, u32 num_mods) 255 { 256 u16 *mod_ids; 257 int ret, i; 258 259 /* Either load to DSP or unload them to free space. */ 260 if (load) { 261 for (i = 0; i < num_mods; i++) { 262 ret = avs_cldma_load_module(adev, &mods[i]); 263 if (ret) 264 return ret; 265 } 266 267 return 0; 268 } 269 270 mod_ids = kcalloc(num_mods, sizeof(u16), GFP_KERNEL); 271 if (!mod_ids) 272 return -ENOMEM; 273 274 for (i = 0; i < num_mods; i++) 275 mod_ids[i] = mods[i].module_id; 276 277 ret = avs_ipc_unload_modules(adev, mod_ids, num_mods); 278 kfree(mod_ids); 279 if (ret) 280 return AVS_IPC_RET(ret); 281 282 return 0; 283 } 284 285 static int 286 avs_hda_init_rom(struct avs_dev *adev, unsigned int dma_id, bool purge) 287 { 288 const struct avs_spec *const spec = adev->spec; 289 unsigned int corex_mask, reg; 290 int ret; 291 292 corex_mask = spec->core_init_mask & ~AVS_MAIN_CORE_MASK; 293 294 ret = avs_dsp_op(adev, power, spec->core_init_mask, true); 295 if (ret < 0) 296 goto err; 297 298 ret = avs_dsp_op(adev, reset, AVS_MAIN_CORE_MASK, false); 299 if (ret < 0) 300 goto err; 301 302 reinit_completion(&adev->fw_ready); 303 avs_dsp_op(adev, int_control, true); 304 305 /* set boot config */ 306 ret = avs_ipc_set_boot_config(adev, dma_id, purge); 307 if (ret) { 308 ret = AVS_IPC_RET(ret); 309 goto err; 310 } 311 312 /* await ROM init */ 313 ret = snd_hdac_adsp_readl_poll(adev, spec->sram->rom_status_offset, reg, 314 (reg & 0xF) == AVS_ROM_INIT_DONE || 315 (reg & 0xF) == APL_ROM_FW_ENTERED, 316 AVS_ROM_INIT_POLLING_US, APL_ROM_INIT_TIMEOUT_US); 317 if (ret < 0) { 318 dev_err(adev->dev, "rom init failed: %d, status: 0x%08x, lec: 0x%08x\n", 319 ret, reg, snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 320 goto err; 321 } 322 323 /* power down non-main cores */ 324 if (corex_mask) { 325 ret = avs_dsp_op(adev, power, corex_mask, false); 326 if (ret < 0) 327 goto err; 328 } 329 330 return 0; 331 332 err: 333 avs_dsp_core_disable(adev, spec->core_init_mask); 334 return ret; 335 } 336 337 static int avs_imr_load_basefw(struct avs_dev *adev) 338 { 339 int ret; 340 341 /* DMA id ignored when flashing from IMR as no transfer occurs. */ 342 ret = avs_hda_init_rom(adev, 0, false); 343 if (ret < 0) 344 return ret; 345 346 ret = wait_for_completion_timeout(&adev->fw_ready, 347 msecs_to_jiffies(AVS_FW_INIT_TIMEOUT_MS)); 348 if (!ret) { 349 dev_err(adev->dev, "firmware ready timeout, status: 0x%08x, lec: 0x%08x\n", 350 snd_hdac_adsp_readl(adev, AVS_FW_REG_STATUS(adev)), 351 snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 352 avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 353 return -ETIMEDOUT; 354 } 355 356 return 0; 357 } 358 359 int avs_hda_load_basefw(struct avs_dev *adev, struct firmware *fw) 360 { 361 struct snd_pcm_substream substream; 362 struct snd_dma_buffer dmab; 363 struct hdac_ext_stream *estream; 364 struct hdac_stream *hstream; 365 struct hdac_bus *bus = &adev->base.core; 366 unsigned int sdfmt, reg; 367 int ret, i; 368 369 /* configure hda dma */ 370 memset(&substream, 0, sizeof(substream)); 371 substream.stream = SNDRV_PCM_STREAM_PLAYBACK; 372 estream = snd_hdac_ext_stream_assign(bus, &substream, 373 HDAC_EXT_STREAM_TYPE_HOST); 374 if (!estream) 375 return -ENODEV; 376 hstream = hdac_stream(estream); 377 378 /* code loading performed with default format */ 379 sdfmt = snd_hdac_stream_format(1, 32, 48000); 380 ret = snd_hdac_dsp_prepare(hstream, sdfmt, fw->size, &dmab); 381 if (ret < 0) 382 goto release_stream; 383 384 /* enable SPIB for hda stream */ 385 snd_hdac_stream_spbcap_enable(bus, true, hstream->index); 386 ret = snd_hdac_stream_set_spib(bus, hstream, fw->size); 387 if (ret) 388 goto cleanup_resources; 389 390 memcpy(dmab.area, fw->data, fw->size); 391 392 for (i = 0; i < APL_ROM_INIT_RETRIES; i++) { 393 unsigned int dma_id = hstream->stream_tag - 1; 394 395 ret = avs_hda_init_rom(adev, dma_id, true); 396 if (!ret) 397 break; 398 dev_info(adev->dev, "#%d rom init failed: %d\n", i + 1, ret); 399 } 400 if (ret < 0) 401 goto cleanup_resources; 402 403 /* transfer firmware */ 404 snd_hdac_dsp_trigger(hstream, true); 405 ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg, 406 (reg & AVS_ROM_STS_MASK) == APL_ROM_FW_ENTERED, 407 AVS_FW_INIT_POLLING_US, AVS_FW_INIT_TIMEOUT_US); 408 snd_hdac_dsp_trigger(hstream, false); 409 if (ret < 0) { 410 dev_err(adev->dev, "transfer fw failed: %d, status: 0x%08x, lec: 0x%08x\n", 411 ret, reg, snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 412 avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 413 } 414 415 cleanup_resources: 416 /* disable SPIB for hda stream */ 417 snd_hdac_stream_spbcap_enable(bus, false, hstream->index); 418 snd_hdac_stream_set_spib(bus, hstream, 0); 419 420 snd_hdac_dsp_cleanup(hstream, &dmab); 421 release_stream: 422 snd_hdac_ext_stream_release(estream, HDAC_EXT_STREAM_TYPE_HOST); 423 424 return ret; 425 } 426 427 int avs_hda_load_library(struct avs_dev *adev, struct firmware *lib, u32 id) 428 { 429 struct snd_pcm_substream substream; 430 struct snd_dma_buffer dmab; 431 struct hdac_ext_stream *estream; 432 struct hdac_stream *stream; 433 struct hdac_bus *bus = &adev->base.core; 434 unsigned int sdfmt; 435 int ret; 436 437 /* configure hda dma */ 438 memset(&substream, 0, sizeof(substream)); 439 substream.stream = SNDRV_PCM_STREAM_PLAYBACK; 440 estream = snd_hdac_ext_stream_assign(bus, &substream, 441 HDAC_EXT_STREAM_TYPE_HOST); 442 if (!estream) 443 return -ENODEV; 444 stream = hdac_stream(estream); 445 446 /* code loading performed with default format */ 447 sdfmt = snd_hdac_stream_format(1, 32, 48000); 448 ret = snd_hdac_dsp_prepare(stream, sdfmt, lib->size, &dmab); 449 if (ret < 0) 450 goto release_stream; 451 452 /* enable SPIB for hda stream */ 453 snd_hdac_stream_spbcap_enable(bus, true, stream->index); 454 snd_hdac_stream_set_spib(bus, stream, lib->size); 455 456 memcpy(dmab.area, lib->data, lib->size); 457 458 /* transfer firmware */ 459 snd_hdac_dsp_trigger(stream, true); 460 ret = avs_ipc_load_library(adev, stream->stream_tag - 1, id); 461 snd_hdac_dsp_trigger(stream, false); 462 if (ret) { 463 dev_err(adev->dev, "transfer lib %d failed: %d\n", id, ret); 464 ret = AVS_IPC_RET(ret); 465 } 466 467 /* disable SPIB for hda stream */ 468 snd_hdac_stream_spbcap_enable(bus, false, stream->index); 469 snd_hdac_stream_set_spib(bus, stream, 0); 470 471 snd_hdac_dsp_cleanup(stream, &dmab); 472 release_stream: 473 snd_hdac_ext_stream_release(estream, HDAC_EXT_STREAM_TYPE_HOST); 474 475 return ret; 476 } 477 478 int avs_hda_transfer_modules(struct avs_dev *adev, bool load, 479 struct avs_module_entry *mods, u32 num_mods) 480 { 481 /* 482 * All platforms without CLDMA are equipped with IMR, 483 * and thus the module transferring is offloaded to DSP. 484 */ 485 return 0; 486 } 487 488 int avs_dsp_load_libraries(struct avs_dev *adev, struct avs_tplg_library *libs, u32 num_libs) 489 { 490 int start, id, i = 0; 491 int ret; 492 493 /* Calculate the id to assign for the next lib. */ 494 for (id = 0; id < adev->fw_cfg.max_libs_count; id++) 495 if (adev->lib_names[id][0] == '\0') 496 break; 497 if (id + num_libs >= adev->fw_cfg.max_libs_count) 498 return -EINVAL; 499 500 start = id; 501 while (i < num_libs) { 502 struct avs_fw_manifest *man; 503 const struct firmware *fw; 504 struct firmware stripped_fw; 505 char *filename; 506 int j; 507 508 filename = kasprintf(GFP_KERNEL, "%s/%s/%s", AVS_ROOT_DIR, adev->spec->name, 509 libs[i].name); 510 if (!filename) 511 return -ENOMEM; 512 513 /* 514 * If any call after this one fails, requested firmware is not released with 515 * avs_release_last_firmware() as failing to load code results in need for reload 516 * of entire driver module. And then avs_release_firmwares() is in place already. 517 */ 518 ret = avs_request_firmware(adev, &fw, filename); 519 kfree(filename); 520 if (ret < 0) 521 return ret; 522 523 stripped_fw = *fw; 524 ret = avs_fw_manifest_strip_verify(adev, &stripped_fw, NULL); 525 if (ret) { 526 dev_err(adev->dev, "invalid library data: %d\n", ret); 527 return ret; 528 } 529 530 ret = avs_fw_manifest_offset(&stripped_fw); 531 if (ret < 0) 532 return ret; 533 man = (struct avs_fw_manifest *)(stripped_fw.data + ret); 534 535 /* Don't load anything that's already in DSP memory. */ 536 for (j = 0; j < id; j++) 537 if (!strncmp(adev->lib_names[j], man->name, AVS_LIB_NAME_SIZE)) 538 goto next_lib; 539 540 ret = avs_dsp_op(adev, load_lib, &stripped_fw, id); 541 if (ret) 542 return ret; 543 544 strscpy(adev->lib_names[id], man->name, AVS_LIB_NAME_SIZE); 545 id++; 546 next_lib: 547 i++; 548 } 549 550 return start == id ? 1 : 0; 551 } 552 553 static int avs_dsp_load_basefw(struct avs_dev *adev) 554 { 555 const struct avs_fw_version *min_req; 556 const struct avs_spec *const spec = adev->spec; 557 const struct firmware *fw; 558 struct firmware stripped_fw; 559 char *filename; 560 int ret; 561 562 filename = kasprintf(GFP_KERNEL, "%s/%s/%s", AVS_ROOT_DIR, spec->name, AVS_BASEFW_FILENAME); 563 if (!filename) 564 return -ENOMEM; 565 566 ret = avs_request_firmware(adev, &fw, filename); 567 kfree(filename); 568 if (ret < 0) { 569 dev_err(adev->dev, "request firmware failed: %d\n", ret); 570 return ret; 571 } 572 573 stripped_fw = *fw; 574 min_req = &adev->spec->min_fw_version; 575 576 ret = avs_fw_manifest_strip_verify(adev, &stripped_fw, min_req); 577 if (ret < 0) { 578 dev_err(adev->dev, "invalid firmware data: %d\n", ret); 579 goto release_fw; 580 } 581 582 ret = avs_dsp_op(adev, load_basefw, &stripped_fw); 583 if (ret < 0) { 584 dev_err(adev->dev, "basefw load failed: %d\n", ret); 585 goto release_fw; 586 } 587 588 ret = wait_for_completion_timeout(&adev->fw_ready, 589 msecs_to_jiffies(AVS_FW_INIT_TIMEOUT_MS)); 590 if (!ret) { 591 dev_err(adev->dev, "firmware ready timeout, status: 0x%08x, lec: 0x%08x\n", 592 snd_hdac_adsp_readl(adev, AVS_FW_REG_STATUS(adev)), 593 snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev))); 594 avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 595 ret = -ETIMEDOUT; 596 goto release_fw; 597 } 598 599 return 0; 600 601 release_fw: 602 avs_release_last_firmware(adev); 603 return ret; 604 } 605 606 int avs_dsp_boot_firmware(struct avs_dev *adev, bool purge) 607 { 608 struct avs_soc_component *acomp; 609 int ret, i; 610 611 /* Forgo full boot if flash from IMR succeeds. */ 612 if (!purge && avs_platattr_test(adev, IMR)) { 613 ret = avs_imr_load_basefw(adev); 614 if (!ret) 615 return 0; 616 617 dev_dbg(adev->dev, "firmware flash from imr failed: %d\n", ret); 618 } 619 620 /* Full boot, clear cached data except for basefw (slot 0). */ 621 for (i = 1; i < adev->fw_cfg.max_libs_count; i++) 622 memset(adev->lib_names[i], 0, AVS_LIB_NAME_SIZE); 623 624 avs_hda_power_gating_enable(adev, false); 625 avs_hda_clock_gating_enable(adev, false); 626 avs_hda_l1sen_enable(adev, false); 627 628 ret = avs_dsp_load_basefw(adev); 629 if (ret) 630 goto reenable_gating; 631 632 mutex_lock(&adev->comp_list_mutex); 633 list_for_each_entry(acomp, &adev->comp_list, node) { 634 struct avs_tplg *tplg = acomp->tplg; 635 636 ret = avs_dsp_load_libraries(adev, tplg->libs, tplg->num_libs); 637 if (ret < 0) 638 break; 639 } 640 mutex_unlock(&adev->comp_list_mutex); 641 642 reenable_gating: 643 avs_hda_l1sen_enable(adev, true); 644 avs_hda_clock_gating_enable(adev, true); 645 avs_hda_power_gating_enable(adev, true); 646 647 if (ret < 0) 648 return ret; 649 650 /* With all code loaded, refresh module information. */ 651 ret = avs_module_info_init(adev, true); 652 if (ret) { 653 dev_err(adev->dev, "init module info failed: %d\n", ret); 654 return ret; 655 } 656 657 return 0; 658 } 659 660 int avs_dsp_first_boot_firmware(struct avs_dev *adev) 661 { 662 int ret, i; 663 664 if (avs_platattr_test(adev, CLDMA)) { 665 ret = hda_cldma_init(&code_loader, &adev->base.core, 666 adev->dsp_ba, AVS_CL_DEFAULT_BUFFER_SIZE); 667 if (ret < 0) { 668 dev_err(adev->dev, "cldma init failed: %d\n", ret); 669 return ret; 670 } 671 } 672 673 ret = avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK); 674 if (ret < 0) 675 return ret; 676 677 ret = avs_dsp_boot_firmware(adev, true); 678 if (ret < 0) { 679 dev_err(adev->dev, "firmware boot failed: %d\n", ret); 680 return ret; 681 } 682 683 ret = avs_ipc_get_hw_config(adev, &adev->hw_cfg); 684 if (ret) 685 return AVS_IPC_RET(ret); 686 687 ret = avs_ipc_get_fw_config(adev, &adev->fw_cfg); 688 if (ret) 689 return AVS_IPC_RET(ret); 690 691 adev->core_refs = devm_kcalloc(adev->dev, adev->hw_cfg.dsp_cores, 692 sizeof(*adev->core_refs), GFP_KERNEL); 693 adev->lib_names = devm_kcalloc(adev->dev, adev->fw_cfg.max_libs_count, 694 sizeof(*adev->lib_names), GFP_KERNEL); 695 if (!adev->core_refs || !adev->lib_names) 696 return -ENOMEM; 697 698 for (i = 0; i < adev->fw_cfg.max_libs_count; i++) { 699 adev->lib_names[i] = devm_kzalloc(adev->dev, AVS_LIB_NAME_SIZE, GFP_KERNEL); 700 if (!adev->lib_names[i]) 701 return -ENOMEM; 702 } 703 704 /* basefw always occupies slot 0 */ 705 strscpy(adev->lib_names[0], "BASEFW", AVS_LIB_NAME_SIZE); 706 707 ida_init(&adev->ppl_ida); 708 709 return 0; 710 } 711