Merge tag 'dmaengine-5.13-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/vkoul...
[linux-2.6-microblaze.git] / sound / soc / uniphier / aio-compress.c
1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Socionext UniPhier AIO Compress Audio driver.
4 //
5 // Copyright (c) 2017-2018 Socionext Inc.
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
19 static int uniphier_aio_compr_prepare(struct snd_soc_component *component,
20                                       struct snd_compr_stream *cstream);
21 static int uniphier_aio_compr_hw_free(struct snd_soc_component *component,
22                                       struct snd_compr_stream *cstream);
23
24 static 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
57 static 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
75 static 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
101 static 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
121 static 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
134 static 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         /* IEC frame type will be changed after received valid data */
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
171 static 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
183 static 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
221 static 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
255 static 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                 /* Size of AIO output format is double of IEC61937 */
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
286 static 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                         /* Next data is Pc and Pd */
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                                 /* Force overwrite IEC frame type */
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
329 static 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                 /* Size of AIO output format is double of IEC61937 */
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
389 static 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
403 static 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
416 static 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
428 const 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 };