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