sst-mfld-platform-compress.c

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