sound/soc/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 /* The module ID includes the id of the library it is part of at offset 12 */
  18 #define SOF_IPC4_MOD_LIB_ID_SHIFT       12
  19
  20 static ssize_t sof_ipc4_fw_parse_ext_man(struct snd_sof_dev *sdev,
  21                                          struct sof_ipc4_fw_library *fw_lib)
  22 {
  23         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
  24         const struct firmware *fw = fw_lib->sof_fw.fw;
  25         struct sof_man4_fw_binary_header *fw_header;
  26         struct sof_ext_manifest4_hdr *ext_man_hdr;
  27         struct sof_man4_module_config *fm_config;
  28         struct sof_ipc4_fw_module *fw_module;
  29         struct sof_man4_module *fm_entry;
  30         ssize_t remaining;
  31         u32 fw_hdr_offset;
  32         int i;
  33
  34         if (!ipc4_data) {
  35                 dev_err(sdev->dev, "%s: ipc4_data is not available\n", __func__);
  36                 return -EINVAL;
  37         }
  38
  39         remaining = fw->size;
  40         if (remaining <= sizeof(*ext_man_hdr)) {
  41                 dev_err(sdev->dev, "Firmware size is too small: %zu\n", remaining);
  42                 return -EINVAL;
  43         }
  44
  45         ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
  46
  47         /*
  48          * At the start of the firmware image we must have an extended manifest.
  49          * Verify that the magic number is correct.
  50          */
  51         if (ext_man_hdr->id != SOF_EXT_MAN4_MAGIC_NUMBER) {
  52                 dev_err(sdev->dev,
  53                         "Unexpected extended manifest magic number: %#x\n",
  54                         ext_man_hdr->id);
  55                 return -EINVAL;
  56         }
  57
  58         fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
  59         if (!fw_hdr_offset)
  60                 return -EINVAL;
  61
  62         if (remaining <= ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header)) {
  63                 dev_err(sdev->dev, "Invalid firmware size %zu, should be at least %zu\n",
  64                         remaining, ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header));
  65                 return -EINVAL;
  66         }
  67
  68         fw_header = (struct sof_man4_fw_binary_header *)
  69                                 (fw->data + ext_man_hdr->len + fw_hdr_offset);
  70         remaining -= (ext_man_hdr->len + fw_hdr_offset);
  71
  72         if (remaining <= fw_header->len) {
  73                 dev_err(sdev->dev, "Invalid fw_header->len %u\n", fw_header->len);
  74                 return -EINVAL;
  75         }
  76
  77         dev_info(sdev->dev, "Loaded firmware library: %s, version: %u.%u.%u.%u\n",
  78                  fw_header->name, fw_header->major_version, fw_header->minor_version,
  79                  fw_header->hotfix_version, fw_header->build_version);
  80         dev_dbg(sdev->dev, "Header length: %u, module count: %u\n",
  81                 fw_header->len, fw_header->num_module_entries);
  82
  83         fw_lib->modules = devm_kmalloc_array(sdev->dev, fw_header->num_module_entries,
  84                                              sizeof(*fw_module), GFP_KERNEL);
  85         if (!fw_lib->modules)
  86                 return -ENOMEM;
  87
  88         fw_lib->name = fw_header->name;
  89         fw_lib->num_modules = fw_header->num_module_entries;
  90         fw_module = fw_lib->modules;
  91
  92         fm_entry = (struct sof_man4_module *)((u8 *)fw_header + fw_header->len);
  93         remaining -= fw_header->len;
  94
  95         if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {
  96                 dev_err(sdev->dev, "Invalid num_module_entries %u\n",
  97                         fw_header->num_module_entries);
  98                 return -EINVAL;
  99         }
 100
 101         fm_config = (struct sof_man4_module_config *)
 102                                 (fm_entry + fw_header->num_module_entries);
 103         remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));
 104         for (i = 0; i < fw_header->num_module_entries; i++) {
 105                 memcpy(&fw_module->man4_module_entry, fm_entry, sizeof(*fm_entry));
 106
 107                 if (fm_entry->cfg_count) {
 108                         if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *
 109                             sizeof(*fm_config)) {
 110                                 dev_err(sdev->dev, "Invalid module cfg_offset %u\n",
 111                                         fm_entry->cfg_offset);
 112                                 return -EINVAL;
 113                         }
 114
 115                         fw_module->fw_mod_cfg = &fm_config[fm_entry->cfg_offset];
 116
 117                         dev_dbg(sdev->dev,
 118                                 "module %s: UUID %pUL cfg_count: %u, bss_size: %#x\n",
 119                                 fm_entry->name, &fm_entry->uuid, fm_entry->cfg_count,
 120                                 fm_config[fm_entry->cfg_offset].is_bytes);
 121                 } else {
 122                         dev_dbg(sdev->dev, "module %s: UUID %pUL\n", fm_entry->name,
 123                                 &fm_entry->uuid);
 124                 }
 125
 126                 fw_module->man4_module_entry.id = i;
 127                 ida_init(&fw_module->m_ida);
 128                 fw_module->private = NULL;
 129
 130                 fw_module++;
 131                 fm_entry++;
 132         }
 133
 134         return ext_man_hdr->len;
 135 }
 136
 137 static size_t sof_ipc4_fw_parse_basefw_ext_man(struct snd_sof_dev *sdev)
 138 {
 139         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 140         struct sof_ipc4_fw_library *fw_lib;
 141         ssize_t payload_offset;
 142         int ret;
 143
 144         fw_lib = devm_kzalloc(sdev->dev, sizeof(*fw_lib), GFP_KERNEL);
 145         if (!fw_lib)
 146                 return -ENOMEM;
 147
 148         fw_lib->sof_fw.fw = sdev->basefw.fw;
 149
 150         payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
 151         if (payload_offset > 0) {
 152                 fw_lib->sof_fw.payload_offset = payload_offset;
 153
 154                 /* basefw ID is 0 */
 155                 fw_lib->id = 0;
 156                 ret = xa_insert(&ipc4_data->fw_lib_xa, 0, fw_lib, GFP_KERNEL);
 157                 if (ret)
 158                         return ret;
 159         }
 160
 161         return payload_offset;
 162 }
 163
 164 static int sof_ipc4_load_library_by_uuid(struct snd_sof_dev *sdev,
 165                                          unsigned long lib_id, const guid_t *uuid)
 166 {
 167         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 168         struct sof_ipc4_fw_library *fw_lib;
 169         const char *fw_filename;
 170         ssize_t payload_offset;
 171         int ret, i, err;
 172
 173         if (!sdev->pdata->fw_lib_prefix) {
 174                 dev_err(sdev->dev,
 175                         "Library loading is not supported due to not set library path\n");
 176                 return -EINVAL;
 177         }
 178
 179         if (!ipc4_data->load_library) {
 180                 dev_err(sdev->dev, "Library loading is not supported on this platform\n");
 181                 return -EOPNOTSUPP;
 182         }
 183
 184         fw_lib = devm_kzalloc(sdev->dev, sizeof(*fw_lib), GFP_KERNEL);
 185         if (!fw_lib)
 186                 return -ENOMEM;
 187
 188         fw_filename = kasprintf(GFP_KERNEL, "%s/%pUL.bin",
 189                                 sdev->pdata->fw_lib_prefix, uuid);
 190         if (!fw_filename) {
 191                 ret = -ENOMEM;
 192                 goto free_fw_lib;
 193         }
 194
 195         ret = request_firmware(&fw_lib->sof_fw.fw, fw_filename, sdev->dev);
 196         if (ret < 0) {
 197                 dev_err(sdev->dev, "Library file '%s' is missing\n", fw_filename);
 198                 goto free_filename;
 199         } else {
 200                 dev_dbg(sdev->dev, "Library file '%s' loaded\n", fw_filename);
 201         }
 202
 203         payload_offset = sof_ipc4_fw_parse_ext_man(sdev, fw_lib);
 204         if (payload_offset <= 0) {
 205                 if (!payload_offset)
 206                         ret = -EINVAL;
 207                 else
 208                         ret = payload_offset;
 209
 210                 goto release;
 211         }
 212
 213         fw_lib->sof_fw.payload_offset = payload_offset;
 214         fw_lib->id = lib_id;
 215
 216         /* Fix up the module ID numbers within the library */
 217         for (i = 0; i < fw_lib->num_modules; i++)
 218                 fw_lib->modules[i].man4_module_entry.id |= (lib_id << SOF_IPC4_MOD_LIB_ID_SHIFT);
 219
 220         /*
 221          * Make sure that the DSP is booted and stays up while attempting the
 222          * loading the library for the first time
 223          */
 224         ret = pm_runtime_resume_and_get(sdev->dev);
 225         if (ret < 0 && ret != -EACCES) {
 226                 dev_err_ratelimited(sdev->dev, "%s: pm_runtime resume failed: %d\n",
 227                                     __func__, ret);
 228                 goto release;
 229         }
 230
 231         ret = ipc4_data->load_library(sdev, fw_lib, false);
 232
 233         pm_runtime_mark_last_busy(sdev->dev);
 234         err = pm_runtime_put_autosuspend(sdev->dev);
 235         if (err < 0)
 236                 dev_err_ratelimited(sdev->dev, "%s: pm_runtime idle failed: %d\n",
 237                                     __func__, err);
 238
 239         if (ret)
 240                 goto release;
 241
 242         ret = xa_insert(&ipc4_data->fw_lib_xa, lib_id, fw_lib, GFP_KERNEL);
 243         if (unlikely(ret))
 244                 goto release;
 245
 246         kfree(fw_filename);
 247
 248         return 0;
 249
 250 release:
 251         release_firmware(fw_lib->sof_fw.fw);
 252         /* Allocated within sof_ipc4_fw_parse_ext_man() */
 253         devm_kfree(sdev->dev, fw_lib->modules);
 254 free_filename:
 255         kfree(fw_filename);
 256 free_fw_lib:
 257         devm_kfree(sdev->dev, fw_lib);
 258
 259         return ret;
 260 }
 261
 262 struct sof_ipc4_fw_module *sof_ipc4_find_module_by_uuid(struct snd_sof_dev *sdev,
 263                                                         const guid_t *uuid)
 264 {
 265         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 266         struct sof_ipc4_fw_library *fw_lib;
 267         unsigned long lib_id;
 268         int i, ret;
 269
 270         if (guid_is_null(uuid))
 271                 return NULL;
 272
 273         xa_for_each(&ipc4_data->fw_lib_xa, lib_id, fw_lib) {
 274                 for (i = 0; i < fw_lib->num_modules; i++) {
 275                         if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
 276                                 return &fw_lib->modules[i];
 277                 }
 278         }
 279
 280         /*
 281          * Do not attempt to load external library in case the maximum number of
 282          * firmware libraries have been already loaded
 283          */
 284         if ((lib_id + 1) == ipc4_data->max_libs_count) {
 285                 dev_err(sdev->dev,
 286                         "%s: Maximum allowed number of libraries reached (%u)\n",
 287                         __func__, ipc4_data->max_libs_count);
 288                 return NULL;
 289         }
 290
 291         /* The module cannot be found, try to load it as a library */
 292         ret = sof_ipc4_load_library_by_uuid(sdev, lib_id + 1, uuid);
 293         if (ret)
 294                 return NULL;
 295
 296         /* Look for the module in the newly loaded library, it should be available now */
 297         xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, lib_id) {
 298                 for (i = 0; i < fw_lib->num_modules; i++) {
 299                         if (guid_equal(uuid, &fw_lib->modules[i].man4_module_entry.uuid))
 300                                 return &fw_lib->modules[i];
 301                 }
 302         }
 303
 304         return NULL;
 305 }
 306
 307 static int sof_ipc4_validate_firmware(struct snd_sof_dev *sdev)
 308 {
 309         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 310         u32 fw_hdr_offset = ipc4_data->manifest_fw_hdr_offset;
 311         struct sof_man4_fw_binary_header *fw_header;
 312         const struct firmware *fw = sdev->basefw.fw;
 313         struct sof_ext_manifest4_hdr *ext_man_hdr;
 314
 315         ext_man_hdr = (struct sof_ext_manifest4_hdr *)fw->data;
 316         fw_header = (struct sof_man4_fw_binary_header *)
 317                                 (fw->data + ext_man_hdr->len + fw_hdr_offset);
 318
 319         /* TODO: Add firmware verification code here */
 320
 321         dev_dbg(sdev->dev, "Validated firmware version: %u.%u.%u.%u\n",
 322                 fw_header->major_version, fw_header->minor_version,
 323                 fw_header->hotfix_version, fw_header->build_version);
 324
 325         return 0;
 326 }
 327
 328 int sof_ipc4_query_fw_configuration(struct snd_sof_dev *sdev)
 329 {
 330         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 331         const struct sof_ipc_ops *iops = sdev->ipc->ops;
 332         struct sof_ipc4_fw_version *fw_ver;
 333         struct sof_ipc4_tuple *tuple;
 334         struct sof_ipc4_msg msg;
 335         size_t offset = 0;
 336         int ret;
 337
 338         /* Get the firmware configuration */
 339         msg.primary = SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG);
 340         msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST);
 341         msg.primary |= SOF_IPC4_MOD_ID(SOF_IPC4_MOD_INIT_BASEFW_MOD_ID);
 342         msg.primary |= SOF_IPC4_MOD_INSTANCE(SOF_IPC4_MOD_INIT_BASEFW_INSTANCE_ID);
 343         msg.extension = SOF_IPC4_MOD_EXT_MSG_PARAM_ID(SOF_IPC4_FW_PARAM_FW_CONFIG);
 344
 345         msg.data_size = sdev->ipc->max_payload_size;
 346         msg.data_ptr = kzalloc(msg.data_size, GFP_KERNEL);
 347         if (!msg.data_ptr)
 348                 return -ENOMEM;
 349
 350         ret = iops->set_get_data(sdev, &msg, msg.data_size, false);
 351         if (ret)
 352                 goto out;
 353
 354         while (offset < msg.data_size) {
 355                 tuple = (struct sof_ipc4_tuple *)((u8 *)msg.data_ptr + offset);
 356
 357                 switch (tuple->type) {
 358                 case SOF_IPC4_FW_CFG_FW_VERSION:
 359                         fw_ver = (struct sof_ipc4_fw_version *)tuple->value;
 360
 361                         dev_info(sdev->dev,
 362                                  "Booted firmware version: %u.%u.%u.%u\n",
 363                                  fw_ver->major, fw_ver->minor, fw_ver->hotfix,
 364                                  fw_ver->build);
 365                         break;
 366                 case SOF_IPC4_FW_CFG_DL_MAILBOX_BYTES:
 367                         trace_sof_ipc4_fw_config(sdev, "DL mailbox size", *tuple->value);
 368                         break;
 369                 case SOF_IPC4_FW_CFG_UL_MAILBOX_BYTES:
 370                         trace_sof_ipc4_fw_config(sdev, "UL mailbox size", *tuple->value);
 371                         break;
 372                 case SOF_IPC4_FW_CFG_TRACE_LOG_BYTES:
 373                         trace_sof_ipc4_fw_config(sdev, "Trace log size", *tuple->value);
 374                         ipc4_data->mtrace_log_bytes = *tuple->value;
 375                         break;
 376                 case SOF_IPC4_FW_CFG_MAX_LIBS_COUNT:
 377                         trace_sof_ipc4_fw_config(sdev, "maximum number of libraries",
 378                                                  *tuple->value);
 379                         ipc4_data->max_libs_count = *tuple->value;
 380                         if (!ipc4_data->max_libs_count)
 381                                 ipc4_data->max_libs_count = 1;
 382                         break;
 383                 case SOF_IPC4_FW_CFG_MAX_PPL_COUNT:
 384                         ipc4_data->max_num_pipelines = *tuple->value;
 385                         trace_sof_ipc4_fw_config(sdev, "Max PPL count %d",
 386                                                  ipc4_data->max_num_pipelines);
 387                         if (ipc4_data->max_num_pipelines <= 0) {
 388                                 dev_err(sdev->dev, "Invalid max_num_pipelines %d",
 389                                         ipc4_data->max_num_pipelines);
 390                                 ret = -EINVAL;
 391                                 goto out;
 392                         }
 393                         break;
 394                 default:
 395                         break;
 396                 }
 397
 398                 offset += sizeof(*tuple) + tuple->size;
 399         }
 400
 401 out:
 402         kfree(msg.data_ptr);
 403
 404         return ret;
 405 }
 406
 407 int sof_ipc4_reload_fw_libraries(struct snd_sof_dev *sdev)
 408 {
 409         struct sof_ipc4_fw_data *ipc4_data = sdev->private;
 410         struct sof_ipc4_fw_library *fw_lib;
 411         unsigned long lib_id;
 412         int ret = 0;
 413
 414         xa_for_each_start(&ipc4_data->fw_lib_xa, lib_id, fw_lib, 1) {
 415                 ret = ipc4_data->load_library(sdev, fw_lib, true);
 416                 if (ret) {
 417                         dev_err(sdev->dev, "%s: Failed to reload library: %s, %d\n",
 418                                 __func__, fw_lib->name, ret);
 419                         break;
 420                 }
 421         }
 422
 423         return ret;
 424 }
 425
 426 /**
 427  * sof_ipc4_update_cpc_from_manifest - Update the cpc in base config from manifest
 428  * @sdev: SOF device
 429  * @fw_module: pointer struct sof_ipc4_fw_module to parse
 430  * @basecfg: Pointer to the base_config to update
 431  */
 432 void sof_ipc4_update_cpc_from_manifest(struct snd_sof_dev *sdev,
 433                                        struct sof_ipc4_fw_module *fw_module,
 434                                        struct sof_ipc4_base_module_cfg *basecfg)
 435 {
 436         const struct sof_man4_module_config *fw_mod_cfg;
 437         u32 cpc_pick = 0;
 438         u32 max_cpc = 0;
 439         const char *msg;
 440         int i;
 441
 442         if (!fw_module->fw_mod_cfg) {
 443                 msg = "No mod_cfg available for CPC lookup in the firmware file's manifest";
 444                 goto no_cpc;
 445         }
 446
 447         /*
 448          * Find the best matching (highest) CPC value based on the module's
 449          * IBS/OBS configuration inferred from the audio format selection.
 450          *
 451          * The CPC value in each module config entry has been measured and
 452          * recorded as a IBS/OBS/CPC triplet and stored in the firmware file's
 453          * manifest
 454          */
 455         fw_mod_cfg = fw_module->fw_mod_cfg;
 456         for (i = 0; i < fw_module->man4_module_entry.cfg_count; i++) {
 457                 if (basecfg->obs == fw_mod_cfg[i].obs &&
 458                     basecfg->ibs == fw_mod_cfg[i].ibs &&
 459                     cpc_pick < fw_mod_cfg[i].cpc)
 460                         cpc_pick = fw_mod_cfg[i].cpc;
 461
 462                 if (max_cpc < fw_mod_cfg[i].cpc)
 463                         max_cpc = fw_mod_cfg[i].cpc;
 464         }
 465
 466         basecfg->cpc = cpc_pick;
 467
 468         /* We have a matching configuration for CPC */
 469         if (basecfg->cpc)
 470                 return;
 471
 472         /*
 473          * No matching IBS/OBS found, the firmware manifest is missing
 474          * information in the module's module configuration table.
 475          */
 476         if (!max_cpc)
 477                 msg = "No CPC value available in the firmware file's manifest";
 478         else if (!cpc_pick)
 479                 msg = "No CPC match in the firmware file's manifest";
 480
 481 no_cpc:
 482         dev_warn(sdev->dev, "%s (UUID: %pUL): %s (ibs/obs: %u/%u)\n",
 483                  fw_module->man4_module_entry.name,
 484                  &fw_module->man4_module_entry.uuid, msg, basecfg->ibs,
 485                  basecfg->obs);
 486         dev_warn_once(sdev->dev, "Please try to update the firmware.\n");
 487         dev_warn_once(sdev->dev, "If the issue persists, file a bug at\n");
 488         dev_warn_once(sdev->dev, "https://github.com/thesofproject/sof/issues/\n");
 489 }
 490
 491 const struct sof_ipc_fw_loader_ops ipc4_loader_ops = {
 492         .validate = sof_ipc4_validate_firmware,
 493         .parse_ext_manifest = sof_ipc4_fw_parse_basefw_ext_man,
 494 };