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