intel/avs/loader.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // Copyright(c) 2021-2022 Intel Corporation. All rights reserved.
0004 //
0005 // Authors: Cezary Rojewski <cezary.rojewski@intel.com>
0006 //          Amadeusz Slawinski <amadeuszx.slawinski@linux.intel.com>
0007 //
0008
0009 #include <linux/firmware.h>
0010 #include <linux/module.h>
0011 #include <linux/slab.h>
0012 #include <sound/hdaudio.h>
0013 #include <sound/hdaudio_ext.h>
0014 #include "avs.h"
0015 #include "cldma.h"
0016 #include "messages.h"
0017 #include "registers.h"
0018 #include "topology.h"
0019
0020 #define AVS_ROM_STS_MASK        0xFF
0021 #define AVS_ROM_INIT_DONE       0x1
0022 #define SKL_ROM_BASEFW_ENTERED      0xF
0023 #define APL_ROM_FW_ENTERED      0x5
0024 #define AVS_ROM_INIT_POLLING_US     5
0025 #define SKL_ROM_INIT_TIMEOUT_US     1000000
0026 #define APL_ROM_INIT_TIMEOUT_US     300000
0027 #define APL_ROM_INIT_RETRIES        3
0028
0029 #define AVS_FW_INIT_POLLING_US      500
0030 #define AVS_FW_INIT_TIMEOUT_MS      3000
0031 #define AVS_FW_INIT_TIMEOUT_US      (AVS_FW_INIT_TIMEOUT_MS * 1000)
0032
0033 #define AVS_CLDMA_START_DELAY_MS    100
0034
0035 #define AVS_ROOT_DIR            "intel/avs"
0036 #define AVS_BASEFW_FILENAME     "dsp_basefw.bin"
0037 #define AVS_EXT_MANIFEST_MAGIC      0x31454124
0038 #define SKL_MANIFEST_MAGIC      0x00000006
0039 #define SKL_ADSPFW_OFFSET       0x284
0040 #define APL_MANIFEST_MAGIC      0x44504324
0041 #define APL_ADSPFW_OFFSET       0x2000
0042
0043 /* Occasionally, engineering (release candidate) firmware is provided for testing. */
0044 static bool debug_ignore_fw_version;
0045 module_param_named(ignore_fw_version, debug_ignore_fw_version, bool, 0444);
0046 MODULE_PARM_DESC(ignore_fw_version, "Verify FW version 0=yes (default), 1=no");
0047
0048 #define AVS_LIB_NAME_SIZE   8
0049
0050 struct avs_fw_manifest {
0051     u32 id;
0052     u32 len;
0053     char name[AVS_LIB_NAME_SIZE];
0054     u32 preload_page_count;
0055     u32 img_flags;
0056     u32 feature_mask;
0057     struct avs_fw_version version;
0058 } __packed;
0059
0060 struct avs_fw_ext_manifest {
0061     u32 id;
0062     u32 len;
0063     u16 version_major;
0064     u16 version_minor;
0065     u32 entries;
0066 } __packed;
0067
0068 static int avs_fw_ext_manifest_strip(struct firmware *fw)
0069 {
0070     struct avs_fw_ext_manifest *man;
0071
0072     if (fw->size < sizeof(*man))
0073         return -EINVAL;
0074
0075     man = (struct avs_fw_ext_manifest *)fw->data;
0076     if (man->id == AVS_EXT_MANIFEST_MAGIC) {
0077         fw->data += man->len;
0078         fw->size -= man->len;
0079     }
0080
0081     return 0;
0082 }
0083
0084 static int avs_fw_manifest_offset(struct firmware *fw)
0085 {
0086     /* Header type found in first DWORD of fw binary. */
0087     u32 magic = *(u32 *)fw->data;
0088
0089     switch (magic) {
0090     case SKL_MANIFEST_MAGIC:
0091         return SKL_ADSPFW_OFFSET;
0092     case APL_MANIFEST_MAGIC:
0093         return APL_ADSPFW_OFFSET;
0094     default:
0095         return -EINVAL;
0096     }
0097 }
0098
0099 static int avs_fw_manifest_strip_verify(struct avs_dev *adev, struct firmware *fw,
0100                     const struct avs_fw_version *min)
0101 {
0102     struct avs_fw_manifest *man;
0103     int offset, ret;
0104
0105     ret = avs_fw_ext_manifest_strip(fw);
0106     if (ret)
0107         return ret;
0108
0109     offset = avs_fw_manifest_offset(fw);
0110     if (offset < 0)
0111         return offset;
0112
0113     if (fw->size < offset + sizeof(*man))
0114         return -EINVAL;
0115     if (!min)
0116         return 0;
0117
0118     man = (struct avs_fw_manifest *)(fw->data + offset);
0119     if (man->version.major != min->major ||
0120         man->version.minor != min->minor ||
0121         man->version.hotfix != min->hotfix ||
0122         man->version.build < min->build) {
0123         dev_warn(adev->dev, "bad FW version %d.%d.%d.%d, expected %d.%d.%d.%d or newer\n",
0124              man->version.major, man->version.minor,
0125              man->version.hotfix, man->version.build,
0126              min->major, min->minor, min->hotfix, min->build);
0127
0128         if (!debug_ignore_fw_version)
0129             return -EINVAL;
0130     }
0131
0132     return 0;
0133 }
0134
0135 int avs_cldma_load_basefw(struct avs_dev *adev, struct firmware *fw)
0136 {
0137     struct hda_cldma *cl = &code_loader;
0138     unsigned int reg;
0139     int ret;
0140
0141     ret = avs_dsp_op(adev, power, AVS_MAIN_CORE_MASK, true);
0142     if (ret < 0)
0143         return ret;
0144
0145     ret = avs_dsp_op(adev, reset, AVS_MAIN_CORE_MASK, false);
0146     if (ret < 0)
0147         return ret;
0148
0149     ret = hda_cldma_reset(cl);
0150     if (ret < 0) {
0151         dev_err(adev->dev, "cldma reset failed: %d\n", ret);
0152         return ret;
0153     }
0154     hda_cldma_setup(cl);
0155
0156     ret = avs_dsp_op(adev, stall, AVS_MAIN_CORE_MASK, false);
0157     if (ret < 0)
0158         return ret;
0159
0160     reinit_completion(&adev->fw_ready);
0161     avs_dsp_op(adev, int_control, true);
0162
0163     /* await ROM init */
0164     ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg,
0165                        (reg & AVS_ROM_INIT_DONE) == AVS_ROM_INIT_DONE,
0166                        AVS_ROM_INIT_POLLING_US, SKL_ROM_INIT_TIMEOUT_US);
0167     if (ret < 0) {
0168         dev_err(adev->dev, "rom init timeout: %d\n", ret);
0169         avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
0170         return ret;
0171     }
0172
0173     hda_cldma_set_data(cl, (void *)fw->data, fw->size);
0174     /* transfer firmware */
0175     hda_cldma_transfer(cl, 0);
0176     ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg,
0177                        (reg & AVS_ROM_STS_MASK) == SKL_ROM_BASEFW_ENTERED,
0178                        AVS_FW_INIT_POLLING_US, AVS_FW_INIT_TIMEOUT_US);
0179     hda_cldma_stop(cl);
0180     if (ret < 0) {
0181         dev_err(adev->dev, "transfer fw failed: %d\n", ret);
0182         avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
0183         return ret;
0184     }
0185
0186     return 0;
0187 }
0188
0189 int avs_cldma_load_library(struct avs_dev *adev, struct firmware *lib, u32 id)
0190 {
0191     struct hda_cldma *cl = &code_loader;
0192     int ret;
0193
0194     hda_cldma_set_data(cl, (void *)lib->data, lib->size);
0195     /* transfer modules manifest */
0196     hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS));
0197
0198     /* DMA id ignored as there is only ever one code-loader DMA */
0199     ret = avs_ipc_load_library(adev, 0, id);
0200     hda_cldma_stop(cl);
0201
0202     if (ret) {
0203         ret = AVS_IPC_RET(ret);
0204         dev_err(adev->dev, "transfer lib %d failed: %d\n", id, ret);
0205     }
0206
0207     return ret;
0208 }
0209
0210 static int avs_cldma_load_module(struct avs_dev *adev, struct avs_module_entry *mentry)
0211 {
0212     struct hda_cldma *cl = &code_loader;
0213     const struct firmware *mod;
0214     char *mod_name;
0215     int ret;
0216
0217     mod_name = kasprintf(GFP_KERNEL, "%s/%s/dsp_mod_%pUL.bin", AVS_ROOT_DIR,
0218                  adev->spec->name, mentry->uuid.b);
0219     if (!mod_name)
0220         return -ENOMEM;
0221
0222     ret = avs_request_firmware(adev, &mod, mod_name);
0223     kfree(mod_name);
0224     if (ret < 0)
0225         return ret;
0226
0227     hda_cldma_set_data(cl, (void *)mod->data, mod->size);
0228     hda_cldma_transfer(cl, msecs_to_jiffies(AVS_CLDMA_START_DELAY_MS));
0229     ret = avs_ipc_load_modules(adev, &mentry->module_id, 1);
0230     hda_cldma_stop(cl);
0231
0232     if (ret) {
0233         dev_err(adev->dev, "load module %d failed: %d\n", mentry->module_id, ret);
0234         avs_release_last_firmware(adev);
0235         return AVS_IPC_RET(ret);
0236     }
0237
0238     return 0;
0239 }
0240
0241 int avs_cldma_transfer_modules(struct avs_dev *adev, bool load,
0242                    struct avs_module_entry *mods, u32 num_mods)
0243 {
0244     u16 *mod_ids;
0245     int ret, i;
0246
0247     /* Either load to DSP or unload them to free space. */
0248     if (load) {
0249         for (i = 0; i < num_mods; i++) {
0250             ret = avs_cldma_load_module(adev, &mods[i]);
0251             if (ret)
0252                 return ret;
0253         }
0254
0255         return 0;
0256     }
0257
0258     mod_ids = kcalloc(num_mods, sizeof(u16), GFP_KERNEL);
0259     if (!mod_ids)
0260         return -ENOMEM;
0261
0262     for (i = 0; i < num_mods; i++)
0263         mod_ids[i] = mods[i].module_id;
0264
0265     ret = avs_ipc_unload_modules(adev, mod_ids, num_mods);
0266     kfree(mod_ids);
0267     if (ret)
0268         return AVS_IPC_RET(ret);
0269
0270     return 0;
0271 }
0272
0273 static int
0274 avs_hda_init_rom(struct avs_dev *adev, unsigned int dma_id, bool purge)
0275 {
0276     const struct avs_spec *const spec = adev->spec;
0277     unsigned int corex_mask, reg;
0278     int ret;
0279
0280     corex_mask = spec->core_init_mask & ~AVS_MAIN_CORE_MASK;
0281
0282     ret = avs_dsp_op(adev, power, spec->core_init_mask, true);
0283     if (ret < 0)
0284         goto err;
0285
0286     ret = avs_dsp_op(adev, reset, AVS_MAIN_CORE_MASK, false);
0287     if (ret < 0)
0288         goto err;
0289
0290     reinit_completion(&adev->fw_ready);
0291     avs_dsp_op(adev, int_control, true);
0292
0293     /* set boot config */
0294     ret = avs_ipc_set_boot_config(adev, dma_id, purge);
0295     if (ret) {
0296         ret = AVS_IPC_RET(ret);
0297         goto err;
0298     }
0299
0300     /* await ROM init */
0301     ret = snd_hdac_adsp_readq_poll(adev, spec->rom_status, reg,
0302                        (reg & 0xF) == AVS_ROM_INIT_DONE ||
0303                        (reg & 0xF) == APL_ROM_FW_ENTERED,
0304                        AVS_ROM_INIT_POLLING_US, APL_ROM_INIT_TIMEOUT_US);
0305     if (ret < 0) {
0306         dev_err(adev->dev, "rom init timeout: %d\n", ret);
0307         goto err;
0308     }
0309
0310     /* power down non-main cores */
0311     if (corex_mask) {
0312         ret = avs_dsp_op(adev, power, corex_mask, false);
0313         if (ret < 0)
0314             goto err;
0315     }
0316
0317     return 0;
0318
0319 err:
0320     avs_dsp_core_disable(adev, spec->core_init_mask);
0321     return ret;
0322 }
0323
0324 static int avs_imr_load_basefw(struct avs_dev *adev)
0325 {
0326     int ret;
0327
0328     /* DMA id ignored when flashing from IMR as no transfer occurs. */
0329     ret = avs_hda_init_rom(adev, 0, false);
0330     if (ret < 0) {
0331         dev_err(adev->dev, "rom init failed: %d\n", ret);
0332         return ret;
0333     }
0334
0335     ret = wait_for_completion_timeout(&adev->fw_ready,
0336                       msecs_to_jiffies(AVS_FW_INIT_TIMEOUT_MS));
0337     if (!ret) {
0338         dev_err(adev->dev, "firmware ready timeout\n");
0339         avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
0340         return -ETIMEDOUT;
0341     }
0342
0343     return 0;
0344 }
0345
0346 int avs_hda_load_basefw(struct avs_dev *adev, struct firmware *fw)
0347 {
0348     struct snd_pcm_substream substream;
0349     struct snd_dma_buffer dmab;
0350     struct hdac_ext_stream *estream;
0351     struct hdac_stream *hstream;
0352     struct hdac_bus *bus = &adev->base.core;
0353     unsigned int sdfmt, reg;
0354     int ret, i;
0355
0356     /* configure hda dma */
0357     memset(&substream, 0, sizeof(substream));
0358     substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
0359     estream = snd_hdac_ext_stream_assign(bus, &substream,
0360                          HDAC_EXT_STREAM_TYPE_HOST);
0361     if (!estream)
0362         return -ENODEV;
0363     hstream = hdac_stream(estream);
0364
0365     /* code loading performed with default format */
0366     sdfmt = snd_hdac_calc_stream_format(48000, 1, SNDRV_PCM_FORMAT_S32_LE, 32, 0);
0367     ret = snd_hdac_dsp_prepare(hstream, sdfmt, fw->size, &dmab);
0368     if (ret < 0)
0369         goto release_stream;
0370
0371     /* enable SPIB for hda stream */
0372     snd_hdac_ext_stream_spbcap_enable(bus, true, hstream->index);
0373     ret = snd_hdac_ext_stream_set_spib(bus, estream, fw->size);
0374     if (ret)
0375         goto cleanup_resources;
0376
0377     memcpy(dmab.area, fw->data, fw->size);
0378
0379     for (i = 0; i < APL_ROM_INIT_RETRIES; i++) {
0380         unsigned int dma_id = hstream->stream_tag - 1;
0381
0382         ret = avs_hda_init_rom(adev, dma_id, true);
0383         if (!ret)
0384             break;
0385         dev_info(adev->dev, "#%d rom init fail: %d\n", i + 1, ret);
0386     }
0387     if (ret < 0)
0388         goto cleanup_resources;
0389
0390     /* transfer firmware */
0391     snd_hdac_dsp_trigger(hstream, true);
0392     ret = snd_hdac_adsp_readl_poll(adev, AVS_FW_REG_STATUS(adev), reg,
0393                        (reg & AVS_ROM_STS_MASK) == APL_ROM_FW_ENTERED,
0394                        AVS_FW_INIT_POLLING_US, AVS_FW_INIT_TIMEOUT_US);
0395     snd_hdac_dsp_trigger(hstream, false);
0396     if (ret < 0) {
0397         dev_err(adev->dev, "transfer fw failed: %d\n", ret);
0398         avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
0399     }
0400
0401 cleanup_resources:
0402     /* disable SPIB for hda stream */
0403     snd_hdac_ext_stream_spbcap_enable(bus, false, hstream->index);
0404     snd_hdac_ext_stream_set_spib(bus, estream, 0);
0405
0406     snd_hdac_dsp_cleanup(hstream, &dmab);
0407 release_stream:
0408     snd_hdac_ext_stream_release(estream, HDAC_EXT_STREAM_TYPE_HOST);
0409
0410     return ret;
0411 }
0412
0413 int avs_hda_load_library(struct avs_dev *adev, struct firmware *lib, u32 id)
0414 {
0415     struct snd_pcm_substream substream;
0416     struct snd_dma_buffer dmab;
0417     struct hdac_ext_stream *estream;
0418     struct hdac_stream *stream;
0419     struct hdac_bus *bus = &adev->base.core;
0420     unsigned int sdfmt;
0421     int ret;
0422
0423     /* configure hda dma */
0424     memset(&substream, 0, sizeof(substream));
0425     substream.stream = SNDRV_PCM_STREAM_PLAYBACK;
0426     estream = snd_hdac_ext_stream_assign(bus, &substream,
0427                          HDAC_EXT_STREAM_TYPE_HOST);
0428     if (!estream)
0429         return -ENODEV;
0430     stream = hdac_stream(estream);
0431
0432     /* code loading performed with default format */
0433     sdfmt = snd_hdac_calc_stream_format(48000, 1, SNDRV_PCM_FORMAT_S32_LE, 32, 0);
0434     ret = snd_hdac_dsp_prepare(stream, sdfmt, lib->size, &dmab);
0435     if (ret < 0)
0436         goto release_stream;
0437
0438     /* enable SPIB for hda stream */
0439     snd_hdac_ext_stream_spbcap_enable(bus, true, stream->index);
0440     snd_hdac_ext_stream_set_spib(bus, estream, lib->size);
0441
0442     memcpy(dmab.area, lib->data, lib->size);
0443
0444     /* transfer firmware */
0445     snd_hdac_dsp_trigger(stream, true);
0446     ret = avs_ipc_load_library(adev, stream->stream_tag - 1, id);
0447     snd_hdac_dsp_trigger(stream, false);
0448     if (ret) {
0449         dev_err(adev->dev, "transfer lib %d failed: %d\n", id, ret);
0450         ret = AVS_IPC_RET(ret);
0451     }
0452
0453     /* disable SPIB for hda stream */
0454     snd_hdac_ext_stream_spbcap_enable(bus, false, stream->index);
0455     snd_hdac_ext_stream_set_spib(bus, estream, 0);
0456
0457     snd_hdac_dsp_cleanup(stream, &dmab);
0458 release_stream:
0459     snd_hdac_ext_stream_release(estream, HDAC_EXT_STREAM_TYPE_HOST);
0460
0461     return ret;
0462 }
0463
0464 int avs_hda_transfer_modules(struct avs_dev *adev, bool load,
0465                  struct avs_module_entry *mods, u32 num_mods)
0466 {
0467     /*
0468      * All platforms without CLDMA are equipped with IMR,
0469      * and thus the module transferring is offloaded to DSP.
0470      */
0471     return 0;
0472 }
0473
0474 int avs_dsp_load_libraries(struct avs_dev *adev, struct avs_tplg_library *libs, u32 num_libs)
0475 {
0476     int start, id, i = 0;
0477     int ret;
0478
0479     /* Calculate the id to assign for the next lib. */
0480     for (id = 0; id < adev->fw_cfg.max_libs_count; id++)
0481         if (adev->lib_names[id][0] == '\0')
0482             break;
0483     if (id + num_libs >= adev->fw_cfg.max_libs_count)
0484         return -EINVAL;
0485
0486     start = id;
0487     while (i < num_libs) {
0488         struct avs_fw_manifest *man;
0489         const struct firmware *fw;
0490         struct firmware stripped_fw;
0491         char *filename;
0492         int j;
0493
0494         filename = kasprintf(GFP_KERNEL, "%s/%s/%s", AVS_ROOT_DIR, adev->spec->name,
0495                      libs[i].name);
0496         if (!filename)
0497             return -ENOMEM;
0498
0499         /*
0500          * If any call after this one fails, requested firmware is not released with
0501          * avs_release_last_firmware() as failing to load code results in need for reload
0502          * of entire driver module. And then avs_release_firmwares() is in place already.
0503          */
0504         ret = avs_request_firmware(adev, &fw, filename);
0505         kfree(filename);
0506         if (ret < 0)
0507             return ret;
0508
0509         stripped_fw = *fw;
0510         ret = avs_fw_manifest_strip_verify(adev, &stripped_fw, NULL);
0511         if (ret) {
0512             dev_err(adev->dev, "invalid library data: %d\n", ret);
0513             return ret;
0514         }
0515
0516         ret = avs_fw_manifest_offset(&stripped_fw);
0517         if (ret < 0)
0518             return ret;
0519         man = (struct avs_fw_manifest *)(stripped_fw.data + ret);
0520
0521         /* Don't load anything that's already in DSP memory. */
0522         for (j = 0; j < id; j++)
0523             if (!strncmp(adev->lib_names[j], man->name, AVS_LIB_NAME_SIZE))
0524                 goto next_lib;
0525
0526         ret = avs_dsp_op(adev, load_lib, &stripped_fw, id);
0527         if (ret)
0528             return ret;
0529
0530         strncpy(adev->lib_names[id], man->name, AVS_LIB_NAME_SIZE);
0531         id++;
0532 next_lib:
0533         i++;
0534     }
0535
0536     return start == id ? 1 : 0;
0537 }
0538
0539 static int avs_dsp_load_basefw(struct avs_dev *adev)
0540 {
0541     const struct avs_fw_version *min_req;
0542     const struct avs_spec *const spec = adev->spec;
0543     const struct firmware *fw;
0544     struct firmware stripped_fw;
0545     char *filename;
0546     int ret;
0547
0548     filename = kasprintf(GFP_KERNEL, "%s/%s/%s", AVS_ROOT_DIR, spec->name, AVS_BASEFW_FILENAME);
0549     if (!filename)
0550         return -ENOMEM;
0551
0552     ret = avs_request_firmware(adev, &fw, filename);
0553     kfree(filename);
0554     if (ret < 0) {
0555         dev_err(adev->dev, "request firmware failed: %d\n", ret);
0556         return ret;
0557     }
0558
0559     stripped_fw = *fw;
0560     min_req = &adev->spec->min_fw_version;
0561
0562     ret = avs_fw_manifest_strip_verify(adev, &stripped_fw, min_req);
0563     if (ret < 0) {
0564         dev_err(adev->dev, "invalid firmware data: %d\n", ret);
0565         goto release_fw;
0566     }
0567
0568     ret = avs_dsp_op(adev, load_basefw, &stripped_fw);
0569     if (ret < 0) {
0570         dev_err(adev->dev, "basefw load failed: %d\n", ret);
0571         goto release_fw;
0572     }
0573
0574     ret = wait_for_completion_timeout(&adev->fw_ready,
0575                       msecs_to_jiffies(AVS_FW_INIT_TIMEOUT_MS));
0576     if (!ret) {
0577         dev_err(adev->dev, "firmware ready timeout\n");
0578         avs_dsp_core_disable(adev, AVS_MAIN_CORE_MASK);
0579         ret = -ETIMEDOUT;
0580         goto release_fw;
0581     }
0582
0583     return 0;
0584
0585 release_fw:
0586     avs_release_last_firmware(adev);
0587     return ret;
0588 }
0589
0590 int avs_dsp_boot_firmware(struct avs_dev *adev, bool purge)
0591 {
0592     struct avs_soc_component *acomp;
0593     int ret, i;
0594
0595     /* Forgo full boot if flash from IMR succeeds. */
0596     if (!purge && avs_platattr_test(adev, IMR)) {
0597         ret = avs_imr_load_basefw(adev);
0598         if (!ret)
0599             return 0;
0600
0601         dev_dbg(adev->dev, "firmware flash from imr failed: %d\n", ret);
0602     }
0603
0604     /* Full boot, clear cached data except for basefw (slot 0). */
0605     for (i = 1; i < adev->fw_cfg.max_libs_count; i++)
0606         memset(adev->lib_names[i], 0, AVS_LIB_NAME_SIZE);
0607
0608     avs_hda_clock_gating_enable(adev, false);
0609     avs_hda_l1sen_enable(adev, false);
0610
0611     ret = avs_dsp_load_basefw(adev);
0612     if (ret)
0613         goto reenable_gating;
0614
0615     mutex_lock(&adev->comp_list_mutex);
0616     list_for_each_entry(acomp, &adev->comp_list, node) {
0617         struct avs_tplg *tplg = acomp->tplg;
0618
0619         ret = avs_dsp_load_libraries(adev, tplg->libs, tplg->num_libs);
0620         if (ret < 0)
0621             break;
0622     }
0623     mutex_unlock(&adev->comp_list_mutex);
0624
0625 reenable_gating:
0626     avs_hda_l1sen_enable(adev, true);
0627     avs_hda_clock_gating_enable(adev, true);
0628
0629     if (ret < 0)
0630         return ret;
0631
0632     /* With all code loaded, refresh module information. */
0633     ret = avs_module_info_init(adev, true);
0634     if (ret) {
0635         dev_err(adev->dev, "init module info failed: %d\n", ret);
0636         return ret;
0637     }
0638
0639     return 0;
0640 }
0641
0642 int avs_dsp_first_boot_firmware(struct avs_dev *adev)
0643 {
0644     int ret, i;
0645
0646     if (avs_platattr_test(adev, CLDMA)) {
0647         ret = hda_cldma_init(&code_loader, &adev->base.core,
0648                      adev->dsp_ba, AVS_CL_DEFAULT_BUFFER_SIZE);
0649         if (ret < 0) {
0650             dev_err(adev->dev, "cldma init failed: %d\n", ret);
0651             return ret;
0652         }
0653     }
0654
0655     ret = avs_dsp_boot_firmware(adev, true);
0656     if (ret < 0) {
0657         dev_err(adev->dev, "firmware boot failed: %d\n", ret);
0658         return ret;
0659     }
0660
0661     ret = avs_ipc_get_hw_config(adev, &adev->hw_cfg);
0662     if (ret) {
0663         dev_err(adev->dev, "get hw cfg failed: %d\n", ret);
0664         return AVS_IPC_RET(ret);
0665     }
0666
0667     ret = avs_ipc_get_fw_config(adev, &adev->fw_cfg);
0668     if (ret) {
0669         dev_err(adev->dev, "get fw cfg failed: %d\n", ret);
0670         return AVS_IPC_RET(ret);
0671     }
0672
0673     adev->core_refs = devm_kcalloc(adev->dev, adev->hw_cfg.dsp_cores,
0674                        sizeof(*adev->core_refs), GFP_KERNEL);
0675     adev->lib_names = devm_kcalloc(adev->dev, adev->fw_cfg.max_libs_count,
0676                        sizeof(*adev->lib_names), GFP_KERNEL);
0677     if (!adev->core_refs || !adev->lib_names)
0678         return -ENOMEM;
0679
0680     for (i = 0; i < adev->fw_cfg.max_libs_count; i++) {
0681         adev->lib_names[i] = devm_kzalloc(adev->dev, AVS_LIB_NAME_SIZE, GFP_KERNEL);
0682         if (!adev->lib_names[i])
0683             return -ENOMEM;
0684     }
0685
0686     /* basefw always occupies slot 0 */
0687     strcpy(&adev->lib_names[0][0], "BASEFW");
0688
0689     ida_init(&adev->ppl_ida);
0690
0691     return 0;
0692 }