[deliverable/linux.git] / sound / soc / intel / atom / sst-mfld-platform-compress.c

/*
 *  sst_mfld_platform.c - Intel MID Platform driver
 *
 *  Copyright (C) 2010-2014 Intel Corp
 *  Author: Vinod Koul <vinod.koul@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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/slab.h>
#include <linux/io.h>
#include <linux/module.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/compress_driver.h>
#include "sst-mfld-platform.h"

/* compress stream operations */
static void sst_compr_fragment_elapsed(void *arg)
{
	struct snd_compr_stream *cstream = (struct snd_compr_stream *)arg;

	pr_debug("fragment elapsed by driver\n");
	if (cstream)
		snd_compr_fragment_elapsed(cstream);
}

static void sst_drain_notify(void *arg)
{
	struct snd_compr_stream *cstream = (struct snd_compr_stream *)arg;

	pr_debug("drain notify by driver\n");
	if (cstream)
		snd_compr_drain_notify(cstream);
}

static int sst_platform_compr_open(struct snd_compr_stream *cstream)
{

	int ret_val = 0;
	struct snd_compr_runtime *runtime = cstream->runtime;
	struct sst_runtime_stream *stream;

	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
	if (!stream)
		return -ENOMEM;

	spin_lock_init(&stream->status_lock);

	/* get the sst ops */
	if (!sst || !try_module_get(sst->dev->driver->owner)) {
		pr_err("no device available to run\n");
		ret_val = -ENODEV;
		goto out_ops;
	}
	stream->compr_ops = sst->compr_ops;
	stream->id = 0;

	/* Turn on LPE */
	sst->compr_ops->power(sst->dev, true);

	sst_set_stream_status(stream, SST_PLATFORM_INIT);
	runtime->private_data = stream;
	return 0;
out_ops:
	kfree(stream);
	return ret_val;
}

static int sst_platform_compr_free(struct snd_compr_stream *cstream)
{
	struct sst_runtime_stream *stream;
	int ret_val = 0, str_id;

	stream = cstream->runtime->private_data;
	/* Turn off LPE */
	sst->compr_ops->power(sst->dev, false);

	/*need to check*/
	str_id = stream->id;
	if (str_id)
		ret_val = stream->compr_ops->close(sst->dev, str_id);
	module_put(sst->dev->driver->owner);
	kfree(stream);
	pr_debug("%s: %d\n", __func__, ret_val);
	return 0;
}

static int sst_platform_compr_set_params(struct snd_compr_stream *cstream,
					struct snd_compr_params *params)
{
	struct sst_runtime_stream *stream;
	int retval;
	struct snd_sst_params str_params;
	struct sst_compress_cb cb;
	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
	struct snd_soc_platform *platform = rtd->platform;
	struct sst_data *ctx = snd_soc_platform_get_drvdata(platform);

	stream = cstream->runtime->private_data;
	/* construct fw structure for this*/
	memset(&str_params, 0, sizeof(str_params));

	/* fill the device type and stream id to pass to SST driver */
	retval = sst_fill_stream_params(cstream, ctx, &str_params, true);
	pr_debug("compr_set_params: fill stream params ret_val = 0x%x\n", retval);
	if (retval < 0)
		return retval;

	switch (params->codec.id) {
	case SND_AUDIOCODEC_MP3: {
		str_params.codec = SST_CODEC_TYPE_MP3;
		str_params.sparams.uc.mp3_params.num_chan = params->codec.ch_in;
		str_params.sparams.uc.mp3_params.pcm_wd_sz = 16;
		break;
	}

	case SND_AUDIOCODEC_AAC: {
		str_params.codec = SST_CODEC_TYPE_AAC;
		str_params.sparams.uc.aac_params.num_chan = params->codec.ch_in;
		str_params.sparams.uc.aac_params.pcm_wd_sz = 16;
		if (params->codec.format == SND_AUDIOSTREAMFORMAT_MP4ADTS)
			str_params.sparams.uc.aac_params.bs_format =
							AAC_BIT_STREAM_ADTS;
		else if (params->codec.format == SND_AUDIOSTREAMFORMAT_RAW)
			str_params.sparams.uc.aac_params.bs_format =
							AAC_BIT_STREAM_RAW;
		else {
			pr_err("Undefined format%d\n", params->codec.format);
			return -EINVAL;
		}
		str_params.sparams.uc.aac_params.externalsr =
						params->codec.sample_rate;
		break;
	}

	default:
		pr_err("codec not supported, id =%d\n", params->codec.id);
		return -EINVAL;
	}

	str_params.aparams.ring_buf_info[0].addr  =
					virt_to_phys(cstream->runtime->buffer);
	str_params.aparams.ring_buf_info[0].size =
					cstream->runtime->buffer_size;
	str_params.aparams.sg_count = 1;
	str_params.aparams.frag_size = cstream->runtime->fragment_size;

	cb.param = cstream;
	cb.compr_cb = sst_compr_fragment_elapsed;
	cb.drain_cb_param = cstream;
	cb.drain_notify = sst_drain_notify;

	retval = stream->compr_ops->open(sst->dev, &str_params, &cb);
	if (retval < 0) {
		pr_err("stream allocation failed %d\n", retval);
		return retval;
	}

	stream->id = retval;
	return 0;
}

static int sst_platform_compr_trigger(struct snd_compr_stream *cstream, int cmd)
{
	struct sst_runtime_stream *stream = cstream->runtime->private_data;

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
		if (stream->compr_ops->stream_start)
			return stream->compr_ops->stream_start(sst->dev, stream->id);
		break;
	case SNDRV_PCM_TRIGGER_STOP:
		if (stream->compr_ops->stream_drop)
			return stream->compr_ops->stream_drop(sst->dev, stream->id);
		break;
	case SND_COMPR_TRIGGER_DRAIN:
		if (stream->compr_ops->stream_drain)
			return stream->compr_ops->stream_drain(sst->dev, stream->id);
		break;
	case SND_COMPR_TRIGGER_PARTIAL_DRAIN:
		if (stream->compr_ops->stream_partial_drain)
			return stream->compr_ops->stream_partial_drain(sst->dev, stream->id);
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
		if (stream->compr_ops->stream_pause)
			return stream->compr_ops->stream_pause(sst->dev, stream->id);
		break;
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		if (stream->compr_ops->stream_pause_release)
			return stream->compr_ops->stream_pause_release(sst->dev, stream->id);
		break;
	}
	return -EINVAL;
}

static int sst_platform_compr_pointer(struct snd_compr_stream *cstream,
					struct snd_compr_tstamp *tstamp)
{
	struct sst_runtime_stream *stream;

	stream  = cstream->runtime->private_data;
	stream->compr_ops->tstamp(sst->dev, stream->id, tstamp);
	tstamp->byte_offset = tstamp->copied_total %
				 (u32)cstream->runtime->buffer_size;
	pr_debug("calc bytes offset/copied bytes as %d\n", tstamp->byte_offset);
	return 0;
}

static int sst_platform_compr_ack(struct snd_compr_stream *cstream,
					size_t bytes)
{
	struct sst_runtime_stream *stream;

	stream  = cstream->runtime->private_data;
	stream->compr_ops->ack(sst->dev, stream->id, (unsigned long)bytes);
	stream->bytes_written += bytes;

	return 0;
}

static int sst_platform_compr_get_caps(struct snd_compr_stream *cstream,
					struct snd_compr_caps *caps)
{
	struct sst_runtime_stream *stream =
		cstream->runtime->private_data;

	return stream->compr_ops->get_caps(caps);
}

static int sst_platform_compr_get_codec_caps(struct snd_compr_stream *cstream,
					struct snd_compr_codec_caps *codec)
{
	struct sst_runtime_stream *stream =
		cstream->runtime->private_data;

	return stream->compr_ops->get_codec_caps(codec);
}

static int sst_platform_compr_set_metadata(struct snd_compr_stream *cstream,
					struct snd_compr_metadata *metadata)
{
	struct sst_runtime_stream *stream  =
		 cstream->runtime->private_data;

	return stream->compr_ops->set_metadata(sst->dev, stream->id, metadata);
}

struct snd_compr_ops sst_platform_compr_ops = {

	.open = sst_platform_compr_open,
	.free = sst_platform_compr_free,
	.set_params = sst_platform_compr_set_params,
	.set_metadata = sst_platform_compr_set_metadata,
	.trigger = sst_platform_compr_trigger,
	.pointer = sst_platform_compr_pointer,
	.ack = sst_platform_compr_ack,
	.get_caps = sst_platform_compr_get_caps,
	.get_codec_caps = sst_platform_compr_get_codec_caps,
};
Commit	Line	Data
4b68b4e1 VK	1	/*
	2	* sst_mfld_platform.c - Intel MID Platform driver
	3	*
	4	* Copyright (C) 2010-2014 Intel Corp
	5	* Author: Vinod Koul <vinod.koul@intel.com>
	6	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; version 2 of the License.
	11	*
	12	* This program is distributed in the hope that it will be useful, but
	13	* WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	15	* General Public License for more details.
	16	*
	17	* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
	18	*/
	19	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
	20
	21	#include <linux/slab.h>
	22	#include <linux/io.h>
	23	#include <linux/module.h>
	24	#include <sound/core.h>
	25	#include <sound/pcm.h>
	26	#include <sound/pcm_params.h>
	27	#include <sound/soc.h>
	28	#include <sound/compress_driver.h>
	29	#include "sst-mfld-platform.h"
	30
	31	/* compress stream operations */
	32	static void sst_compr_fragment_elapsed(void *arg)
	33	{
	34	struct snd_compr_stream cstream = (struct snd_compr_stream )arg;
	35
	36	pr_debug("fragment elapsed by driver\n");
	37	if (cstream)
	38	snd_compr_fragment_elapsed(cstream);
	39	}
	40
bd17aa45 VK	41	static void sst_drain_notify(void *arg)
	42	{
	43	struct snd_compr_stream cstream = (struct snd_compr_stream )arg;
	44
	45	pr_debug("drain notify by driver\n");
	46	if (cstream)
	47	snd_compr_drain_notify(cstream);
	48	}
	49
4b68b4e1 VK	50	static int sst_platform_compr_open(struct snd_compr_stream *cstream)
	51	{
	52
	53	int ret_val = 0;
	54	struct snd_compr_runtime *runtime = cstream->runtime;
	55	struct sst_runtime_stream *stream;
	56
	57	stream = kzalloc(sizeof(*stream), GFP_KERNEL);
	58	if (!stream)
	59	return -ENOMEM;
	60
	61	spin_lock_init(&stream->status_lock);
	62
	63	/* get the sst ops */
	64	if (!sst \|\| !try_module_get(sst->dev->driver->owner)) {
	65	pr_err("no device available to run\n");
	66	ret_val = -ENODEV;
	67	goto out_ops;
	68	}
	69	stream->compr_ops = sst->compr_ops;
4b68b4e1	70	stream->id = 0;
fdcc4a03 SP	71
	72	/* Turn on LPE */
	73	sst->compr_ops->power(sst->dev, true);
	74
4b68b4e1 VK	75	sst_set_stream_status(stream, SST_PLATFORM_INIT);
	76	runtime->private_data = stream;
	77	return 0;
	78	out_ops:
	79	kfree(stream);
	80	return ret_val;
	81	}
	82
	83	static int sst_platform_compr_free(struct snd_compr_stream *cstream)
	84	{
	85	struct sst_runtime_stream *stream;
	86	int ret_val = 0, str_id;
	87
	88	stream = cstream->runtime->private_data;
fdcc4a03 SP	89	/* Turn off LPE */
	90	sst->compr_ops->power(sst->dev, false);
	91
4b68b4e1 VK	92	/need to check/
	93	str_id = stream->id;
	94	if (str_id)
06cb1eb3	95	ret_val = stream->compr_ops->close(sst->dev, str_id);
4b68b4e1 VK	96	module_put(sst->dev->driver->owner);
	97	kfree(stream);
	98	pr_debug("%s: %d\n", __func__, ret_val);
	99	return 0;
	100	}
	101
	102	static int sst_platform_compr_set_params(struct snd_compr_stream *cstream,
	103	struct snd_compr_params *params)
	104	{
	105	struct sst_runtime_stream *stream;
	106	int retval;
	107	struct snd_sst_params str_params;
	108	struct sst_compress_cb cb;
0ec66fed VK	109	struct snd_soc_pcm_runtime *rtd = cstream->private_data;
	110	struct snd_soc_platform *platform = rtd->platform;
	111	struct sst_data *ctx = snd_soc_platform_get_drvdata(platform);
4b68b4e1 VK	112
	113	stream = cstream->runtime->private_data;
	114	/* construct fw structure for this*/
	115	memset(&str_params, 0, sizeof(str_params));
	116
0ec66fed VK	117	/* fill the device type and stream id to pass to SST driver */
	118	retval = sst_fill_stream_params(cstream, ctx, &str_params, true);
	119	pr_debug("compr_set_params: fill stream params ret_val = 0x%x\n", retval);
	120	if (retval < 0)
	121	return retval;
4b68b4e1 VK	122
	123	switch (params->codec.id) {
	124	case SND_AUDIOCODEC_MP3: {
	125	str_params.codec = SST_CODEC_TYPE_MP3;
4b68b4e1 VK	126	str_params.sparams.uc.mp3_params.num_chan = params->codec.ch_in;
	127	str_params.sparams.uc.mp3_params.pcm_wd_sz = 16;
	128	break;
	129	}
	130
	131	case SND_AUDIOCODEC_AAC: {
	132	str_params.codec = SST_CODEC_TYPE_AAC;
4b68b4e1 VK	133	str_params.sparams.uc.aac_params.num_chan = params->codec.ch_in;
	134	str_params.sparams.uc.aac_params.pcm_wd_sz = 16;
	135	if (params->codec.format == SND_AUDIOSTREAMFORMAT_MP4ADTS)
	136	str_params.sparams.uc.aac_params.bs_format =
	137	AAC_BIT_STREAM_ADTS;
	138	else if (params->codec.format == SND_AUDIOSTREAMFORMAT_RAW)
	139	str_params.sparams.uc.aac_params.bs_format =
	140	AAC_BIT_STREAM_RAW;
	141	else {
	142	pr_err("Undefined format%d\n", params->codec.format);
	143	return -EINVAL;
	144	}
	145	str_params.sparams.uc.aac_params.externalsr =
	146	params->codec.sample_rate;
	147	break;
	148	}
	149
	150	default:
	151	pr_err("codec not supported, id =%d\n", params->codec.id);
	152	return -EINVAL;
	153	}
	154
	155	str_params.aparams.ring_buf_info[0].addr =
	156	virt_to_phys(cstream->runtime->buffer);
	157	str_params.aparams.ring_buf_info[0].size =
	158	cstream->runtime->buffer_size;
	159	str_params.aparams.sg_count = 1;
	160	str_params.aparams.frag_size = cstream->runtime->fragment_size;
	161
	162	cb.param = cstream;
	163	cb.compr_cb = sst_compr_fragment_elapsed;
bd17aa45 VK	164	cb.drain_cb_param = cstream;
bd17aa45 VK	165	cb.drain_notify = sst_drain_notify;
4b68b4e1	166
06cb1eb3	167	retval = stream->compr_ops->open(sst->dev, &str_params, &cb);
4b68b4e1 VK	168	if (retval < 0) {
	169	pr_err("stream allocation failed %d\n", retval);
	170	return retval;
	171	}
	172
	173	stream->id = retval;
	174	return 0;
	175	}
	176
	177	static int sst_platform_compr_trigger(struct snd_compr_stream *cstream, int cmd)
	178	{
06cb1eb3 SP	179	struct sst_runtime_stream *stream = cstream->runtime->private_data;
	180
	181	switch (cmd) {
	182	case SNDRV_PCM_TRIGGER_START:
	183	if (stream->compr_ops->stream_start)
	184	return stream->compr_ops->stream_start(sst->dev, stream->id);
18f58399	185	break;
06cb1eb3 SP	186	case SNDRV_PCM_TRIGGER_STOP:
	187	if (stream->compr_ops->stream_drop)
	188	return stream->compr_ops->stream_drop(sst->dev, stream->id);
18f58399	189	break;
06cb1eb3 SP	190	case SND_COMPR_TRIGGER_DRAIN:
	191	if (stream->compr_ops->stream_drain)
	192	return stream->compr_ops->stream_drain(sst->dev, stream->id);
18f58399	193	break;
06cb1eb3 SP	194	case SND_COMPR_TRIGGER_PARTIAL_DRAIN:
	195	if (stream->compr_ops->stream_partial_drain)
	196	return stream->compr_ops->stream_partial_drain(sst->dev, stream->id);
18f58399	197	break;
06cb1eb3 SP	198	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
	199	if (stream->compr_ops->stream_pause)
	200	return stream->compr_ops->stream_pause(sst->dev, stream->id);
18f58399	201	break;
06cb1eb3 SP	202	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
	203	if (stream->compr_ops->stream_pause_release)
	204	return stream->compr_ops->stream_pause_release(sst->dev, stream->id);
18f58399	205	break;
06cb1eb3	206	}
18f58399	207	return -EINVAL;
4b68b4e1 VK	208	}
	209
	210	static int sst_platform_compr_pointer(struct snd_compr_stream *cstream,
	211	struct snd_compr_tstamp *tstamp)
	212	{
	213	struct sst_runtime_stream *stream;
	214
	215	stream = cstream->runtime->private_data;
06cb1eb3	216	stream->compr_ops->tstamp(sst->dev, stream->id, tstamp);
4b68b4e1 VK	217	tstamp->byte_offset = tstamp->copied_total %
	218	(u32)cstream->runtime->buffer_size;
	219	pr_debug("calc bytes offset/copied bytes as %d\n", tstamp->byte_offset);
	220	return 0;
	221	}
	222
	223	static int sst_platform_compr_ack(struct snd_compr_stream *cstream,
	224	size_t bytes)
	225	{
	226	struct sst_runtime_stream *stream;
	227
	228	stream = cstream->runtime->private_data;
06cb1eb3	229	stream->compr_ops->ack(sst->dev, stream->id, (unsigned long)bytes);
4b68b4e1 VK	230	stream->bytes_written += bytes;
	231
	232	return 0;
	233	}
	234
	235	static int sst_platform_compr_get_caps(struct snd_compr_stream *cstream,
	236	struct snd_compr_caps *caps)
	237	{
	238	struct sst_runtime_stream *stream =
	239	cstream->runtime->private_data;
	240
	241	return stream->compr_ops->get_caps(caps);
	242	}
	243
	244	static int sst_platform_compr_get_codec_caps(struct snd_compr_stream *cstream,
	245	struct snd_compr_codec_caps *codec)
	246	{
	247	struct sst_runtime_stream *stream =
	248	cstream->runtime->private_data;
	249
	250	return stream->compr_ops->get_codec_caps(codec);
	251	}
	252
	253	static int sst_platform_compr_set_metadata(struct snd_compr_stream *cstream,
	254	struct snd_compr_metadata *metadata)
	255	{
	256	struct sst_runtime_stream *stream =
	257	cstream->runtime->private_data;
	258
06cb1eb3	259	return stream->compr_ops->set_metadata(sst->dev, stream->id, metadata);
4b68b4e1 VK	260	}
	261
	262	struct snd_compr_ops sst_platform_compr_ops = {
	263
	264	.open = sst_platform_compr_open,
	265	.free = sst_platform_compr_free,
	266	.set_params = sst_platform_compr_set_params,
	267	.set_metadata = sst_platform_compr_set_metadata,
	268	.trigger = sst_platform_compr_trigger,
	269	.pointer = sst_platform_compr_pointer,
	270	.ack = sst_platform_compr_ack,
	271	.get_caps = sst_platform_compr_get_caps,
	272	.get_codec_caps = sst_platform_compr_get_codec_caps,
	273	};