[mirror_ubuntu-hirsute-kernel.git] / sound / soc / intel / skylake / skl-sst-utils.c

/*
 *  skl-sst-utils.c - SKL sst utils functions
 *
 *  Copyright (C) 2016 Intel Corp
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as version 2, as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 */

#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include "skl-sst-dsp.h"
#include "../common/sst-dsp.h"
#include "../common/sst-dsp-priv.h"
#include "skl-sst-ipc.h"


#define UUID_STR_SIZE 37
#define DEFAULT_HASH_SHA256_LEN 32

/* FW Extended Manifest Header id = $AE1 */
#define SKL_EXT_MANIFEST_HEADER_MAGIC   0x31454124

struct UUID {
	u8 id[16];
};

union seg_flags {
	u32 ul;
	struct {
		u32 contents : 1;
		u32 alloc    : 1;
		u32 load     : 1;
		u32 read_only : 1;
		u32 code     : 1;
		u32 data     : 1;
		u32 _rsvd0   : 2;
		u32 type     : 4;
		u32 _rsvd1   : 4;
		u32 length   : 16;
	} r;
} __packed;

struct segment_desc {
	union seg_flags flags;
	u32 v_base_addr;
	u32 file_offset;
};

struct module_type {
	u32 load_type  : 4;
	u32 auto_start : 1;
	u32 domain_ll  : 1;
	u32 domain_dp  : 1;
	u32 rsvd       : 25;
} __packed;

struct adsp_module_entry {
	u32 struct_id;
	u8  name[8];
	struct UUID uuid;
	struct module_type type;
	u8  hash1[DEFAULT_HASH_SHA256_LEN];
	u32 entry_point;
	u16 cfg_offset;
	u16 cfg_count;
	u32 affinity_mask;
	u16 instance_max_count;
	u16 instance_bss_size;
	struct segment_desc segments[3];
} __packed;

struct adsp_fw_hdr {
	u32 id;
	u32 len;
	u8  name[8];
	u32 preload_page_count;
	u32 fw_image_flags;
	u32 feature_mask;
	u16 major;
	u16 minor;
	u16 hotfix;
	u16 build;
	u32 num_modules;
	u32 hw_buf_base;
	u32 hw_buf_length;
	u32 load_offset;
} __packed;

#define MAX_INSTANCE_BUFF 2

struct uuid_module {
	uuid_le uuid;
	int id;
	int is_loadable;
	int max_instance;
	u64 pvt_id[MAX_INSTANCE_BUFF];
	int *instance_id;

	struct list_head list;
};

struct skl_ext_manifest_hdr {
	u32 id;
	u32 len;
	u16 version_major;
	u16 version_minor;
	u32 entries;
};

int snd_skl_get_module_info(struct skl_sst *ctx,
				struct skl_module_cfg *mconfig)
{
	struct uuid_module *module;
	uuid_le *uuid_mod;

	uuid_mod = (uuid_le *)mconfig->guid;

	if (list_empty(&ctx->uuid_list)) {
		dev_err(ctx->dev, "Module list is empty\n");
		return -EINVAL;
	}

	list_for_each_entry(module, &ctx->uuid_list, list) {
		if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
			mconfig->id.module_id = module->id;
			mconfig->is_loadable = module->is_loadable;

			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(snd_skl_get_module_info);

static int skl_get_pvtid_map(struct uuid_module *module, int instance_id)
{
	int pvt_id;

	for (pvt_id = 0; pvt_id < module->max_instance; pvt_id++) {
		if (module->instance_id[pvt_id] == instance_id)
			return pvt_id;
	}
	return -EINVAL;
}

int skl_get_pvt_instance_id_map(struct skl_sst *ctx,
				int module_id, int instance_id)
{
	struct uuid_module *module;

	list_for_each_entry(module, &ctx->uuid_list, list) {
		if (module->id == module_id)
			return skl_get_pvtid_map(module, instance_id);
	}

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(skl_get_pvt_instance_id_map);

static inline int skl_getid_32(struct uuid_module *module, u64 *val,
				int word1_mask, int word2_mask)
{
	int index, max_inst, pvt_id;
	u32 mask_val;

	max_inst =  module->max_instance;
	mask_val = (u32)(*val >> word1_mask);

	if (mask_val != 0xffffffff) {
		index = ffz(mask_val);
		pvt_id = index + word1_mask + word2_mask;
		if (pvt_id <= (max_inst - 1)) {
			*val |= 1 << (index + word1_mask);
			return pvt_id;
		}
	}

	return -EINVAL;
}

static inline int skl_pvtid_128(struct uuid_module *module)
{
	int j, i, word1_mask, word2_mask = 0, pvt_id;

	for (j = 0; j < MAX_INSTANCE_BUFF; j++) {
		word1_mask = 0;

		for (i = 0; i < 2; i++) {
			pvt_id = skl_getid_32(module, &module->pvt_id[j],
						word1_mask, word2_mask);
			if (pvt_id >= 0)
				return pvt_id;

			word1_mask += 32;
			if ((word1_mask + word2_mask) >= module->max_instance)
				return -EINVAL;
		}

		word2_mask += 64;
		if (word2_mask >= module->max_instance)
			return -EINVAL;
	}

	return -EINVAL;
}

/**
 * skl_get_pvt_id: generate a private id for use as module id
 *
 * @ctx: driver context
 * @mconfig: module configuration data
 *
 * This generates a 128 bit private unique id for a module TYPE so that
 * module instance is unique
 */
int skl_get_pvt_id(struct skl_sst *ctx, struct skl_module_cfg *mconfig)
{
	struct uuid_module *module;
	uuid_le *uuid_mod;
	int pvt_id;

	uuid_mod = (uuid_le *)mconfig->guid;

	list_for_each_entry(module, &ctx->uuid_list, list) {
		if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {

			pvt_id = skl_pvtid_128(module);
			if (pvt_id >= 0) {
				module->instance_id[pvt_id] =
						mconfig->id.instance_id;
				return pvt_id;
			}
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(skl_get_pvt_id);

/**
 * skl_put_pvt_id: free up the private id allocated
 *
 * @ctx: driver context
 * @mconfig: module configuration data
 *
 * This frees a 128 bit private unique id previously generated
 */
int skl_put_pvt_id(struct skl_sst *ctx, struct skl_module_cfg *mconfig)
{
	int i;
	uuid_le *uuid_mod;
	struct uuid_module *module;

	uuid_mod = (uuid_le *)mconfig->guid;
	list_for_each_entry(module, &ctx->uuid_list, list) {
		if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {

			if (mconfig->id.pvt_id != 0)
				i = (mconfig->id.pvt_id) / 64;
			else
				i = 0;

			module->pvt_id[i] &= ~(1 << (mconfig->id.pvt_id));
			mconfig->id.pvt_id = -1;
			return 0;
		}
	}

	return -EINVAL;
}
EXPORT_SYMBOL_GPL(skl_put_pvt_id);

/*
 * Parse the firmware binary to get the UUID, module id
 * and loadable flags
 */
int snd_skl_parse_uuids(struct sst_dsp *ctx, const struct firmware *fw,
			unsigned int offset, int index)
{
	struct adsp_fw_hdr *adsp_hdr;
	struct adsp_module_entry *mod_entry;
	int i, num_entry, size;
	uuid_le *uuid_bin;
	const char *buf;
	struct skl_sst *skl = ctx->thread_context;
	struct uuid_module *module;
	struct firmware stripped_fw;
	unsigned int safe_file;

	/* Get the FW pointer to derive ADSP header */
	stripped_fw.data = fw->data;
	stripped_fw.size = fw->size;

	skl_dsp_strip_extended_manifest(&stripped_fw);

	buf = stripped_fw.data;

	/* check if we have enough space in file to move to header */
	safe_file = sizeof(*adsp_hdr) + offset;
	if (stripped_fw.size <= safe_file) {
		dev_err(ctx->dev, "Small fw file size, No space for hdr\n");
		return -EINVAL;
	}

	adsp_hdr = (struct adsp_fw_hdr *)(buf + offset);

	/* check 1st module entry is in file */
	safe_file += adsp_hdr->len + sizeof(*mod_entry);
	if (stripped_fw.size <= safe_file) {
		dev_err(ctx->dev, "Small fw file size, No module entry\n");
		return -EINVAL;
	}

	mod_entry = (struct adsp_module_entry *)
		(buf + offset + adsp_hdr->len);

	num_entry = adsp_hdr->num_modules;

	/* check all entries are in file */
	safe_file += num_entry * sizeof(*mod_entry);
	if (stripped_fw.size <= safe_file) {
		dev_err(ctx->dev, "Small fw file size, No modules\n");
		return -EINVAL;
	}


	/*
	 * Read the UUID(GUID) from FW Manifest.
	 *
	 * The 16 byte UUID format is: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXX
	 * Populate the UUID table to store module_id and loadable flags
	 * for the module.
	 */

	for (i = 0; i < num_entry; i++, mod_entry++) {
		module = kzalloc(sizeof(*module), GFP_KERNEL);
		if (!module)
			return -ENOMEM;

		uuid_bin = (uuid_le *)mod_entry->uuid.id;
		memcpy(&module->uuid, uuid_bin, sizeof(module->uuid));

		module->id = (i | (index << 12));
		module->is_loadable = mod_entry->type.load_type;
		module->max_instance = mod_entry->instance_max_count;
		size = sizeof(int) * mod_entry->instance_max_count;
		module->instance_id = devm_kzalloc(ctx->dev, size, GFP_KERNEL);
		if (!module->instance_id) {
			kfree(module);
			return -ENOMEM;
		}

		list_add_tail(&module->list, &skl->uuid_list);

		dev_dbg(ctx->dev,
			"Adding uuid :%pUL   mod id: %d  Loadable: %d\n",
			&module->uuid, module->id, module->is_loadable);
	}

	return 0;
}

void skl_freeup_uuid_list(struct skl_sst *ctx)
{
	struct uuid_module *uuid, *_uuid;

	list_for_each_entry_safe(uuid, _uuid, &ctx->uuid_list, list) {
		list_del(&uuid->list);
		kfree(uuid);
	}
}

/*
 * some firmware binary contains some extended manifest. This needs
 * to be stripped in that case before we load and use that image.
 *
 * Get the module id for the module by checking
 * the table for the UUID for the module
 */
int skl_dsp_strip_extended_manifest(struct firmware *fw)
{
	struct skl_ext_manifest_hdr *hdr;

	/* check if fw file is greater than header we are looking */
	if (fw->size < sizeof(hdr)) {
		pr_err("%s: Firmware file small, no hdr\n", __func__);
		return -EINVAL;
	}

	hdr = (struct skl_ext_manifest_hdr *)fw->data;

	if (hdr->id == SKL_EXT_MANIFEST_HEADER_MAGIC) {
		fw->size -= hdr->len;
		fw->data += hdr->len;
	}

	return 0;
}
Commit	Line	Data
6eee8726 RB	1	/*
	2	* skl-sst-utils.c - SKL sst utils functions
	3	*
	4	* Copyright (C) 2016 Intel Corp
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as version 2, as
	8	* published by the Free Software Foundation.
	9	*
	10	* This program is distributed in the hope that it will be useful, but
	11	* WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	* General Public License for more details.
	14	*/
	15
ea6b3e94 SN	16	#include <linux/device.h>
	17	#include <linux/slab.h>
	18	#include <linux/uuid.h>
6eee8726	19	#include "skl-sst-dsp.h"
ea6b3e94 SN	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
6eee8726 RB	27
	28	/* FW Extended Manifest Header id = $AE1 */
	29	#define SKL_EXT_MANIFEST_HEADER_MAGIC 0x31454124
	30
ea6b3e94 SN	31	struct UUID {
	32	u8 id[16];
	33	};
	34
	35	union 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
	51	struct segment_desc {
	52	union seg_flags flags;
	53	u32 v_base_addr;
	54	u32 file_offset;
	55	};
	56
	57	struct 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
	65	struct 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
	80	struct 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
700a9a63 D	97	#define MAX_INSTANCE_BUFF 2
700a9a63 D	98
ea6b3e94 SN	99	struct uuid_module {
	100	uuid_le uuid;
	101	int id;
	102	int is_loadable;
700a9a63 D	103	int max_instance;
700a9a63 D	104	u64 pvt_id[MAX_INSTANCE_BUFF];
55a92ea9	105	int *instance_id;
ea6b3e94 SN	106
	107	struct list_head list;
	108	};
	109
6eee8726 RB	110	struct skl_ext_manifest_hdr {
	111	u32 id;
	112	u32 len;
	113	u16 version_major;
	114	u16 version_minor;
	115	u32 entries;
	116	};
	117
0556ba46 D	118	int snd_skl_get_module_info(struct skl_sst *ctx,
0556ba46 D	119	struct skl_module_cfg *mconfig)
ea6b3e94 SN	120	{
	121	struct uuid_module *module;
	122	uuid_le *uuid_mod;
	123
0556ba46	124	uuid_mod = (uuid_le *)mconfig->guid;
ea6b3e94	125
2392f7fd VK	126	if (list_empty(&ctx->uuid_list)) {
	127	dev_err(ctx->dev, "Module list is empty\n");
	128	return -EINVAL;
	129	}
	130
ea6b3e94 SN	131	list_for_each_entry(module, &ctx->uuid_list, list) {
ea6b3e94 SN	132	if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
0556ba46 D	133	mconfig->id.module_id = module->id;
0556ba46 D	134	mconfig->is_loadable = module->is_loadable;
ea6b3e94 SN	135
	136	return 0;
	137	}
	138	}
	139
	140	return -EINVAL;
	141	}
	142	EXPORT_SYMBOL_GPL(snd_skl_get_module_info);
	143
55a92ea9 D	144	static int skl_get_pvtid_map(struct uuid_module *module, int instance_id)
	145	{
	146	int pvt_id;
	147
	148	for (pvt_id = 0; pvt_id < module->max_instance; pvt_id++) {
	149	if (module->instance_id[pvt_id] == instance_id)
	150	return pvt_id;
	151	}
	152	return -EINVAL;
	153	}
	154
	155	int skl_get_pvt_instance_id_map(struct skl_sst *ctx,
	156	int module_id, int instance_id)
	157	{
	158	struct uuid_module *module;
	159
	160	list_for_each_entry(module, &ctx->uuid_list, list) {
	161	if (module->id == module_id)
	162	return skl_get_pvtid_map(module, instance_id);
	163	}
	164
	165	return -EINVAL;
	166	}
	167	EXPORT_SYMBOL_GPL(skl_get_pvt_instance_id_map);
	168
700a9a63	169	static inline int skl_getid_32(struct uuid_module module, u64 val,
ef2a352c	170	int word1_mask, int word2_mask)
700a9a63 D	171	{
	172	int index, max_inst, pvt_id;
	173	u32 mask_val;
	174
	175	max_inst = module->max_instance;
	176	mask_val = (u32)(*val >> word1_mask);
	177
	178	if (mask_val != 0xffffffff) {
	179	index = ffz(mask_val);
	180	pvt_id = index + word1_mask + word2_mask;
	181	if (pvt_id <= (max_inst - 1)) {
	182	*val \|= 1 << (index + word1_mask);
	183	return pvt_id;
	184	}
	185	}
	186
	187	return -EINVAL;
	188	}
	189
	190	static inline int skl_pvtid_128(struct uuid_module *module)
	191	{
	192	int j, i, word1_mask, word2_mask = 0, pvt_id;
	193
	194	for (j = 0; j < MAX_INSTANCE_BUFF; j++) {
	195	word1_mask = 0;
	196
	197	for (i = 0; i < 2; i++) {
	198	pvt_id = skl_getid_32(module, &module->pvt_id[j],
	199	word1_mask, word2_mask);
	200	if (pvt_id >= 0)
	201	return pvt_id;
	202
	203	word1_mask += 32;
	204	if ((word1_mask + word2_mask) >= module->max_instance)
	205	return -EINVAL;
	206	}
	207
	208	word2_mask += 64;
	209	if (word2_mask >= module->max_instance)
	210	return -EINVAL;
	211	}
	212
	213	return -EINVAL;
	214	}
	215
	216	/**
	217	* skl_get_pvt_id: generate a private id for use as module id
	218	*
	219	* @ctx: driver context
	220	* @mconfig: module configuration data
	221	*
	222	* This generates a 128 bit private unique id for a module TYPE so that
	223	* module instance is unique
	224	*/
	225	int skl_get_pvt_id(struct skl_sst ctx, struct skl_module_cfg mconfig)
	226	{
	227	struct uuid_module *module;
	228	uuid_le *uuid_mod;
	229	int pvt_id;
	230
	231	uuid_mod = (uuid_le *)mconfig->guid;
	232
	233	list_for_each_entry(module, &ctx->uuid_list, list) {
	234	if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
235
236	pvt_id = skl_pvtid_128(module);
55a92ea9 D	237	if (pvt_id >= 0) {
	238	module->instance_id[pvt_id] =
	239	mconfig->id.instance_id;
700a9a63	240	return pvt_id;
55a92ea9	241	}
700a9a63 D	242	}
	243	}
	244
	245	return -EINVAL;
	246	}
	247	EXPORT_SYMBOL_GPL(skl_get_pvt_id);
	248
	249	/**
	250	* skl_put_pvt_id: free up the private id allocated
	251	*
	252	* @ctx: driver context
	253	* @mconfig: module configuration data
	254	*
	255	* This frees a 128 bit private unique id previously generated
	256	*/
	257	int skl_put_pvt_id(struct skl_sst ctx, struct skl_module_cfg mconfig)
	258	{
	259	int i;
	260	uuid_le *uuid_mod;
	261	struct uuid_module *module;
	262
	263	uuid_mod = (uuid_le *)mconfig->guid;
	264	list_for_each_entry(module, &ctx->uuid_list, list) {
	265	if (uuid_le_cmp(*uuid_mod, module->uuid) == 0) {
	266
	267	if (mconfig->id.pvt_id != 0)
	268	i = (mconfig->id.pvt_id) / 64;
	269	else
	270	i = 0;
	271
	272	module->pvt_id[i] &= ~(1 << (mconfig->id.pvt_id));
	273	mconfig->id.pvt_id = -1;
	274	return 0;
	275	}
	276	}
	277
	278	return -EINVAL;
	279	}
	280	EXPORT_SYMBOL_GPL(skl_put_pvt_id);
	281
ea6b3e94 SN	282	/*
	283	* Parse the firmware binary to get the UUID, module id
	284	* and loadable flags
	285	*/
a8e2c19e SV	286	int snd_skl_parse_uuids(struct sst_dsp ctx, const struct firmware fw,
a8e2c19e SV	287	unsigned int offset, int index)
ea6b3e94 SN	288	{
	289	struct adsp_fw_hdr *adsp_hdr;
	290	struct adsp_module_entry *mod_entry;
55a92ea9	291	int i, num_entry, size;
ea6b3e94 SN	292	uuid_le *uuid_bin;
	293	const char *buf;
	294	struct skl_sst *skl = ctx->thread_context;
	295	struct uuid_module *module;
	296	struct firmware stripped_fw;
	297	unsigned int safe_file;
	298
	299	/* Get the FW pointer to derive ADSP header */
a8e2c19e SV	300	stripped_fw.data = fw->data;
a8e2c19e SV	301	stripped_fw.size = fw->size;
ea6b3e94 SN	302
	303	skl_dsp_strip_extended_manifest(&stripped_fw);
	304
	305	buf = stripped_fw.data;
	306
	307	/* check if we have enough space in file to move to header */
	308	safe_file = sizeof(*adsp_hdr) + offset;
	309	if (stripped_fw.size <= safe_file) {
	310	dev_err(ctx->dev, "Small fw file size, No space for hdr\n");
	311	return -EINVAL;
	312	}
	313
	314	adsp_hdr = (struct adsp_fw_hdr *)(buf + offset);
	315
	316	/* check 1st module entry is in file */
	317	safe_file += adsp_hdr->len + sizeof(*mod_entry);
	318	if (stripped_fw.size <= safe_file) {
	319	dev_err(ctx->dev, "Small fw file size, No module entry\n");
	320	return -EINVAL;
	321	}
	322
	323	mod_entry = (struct adsp_module_entry *)
	324	(buf + offset + adsp_hdr->len);
	325
	326	num_entry = adsp_hdr->num_modules;
	327
	328	/* check all entries are in file */
	329	safe_file += num_entry * sizeof(*mod_entry);
	330	if (stripped_fw.size <= safe_file) {
	331	dev_err(ctx->dev, "Small fw file size, No modules\n");
	332	return -EINVAL;
	333	}
	334
	335
	336	/*
	337	* Read the UUID(GUID) from FW Manifest.
	338	*
	339	* The 16 byte UUID format is: XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXX
	340	* Populate the UUID table to store module_id and loadable flags
	341	* for the module.
	342	*/
	343
	344	for (i = 0; i < num_entry; i++, mod_entry++) {
	345	module = kzalloc(sizeof(*module), GFP_KERNEL);
	346	if (!module)
	347	return -ENOMEM;
	348
	349	uuid_bin = (uuid_le *)mod_entry->uuid.id;
	350	memcpy(&module->uuid, uuid_bin, sizeof(module->uuid));
	351
a8e2c19e	352	module->id = (i \| (index << 12));
ea6b3e94	353	module->is_loadable = mod_entry->type.load_type;
700a9a63	354	module->max_instance = mod_entry->instance_max_count;
55a92ea9 D	355	size = sizeof(int) * mod_entry->instance_max_count;
55a92ea9 D	356	module->instance_id = devm_kzalloc(ctx->dev, size, GFP_KERNEL);
0730bd2e CIK	357	if (!module->instance_id) {
0730bd2e CIK	358	kfree(module);
55a92ea9	359	return -ENOMEM;
0730bd2e	360	}
ea6b3e94 SN	361
	362	list_add_tail(&module->list, &skl->uuid_list);
	363
	364	dev_dbg(ctx->dev,
	365	"Adding uuid :%pUL mod id: %d Loadable: %d\n",
	366	&module->uuid, module->id, module->is_loadable);
	367	}
	368
	369	return 0;
	370	}
	371
	372	void skl_freeup_uuid_list(struct skl_sst *ctx)
	373	{
	374	struct uuid_module uuid, _uuid;
	375
	376	list_for_each_entry_safe(uuid, _uuid, &ctx->uuid_list, list) {
	377	list_del(&uuid->list);
	378	kfree(uuid);
	379	}
	380	}
	381
6eee8726 RB	382	/*
	383	* some firmware binary contains some extended manifest. This needs
	384	* to be stripped in that case before we load and use that image.
	385	*
ea6b3e94 SN	386	* Get the module id for the module by checking
ea6b3e94 SN	387	* the table for the UUID for the module
6eee8726 RB	388	*/
	389	int skl_dsp_strip_extended_manifest(struct firmware *fw)
	390	{
	391	struct skl_ext_manifest_hdr *hdr;
	392
	393	/* check if fw file is greater than header we are looking */
	394	if (fw->size < sizeof(hdr)) {
	395	pr_err("%s: Firmware file small, no hdr\n", __func__);
	396	return -EINVAL;
	397	}
	398
	399	hdr = (struct skl_ext_manifest_hdr *)fw->data;
	400
	401	if (hdr->id == SKL_EXT_MANIFEST_HEADER_MAGIC) {
	402	fw->size -= hdr->len;
	403	fw->data += hdr->len;
	404	}
	405
	406	return 0;
	407	}