// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)//// This file is provided under a dual BSD/GPLv2 license.  When using or// redistributing this file, you may do so under either license.//// Copyright(c) 2018 Intel Corporation//// Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>//// Generic firmware loader.// #include <linux/firmware.h>#include "sof-priv.h"#include "ops.h" int snd_sof_load_firmware_raw(struct snd_sof_dev *sdev){	struct snd_sof_pdata *plat_data = sdev->pdata;	const char *fw_filename;	ssize_t ext_man_size;	int ret; 	/* Don't request firmware again if firmware is already requested */	if (sdev->basefw.fw)		return 0; 	fw_filename = kasprintf(GFP_KERNEL, "%s/%s",				plat_data->fw_filename_prefix,				plat_data->fw_filename);	if (!fw_filename)		return -ENOMEM; 	ret = request_firmware(&sdev->basefw.fw, fw_filename, sdev->dev); 	if (ret < 0) {		dev_err(sdev->dev,			"error: sof firmware file is missing, you might need to\n");		dev_err(sdev->dev,			"       download it from https://github.com/thesofproject/sof-bin/\n");		goto err;	} else {		dev_dbg(sdev->dev, "request_firmware %s successful\n",			fw_filename);	} 	/* check for extended manifest */	ext_man_size = sdev->ipc->ops->fw_loader->parse_ext_manifest(sdev);	if (ext_man_size > 0) {		/* when no error occurred, drop extended manifest */		sdev->basefw.payload_offset = ext_man_size;	} else if (!ext_man_size) {		/* No extended manifest, so nothing to skip during FW load */		dev_dbg(sdev->dev, "firmware doesn't contain extended manifest\n");	} else {		ret = ext_man_size;		dev_err(sdev->dev, "error: firmware %s contains unsupported or invalid extended manifest: %d\n",			fw_filename, ret);	} err:	kfree(fw_filename); 	return ret;}EXPORT_SYMBOL(snd_sof_load_firmware_raw); int snd_sof_load_firmware_memcpy(struct snd_sof_dev *sdev){	int ret; 	ret = snd_sof_load_firmware_raw(sdev);	if (ret < 0)		return ret; 	/* make sure the FW header and file is valid */	ret = sdev->ipc->ops->fw_loader->validate(sdev);	if (ret < 0) {		dev_err(sdev->dev, "error: invalid FW header\n");		goto error;	} 	/* prepare the DSP for FW loading */	ret = snd_sof_dsp_reset(sdev);	if (ret < 0) {		dev_err(sdev->dev, "error: failed to reset DSP\n");		goto error;	} 	/* parse and load firmware modules to DSP */	if (sdev->ipc->ops->fw_loader->load_fw_to_dsp) {		ret = sdev->ipc->ops->fw_loader->load_fw_to_dsp(sdev);		if (ret < 0) {			dev_err(sdev->dev, "Firmware loading failed\n");			goto error;		}	} 	return 0; error:	release_firmware(sdev->basefw.fw);	sdev->basefw.fw = NULL;	return ret; }EXPORT_SYMBOL(snd_sof_load_firmware_memcpy); int snd_sof_run_firmware(struct snd_sof_dev *sdev){	int ret; 	init_waitqueue_head(&sdev->boot_wait); 	/* (re-)enable dsp dump */	sdev->dbg_dump_printed = false;	sdev->ipc_dump_printed = false; 	/* create read-only fw_version debugfs to store boot version info */	if (sdev->first_boot) {		ret = snd_sof_debugfs_buf_item(sdev, &sdev->fw_version,					       sizeof(sdev->fw_version),					       "fw_version", 0444);		/* errors are only due to memory allocation, not debugfs */		if (ret < 0) {			dev_err(sdev->dev, "snd_sof_debugfs_buf_item failed\n");			return ret;		}	} 	/* perform pre fw run operations */	ret = snd_sof_dsp_pre_fw_run(sdev);	if (ret < 0) {		dev_err(sdev->dev, "failed pre fw run op\n");		return ret;	} 	dev_dbg(sdev->dev, "booting DSP firmware\n"); 	/* boot the firmware on the DSP */	ret = snd_sof_dsp_run(sdev);	if (ret < 0) {		snd_sof_dsp_dbg_dump(sdev, "Failed to start DSP",				     SOF_DBG_DUMP_MBOX | SOF_DBG_DUMP_PCI);		return ret;	} 	/*	 * now wait for the DSP to boot. There are 3 possible outcomes:	 * 1. Boot wait times out indicating FW boot failure.	 * 2. FW boots successfully and fw_ready op succeeds.	 * 3. FW boots but fw_ready op fails.	 */	ret = wait_event_timeout(sdev->boot_wait,				 sdev->fw_state > SOF_FW_BOOT_IN_PROGRESS,				 msecs_to_jiffies(sdev->boot_timeout));	if (ret == 0) {		snd_sof_dsp_dbg_dump(sdev, "Firmware boot failure due to timeout",				     SOF_DBG_DUMP_REGS | SOF_DBG_DUMP_MBOX |				     SOF_DBG_DUMP_TEXT | SOF_DBG_DUMP_PCI);		return -EIO;	} 	if (sdev->fw_state == SOF_FW_BOOT_READY_FAILED)		return -EIO; /* FW boots but fw_ready op failed */ 	dev_dbg(sdev->dev, "firmware boot complete\n");	sof_set_fw_state(sdev, SOF_FW_BOOT_COMPLETE); 	/* perform post fw run operations */	ret = snd_sof_dsp_post_fw_run(sdev);	if (ret < 0) {		dev_err(sdev->dev, "error: failed post fw run op\n");		return ret;	} 	if (sdev->ipc->ops->post_fw_boot)		return sdev->ipc->ops->post_fw_boot(sdev); 	return 0;}EXPORT_SYMBOL(snd_sof_run_firmware); void snd_sof_fw_unload(struct snd_sof_dev *sdev){	/* TODO: support module unloading at runtime */	release_firmware(sdev->basefw.fw);	sdev->basefw.fw = NULL;}EXPORT_SYMBOL(snd_sof_fw_unload);