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