1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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
32static 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
41static 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
50static 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
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;
70 stream->id = 0;
71
72
73 sst->compr_ops->power(sst->dev, true);
74
75 sst_set_stream_status(stream, SST_PLATFORM_INIT);
76 runtime->private_data = stream;
77 return 0;
78out_ops:
79 kfree(stream);
80 return ret_val;
81}
82
83static 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;
89
90 sst->compr_ops->power(sst->dev, false);
91
92
93 str_id = stream->id;
94 if (str_id)
95 ret_val = stream->compr_ops->close(sst->dev, str_id);
96 module_put(sst->dev->driver->owner);
97 kfree(stream);
98 pr_debug("%s: %d\n", __func__, ret_val);
99 return 0;
100}
101
102static 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;
109 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
110 struct snd_soc_component *component = snd_soc_rtdcom_lookup(rtd, DRV_NAME);
111 struct sst_data *ctx = snd_soc_component_get_drvdata(component);
112
113 stream = cstream->runtime->private_data;
114
115 memset(&str_params, 0, sizeof(str_params));
116
117
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;
122
123 switch (params->codec.id) {
124 case SND_AUDIOCODEC_MP3: {
125 str_params.codec = SST_CODEC_TYPE_MP3;
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;
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;
164 cb.drain_cb_param = cstream;
165 cb.drain_notify = sst_drain_notify;
166
167 retval = stream->compr_ops->open(sst->dev, &str_params, &cb);
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
177static int sst_platform_compr_trigger(struct snd_compr_stream *cstream, int cmd)
178{
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);
185 break;
186 case SNDRV_PCM_TRIGGER_STOP:
187 if (stream->compr_ops->stream_drop)
188 return stream->compr_ops->stream_drop(sst->dev, stream->id);
189 break;
190 case SND_COMPR_TRIGGER_DRAIN:
191 if (stream->compr_ops->stream_drain)
192 return stream->compr_ops->stream_drain(sst->dev, stream->id);
193 break;
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);
197 break;
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);
201 break;
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);
205 break;
206 }
207 return -EINVAL;
208}
209
210static 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;
216 stream->compr_ops->tstamp(sst->dev, stream->id, tstamp);
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
223static 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;
229 stream->compr_ops->ack(sst->dev, stream->id, (unsigned long)bytes);
230 stream->bytes_written += bytes;
231
232 return 0;
233}
234
235static 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
244static 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
253static 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
259 return stream->compr_ops->set_metadata(sst->dev, stream->id, metadata);
260}
261
262const 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};
274
