git.oblomov.eu Git - linux-2.6/blob - sound/soc/fsl/mpc5200_dma.c

   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
  30 MODULE_AUTHOR("Grant Likely <grant.likely@secretlab.ca>");
  31 MODULE_DESCRIPTION("Freescale MPC5200 PSC in DMA mode ASoC Driver");
  32 MODULE_LICENSE("GPL");
  33
  34 /*
  35  * Interrupt handlers
  36  */
  37 static irqreturn_t psc_dma_status_irq(int irq, void *_psc_dma)
  38 {
  39         struct psc_dma *psc_dma = _psc_dma;
  40         struct mpc52xx_psc __iomem *regs = psc_dma->psc_regs;
  41         u16 isr;
  42
  43         isr = in_be16(&regs->mpc52xx_psc_isr);
  44
  45         /* Playback underrun error */
  46         if (psc_dma->playback.active && (isr & MPC52xx_PSC_IMR_TXEMP))
  47                 psc_dma->stats.underrun_count++;
  48
  49         /* Capture overrun error */
  50         if (psc_dma->capture.active && (isr & MPC52xx_PSC_IMR_ORERR))
  51                 psc_dma->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_dma_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  */
  68 static void psc_dma_bcom_enqueue_next_buffer(struct psc_dma_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 */
  85 static irqreturn_t psc_dma_bcom_irq(int irq, void *_psc_dma_stream)
  86 {
  87         struct psc_dma_stream *s = _psc_dma_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_dma_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_dma_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  */
 116 int psc_dma_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_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 121         int rc;
 122
 123         dev_dbg(psc_dma->dev, "psc_dma_startup(substream=%p)\n", substream);
 124
 125         if (!psc_dma->playback.active &&
 126             !psc_dma->capture.active) {
 127                 /* Setup the IRQs */
 128                 rc = request_irq(psc_dma->irq, &psc_dma_status_irq, IRQF_SHARED,
 129                                  "psc-dma-status", psc_dma);
 130                 rc |= request_irq(psc_dma->capture.irq,
 131                                   &psc_dma_bcom_irq, IRQF_SHARED,
 132                                   "psc-dma-capture", &psc_dma->capture);
 133                 rc |= request_irq(psc_dma->playback.irq,
 134                                   &psc_dma_bcom_irq, IRQF_SHARED,
 135                                   "psc-dma-playback", &psc_dma->playback);
 136                 if (rc) {
 137                         free_irq(psc_dma->irq, psc_dma);
 138                         free_irq(psc_dma->capture.irq,
 139                                  &psc_dma->capture);
 140                         free_irq(psc_dma->playback.irq,
 141                                  &psc_dma->playback);
 142                         return -ENODEV;
 143                 }
 144         }
 145
 146         return 0;
 147 }
 148
 149 int psc_dma_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_dma_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  */
 162 int psc_dma_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_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 167         struct snd_pcm_runtime *runtime = substream->runtime;
 168         struct psc_dma_stream *s;
 169         struct mpc52xx_psc __iomem *regs = psc_dma->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_dma->capture;
 176         else
 177                 s = &psc_dma->playback;
 178
 179         dev_dbg(psc_dma->dev, "psc_dma_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_dma_bcom_enqueue_next_buffer(s);
 211                 bcom_enable(s->bcom_task);
 212
 213                 /* Due to errata in the dma mode; need to line up enabling
 214                  * the transmitter with a transition on the frame sync
 215                  * line */
 216
 217                 spin_lock_irqsave(&psc_dma->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_dma->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_dma->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_dma->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_dma->dev, "invalid command\n");
 259                 return -EINVAL;
 260         }
 261
 262         /* Update interrupt enable settings */
 263         imr = 0;
 264         if (psc_dma->playback.active)
 265                 imr |= MPC52xx_PSC_IMR_TXEMP;
 266         if (psc_dma->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_dma_shutdown: shutdown the data transfer on a stream
 275  *
 276  * Shutdown the PSC if there are no other substreams open.
 277  */
 278 void psc_dma_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_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 283
 284         dev_dbg(psc_dma->dev, "psc_dma_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_dma->playback.active &&
 291             !psc_dma->capture.active) {
 292
 293                 /* Disable all interrupts and reset the PSC */
 294                 out_be16(&psc_dma->psc_regs->isr_imr.imr, 0);
 295                 out_8(&psc_dma->psc_regs->command, 3 << 4); /* reset tx */
 296                 out_8(&psc_dma->psc_regs->command, 2 << 4); /* reset rx */
 297                 out_8(&psc_dma->psc_regs->command, 1 << 4); /* reset mode */
 298                 out_8(&psc_dma->psc_regs->command, 4 << 4); /* reset error */
 299
 300                 /* Release irqs */
 301                 free_irq(psc_dma->irq, psc_dma);
 302                 free_irq(psc_dma->capture.irq, &psc_dma->capture);
 303                 free_irq(psc_dma->playback.irq, &psc_dma->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
 315 static const struct snd_pcm_hardware psc_dma_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
 333 static int psc_dma_pcm_open(struct snd_pcm_substream *substream)
 334 {
 335         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 336         struct psc_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 337         struct psc_dma_stream *s;
 338
 339         dev_dbg(psc_dma->dev, "psc_dma_pcm_open(substream=%p)\n", substream);
 340
 341         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
 342                 s = &psc_dma->capture;
 343         else
 344                 s = &psc_dma->playback;
 345
 346         snd_soc_set_runtime_hwparams(substream, &psc_dma_pcm_hardware);
 347
 348         s->stream = substream;
 349         return 0;
 350 }
 351
 352 static int psc_dma_pcm_close(struct snd_pcm_substream *substream)
 353 {
 354         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 355         struct psc_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 356         struct psc_dma_stream *s;
 357
 358         dev_dbg(psc_dma->dev, "psc_dma_pcm_close(substream=%p)\n", substream);
 359
 360         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
 361                 s = &psc_dma->capture;
 362         else
 363                 s = &psc_dma->playback;
 364
 365         s->stream = NULL;
 366         return 0;
 367 }
 368
 369 static snd_pcm_uframes_t
 370 psc_dma_pcm_pointer(struct snd_pcm_substream *substream)
 371 {
 372         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 373         struct psc_dma *psc_dma = rtd->dai->cpu_dai->private_data;
 374         struct psc_dma_stream *s;
 375         dma_addr_t count;
 376
 377         if (substream->pstr->stream == SNDRV_PCM_STREAM_CAPTURE)
 378                 s = &psc_dma->capture;
 379         else
 380                 s = &psc_dma->playback;
 381
 382         count = s->period_current_pt - s->period_start;
 383
 384         return bytes_to_frames(substream->runtime, count);
 385 }
 386
 387 static struct snd_pcm_ops psc_dma_pcm_ops = {
 388         .open           = psc_dma_pcm_open,
 389         .close          = psc_dma_pcm_close,
 390         .ioctl          = snd_pcm_lib_ioctl,
 391         .pointer        = psc_dma_pcm_pointer,
 392 };
 393
 394 static u64 psc_dma_pcm_dmamask = 0xffffffff;
 395 static int psc_dma_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_dma_pcm_hardware.buffer_bytes_max;
 400         int rc = 0;
 401
 402         dev_dbg(rtd->socdev->dev, "psc_dma_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_dma_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
 434 static void psc_dma_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_dma_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
 452 struct snd_soc_platform psc_dma_pcm_soc_platform = {
 453         .name           = "mpc5200-psc-audio",
 454         .pcm_ops        = &psc_dma_pcm_ops,
 455         .pcm_new        = &psc_dma_pcm_new,
 456         .pcm_free       = &psc_dma_pcm_free,
 457 };
 458