2 * sst_mfld_platform.c - Intel MID Platform driver
4 * Copyright (C) 2010-2014 Intel Corp
5 * Author: Vinod Koul <vinod.koul@intel.com>
6 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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.
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.
17 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21 #include <linux/slab.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"
31 /* compress stream operations */
32 static void sst_compr_fragment_elapsed(void *arg)
34 struct snd_compr_stream *cstream = (struct snd_compr_stream *)arg;
36 pr_debug("fragment elapsed by driver\n");
38 snd_compr_fragment_elapsed(cstream);
41 static void sst_drain_notify(void *arg)
43 struct snd_compr_stream *cstream = (struct snd_compr_stream *)arg;
45 pr_debug("drain notify by driver\n");
47 snd_compr_drain_notify(cstream);
50 static int sst_platform_compr_open(struct snd_compr_stream *cstream)
54 struct snd_compr_runtime *runtime = cstream->runtime;
55 struct sst_runtime_stream *stream;
57 stream = kzalloc(sizeof(*stream), GFP_KERNEL);
61 spin_lock_init(&stream->status_lock);
64 if (!sst || !try_module_get(sst->dev->driver->owner)) {
65 pr_err("no device available to run\n");
69 stream->compr_ops = sst->compr_ops;
72 sst_set_stream_status(stream, SST_PLATFORM_INIT);
73 runtime->private_data = stream;
80 static int sst_platform_compr_free(struct snd_compr_stream *cstream)
82 struct sst_runtime_stream *stream;
83 int ret_val = 0, str_id;
85 stream = cstream->runtime->private_data;
89 ret_val = stream->compr_ops->close(sst->dev, str_id);
90 module_put(sst->dev->driver->owner);
92 pr_debug("%s: %d\n", __func__, ret_val);
96 static int sst_platform_compr_set_params(struct snd_compr_stream *cstream,
97 struct snd_compr_params *params)
99 struct sst_runtime_stream *stream;
101 struct snd_sst_params str_params;
102 struct sst_compress_cb cb;
103 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
104 struct snd_soc_platform *platform = rtd->platform;
105 struct sst_data *ctx = snd_soc_platform_get_drvdata(platform);
107 stream = cstream->runtime->private_data;
108 /* construct fw structure for this*/
109 memset(&str_params, 0, sizeof(str_params));
111 /* fill the device type and stream id to pass to SST driver */
112 retval = sst_fill_stream_params(cstream, ctx, &str_params, true);
113 pr_debug("compr_set_params: fill stream params ret_val = 0x%x\n", retval);
117 switch (params->codec.id) {
118 case SND_AUDIOCODEC_MP3: {
119 str_params.codec = SST_CODEC_TYPE_MP3;
120 str_params.sparams.uc.mp3_params.num_chan = params->codec.ch_in;
121 str_params.sparams.uc.mp3_params.pcm_wd_sz = 16;
125 case SND_AUDIOCODEC_AAC: {
126 str_params.codec = SST_CODEC_TYPE_AAC;
127 str_params.sparams.uc.aac_params.num_chan = params->codec.ch_in;
128 str_params.sparams.uc.aac_params.pcm_wd_sz = 16;
129 if (params->codec.format == SND_AUDIOSTREAMFORMAT_MP4ADTS)
130 str_params.sparams.uc.aac_params.bs_format =
132 else if (params->codec.format == SND_AUDIOSTREAMFORMAT_RAW)
133 str_params.sparams.uc.aac_params.bs_format =
136 pr_err("Undefined format%d\n", params->codec.format);
139 str_params.sparams.uc.aac_params.externalsr =
140 params->codec.sample_rate;
145 pr_err("codec not supported, id =%d\n", params->codec.id);
149 str_params.aparams.ring_buf_info[0].addr =
150 virt_to_phys(cstream->runtime->buffer);
151 str_params.aparams.ring_buf_info[0].size =
152 cstream->runtime->buffer_size;
153 str_params.aparams.sg_count = 1;
154 str_params.aparams.frag_size = cstream->runtime->fragment_size;
157 cb.compr_cb = sst_compr_fragment_elapsed;
158 cb.drain_cb_param = cstream;
159 cb.drain_notify = sst_drain_notify;
161 retval = stream->compr_ops->open(sst->dev, &str_params, &cb);
163 pr_err("stream allocation failed %d\n", retval);
171 static int sst_platform_compr_trigger(struct snd_compr_stream *cstream, int cmd)
173 struct sst_runtime_stream *stream = cstream->runtime->private_data;
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 case SNDRV_PCM_TRIGGER_STOP:
180 if (stream->compr_ops->stream_drop)
181 return stream->compr_ops->stream_drop(sst->dev, stream->id);
182 case SND_COMPR_TRIGGER_DRAIN:
183 if (stream->compr_ops->stream_drain)
184 return stream->compr_ops->stream_drain(sst->dev, stream->id);
185 case SND_COMPR_TRIGGER_PARTIAL_DRAIN:
186 if (stream->compr_ops->stream_partial_drain)
187 return stream->compr_ops->stream_partial_drain(sst->dev, stream->id);
188 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
189 if (stream->compr_ops->stream_pause)
190 return stream->compr_ops->stream_pause(sst->dev, stream->id);
191 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
192 if (stream->compr_ops->stream_pause_release)
193 return stream->compr_ops->stream_pause_release(sst->dev, stream->id);
199 static int sst_platform_compr_pointer(struct snd_compr_stream *cstream,
200 struct snd_compr_tstamp *tstamp)
202 struct sst_runtime_stream *stream;
204 stream = cstream->runtime->private_data;
205 stream->compr_ops->tstamp(sst->dev, stream->id, tstamp);
206 tstamp->byte_offset = tstamp->copied_total %
207 (u32)cstream->runtime->buffer_size;
208 pr_debug("calc bytes offset/copied bytes as %d\n", tstamp->byte_offset);
212 static int sst_platform_compr_ack(struct snd_compr_stream *cstream,
215 struct sst_runtime_stream *stream;
217 stream = cstream->runtime->private_data;
218 stream->compr_ops->ack(sst->dev, stream->id, (unsigned long)bytes);
219 stream->bytes_written += bytes;
224 static int sst_platform_compr_get_caps(struct snd_compr_stream *cstream,
225 struct snd_compr_caps *caps)
227 struct sst_runtime_stream *stream =
228 cstream->runtime->private_data;
230 return stream->compr_ops->get_caps(caps);
233 static int sst_platform_compr_get_codec_caps(struct snd_compr_stream *cstream,
234 struct snd_compr_codec_caps *codec)
236 struct sst_runtime_stream *stream =
237 cstream->runtime->private_data;
239 return stream->compr_ops->get_codec_caps(codec);
242 static int sst_platform_compr_set_metadata(struct snd_compr_stream *cstream,
243 struct snd_compr_metadata *metadata)
245 struct sst_runtime_stream *stream =
246 cstream->runtime->private_data;
248 return stream->compr_ops->set_metadata(sst->dev, stream->id, metadata);
251 struct snd_compr_ops sst_platform_compr_ops = {
253 .open = sst_platform_compr_open,
254 .free = sst_platform_compr_free,
255 .set_params = sst_platform_compr_set_params,
256 .set_metadata = sst_platform_compr_set_metadata,
257 .trigger = sst_platform_compr_trigger,
258 .pointer = sst_platform_compr_pointer,
259 .ack = sst_platform_compr_ack,
260 .get_caps = sst_platform_compr_get_caps,
261 .get_codec_caps = sst_platform_compr_get_codec_caps,