sound/soc/intel/catpt/loader.c - third_party/kernel - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 //
 // Copyright(c) 2020 Intel Corporation. All rights reserved.
 //
 // Author: Cezary Rojewski <cezary.rojewski@intel.com>
 //

 #include <linux/dma-mapping.h>
 #include <linux/firmware.h>
 #include <linux/slab.h>
 #include "core.h"
 #include "registers.h"

 /* FW load (200ms) plus operational delays */
 #define FW_READY_TIMEOUT_MS	250

 #define FW_SIGNATURE		"$SST"
 #define FW_SIGNATURE_SIZE	4

 struct catpt_fw_hdr {
 	char signature[FW_SIGNATURE_SIZE];
 	u32 file_size;
 	u32 modules;
 	u32 file_format;
 	u32 reserved[4];
 } __packed;

 struct catpt_fw_mod_hdr {
 	char signature[FW_SIGNATURE_SIZE];
 	u32 mod_size;
 	u32 blocks;
 	u16 slot;
 	u16 module_id;
 	u32 entry_point;
 	u32 persistent_size;
 	u32 scratch_size;
 } __packed;

 enum catpt_ram_type {
 	CATPT_RAM_TYPE_IRAM = 1,
 	CATPT_RAM_TYPE_DRAM = 2,
 	/* DRAM with module's initial state */
 	CATPT_RAM_TYPE_INSTANCE = 3,
 };

 struct catpt_fw_block_hdr {
 	u32 ram_type;
 	u32 size;
 	u32 ram_offset;
 	u32 rsvd;
 } __packed;

 void catpt_sram_init(struct resource *sram, u32 start, u32 size)
 {
 	sram->start = start;
 	sram->end = start + size - 1;
 }

 void catpt_sram_free(struct resource *sram)
 {
 	struct resource *res, *save;

 	for (res = sram->child; res;) {
 		save = res->sibling;
 		release_resource(res);
 		kfree(res);
 		res = save;
 	}
 }

 struct resource *
 catpt_request_region(struct resource *root, resource_size_t size)
 {
 	struct resource *res = root->child;
 	resource_size_t addr = root->start;

 	for (;;) {
 		if (res->start - addr >= size)
 			break;
 		addr = res->end + 1;
 		res = res->sibling;
 		if (!res)
 			return NULL;
 	}

 	return __request_region(root, addr, size, NULL, 0);
 }

 int catpt_store_streams_context(struct catpt_dev *cdev, struct dma_chan *chan)
 {
 	struct catpt_stream_runtime *stream;

 	list_for_each_entry(stream, &cdev->stream_list, node) {
 		u32 off, size;
 		int ret;

 		off = stream->persistent->start;
 		size = resource_size(stream->persistent);
 		dev_dbg(cdev->dev, "storing stream %d ctx: off 0x%08x size %d\n",
 			stream->info.stream_hw_id, off, size);

 		ret = catpt_dma_memcpy_fromdsp(cdev, chan,
 					       cdev->dxbuf_paddr + off,
 					       cdev->lpe_base + off,
 					       ALIGN(size, 4));
 		if (ret) {
 			dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 int catpt_store_module_states(struct catpt_dev *cdev, struct dma_chan *chan)
 {
 	int i;

 	for (i = 0; i < ARRAY_SIZE(cdev->modules); i++) {
 		struct catpt_module_type *type;
 		u32 off;
 		int ret;

 		type = &cdev->modules[i];
 		if (!type->loaded || !type->state_size)
 			continue;

 		off = type->state_offset;
 		dev_dbg(cdev->dev, "storing mod %d state: off 0x%08x size %d\n",
 			i, off, type->state_size);

 		ret = catpt_dma_memcpy_fromdsp(cdev, chan,
 					       cdev->dxbuf_paddr + off,
 					       cdev->lpe_base + off,
 					       ALIGN(type->state_size, 4));
 		if (ret) {
 			dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 int catpt_store_memdumps(struct catpt_dev *cdev, struct dma_chan *chan)
 {
 	int i;

 	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
 		struct catpt_save_meminfo *info;
 		u32 off;
 		int ret;

 		info = &cdev->dx_ctx.meminfo[i];
 		if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
 			continue;

 		off = catpt_to_host_offset(info->offset);
 		if (off < cdev->dram.start || off > cdev->dram.end)
 			continue;

 		dev_dbg(cdev->dev, "storing memdump: off 0x%08x size %d\n",
 			off, info->size);

 		ret = catpt_dma_memcpy_fromdsp(cdev, chan,
 					       cdev->dxbuf_paddr + off,
 					       cdev->lpe_base + off,
 					       ALIGN(info->size, 4));
 		if (ret) {
 			dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 static int
 catpt_restore_streams_context(struct catpt_dev *cdev, struct dma_chan *chan)
 {
 	struct catpt_stream_runtime *stream;

 	list_for_each_entry(stream, &cdev->stream_list, node) {
 		u32 off, size;
 		int ret;

 		off = stream->persistent->start;
 		size = resource_size(stream->persistent);
 		dev_dbg(cdev->dev, "restoring stream %d ctx: off 0x%08x size %d\n",
 			stream->info.stream_hw_id, off, size);

 		ret = catpt_dma_memcpy_todsp(cdev, chan,
 					     cdev->lpe_base + off,
 					     cdev->dxbuf_paddr + off,
 					     ALIGN(size, 4));
 		if (ret) {
 			dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 static int catpt_restore_memdumps(struct catpt_dev *cdev, struct dma_chan *chan)
 {
 	int i;

 	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
 		struct catpt_save_meminfo *info;
 		u32 off;
 		int ret;

 		info = &cdev->dx_ctx.meminfo[i];
 		if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
 			continue;

 		off = catpt_to_host_offset(info->offset);
 		if (off < cdev->dram.start || off > cdev->dram.end)
 			continue;

 		dev_dbg(cdev->dev, "restoring memdump: off 0x%08x size %d\n",
 			off, info->size);

 		ret = catpt_dma_memcpy_todsp(cdev, chan,
 					     cdev->lpe_base + off,
 					     cdev->dxbuf_paddr + off,
 					     ALIGN(info->size, 4));
 		if (ret) {
 			dev_err(cdev->dev, "restore block failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 static int catpt_restore_fwimage(struct catpt_dev *cdev,
 				 struct dma_chan *chan, dma_addr_t paddr,
 				 struct catpt_fw_block_hdr *blk)
 {
 	struct resource r1, r2, common;
 	int i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     blk, sizeof(*blk), false);

 	r1.start = cdev->dram.start + blk->ram_offset;
 	r1.end = r1.start + blk->size - 1;
 	/* advance to data area */
 	paddr += sizeof(*blk);

 	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
 		struct catpt_save_meminfo *info;
 		u32 off;
 		int ret;

 		info = &cdev->dx_ctx.meminfo[i];

 		if (info->source != CATPT_DX_TYPE_FW_IMAGE)
 			continue;

 		off = catpt_to_host_offset(info->offset);
 		if (off < cdev->dram.start || off > cdev->dram.end)
 			continue;

 		r2.start = off;
 		r2.end = r2.start + info->size - 1;

 		if (!resource_intersection(&r2, &r1, &common))
 			continue;
 		/* calculate start offset of common data area */
 		off = common.start - r1.start;

 		dev_dbg(cdev->dev, "restoring fwimage: %pr\n", &common);

 		ret = catpt_dma_memcpy_todsp(cdev, chan, common.start,
 					     paddr + off,
 					     resource_size(&common));
 		if (ret) {
 			dev_err(cdev->dev, "memcpy todsp failed: %d\n", ret);
 			return ret;
 		}
 	}

 	return 0;
 }

 static int catpt_load_block(struct catpt_dev *cdev,
 			    struct dma_chan *chan, dma_addr_t paddr,
 			    struct catpt_fw_block_hdr *blk, bool alloc)
 {
 	struct resource *sram, *res;
 	dma_addr_t dst_addr;
 	int ret;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     blk, sizeof(*blk), false);

 	switch (blk->ram_type) {
 	case CATPT_RAM_TYPE_IRAM:
 		sram = &cdev->iram;
 		break;
 	default:
 		sram = &cdev->dram;
 		break;
 	}

 	dst_addr = sram->start + blk->ram_offset;
 	if (alloc) {
 		res = __request_region(sram, dst_addr, blk->size, NULL, 0);
 		if (!res)
 			return -EBUSY;
 	}

 	/* advance to data area */
 	paddr += sizeof(*blk);

 	ret = catpt_dma_memcpy_todsp(cdev, chan, dst_addr, paddr, blk->size);
 	if (ret) {
 		dev_err(cdev->dev, "memcpy error: %d\n", ret);
 		__release_region(sram, dst_addr, blk->size);
 	}

 	return ret;
 }

 static int catpt_restore_basefw(struct catpt_dev *cdev,
 				struct dma_chan *chan, dma_addr_t paddr,
 				struct catpt_fw_mod_hdr *basefw)
 {
 	u32 offset = sizeof(*basefw);
 	int ret, i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     basefw, sizeof(*basefw), false);

 	/* restore basefw image */
 	for (i = 0; i < basefw->blocks; i++) {
 		struct catpt_fw_block_hdr *blk;

 		blk = (struct catpt_fw_block_hdr *)((u8 *)basefw + offset);

 		switch (blk->ram_type) {
 		case CATPT_RAM_TYPE_IRAM:
 			ret = catpt_load_block(cdev, chan, paddr + offset,
 					       blk, false);
 			break;
 		default:
 			ret = catpt_restore_fwimage(cdev, chan, paddr + offset,
 						    blk);
 			break;
 		}

 		if (ret) {
 			dev_err(cdev->dev, "restore block failed: %d\n", ret);
 			return ret;
 		}

 		offset += sizeof(*blk) + blk->size;
 	}

 	/* then proceed with memory dumps */
 	ret = catpt_restore_memdumps(cdev, chan);
 	if (ret)
 		dev_err(cdev->dev, "restore memdumps failed: %d\n", ret);

 	return ret;
 }

 static int catpt_restore_module(struct catpt_dev *cdev,
 				struct dma_chan *chan, dma_addr_t paddr,
 				struct catpt_fw_mod_hdr *mod)
 {
 	u32 offset = sizeof(*mod);
 	int i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     mod, sizeof(*mod), false);

 	for (i = 0; i < mod->blocks; i++) {
 		struct catpt_fw_block_hdr *blk;
 		int ret;

 		blk = (struct catpt_fw_block_hdr *)((u8 *)mod + offset);

 		switch (blk->ram_type) {
 		case CATPT_RAM_TYPE_INSTANCE:
 			/* restore module state */
 			ret = catpt_dma_memcpy_todsp(cdev, chan,
 					cdev->lpe_base + blk->ram_offset,
 					cdev->dxbuf_paddr + blk->ram_offset,
 					ALIGN(blk->size, 4));
 			break;
 		default:
 			ret = catpt_load_block(cdev, chan, paddr + offset,
 					       blk, false);
 			break;
 		}

 		if (ret) {
 			dev_err(cdev->dev, "restore block failed: %d\n", ret);
 			return ret;
 		}

 		offset += sizeof(*blk) + blk->size;
 	}

 	return 0;
 }

 static int catpt_load_module(struct catpt_dev *cdev,
 			     struct dma_chan *chan, dma_addr_t paddr,
 			     struct catpt_fw_mod_hdr *mod)
 {
 	struct catpt_module_type *type;
 	u32 offset = sizeof(*mod);
 	int i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     mod, sizeof(*mod), false);

 	type = &cdev->modules[mod->module_id];

 	for (i = 0; i < mod->blocks; i++) {
 		struct catpt_fw_block_hdr *blk;
 		int ret;

 		blk = (struct catpt_fw_block_hdr *)((u8 *)mod + offset);

 		ret = catpt_load_block(cdev, chan, paddr + offset, blk, true);
 		if (ret) {
 			dev_err(cdev->dev, "load block failed: %d\n", ret);
 			return ret;
 		}

 		/*
 		 * Save state window coordinates - these will be
 		 * used to capture module state on D0 exit.
 		 */
 		if (blk->ram_type == CATPT_RAM_TYPE_INSTANCE) {
 			type->state_offset = blk->ram_offset;
 			type->state_size = blk->size;
 		}

 		offset += sizeof(*blk) + blk->size;
 	}

 	/* init module type static info */
 	type->loaded = true;
 	/* DSP expects address from module header substracted by 4 */
 	type->entry_point = mod->entry_point - 4;
 	type->persistent_size = mod->persistent_size;
 	type->scratch_size = mod->scratch_size;

 	return 0;
 }

 static int catpt_restore_firmware(struct catpt_dev *cdev,
 				  struct dma_chan *chan, dma_addr_t paddr,
 				  struct catpt_fw_hdr *fw)
 {
 	u32 offset = sizeof(*fw);
 	int i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     fw, sizeof(*fw), false);

 	for (i = 0; i < fw->modules; i++) {
 		struct catpt_fw_mod_hdr *mod;
 		int ret;

 		mod = (struct catpt_fw_mod_hdr *)((u8 *)fw + offset);
 		if (strncmp(fw->signature, mod->signature,
 			    FW_SIGNATURE_SIZE)) {
 			dev_err(cdev->dev, "module signature mismatch\n");
 			return -EINVAL;
 		}

 		if (mod->module_id > CATPT_MODID_LAST)
 			return -EINVAL;

 		switch (mod->module_id) {
 		case CATPT_MODID_BASE_FW:
 			ret = catpt_restore_basefw(cdev, chan, paddr + offset,
 						   mod);
 			break;
 		default:
 			ret = catpt_restore_module(cdev, chan, paddr + offset,
 						   mod);
 			break;
 		}

 		if (ret) {
 			dev_err(cdev->dev, "restore module failed: %d\n", ret);
 			return ret;
 		}

 		offset += sizeof(*mod) + mod->mod_size;
 	}

 	return 0;
 }

 static int catpt_load_firmware(struct catpt_dev *cdev,
 			       struct dma_chan *chan, dma_addr_t paddr,
 			       struct catpt_fw_hdr *fw)
 {
 	u32 offset = sizeof(*fw);
 	int i;

 	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
 			     fw, sizeof(*fw), false);

 	for (i = 0; i < fw->modules; i++) {
 		struct catpt_fw_mod_hdr *mod;
 		int ret;

 		mod = (struct catpt_fw_mod_hdr *)((u8 *)fw + offset);
 		if (strncmp(fw->signature, mod->signature,
 			    FW_SIGNATURE_SIZE)) {
 			dev_err(cdev->dev, "module signature mismatch\n");
 			return -EINVAL;
 		}

 		if (mod->module_id > CATPT_MODID_LAST)
 			return -EINVAL;

 		ret = catpt_load_module(cdev, chan, paddr + offset, mod);
 		if (ret) {
 			dev_err(cdev->dev, "load module failed: %d\n", ret);
 			return ret;
 		}

 		offset += sizeof(*mod) + mod->mod_size;
 	}

 	return 0;
 }

 static int catpt_load_image(struct catpt_dev *cdev, struct dma_chan *chan,
 			    const char *name, const char *signature,
 			    bool restore)
 {
 	struct catpt_fw_hdr *fw;
 	struct firmware *img;
 	dma_addr_t paddr;
 	void *vaddr;
 	int ret;

 	ret = request_firmware((const struct firmware **)&img, name, cdev->dev);
 	if (ret)
 		return ret;

 	fw = (struct catpt_fw_hdr *)img->data;
 	if (strncmp(fw->signature, signature, FW_SIGNATURE_SIZE)) {
 		dev_err(cdev->dev, "firmware signature mismatch\n");
 		ret = -EINVAL;
 		goto release_fw;
 	}

 	vaddr = dma_alloc_coherent(cdev->dev, img->size, &paddr, GFP_KERNEL);
 	if (!vaddr) {
 		ret = -ENOMEM;
 		goto release_fw;
 	}

 	memcpy(vaddr, img->data, img->size);
 	fw = (struct catpt_fw_hdr *)vaddr;
 	if (restore)
 		ret = catpt_restore_firmware(cdev, chan, paddr, fw);
 	else
 		ret = catpt_load_firmware(cdev, chan, paddr, fw);

 	dma_free_coherent(cdev->dev, img->size, vaddr, paddr);
 release_fw:
 	release_firmware(img);
 	return ret;
 }

 static int catpt_load_images(struct catpt_dev *cdev, bool restore)
 {
 	static const char *const names[] = {
 		"intel/IntcSST1.bin",
 		"intel/IntcSST2.bin",
 	};
 	struct dma_chan *chan;
 	int ret;

 	chan = catpt_dma_request_config_chan(cdev);
 	if (IS_ERR(chan))
 		return PTR_ERR(chan);

 	ret = catpt_load_image(cdev, chan, names[cdev->spec->core_id - 1],
 			       FW_SIGNATURE, restore);
 	if (ret)
 		goto release_dma_chan;

 	if (!restore)
 		goto release_dma_chan;
 	ret = catpt_restore_streams_context(cdev, chan);
 	if (ret)
 		dev_err(cdev->dev, "restore streams ctx failed: %d\n", ret);
 release_dma_chan:
 	dma_release_channel(chan);
 	return ret;
 }

 int catpt_boot_firmware(struct catpt_dev *cdev, bool restore)
 {
 	int ret;

 	catpt_dsp_stall(cdev, true);

 	ret = catpt_load_images(cdev, restore);
 	if (ret) {
 		dev_err(cdev->dev, "load binaries failed: %d\n", ret);
 		return ret;
 	}

 	reinit_completion(&cdev->fw_ready);
 	catpt_dsp_stall(cdev, false);

 	ret = wait_for_completion_timeout(&cdev->fw_ready,
 			msecs_to_jiffies(FW_READY_TIMEOUT_MS));
 	if (!ret) {
 		dev_err(cdev->dev, "firmware ready timeout\n");
 		return -ETIMEDOUT;
 	}

 	/* update sram pg & clock once done booting */
 	catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
 	catpt_dsp_update_srampge(cdev, &cdev->iram, cdev->spec->iram_mask);

 	return catpt_dsp_update_lpclock(cdev);
 }

 int catpt_first_boot_firmware(struct catpt_dev *cdev)
 {
 	struct resource *res;
 	int ret;

 	ret = catpt_boot_firmware(cdev, false);
 	if (ret) {
 		dev_err(cdev->dev, "basefw boot failed: %d\n", ret);
 		return ret;
 	}

 	/* restrict FW Core dump area */
 	__request_region(&cdev->dram, 0, 0x200, NULL, 0);
 	/* restrict entire area following BASE_FW - highest offset in DRAM */
 	for (res = cdev->dram.child; res->sibling; res = res->sibling)
 		;
 	__request_region(&cdev->dram, res->end + 1,
 			 cdev->dram.end - res->end, NULL, 0);

 	ret = catpt_ipc_get_mixer_stream_info(cdev, &cdev->mixer);
 	if (ret)
 		return CATPT_IPC_ERROR(ret);

 	ret = catpt_arm_stream_templates(cdev);
 	if (ret) {
 		dev_err(cdev->dev, "arm templates failed: %d\n", ret);
 		return ret;
 	}

 	/* update dram pg for scratch and restricted regions */
 	catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);

 	return 0;
 }
	// SPDX-License-Identifier: GPL-2.0-only
	//
	// Copyright(c) 2020 Intel Corporation. All rights reserved.
	//
	// Author: Cezary Rojewski <cezary.rojewski@intel.com>
	//

	#include <linux/dma-mapping.h>
	#include <linux/firmware.h>
	#include <linux/slab.h>
	#include "core.h"
	#include "registers.h"

	/* FW load (200ms) plus operational delays */
	#define FW_READY_TIMEOUT_MS 250

	#define FW_SIGNATURE "$SST"
	#define FW_SIGNATURE_SIZE 4

	struct catpt_fw_hdr {
	char signature[FW_SIGNATURE_SIZE];
	u32 file_size;
	u32 modules;
	u32 file_format;
	u32 reserved[4];
	} __packed;

	struct catpt_fw_mod_hdr {
	char signature[FW_SIGNATURE_SIZE];
	u32 mod_size;
	u32 blocks;
	u16 slot;
	u16 module_id;
	u32 entry_point;
	u32 persistent_size;
	u32 scratch_size;
	} __packed;

	enum catpt_ram_type {
	CATPT_RAM_TYPE_IRAM = 1,
	CATPT_RAM_TYPE_DRAM = 2,
	/* DRAM with module's initial state */
	CATPT_RAM_TYPE_INSTANCE = 3,
	};

	struct catpt_fw_block_hdr {
	u32 ram_type;
	u32 size;
	u32 ram_offset;
	u32 rsvd;
	} __packed;

	void catpt_sram_init(struct resource *sram, u32 start, u32 size)
	{
	sram->start = start;
	sram->end = start + size - 1;
	}

	void catpt_sram_free(struct resource *sram)
	{
	struct resource res, save;

	for (res = sram->child; res;) {
	save = res->sibling;
	release_resource(res);
	kfree(res);
	res = save;
	}
	}

	struct resource *
	catpt_request_region(struct resource *root, resource_size_t size)
	{
	struct resource *res = root->child;
	resource_size_t addr = root->start;

	for (;;) {
	if (res->start - addr >= size)
	break;
	addr = res->end + 1;
	res = res->sibling;
	if (!res)
	return NULL;
	}

	return __request_region(root, addr, size, NULL, 0);
	}

	int catpt_store_streams_context(struct catpt_dev cdev, struct dma_chan chan)
	{
	struct catpt_stream_runtime *stream;

	list_for_each_entry(stream, &cdev->stream_list, node) {
	u32 off, size;
	int ret;

	off = stream->persistent->start;
	size = resource_size(stream->persistent);
	dev_dbg(cdev->dev, "storing stream %d ctx: off 0x%08x size %d\n",
	stream->info.stream_hw_id, off, size);

	ret = catpt_dma_memcpy_fromdsp(cdev, chan,
	cdev->dxbuf_paddr + off,
	cdev->lpe_base + off,
	ALIGN(size, 4));
	if (ret) {
	dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	int catpt_store_module_states(struct catpt_dev cdev, struct dma_chan chan)
	{
	int i;

	for (i = 0; i < ARRAY_SIZE(cdev->modules); i++) {
	struct catpt_module_type *type;
	u32 off;
	int ret;

	type = &cdev->modules[i];
	if (!type->loaded \|\| !type->state_size)
	continue;

	off = type->state_offset;
	dev_dbg(cdev->dev, "storing mod %d state: off 0x%08x size %d\n",
	i, off, type->state_size);

	ret = catpt_dma_memcpy_fromdsp(cdev, chan,
	cdev->dxbuf_paddr + off,
	cdev->lpe_base + off,
	ALIGN(type->state_size, 4));
	if (ret) {
	dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	int catpt_store_memdumps(struct catpt_dev cdev, struct dma_chan chan)
	{
	int i;

	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
	struct catpt_save_meminfo *info;
	u32 off;
	int ret;

	info = &cdev->dx_ctx.meminfo[i];
	if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
	continue;

	off = catpt_to_host_offset(info->offset);
	if (off < cdev->dram.start \|\| off > cdev->dram.end)
	continue;

	dev_dbg(cdev->dev, "storing memdump: off 0x%08x size %d\n",
	off, info->size);

	ret = catpt_dma_memcpy_fromdsp(cdev, chan,
	cdev->dxbuf_paddr + off,
	cdev->lpe_base + off,
	ALIGN(info->size, 4));
	if (ret) {
	dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	static int
	catpt_restore_streams_context(struct catpt_dev cdev, struct dma_chan chan)
	{
	struct catpt_stream_runtime *stream;

	list_for_each_entry(stream, &cdev->stream_list, node) {
	u32 off, size;
	int ret;

	off = stream->persistent->start;
	size = resource_size(stream->persistent);
	dev_dbg(cdev->dev, "restoring stream %d ctx: off 0x%08x size %d\n",
	stream->info.stream_hw_id, off, size);

	ret = catpt_dma_memcpy_todsp(cdev, chan,
	cdev->lpe_base + off,
	cdev->dxbuf_paddr + off,
	ALIGN(size, 4));
	if (ret) {
	dev_err(cdev->dev, "memcpy fromdsp failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	static int catpt_restore_memdumps(struct catpt_dev cdev, struct dma_chan chan)
	{
	int i;

	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
	struct catpt_save_meminfo *info;
	u32 off;
	int ret;

	info = &cdev->dx_ctx.meminfo[i];
	if (info->source != CATPT_DX_TYPE_MEMORY_DUMP)
	continue;

	off = catpt_to_host_offset(info->offset);
	if (off < cdev->dram.start \|\| off > cdev->dram.end)
	continue;

	dev_dbg(cdev->dev, "restoring memdump: off 0x%08x size %d\n",
	off, info->size);

	ret = catpt_dma_memcpy_todsp(cdev, chan,
	cdev->lpe_base + off,
	cdev->dxbuf_paddr + off,
	ALIGN(info->size, 4));
	if (ret) {
	dev_err(cdev->dev, "restore block failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	static int catpt_restore_fwimage(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_block_hdr *blk)
	{
	struct resource r1, r2, common;
	int i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	blk, sizeof(*blk), false);

	r1.start = cdev->dram.start + blk->ram_offset;
	r1.end = r1.start + blk->size - 1;
	/* advance to data area */
	paddr += sizeof(*blk);

	for (i = 0; i < cdev->dx_ctx.num_meminfo; i++) {
	struct catpt_save_meminfo *info;
	u32 off;
	int ret;

	info = &cdev->dx_ctx.meminfo[i];

	if (info->source != CATPT_DX_TYPE_FW_IMAGE)
	continue;

	off = catpt_to_host_offset(info->offset);
	if (off < cdev->dram.start \|\| off > cdev->dram.end)
	continue;

	r2.start = off;
	r2.end = r2.start + info->size - 1;

	if (!resource_intersection(&r2, &r1, &common))
	continue;
	/* calculate start offset of common data area */
	off = common.start - r1.start;

	dev_dbg(cdev->dev, "restoring fwimage: %pr\n", &common);

	ret = catpt_dma_memcpy_todsp(cdev, chan, common.start,
	paddr + off,
	resource_size(&common));
	if (ret) {
	dev_err(cdev->dev, "memcpy todsp failed: %d\n", ret);
	return ret;
	}
	}

	return 0;
	}

	static int catpt_load_block(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_block_hdr *blk, bool alloc)
	{
	struct resource sram, res;
	dma_addr_t dst_addr;
	int ret;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	blk, sizeof(*blk), false);

	switch (blk->ram_type) {
	case CATPT_RAM_TYPE_IRAM:
	sram = &cdev->iram;
	break;
	default:
	sram = &cdev->dram;
	break;
	}

	dst_addr = sram->start + blk->ram_offset;
	if (alloc) {
	res = __request_region(sram, dst_addr, blk->size, NULL, 0);
	if (!res)
	return -EBUSY;
	}

	/* advance to data area */
	paddr += sizeof(*blk);

	ret = catpt_dma_memcpy_todsp(cdev, chan, dst_addr, paddr, blk->size);
	if (ret) {
	dev_err(cdev->dev, "memcpy error: %d\n", ret);
	__release_region(sram, dst_addr, blk->size);
	}

	return ret;
	}

	static int catpt_restore_basefw(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_mod_hdr *basefw)
	{
	u32 offset = sizeof(*basefw);
	int ret, i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	basefw, sizeof(*basefw), false);

	/* restore basefw image */
	for (i = 0; i < basefw->blocks; i++) {
	struct catpt_fw_block_hdr *blk;

	blk = (struct catpt_fw_block_hdr )((u8 )basefw + offset);

	switch (blk->ram_type) {
	case CATPT_RAM_TYPE_IRAM:
	ret = catpt_load_block(cdev, chan, paddr + offset,
	blk, false);
	break;
	default:
	ret = catpt_restore_fwimage(cdev, chan, paddr + offset,
	blk);
	break;
	}

	if (ret) {
	dev_err(cdev->dev, "restore block failed: %d\n", ret);
	return ret;
	}

	offset += sizeof(*blk) + blk->size;
	}

	/* then proceed with memory dumps */
	ret = catpt_restore_memdumps(cdev, chan);
	if (ret)
	dev_err(cdev->dev, "restore memdumps failed: %d\n", ret);

	return ret;
	}

	static int catpt_restore_module(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_mod_hdr *mod)
	{
	u32 offset = sizeof(*mod);
	int i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	mod, sizeof(*mod), false);

	for (i = 0; i < mod->blocks; i++) {
	struct catpt_fw_block_hdr *blk;
	int ret;

	blk = (struct catpt_fw_block_hdr )((u8 )mod + offset);

	switch (blk->ram_type) {
	case CATPT_RAM_TYPE_INSTANCE:
	/* restore module state */
	ret = catpt_dma_memcpy_todsp(cdev, chan,
	cdev->lpe_base + blk->ram_offset,
	cdev->dxbuf_paddr + blk->ram_offset,
	ALIGN(blk->size, 4));
	break;
	default:
	ret = catpt_load_block(cdev, chan, paddr + offset,
	blk, false);
	break;
	}

	if (ret) {
	dev_err(cdev->dev, "restore block failed: %d\n", ret);
	return ret;
	}

	offset += sizeof(*blk) + blk->size;
	}

	return 0;
	}

	static int catpt_load_module(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_mod_hdr *mod)
	{
	struct catpt_module_type *type;
	u32 offset = sizeof(*mod);
	int i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	mod, sizeof(*mod), false);

	type = &cdev->modules[mod->module_id];

	for (i = 0; i < mod->blocks; i++) {
	struct catpt_fw_block_hdr *blk;
	int ret;

	blk = (struct catpt_fw_block_hdr )((u8 )mod + offset);

	ret = catpt_load_block(cdev, chan, paddr + offset, blk, true);
	if (ret) {
	dev_err(cdev->dev, "load block failed: %d\n", ret);
	return ret;
	}

	/*
	* Save state window coordinates - these will be
	* used to capture module state on D0 exit.
	*/
	if (blk->ram_type == CATPT_RAM_TYPE_INSTANCE) {
	type->state_offset = blk->ram_offset;
	type->state_size = blk->size;
	}

	offset += sizeof(*blk) + blk->size;
	}

	/* init module type static info */
	type->loaded = true;
	/* DSP expects address from module header substracted by 4 */
	type->entry_point = mod->entry_point - 4;
	type->persistent_size = mod->persistent_size;
	type->scratch_size = mod->scratch_size;

	return 0;
	}

	static int catpt_restore_firmware(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_hdr *fw)
	{
	u32 offset = sizeof(*fw);
	int i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	fw, sizeof(*fw), false);

	for (i = 0; i < fw->modules; i++) {
	struct catpt_fw_mod_hdr *mod;
	int ret;

	mod = (struct catpt_fw_mod_hdr )((u8 )fw + offset);
	if (strncmp(fw->signature, mod->signature,
	FW_SIGNATURE_SIZE)) {
	dev_err(cdev->dev, "module signature mismatch\n");
	return -EINVAL;
	}

	if (mod->module_id > CATPT_MODID_LAST)
	return -EINVAL;

	switch (mod->module_id) {
	case CATPT_MODID_BASE_FW:
	ret = catpt_restore_basefw(cdev, chan, paddr + offset,
	mod);
	break;
	default:
	ret = catpt_restore_module(cdev, chan, paddr + offset,
	mod);
	break;
	}

	if (ret) {
	dev_err(cdev->dev, "restore module failed: %d\n", ret);
	return ret;
	}

	offset += sizeof(*mod) + mod->mod_size;
	}

	return 0;
	}

	static int catpt_load_firmware(struct catpt_dev *cdev,
	struct dma_chan *chan, dma_addr_t paddr,
	struct catpt_fw_hdr *fw)
	{
	u32 offset = sizeof(*fw);
	int i;

	print_hex_dump_debug(__func__, DUMP_PREFIX_OFFSET, 8, 4,
	fw, sizeof(*fw), false);

	for (i = 0; i < fw->modules; i++) {
	struct catpt_fw_mod_hdr *mod;
	int ret;

	mod = (struct catpt_fw_mod_hdr )((u8 )fw + offset);
	if (strncmp(fw->signature, mod->signature,
	FW_SIGNATURE_SIZE)) {
	dev_err(cdev->dev, "module signature mismatch\n");
	return -EINVAL;
	}

	if (mod->module_id > CATPT_MODID_LAST)
	return -EINVAL;

	ret = catpt_load_module(cdev, chan, paddr + offset, mod);
	if (ret) {
	dev_err(cdev->dev, "load module failed: %d\n", ret);
	return ret;
	}

	offset += sizeof(*mod) + mod->mod_size;
	}

	return 0;
	}

	static int catpt_load_image(struct catpt_dev cdev, struct dma_chan chan,
	const char name, const char signature,
	bool restore)
	{
	struct catpt_fw_hdr *fw;
	struct firmware *img;
	dma_addr_t paddr;
	void *vaddr;
	int ret;

	ret = request_firmware((const struct firmware **)&img, name, cdev->dev);
	if (ret)
	return ret;

	fw = (struct catpt_fw_hdr *)img->data;
	if (strncmp(fw->signature, signature, FW_SIGNATURE_SIZE)) {
	dev_err(cdev->dev, "firmware signature mismatch\n");
	ret = -EINVAL;
	goto release_fw;
	}

	vaddr = dma_alloc_coherent(cdev->dev, img->size, &paddr, GFP_KERNEL);
	if (!vaddr) {
	ret = -ENOMEM;
	goto release_fw;
	}

	memcpy(vaddr, img->data, img->size);
	fw = (struct catpt_fw_hdr *)vaddr;
	if (restore)
	ret = catpt_restore_firmware(cdev, chan, paddr, fw);
	else
	ret = catpt_load_firmware(cdev, chan, paddr, fw);

	dma_free_coherent(cdev->dev, img->size, vaddr, paddr);
	release_fw:
	release_firmware(img);
	return ret;
	}

	static int catpt_load_images(struct catpt_dev *cdev, bool restore)
	{
	static const char *const names[] = {
	"intel/IntcSST1.bin",
	"intel/IntcSST2.bin",
	};
	struct dma_chan *chan;
	int ret;

	chan = catpt_dma_request_config_chan(cdev);
	if (IS_ERR(chan))
	return PTR_ERR(chan);

	ret = catpt_load_image(cdev, chan, names[cdev->spec->core_id - 1],
	FW_SIGNATURE, restore);
	if (ret)
	goto release_dma_chan;

	if (!restore)
	goto release_dma_chan;
	ret = catpt_restore_streams_context(cdev, chan);
	if (ret)
	dev_err(cdev->dev, "restore streams ctx failed: %d\n", ret);
	release_dma_chan:
	dma_release_channel(chan);
	return ret;
	}

	int catpt_boot_firmware(struct catpt_dev *cdev, bool restore)
	{
	int ret;

	catpt_dsp_stall(cdev, true);

	ret = catpt_load_images(cdev, restore);
	if (ret) {
	dev_err(cdev->dev, "load binaries failed: %d\n", ret);
	return ret;
	}

	reinit_completion(&cdev->fw_ready);
	catpt_dsp_stall(cdev, false);

	ret = wait_for_completion_timeout(&cdev->fw_ready,
	msecs_to_jiffies(FW_READY_TIMEOUT_MS));
	if (!ret) {
	dev_err(cdev->dev, "firmware ready timeout\n");
	return -ETIMEDOUT;
	}

	/* update sram pg & clock once done booting */
	catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);
	catpt_dsp_update_srampge(cdev, &cdev->iram, cdev->spec->iram_mask);

	return catpt_dsp_update_lpclock(cdev);
	}

	int catpt_first_boot_firmware(struct catpt_dev *cdev)
	{
	struct resource *res;
	int ret;

	ret = catpt_boot_firmware(cdev, false);
	if (ret) {
	dev_err(cdev->dev, "basefw boot failed: %d\n", ret);
	return ret;
	}

	/* restrict FW Core dump area */
	__request_region(&cdev->dram, 0, 0x200, NULL, 0);
	/* restrict entire area following BASE_FW - highest offset in DRAM */
	for (res = cdev->dram.child; res->sibling; res = res->sibling)
	;
	__request_region(&cdev->dram, res->end + 1,
	cdev->dram.end - res->end, NULL, 0);

	ret = catpt_ipc_get_mixer_stream_info(cdev, &cdev->mixer);
	if (ret)
	return CATPT_IPC_ERROR(ret);

	ret = catpt_arm_stream_templates(cdev);
	if (ret) {
	dev_err(cdev->dev, "arm templates failed: %d\n", ret);
	return ret;
	}

	/* update dram pg for scratch and restricted regions */
	catpt_dsp_update_srampge(cdev, &cdev->dram, cdev->spec->dram_mask);

	return 0;
	}