[net-next-2.6.git] / drivers / staging / intel_sst / intel_sst_drv_interface.c

/*
 *  intel_sst_interface.c - Intel SST Driver for audio engine
 *
 *  Copyright (C) 2008-10 Intel Corp
 *  Authors:	Vinod Koul <vinod.koul@intel.com>
 *		Harsha Priya <priya.harsha@intel.com>
 *		Dharageswari R <dharageswari.r@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.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *  This driver exposes the audio engine functionalities to the ALSA
 *	and middleware.
 *  Upper layer interfaces (MAD driver, MMF) to SST driver
 */

#include <linux/delay.h>
#include <linux/pci.h>
#include <linux/fs.h>
#include <linux/firmware.h>
#include "intel_sst.h"
#include "intel_sst_ioctl.h"
#include "intel_sst_fw_ipc.h"
#include "intel_sst_common.h"


/*
 * sst_download_fw - download the audio firmware to DSP
 *
 * This function is called when the FW needs to be downloaded to SST DSP engine
 */
int sst_download_fw(void)
{
	int retval;
	const struct firmware *fw_sst;
	const char *name;
	if (sst_drv_ctx->sst_state != SST_UN_INIT)
		return -EPERM;
	if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
		name = SST_FW_FILENAME_MRST;
	else
		name = SST_FW_FILENAME_MFLD;
	pr_debug("sst: Downloading %s FW now...\n", name);
	retval = request_firmware(&fw_sst, name, &sst_drv_ctx->pci->dev);
	if (retval) {
		pr_err("sst: request fw failed %d\n", retval);
		return retval;
	}
	sst_drv_ctx->alloc_block[0].sst_id = FW_DWNL_ID;
	sst_drv_ctx->alloc_block[0].ops_block.condition = false;
	retval = sst_load_fw(fw_sst, NULL);
	if (retval)
		goto end_restore;

	retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[0]);
	if (retval)
		pr_err("sst: fw download failed %d\n" , retval);
end_restore:
	release_firmware(fw_sst);
	sst_drv_ctx->alloc_block[0].sst_id = BLOCK_UNINIT;
	return retval;
}


/*
 * sst_stalled - this function checks if the lpe is in stalled state
 */
int sst_stalled(void)
{
	int retry = 1000;
	int retval = -1;

	while (retry) {
		if (!sst_drv_ctx->lpe_stalled)
			return 0;
		/*wait for time and re-check*/
		msleep(1);

		retry--;
	}
	pr_debug("sst: in Stalled State\n");
	return retval;
}

void free_stream_context(unsigned int str_id)
{
	struct stream_info *stream;

	if (!sst_validate_strid(str_id)) {
		/* str_id is valid, so stream is alloacted */
		stream = &sst_drv_ctx->streams[str_id];
		if (stream->ops == STREAM_OPS_PLAYBACK ||
				stream->ops == STREAM_OPS_PLAYBACK_DRM) {
			sst_drv_ctx->pb_streams--;
			if (sst_drv_ctx->pb_streams == 0)
				sst_drv_ctx->scard_ops->power_down_pmic_pb();
		} else if (stream->ops == STREAM_OPS_CAPTURE) {
			sst_drv_ctx->cp_streams--;
			if (sst_drv_ctx->cp_streams == 0)
				sst_drv_ctx->scard_ops->power_down_pmic_cp();
		}
		if (sst_drv_ctx->pb_streams == 0
				&& sst_drv_ctx->cp_streams == 0)
			sst_drv_ctx->scard_ops->power_down_pmic();
		if (sst_free_stream(str_id))
			sst_clean_stream(&sst_drv_ctx->streams[str_id]);
	}
}

/*
 * sst_get_stream_allocated - this function gets a stream allocated with
 * the given params
 *
 * @str_param : stream params
 * @lib_dnld : pointer to pointer of lib downlaod struct
 *
 * This creates new stream id for a stream, in case lib is to be downloaded to
 * DSP, it downloads that
 */
int sst_get_stream_allocated(struct snd_sst_params *str_param,
		struct snd_sst_lib_download **lib_dnld)
{
	int retval, str_id;
	struct stream_info *str_info;

	retval = sst_alloc_stream((char *) &str_param->sparams, str_param->ops,
				str_param->codec, str_param->device_type);
	if (retval < 0) {
		pr_err("sst: sst_alloc_stream failed %d\n", retval);
		return retval;
	}
	pr_debug("sst: Stream allocated %d\n", retval);
	str_id = retval;
	str_info = &sst_drv_ctx->streams[str_id];
	/* Block the call for reply */
	retval = sst_wait_interruptible_timeout(sst_drv_ctx,
			&str_info->ctrl_blk, SST_BLOCK_TIMEOUT);
	if ((retval != 0) || (str_info->ctrl_blk.ret_code != 0)) {
		pr_debug("sst: FW alloc failed retval %d, ret_code %d\n",
				retval, str_info->ctrl_blk.ret_code);
		str_id = -str_info->ctrl_blk.ret_code; /*return error*/
		*lib_dnld = str_info->ctrl_blk.data;
		sst_clean_stream(str_info);
	} else
		pr_debug("sst: FW Stream allocated sucess\n");
	return str_id; /*will ret either error (in above if) or correct str id*/
}

/*
 * sst_get_sfreq - this function returns the frequency of the stream
 *
 * @str_param : stream params
 */
static int sst_get_sfreq(struct snd_sst_params *str_param)
{
	switch (str_param->codec) {
	case SST_CODEC_TYPE_PCM:
		return 48000; /*str_param->sparams.uc.pcm_params.sfreq;*/
	case SST_CODEC_TYPE_MP3:
		return str_param->sparams.uc.mp3_params.sfreq;
	case SST_CODEC_TYPE_AAC:
		return str_param->sparams.uc.aac_params.sfreq;;
	case SST_CODEC_TYPE_WMA9:
		return str_param->sparams.uc.wma_params.sfreq;;
	default:
		return 0;
	}
}

/*
 * sst_get_stream - this function prepares for stream allocation
 *
 * @str_param : stream param
 */
int sst_get_stream(struct snd_sst_params *str_param)
{
	int i, retval;
	struct stream_info *str_info;
	struct snd_sst_lib_download *lib_dnld;

	/* stream is not allocated, we are allocating */
	retval = sst_get_stream_allocated(str_param, &lib_dnld);
	if (retval == -(SST_LIB_ERR_LIB_DNLD_REQUIRED)) {
		/* codec download is required */
		struct snd_sst_alloc_response *response;

		pr_debug("sst: Codec is required.... trying that\n");
		if (lib_dnld == NULL) {
			pr_err("sst: lib download null!!! abort\n");
			return -EIO;
		}
		i = sst_get_block_stream(sst_drv_ctx);
		response = sst_drv_ctx->alloc_block[i].ops_block.data;
		pr_debug("sst: alloc block allocated = %d\n", i);
		if (i < 0) {
			kfree(lib_dnld);
			return -ENOMEM;
		}
		retval = sst_load_library(lib_dnld, str_param->ops);
		kfree(lib_dnld);

		sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT;
		if (!retval) {
			pr_debug("sst: codec was downloaded sucesfully\n");

			retval = sst_get_stream_allocated(str_param, &lib_dnld);
			if (retval <= 0)
				goto err;

			pr_debug("sst: Alloc done stream id %d\n", retval);
		} else {
			pr_debug("sst: codec download failed\n");
			retval = -EIO;
			goto err;
		}
	} else if  (retval <= 0)
		goto err;
	/*else
		set_port_params(str_param, str_param->ops);*/

	/* store sampling freq */
	str_info = &sst_drv_ctx->streams[retval];
	str_info->sfreq = sst_get_sfreq(str_param);

	/* power on the analog, if reqd */
	if (str_param->ops == STREAM_OPS_PLAYBACK ||
			str_param->ops == STREAM_OPS_PLAYBACK_DRM) {
		if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
			sst_drv_ctx->scard_ops->power_up_pmic_pb(
					sst_drv_ctx->pmic_port_instance);
		else
			sst_drv_ctx->scard_ops->power_up_pmic_pb(
							str_info->device);
		/*Only if the playback is MP3 - Send a message*/
		sst_drv_ctx->pb_streams++;
	} else if (str_param->ops == STREAM_OPS_CAPTURE) {

		sst_drv_ctx->scard_ops->power_up_pmic_cp(
				sst_drv_ctx->pmic_port_instance);
		/*Send a messageif not sent already*/
		sst_drv_ctx->cp_streams++;
	}

err:
	return retval;
}

void sst_process_mad_ops(struct work_struct *work)
{

	struct mad_ops_wq *mad_ops =
			container_of(work, struct mad_ops_wq, wq);
	int retval = 0;

	switch (mad_ops->control_op) {
	case SST_SND_PAUSE:
		retval = sst_pause_stream(mad_ops->stream_id);
		break;
	case SST_SND_RESUME:
		retval = sst_resume_stream(mad_ops->stream_id);
		break;
	case SST_SND_DROP:
/*		retval = sst_drop_stream(mad_ops->stream_id);
*/		break;
	case SST_SND_START:
			pr_debug("SST Debug: start stream\n");
		retval = sst_start_stream(mad_ops->stream_id);
		break;
	case SST_SND_STREAM_PROCESS:
		pr_debug("sst: play/capt frames...\n");
		break;
	default:
		pr_err("sst:  wrong control_ops reported\n");
	}
	return;
}
/*
 * sst_control_set - Set Control params
 *
 * @control_list: list of controls to be set
 *
 * This function is called by MID sound card driver to set
 * SST/Sound card controls. This is registered with MID driver
 */
int sst_control_set(int control_element, void *value)
{
	int retval = 0, str_id = 0;
	struct stream_info *stream;

	if (sst_drv_ctx->sst_state == SST_SUSPENDED) {
		/*LPE is suspended, resume it before proceding*/
		pr_debug("sst: Resuming from Suspended state\n");
		retval = intel_sst_resume(sst_drv_ctx->pci);
		if (retval) {
			pr_err("sst: Resume Failed = %#x, abort\n", retval);
			return retval;
		}
	}
	if (sst_drv_ctx->sst_state == SST_UN_INIT) {
		/* FW is not downloaded */
		pr_debug("sst: DSP Downloading FW now...\n");
		retval = sst_download_fw();
		if (retval) {
			pr_err("sst: FW download fail %x, abort\n", retval);
			return retval;
		}
		if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID &&
			sst_drv_ctx->rx_time_slot_status != RX_TIMESLOT_UNINIT
				&& sst_drv_ctx->pmic_vendor != SND_NC)
			sst_enable_rx_timeslot(
					sst_drv_ctx->rx_time_slot_status);
	}

	switch (control_element) {
	case SST_SND_ALLOC: {
		struct snd_sst_params *str_param;
		struct stream_info *str_info;

		str_param = (struct snd_sst_params *)value;
		BUG_ON(!str_param);
		retval = sst_get_stream(str_param);
		if (retval >= 0)
			sst_drv_ctx->stream_cnt++;
		str_info = &sst_drv_ctx->streams[retval];
		str_info->src = MAD_DRV;
		break;
	}

	case SST_SND_PAUSE:
	case SST_SND_RESUME:
	case SST_SND_DROP:
	case SST_SND_START:
		sst_drv_ctx->mad_ops.control_op = control_element;
		sst_drv_ctx->mad_ops.stream_id = *(int *)value;
		queue_work(sst_drv_ctx->mad_wq, &sst_drv_ctx->mad_ops.wq);
		break;

	case SST_SND_FREE:
		str_id = *(int *)value;
		stream = &sst_drv_ctx->streams[str_id];
		free_stream_context(str_id);
		stream->pcm_substream = NULL;
		stream->status = STREAM_UN_INIT;
		stream->period_elapsed = NULL;
		sst_drv_ctx->stream_cnt--;
		break;

	case SST_SND_STREAM_INIT: {
		struct pcm_stream_info *str_info;
		struct stream_info *stream;

		pr_debug("sst: stream init called\n");
		str_info = (struct pcm_stream_info *)value;
		str_id = str_info->str_id;
		retval = sst_validate_strid(str_id);
		if (retval)
			break;

		stream = &sst_drv_ctx->streams[str_id];
		pr_debug("sst: setting the period ptrs\n");
		stream->pcm_substream = str_info->mad_substream;
		stream->period_elapsed = str_info->period_elapsed;
		stream->sfreq = str_info->sfreq;
		stream->prev = stream->status;
		stream->status = STREAM_INIT;
		break;
	}

	case SST_SND_BUFFER_POINTER: {
		struct pcm_stream_info *stream_info;
		struct snd_sst_tstamp fw_tstamp = {0,};
		struct stream_info *stream;


		stream_info = (struct pcm_stream_info *)value;
		str_id = stream_info->str_id;
		retval = sst_validate_strid(str_id);
		if (retval)
			break;
		stream = &sst_drv_ctx->streams[str_id];

		if (!stream->pcm_substream)
			break;
		memcpy_fromio(&fw_tstamp,
			((void *)(sst_drv_ctx->mailbox + SST_TIME_STAMP)
			+(str_id * sizeof(fw_tstamp))),
			sizeof(fw_tstamp));

		pr_debug("sst: Pointer Query on strid = %d ops %d\n",
						str_id, stream->ops);

		if (stream->ops == STREAM_OPS_PLAYBACK)
			stream_info->buffer_ptr = fw_tstamp.samples_rendered;
		else
			stream_info->buffer_ptr = fw_tstamp.samples_processed;
		pr_debug("sst: Samples rendered = %llu, buffer ptr %llu\n",
			fw_tstamp.samples_rendered, stream_info->buffer_ptr);
		break;
	}
	case SST_ENABLE_RX_TIME_SLOT: {
		int status = *(int *)value;
		sst_drv_ctx->rx_time_slot_status = status ;
		sst_enable_rx_timeslot(status);
		break;
	}
	default:
		/* Illegal case */
		pr_warn("sst: illegal req\n");
		return -EINVAL;
	}

	return retval;
}


struct intel_sst_card_ops sst_pmic_ops = {
	.control_set = sst_control_set,
};

/*
 * register_sst_card - function for sound card to register
 *
 * @card: pointer to structure of operations
 *
 * This function is called card driver loads and is ready for registration
 */
int register_sst_card(struct intel_sst_card_ops *card)
{
	if (!sst_drv_ctx) {
		pr_err("sst: No SST driver register card reject\n");
		return -ENODEV;
	}

	if (!card || !card->module_name) {
		pr_err("sst: Null Pointer Passed\n");
		return -EINVAL;
	}
	if (sst_drv_ctx->pmic_state == SND_MAD_UN_INIT) {
		/* register this driver */
		if ((strncmp(SST_CARD_NAMES, card->module_name,
				strlen(SST_CARD_NAMES))) == 0) {
			sst_drv_ctx->pmic_vendor = card->vendor_id;
			sst_drv_ctx->scard_ops =  card->scard_ops;
			sst_pmic_ops.module_name = card->module_name;
			sst_drv_ctx->pmic_state = SND_MAD_INIT_DONE;
			sst_drv_ctx->rx_time_slot_status = 0; /*default AMIC*/
			card->control_set = sst_pmic_ops.control_set;
			sst_drv_ctx->scard_ops->card_status = SND_CARD_UN_INIT;
			return 0;
		} else {
			pr_err("sst: strcmp fail %s\n", card->module_name);
			return -EINVAL;
		}

	} else {
		/* already registered a driver */
		pr_err("sst: Repeat for registeration..denied\n");
		return -EBADRQC;
	}
	return 0;
}
EXPORT_SYMBOL_GPL(register_sst_card);

/*
 * unregister_sst_card- function for sound card to un-register
 *
 * @card: pointer to structure of operations
 *
 * This function is called when card driver unloads
 */
void unregister_sst_card(struct intel_sst_card_ops *card)
{
	if (sst_pmic_ops.control_set == card->control_set) {
		/* unreg */
		sst_pmic_ops.module_name = "";
		sst_drv_ctx->pmic_state = SND_MAD_UN_INIT;
		pr_debug("sst: Unregistered %s\n", card->module_name);
	}
	return;
}
EXPORT_SYMBOL_GPL(unregister_sst_card);
Commit	Line	Data
fffa1cca VK	1	/*
	2	* intel_sst_interface.c - Intel SST Driver for audio engine
	3	*
	4	* Copyright (C) 2008-10 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	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; version 2 of the License.
	13	*
	14	* This program is distributed in the hope that it will be useful, but
	15	* WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License along
	20	* with this program; if not, write to the Free Software Foundation, Inc.,
	21	* 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
	22	*
	23	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	24	* This driver exposes the audio engine functionalities to the ALSA
	25	* and middleware.
	26	* Upper layer interfaces (MAD driver, MMF) to SST driver
	27	*/
	28
1dd8b732	29	#include <linux/delay.h>
fffa1cca VK	30	#include <linux/pci.h>
	31	#include <linux/fs.h>
	32	#include <linux/firmware.h>
	33	#include "intel_sst.h"
	34	#include "intel_sst_ioctl.h"
	35	#include "intel_sst_fw_ipc.h"
	36	#include "intel_sst_common.h"
	37
	38
	39	/*
	40	* sst_download_fw - download the audio firmware to DSP
	41	*
	42	* This function is called when the FW needs to be downloaded to SST DSP engine
	43	*/
	44	int sst_download_fw(void)
	45	{
	46	int retval;
	47	const struct firmware *fw_sst;
	48	const char *name;
	49	if (sst_drv_ctx->sst_state != SST_UN_INIT)
	50	return -EPERM;
	51	if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
	52	name = SST_FW_FILENAME_MRST;
	53	else
	54	name = SST_FW_FILENAME_MFLD;
	55	pr_debug("sst: Downloading %s FW now...\n", name);
	56	retval = request_firmware(&fw_sst, name, &sst_drv_ctx->pci->dev);
	57	if (retval) {
	58	pr_err("sst: request fw failed %d\n", retval);
	59	return retval;
	60	}
	61	sst_drv_ctx->alloc_block[0].sst_id = FW_DWNL_ID;
	62	sst_drv_ctx->alloc_block[0].ops_block.condition = false;
	63	retval = sst_load_fw(fw_sst, NULL);
	64	if (retval)
	65	goto end_restore;
	66
	67	retval = sst_wait_timeout(sst_drv_ctx, &sst_drv_ctx->alloc_block[0]);
	68	if (retval)
	69	pr_err("sst: fw download failed %d\n" , retval);
	70	end_restore:
	71	release_firmware(fw_sst);
	72	sst_drv_ctx->alloc_block[0].sst_id = BLOCK_UNINIT;
	73	return retval;
	74	}
	75
	76
	77	/*
	78	* sst_stalled - this function checks if the lpe is in stalled state
	79	*/
	80	int sst_stalled(void)
	81	{
	82	int retry = 1000;
	83	int retval = -1;
	84
	85	while (retry) {
	86	if (!sst_drv_ctx->lpe_stalled)
	87	return 0;
	88	/wait for time and re-check/
	89	msleep(1);
	90
	91	retry--;
	92	}
	93	pr_debug("sst: in Stalled State\n");
94	return retval;
95	}
96
97	void free_stream_context(unsigned int str_id)
98	{
99	struct stream_info *stream;
100
101	if (!sst_validate_strid(str_id)) {
102	/* str_id is valid, so stream is alloacted */
103	stream = &sst_drv_ctx->streams[str_id];
104	if (stream->ops == STREAM_OPS_PLAYBACK \|\|
105	stream->ops == STREAM_OPS_PLAYBACK_DRM) {
106	sst_drv_ctx->pb_streams--;
107	if (sst_drv_ctx->pb_streams == 0)
108	sst_drv_ctx->scard_ops->power_down_pmic_pb();
109	} else if (stream->ops == STREAM_OPS_CAPTURE) {
110	sst_drv_ctx->cp_streams--;
111	if (sst_drv_ctx->cp_streams == 0)
112	sst_drv_ctx->scard_ops->power_down_pmic_cp();
113	}
114	if (sst_drv_ctx->pb_streams == 0
115	&& sst_drv_ctx->cp_streams == 0)
116	sst_drv_ctx->scard_ops->power_down_pmic();
117	if (sst_free_stream(str_id))
118	sst_clean_stream(&sst_drv_ctx->streams[str_id]);
119	}
120	}
121
122	/*
123	* sst_get_stream_allocated - this function gets a stream allocated with
124	* the given params
125	*
126	* @str_param : stream params
127	* @lib_dnld : pointer to pointer of lib downlaod struct
128	*
129	* This creates new stream id for a stream, in case lib is to be downloaded to
130	* DSP, it downloads that
131	*/
132	int sst_get_stream_allocated(struct snd_sst_params *str_param,
133	struct snd_sst_lib_download **lib_dnld)
134	{
135	int retval, str_id;
136	struct stream_info *str_info;
137
138	retval = sst_alloc_stream((char *) &str_param->sparams, str_param->ops,
139	str_param->codec, str_param->device_type);
140	if (retval < 0) {
141	pr_err("sst: sst_alloc_stream failed %d\n", retval);
142	return retval;
143	}
144	pr_debug("sst: Stream allocated %d\n", retval);
145	str_id = retval;
146	str_info = &sst_drv_ctx->streams[str_id];
147	/* Block the call for reply */
148	retval = sst_wait_interruptible_timeout(sst_drv_ctx,
149	&str_info->ctrl_blk, SST_BLOCK_TIMEOUT);
150	if ((retval != 0) \|\| (str_info->ctrl_blk.ret_code != 0)) {
151	pr_debug("sst: FW alloc failed retval %d, ret_code %d\n",
152	retval, str_info->ctrl_blk.ret_code);
153	str_id = -str_info->ctrl_blk.ret_code; /return error/
154	*lib_dnld = str_info->ctrl_blk.data;
155	sst_clean_stream(str_info);
156	} else
157	pr_debug("sst: FW Stream allocated sucess\n");
158	return str_id; /will ret either error (in above if) or correct str id/
159	}
160
161	/*
162	* sst_get_sfreq - this function returns the frequency of the stream
163	*
164	* @str_param : stream params
165	*/
166	static int sst_get_sfreq(struct snd_sst_params *str_param)
167	{
168	switch (str_param->codec) {
169	case SST_CODEC_TYPE_PCM:
170	return 48000; /str_param->sparams.uc.pcm_params.sfreq;/
171	case SST_CODEC_TYPE_MP3:
172	return str_param->sparams.uc.mp3_params.sfreq;
173	case SST_CODEC_TYPE_AAC:
174	return str_param->sparams.uc.aac_params.sfreq;;
175	case SST_CODEC_TYPE_WMA9:
176	return str_param->sparams.uc.wma_params.sfreq;;
177	default:
178	return 0;
179	}
180	}
181
182	/*
183	* sst_get_stream - this function prepares for stream allocation
184	*
185	* @str_param : stream param
186	*/
187	int sst_get_stream(struct snd_sst_params *str_param)
188	{
189	int i, retval;
190	struct stream_info *str_info;
191	struct snd_sst_lib_download *lib_dnld;
192
193	/* stream is not allocated, we are allocating */
194	retval = sst_get_stream_allocated(str_param, &lib_dnld);
195	if (retval == -(SST_LIB_ERR_LIB_DNLD_REQUIRED)) {
196	/* codec download is required */
197	struct snd_sst_alloc_response *response;
198
199	pr_debug("sst: Codec is required.... trying that\n");
200	if (lib_dnld == NULL) {
201	pr_err("sst: lib download null!!! abort\n");
202	return -EIO;
203	}
204	i = sst_get_block_stream(sst_drv_ctx);
205	response = sst_drv_ctx->alloc_block[i].ops_block.data;
206	pr_debug("sst: alloc block allocated = %d\n", i);
207	if (i < 0) {
208	kfree(lib_dnld);
209	return -ENOMEM;
210	}
211	retval = sst_load_library(lib_dnld, str_param->ops);
212	kfree(lib_dnld);
213
214	sst_drv_ctx->alloc_block[i].sst_id = BLOCK_UNINIT;
215	if (!retval) {
216	pr_debug("sst: codec was downloaded sucesfully\n");
217
218	retval = sst_get_stream_allocated(str_param, &lib_dnld);
219	if (retval <= 0)
220	goto err;
221
222	pr_debug("sst: Alloc done stream id %d\n", retval);
223	} else {
224	pr_debug("sst: codec download failed\n");
225	retval = -EIO;
226	goto err;
227	}
228	} else if (retval <= 0)
229	goto err;
230	/*else
231	set_port_params(str_param, str_param->ops);*/
232
233	/* store sampling freq */
234	str_info = &sst_drv_ctx->streams[retval];
235	str_info->sfreq = sst_get_sfreq(str_param);
236
237	/* power on the analog, if reqd */
238	if (str_param->ops == STREAM_OPS_PLAYBACK \|\|
239	str_param->ops == STREAM_OPS_PLAYBACK_DRM) {
240	if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID)
241	sst_drv_ctx->scard_ops->power_up_pmic_pb(
242	sst_drv_ctx->pmic_port_instance);
243	else
244	sst_drv_ctx->scard_ops->power_up_pmic_pb(
245	str_info->device);
246	/Only if the playback is MP3 - Send a message/
247	sst_drv_ctx->pb_streams++;
248	} else if (str_param->ops == STREAM_OPS_CAPTURE) {
249
250	sst_drv_ctx->scard_ops->power_up_pmic_cp(
251	sst_drv_ctx->pmic_port_instance);
252	/Send a messageif not sent already/
253	sst_drv_ctx->cp_streams++;
254	}
255
256	err:
257	return retval;
258	}
259
260	void sst_process_mad_ops(struct work_struct *work)
261	{
262
263	struct mad_ops_wq *mad_ops =
264	container_of(work, struct mad_ops_wq, wq);
265	int retval = 0;
266
267	switch (mad_ops->control_op) {
268	case SST_SND_PAUSE:
269	retval = sst_pause_stream(mad_ops->stream_id);
270	break;
271	case SST_SND_RESUME:
272	retval = sst_resume_stream(mad_ops->stream_id);
273	break;
274	case SST_SND_DROP:
275	/* retval = sst_drop_stream(mad_ops->stream_id);
276	*/ break;
277	case SST_SND_START:
278	pr_debug("SST Debug: start stream\n");
279	retval = sst_start_stream(mad_ops->stream_id);
280	break;
281	case SST_SND_STREAM_PROCESS:
282	pr_debug("sst: play/capt frames...\n");
283	break;
284	default:
285	pr_err("sst: wrong control_ops reported\n");
286	}
287	return;
288	}
289	/*
290	* sst_control_set - Set Control params
291	*
292	* @control_list: list of controls to be set
293	*
294	* This function is called by MID sound card driver to set
295	* SST/Sound card controls. This is registered with MID driver
296	*/
297	int sst_control_set(int control_element, void *value)
298	{
299	int retval = 0, str_id = 0;
300	struct stream_info *stream;
301
302	if (sst_drv_ctx->sst_state == SST_SUSPENDED) {
303	/LPE is suspended, resume it before proceding/
304	pr_debug("sst: Resuming from Suspended state\n");
305	retval = intel_sst_resume(sst_drv_ctx->pci);
306	if (retval) {
307	pr_err("sst: Resume Failed = %#x, abort\n", retval);
308	return retval;
309	}
310	}
311	if (sst_drv_ctx->sst_state == SST_UN_INIT) {
312	/* FW is not downloaded */
313	pr_debug("sst: DSP Downloading FW now...\n");
314	retval = sst_download_fw();
315	if (retval) {
316	pr_err("sst: FW download fail %x, abort\n", retval);
317	return retval;
318	}
319	if (sst_drv_ctx->pci_id == SST_MRST_PCI_ID &&
320	sst_drv_ctx->rx_time_slot_status != RX_TIMESLOT_UNINIT
321	&& sst_drv_ctx->pmic_vendor != SND_NC)
322	sst_enable_rx_timeslot(
323	sst_drv_ctx->rx_time_slot_status);
324	}
325
326	switch (control_element) {
327	case SST_SND_ALLOC: {
328	struct snd_sst_params *str_param;
329	struct stream_info *str_info;
330
331	str_param = (struct snd_sst_params *)value;
332	BUG_ON(!str_param);
333	retval = sst_get_stream(str_param);
334	if (retval >= 0)
335	sst_drv_ctx->stream_cnt++;
336	str_info = &sst_drv_ctx->streams[retval];
337	str_info->src = MAD_DRV;
338	break;
339	}
340
341	case SST_SND_PAUSE:
342	case SST_SND_RESUME:
343	case SST_SND_DROP:
344	case SST_SND_START:
345	sst_drv_ctx->mad_ops.control_op = control_element;
346	sst_drv_ctx->mad_ops.stream_id = (int )value;
347	queue_work(sst_drv_ctx->mad_wq, &sst_drv_ctx->mad_ops.wq);
348	break;
349
350	case SST_SND_FREE:
351	str_id = (int )value;
352	stream = &sst_drv_ctx->streams[str_id];
353	free_stream_context(str_id);
354	stream->pcm_substream = NULL;
355	stream->status = STREAM_UN_INIT;
356	stream->period_elapsed = NULL;
357	sst_drv_ctx->stream_cnt--;
358	break;
359
360	case SST_SND_STREAM_INIT: {
361	struct pcm_stream_info *str_info;
362	struct stream_info *stream;
363
364	pr_debug("sst: stream init called\n");
365	str_info = (struct pcm_stream_info *)value;
366	str_id = str_info->str_id;
367	retval = sst_validate_strid(str_id);
368	if (retval)
369	break;
370
371	stream = &sst_drv_ctx->streams[str_id];
372	pr_debug("sst: setting the period ptrs\n");
373	stream->pcm_substream = str_info->mad_substream;
374	stream->period_elapsed = str_info->period_elapsed;
375	stream->sfreq = str_info->sfreq;
376	stream->prev = stream->status;
377	stream->status = STREAM_INIT;
378	break;
379	}
380
381	case SST_SND_BUFFER_POINTER: {
382	struct pcm_stream_info *stream_info;
383	struct snd_sst_tstamp fw_tstamp = {0,};
384	struct stream_info *stream;
385
386
387	stream_info = (struct pcm_stream_info *)value;
388	str_id = stream_info->str_id;
389	retval = sst_validate_strid(str_id);
390	if (retval)
391	break;
392	stream = &sst_drv_ctx->streams[str_id];
393
394	if (!stream->pcm_substream)
395	break;
396	memcpy_fromio(&fw_tstamp,
397	((void *)(sst_drv_ctx->mailbox + SST_TIME_STAMP)
398	+(str_id * sizeof(fw_tstamp))),
399	sizeof(fw_tstamp));
400
401	pr_debug("sst: Pointer Query on strid = %d ops %d\n",
402	str_id, stream->ops);
403
404	if (stream->ops == STREAM_OPS_PLAYBACK)
405	stream_info->buffer_ptr = fw_tstamp.samples_rendered;
406	else
407	stream_info->buffer_ptr = fw_tstamp.samples_processed;
408	pr_debug("sst: Samples rendered = %llu, buffer ptr %llu\n",
409	fw_tstamp.samples_rendered, stream_info->buffer_ptr);
410	break;
411	}
412	case SST_ENABLE_RX_TIME_SLOT: {
413	int status = (int )value;
414	sst_drv_ctx->rx_time_slot_status = status ;
415	sst_enable_rx_timeslot(status);
416	break;
417	}
418	default:
419	/* Illegal case */
420	pr_warn("sst: illegal req\n");
421	return -EINVAL;
422	}
423
424	return retval;
425	}
426
427
428	struct intel_sst_card_ops sst_pmic_ops = {
429	.control_set = sst_control_set,
430	};
431
432	/*
433	* register_sst_card - function for sound card to register
434	*
435	* @card: pointer to structure of operations
436	*
437	* This function is called card driver loads and is ready for registration
438	*/
439	int register_sst_card(struct intel_sst_card_ops *card)
440	{
441	if (!sst_drv_ctx) {
442	pr_err("sst: No SST driver register card reject\n");
443	return -ENODEV;
444	}
445
446	if (!card \|\| !card->module_name) {
447	pr_err("sst: Null Pointer Passed\n");
448	return -EINVAL;
449	}
450	if (sst_drv_ctx->pmic_state == SND_MAD_UN_INIT) {
451	/* register this driver */
452	if ((strncmp(SST_CARD_NAMES, card->module_name,
453	strlen(SST_CARD_NAMES))) == 0) {
454	sst_drv_ctx->pmic_vendor = card->vendor_id;
455	sst_drv_ctx->scard_ops = card->scard_ops;
456	sst_pmic_ops.module_name = card->module_name;
457	sst_drv_ctx->pmic_state = SND_MAD_INIT_DONE;
458	sst_drv_ctx->rx_time_slot_status = 0; /default AMIC/
459	card->control_set = sst_pmic_ops.control_set;
460	sst_drv_ctx->scard_ops->card_status = SND_CARD_UN_INIT;
461	return 0;
462	} else {
463	pr_err("sst: strcmp fail %s\n", card->module_name);
464	return -EINVAL;
465	}
466
467	} else {
468	/* already registered a driver */
469	pr_err("sst: Repeat for registeration..denied\n");
470	return -EBADRQC;
471	}
472	return 0;
473	}
474	EXPORT_SYMBOL_GPL(register_sst_card);
475
476	/*
477	* unregister_sst_card- function for sound card to un-register
478	*
479	* @card: pointer to structure of operations
480	*
481	* This function is called when card driver unloads
482	*/
483	void unregister_sst_card(struct intel_sst_card_ops *card)
484	{
485	if (sst_pmic_ops.control_set == card->control_set) {
486	/* unreg */
487	sst_pmic_ops.module_name = "";
488	sst_drv_ctx->pmic_state = SND_MAD_UN_INIT;
489	pr_debug("sst: Unregistered %s\n", card->module_name);
490	}
491	return;
492	}
493	EXPORT_SYMBOL_GPL(unregister_sst_card);