1
2
3
4
5
6
7#include <linux/bitfield.h>
8#include <linux/circ_buf.h>
9#include <linux/dma-mapping.h>
10#include <linux/errno.h>
11#include <linux/kernel.h>
12#include <linux/module.h>
13#include <sound/core.h>
14#include <sound/pcm.h>
15#include <sound/soc.h>
16
17#include "aio.h"
18
19static int uniphier_aio_compr_prepare(struct snd_soc_component *component,
20 struct snd_compr_stream *cstream);
21static int uniphier_aio_compr_hw_free(struct snd_soc_component *component,
22 struct snd_compr_stream *cstream);
23
24static int uniphier_aio_comprdma_new(struct snd_soc_pcm_runtime *rtd)
25{
26 struct snd_compr *compr = rtd->compr;
27 struct device *dev = compr->card->dev;
28 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
29 struct uniphier_aio_sub *sub = &aio->sub[compr->direction];
30 size_t size = AUD_RING_SIZE;
31 int dma_dir = DMA_FROM_DEVICE, ret;
32
33 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(33));
34 if (ret)
35 return ret;
36
37 sub->compr_area = kzalloc(size, GFP_KERNEL);
38 if (!sub->compr_area)
39 return -ENOMEM;
40
41 if (sub->swm->dir == PORT_DIR_OUTPUT)
42 dma_dir = DMA_TO_DEVICE;
43
44 sub->compr_addr = dma_map_single(dev, sub->compr_area, size, dma_dir);
45 if (dma_mapping_error(dev, sub->compr_addr)) {
46 kfree(sub->compr_area);
47 sub->compr_area = NULL;
48
49 return -ENOMEM;
50 }
51
52 sub->compr_bytes = size;
53
54 return 0;
55}
56
57static int uniphier_aio_comprdma_free(struct snd_soc_pcm_runtime *rtd)
58{
59 struct snd_compr *compr = rtd->compr;
60 struct device *dev = compr->card->dev;
61 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
62 struct uniphier_aio_sub *sub = &aio->sub[compr->direction];
63 int dma_dir = DMA_FROM_DEVICE;
64
65 if (sub->swm->dir == PORT_DIR_OUTPUT)
66 dma_dir = DMA_TO_DEVICE;
67
68 dma_unmap_single(dev, sub->compr_addr, sub->compr_bytes, dma_dir);
69 kfree(sub->compr_area);
70 sub->compr_area = NULL;
71
72 return 0;
73}
74
75static int uniphier_aio_compr_open(struct snd_soc_component *component,
76 struct snd_compr_stream *cstream)
77{
78 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
79 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
80 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
81 int ret;
82
83 if (sub->cstream)
84 return -EBUSY;
85
86 sub->cstream = cstream;
87 sub->pass_through = 1;
88 sub->use_mmap = false;
89
90 ret = uniphier_aio_comprdma_new(rtd);
91 if (ret)
92 return ret;
93
94 ret = aio_init(sub);
95 if (ret)
96 return ret;
97
98 return 0;
99}
100
101static int uniphier_aio_compr_free(struct snd_soc_component *component,
102 struct snd_compr_stream *cstream)
103{
104 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
105 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
106 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
107 int ret;
108
109 ret = uniphier_aio_compr_hw_free(component, cstream);
110 if (ret)
111 return ret;
112 ret = uniphier_aio_comprdma_free(rtd);
113 if (ret)
114 return ret;
115
116 sub->cstream = NULL;
117
118 return 0;
119}
120
121static int uniphier_aio_compr_get_params(struct snd_soc_component *component,
122 struct snd_compr_stream *cstream,
123 struct snd_codec *params)
124{
125 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
126 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
127 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
128
129 *params = sub->cparams.codec;
130
131 return 0;
132}
133
134static int uniphier_aio_compr_set_params(struct snd_soc_component *component,
135 struct snd_compr_stream *cstream,
136 struct snd_compr_params *params)
137{
138 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
139 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
140 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
141 struct device *dev = &aio->chip->pdev->dev;
142 int ret;
143
144 if (params->codec.id != SND_AUDIOCODEC_IEC61937) {
145 dev_err(dev, "Codec ID is not supported(%d)\n",
146 params->codec.id);
147 return -EINVAL;
148 }
149 if (params->codec.profile != SND_AUDIOPROFILE_IEC61937_SPDIF) {
150 dev_err(dev, "Codec profile is not supported(%d)\n",
151 params->codec.profile);
152 return -EINVAL;
153 }
154
155
156 sub->iec_pc = IEC61937_PC_AAC;
157
158 sub->cparams = *params;
159 sub->setting = 1;
160
161 aio_port_reset(sub);
162 aio_src_reset(sub);
163
164 ret = uniphier_aio_compr_prepare(component, cstream);
165 if (ret)
166 return ret;
167
168 return 0;
169}
170
171static int uniphier_aio_compr_hw_free(struct snd_soc_component *component,
172 struct snd_compr_stream *cstream)
173{
174 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
175 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
176 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
177
178 sub->setting = 0;
179
180 return 0;
181}
182
183static int uniphier_aio_compr_prepare(struct snd_soc_component *component,
184 struct snd_compr_stream *cstream)
185{
186 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
187 struct snd_compr_runtime *runtime = cstream->runtime;
188 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
189 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
190 int bytes = runtime->fragment_size;
191 unsigned long flags;
192 int ret;
193
194 ret = aiodma_ch_set_param(sub);
195 if (ret)
196 return ret;
197
198 spin_lock_irqsave(&sub->lock, flags);
199 ret = aiodma_rb_set_buffer(sub, sub->compr_addr,
200 sub->compr_addr + sub->compr_bytes,
201 bytes);
202 spin_unlock_irqrestore(&sub->lock, flags);
203 if (ret)
204 return ret;
205
206 ret = aio_port_set_param(sub, sub->pass_through, &sub->params);
207 if (ret)
208 return ret;
209 ret = aio_oport_set_stream_type(sub, sub->iec_pc);
210 if (ret)
211 return ret;
212 aio_port_set_enable(sub, 1);
213
214 ret = aio_if_set_param(sub, sub->pass_through);
215 if (ret)
216 return ret;
217
218 return 0;
219}
220
221static int uniphier_aio_compr_trigger(struct snd_soc_component *component,
222 struct snd_compr_stream *cstream,
223 int cmd)
224{
225 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
226 struct snd_compr_runtime *runtime = cstream->runtime;
227 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
228 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
229 struct device *dev = &aio->chip->pdev->dev;
230 int bytes = runtime->fragment_size, ret = 0;
231 unsigned long flags;
232
233 spin_lock_irqsave(&sub->lock, flags);
234 switch (cmd) {
235 case SNDRV_PCM_TRIGGER_START:
236 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
237 aiodma_ch_set_enable(sub, 1);
238 sub->running = 1;
239
240 break;
241 case SNDRV_PCM_TRIGGER_STOP:
242 sub->running = 0;
243 aiodma_ch_set_enable(sub, 0);
244
245 break;
246 default:
247 dev_warn(dev, "Unknown trigger(%d)\n", cmd);
248 ret = -EINVAL;
249 }
250 spin_unlock_irqrestore(&sub->lock, flags);
251
252 return ret;
253}
254
255static int uniphier_aio_compr_pointer(struct snd_soc_component *component,
256 struct snd_compr_stream *cstream,
257 struct snd_compr_tstamp *tstamp)
258{
259 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
260 struct snd_compr_runtime *runtime = cstream->runtime;
261 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
262 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
263 int bytes = runtime->fragment_size;
264 unsigned long flags;
265 u32 pos;
266
267 spin_lock_irqsave(&sub->lock, flags);
268
269 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
270
271 if (sub->swm->dir == PORT_DIR_OUTPUT) {
272 pos = sub->rd_offs;
273
274 tstamp->copied_total = sub->rd_total / 2;
275 } else {
276 pos = sub->wr_offs;
277 tstamp->copied_total = sub->rd_total;
278 }
279 tstamp->byte_offset = pos;
280
281 spin_unlock_irqrestore(&sub->lock, flags);
282
283 return 0;
284}
285
286static int aio_compr_send_to_hw(struct uniphier_aio_sub *sub,
287 char __user *buf, size_t dstsize)
288{
289 u32 __user *srcbuf = (u32 __user *)buf;
290 u32 *dstbuf = (u32 *)(sub->compr_area + sub->wr_offs);
291 int src = 0, dst = 0, ret;
292 u32 frm, frm_a, frm_b;
293
294 while (dstsize > 0) {
295 ret = get_user(frm, srcbuf + src);
296 if (ret)
297 return ret;
298 src++;
299
300 frm_a = frm & 0xffff;
301 frm_b = (frm >> 16) & 0xffff;
302
303 if (frm == IEC61937_HEADER_SIGN) {
304 frm_a |= 0x01000000;
305
306
307 sub->iec_header = true;
308 } else {
309 u16 pc = be16_to_cpu((__be16)frm_a);
310
311 if (sub->iec_header && sub->iec_pc != pc) {
312
313 sub->iec_pc = pc;
314 ret = aio_oport_set_stream_type(sub, pc);
315 if (ret)
316 return ret;
317 }
318 sub->iec_header = false;
319 }
320 dstbuf[dst++] = frm_a;
321 dstbuf[dst++] = frm_b;
322
323 dstsize -= sizeof(u32) * 2;
324 }
325
326 return 0;
327}
328
329static int uniphier_aio_compr_copy(struct snd_soc_component *component,
330 struct snd_compr_stream *cstream,
331 char __user *buf, size_t count)
332{
333 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
334 struct snd_compr_runtime *runtime = cstream->runtime;
335 struct device *carddev = rtd->compr->card->dev;
336 struct uniphier_aio *aio = uniphier_priv(asoc_rtd_to_cpu(rtd, 0));
337 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
338 size_t cnt = min_t(size_t, count, aio_rb_space_to_end(sub) / 2);
339 int bytes = runtime->fragment_size;
340 unsigned long flags;
341 size_t s;
342 int ret;
343
344 if (cnt < sizeof(u32))
345 return 0;
346
347 if (sub->swm->dir == PORT_DIR_OUTPUT) {
348 dma_addr_t dmapos = sub->compr_addr + sub->wr_offs;
349
350
351 s = cnt * 2;
352
353 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_TO_DEVICE);
354 ret = aio_compr_send_to_hw(sub, buf, s);
355 dma_sync_single_for_device(carddev, dmapos, s, DMA_TO_DEVICE);
356 } else {
357 dma_addr_t dmapos = sub->compr_addr + sub->rd_offs;
358
359 s = cnt;
360
361 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_FROM_DEVICE);
362 ret = copy_to_user(buf, sub->compr_area + sub->rd_offs, s);
363 dma_sync_single_for_device(carddev, dmapos, s, DMA_FROM_DEVICE);
364 }
365 if (ret)
366 return -EFAULT;
367
368 spin_lock_irqsave(&sub->lock, flags);
369
370 sub->threshold = 2 * bytes;
371 aiodma_rb_set_threshold(sub, sub->compr_bytes, 2 * bytes);
372
373 if (sub->swm->dir == PORT_DIR_OUTPUT) {
374 sub->wr_offs += s;
375 if (sub->wr_offs >= sub->compr_bytes)
376 sub->wr_offs -= sub->compr_bytes;
377 } else {
378 sub->rd_offs += s;
379 if (sub->rd_offs >= sub->compr_bytes)
380 sub->rd_offs -= sub->compr_bytes;
381 }
382 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
383
384 spin_unlock_irqrestore(&sub->lock, flags);
385
386 return cnt;
387}
388
389static int uniphier_aio_compr_get_caps(struct snd_soc_component *component,
390 struct snd_compr_stream *cstream,
391 struct snd_compr_caps *caps)
392{
393 caps->num_codecs = 1;
394 caps->min_fragment_size = AUD_MIN_FRAGMENT_SIZE;
395 caps->max_fragment_size = AUD_MAX_FRAGMENT_SIZE;
396 caps->min_fragments = AUD_MIN_FRAGMENT;
397 caps->max_fragments = AUD_MAX_FRAGMENT;
398 caps->codecs[0] = SND_AUDIOCODEC_IEC61937;
399
400 return 0;
401}
402
403static const struct snd_compr_codec_caps caps_iec = {
404 .num_descriptors = 1,
405 .descriptor[0].max_ch = 8,
406 .descriptor[0].num_sample_rates = 0,
407 .descriptor[0].num_bitrates = 0,
408 .descriptor[0].profiles = SND_AUDIOPROFILE_IEC61937_SPDIF,
409 .descriptor[0].modes = SND_AUDIOMODE_IEC_AC3 |
410 SND_AUDIOMODE_IEC_MPEG1 |
411 SND_AUDIOMODE_IEC_MP3 |
412 SND_AUDIOMODE_IEC_DTS,
413 .descriptor[0].formats = 0,
414};
415
416static int uniphier_aio_compr_get_codec_caps(struct snd_soc_component *component,
417 struct snd_compr_stream *stream,
418 struct snd_compr_codec_caps *codec)
419{
420 if (codec->codec == SND_AUDIOCODEC_IEC61937)
421 *codec = caps_iec;
422 else
423 return -EINVAL;
424
425 return 0;
426}
427
428const struct snd_compress_ops uniphier_aio_compress_ops = {
429 .open = uniphier_aio_compr_open,
430 .free = uniphier_aio_compr_free,
431 .get_params = uniphier_aio_compr_get_params,
432 .set_params = uniphier_aio_compr_set_params,
433 .trigger = uniphier_aio_compr_trigger,
434 .pointer = uniphier_aio_compr_pointer,
435 .copy = uniphier_aio_compr_copy,
436 .get_caps = uniphier_aio_compr_get_caps,
437 .get_codec_caps = uniphier_aio_compr_get_codec_caps,
438};
439
