sound/soc/sof/fw-file-profile.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) 2023 Intel Corporation. All rights reserved.
   7 //
   8
   9 #include <linux/firmware.h>
  10 #include <sound/sof.h>
  11 #include <sound/sof/ext_manifest4.h>
  12 #include "sof-priv.h"
  13
  14 static int sof_test_firmware_file(struct device *dev,
  15                                   struct sof_loadable_file_profile *profile,
  16                                   enum sof_ipc_type *ipc_type_to_adjust)
  17 {
  18         enum sof_ipc_type fw_ipc_type;
  19         const struct firmware *fw;
  20         const char *fw_filename;
  21         const u32 *magic;
  22         int ret;
  23
  24         fw_filename = kasprintf(GFP_KERNEL, "%s/%s", profile->fw_path,
  25                                 profile->fw_name);
  26         if (!fw_filename)
  27                 return -ENOMEM;
  28
  29         ret = firmware_request_nowarn(&fw, fw_filename, dev);
  30         if (ret < 0) {
  31                 dev_dbg(dev, "Failed to open firmware file: %s\n", fw_filename);
  32                 kfree(fw_filename);
  33                 return ret;
  34         }
  35
  36         /* firmware file exists, check the magic number */
  37         magic = (const u32 *)fw->data;
  38         switch (*magic) {
  39         case SOF_EXT_MAN_MAGIC_NUMBER:
  40                 fw_ipc_type = SOF_IPC_TYPE_3;
  41                 break;
  42         case SOF_EXT_MAN4_MAGIC_NUMBER:
  43                 fw_ipc_type = SOF_IPC_TYPE_4;
  44                 break;
  45         default:
  46                 dev_err(dev, "Invalid firmware magic: %#x\n", *magic);
  47                 ret = -EINVAL;
  48                 goto out;
  49         }
  50
  51         if (ipc_type_to_adjust) {
  52                 *ipc_type_to_adjust = fw_ipc_type;
  53         } else if (fw_ipc_type != profile->ipc_type) {
  54                 dev_err(dev,
  55                         "ipc type mismatch between %s and expected: %d vs %d\n",
  56                         fw_filename, fw_ipc_type, profile->ipc_type);
  57                 ret = -EINVAL;
  58         }
  59 out:
  60         release_firmware(fw);
  61         kfree(fw_filename);
  62
  63         return ret;
  64 }
  65
  66 static int sof_test_topology_file(struct device *dev,
  67                                   struct sof_loadable_file_profile *profile)
  68 {
  69         const struct firmware *fw;
  70         const char *tplg_filename;
  71         int ret;
  72
  73         if (!profile->tplg_path || !profile->tplg_name)
  74                 return 0;
  75
  76         tplg_filename = kasprintf(GFP_KERNEL, "%s/%s", profile->tplg_path,
  77                                   profile->tplg_name);
  78         if (!tplg_filename)
  79                 return -ENOMEM;
  80
  81         ret = firmware_request_nowarn(&fw, tplg_filename, dev);
  82         if (!ret)
  83                 release_firmware(fw);
  84         else
  85                 dev_dbg(dev, "Failed to open topology file: %s\n", tplg_filename);
  86
  87         kfree(tplg_filename);
  88
  89         return ret;
  90 }
  91
  92 static bool sof_platform_uses_generic_loader(struct snd_sof_dev *sdev)
  93 {
  94         return (sdev->pdata->desc->ops->load_firmware == snd_sof_load_firmware_raw ||
  95                 sdev->pdata->desc->ops->load_firmware == snd_sof_load_firmware_memcpy);
  96 }
  97
  98 static int
  99 sof_file_profile_for_ipc_type(struct snd_sof_dev *sdev,
 100                               enum sof_ipc_type ipc_type,
 101                               const struct sof_dev_desc *desc,
 102                               struct sof_loadable_file_profile *base_profile,
 103                               struct sof_loadable_file_profile *out_profile)
 104 {
 105         struct snd_sof_pdata *plat_data = sdev->pdata;
 106         bool fw_lib_path_allocated = false;
 107         struct device *dev = sdev->dev;
 108         bool fw_path_allocated = false;
 109         int ret = 0;
 110
 111         /* firmware path */
 112         if (base_profile->fw_path) {
 113                 out_profile->fw_path = base_profile->fw_path;
 114         } else if (base_profile->fw_path_postfix) {
 115                 out_profile->fw_path = devm_kasprintf(dev, GFP_KERNEL, "%s/%s",
 116                                                         desc->default_fw_path[ipc_type],
 117                                                         base_profile->fw_path_postfix);
 118                 if (!out_profile->fw_path)
 119                         return -ENOMEM;
 120
 121                 fw_path_allocated = true;
 122         } else {
 123                 out_profile->fw_path = desc->default_fw_path[ipc_type];
 124         }
 125
 126         /* firmware filename */
 127         if (base_profile->fw_name)
 128                 out_profile->fw_name = base_profile->fw_name;
 129         else
 130                 out_profile->fw_name = desc->default_fw_filename[ipc_type];
 131
 132         /*
 133          * Check the custom firmware path/filename and adjust the ipc_type to
 134          * match with the existing file for the remaining path configuration.
 135          *
 136          * For default path and firmware name do a verification before
 137          * continuing further.
 138          */
 139         if ((base_profile->fw_path || base_profile->fw_name) &&
 140             sof_platform_uses_generic_loader(sdev)) {
 141                 ret = sof_test_firmware_file(dev, out_profile, &ipc_type);
 142                 if (ret)
 143                         return ret;
 144
 145                 if (!(desc->ipc_supported_mask & BIT(ipc_type))) {
 146                         dev_err(dev, "Unsupported IPC type %d needed by %s/%s\n",
 147                                 ipc_type, out_profile->fw_path,
 148                                 out_profile->fw_name);
 149                         return -EINVAL;
 150                 }
 151         }
 152
 153         /* firmware library path */
 154         if (base_profile->fw_lib_path) {
 155                 out_profile->fw_lib_path = base_profile->fw_lib_path;
 156         } else if (desc->default_lib_path[ipc_type]) {
 157                 if (base_profile->fw_lib_path_postfix) {
 158                         out_profile->fw_lib_path = devm_kasprintf(dev,
 159                                                         GFP_KERNEL, "%s/%s",
 160                                                         desc->default_lib_path[ipc_type],
 161                                                         base_profile->fw_lib_path_postfix);
 162                         if (!out_profile->fw_lib_path) {
 163                                 ret = -ENOMEM;
 164                                 goto out;
 165                         }
 166
 167                         fw_lib_path_allocated = true;
 168                 } else {
 169                         out_profile->fw_lib_path = desc->default_lib_path[ipc_type];
 170                 }
 171         }
 172
 173         if (base_profile->fw_path_postfix)
 174                 out_profile->fw_path_postfix = base_profile->fw_path_postfix;
 175
 176         if (base_profile->fw_lib_path_postfix)
 177                 out_profile->fw_lib_path_postfix = base_profile->fw_lib_path_postfix;
 178
 179         /* topology path */
 180         if (base_profile->tplg_path)
 181                 out_profile->tplg_path = base_profile->tplg_path;
 182         else
 183                 out_profile->tplg_path = desc->default_tplg_path[ipc_type];
 184
 185         /* topology name */
 186         out_profile->tplg_name = plat_data->tplg_filename;
 187
 188         out_profile->ipc_type = ipc_type;
 189
 190         /* Test only default firmware file */
 191         if ((!base_profile->fw_path && !base_profile->fw_name) &&
 192             sof_platform_uses_generic_loader(sdev))
 193                 ret = sof_test_firmware_file(dev, out_profile, NULL);
 194
 195         if (!ret)
 196                 ret = sof_test_topology_file(dev, out_profile);
 197
 198 out:
 199         if (ret) {
 200                 /* Free up path strings created with devm_kasprintf */
 201                 if (fw_path_allocated)
 202                         devm_kfree(dev, out_profile->fw_path);
 203                 if (fw_lib_path_allocated)
 204                         devm_kfree(dev, out_profile->fw_lib_path);
 205
 206                 memset(out_profile, 0, sizeof(*out_profile));
 207         }
 208
 209         return ret;
 210 }
 211
 212 static void
 213 sof_print_missing_firmware_info(struct snd_sof_dev *sdev,
 214                                 enum sof_ipc_type ipc_type,
 215                                 struct sof_loadable_file_profile *base_profile)
 216 {
 217         struct snd_sof_pdata *plat_data = sdev->pdata;
 218         const struct sof_dev_desc *desc = plat_data->desc;
 219         struct device *dev = sdev->dev;
 220         int ipc_type_count, i;
 221         char *marker;
 222
 223         dev_err(dev, "SOF firmware and/or topology file not found.\n");
 224         dev_info(dev, "Supported default profiles\n");
 225
 226         if (IS_ENABLED(CONFIG_SND_SOC_SOF_ALLOW_FALLBACK_TO_NEWER_IPC_VERSION))
 227                 ipc_type_count = SOF_IPC_TYPE_COUNT - 1;
 228         else
 229                 ipc_type_count = base_profile->ipc_type;
 230
 231         for (i = 0; i <= ipc_type_count; i++) {
 232                 if (!(desc->ipc_supported_mask & BIT(i)))
 233                         continue;
 234
 235                 if (i == ipc_type)
 236                         marker = "Requested";
 237                 else
 238                         marker = "Fallback";
 239
 240                 dev_info(dev, "- ipc type %d (%s):\n", i, marker);
 241                 if (base_profile->fw_path_postfix)
 242                         dev_info(dev, " Firmware file: %s/%s/%s\n",
 243                                  desc->default_fw_path[i],
 244                                  base_profile->fw_path_postfix,
 245                                  desc->default_fw_filename[i]);
 246                 else
 247                         dev_info(dev, " Firmware file: %s/%s\n",
 248                                  desc->default_fw_path[i],
 249                                  desc->default_fw_filename[i]);
 250
 251                 dev_info(dev, " Topology file: %s/%s\n",
 252                          desc->default_tplg_path[i],
 253                          plat_data->tplg_filename);
 254         }
 255
 256         if (base_profile->fw_path || base_profile->fw_name ||
 257             base_profile->tplg_path || base_profile->tplg_name)
 258                 dev_info(dev, "Verify the path/name override module parameters.\n");
 259
 260         dev_info(dev, "Check if you have 'sof-firmware' package installed.\n");
 261         dev_info(dev, "Optionally it can be manually downloaded from:\n");
 262         dev_info(dev, "   https://github.com/thesofproject/sof-bin/\n");
 263 }
 264
 265 static void sof_print_profile_info(struct snd_sof_dev *sdev,
 266                                    enum sof_ipc_type ipc_type,
 267                                    struct sof_loadable_file_profile *profile)
 268 {
 269         struct device *dev = sdev->dev;
 270
 271         if (ipc_type != profile->ipc_type)
 272                 dev_info(dev,
 273                          "Using fallback IPC type %d (requested type was %d)\n",
 274                          profile->ipc_type, ipc_type);
 275
 276         dev_info(dev, "Firmware paths/files for ipc type %d:\n", profile->ipc_type);
 277
 278         /* The firmware path is only valid when generic loader is used */
 279         if (sof_platform_uses_generic_loader(sdev))
 280                 dev_info(dev, " Firmware file:     %s/%s\n",
 281                          profile->fw_path, profile->fw_name);
 282
 283         if (profile->fw_lib_path)
 284                 dev_info(dev, " Firmware lib path: %s\n", profile->fw_lib_path);
 285         dev_info(dev, " Topology file:     %s/%s\n", profile->tplg_path, profile->tplg_name);
 286 }
 287
 288 int sof_create_ipc_file_profile(struct snd_sof_dev *sdev,
 289                                 struct sof_loadable_file_profile *base_profile,
 290                                 struct sof_loadable_file_profile *out_profile)
 291 {
 292         const struct sof_dev_desc *desc = sdev->pdata->desc;
 293         int ipc_fallback_start, ret, i;
 294
 295         memset(out_profile, 0, sizeof(*out_profile));
 296
 297         ret = sof_file_profile_for_ipc_type(sdev, base_profile->ipc_type, desc,
 298                                             base_profile, out_profile);
 299         if (!ret)
 300                 goto out;
 301
 302         /*
 303          * No firmware file was found for the requested IPC type, as fallback
 304          * if SND_SOC_SOF_ALLOW_FALLBACK_TO_NEWER_IPC_VERSION is selected, check
 305          * all IPC versions in a backwards direction (from newer to older)
 306          * if SND_SOC_SOF_ALLOW_FALLBACK_TO_NEWER_IPC_VERSION is not selected,
 307          * check only older IPC versions than the selected/default version
 308          */
 309         if (IS_ENABLED(CONFIG_SND_SOC_SOF_ALLOW_FALLBACK_TO_NEWER_IPC_VERSION))
 310                 ipc_fallback_start = SOF_IPC_TYPE_COUNT - 1;
 311         else
 312                 ipc_fallback_start = (int)base_profile->ipc_type - 1;
 313
 314         for (i = ipc_fallback_start; i >= 0 ; i--) {
 315                 if (i == base_profile->ipc_type ||
 316                     !(desc->ipc_supported_mask & BIT(i)))
 317                         continue;
 318
 319                 ret = sof_file_profile_for_ipc_type(sdev, i, desc, base_profile,
 320                                                     out_profile);
 321                 if (!ret)
 322                         break;
 323         }
 324
 325 out:
 326         if (ret)
 327                 sof_print_missing_firmware_info(sdev, base_profile->ipc_type,
 328                                                 base_profile);
 329         else
 330                 sof_print_profile_info(sdev, base_profile->ipc_type, out_profile);
 331
 332         return ret;
 333 }
 334 EXPORT_SYMBOL(sof_create_ipc_file_profile);