[mirror_ubuntu-bionic-kernel.git] / sound / soc / intel / atom / sst / sst_ipc.c

/*
 *  sst_ipc.c - Intel SST Driver for audio engine
 *
 *  Copyright (C) 2008-14 Intel Corporation
 *  Authors:	Vinod Koul <vinod.koul@intel.com>
 *		Harsha Priya <priya.harsha@intel.com>
 *		Dharageswari R <dharageswari.r@intel.com>
 *		KP Jeeja <jeeja.kp@intel.com>
 *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  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/pci.h>
#include <linux/firmware.h>
#include <linux/sched.h>
#include <linux/delay.h>
#include <linux/pm_runtime.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <sound/compress_driver.h>
#include <asm/intel-mid.h>
#include <asm/platform_sst_audio.h>
#include "../sst-mfld-platform.h"
#include "sst.h"
#include "../../common/sst-dsp.h"

struct sst_block *sst_create_block(struct intel_sst_drv *ctx,
					u32 msg_id, u32 drv_id)
{
	struct sst_block *msg = NULL;

	dev_dbg(ctx->dev, "Enter\n");
	msg = kzalloc(sizeof(*msg), GFP_KERNEL);
	if (!msg)
		return NULL;
	msg->condition = false;
	msg->on = true;
	msg->msg_id = msg_id;
	msg->drv_id = drv_id;
	spin_lock_bh(&ctx->block_lock);
	list_add_tail(&msg->node, &ctx->block_list);
	spin_unlock_bh(&ctx->block_lock);

	return msg;
}

/*
 * while handling the interrupts, we need to check for message status and
 * then if we are blocking for a message
 *
 * here we are unblocking the blocked ones, this is based on id we have
 * passed and search that for block threads.
 * We will not find block in two cases
 *  a) when its small message and block in not there, so silently ignore
 *  them
 *  b) when we are actually not able to find the block (bug perhaps)
 *
 *  Since we have bit of small messages we can spam kernel log with err
 *  print on above so need to keep as debug prints which should be enabled
 *  via dynamic debug while debugging IPC issues
 */
int sst_wake_up_block(struct intel_sst_drv *ctx, int result,
		u32 drv_id, u32 ipc, void *data, u32 size)
{
	struct sst_block *block = NULL;

	dev_dbg(ctx->dev, "Enter\n");

	spin_lock_bh(&ctx->block_lock);
	list_for_each_entry(block, &ctx->block_list, node) {
		dev_dbg(ctx->dev, "Block ipc %d, drv_id %d\n", block->msg_id,
							block->drv_id);
		if (block->msg_id == ipc && block->drv_id == drv_id) {
			dev_dbg(ctx->dev, "free up the block\n");
			block->ret_code = result;
			block->data = data;
			block->size = size;
			block->condition = true;
			spin_unlock_bh(&ctx->block_lock);
			wake_up(&ctx->wait_queue);
			return 0;
		}
	}
	spin_unlock_bh(&ctx->block_lock);
	dev_dbg(ctx->dev,
		"Block not found or a response received for a short msg for ipc %d, drv_id %d\n",
		ipc, drv_id);
	return -EINVAL;
}

int sst_free_block(struct intel_sst_drv *ctx, struct sst_block *freed)
{
	struct sst_block *block = NULL, *__block;

	dev_dbg(ctx->dev, "Enter\n");
	spin_lock_bh(&ctx->block_lock);
	list_for_each_entry_safe(block, __block, &ctx->block_list, node) {
		if (block == freed) {
			pr_debug("pvt_id freed --> %d\n", freed->drv_id);
			/* toggle the index position of pvt_id */
			list_del(&freed->node);
			spin_unlock_bh(&ctx->block_lock);
			kfree(freed->data);
			freed->data = NULL;
			kfree(freed);
			return 0;
		}
	}
	spin_unlock_bh(&ctx->block_lock);
	dev_err(ctx->dev, "block is already freed!!!\n");
	return -EINVAL;
}

int sst_post_message_mrfld(struct intel_sst_drv *sst_drv_ctx,
		struct ipc_post *ipc_msg, bool sync)
{
	struct ipc_post *msg = ipc_msg;
	union ipc_header_mrfld header;
	unsigned int loop_count = 0;
	int retval = 0;
	unsigned long irq_flags;

	dev_dbg(sst_drv_ctx->dev, "Enter: sync: %d\n", sync);
	spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
	header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
	if (sync) {
		while (header.p.header_high.part.busy) {
			if (loop_count > 25) {
				dev_err(sst_drv_ctx->dev,
					"sst: Busy wait failed, cant send this msg\n");
				retval = -EBUSY;
				goto out;
			}
			cpu_relax();
			loop_count++;
			header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
		}
	} else {
		if (list_empty(&sst_drv_ctx->ipc_dispatch_list)) {
			/* queue is empty, nothing to send */
			spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
			dev_dbg(sst_drv_ctx->dev,
					"Empty msg queue... NO Action\n");
			return 0;
		}

		if (header.p.header_high.part.busy) {
			spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
			dev_dbg(sst_drv_ctx->dev, "Busy not free... post later\n");
			return 0;
		}

		/* copy msg from list */
		msg = list_entry(sst_drv_ctx->ipc_dispatch_list.next,
				struct ipc_post, node);
		list_del(&msg->node);
	}
	dev_dbg(sst_drv_ctx->dev, "sst: Post message: header = %x\n",
				msg->mrfld_header.p.header_high.full);
	dev_dbg(sst_drv_ctx->dev, "sst: size = 0x%x\n",
			msg->mrfld_header.p.header_low_payload);

	if (msg->mrfld_header.p.header_high.part.large)
		memcpy_toio(sst_drv_ctx->mailbox + SST_MAILBOX_SEND,
			msg->mailbox_data,
			msg->mrfld_header.p.header_low_payload);

	sst_shim_write64(sst_drv_ctx->shim, SST_IPCX, msg->mrfld_header.full);

out:
	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
	kfree(msg->mailbox_data);
	kfree(msg);
	return retval;
}

void intel_sst_clear_intr_mrfld(struct intel_sst_drv *sst_drv_ctx)
{
	union interrupt_reg_mrfld isr;
	union interrupt_reg_mrfld imr;
	union ipc_header_mrfld clear_ipc;
	unsigned long irq_flags;

	spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
	imr.full = sst_shim_read64(sst_drv_ctx->shim, SST_IMRX);
	isr.full = sst_shim_read64(sst_drv_ctx->shim, SST_ISRX);

	/* write 1 to clear*/
	isr.part.busy_interrupt = 1;
	sst_shim_write64(sst_drv_ctx->shim, SST_ISRX, isr.full);

	/* Set IA done bit */
	clear_ipc.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCD);

	clear_ipc.p.header_high.part.busy = 0;
	clear_ipc.p.header_high.part.done = 1;
	clear_ipc.p.header_low_payload = IPC_ACK_SUCCESS;
	sst_shim_write64(sst_drv_ctx->shim, SST_IPCD, clear_ipc.full);
	/* un mask busy interrupt */
	imr.part.busy_interrupt = 0;
	sst_shim_write64(sst_drv_ctx->shim, SST_IMRX, imr.full);
	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
}


/*
 * process_fw_init - process the FW init msg
 *
 * @msg: IPC message mailbox data from FW
 *
 * This function processes the FW init msg from FW
 * marks FW state and prints debug info of loaded FW
 */
static void process_fw_init(struct intel_sst_drv *sst_drv_ctx,
			void *msg)
{
	struct ipc_header_fw_init *init =
		(struct ipc_header_fw_init *)msg;
	int retval = 0;

	dev_dbg(sst_drv_ctx->dev, "*** FW Init msg came***\n");
	if (init->result) {
		sst_set_fw_state_locked(sst_drv_ctx, SST_RESET);
		dev_err(sst_drv_ctx->dev, "FW Init failed, Error %x\n",
				init->result);
		retval = init->result;
		goto ret;
	}
	if (memcmp(&sst_drv_ctx->fw_version, &init->fw_version,
		   sizeof(init->fw_version)))
		dev_info(sst_drv_ctx->dev, "FW Version %02x.%02x.%02x.%02x\n",
			init->fw_version.type, init->fw_version.major,
			init->fw_version.minor, init->fw_version.build);
	dev_dbg(sst_drv_ctx->dev, "Build date %s Time %s\n",
			init->build_info.date, init->build_info.time);

	/* Save FW version */
	sst_drv_ctx->fw_version.type = init->fw_version.type;
	sst_drv_ctx->fw_version.major = init->fw_version.major;
	sst_drv_ctx->fw_version.minor = init->fw_version.minor;
	sst_drv_ctx->fw_version.build = init->fw_version.build;

ret:
	sst_wake_up_block(sst_drv_ctx, retval, FW_DWNL_ID, 0 , NULL, 0);
}

static void process_fw_async_msg(struct intel_sst_drv *sst_drv_ctx,
			struct ipc_post *msg)
{
	u32 msg_id;
	int str_id;
	u32 data_size, i;
	void *data_offset;
	struct stream_info *stream;
	u32 msg_low, pipe_id;

	msg_low = msg->mrfld_header.p.header_low_payload;
	msg_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->cmd_id;
	data_offset = (msg->mailbox_data + sizeof(struct ipc_dsp_hdr));
	data_size =  msg_low - (sizeof(struct ipc_dsp_hdr));

	switch (msg_id) {
	case IPC_SST_PERIOD_ELAPSED_MRFLD:
		pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
		str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
		if (str_id > 0) {
			dev_dbg(sst_drv_ctx->dev,
				"Period elapsed rcvd for pipe id 0x%x\n",
				pipe_id);
			stream = &sst_drv_ctx->streams[str_id];
			/* If stream is dropped, skip processing this message*/
			if (stream->status == STREAM_INIT)
				break;
			if (stream->period_elapsed)
				stream->period_elapsed(stream->pcm_substream);
			if (stream->compr_cb)
				stream->compr_cb(stream->compr_cb_param);
		}
		break;

	case IPC_IA_DRAIN_STREAM_MRFLD:
		pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
		str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
		if (str_id > 0) {
			stream = &sst_drv_ctx->streams[str_id];
			if (stream->drain_notify)
				stream->drain_notify(stream->drain_cb_param);
		}
		break;

	case IPC_IA_FW_ASYNC_ERR_MRFLD:
		dev_err(sst_drv_ctx->dev, "FW sent async error msg:\n");
		for (i = 0; i < (data_size/4); i++)
			print_hex_dump(KERN_DEBUG, NULL, DUMP_PREFIX_NONE,
					16, 4, data_offset, data_size, false);
		break;

	case IPC_IA_FW_INIT_CMPLT_MRFLD:
		process_fw_init(sst_drv_ctx, data_offset);
		break;

	case IPC_IA_BUF_UNDER_RUN_MRFLD:
		pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
		str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
		if (str_id > 0)
			dev_err(sst_drv_ctx->dev,
				"Buffer under-run for pipe:%#x str_id:%d\n",
				pipe_id, str_id);
		break;

	default:
		dev_err(sst_drv_ctx->dev,
			"Unrecognized async msg from FW msg_id %#x\n", msg_id);
	}
}

void sst_process_reply_mrfld(struct intel_sst_drv *sst_drv_ctx,
		struct ipc_post *msg)
{
	unsigned int drv_id;
	void *data;
	union ipc_header_high msg_high;
	u32 msg_low;
	struct ipc_dsp_hdr *dsp_hdr;

	msg_high = msg->mrfld_header.p.header_high;
	msg_low = msg->mrfld_header.p.header_low_payload;

	dev_dbg(sst_drv_ctx->dev, "IPC process message header %x payload %x\n",
			msg->mrfld_header.p.header_high.full,
			msg->mrfld_header.p.header_low_payload);

	drv_id = msg_high.part.drv_id;

	/* Check for async messages first */
	if (drv_id == SST_ASYNC_DRV_ID) {
		/*FW sent async large message*/
		process_fw_async_msg(sst_drv_ctx, msg);
		return;
	}

	/* FW sent short error response for an IPC */
	if (msg_high.part.result && drv_id && !msg_high.part.large) {
		/* 32-bit FW error code in msg_low */
		dev_err(sst_drv_ctx->dev, "FW sent error response 0x%x", msg_low);
		sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
			msg_high.part.drv_id,
			msg_high.part.msg_id, NULL, 0);
		return;
	}

	/*
	 * Process all valid responses
	 * if it is a large message, the payload contains the size to
	 * copy from mailbox
	 **/
	if (msg_high.part.large) {
		data = kmemdup((void *)msg->mailbox_data, msg_low, GFP_KERNEL);
		if (!data)
			return;
		/* Copy command id so that we can use to put sst to reset */
		dsp_hdr = (struct ipc_dsp_hdr *)data;
		dev_dbg(sst_drv_ctx->dev, "cmd_id %d\n", dsp_hdr->cmd_id);
		if (sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
				msg_high.part.drv_id,
				msg_high.part.msg_id, data, msg_low))
			kfree(data);
	} else {
		sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
				msg_high.part.drv_id,
				msg_high.part.msg_id, NULL, 0);
	}

}
Commit	Line	Data
ea12aa4a VK	1	/*
	2	* sst_ipc.c - Intel SST Driver for audio engine
	3	*
	4	* Copyright (C) 2008-14 Intel Corporation
	5	* Authors: Vinod Koul <vinod.koul@intel.com>
	6	* Harsha Priya <priya.harsha@intel.com>
	7	* Dharageswari R <dharageswari.r@intel.com>
	8	* KP Jeeja <jeeja.kp@intel.com>
	9	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; version 2 of the License.
	14	*
	15	* This program is distributed in the hope that it will be useful, but
	16	* WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	* General Public License for more details.
	19	*
	20	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	21	*/
	22	#include <linux/pci.h>
	23	#include <linux/firmware.h>
	24	#include <linux/sched.h>
	25	#include <linux/delay.h>
	26	#include <linux/pm_runtime.h>
	27	#include <sound/core.h>
	28	#include <sound/pcm.h>
	29	#include <sound/soc.h>
	30	#include <sound/compress_driver.h>
	31	#include <asm/intel-mid.h>
	32	#include <asm/platform_sst_audio.h>
	33	#include "../sst-mfld-platform.h"
	34	#include "sst.h"
b97169da	35	#include "../../common/sst-dsp.h"
ea12aa4a VK	36
	37	struct sst_block sst_create_block(struct intel_sst_drv ctx,
	38	u32 msg_id, u32 drv_id)
	39	{
	40	struct sst_block *msg = NULL;
	41
	42	dev_dbg(ctx->dev, "Enter\n");
	43	msg = kzalloc(sizeof(*msg), GFP_KERNEL);
	44	if (!msg)
	45	return NULL;
	46	msg->condition = false;
	47	msg->on = true;
	48	msg->msg_id = msg_id;
	49	msg->drv_id = drv_id;
	50	spin_lock_bh(&ctx->block_lock);
	51	list_add_tail(&msg->node, &ctx->block_list);
	52	spin_unlock_bh(&ctx->block_lock);
	53
	54	return msg;
	55	}
	56
33c1256f VK	57	/*
	58	* while handling the interrupts, we need to check for message status and
	59	* then if we are blocking for a message
	60	*
	61	* here we are unblocking the blocked ones, this is based on id we have
	62	* passed and search that for block threads.
	63	* We will not find block in two cases
	64	* a) when its small message and block in not there, so silently ignore
	65	* them
	66	* b) when we are actually not able to find the block (bug perhaps)
	67	*
	68	* Since we have bit of small messages we can spam kernel log with err
	69	* print on above so need to keep as debug prints which should be enabled
	70	* via dynamic debug while debugging IPC issues
	71	*/
ea12aa4a VK	72	int sst_wake_up_block(struct intel_sst_drv *ctx, int result,
	73	u32 drv_id, u32 ipc, void *data, u32 size)
	74	{
	75	struct sst_block *block = NULL;
	76
	77	dev_dbg(ctx->dev, "Enter\n");
	78
	79	spin_lock_bh(&ctx->block_lock);
	80	list_for_each_entry(block, &ctx->block_list, node) {
	81	dev_dbg(ctx->dev, "Block ipc %d, drv_id %d\n", block->msg_id,
	82	block->drv_id);
	83	if (block->msg_id == ipc && block->drv_id == drv_id) {
	84	dev_dbg(ctx->dev, "free up the block\n");
	85	block->ret_code = result;
	86	block->data = data;
	87	block->size = size;
	88	block->condition = true;
	89	spin_unlock_bh(&ctx->block_lock);
	90	wake_up(&ctx->wait_queue);
	91	return 0;
	92	}
	93	}
	94	spin_unlock_bh(&ctx->block_lock);
	95	dev_dbg(ctx->dev,
	96	"Block not found or a response received for a short msg for ipc %d, drv_id %d\n",
	97	ipc, drv_id);
	98	return -EINVAL;
	99	}
	100
	101	int sst_free_block(struct intel_sst_drv ctx, struct sst_block freed)
	102	{
	103	struct sst_block block = NULL, __block;
	104
	105	dev_dbg(ctx->dev, "Enter\n");
	106	spin_lock_bh(&ctx->block_lock);
	107	list_for_each_entry_safe(block, __block, &ctx->block_list, node) {
	108	if (block == freed) {
	109	pr_debug("pvt_id freed --> %d\n", freed->drv_id);
	110	/* toggle the index position of pvt_id */
	111	list_del(&freed->node);
	112	spin_unlock_bh(&ctx->block_lock);
	113	kfree(freed->data);
	114	freed->data = NULL;
	115	kfree(freed);
	116	return 0;
	117	}
	118	}
	119	spin_unlock_bh(&ctx->block_lock);
	120	dev_err(ctx->dev, "block is already freed!!!\n");
	121	return -EINVAL;
	122	}
	123
	124	int sst_post_message_mrfld(struct intel_sst_drv *sst_drv_ctx,
	125	struct ipc_post *ipc_msg, bool sync)
	126	{
	127	struct ipc_post *msg = ipc_msg;
	128	union ipc_header_mrfld header;
	129	unsigned int loop_count = 0;
	130	int retval = 0;
	131	unsigned long irq_flags;
	132
	133	dev_dbg(sst_drv_ctx->dev, "Enter: sync: %d\n", sync);
	134	spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
	135	header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
136	if (sync) {
137	while (header.p.header_high.part.busy) {
138	if (loop_count > 25) {
139	dev_err(sst_drv_ctx->dev,
140	"sst: Busy wait failed, cant send this msg\n");
141	retval = -EBUSY;
142	goto out;
143	}
144	cpu_relax();
145	loop_count++;
146	header.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCX);
147	}
148	} else {
149	if (list_empty(&sst_drv_ctx->ipc_dispatch_list)) {
150	/* queue is empty, nothing to send */
151	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
152	dev_dbg(sst_drv_ctx->dev,
153	"Empty msg queue... NO Action\n");
154	return 0;
155	}
156
157	if (header.p.header_high.part.busy) {
158	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
159	dev_dbg(sst_drv_ctx->dev, "Busy not free... post later\n");
160	return 0;
161	}
162
163	/* copy msg from list */
164	msg = list_entry(sst_drv_ctx->ipc_dispatch_list.next,
165	struct ipc_post, node);
166	list_del(&msg->node);
167	}
168	dev_dbg(sst_drv_ctx->dev, "sst: Post message: header = %x\n",
169	msg->mrfld_header.p.header_high.full);
170	dev_dbg(sst_drv_ctx->dev, "sst: size = 0x%x\n",
171	msg->mrfld_header.p.header_low_payload);
172
173	if (msg->mrfld_header.p.header_high.part.large)
174	memcpy_toio(sst_drv_ctx->mailbox + SST_MAILBOX_SEND,
175	msg->mailbox_data,
176	msg->mrfld_header.p.header_low_payload);
177
178	sst_shim_write64(sst_drv_ctx->shim, SST_IPCX, msg->mrfld_header.full);
179
180	out:
181	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
182	kfree(msg->mailbox_data);
183	kfree(msg);
184	return retval;
185	}
186
187	void intel_sst_clear_intr_mrfld(struct intel_sst_drv *sst_drv_ctx)
188	{
189	union interrupt_reg_mrfld isr;
190	union interrupt_reg_mrfld imr;
191	union ipc_header_mrfld clear_ipc;
192	unsigned long irq_flags;
193
194	spin_lock_irqsave(&sst_drv_ctx->ipc_spin_lock, irq_flags);
195	imr.full = sst_shim_read64(sst_drv_ctx->shim, SST_IMRX);
196	isr.full = sst_shim_read64(sst_drv_ctx->shim, SST_ISRX);
197
198	/* write 1 to clear*/
199	isr.part.busy_interrupt = 1;
200	sst_shim_write64(sst_drv_ctx->shim, SST_ISRX, isr.full);
201
202	/* Set IA done bit */
203	clear_ipc.full = sst_shim_read64(sst_drv_ctx->shim, SST_IPCD);
204
205	clear_ipc.p.header_high.part.busy = 0;
206	clear_ipc.p.header_high.part.done = 1;
207	clear_ipc.p.header_low_payload = IPC_ACK_SUCCESS;
208	sst_shim_write64(sst_drv_ctx->shim, SST_IPCD, clear_ipc.full);
209	/* un mask busy interrupt */
210	imr.part.busy_interrupt = 0;
211	sst_shim_write64(sst_drv_ctx->shim, SST_IMRX, imr.full);
212	spin_unlock_irqrestore(&sst_drv_ctx->ipc_spin_lock, irq_flags);
213	}
214
215
216	/*
217	* process_fw_init - process the FW init msg
218	*
219	* @msg: IPC message mailbox data from FW
220	*
221	* This function processes the FW init msg from FW
222	* marks FW state and prints debug info of loaded FW
223	*/
224	static void process_fw_init(struct intel_sst_drv *sst_drv_ctx,
225	void *msg)
226	{
227	struct ipc_header_fw_init *init =
228	(struct ipc_header_fw_init *)msg;
229	int retval = 0;
230
231	dev_dbg(sst_drv_ctx->dev, "* FW Init msg came*\n");
232	if (init->result) {
45f31bfc	233	sst_set_fw_state_locked(sst_drv_ctx, SST_RESET);
ea12aa4a VK	234	dev_err(sst_drv_ctx->dev, "FW Init failed, Error %x\n",
	235	init->result);
	236	retval = init->result;
	237	goto ret;
	238	}
36d96039 TI	239	if (memcmp(&sst_drv_ctx->fw_version, &init->fw_version,
	240	sizeof(init->fw_version)))
	241	dev_info(sst_drv_ctx->dev, "FW Version %02x.%02x.%02x.%02x\n",
6a7f5e41 SG	242	init->fw_version.type, init->fw_version.major,
	243	init->fw_version.minor, init->fw_version.build);
	244	dev_dbg(sst_drv_ctx->dev, "Build date %s Time %s\n",
	245	init->build_info.date, init->build_info.time);
ea12aa4a	246
c7da1e9d SG	247	/* Save FW version */
	248	sst_drv_ctx->fw_version.type = init->fw_version.type;
	249	sst_drv_ctx->fw_version.major = init->fw_version.major;
	250	sst_drv_ctx->fw_version.minor = init->fw_version.minor;
	251	sst_drv_ctx->fw_version.build = init->fw_version.build;
	252
ea12aa4a VK	253	ret:
	254	sst_wake_up_block(sst_drv_ctx, retval, FW_DWNL_ID, 0 , NULL, 0);
	255	}
	256
	257	static void process_fw_async_msg(struct intel_sst_drv *sst_drv_ctx,
	258	struct ipc_post *msg)
	259	{
	260	u32 msg_id;
	261	int str_id;
	262	u32 data_size, i;
	263	void *data_offset;
	264	struct stream_info *stream;
ea12aa4a VK	265	u32 msg_low, pipe_id;
ea12aa4a VK	266
ea12aa4a VK	267	msg_low = msg->mrfld_header.p.header_low_payload;
	268	msg_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->cmd_id;
	269	data_offset = (msg->mailbox_data + sizeof(struct ipc_dsp_hdr));
	270	data_size = msg_low - (sizeof(struct ipc_dsp_hdr));
	271
	272	switch (msg_id) {
	273	case IPC_SST_PERIOD_ELAPSED_MRFLD:
	274	pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
	275	str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
	276	if (str_id > 0) {
	277	dev_dbg(sst_drv_ctx->dev,
	278	"Period elapsed rcvd for pipe id 0x%x\n",
	279	pipe_id);
	280	stream = &sst_drv_ctx->streams[str_id];
de34dcfe HP	281	/* If stream is dropped, skip processing this message*/
	282	if (stream->status == STREAM_INIT)
	283	break;
ea12aa4a VK	284	if (stream->period_elapsed)
	285	stream->period_elapsed(stream->pcm_substream);
	286	if (stream->compr_cb)
	287	stream->compr_cb(stream->compr_cb_param);
	288	}
	289	break;
	290
	291	case IPC_IA_DRAIN_STREAM_MRFLD:
	292	pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
	293	str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
	294	if (str_id > 0) {
	295	stream = &sst_drv_ctx->streams[str_id];
	296	if (stream->drain_notify)
	297	stream->drain_notify(stream->drain_cb_param);
	298	}
	299	break;
	300
	301	case IPC_IA_FW_ASYNC_ERR_MRFLD:
	302	dev_err(sst_drv_ctx->dev, "FW sent async error msg:\n");
	303	for (i = 0; i < (data_size/4); i++)
	304	print_hex_dump(KERN_DEBUG, NULL, DUMP_PREFIX_NONE,
	305	16, 4, data_offset, data_size, false);
	306	break;
	307
	308	case IPC_IA_FW_INIT_CMPLT_MRFLD:
	309	process_fw_init(sst_drv_ctx, data_offset);
	310	break;
	311
	312	case IPC_IA_BUF_UNDER_RUN_MRFLD:
	313	pipe_id = ((struct ipc_dsp_hdr *)msg->mailbox_data)->pipe_id;
	314	str_id = get_stream_id_mrfld(sst_drv_ctx, pipe_id);
	315	if (str_id > 0)
	316	dev_err(sst_drv_ctx->dev,
	317	"Buffer under-run for pipe:%#x str_id:%d\n",
	318	pipe_id, str_id);
	319	break;
	320
	321	default:
	322	dev_err(sst_drv_ctx->dev,
	323	"Unrecognized async msg from FW msg_id %#x\n", msg_id);
	324	}
	325	}
	326
	327	void sst_process_reply_mrfld(struct intel_sst_drv *sst_drv_ctx,
	328	struct ipc_post *msg)
	329	{
	330	unsigned int drv_id;
	331	void *data;
	332	union ipc_header_high msg_high;
	333	u32 msg_low;
	334	struct ipc_dsp_hdr *dsp_hdr;
ea12aa4a VK	335
	336	msg_high = msg->mrfld_header.p.header_high;
	337	msg_low = msg->mrfld_header.p.header_low_payload;
	338
	339	dev_dbg(sst_drv_ctx->dev, "IPC process message header %x payload %x\n",
	340	msg->mrfld_header.p.header_high.full,
	341	msg->mrfld_header.p.header_low_payload);
	342
	343	drv_id = msg_high.part.drv_id;
	344
	345	/* Check for async messages first */
	346	if (drv_id == SST_ASYNC_DRV_ID) {
	347	/FW sent async large message/
	348	process_fw_async_msg(sst_drv_ctx, msg);
	349	return;
	350	}
	351
	352	/* FW sent short error response for an IPC */
	353	if (msg_high.part.result && drv_id && !msg_high.part.large) {
	354	/* 32-bit FW error code in msg_low */
	355	dev_err(sst_drv_ctx->dev, "FW sent error response 0x%x", msg_low);
	356	sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
	357	msg_high.part.drv_id,
	358	msg_high.part.msg_id, NULL, 0);
	359	return;
	360	}
	361
	362	/*
	363	* Process all valid responses
	364	* if it is a large message, the payload contains the size to
	365	* copy from mailbox
	366	**/
	367	if (msg_high.part.large) {
b42e093e	368	data = kmemdup((void *)msg->mailbox_data, msg_low, GFP_KERNEL);
ea12aa4a VK	369	if (!data)
ea12aa4a VK	370	return;
ea12aa4a VK	371	/* Copy command id so that we can use to put sst to reset */
ea12aa4a VK	372	dsp_hdr = (struct ipc_dsp_hdr *)data;
ea12aa4a VK	373	dev_dbg(sst_drv_ctx->dev, "cmd_id %d\n", dsp_hdr->cmd_id);
	374	if (sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
	375	msg_high.part.drv_id,
	376	msg_high.part.msg_id, data, msg_low))
	377	kfree(data);
	378	} else {
	379	sst_wake_up_block(sst_drv_ctx, msg_high.part.result,
	380	msg_high.part.drv_id,
	381	msg_high.part.msg_id, NULL, 0);
	382	}
	383
	384	}