Quelle  loader.c   Sprache: C

// 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);