1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Copyright(c) 2021-2022 Intel Corporation
4 //
5 // Authors: Cezary Rojewski <[email protected]>
6 // Amadeusz Slawinski <[email protected]>
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
avs_fw_ext_manifest_strip(struct firmware * fw)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
avs_fw_manifest_offset(struct firmware * fw)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
avs_fw_manifest_strip_verify(struct avs_dev * adev,struct firmware * fw,const struct avs_fw_version * min)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
avs_cldma_load_basefw(struct avs_dev * adev,struct firmware * fw)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
avs_cldma_load_library(struct avs_dev * adev,struct firmware * lib,u32 id)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
avs_cldma_load_module(struct avs_dev * adev,struct avs_module_entry * mentry)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
avs_cldma_transfer_modules(struct avs_dev * adev,bool load,struct avs_module_entry * mods,u32 num_mods)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
avs_hda_init_rom(struct avs_dev * adev,unsigned int dma_id,bool purge)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
avs_imr_load_basefw(struct avs_dev * adev)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
avs_hda_load_basefw(struct avs_dev * adev,struct firmware * fw)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
avs_hda_load_library(struct avs_dev * adev,struct firmware * lib,u32 id)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
avs_hda_transfer_modules(struct avs_dev * adev,bool load,struct avs_module_entry * mods,u32 num_mods)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
avs_dsp_load_libraries(struct avs_dev * adev,struct avs_tplg_library * libs,u32 num_libs)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
avs_dsp_load_basefw(struct avs_dev * adev)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
avs_dsp_boot_firmware(struct avs_dev * adev,bool purge)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
avs_dsp_first_boot_firmware(struct avs_dev * adev)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