1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/device.h>
17#include <linux/slab.h>
18#include <linux/uuid.h>
19#include "skl-sst-dsp.h"
20#include "../common/sst-dsp.h"
21#include "../common/sst-dsp-priv.h"
22#include "skl-sst-ipc.h"
23
24
25#define UUID_STR_SIZE 37
26#define DEFAULT_HASH_SHA256_LEN 32
27
28
29#define SKL_EXT_MANIFEST_HEADER_MAGIC 0x31454124
30
31struct UUID {
32 u8 id[16];
33};
34
35union seg_flags {
36 u32 ul;
37 struct {
38 u32 contents : 1;
39 u32 alloc : 1;
40 u32 load : 1;
41 u32 read_only : 1;
42 u32 code : 1;
43 u32 data : 1;
44 u32 _rsvd0 : 2;
45 u32 type : 4;
46 u32 _rsvd1 : 4;
47 u32 length : 16;
48 } r;
49} __packed;
50
51struct segment_desc {
52 union seg_flags flags;
53 u32 v_base_addr;
54 u32 file_offset;
55};
56
57struct module_type {
58 u32 load_type : 4;
59 u32 auto_start : 1;
60 u32 domain_ll : 1;
61 u32 domain_dp : 1;
62 u32 rsvd : 25;
63} __packed;
64
65struct adsp_module_entry {
66 u32 struct_id;
67 u8 name[8];
68 struct UUID uuid;
69 struct module_type type;
70 u8 hash1[DEFAULT_HASH_SHA256_LEN];
71 u32 entry_point;
72 u16 cfg_offset;
73 u16 cfg_count;
74 u32 affinity_mask;
75 u16 instance_max_count;
76 u16 instance_bss_size;
77 struct segment_desc segments[3];
78} __packed;
79
80struct adsp_fw_hdr {
81 u32 id;
82 u32 len;
83 u8 name[8];
84 u32 preload_page_count;
85 u32 fw_image_flags;
86 u32 feature_mask;
87 u16 major;
88 u16 minor;
89 u16 hotfix;
90 u16 build;
91 u32 num_modules;
92 u32 hw_buf_base;
93 u32 hw_buf_length;
94 u32 load_offset;
95} __packed;
96
97struct skl_ext_manifest_hdr {
98 u32 id;
99 u32 len;
100 u16 version_major;
101 u16 version_minor;
102 u32 entries;
103};
104
105static int skl_get_pvtid_map(struct uuid_module *module, int instance_id)
106{
107 int pvt_id;
108
109 for (pvt_id = 0; pvt_id < module->max_instance; pvt_id++) {
110 if (module->instance_id[pvt_id] == instance_id)
111 return pvt_id;
112 }
113 return -EINVAL;
114}
115
116int skl_get_pvt_instance_id_map(struct skl_sst *ctx,
117 int module_id, int instance_id)
118{
119 struct uuid_module *module;
120
121 list_for_each_entry(module, &ctx->uuid_list, list) {
122 if (module->id == module_id)
123 return skl_get_pvtid_map(module, instance_id);
124 }
125
126 return -EINVAL;
127}
128EXPORT_SYMBOL_GPL(skl_get_pvt_instance_id_map);
129
130static inline int skl_getid_32(struct uuid_module *module, u64 *val,
131 int word1_mask, int word2_mask)
132{
133 int index, max_inst, pvt_id;
134 u32 mask_val;
135
136 max_inst = module->max_instance;
137 mask_val = (u32)(*val >> word1_mask);
138
139 if (mask_val != 0xffffffff) {
140 index = ffz(mask_val);
141 pvt_id = index + word1_mask + word2_mask;
142 if (pvt_id <= (max_inst - 1)) {
143 *val |= 1ULL << (index + word1_mask);
144 return pvt_id;
145 }
146 }
147
148 return -EINVAL;
149}
150
151static inline int skl_pvtid_128(struct uuid_module *module)
152{
153 int j, i, word1_mask, word2_mask = 0, pvt_id;
154
155 for (j = 0; j < MAX_INSTANCE_BUFF; j++) {
156 word1_mask = 0;
157
158 for (i = 0; i < 2; i++) {
159 pvt_id = skl_getid_32(module, &module->pvt_id[j],
160 word1_mask, word2_mask);
161 if (pvt_id >= 0)
162 return pvt_id;
163
164 word1_mask += 32;
165 if ((word1_mask + word2_mask) >= module->max_instance)
166 return -EINVAL;
167 }
168
169 word2_mask += 64;
170 if (word2_mask >= module->max_instance)
171 return -EINVAL;
172 }
173
174 return -EINVAL;
175}
176
177
178
179
180
181
182
183
184
185
186int skl_get_pvt_id(struct skl_sst *ctx, uuid_le *uuid_mod, int instance_id)
187{
188 struct uuid_module *module;
189 int pvt_id;
190
191 list_for_each_entry(module, &ctx->uuid_list, list) {
192 if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
193
194 pvt_id = skl_pvtid_128(module);
195 if (pvt_id >= 0) {
196 module->instance_id[pvt_id] = instance_id;
197
198 return pvt_id;
199 }
200 }
201 }
202
203 return -EINVAL;
204}
205EXPORT_SYMBOL_GPL(skl_get_pvt_id);
206
207
208
209
210
211
212
213
214
215int skl_put_pvt_id(struct skl_sst *ctx, uuid_le *uuid_mod, int *pvt_id)
216{
217 int i;
218 struct uuid_module *module;
219
220 list_for_each_entry(module, &ctx->uuid_list, list) {
221 if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
222
223 if (*pvt_id != 0)
224 i = (*pvt_id) / 64;
225 else
226 i = 0;
227
228 module->pvt_id[i] &= ~(1 << (*pvt_id));
229 *pvt_id = -1;
230 return 0;
231 }
232 }
233
234 return -EINVAL;
235}
236EXPORT_SYMBOL_GPL(skl_put_pvt_id);
237
238
239
240
241
242int snd_skl_parse_uuids(struct sst_dsp *ctx, const struct firmware *fw,
243 unsigned int offset, int index)
244{
245 struct adsp_fw_hdr *adsp_hdr;
246 struct adsp_module_entry *mod_entry;
247 int i, num_entry, size;
248 uuid_le *uuid_bin;
249 const char *buf;
250 struct skl_sst *skl = ctx->thread_context;
251 struct uuid_module *module;
252 struct firmware stripped_fw;
253 unsigned int safe_file;
254 int ret = 0;
255
256
257 stripped_fw.data = fw->data;
258 stripped_fw.size = fw->size;
259
260 skl_dsp_strip_extended_manifest(&stripped_fw);
261
262 buf = stripped_fw.data;
263
264
265 safe_file = sizeof(*adsp_hdr) + offset;
266 if (stripped_fw.size <= safe_file) {
267 dev_err(ctx->dev, "Small fw file size, No space for hdr\n");
268 return -EINVAL;
269 }
270
271 adsp_hdr = (struct adsp_fw_hdr *)(buf + offset);
272
273
274 safe_file += adsp_hdr->len + sizeof(*mod_entry);
275 if (stripped_fw.size <= safe_file) {
276 dev_err(ctx->dev, "Small fw file size, No module entry\n");
277 return -EINVAL;
278 }
279
280 mod_entry = (struct adsp_module_entry *)
281 (buf + offset + adsp_hdr->len);
282
283 num_entry = adsp_hdr->num_modules;
284
285
286 safe_file += num_entry * sizeof(*mod_entry);
287 if (stripped_fw.size <= safe_file) {
288 dev_err(ctx->dev, "Small fw file size, No modules\n");
289 return -EINVAL;
290 }
291
292
293
294
295
296
297
298
299
300
301 for (i = 0; i < num_entry; i++, mod_entry++) {
302 module = kzalloc(sizeof(*module), GFP_KERNEL);
303 if (!module) {
304 ret = -ENOMEM;
305 goto free_uuid_list;
306 }
307
308 uuid_bin = (uuid_le *)mod_entry->uuid.id;
309 memcpy(&module->uuid, uuid_bin, sizeof(module->uuid));
310
311 module->id = (i | (index << 12));
312 module->is_loadable = mod_entry->type.load_type;
313 module->max_instance = mod_entry->instance_max_count;
314 size = sizeof(int) * mod_entry->instance_max_count;
315 module->instance_id = devm_kzalloc(ctx->dev, size, GFP_KERNEL);
316 if (!module->instance_id) {
317 ret = -ENOMEM;
318 goto free_uuid_list;
319 }
320
321 list_add_tail(&module->list, &skl->uuid_list);
322
323 dev_dbg(ctx->dev,
324 "Adding uuid :%pUL mod id: %d Loadable: %d\n",
325 &module->uuid, module->id, module->is_loadable);
326 }
327
328 return 0;
329
330free_uuid_list:
331 skl_freeup_uuid_list(skl);
332 return ret;
333}
334
335void skl_freeup_uuid_list(struct skl_sst *ctx)
336{
337 struct uuid_module *uuid, *_uuid;
338
339 list_for_each_entry_safe(uuid, _uuid, &ctx->uuid_list, list) {
340 list_del(&uuid->list);
341 kfree(uuid);
342 }
343}
344
345
346
347
348
349
350
351
352int skl_dsp_strip_extended_manifest(struct firmware *fw)
353{
354 struct skl_ext_manifest_hdr *hdr;
355
356
357 if (fw->size < sizeof(hdr)) {
358 pr_err("%s: Firmware file small, no hdr\n", __func__);
359 return -EINVAL;
360 }
361
362 hdr = (struct skl_ext_manifest_hdr *)fw->data;
363
364 if (hdr->id == SKL_EXT_MANIFEST_HEADER_MAGIC) {
365 fw->size -= hdr->len;
366 fw->data += hdr->len;
367 }
368
369 return 0;
370}
371
372int skl_sst_ctx_init(struct device *dev, int irq, const char *fw_name,
373 struct skl_dsp_loader_ops dsp_ops, struct skl_sst **dsp,
374 struct sst_dsp_device *skl_dev)
375{
376 struct skl_sst *skl;
377 struct sst_dsp *sst;
378
379 skl = devm_kzalloc(dev, sizeof(*skl), GFP_KERNEL);
380 if (skl == NULL)
381 return -ENOMEM;
382
383 skl->dev = dev;
384 skl_dev->thread_context = skl;
385 INIT_LIST_HEAD(&skl->uuid_list);
386 skl->dsp = skl_dsp_ctx_init(dev, skl_dev, irq);
387 if (!skl->dsp) {
388 dev_err(skl->dev, "%s: no device\n", __func__);
389 return -ENODEV;
390 }
391
392 sst = skl->dsp;
393 sst->fw_name = fw_name;
394 sst->dsp_ops = dsp_ops;
395 init_waitqueue_head(&skl->mod_load_wait);
396 INIT_LIST_HEAD(&sst->module_list);
397
398 skl->is_first_boot = true;
399 if (dsp)
400 *dsp = skl;
401
402 return 0;
403}
404
405int skl_prepare_lib_load(struct skl_sst *skl, struct skl_lib_info *linfo,
406 struct firmware *stripped_fw,
407 unsigned int hdr_offset, int index)
408{
409 int ret;
410 struct sst_dsp *dsp = skl->dsp;
411
412 if (linfo->fw == NULL) {
413 ret = request_firmware(&linfo->fw, linfo->name,
414 skl->dev);
415 if (ret < 0) {
416 dev_err(skl->dev, "Request lib %s failed:%d\n",
417 linfo->name, ret);
418 return ret;
419 }
420 }
421
422 if (skl->is_first_boot) {
423 ret = snd_skl_parse_uuids(dsp, linfo->fw, hdr_offset, index);
424 if (ret < 0)
425 return ret;
426 }
427
428 stripped_fw->data = linfo->fw->data;
429 stripped_fw->size = linfo->fw->size;
430 skl_dsp_strip_extended_manifest(stripped_fw);
431
432 return 0;
433}
434
435void skl_release_library(struct skl_lib_info *linfo, int lib_count)
436{
437 int i;
438
439
440 for (i = 1; i < lib_count; i++) {
441 if (linfo[i].fw) {
442 release_firmware(linfo[i].fw);
443 linfo[i].fw = NULL;
444 }
445 }
446}
447