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 };
439