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 "sof-priv.h" 15 #include "ops.h" 16 17 int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev) 18 { 19 struct snd_sof_pdata *plat_data = sdev->pdata; 20 const char *fw_filename; 21 ssize_t ext_man_size; 22 int ret; 23 24 /* Don't request firmware again if firmware is already requested */ 25 if (plat_data->fw) 26 return 0; 27 28 fw_filename = kasprintf(GFP_KERNEL, "%s/%s", 29 plat_data->fw_filename_prefix, 30 plat_data->fw_filename); 31 if (!fw_filename) 32 return -ENOMEM; 33 34 ret = request_firmware(&plat_data->fw, fw_filename, sdev->dev); 35 36 if (ret < 0) { 37 dev_err(sdev->dev, 38 "error: sof firmware file is missing, you might need to\n"); 39 dev_err(sdev->dev, 40 " download it from https://github.com/thesofproject/sof-bin/\n"); 41 goto err; 42 } else { 43 dev_dbg(sdev->dev, "request_firmware %s successful\n", 44 fw_filename); 45 } 46 47 /* check for extended manifest */ 48 ext_man_size = sdev->ipc->ops->fw_loader->parse_ext_manifest(sdev); 49 if (ext_man_size > 0) { 50 /* when no error occurred, drop extended manifest */ 51 plat_data->fw_offset = ext_man_size; 52 } else if (!ext_man_size) { 53 /* No extended manifest, so nothing to skip during FW load */ 54 dev_dbg(sdev->dev, "firmware doesn't contain extended manifest\n"); 55 } else { 56 ret = ext_man_size; 57 dev_err(sdev->dev, "error: firmware %s contains unsupported or invalid extended manifest: %d\n", 58 fw_filename, ret); 59 } 60 61 err: 62 kfree(fw_filename); 63 64 return ret; 65 } 66 EXPORT_SYMBOL(snd_sof_load_firmware_raw); 67 68 int snd_sof_load_firmware_memcpy(struct snd_sof_dev *sdev) 69 { 70 struct snd_sof_pdata *plat_data = sdev->pdata; 71 int ret; 72 73 ret = snd_sof_load_firmware_raw(sdev); 74 if (ret < 0) 75 return ret; 76 77 /* make sure the FW header and file is valid */ 78 ret = sdev->ipc->ops->fw_loader->validate(sdev); 79 if (ret < 0) { 80 dev_err(sdev->dev, "error: invalid FW header\n"); 81 goto error; 82 } 83 84 /* prepare the DSP for FW loading */ 85 ret = snd_sof_dsp_reset(sdev); 86 if (ret < 0) { 87 dev_err(sdev->dev, "error: failed to reset DSP\n"); 88 goto error; 89 } 90 91 /* parse and load firmware modules to DSP */ 92 if (sdev->ipc->ops->fw_loader->load_fw_to_dsp) { 93 ret = sdev->ipc->ops->fw_loader->load_fw_to_dsp(sdev); 94 if (ret < 0) { 95 dev_err(sdev->dev, "Firmware loading failed\n"); 96 goto error; 97 } 98 } 99 100 return 0; 101 102 error: 103 release_firmware(plat_data->fw); 104 plat_data->fw = NULL; 105 return ret; 106 107 } 108 EXPORT_SYMBOL(snd_sof_load_firmware_memcpy); 109 110 int snd_sof_run_firmware(struct snd_sof_dev *sdev) 111 { 112 int ret; 113 114 init_waitqueue_head(&sdev->boot_wait); 115 116 /* (re-)enable dsp dump */ 117 sdev->dbg_dump_printed = false; 118 sdev->ipc_dump_printed = false; 119 120 /* create read-only fw_version debugfs to store boot version info */ 121 if (sdev->first_boot) { 122 ret = snd_sof_debugfs_buf_item(sdev, &sdev->fw_version, 123 sizeof(sdev->fw_version), 124 "fw_version", 0444); 125 /* errors are only due to memory allocation, not debugfs */ 126 if (ret < 0) { 127 dev_err(sdev->dev, "error: snd_sof_debugfs_buf_item failed\n"); 128 return ret; 129 } 130 } 131 132 /* perform pre fw run operations */ 133 ret = snd_sof_dsp_pre_fw_run(sdev); 134 if (ret < 0) { 135 dev_err(sdev->dev, "error: failed pre fw run op\n"); 136 return ret; 137 } 138 139 dev_dbg(sdev->dev, "booting DSP firmware\n"); 140 141 /* boot the firmware on the DSP */ 142 ret = snd_sof_dsp_run(sdev); 143 if (ret < 0) { 144 snd_sof_dsp_dbg_dump(sdev, "Failed to start DSP", 145 SOF_DBG_DUMP_MBOX | SOF_DBG_DUMP_PCI); 146 return ret; 147 } 148 149 /* 150 * now wait for the DSP to boot. There are 3 possible outcomes: 151 * 1. Boot wait times out indicating FW boot failure. 152 * 2. FW boots successfully and fw_ready op succeeds. 153 * 3. FW boots but fw_ready op fails. 154 */ 155 ret = wait_event_timeout(sdev->boot_wait, 156 sdev->fw_state > SOF_FW_BOOT_IN_PROGRESS, 157 msecs_to_jiffies(sdev->boot_timeout)); 158 if (ret == 0) { 159 snd_sof_dsp_dbg_dump(sdev, "Firmware boot failure due to timeout", 160 SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX | 161 SOF_DBG_DUMP_TEXT | SOF_DBG_DUMP_PCI); 162 return -EIO; 163 } 164 165 if (sdev->fw_state == SOF_FW_BOOT_READY_FAILED) 166 return -EIO; /* FW boots but fw_ready op failed */ 167 168 /* perform post fw run operations */ 169 ret = snd_sof_dsp_post_fw_run(sdev); 170 if (ret < 0) { 171 dev_err(sdev->dev, "error: failed post fw run op\n"); 172 return ret; 173 } 174 175 dev_dbg(sdev->dev, "firmware boot complete\n"); 176 sof_set_fw_state(sdev, SOF_FW_BOOT_COMPLETE); 177 178 if (sdev->first_boot && sdev->ipc->ops->fw_loader->query_fw_configuration) 179 return sdev->ipc->ops->fw_loader->query_fw_configuration(sdev); 180 181 return 0; 182 } 183 EXPORT_SYMBOL(snd_sof_run_firmware); 184 185 void snd_sof_fw_unload(struct snd_sof_dev *sdev) 186 { 187 /* TODO: support module unloading at runtime */ 188 release_firmware(sdev->pdata->fw); 189 sdev->pdata->fw = NULL; 190 } 191 EXPORT_SYMBOL(snd_sof_fw_unload); 192