sof/ipc4-loader.c

   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) 2022 Intel Corporation. All rights reserved.
   7
   8 #include <linux/firmware.h>
   9 #include <sound/sof/ext_manifest4.h>
  10 #include <sound/sof/ipc4/header.h>
  11 #include <trace/events/sof.h>
  12 #include "ipc4-priv.h"
  13 #include "sof-audio.h"
  14 #include "sof-priv.h"
  15 #include "ops.h"
  16
  17 static size_t sof_ipc4_fw_parse_ext_man(struct snd_sof_dev *sdev)
  18 {
  19         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
  20         struct sof_man4_fw_binary_header *fw_header;
  21         const struct firmware *fw = sdev->basefw.fw;
  22         struct sof_ext_manifest4_hdr *ext_man_hdr;
  23         struct sof_man4_module_config *fm_config;
  24         struct sof_ipc4_fw_module *fw_module;
  25         struct sof_man4_module *fm_entry;
  26         ssize_t remaining;
  27         u32 fw_hdr_offset;
  28         int i;
  29
  30         if (!ipc4_data) {
  31                 dev_err(sdev->dev, "%s: ipc4_data is not available\n", __func__);
  32                 return -EINVAL;
  33         }
  34
  35         remaining = fw->size;
  36         if (remaining <= sizeof(*ext_man_hdr)) {
  37                 dev_err(sdev->dev, "Firmware size is too small: %zu\n", remaining);
  38                 return -EINVAL;
  39         }
  40
  41         ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
  42
  43         /*
  44          * At the start of the firmware image we must have an extended manifest.
  45          * Verify that the magic number is correct.
  46          */
  47         if (ext_man_hdr->id != SOF_EXT_MAN4_MAGIC_NUMBER) {
  48                 dev_err(sdev->dev,
  49                         "Unexpected extended manifest magic number: %#x\n",
  50                         ext_man_hdr->id);
  51                 return -EINVAL;
  52         }
  53
  54         fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
  55         if (!fw_hdr_offset)
  56                 return -EINVAL;
  57
  58         if (remaining <= ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header)) {
  59                 dev_err(sdev->dev, "Invalid firmware size %zu, should be at least %zu\n",
  60                         remaining, ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header));
  61                 return -EINVAL;
  62         }
  63
  64         fw_header = (struct sof_man4_fw_binary_header *)
  65                                 (fw->data + ext_man_hdr->len + fw_hdr_offset);
  66         remaining -= (ext_man_hdr->len + fw_hdr_offset);
  67
  68         if (remaining <= fw_header->len) {
  69                 dev_err(sdev->dev, "Invalid fw_header->len %u\n", fw_header->len);
  70                 return -EINVAL;
  71         }
  72
  73         dev_info(sdev->dev, "Loaded firmware version: %u.%u.%u.%u\n",
  74                  fw_header->major_version, fw_header->minor_version,
  75                  fw_header->hotfix_version, fw_header->build_version);
  76         dev_dbg(sdev->dev, "Firmware name: %s, header length: %u, module count: %u\n",
  77                 fw_header->name, fw_header->len, fw_header->num_module_entries);
  78
  79         ipc4_data->fw_modules = devm_kmalloc_array(sdev->dev,
  80                                                    fw_header->num_module_entries,
  81                                                    sizeof(*fw_module), GFP_KERNEL);
  82         if (!ipc4_data->fw_modules)
  83                 return -ENOMEM;
  84
  85         ipc4_data->num_fw_modules = fw_header->num_module_entries;
  86         fw_module = ipc4_data->fw_modules;
  87
  88         fm_entry = (struct sof_man4_module *)((u8 *)fw_header + fw_header->len);
  89         remaining -= fw_header->len;
  90
  91         if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {
  92                 dev_err(sdev->dev, "Invalid num_module_entries %u\n",
  93                         fw_header->num_module_entries);
  94                 return -EINVAL;
  95         }
  96
  97         fm_config = (struct sof_man4_module_config *)
  98                                 (fm_entry + fw_header->num_module_entries);
  99         remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));
 100         for (i = 0; i < fw_header->num_module_entries; i++) {
 101                 memcpy(&fw_module->man4_module_entry, fm_entry, sizeof(*fm_entry));
 102
 103                 if (fm_entry->cfg_count) {
 104                         if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *
 105                             sizeof(*fm_config)) {
 106                                 dev_err(sdev->dev, "Invalid module cfg_offset %u\n",
 107                                         fm_entry->cfg_offset);
 108                                 return -EINVAL;
 109                         }
 110
 111                         /* a module's config is always the same size */
 112                         fw_module->bss_size = fm_config[fm_entry->cfg_offset].is_bytes;
 113
 114                         dev_dbg(sdev->dev,
 115                                 "module %s: UUID %pUL cfg_count: %u, bss_size: %#x\n",
 116                                 fm_entry->name, &fm_entry->uuid, fm_entry->cfg_count,
 117                                 fw_module->bss_size);
 118                 } else {
 119                         fw_module->bss_size = 0;
 120
 121                         dev_dbg(sdev->dev, "module %s: UUID %pUL\n", fm_entry->name,
 122                                 &fm_entry->uuid);
 123                 }
 124
 125                 fw_module->man4_module_entry.id = i;
 126                 ida_init(&fw_module->m_ida);
 127                 fw_module->private = NULL;
 128
 129                 fw_module++;
 130                 fm_entry++;
 131         }
 132
 133         return ext_man_hdr->len;
 134 }
 135
 136 static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
 137 {
 138         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 139         u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
 140         struct sof_man4_fw_binary_header *fw_header;
 141         const struct firmware *fw = sdev->basefw.fw;
 142         struct sof_ext_manifest4_hdr *ext_man_hdr;
 143
 144         ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
 145         fw_header = (struct sof_man4_fw_binary_header *)
 146                                 (fw->data + ext_man_hdr->len + fw_hdr_offset);
 147
 148         /* TODO: Add firmware verification code here */
 149
 150         dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
 151                 fw_header->major_version, fw_header->minor_version,
 152                 fw_header->hotfix_version, fw_header->build_version);
 153
 154         return 0;
 155 }
 156
 157 static int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
 158 {
 159         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 160         const struct sof_ipc_ops *iops = sdev->ipc->ops;
 161         struct sof_ipc4_fw_version *fw_ver;
 162         struct sof_ipc4_tuple *tuple;
 163         struct sof_ipc4_msg msg;
 164         size_t offset = 0;
 165         int ret;
 166
 167         /* Get the firmware configuration */
 168         msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
 169         msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 170         msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
 171         msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
 172         msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
 173
 174         msg.data_size = sdev->ipc->max_payload_size;
 175         msg.data_ptr = kzalloc(msg.data_size, GFP_KERNEL);
 176         if (!msg.data_ptr)
 177                 return -ENOMEM;
 178
 179         ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
 180         if (ret)
 181                 goto out;
 182
 183         while (offset < msg.data_size) {
 184                 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
 185
 186                 switch (tuple->type) {
 187                 case SOF_IPC4_FW_CFG_FW_VERSION:
 188                         fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
 189
 190                         dev_info(sdev->dev,
 191                                  "Booted firmware version: %u.%u.%u.%u\n",
 192                                  fw_ver->major, fw_ver->minor, fw_ver->hotfix,
 193                                  fw_ver->build);
 194                         break;
 195                 case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
 196                         trace_sof_ipc4_fw_config(sdev, "DL mailbox size", *tuple->value);
 197                         break;
 198                 case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
 199                         trace_sof_ipc4_fw_config(sdev, "UL mailbox size", *tuple->value);
 200                         break;
 201                 case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
 202                         trace_sof_ipc4_fw_config(sdev, "Trace log size", *tuple->value);
 203                         ipc4_data->mtrace_log_bytes = *tuple->value;
 204                         break;
 205                 default:
 206                         break;
 207                 }
 208
 209                 offset += sizeof(*tuple) + tuple->size;
 210         }
 211
 212 out:
 213         kfree(msg.data_ptr);
 214
 215         return ret;
 216 }
 217
 218 const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
 219         .validate = sof_ipc4_validate_firmware,
 220         .parse_ext_manifest = sof_ipc4_fw_parse_ext_man,
 221         .query_fw_configuration = sof_ipc4_query_fw_configuration,
 222 };