aboutsummaryrefslogtreecommitdiffstats
path: root/sound/soc/fsl/mpc5200_dma.c
diff options
context:
space:
mode:
authorJon Smirl <jonsmirl@gmail.com>2009-05-23 19:12:59 -0400
committerMark Brown <broonie@opensource.wolfsonmicro.com>2009-05-24 14:31:03 -0400
commit89dd08425273773fd33fc85d48d152c5679b2fb4 (patch)
tree76ea69d61d9b2e204c77d421dc3d8419681a526e /sound/soc/fsl/mpc5200_dma.c
parent05e1efa2deb42b1bd548208e5c43f471e2cf0da1 (diff)
ASoC: Basic split of mpc5200 DMA code out of mpc5200_psc_i2s
Basic split of mpc5200 DMA code out from i2s into a standalone file. Signed-off-by: Jon Smirl <jonsmirl@gmail.com> Acked-by: Grant Likely <grant.likely@secretlab.ca> Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Diffstat (limited to 'sound/soc/fsl/mpc5200_dma.c')
-rw-r--r--sound/soc/fsl/mpc5200_dma.c458
1 files changed, 458 insertions, 0 deletions
diff --git a/sound/soc/fsl/mpc5200_dma.c b/sound/soc/fsl/mpc5200_dma.c
new file mode 100644
index 000000000000..4bae8d6e1a6a
--- /dev/null
+++ b/sound/soc/fsl/mpc5200_dma.c
@@ -0,0 +1,458 @@
1/*
2 * Freescale MPC5200 PSC DMA
3 * ALSA SoC Platform driver
4 *
5 * Copyright (C) 2008 Secret Lab Technologies Ltd.
6 */
7
8#include <linux/init.h>
9#include <linux/module.h>
10#include <linux/interrupt.h>
11#include <linux/device.h>
12#include <linux/delay.h>
13#include <linux/of_device.h>
14#include <linux/of_platform.h>
15#include <linux/dma-mapping.h>
16
17#include <sound/core.h>
18#include <sound/pcm.h>
19#include <sound/pcm_params.h>
20#include <sound/initval.h>
21#include <sound/soc.h>
22#include <sound/soc-of-simple.h>
23
24#include <sysdev/bestcomm/bestcomm.h>
25#include <sysdev/bestcomm/gen_bd.h>
26#include <asm/mpc52xx_psc.h>
27
28#include "mpc5200_dma.h"
29
30MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
31MODULE_DESCRIPTION("Freescale MPC5200 PSC in DMA mode ASoC Driver");
32MODULE_LICENSE("GPL");
33
34/*
35 * Interrupt handlers
36 */
37static irqreturn_t psc_i2s_status_irq(int irq, void *_psc_i2s)
38{
39 struct psc_i2s *psc_i2s = _psc_i2s;
40 struct mpc52xx_psc __iomem *regs = psc_i2s->psc_regs;
41 u16 isr;
42
43 isr = in_be16(&regs->mpc52xx_psc_isr);
44
45 /* Playback underrun error */
46 if (psc_i2s->playback.active && (isr & MPC52xx_PSC_IMR_TXEMP))
47 psc_i2s->stats.underrun_count++;
48
49 /* Capture overrun error */
50 if (psc_i2s->capture.active && (isr & MPC52xx_PSC_IMR_ORERR))
51 psc_i2s->stats.overrun_count++;
52
53 out_8(&regs->command, 4 << 4); /* reset the error status */
54
55 return IRQ_HANDLED;
56}
57
58/**
59 * psc_i2s_bcom_enqueue_next_buffer - Enqueue another audio buffer
60 * @s: pointer to stream private data structure
61 *
62 * Enqueues another audio period buffer into the bestcomm queue.
63 *
64 * Note: The routine must only be called when there is space available in
65 * the queue. Otherwise the enqueue will fail and the audio ring buffer
66 * will get out of sync
67 */
68static void psc_i2s_bcom_enqueue_next_buffer(struct psc_i2s_stream *s)
69{
70 struct bcom_bd *bd;
71
72 /* Prepare and enqueue the next buffer descriptor */
73 bd = bcom_prepare_next_buffer(s->bcom_task);
74 bd->status = s->period_bytes;
75 bd->data[0] = s->period_next_pt;
76 bcom_submit_next_buffer(s->bcom_task, NULL);
77
78 /* Update for next period */
79 s->period_next_pt += s->period_bytes;
80 if (s->period_next_pt >= s->period_end)
81 s->period_next_pt = s->period_start;
82}
83
84/* Bestcomm DMA irq handler */
85static irqreturn_t psc_i2s_bcom_irq(int irq, void *_psc_i2s_stream)
86{
87 struct psc_i2s_stream *s = _psc_i2s_stream;
88
89 /* For each finished period, dequeue the completed period buffer
90 * and enqueue a new one in it's place. */
91 while (bcom_buffer_done(s->bcom_task)) {
92 bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
93 s->period_current_pt += s->period_bytes;
94 if (s->period_current_pt >= s->period_end)
95 s->period_current_pt = s->period_start;
96 psc_i2s_bcom_enqueue_next_buffer(s);
97 bcom_enable(s->bcom_task);
98 }
99
100 /* If the stream is active, then also inform the PCM middle layer
101 * of the period finished event. */
102 if (s->active)
103 snd_pcm_period_elapsed(s->stream);
104
105 return IRQ_HANDLED;
106}
107
108/**
109 * psc_i2s_startup: create a new substream
110 *
111 * This is the first function called when a stream is opened.
112 *
113 * If this is the first stream open, then grab the IRQ and program most of
114 * the PSC registers.
115 */
116int psc_i2s_startup(struct snd_pcm_substream *substream,
117 struct snd_soc_dai *dai)
118{
119 struct snd_soc_pcm_runtime *rtd = substream->private_data;
120 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
121 int rc;
122
123 dev_dbg(psc_i2s->dev, "psc_i2s_startup(substream=%p)\n", substream);
124
125 if (!psc_i2s->playback.active &&
126 !psc_i2s->capture.active) {
127 /* Setup the IRQs */
128 rc = request_irq(psc_i2s->irq, &psc_i2s_status_irq, IRQF_SHARED,
129 "psc-i2s-status", psc_i2s);
130 rc |= request_irq(psc_i2s->capture.irq,
131 &psc_i2s_bcom_irq, IRQF_SHARED,
132 "psc-i2s-capture", &psc_i2s->capture);
133 rc |= request_irq(psc_i2s->playback.irq,
134 &psc_i2s_bcom_irq, IRQF_SHARED,
135 "psc-i2s-playback", &psc_i2s->playback);
136 if (rc) {
137 free_irq(psc_i2s->irq, psc_i2s);
138 free_irq(psc_i2s->capture.irq,
139 &psc_i2s->capture);
140 free_irq(psc_i2s->playback.irq,
141 &psc_i2s->playback);
142 return -ENODEV;
143 }
144 }
145
146 return 0;
147}
148
149int psc_i2s_hw_free(struct snd_pcm_substream *substream,
150 struct snd_soc_dai *dai)
151{
152 snd_pcm_set_runtime_buffer(substream, NULL);
153 return 0;
154}
155
156/**
157 * psc_i2s_trigger: start and stop the DMA transfer.
158 *
159 * This function is called by ALSA to start, stop, pause, and resume the DMA
160 * transfer of data.
161 */
162int psc_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
163 struct snd_soc_dai *dai)
164{
165 struct snd_soc_pcm_runtime *rtd = substream->private_data;
166 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
167 struct snd_pcm_runtime *runtime = substream->runtime;
168 struct psc_i2s_stream *s;
169 struct mpc52xx_psc __iomem *regs = psc_i2s->psc_regs;
170 u16 imr;
171 u8 psc_cmd;
172 unsigned long flags;
173
174 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
175 s = &psc_i2s->capture;
176 else
177 s = &psc_i2s->playback;
178
179 dev_dbg(psc_i2s->dev, "psc_i2s_trigger(substream=%p, cmd=%i)"
180 " stream_id=%i\n",
181 substream, cmd, substream->pstr->stream);
182
183 switch (cmd) {
184 case SNDRV_PCM_TRIGGER_START:
185 s->period_bytes = frames_to_bytes(runtime,
186 runtime->period_size);
187 s->period_start = virt_to_phys(runtime->dma_area);
188 s->period_end = s->period_start +
189 (s->period_bytes * runtime->periods);
190 s->period_next_pt = s->period_start;
191 s->period_current_pt = s->period_start;
192 s->active = 1;
193
194 /* First; reset everything */
195 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
196 out_8(&regs->command, MPC52xx_PSC_RST_RX);
197 out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
198 } else {
199 out_8(&regs->command, MPC52xx_PSC_RST_TX);
200 out_8(&regs->command, MPC52xx_PSC_RST_ERR_STAT);
201 }
202
203 /* Next, fill up the bestcomm bd queue and enable DMA.
204 * This will begin filling the PSC's fifo. */
205 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
206 bcom_gen_bd_rx_reset(s->bcom_task);
207 else
208 bcom_gen_bd_tx_reset(s->bcom_task);
209 while (!bcom_queue_full(s->bcom_task))
210 psc_i2s_bcom_enqueue_next_buffer(s);
211 bcom_enable(s->bcom_task);
212
213 /* Due to errata in the i2s mode; need to line up enabling
214 * the transmitter with a transition on the frame sync
215 * line */
216
217 spin_lock_irqsave(&psc_i2s->lock, flags);
218 /* first make sure it is low */
219 while ((in_8(&regs->ipcr_acr.ipcr) & 0x80) != 0)
220 ;
221 /* then wait for the transition to high */
222 while ((in_8(&regs->ipcr_acr.ipcr) & 0x80) == 0)
223 ;
224 /* Finally, enable the PSC.
225 * Receiver must always be enabled; even when we only want
226 * transmit. (see 15.3.2.3 of MPC5200B User's Guide) */
227 psc_cmd = MPC52xx_PSC_RX_ENABLE;
228 if (substream->pstr->stream == SNDRV_PCM_STREAM_PLAYBACK)
229 psc_cmd |= MPC52xx_PSC_TX_ENABLE;
230 out_8(&regs->command, psc_cmd);
231 spin_unlock_irqrestore(&psc_i2s->lock, flags);
232
233 break;
234
235 case SNDRV_PCM_TRIGGER_STOP:
236 /* Turn off the PSC */
237 s->active = 0;
238 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE) {
239 if (!psc_i2s->playback.active) {
240 out_8(&regs->command, 2 << 4); /* reset rx */
241 out_8(&regs->command, 3 << 4); /* reset tx */
242 out_8(&regs->command, 4 << 4); /* reset err */
243 }
244 } else {
245 out_8(&regs->command, 3 << 4); /* reset tx */
246 out_8(&regs->command, 4 << 4); /* reset err */
247 if (!psc_i2s->capture.active)
248 out_8(&regs->command, 2 << 4); /* reset rx */
249 }
250
251 bcom_disable(s->bcom_task);
252 while (!bcom_queue_empty(s->bcom_task))
253 bcom_retrieve_buffer(s->bcom_task, NULL, NULL);
254
255 break;
256
257 default:
258 dev_dbg(psc_i2s->dev, "invalid command\n");
259 return -EINVAL;
260 }
261
262 /* Update interrupt enable settings */
263 imr = 0;
264 if (psc_i2s->playback.active)
265 imr |= MPC52xx_PSC_IMR_TXEMP;
266 if (psc_i2s->capture.active)
267 imr |= MPC52xx_PSC_IMR_ORERR;
268 out_be16(&regs->isr_imr.imr, imr);
269
270 return 0;
271}
272
273/**
274 * psc_i2s_shutdown: shutdown the data transfer on a stream
275 *
276 * Shutdown the PSC if there are no other substreams open.
277 */
278void psc_i2s_shutdown(struct snd_pcm_substream *substream,
279 struct snd_soc_dai *dai)
280{
281 struct snd_soc_pcm_runtime *rtd = substream->private_data;
282 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
283
284 dev_dbg(psc_i2s->dev, "psc_i2s_shutdown(substream=%p)\n", substream);
285
286 /*
287 * If this is the last active substream, disable the PSC and release
288 * the IRQ.
289 */
290 if (!psc_i2s->playback.active &&
291 !psc_i2s->capture.active) {
292
293 /* Disable all interrupts and reset the PSC */
294 out_be16(&psc_i2s->psc_regs->isr_imr.imr, 0);
295 out_8(&psc_i2s->psc_regs->command, 3 << 4); /* reset tx */
296 out_8(&psc_i2s->psc_regs->command, 2 << 4); /* reset rx */
297 out_8(&psc_i2s->psc_regs->command, 1 << 4); /* reset mode */
298 out_8(&psc_i2s->psc_regs->command, 4 << 4); /* reset error */
299
300 /* Release irqs */
301 free_irq(psc_i2s->irq, psc_i2s);
302 free_irq(psc_i2s->capture.irq, &psc_i2s->capture);
303 free_irq(psc_i2s->playback.irq, &psc_i2s->playback);
304 }
305}
306
307/* ---------------------------------------------------------------------
308 * The PSC DMA 'ASoC platform' driver
309 *
310 * Can be referenced by an 'ASoC machine' driver
311 * This driver only deals with the audio bus; it doesn't have any
312 * interaction with the attached codec
313 */
314
315static const struct snd_pcm_hardware psc_i2s_pcm_hardware = {
316 .info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
317 SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
318 SNDRV_PCM_INFO_BATCH,
319 .formats = SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE |
320 SNDRV_PCM_FMTBIT_S24_BE | SNDRV_PCM_FMTBIT_S32_BE,
321 .rate_min = 8000,
322 .rate_max = 48000,
323 .channels_min = 2,
324 .channels_max = 2,
325 .period_bytes_max = 1024 * 1024,
326 .period_bytes_min = 32,
327 .periods_min = 2,
328 .periods_max = 256,
329 .buffer_bytes_max = 2 * 1024 * 1024,
330 .fifo_size = 0,
331};
332
333static int psc_i2s_pcm_open(struct snd_pcm_substream *substream)
334{
335 struct snd_soc_pcm_runtime *rtd = substream->private_data;
336 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
337 struct psc_i2s_stream *s;
338
339 dev_dbg(psc_i2s->dev, "psc_i2s_pcm_open(substream=%p)\n", substream);
340
341 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
342 s = &psc_i2s->capture;
343 else
344 s = &psc_i2s->playback;
345
346 snd_soc_set_runtime_hwparams(substream, &psc_i2s_pcm_hardware);
347
348 s->stream = substream;
349 return 0;
350}
351
352static int psc_i2s_pcm_close(struct snd_pcm_substream *substream)
353{
354 struct snd_soc_pcm_runtime *rtd = substream->private_data;
355 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
356 struct psc_i2s_stream *s;
357
358 dev_dbg(psc_i2s->dev, "psc_i2s_pcm_close(substream=%p)\n", substream);
359
360 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
361 s = &psc_i2s->capture;
362 else
363 s = &psc_i2s->playback;
364
365 s->stream = NULL;
366 return 0;
367}
368
369static snd_pcm_uframes_t
370psc_i2s_pcm_pointer(struct snd_pcm_substream *substream)
371{
372 struct snd_soc_pcm_runtime *rtd = substream->private_data;
373 struct psc_i2s *psc_i2s = rtd->dai->cpu_dai->private_data;
374 struct psc_i2s_stream *s;
375 dma_addr_t count;
376
377 if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
378 s = &psc_i2s->capture;
379 else
380 s = &psc_i2s->playback;
381
382 count = s->period_current_pt - s->period_start;
383
384 return bytes_to_frames(substream->runtime, count);
385}
386
387static struct snd_pcm_ops psc_i2s_pcm_ops = {
388 .open = psc_i2s_pcm_open,
389 .close = psc_i2s_pcm_close,
390 .ioctl = snd_pcm_lib_ioctl,
391 .pointer = psc_i2s_pcm_pointer,
392};
393
394static u64 psc_i2s_pcm_dmamask = 0xffffffff;
395static int psc_i2s_pcm_new(struct snd_card *card, struct snd_soc_dai *dai,
396 struct snd_pcm *pcm)
397{
398 struct snd_soc_pcm_runtime *rtd = pcm->private_data;
399 size_t size = psc_i2s_pcm_hardware.buffer_bytes_max;
400 int rc = 0;
401
402 dev_dbg(rtd->socdev->dev, "psc_i2s_pcm_new(card=%p, dai=%p, pcm=%p)\n",
403 card, dai, pcm);
404
405 if (!card->dev->dma_mask)
406 card->dev->dma_mask = &psc_i2s_pcm_dmamask;
407 if (!card->dev->coherent_dma_mask)
408 card->dev->coherent_dma_mask = 0xffffffff;
409
410 if (pcm->streams[0].substream) {
411 rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->dev, size,
412 &pcm->streams[0].substream->dma_buffer);
413 if (rc)
414 goto playback_alloc_err;
415 }
416
417 if (pcm->streams[1].substream) {
418 rc = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->dev, size,
419 &pcm->streams[1].substream->dma_buffer);
420 if (rc)
421 goto capture_alloc_err;
422 }
423
424 return 0;
425
426 capture_alloc_err:
427 if (pcm->streams[0].substream)
428 snd_dma_free_pages(&pcm->streams[0].substream->dma_buffer);
429 playback_alloc_err:
430 dev_err(card->dev, "Cannot allocate buffer(s)\n");
431 return -ENOMEM;
432}
433
434static void psc_i2s_pcm_free(struct snd_pcm *pcm)
435{
436 struct snd_soc_pcm_runtime *rtd = pcm->private_data;
437 struct snd_pcm_substream *substream;
438 int stream;
439
440 dev_dbg(rtd->socdev->dev, "psc_i2s_pcm_free(pcm=%p)\n", pcm);
441
442 for (stream = 0; stream < 2; stream++) {
443 substream = pcm->streams[stream].substream;
444 if (substream) {
445 snd_dma_free_pages(&substream->dma_buffer);
446 substream->dma_buffer.area = NULL;
447 substream->dma_buffer.addr = 0;
448 }
449 }
450}
451
452struct snd_soc_platform psc_i2s_pcm_soc_platform = {
453 .name = "mpc5200-psc-audio",
454 .pcm_ops = &psc_i2s_pcm_ops,
455 .pcm_new = &psc_i2s_pcm_new,
456 .pcm_free = &psc_i2s_pcm_free,
457};
458
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-05 19:28:18 -0500