[deliverable/linux.git] / sound / soc / intel / sst / sst_stream.c

/*
 *  sst_stream.c - Intel SST Driver for audio engine
 *
 *  Copyright (C) 2008-14 Intel Corp
 *  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/platform_sst_audio.h>
#include "../sst-mfld-platform.h"
#include "sst.h"
#include "../sst-dsp.h"

int sst_alloc_stream_mrfld(struct intel_sst_drv *sst_drv_ctx, void *params)
{
	struct snd_sst_alloc_mrfld alloc_param;
	struct snd_sst_params *str_params;
	struct snd_sst_tstamp fw_tstamp;
	struct stream_info *str_info;
	struct snd_sst_alloc_response *response;
	unsigned int str_id, pipe_id, task_id;
	int i, num_ch, ret = 0;
	void *data = NULL;

	dev_dbg(sst_drv_ctx->dev, "Enter\n");
	BUG_ON(!params);

	str_params = (struct snd_sst_params *)params;
	memset(&alloc_param, 0, sizeof(alloc_param));
	alloc_param.operation = str_params->ops;
	alloc_param.codec_type = str_params->codec;
	alloc_param.sg_count = str_params->aparams.sg_count;
	alloc_param.ring_buf_info[0].addr =
		str_params->aparams.ring_buf_info[0].addr;
	alloc_param.ring_buf_info[0].size =
		str_params->aparams.ring_buf_info[0].size;
	alloc_param.frag_size = str_params->aparams.frag_size;

	memcpy(&alloc_param.codec_params, &str_params->sparams,
			sizeof(struct snd_sst_stream_params));

	/*
	 * fill channel map params for multichannel support.
	 * Ideally channel map should be received from upper layers
	 * for multichannel support.
	 * Currently hardcoding as per FW reqm.
	 */
	num_ch = sst_get_num_channel(str_params);
	for (i = 0; i < 8; i++) {
		if (i < num_ch)
			alloc_param.codec_params.uc.pcm_params.channel_map[i] = i;
		else
			alloc_param.codec_params.uc.pcm_params.channel_map[i] = 0xFF;
	}

	str_id = str_params->stream_id;
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (str_info == NULL) {
		dev_err(sst_drv_ctx->dev, "get stream info returned null\n");
		return -EINVAL;
	}

	pipe_id = str_params->device_type;
	task_id = str_params->task;
	sst_drv_ctx->streams[str_id].pipe_id = pipe_id;
	sst_drv_ctx->streams[str_id].task_id = task_id;
	sst_drv_ctx->streams[str_id].num_ch = num_ch;

	if (sst_drv_ctx->info.lpe_viewpt_rqd)
		alloc_param.ts = sst_drv_ctx->info.mailbox_start +
			sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
	else
		alloc_param.ts = sst_drv_ctx->mailbox_add +
			sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));

	dev_dbg(sst_drv_ctx->dev, "alloc tstamp location = 0x%x\n",
			alloc_param.ts);
	dev_dbg(sst_drv_ctx->dev, "assigned pipe id 0x%x to task %d\n",
			pipe_id, task_id);

	/* allocate device type context */
	sst_init_stream(&sst_drv_ctx->streams[str_id], alloc_param.codec_type,
			str_id, alloc_param.operation, 0);

	dev_info(sst_drv_ctx->dev, "Alloc for str %d pipe %#x\n",
			str_id, pipe_id);
	ret = sst_prepare_and_post_msg(sst_drv_ctx, task_id, IPC_CMD,
			IPC_IA_ALLOC_STREAM_MRFLD, pipe_id, sizeof(alloc_param),
			&alloc_param, data, true, true, false, true);

	if (ret < 0) {
		dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
		/* alloc failed, so reset the state to uninit */
		str_info->status = STREAM_UN_INIT;
		str_id = ret;
	} else if (data) {
		response = (struct snd_sst_alloc_response *)data;
		ret = response->str_type.result;
		if (!ret)
			goto out;
		dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
		if (ret == SST_ERR_STREAM_IN_USE) {
			dev_err(sst_drv_ctx->dev,
				"FW not in clean state, send free for:%d\n", str_id);
			sst_free_stream(sst_drv_ctx, str_id);
		}
		str_id = -ret;
	}
out:
	kfree(data);
	return str_id;
}

/**
* sst_start_stream - Send msg for a starting stream
* @str_id:	 stream ID
*
* This function is called by any function which wants to start
* a stream.
*/
int sst_start_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
{
	int retval = 0;
	struct stream_info *str_info;
	u16 data = 0;

	dev_dbg(sst_drv_ctx->dev, "sst_start_stream for %d\n", str_id);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;
	if (str_info->status != STREAM_RUNNING)
		return -EBADRQC;

	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
			IPC_CMD, IPC_IA_START_STREAM_MRFLD, str_info->pipe_id,
			sizeof(u16), &data, NULL, true, true, true, false);

	return retval;
}

int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx,
		struct snd_sst_bytes_v2 *bytes)
{	struct ipc_post *msg = NULL;
	u32 length;
	int pvt_id, ret = 0;
	struct sst_block *block = NULL;

	dev_dbg(sst_drv_ctx->dev,
		"type:%u ipc_msg:%u block:%u task_id:%u pipe: %#x length:%#x\n",
		bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id,
		bytes->pipe_id, bytes->len);

	if (sst_create_ipc_msg(&msg, true))
		return -ENOMEM;

	pvt_id = sst_assign_pvt_id(sst_drv_ctx);
	sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg,
			bytes->task_id, 1, pvt_id);
	msg->mrfld_header.p.header_high.part.res_rqd = bytes->block;
	length = bytes->len;
	msg->mrfld_header.p.header_low_payload = length;
	dev_dbg(sst_drv_ctx->dev, "length is %d\n", length);
	memcpy(msg->mailbox_data, &bytes->bytes, bytes->len);
	if (bytes->block) {
		block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id);
		if (block == NULL) {
			kfree(msg);
			ret = -ENOMEM;
			goto out;
		}
	}

	sst_add_to_dispatch_list_and_post(sst_drv_ctx, msg);
	dev_dbg(sst_drv_ctx->dev, "msg->mrfld_header.p.header_low_payload:%d",
			msg->mrfld_header.p.header_low_payload);

	if (bytes->block) {
		ret = sst_wait_timeout(sst_drv_ctx, block);
		if (ret) {
			dev_err(sst_drv_ctx->dev, "fw returned err %d\n", ret);
			sst_free_block(sst_drv_ctx, block);
			goto out;
		}
	}
	if (bytes->type == SND_SST_BYTES_GET) {
		/*
		 * copy the reply and send back
		 * we need to update only sz and payload
		 */
		if (bytes->block) {
			unsigned char *r = block->data;

			dev_dbg(sst_drv_ctx->dev, "read back %d bytes",
					bytes->len);
			memcpy(bytes->bytes, r, bytes->len);
		}
	}
	if (bytes->block)
		sst_free_block(sst_drv_ctx, block);
out:
	test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id);
	return 0;
}

/*
 * sst_pause_stream - Send msg for a pausing stream
 * @str_id:	 stream ID
 *
 * This function is called by any function which wants to pause
 * an already running stream.
 */
int sst_pause_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
{
	int retval = 0;
	struct stream_info *str_info;

	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_pause_stream for %d\n", str_id);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;
	if (str_info->status == STREAM_PAUSED)
		return 0;
	if (str_info->status == STREAM_RUNNING ||
		str_info->status == STREAM_INIT) {
		if (str_info->prev == STREAM_UN_INIT)
			return -EBADRQC;

		retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
				IPC_IA_PAUSE_STREAM_MRFLD, str_info->pipe_id,
				0, NULL, NULL, true, true, false, true);

		if (retval == 0) {
			str_info->prev = str_info->status;
			str_info->status = STREAM_PAUSED;
		} else if (retval == SST_ERR_INVALID_STREAM_ID) {
			retval = -EINVAL;
			mutex_lock(&sst_drv_ctx->sst_lock);
			sst_clean_stream(str_info);
			mutex_unlock(&sst_drv_ctx->sst_lock);
		}
	} else {
		retval = -EBADRQC;
		dev_dbg(sst_drv_ctx->dev, "SST DBG:BADRQC for stream\n ");
	}

	return retval;
}

/**
 * sst_resume_stream - Send msg for resuming stream
 * @str_id:		stream ID
 *
 * This function is called by any function which wants to resume
 * an already paused stream.
 */
int sst_resume_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
{
	int retval = 0;
	struct stream_info *str_info;

	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_resume_stream for %d\n", str_id);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;
	if (str_info->status == STREAM_RUNNING)
			return 0;
	if (str_info->status == STREAM_PAUSED) {
		retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
				IPC_CMD, IPC_IA_RESUME_STREAM_MRFLD,
				str_info->pipe_id, 0, NULL, NULL,
				true, true, false, true);

		if (!retval) {
			if (str_info->prev == STREAM_RUNNING)
				str_info->status = STREAM_RUNNING;
			else
				str_info->status = STREAM_INIT;
			str_info->prev = STREAM_PAUSED;
		} else if (retval == -SST_ERR_INVALID_STREAM_ID) {
			retval = -EINVAL;
			mutex_lock(&sst_drv_ctx->sst_lock);
			sst_clean_stream(str_info);
			mutex_unlock(&sst_drv_ctx->sst_lock);
		}
	} else {
		retval = -EBADRQC;
		dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream\n");
	}

	return retval;
}


/**
 * sst_drop_stream - Send msg for stopping stream
 * @str_id:		stream ID
 *
 * This function is called by any function which wants to stop
 * a stream.
 */
int sst_drop_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
{
	int retval = 0;
	struct stream_info *str_info;

	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drop_stream for %d\n", str_id);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;

	if (str_info->status != STREAM_UN_INIT) {
		str_info->prev = STREAM_UN_INIT;
		str_info->status = STREAM_INIT;
		str_info->cumm_bytes = 0;
		retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
				IPC_CMD, IPC_IA_DROP_STREAM_MRFLD,
				str_info->pipe_id, 0, NULL, NULL,
				true, true, true, false);
	} else {
		retval = -EBADRQC;
		dev_dbg(sst_drv_ctx->dev, "BADQRC for stream, state %x\n",
				str_info->status);
	}
	return retval;
}

/**
* sst_drain_stream - Send msg for draining stream
* @str_id:		stream ID
*
* This function is called by any function which wants to drain
* a stream.
*/
int sst_drain_stream(struct intel_sst_drv *sst_drv_ctx,
			int str_id, bool partial_drain)
{
	int retval = 0;
	struct stream_info *str_info;

	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drain_stream for %d\n", str_id);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;
	if (str_info->status != STREAM_RUNNING &&
		str_info->status != STREAM_INIT &&
		str_info->status != STREAM_PAUSED) {
			dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream = %d\n",
				       str_info->status);
			return -EBADRQC;
	}

	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
			IPC_IA_DRAIN_STREAM_MRFLD, str_info->pipe_id,
			sizeof(u8), &partial_drain, NULL, true, true, false, false);
	/*
	 * with new non blocked drain implementation in core we dont need to
	 * wait for respsonse, and need to only invoke callback for drain
	 * complete
	 */

	return retval;
}

/**
 * sst_free_stream - Frees a stream
 * @str_id:		stream ID
 *
 * This function is called by any function which wants to free
 * a stream.
 */
int sst_free_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
{
	int retval = 0;
	struct stream_info *str_info;
	struct intel_sst_ops *ops;

	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_free_stream for %d\n", str_id);

	mutex_lock(&sst_drv_ctx->sst_lock);
	if (sst_drv_ctx->sst_state == SST_RESET) {
		mutex_unlock(&sst_drv_ctx->sst_lock);
		return -ENODEV;
	}
	mutex_unlock(&sst_drv_ctx->sst_lock);
	str_info = get_stream_info(sst_drv_ctx, str_id);
	if (!str_info)
		return -EINVAL;
	ops = sst_drv_ctx->ops;

	mutex_lock(&str_info->lock);
	if (str_info->status != STREAM_UN_INIT) {
		str_info->prev =  str_info->status;
		str_info->status = STREAM_UN_INIT;
		mutex_unlock(&str_info->lock);

		dev_info(sst_drv_ctx->dev, "Free for str %d pipe %#x\n",
				str_id, str_info->pipe_id);
		retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
				IPC_IA_FREE_STREAM_MRFLD, str_info->pipe_id, 0,
				NULL, NULL, true, true, false, true);

		dev_dbg(sst_drv_ctx->dev, "sst: wait for free returned %d\n",
				retval);
		mutex_lock(&sst_drv_ctx->sst_lock);
		sst_clean_stream(str_info);
		mutex_unlock(&sst_drv_ctx->sst_lock);
		dev_dbg(sst_drv_ctx->dev, "SST DBG:Stream freed\n");
	} else {
		mutex_unlock(&str_info->lock);
		retval = -EBADRQC;
		dev_dbg(sst_drv_ctx->dev, "SST DBG:BADQRC for stream\n");
	}

	return retval;
}
Commit	Line	Data
3d9ff346 VK	1	/*
	2	* sst_stream.c - Intel SST Driver for audio engine
	3	*
	4	* Copyright (C) 2008-14 Intel Corp
	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/platform_sst_audio.h>
	32	#include "../sst-mfld-platform.h"
	33	#include "sst.h"
	34	#include "../sst-dsp.h"
	35
	36	int sst_alloc_stream_mrfld(struct intel_sst_drv sst_drv_ctx, void params)
	37	{
	38	struct snd_sst_alloc_mrfld alloc_param;
	39	struct snd_sst_params *str_params;
	40	struct snd_sst_tstamp fw_tstamp;
	41	struct stream_info *str_info;
	42	struct snd_sst_alloc_response *response;
	43	unsigned int str_id, pipe_id, task_id;
	44	int i, num_ch, ret = 0;
	45	void *data = NULL;
	46
	47	dev_dbg(sst_drv_ctx->dev, "Enter\n");
	48	BUG_ON(!params);
	49
	50	str_params = (struct snd_sst_params *)params;
	51	memset(&alloc_param, 0, sizeof(alloc_param));
	52	alloc_param.operation = str_params->ops;
	53	alloc_param.codec_type = str_params->codec;
	54	alloc_param.sg_count = str_params->aparams.sg_count;
	55	alloc_param.ring_buf_info[0].addr =
	56	str_params->aparams.ring_buf_info[0].addr;
	57	alloc_param.ring_buf_info[0].size =
	58	str_params->aparams.ring_buf_info[0].size;
	59	alloc_param.frag_size = str_params->aparams.frag_size;
	60
	61	memcpy(&alloc_param.codec_params, &str_params->sparams,
	62	sizeof(struct snd_sst_stream_params));
	63
	64	/*
65	* fill channel map params for multichannel support.
66	* Ideally channel map should be received from upper layers
67	* for multichannel support.
68	* Currently hardcoding as per FW reqm.
69	*/
70	num_ch = sst_get_num_channel(str_params);
71	for (i = 0; i < 8; i++) {
72	if (i < num_ch)
73	alloc_param.codec_params.uc.pcm_params.channel_map[i] = i;
74	else
75	alloc_param.codec_params.uc.pcm_params.channel_map[i] = 0xFF;
76	}
77
78	str_id = str_params->stream_id;
79	str_info = get_stream_info(sst_drv_ctx, str_id);
80	if (str_info == NULL) {
81	dev_err(sst_drv_ctx->dev, "get stream info returned null\n");
82	return -EINVAL;
83	}
84
85	pipe_id = str_params->device_type;
86	task_id = str_params->task;
87	sst_drv_ctx->streams[str_id].pipe_id = pipe_id;
88	sst_drv_ctx->streams[str_id].task_id = task_id;
89	sst_drv_ctx->streams[str_id].num_ch = num_ch;
90
91	if (sst_drv_ctx->info.lpe_viewpt_rqd)
92	alloc_param.ts = sst_drv_ctx->info.mailbox_start +
93	sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
94	else
95	alloc_param.ts = sst_drv_ctx->mailbox_add +
96	sst_drv_ctx->tstamp + (str_id * sizeof(fw_tstamp));
97
98	dev_dbg(sst_drv_ctx->dev, "alloc tstamp location = 0x%x\n",
99	alloc_param.ts);
100	dev_dbg(sst_drv_ctx->dev, "assigned pipe id 0x%x to task %d\n",
101	pipe_id, task_id);
102
103	/* allocate device type context */
104	sst_init_stream(&sst_drv_ctx->streams[str_id], alloc_param.codec_type,
105	str_id, alloc_param.operation, 0);
106
107	dev_info(sst_drv_ctx->dev, "Alloc for str %d pipe %#x\n",
108	str_id, pipe_id);
109	ret = sst_prepare_and_post_msg(sst_drv_ctx, task_id, IPC_CMD,
110	IPC_IA_ALLOC_STREAM_MRFLD, pipe_id, sizeof(alloc_param),
111	&alloc_param, data, true, true, false, true);
112
113	if (ret < 0) {
114	dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
115	/* alloc failed, so reset the state to uninit */
116	str_info->status = STREAM_UN_INIT;
117	str_id = ret;
118	} else if (data) {
119	response = (struct snd_sst_alloc_response *)data;
120	ret = response->str_type.result;
121	if (!ret)
122	goto out;
123	dev_err(sst_drv_ctx->dev, "FW alloc failed ret %d\n", ret);
124	if (ret == SST_ERR_STREAM_IN_USE) {
125	dev_err(sst_drv_ctx->dev,
126	"FW not in clean state, send free for:%d\n", str_id);
127	sst_free_stream(sst_drv_ctx, str_id);
128	}
129	str_id = -ret;
130	}
131	out:
132	kfree(data);
133	return str_id;
134	}
135
136	/**
137	* sst_start_stream - Send msg for a starting stream
138	* @str_id: stream ID
139	*
140	* This function is called by any function which wants to start
141	* a stream.
142	*/
143	int sst_start_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
144	{
145	int retval = 0;
146	struct stream_info *str_info;
147	u16 data = 0;
148
149	dev_dbg(sst_drv_ctx->dev, "sst_start_stream for %d\n", str_id);
150	str_info = get_stream_info(sst_drv_ctx, str_id);
151	if (!str_info)
152	return -EINVAL;
153	if (str_info->status != STREAM_RUNNING)
154	return -EBADRQC;
155
156	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
157	IPC_CMD, IPC_IA_START_STREAM_MRFLD, str_info->pipe_id,
158	sizeof(u16), &data, NULL, true, true, true, false);
159
160	return retval;
161	}
162
163	int sst_send_byte_stream_mrfld(struct intel_sst_drv *sst_drv_ctx,
164	struct snd_sst_bytes_v2 *bytes)
165	{ struct ipc_post *msg = NULL;
166	u32 length;
167	int pvt_id, ret = 0;
168	struct sst_block *block = NULL;
169
170	dev_dbg(sst_drv_ctx->dev,
171	"type:%u ipc_msg:%u block:%u task_id:%u pipe: %#x length:%#x\n",
172	bytes->type, bytes->ipc_msg, bytes->block, bytes->task_id,
173	bytes->pipe_id, bytes->len);
174
175	if (sst_create_ipc_msg(&msg, true))
176	return -ENOMEM;
177
178	pvt_id = sst_assign_pvt_id(sst_drv_ctx);
179	sst_fill_header_mrfld(&msg->mrfld_header, bytes->ipc_msg,
180	bytes->task_id, 1, pvt_id);
181	msg->mrfld_header.p.header_high.part.res_rqd = bytes->block;
182	length = bytes->len;
183	msg->mrfld_header.p.header_low_payload = length;
184	dev_dbg(sst_drv_ctx->dev, "length is %d\n", length);
185	memcpy(msg->mailbox_data, &bytes->bytes, bytes->len);
186	if (bytes->block) {
187	block = sst_create_block(sst_drv_ctx, bytes->ipc_msg, pvt_id);
188	if (block == NULL) {
189	kfree(msg);
190	ret = -ENOMEM;
191	goto out;
192	}
193	}
194
195	sst_add_to_dispatch_list_and_post(sst_drv_ctx, msg);
196	dev_dbg(sst_drv_ctx->dev, "msg->mrfld_header.p.header_low_payload:%d",
197	msg->mrfld_header.p.header_low_payload);
198
199	if (bytes->block) {
200	ret = sst_wait_timeout(sst_drv_ctx, block);
201	if (ret) {
202	dev_err(sst_drv_ctx->dev, "fw returned err %d\n", ret);
203	sst_free_block(sst_drv_ctx, block);
204	goto out;
205	}
206	}
207	if (bytes->type == SND_SST_BYTES_GET) {
208	/*
209	* copy the reply and send back
210	* we need to update only sz and payload
211	*/
212	if (bytes->block) {
213	unsigned char *r = block->data;
214
215	dev_dbg(sst_drv_ctx->dev, "read back %d bytes",
216	bytes->len);
217	memcpy(bytes->bytes, r, bytes->len);
218	}
219	}
220	if (bytes->block)
221	sst_free_block(sst_drv_ctx, block);
222	out:
223	test_and_clear_bit(pvt_id, &sst_drv_ctx->pvt_id);
224	return 0;
225	}
226
227	/*
228	* sst_pause_stream - Send msg for a pausing stream
229	* @str_id: stream ID
230	*
231	* This function is called by any function which wants to pause
232	* an already running stream.
233	*/
234	int sst_pause_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
235	{
236	int retval = 0;
237	struct stream_info *str_info;
238
239	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_pause_stream for %d\n", str_id);
240	str_info = get_stream_info(sst_drv_ctx, str_id);
241	if (!str_info)
242	return -EINVAL;
243	if (str_info->status == STREAM_PAUSED)
244	return 0;
245	if (str_info->status == STREAM_RUNNING \|\|
246	str_info->status == STREAM_INIT) {
247	if (str_info->prev == STREAM_UN_INIT)
248	return -EBADRQC;
249
250	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
251	IPC_IA_PAUSE_STREAM_MRFLD, str_info->pipe_id,
252	0, NULL, NULL, true, true, false, true);
253
254	if (retval == 0) {
255	str_info->prev = str_info->status;
256	str_info->status = STREAM_PAUSED;
257	} else if (retval == SST_ERR_INVALID_STREAM_ID) {
258	retval = -EINVAL;
259	mutex_lock(&sst_drv_ctx->sst_lock);
260	sst_clean_stream(str_info);
261	mutex_unlock(&sst_drv_ctx->sst_lock);
262	}
263	} else {
264	retval = -EBADRQC;
265	dev_dbg(sst_drv_ctx->dev, "SST DBG:BADRQC for stream\n ");
266	}
267
268	return retval;
269	}
270
271	/**
272	* sst_resume_stream - Send msg for resuming stream
273	* @str_id: stream ID
274	*
275	* This function is called by any function which wants to resume
276	* an already paused stream.
277	*/
278	int sst_resume_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
279	{
280	int retval = 0;
281	struct stream_info *str_info;
282
283	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_resume_stream for %d\n", str_id);
284	str_info = get_stream_info(sst_drv_ctx, str_id);
285	if (!str_info)
286	return -EINVAL;
287	if (str_info->status == STREAM_RUNNING)
288	return 0;
289	if (str_info->status == STREAM_PAUSED) {
290	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
291	IPC_CMD, IPC_IA_RESUME_STREAM_MRFLD,
292	str_info->pipe_id, 0, NULL, NULL,
293	true, true, false, true);
294
295	if (!retval) {
296	if (str_info->prev == STREAM_RUNNING)
297	str_info->status = STREAM_RUNNING;
298	else
299	str_info->status = STREAM_INIT;
300	str_info->prev = STREAM_PAUSED;
301	} else if (retval == -SST_ERR_INVALID_STREAM_ID) {
302	retval = -EINVAL;
303	mutex_lock(&sst_drv_ctx->sst_lock);
304	sst_clean_stream(str_info);
305	mutex_unlock(&sst_drv_ctx->sst_lock);
306	}
307	} else {
308	retval = -EBADRQC;
309	dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream\n");
310	}
311
312	return retval;
313	}
314
315
316	/**
317	* sst_drop_stream - Send msg for stopping stream
318	* @str_id: stream ID
319	*
320	* This function is called by any function which wants to stop
321	* a stream.
322	*/
323	int sst_drop_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
324	{
325	int retval = 0;
326	struct stream_info *str_info;
327
328	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drop_stream for %d\n", str_id);
329	str_info = get_stream_info(sst_drv_ctx, str_id);
330	if (!str_info)
331	return -EINVAL;
332
333	if (str_info->status != STREAM_UN_INIT) {
334	str_info->prev = STREAM_UN_INIT;
335	str_info->status = STREAM_INIT;
336	str_info->cumm_bytes = 0;
337	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id,
338	IPC_CMD, IPC_IA_DROP_STREAM_MRFLD,
339	str_info->pipe_id, 0, NULL, NULL,
340	true, true, true, false);
341	} else {
342	retval = -EBADRQC;
343	dev_dbg(sst_drv_ctx->dev, "BADQRC for stream, state %x\n",
344	str_info->status);
345	}
346	return retval;
347	}
348
349	/**
350	* sst_drain_stream - Send msg for draining stream
351	* @str_id: stream ID
352	*
353	* This function is called by any function which wants to drain
354	* a stream.
355	*/
356	int sst_drain_stream(struct intel_sst_drv *sst_drv_ctx,
357	int str_id, bool partial_drain)
358	{
359	int retval = 0;
360	struct stream_info *str_info;
361
362	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_drain_stream for %d\n", str_id);
363	str_info = get_stream_info(sst_drv_ctx, str_id);
364	if (!str_info)
365	return -EINVAL;
366	if (str_info->status != STREAM_RUNNING &&
367	str_info->status != STREAM_INIT &&
368	str_info->status != STREAM_PAUSED) {
369	dev_err(sst_drv_ctx->dev, "SST ERR: BADQRC for stream = %d\n",
370	str_info->status);
371	return -EBADRQC;
372	}
373
374	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
375	IPC_IA_DRAIN_STREAM_MRFLD, str_info->pipe_id,
376	sizeof(u8), &partial_drain, NULL, true, true, false, false);
377	/*
378	* with new non blocked drain implementation in core we dont need to
379	* wait for respsonse, and need to only invoke callback for drain
380	* complete
381	*/
382
383	return retval;
384	}
385
386	/**
387	* sst_free_stream - Frees a stream
388	* @str_id: stream ID
389	*
390	* This function is called by any function which wants to free
391	* a stream.
392	*/
393	int sst_free_stream(struct intel_sst_drv *sst_drv_ctx, int str_id)
394	{
395	int retval = 0;
396	struct stream_info *str_info;
397	struct intel_sst_ops *ops;
398
399	dev_dbg(sst_drv_ctx->dev, "SST DBG:sst_free_stream for %d\n", str_id);
400
401	mutex_lock(&sst_drv_ctx->sst_lock);
402	if (sst_drv_ctx->sst_state == SST_RESET) {
403	mutex_unlock(&sst_drv_ctx->sst_lock);
404	return -ENODEV;
405	}
406	mutex_unlock(&sst_drv_ctx->sst_lock);
407	str_info = get_stream_info(sst_drv_ctx, str_id);
408	if (!str_info)
409	return -EINVAL;
410	ops = sst_drv_ctx->ops;
411
412	mutex_lock(&str_info->lock);
413	if (str_info->status != STREAM_UN_INIT) {
414	str_info->prev = str_info->status;
415	str_info->status = STREAM_UN_INIT;
416	mutex_unlock(&str_info->lock);
417
418	dev_info(sst_drv_ctx->dev, "Free for str %d pipe %#x\n",
419	str_id, str_info->pipe_id);
420	retval = sst_prepare_and_post_msg(sst_drv_ctx, str_info->task_id, IPC_CMD,
421	IPC_IA_FREE_STREAM_MRFLD, str_info->pipe_id, 0,
422	NULL, NULL, true, true, false, true);
423
424	dev_dbg(sst_drv_ctx->dev, "sst: wait for free returned %d\n",
425	retval);
426	mutex_lock(&sst_drv_ctx->sst_lock);
427	sst_clean_stream(str_info);
428	mutex_unlock(&sst_drv_ctx->sst_lock);
429	dev_dbg(sst_drv_ctx->dev, "SST DBG:Stream freed\n");
430	} else {
431	mutex_unlock(&str_info->lock);
432	retval = -EBADRQC;
433	dev_dbg(sst_drv_ctx->dev, "SST DBG:BADQRC for stream\n");
434	}
435
436	return retval;
437	}