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

source code of linux/sound/soc/sof/fw-file-profile.c