xref: /linux/sound/soc/fsl/mpc5200_dma.c (revision a4654e9bde4ecedb4921e6c8fe2088114bdff1b3)
1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // Freescale MPC5200 PSC DMA
4 // ALSA SoC Platform driver
5 //
6 // Copyright (C) 2008 Secret Lab Technologies Ltd.
7 // Copyright (C) 2009 Jon Smirl, Digispeaker
8 
9 #include <linux/module.h>
10 #include <linux/of_device.h>
11 #include <linux/dma-mapping.h>
12 #include <linux/slab.h>
13 #include <linux/of_address.h>
14 #include <linux/of_irq.h>
15 #include <linux/of_platform.h>
16 
17 #include <sound/soc.h>
18 
19 #include <linux/fsl/bestcomm/bestcomm.h>
20 #include <linux/fsl/bestcomm/gen_bd.h>
21 #include <asm/mpc52xx_psc.h>
22 
23 #include "mpc5200_dma.h"
24 
25 #define DRV_NAME "mpc5200_dma"
26 
27 /*
28  * Interrupt handlers
29  */
30 static irqreturn_t psc_dma_status_irq(int irq, void *_psc_dma)
31 {
32 	struct psc_dma *psc_dma = _psc_dma;
33 	struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
34 	u16 isr;
35 
36 	isr = in_be16(&regs->mpc52xx_psc_isr);
37 
38 	/* Playback underrun error */
39 	if (psc_dma->playback.active && (isr & MPC52xx_PSC_IMR_TXEMP))
40 		psc_dma->stats.underrun_count++;
41 
42 	/* Capture overrun error */
43 	if (psc_dma->capture.active && (isr & MPC52xx_PSC_IMR_ORERR))
44 		psc_dma->stats.overrun_count++;
45 
46 	out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
47 
48 	return IRQ_HANDLED;
49 }
50 
51 /**
52  * psc_dma_bcom_enqueue_next_buffer - Enqueue another audio buffer
53  * @s: pointer to stream private data structure
54  *
55  * Enqueues another audio period buffer into the bestcomm queue.
56  *
57  * Note: The routine must only be called when there is space available in
58  * the queue.  Otherwise the enqueue will fail and the audio ring buffer
59  * will get out of sync
60  */
61 static void psc_dma_bcom_enqueue_next_buffer(struct psc_dma_stream *s)
62 {
63 	struct bcom_bd *bd;
64 
65 	/* Prepare and enqueue the next buffer descriptor */
66 	bd = bcom_prepare_next_buffer(s->bcom_task);
67 	bd->status = s->period_bytes;
68 	bd->data[0] = s->runtime->dma_addr + (s->period_next * s->period_bytes);
69 	bcom_submit_next_buffer(s->bcom_task, NULL);
70 
71 	/* Update for next period */
72 	s->period_next = (s->period_next + 1) % s->runtime->periods;
73 }
74 
75 /* Bestcomm DMA irq handler */
76 static irqreturn_t psc_dma_bcom_irq(int irq, void *_psc_dma_stream)
77 {
78 	struct psc_dma_stream *s = _psc_dma_stream;
79 
80 	spin_lock(&s->psc_dma->lock);
81 	/* For each finished period, dequeue the completed period buffer
82 	 * and enqueue a new one in it's place. */
83 	while (bcom_buffer_done(s->bcom_task)) {
84 		bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
85 
86 		s->period_current = (s->period_current+1) % s->runtime->periods;
87 		s->period_count++;
88 
89 		psc_dma_bcom_enqueue_next_buffer(s);
90 	}
91 	spin_unlock(&s->psc_dma->lock);
92 
93 	/* If the stream is active, then also inform the PCM middle layer
94 	 * of the period finished event. */
95 	if (s->active)
96 		snd_pcm_period_elapsed(s->stream);
97 
98 	return IRQ_HANDLED;
99 }
100 
101 static int psc_dma_hw_free(struct snd_soc_component *component,
102 			   struct snd_pcm_substream *substream)
103 {
104 	snd_pcm_set_runtime_buffer(substream, NULL);
105 	return 0;
106 }
107 
108 /**
109  * psc_dma_trigger: start and stop the DMA transfer.
110  *
111  * This function is called by ALSA to start, stop, pause, and resume the DMA
112  * transfer of data.
113  */
114 static int psc_dma_trigger(struct snd_soc_component *component,
115 			   struct snd_pcm_substream *substream, int cmd)
116 {
117 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
118 	struct psc_dma *psc_dma = snd_soc_dai_get_drvdata(rtd->cpu_dai);
119 	struct snd_pcm_runtime *runtime = substream->runtime;
120 	struct psc_dma_stream *s = to_psc_dma_stream(substream, psc_dma);
121 	struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
122 	u16 imr;
123 	unsigned long flags;
124 	int i;
125 
126 	switch (cmd) {
127 	case SNDRV_PCM_TRIGGER_START:
128 		dev_dbg(psc_dma->dev, "START: stream=%i fbits=%u ps=%u #p=%u\n",
129 			substream->pstr->stream, runtime->frame_bits,
130 			(int)runtime->period_size, runtime->periods);
131 		s->period_bytes = frames_to_bytes(runtime,
132 						  runtime->period_size);
133 		s->period_next = 0;
134 		s->period_current = 0;
135 		s->active = 1;
136 		s->period_count = 0;
137 		s->runtime = runtime;
138 
139 		/* Fill up the bestcomm bd queue and enable DMA.
140 		 * This will begin filling the PSC's fifo.
141 		 */
142 		spin_lock_irqsave(&psc_dma->lock, flags);
143 
144 		if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
145 			bcom_gen_bd_rx_reset(s->bcom_task);
146 		else
147 			bcom_gen_bd_tx_reset(s->bcom_task);
148 
149 		for (i = 0; i < runtime->periods; i++)
150 			if (!bcom_queue_full(s->bcom_task))
151 				psc_dma_bcom_enqueue_next_buffer(s);
152 
153 		bcom_enable(s->bcom_task);
154 		spin_unlock_irqrestore(&psc_dma->lock, flags);
155 
156 		out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
157 
158 		break;
159 
160 	case SNDRV_PCM_TRIGGER_STOP:
161 		dev_dbg(psc_dma->dev, "STOP: stream=%i periods_count=%i\n",
162 			substream->pstr->stream, s->period_count);
163 		s->active = 0;
164 
165 		spin_lock_irqsave(&psc_dma->lock, flags);
166 		bcom_disable(s->bcom_task);
167 		if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
168 			bcom_gen_bd_rx_reset(s->bcom_task);
169 		else
170 			bcom_gen_bd_tx_reset(s->bcom_task);
171 		spin_unlock_irqrestore(&psc_dma->lock, flags);
172 
173 		break;
174 
175 	default:
176 		dev_dbg(psc_dma->dev, "unhandled trigger: stream=%i cmd=%i\n",
177 			substream->pstr->stream, cmd);
178 		return -EINVAL;
179 	}
180 
181 	/* Update interrupt enable settings */
182 	imr = 0;
183 	if (psc_dma->playback.active)
184 		imr |= MPC52xx_PSC_IMR_TXEMP;
185 	if (psc_dma->capture.active)
186 		imr |= MPC52xx_PSC_IMR_ORERR;
187 	out_be16(&regs->isr_imr.imr, psc_dma->imr | imr);
188 
189 	return 0;
190 }
191 
192 
193 /* ---------------------------------------------------------------------
194  * The PSC DMA 'ASoC platform' driver
195  *
196  * Can be referenced by an 'ASoC machine' driver
197  * This driver only deals with the audio bus; it doesn't have any
198  * interaction with the attached codec
199  */
200 
201 static const struct snd_pcm_hardware psc_dma_hardware = {
202 	.info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
203 		SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
204 		SNDRV_PCM_INFO_BATCH,
205 	.formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE |
206 		SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S32_BE,
207 	.period_bytes_max	= 1024 * 1024,
208 	.period_bytes_min	= 32,
209 	.periods_min		= 2,
210 	.periods_max		= 256,
211 	.buffer_bytes_max	= 2 * 1024 * 1024,
212 	.fifo_size		= 512,
213 };
214 
215 static int psc_dma_open(struct snd_soc_component *component,
216 			struct snd_pcm_substream *substream)
217 {
218 	struct snd_pcm_runtime *runtime = substream->runtime;
219 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
220 	struct psc_dma *psc_dma = snd_soc_dai_get_drvdata(rtd->cpu_dai);
221 	struct psc_dma_stream *s;
222 	int rc;
223 
224 	dev_dbg(psc_dma->dev, "psc_dma_open(substream=%p)\n", substream);
225 
226 	if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
227 		s = &psc_dma->capture;
228 	else
229 		s = &psc_dma->playback;
230 
231 	snd_soc_set_runtime_hwparams(substream, &psc_dma_hardware);
232 
233 	rc = snd_pcm_hw_constraint_integer(runtime,
234 		SNDRV_PCM_HW_PARAM_PERIODS);
235 	if (rc < 0) {
236 		dev_err(substream->pcm->card->dev, "invalid buffer size\n");
237 		return rc;
238 	}
239 
240 	s->stream = substream;
241 	return 0;
242 }
243 
244 static int psc_dma_close(struct snd_soc_component *component,
245 			 struct snd_pcm_substream *substream)
246 {
247 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
248 	struct psc_dma *psc_dma = snd_soc_dai_get_drvdata(rtd->cpu_dai);
249 	struct psc_dma_stream *s;
250 
251 	dev_dbg(psc_dma->dev, "psc_dma_close(substream=%p)\n", substream);
252 
253 	if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
254 		s = &psc_dma->capture;
255 	else
256 		s = &psc_dma->playback;
257 
258 	if (!psc_dma->playback.active &&
259 	    !psc_dma->capture.active) {
260 
261 		/* Disable all interrupts and reset the PSC */
262 		out_be16(&psc_dma->psc_regs->isr_imr.imr, psc_dma->imr);
263 		out_8(&psc_dma->psc_regs->command, 4 << 4); /* reset error */
264 	}
265 	s->stream = NULL;
266 	return 0;
267 }
268 
269 static snd_pcm_uframes_t
270 psc_dma_pointer(struct snd_soc_component *component,
271 		struct snd_pcm_substream *substream)
272 {
273 	struct snd_soc_pcm_runtime *rtd = substream->private_data;
274 	struct psc_dma *psc_dma = snd_soc_dai_get_drvdata(rtd->cpu_dai);
275 	struct psc_dma_stream *s;
276 	dma_addr_t count;
277 
278 	if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
279 		s = &psc_dma->capture;
280 	else
281 		s = &psc_dma->playback;
282 
283 	count = s->period_current * s->period_bytes;
284 
285 	return bytes_to_frames(substream->runtime, count);
286 }
287 
288 static int psc_dma_hw_params(struct snd_soc_component *component,
289 			     struct snd_pcm_substream *substream,
290 			     struct snd_pcm_hw_params *params)
291 {
292 	snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
293 
294 	return 0;
295 }
296 
297 static int psc_dma_new(struct snd_soc_component *component,
298 		       struct snd_soc_pcm_runtime *rtd)
299 {
300 	struct snd_card *card = rtd->card->snd_card;
301 	struct snd_soc_dai *dai = rtd->cpu_dai;
302 	struct snd_pcm *pcm = rtd->pcm;
303 	size_t size = psc_dma_hardware.buffer_bytes_max;
304 	int rc;
305 
306 	dev_dbg(component->dev, "psc_dma_new(card=%p, dai=%p, pcm=%p)\n",
307 		card, dai, pcm);
308 
309 	rc = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
310 	if (rc)
311 		return rc;
312 
313 	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
314 		rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->card->dev,
315 				size, &pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->dma_buffer);
316 		if (rc)
317 			goto playback_alloc_err;
318 	}
319 
320 	if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
321 		rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->card->dev,
322 				size, &pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream->dma_buffer);
323 		if (rc)
324 			goto capture_alloc_err;
325 	}
326 
327 	return 0;
328 
329  capture_alloc_err:
330 	if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
331 		snd_dma_free_pages(&pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream->dma_buffer);
332 
333  playback_alloc_err:
334 	dev_err(card->dev, "Cannot allocate buffer(s)\n");
335 
336 	return -ENOMEM;
337 }
338 
339 static void psc_dma_free(struct snd_soc_component *component,
340 			 struct snd_pcm *pcm)
341 {
342 	struct snd_soc_pcm_runtime *rtd = pcm->private_data;
343 	struct snd_pcm_substream *substream;
344 	int stream;
345 
346 	dev_dbg(component->dev, "psc_dma_free(pcm=%p)\n", pcm);
347 
348 	for (stream = 0; stream < 2; stream++) {
349 		substream = pcm->streams[stream].substream;
350 		if (substream) {
351 			snd_dma_free_pages(&substream->dma_buffer);
352 			substream->dma_buffer.area = NULL;
353 			substream->dma_buffer.addr = 0;
354 		}
355 	}
356 }
357 
358 static const struct snd_soc_component_driver mpc5200_audio_dma_component = {
359 	.name		= DRV_NAME,
360 	.open		= psc_dma_open,
361 	.close		= psc_dma_close,
362 	.hw_free	= psc_dma_hw_free,
363 	.pointer	= psc_dma_pointer,
364 	.trigger	= psc_dma_trigger,
365 	.hw_params	= psc_dma_hw_params,
366 	.pcm_construct	= psc_dma_new,
367 	.pcm_destruct	= psc_dma_free,
368 };
369 
370 int mpc5200_audio_dma_create(struct platform_device *op)
371 {
372 	phys_addr_t fifo;
373 	struct psc_dma *psc_dma;
374 	struct resource res;
375 	int size, irq, rc;
376 	const __be32 *prop;
377 	void __iomem *regs;
378 	int ret;
379 
380 	/* Fetch the registers and IRQ of the PSC */
381 	irq = irq_of_parse_and_map(op->dev.of_node, 0);
382 	if (of_address_to_resource(op->dev.of_node, 0, &res)) {
383 		dev_err(&op->dev, "Missing reg property\n");
384 		return -ENODEV;
385 	}
386 	regs = ioremap(res.start, resource_size(&res));
387 	if (!regs) {
388 		dev_err(&op->dev, "Could not map registers\n");
389 		return -ENODEV;
390 	}
391 
392 	/* Allocate and initialize the driver private data */
393 	psc_dma = kzalloc(sizeof *psc_dma, GFP_KERNEL);
394 	if (!psc_dma) {
395 		ret = -ENOMEM;
396 		goto out_unmap;
397 	}
398 
399 	/* Get the PSC ID */
400 	prop = of_get_property(op->dev.of_node, "cell-index", &size);
401 	if (!prop || size < sizeof *prop) {
402 		ret = -ENODEV;
403 		goto out_free;
404 	}
405 
406 	spin_lock_init(&psc_dma->lock);
407 	mutex_init(&psc_dma->mutex);
408 	psc_dma->id = be32_to_cpu(*prop);
409 	psc_dma->irq = irq;
410 	psc_dma->psc_regs = regs;
411 	psc_dma->fifo_regs = regs + sizeof *psc_dma->psc_regs;
412 	psc_dma->dev = &op->dev;
413 	psc_dma->playback.psc_dma = psc_dma;
414 	psc_dma->capture.psc_dma = psc_dma;
415 	snprintf(psc_dma->name, sizeof psc_dma->name, "PSC%u", psc_dma->id);
416 
417 	/* Find the address of the fifo data registers and setup the
418 	 * DMA tasks */
419 	fifo = res.start + offsetof(struct mpc52xx_psc, buffer.buffer_32);
420 	psc_dma->capture.bcom_task =
421 		bcom_psc_gen_bd_rx_init(psc_dma->id, 10, fifo, 512);
422 	psc_dma->playback.bcom_task =
423 		bcom_psc_gen_bd_tx_init(psc_dma->id, 10, fifo);
424 	if (!psc_dma->capture.bcom_task ||
425 	    !psc_dma->playback.bcom_task) {
426 		dev_err(&op->dev, "Could not allocate bestcomm tasks\n");
427 		ret = -ENODEV;
428 		goto out_free;
429 	}
430 
431 	/* Disable all interrupts and reset the PSC */
432 	out_be16(&psc_dma->psc_regs->isr_imr.imr, psc_dma->imr);
433 	 /* reset receiver */
434 	out_8(&psc_dma->psc_regs->command, MPC52xx_PSC_RST_RX);
435 	 /* reset transmitter */
436 	out_8(&psc_dma->psc_regs->command, MPC52xx_PSC_RST_TX);
437 	 /* reset error */
438 	out_8(&psc_dma->psc_regs->command, MPC52xx_PSC_RST_ERR_STAT);
439 	 /* reset mode */
440 	out_8(&psc_dma->psc_regs->command, MPC52xx_PSC_SEL_MODE_REG_1);
441 
442 	/* Set up mode register;
443 	 * First write: RxRdy (FIFO Alarm) generates rx FIFO irq
444 	 * Second write: register Normal mode for non loopback
445 	 */
446 	out_8(&psc_dma->psc_regs->mode, 0);
447 	out_8(&psc_dma->psc_regs->mode, 0);
448 
449 	/* Set the TX and RX fifo alarm thresholds */
450 	out_be16(&psc_dma->fifo_regs->rfalarm, 0x100);
451 	out_8(&psc_dma->fifo_regs->rfcntl, 0x4);
452 	out_be16(&psc_dma->fifo_regs->tfalarm, 0x100);
453 	out_8(&psc_dma->fifo_regs->tfcntl, 0x7);
454 
455 	/* Lookup the IRQ numbers */
456 	psc_dma->playback.irq =
457 		bcom_get_task_irq(psc_dma->playback.bcom_task);
458 	psc_dma->capture.irq =
459 		bcom_get_task_irq(psc_dma->capture.bcom_task);
460 
461 	rc = request_irq(psc_dma->irq, &psc_dma_status_irq, IRQF_SHARED,
462 			 "psc-dma-status", psc_dma);
463 	rc |= request_irq(psc_dma->capture.irq, &psc_dma_bcom_irq, IRQF_SHARED,
464 			  "psc-dma-capture", &psc_dma->capture);
465 	rc |= request_irq(psc_dma->playback.irq, &psc_dma_bcom_irq, IRQF_SHARED,
466 			  "psc-dma-playback", &psc_dma->playback);
467 	if (rc) {
468 		ret = -ENODEV;
469 		goto out_irq;
470 	}
471 
472 	/* Save what we've done so it can be found again later */
473 	dev_set_drvdata(&op->dev, psc_dma);
474 
475 	/* Tell the ASoC OF helpers about it */
476 	return devm_snd_soc_register_component(&op->dev,
477 					&mpc5200_audio_dma_component, NULL, 0);
478 out_irq:
479 	free_irq(psc_dma->irq, psc_dma);
480 	free_irq(psc_dma->capture.irq, &psc_dma->capture);
481 	free_irq(psc_dma->playback.irq, &psc_dma->playback);
482 out_free:
483 	kfree(psc_dma);
484 out_unmap:
485 	iounmap(regs);
486 	return ret;
487 }
488 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_create);
489 
490 int mpc5200_audio_dma_destroy(struct platform_device *op)
491 {
492 	struct psc_dma *psc_dma = dev_get_drvdata(&op->dev);
493 
494 	dev_dbg(&op->dev, "mpc5200_audio_dma_destroy()\n");
495 
496 	bcom_gen_bd_rx_release(psc_dma->capture.bcom_task);
497 	bcom_gen_bd_tx_release(psc_dma->playback.bcom_task);
498 
499 	/* Release irqs */
500 	free_irq(psc_dma->irq, psc_dma);
501 	free_irq(psc_dma->capture.irq, &psc_dma->capture);
502 	free_irq(psc_dma->playback.irq, &psc_dma->playback);
503 
504 	iounmap(psc_dma->psc_regs);
505 	kfree(psc_dma);
506 	dev_set_drvdata(&op->dev, NULL);
507 
508 	return 0;
509 }
510 EXPORT_SYMBOL_GPL(mpc5200_audio_dma_destroy);
511 
512 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
513 MODULE_DESCRIPTION("Freescale MPC5200 PSC in DMA mode ASoC Driver");
514 MODULE_LICENSE("GPL");
515