1 // SPDX-License-Identifier: GPL-2.0
3 // Socionext UniPhier AIO Compress Audio driver.
5 // Copyright (c) 2017-2018 Socionext Inc.
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>
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);
24 static int uniphier_aio_comprdma_new(struct snd_soc_pcm_runtime *rtd)
26 struct snd_compr *compr = rtd->compr;
27 struct device *dev = compr->card->dev;
28 struct uniphier_aio *aio = uniphier_priv(snd_soc_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;
33 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(33));
37 sub->compr_area = kzalloc(size, GFP_KERNEL);
41 if (sub->swm->dir == PORT_DIR_OUTPUT)
42 dma_dir = DMA_TO_DEVICE;
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;
52 sub->compr_bytes = size;
57 static int uniphier_aio_comprdma_free(struct snd_soc_pcm_runtime *rtd)
59 struct snd_compr *compr = rtd->compr;
60 struct device *dev = compr->card->dev;
61 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
62 struct uniphier_aio_sub *sub = &aio->sub[compr->direction];
63 int dma_dir = DMA_FROM_DEVICE;
65 if (sub->swm->dir == PORT_DIR_OUTPUT)
66 dma_dir = DMA_TO_DEVICE;
68 dma_unmap_single(dev, sub->compr_addr, sub->compr_bytes, dma_dir);
69 kfree(sub->compr_area);
70 sub->compr_area = NULL;
75 static int uniphier_aio_compr_open(struct snd_soc_component *component,
76 struct snd_compr_stream *cstream)
78 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
79 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
80 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
86 sub->cstream = cstream;
87 sub->pass_through = 1;
88 sub->use_mmap = false;
90 ret = uniphier_aio_comprdma_new(rtd);
101 static int uniphier_aio_compr_free(struct snd_soc_component *component,
102 struct snd_compr_stream *cstream)
104 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
105 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
106 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
109 ret = uniphier_aio_compr_hw_free(component, cstream);
112 ret = uniphier_aio_comprdma_free(rtd);
121 static int uniphier_aio_compr_get_params(struct snd_soc_component *component,
122 struct snd_compr_stream *cstream,
123 struct snd_codec *params)
125 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
126 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
127 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
129 *params = sub->cparams.codec;
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)
138 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
139 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
140 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
141 struct device *dev = &aio->chip->pdev->dev;
143 if (params->codec.id != SND_AUDIOCODEC_IEC61937) {
144 dev_err(dev, "Codec ID is not supported(%d)\n",
148 if (params->codec.profile != SND_AUDIOPROFILE_IEC61937_SPDIF) {
149 dev_err(dev, "Codec profile is not supported(%d)\n",
150 params->codec.profile);
154 /* IEC frame type will be changed after received valid data */
155 sub->iec_pc = IEC61937_PC_AAC;
157 sub->cparams = *params;
163 return uniphier_aio_compr_prepare(component, cstream);
166 static int uniphier_aio_compr_hw_free(struct snd_soc_component *component,
167 struct snd_compr_stream *cstream)
169 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
170 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
171 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
178 static int uniphier_aio_compr_prepare(struct snd_soc_component *component,
179 struct snd_compr_stream *cstream)
181 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
182 struct snd_compr_runtime *runtime = cstream->runtime;
183 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
184 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
185 int bytes = runtime->fragment_size;
189 ret = aiodma_ch_set_param(sub);
193 spin_lock_irqsave(&sub->lock, flags);
194 ret = aiodma_rb_set_buffer(sub, sub->compr_addr,
195 sub->compr_addr + sub->compr_bytes,
197 spin_unlock_irqrestore(&sub->lock, flags);
201 ret = aio_port_set_param(sub, sub->pass_through, &sub->params);
204 ret = aio_oport_set_stream_type(sub, sub->iec_pc);
207 aio_port_set_enable(sub, 1);
209 ret = aio_if_set_param(sub, sub->pass_through);
216 static int uniphier_aio_compr_trigger(struct snd_soc_component *component,
217 struct snd_compr_stream *cstream,
220 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
221 struct snd_compr_runtime *runtime = cstream->runtime;
222 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
223 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
224 struct device *dev = &aio->chip->pdev->dev;
225 int bytes = runtime->fragment_size, ret = 0;
228 spin_lock_irqsave(&sub->lock, flags);
230 case SNDRV_PCM_TRIGGER_START:
231 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
232 aiodma_ch_set_enable(sub, 1);
236 case SNDRV_PCM_TRIGGER_STOP:
238 aiodma_ch_set_enable(sub, 0);
242 dev_warn(dev, "Unknown trigger(%d)\n", cmd);
245 spin_unlock_irqrestore(&sub->lock, flags);
250 static int uniphier_aio_compr_pointer(struct snd_soc_component *component,
251 struct snd_compr_stream *cstream,
252 struct snd_compr_tstamp *tstamp)
254 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
255 struct snd_compr_runtime *runtime = cstream->runtime;
256 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
257 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
258 int bytes = runtime->fragment_size;
262 spin_lock_irqsave(&sub->lock, flags);
264 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
266 if (sub->swm->dir == PORT_DIR_OUTPUT) {
268 /* Size of AIO output format is double of IEC61937 */
269 tstamp->copied_total = sub->rd_total / 2;
272 tstamp->copied_total = sub->rd_total;
274 tstamp->byte_offset = pos;
276 spin_unlock_irqrestore(&sub->lock, flags);
281 static int aio_compr_send_to_hw(struct uniphier_aio_sub *sub,
282 char __user *buf, size_t dstsize)
284 u32 __user *srcbuf = (u32 __user *)buf;
285 u32 *dstbuf = (u32 *)(sub->compr_area + sub->wr_offs);
286 int src = 0, dst = 0, ret;
287 u32 frm, frm_a, frm_b;
289 while (dstsize > 0) {
290 ret = get_user(frm, srcbuf + src);
295 frm_a = frm & 0xffff;
296 frm_b = (frm >> 16) & 0xffff;
298 if (frm == IEC61937_HEADER_SIGN) {
301 /* Next data is Pc and Pd */
302 sub->iec_header = true;
304 u16 pc = be16_to_cpu((__be16)frm_a);
306 if (sub->iec_header && sub->iec_pc != pc) {
307 /* Force overwrite IEC frame type */
309 ret = aio_oport_set_stream_type(sub, pc);
313 sub->iec_header = false;
315 dstbuf[dst++] = frm_a;
316 dstbuf[dst++] = frm_b;
318 dstsize -= sizeof(u32) * 2;
324 static int uniphier_aio_compr_copy(struct snd_soc_component *component,
325 struct snd_compr_stream *cstream,
326 char __user *buf, size_t count)
328 struct snd_soc_pcm_runtime *rtd = cstream->private_data;
329 struct snd_compr_runtime *runtime = cstream->runtime;
330 struct device *carddev = rtd->compr->card->dev;
331 struct uniphier_aio *aio = uniphier_priv(snd_soc_rtd_to_cpu(rtd, 0));
332 struct uniphier_aio_sub *sub = &aio->sub[cstream->direction];
333 size_t cnt = min_t(size_t, count, aio_rb_space_to_end(sub) / 2);
334 int bytes = runtime->fragment_size;
339 if (cnt < sizeof(u32))
342 if (sub->swm->dir == PORT_DIR_OUTPUT) {
343 dma_addr_t dmapos = sub->compr_addr + sub->wr_offs;
345 /* Size of AIO output format is double of IEC61937 */
348 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_TO_DEVICE);
349 ret = aio_compr_send_to_hw(sub, buf, s);
350 dma_sync_single_for_device(carddev, dmapos, s, DMA_TO_DEVICE);
352 dma_addr_t dmapos = sub->compr_addr + sub->rd_offs;
356 dma_sync_single_for_cpu(carddev, dmapos, s, DMA_FROM_DEVICE);
357 ret = copy_to_user(buf, sub->compr_area + sub->rd_offs, s);
358 dma_sync_single_for_device(carddev, dmapos, s, DMA_FROM_DEVICE);
363 spin_lock_irqsave(&sub->lock, flags);
365 sub->threshold = 2 * bytes;
366 aiodma_rb_set_threshold(sub, sub->compr_bytes, 2 * bytes);
368 if (sub->swm->dir == PORT_DIR_OUTPUT) {
370 if (sub->wr_offs >= sub->compr_bytes)
371 sub->wr_offs -= sub->compr_bytes;
374 if (sub->rd_offs >= sub->compr_bytes)
375 sub->rd_offs -= sub->compr_bytes;
377 aiodma_rb_sync(sub, sub->compr_addr, sub->compr_bytes, bytes);
379 spin_unlock_irqrestore(&sub->lock, flags);
384 static int uniphier_aio_compr_get_caps(struct snd_soc_component *component,
385 struct snd_compr_stream *cstream,
386 struct snd_compr_caps *caps)
388 caps->num_codecs = 1;
389 caps->min_fragment_size = AUD_MIN_FRAGMENT_SIZE;
390 caps->max_fragment_size = AUD_MAX_FRAGMENT_SIZE;
391 caps->min_fragments = AUD_MIN_FRAGMENT;
392 caps->max_fragments = AUD_MAX_FRAGMENT;
393 caps->codecs[0] = SND_AUDIOCODEC_IEC61937;
398 static const struct snd_compr_codec_caps caps_iec = {
399 .num_descriptors = 1,
400 .descriptor[0].max_ch = 8,
401 .descriptor[0].num_sample_rates = 0,
402 .descriptor[0].num_bitrates = 0,
403 .descriptor[0].profiles = SND_AUDIOPROFILE_IEC61937_SPDIF,
404 .descriptor[0].modes = SND_AUDIOMODE_IEC_AC3 |
405 SND_AUDIOMODE_IEC_MPEG1 |
406 SND_AUDIOMODE_IEC_MP3 |
407 SND_AUDIOMODE_IEC_DTS,
408 .descriptor[0].formats = 0,
411 static int uniphier_aio_compr_get_codec_caps(struct snd_soc_component *component,
412 struct snd_compr_stream *stream,
413 struct snd_compr_codec_caps *codec)
415 if (codec->codec == SND_AUDIOCODEC_IEC61937)
423 const struct snd_compress_ops uniphier_aio_compress_ops = {
424 .open = uniphier_aio_compr_open,
425 .free = uniphier_aio_compr_free,
426 .get_params = uniphier_aio_compr_get_params,
427 .set_params = uniphier_aio_compr_set_params,
428 .trigger = uniphier_aio_compr_trigger,
429 .pointer = uniphier_aio_compr_pointer,
430 .copy = uniphier_aio_compr_copy,
431 .get_caps = uniphier_aio_compr_get_caps,
432 .get_codec_caps = uniphier_aio_compr_get_codec_caps,