sound/soc/samsung/dma.c

   1 /*
   2  * dma.c  --  ALSA Soc Audio Layer
   3  *
   4  * (c) 2006 Wolfson Microelectronics PLC.
   5  * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
   6  *
   7  * Copyright 2004-2005 Simtec Electronics
   8  *      http://armlinux.simtec.co.uk/
   9  *      Ben Dooks <ben@simtec.co.uk>
  10  *
  11  *  This program is free software; you can redistribute  it and/or modify it
  12  *  under  the terms of  the GNU General  Public License as published by the
  13  *  Free Software Foundation;  either version 2 of the  License, or (at your
  14  *  option) any later version.
  15  */
  16
  17 #include <linux/slab.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/module.h>
  20
  21 #include <sound/soc.h>
  22 #include <sound/pcm_params.h>
  23
  24 #include <asm/dma.h>
  25 #include <mach/hardware.h>
  26 #include <mach/dma.h>
  27
  28 #include "dma.h"
  29
  30 #define ST_RUNNING              (1<<0)
  31 #define ST_OPENED               (1<<1)
  32
  33 static const struct snd_pcm_hardware dma_hardware = {
  34         .info                   = SNDRV_PCM_INFO_INTERLEAVED |
  35                                     SNDRV_PCM_INFO_BLOCK_TRANSFER |
  36                                     SNDRV_PCM_INFO_MMAP |
  37                                     SNDRV_PCM_INFO_MMAP_VALID |
  38                                     SNDRV_PCM_INFO_PAUSE |
  39                                     SNDRV_PCM_INFO_RESUME,
  40         .formats                = SNDRV_PCM_FMTBIT_S16_LE |
  41                                     SNDRV_PCM_FMTBIT_U16_LE |
  42                                     SNDRV_PCM_FMTBIT_U8 |
  43                                     SNDRV_PCM_FMTBIT_S8,
  44         .channels_min           = 2,
  45         .channels_max           = 2,
  46         .buffer_bytes_max       = 128*1024,
  47         .period_bytes_min       = PAGE_SIZE,
  48         .period_bytes_max       = PAGE_SIZE*2,
  49         .periods_min            = 2,
  50         .periods_max            = 128,
  51         .fifo_size              = 32,
  52 };
  53
  54 struct runtime_data {
  55         spinlock_t lock;
  56         int state;
  57         unsigned int dma_loaded;
  58         unsigned int dma_limit;
  59         unsigned int dma_period;
  60         dma_addr_t dma_start;
  61         dma_addr_t dma_pos;
  62         dma_addr_t dma_end;
  63         struct s3c_dma_params *params;
  64 };
  65
  66 /* dma_enqueue
  67  *
  68  * place a dma buffer onto the queue for the dma system
  69  * to handle.
  70 */
  71 static void dma_enqueue(struct snd_pcm_substream *substream)
  72 {
  73         struct runtime_data *prtd = substream->runtime->private_data;
  74         dma_addr_t pos = prtd->dma_pos;
  75         unsigned int limit;
  76         int ret;
  77
  78         pr_debug("Entered %s\n", __func__);
  79
  80         if (s3c_dma_has_circular())
  81                 limit = (prtd->dma_end - prtd->dma_start) / prtd->dma_period;
  82         else
  83                 limit = prtd->dma_limit;
  84
  85         pr_debug("%s: loaded %d, limit %d\n",
  86                                 __func__, prtd->dma_loaded, limit);
  87
  88         while (prtd->dma_loaded < limit) {
  89                 unsigned long len = prtd->dma_period;
  90
  91                 pr_debug("dma_loaded: %d\n", prtd->dma_loaded);
  92
  93                 if ((pos + len) > prtd->dma_end) {
  94                         len  = prtd->dma_end - pos;
  95                         pr_debug("%s: corrected dma len %ld\n", __func__, len);
  96                 }
  97
  98                 ret = s3c2410_dma_enqueue(prtd->params->channel,
  99                         substream, pos, len);
 100
 101                 if (ret == 0) {
 102                         prtd->dma_loaded++;
 103                         pos += prtd->dma_period;
 104                         if (pos >= prtd->dma_end)
 105                                 pos = prtd->dma_start;
 106                 } else
 107                         break;
 108         }
 109
 110         prtd->dma_pos = pos;
 111 }
 112
 113 static void audio_buffdone(struct s3c2410_dma_chan *channel,
 114                                 void *dev_id, int size,
 115                                 enum s3c2410_dma_buffresult result)
 116 {
 117         struct snd_pcm_substream *substream = dev_id;
 118         struct runtime_data *prtd;
 119
 120         pr_debug("Entered %s\n", __func__);
 121
 122         if (result == S3C2410_RES_ABORT || result == S3C2410_RES_ERR)
 123                 return;
 124
 125         prtd = substream->runtime->private_data;
 126
 127         if (substream)
 128                 snd_pcm_period_elapsed(substream);
 129
 130         spin_lock(&prtd->lock);
 131         if (prtd->state & ST_RUNNING && !s3c_dma_has_circular()) {
 132                 prtd->dma_loaded--;
 133                 dma_enqueue(substream);
 134         }
 135
 136         spin_unlock(&prtd->lock);
 137 }
 138
 139 static int dma_hw_params(struct snd_pcm_substream *substream,
 140         struct snd_pcm_hw_params *params)
 141 {
 142         struct snd_pcm_runtime *runtime = substream->runtime;
 143         struct runtime_data *prtd = runtime->private_data;
 144         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 145         unsigned long totbytes = params_buffer_bytes(params);
 146         struct s3c_dma_params *dma =
 147                 snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
 148         int ret = 0;
 149
 150
 151         pr_debug("Entered %s\n", __func__);
 152
 153         /* return if this is a bufferless transfer e.g.
 154          * codec <--> BT codec or GSM modem -- lg FIXME */
 155         if (!dma)
 156                 return 0;
 157
 158         /* this may get called several times by oss emulation
 159          * with different params -HW */
 160         if (prtd->params == NULL) {
 161                 /* prepare DMA */
 162                 prtd->params = dma;
 163
 164                 pr_debug("params %p, client %p, channel %d\n", prtd->params,
 165                         prtd->params->client, prtd->params->channel);
 166
 167                 ret = s3c2410_dma_request(prtd->params->channel,
 168                                           prtd->params->client, NULL);
 169
 170                 if (ret < 0) {
 171                         printk(KERN_ERR "failed to get dma channel\n");
 172                         return ret;
 173                 }
 174
 175                 /* use the circular buffering if we have it available. */
 176                 if (s3c_dma_has_circular())
 177                         s3c2410_dma_setflags(prtd->params->channel,
 178                                              S3C2410_DMAF_CIRCULAR);
 179         }
 180
 181         s3c2410_dma_set_buffdone_fn(prtd->params->channel,
 182                                     audio_buffdone);
 183
 184         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 185
 186         runtime->dma_bytes = totbytes;
 187
 188         spin_lock_irq(&prtd->lock);
 189         prtd->dma_loaded = 0;
 190         prtd->dma_limit = runtime->hw.periods_min;
 191         prtd->dma_period = params_period_bytes(params);
 192         prtd->dma_start = runtime->dma_addr;
 193         prtd->dma_pos = prtd->dma_start;
 194         prtd->dma_end = prtd->dma_start + totbytes;
 195         spin_unlock_irq(&prtd->lock);
 196
 197         return 0;
 198 }
 199
 200 static int dma_hw_free(struct snd_pcm_substream *substream)
 201 {
 202         struct runtime_data *prtd = substream->runtime->private_data;
 203
 204         pr_debug("Entered %s\n", __func__);
 205
 206         /* TODO - do we need to ensure DMA flushed */
 207         snd_pcm_set_runtime_buffer(substream, NULL);
 208
 209         if (prtd->params) {
 210                 s3c2410_dma_free(prtd->params->channel, prtd->params->client);
 211                 prtd->params = NULL;
 212         }
 213
 214         return 0;
 215 }
 216
 217 static int dma_prepare(struct snd_pcm_substream *substream)
 218 {
 219         struct runtime_data *prtd = substream->runtime->private_data;
 220         int ret = 0;
 221
 222         pr_debug("Entered %s\n", __func__);
 223
 224         /* return if this is a bufferless transfer e.g.
 225          * codec <--> BT codec or GSM modem -- lg FIXME */
 226         if (!prtd->params)
 227                 return 0;
 228
 229         /* channel needs configuring for mem=>device, increment memory addr,
 230          * sync to pclk, half-word transfers to the IIS-FIFO. */
 231         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 232                 s3c2410_dma_devconfig(prtd->params->channel,
 233                                       S3C2410_DMASRC_MEM,
 234                                       prtd->params->dma_addr);
 235         } else {
 236                 s3c2410_dma_devconfig(prtd->params->channel,
 237                                       S3C2410_DMASRC_HW,
 238                                       prtd->params->dma_addr);
 239         }
 240
 241         s3c2410_dma_config(prtd->params->channel,
 242                            prtd->params->dma_size);
 243
 244         /* flush the DMA channel */
 245         s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_FLUSH);
 246         prtd->dma_loaded = 0;
 247         prtd->dma_pos = prtd->dma_start;
 248
 249         /* enqueue dma buffers */
 250         dma_enqueue(substream);
 251
 252         return ret;
 253 }
 254
 255 static int dma_trigger(struct snd_pcm_substream *substream, int cmd)
 256 {
 257         struct runtime_data *prtd = substream->runtime->private_data;
 258         int ret = 0;
 259
 260         pr_debug("Entered %s\n", __func__);
 261
 262         spin_lock(&prtd->lock);
 263
 264         switch (cmd) {
 265         case SNDRV_PCM_TRIGGER_START:
 266         case SNDRV_PCM_TRIGGER_RESUME:
 267         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 268                 prtd->state |= ST_RUNNING;
 269                 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_START);
 270                 break;
 271
 272         case SNDRV_PCM_TRIGGER_STOP:
 273         case SNDRV_PCM_TRIGGER_SUSPEND:
 274         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 275                 prtd->state &= ~ST_RUNNING;
 276                 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_STOP);
 277                 break;
 278
 279         default:
 280                 ret = -EINVAL;
 281                 break;
 282         }
 283
 284         spin_unlock(&prtd->lock);
 285
 286         return ret;
 287 }
 288
 289 static snd_pcm_uframes_t
 290 dma_pointer(struct snd_pcm_substream *substream)
 291 {
 292         struct snd_pcm_runtime *runtime = substream->runtime;
 293         struct runtime_data *prtd = runtime->private_data;
 294         unsigned long res;
 295         dma_addr_t src, dst;
 296
 297         pr_debug("Entered %s\n", __func__);
 298
 299         spin_lock(&prtd->lock);
 300         s3c2410_dma_getposition(prtd->params->channel, &src, &dst);
 301
 302         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 303                 res = dst - prtd->dma_start;
 304         else
 305                 res = src - prtd->dma_start;
 306
 307         spin_unlock(&prtd->lock);
 308
 309         pr_debug("Pointer %x %x\n", src, dst);
 310
 311         /* we seem to be getting the odd error from the pcm library due
 312          * to out-of-bounds pointers. this is maybe due to the dma engine
 313          * not having loaded the new values for the channel before being
 314          * called... (todo - fix )
 315          */
 316
 317         if (res >= snd_pcm_lib_buffer_bytes(substream)) {
 318                 if (res == snd_pcm_lib_buffer_bytes(substream))
 319                         res = 0;
 320         }
 321
 322         return bytes_to_frames(substream->runtime, res);
 323 }
 324
 325 static int dma_open(struct snd_pcm_substream *substream)
 326 {
 327         struct snd_pcm_runtime *runtime = substream->runtime;
 328         struct runtime_data *prtd;
 329
 330         pr_debug("Entered %s\n", __func__);
 331
 332         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 333         snd_soc_set_runtime_hwparams(substream, &dma_hardware);
 334
 335         prtd = kzalloc(sizeof(struct runtime_data), GFP_KERNEL);
 336         if (prtd == NULL)
 337                 return -ENOMEM;
 338
 339         spin_lock_init(&prtd->lock);
 340
 341         runtime->private_data = prtd;
 342         return 0;
 343 }
 344
 345 static int dma_close(struct snd_pcm_substream *substream)
 346 {
 347         struct snd_pcm_runtime *runtime = substream->runtime;
 348         struct runtime_data *prtd = runtime->private_data;
 349
 350         pr_debug("Entered %s\n", __func__);
 351
 352         if (!prtd)
 353                 pr_debug("dma_close called with prtd == NULL\n");
 354
 355         kfree(prtd);
 356
 357         return 0;
 358 }
 359
 360 static int dma_mmap(struct snd_pcm_substream *substream,
 361         struct vm_area_struct *vma)
 362 {
 363         struct snd_pcm_runtime *runtime = substream->runtime;
 364
 365         pr_debug("Entered %s\n", __func__);
 366
 367         return dma_mmap_writecombine(substream->pcm->card->dev, vma,
 368                                      runtime->dma_area,
 369                                      runtime->dma_addr,
 370                                      runtime->dma_bytes);
 371 }
 372
 373 static struct snd_pcm_ops dma_ops = {
 374         .open           = dma_open,
 375         .close          = dma_close,
 376         .ioctl          = snd_pcm_lib_ioctl,
 377         .hw_params      = dma_hw_params,
 378         .hw_free        = dma_hw_free,
 379         .prepare        = dma_prepare,
 380         .trigger        = dma_trigger,
 381         .pointer        = dma_pointer,
 382         .mmap           = dma_mmap,
 383 };
 384
 385 static int preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
 386 {
 387         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
 388         struct snd_dma_buffer *buf = &substream->dma_buffer;
 389         size_t size = dma_hardware.buffer_bytes_max;
 390
 391         pr_debug("Entered %s\n", __func__);
 392
 393         buf->dev.type = SNDRV_DMA_TYPE_DEV;
 394         buf->dev.dev = pcm->card->dev;
 395         buf->private_data = NULL;
 396         buf->area = dma_alloc_writecombine(pcm->card->dev, size,
 397                                            &buf->addr, GFP_KERNEL);
 398         if (!buf->area)
 399                 return -ENOMEM;
 400         buf->bytes = size;
 401         return 0;
 402 }
 403
 404 static void dma_free_dma_buffers(struct snd_pcm *pcm)
 405 {
 406         struct snd_pcm_substream *substream;
 407         struct snd_dma_buffer *buf;
 408         int stream;
 409
 410         pr_debug("Entered %s\n", __func__);
 411
 412         for (stream = 0; stream < 2; stream++) {
 413                 substream = pcm->streams[stream].substream;
 414                 if (!substream)
 415                         continue;
 416
 417                 buf = &substream->dma_buffer;
 418                 if (!buf->area)
 419                         continue;
 420
 421                 dma_free_writecombine(pcm->card->dev, buf->bytes,
 422                                       buf->area, buf->addr);
 423                 buf->area = NULL;
 424         }
 425 }
 426
 427 static u64 dma_mask = DMA_BIT_MASK(32);
 428
 429 static int dma_new(struct snd_soc_pcm_runtime *rtd)
 430 {
 431         struct snd_card *card = rtd->card->snd_card;
 432         struct snd_soc_dai *dai = rtd->cpu_dai;
 433         struct snd_pcm *pcm = rtd->pcm;
 434         int ret = 0;
 435
 436         pr_debug("Entered %s\n", __func__);
 437
 438         if (!card->dev->dma_mask)
 439                 card->dev->dma_mask = &dma_mask;
 440         if (!card->dev->coherent_dma_mask)
 441                 card->dev->coherent_dma_mask = 0xffffffff;
 442
 443         if (dai->driver->playback.channels_min) {
 444                 ret = preallocate_dma_buffer(pcm,
 445                         SNDRV_PCM_STREAM_PLAYBACK);
 446                 if (ret)
 447                         goto out;
 448         }
 449
 450         if (dai->driver->capture.channels_min) {
 451                 ret = preallocate_dma_buffer(pcm,
 452                         SNDRV_PCM_STREAM_CAPTURE);
 453                 if (ret)
 454                         goto out;
 455         }
 456 out:
 457         return ret;
 458 }
 459
 460 static struct snd_soc_platform_driver samsung_asoc_platform = {
 461         .ops            = &dma_ops,
 462         .pcm_new        = dma_new,
 463         .pcm_free       = dma_free_dma_buffers,
 464 };
 465
 466 static int __devinit samsung_asoc_platform_probe(struct platform_device *pdev)
 467 {
 468         return snd_soc_register_platform(&pdev->dev, &samsung_asoc_platform);
 469 }
 470
 471 static int __devexit samsung_asoc_platform_remove(struct platform_device *pdev)
 472 {
 473         snd_soc_unregister_platform(&pdev->dev);
 474         return 0;
 475 }
 476
 477 static struct platform_driver asoc_dma_driver = {
 478         .driver = {
 479                 .name = "samsung-audio",
 480                 .owner = THIS_MODULE,
 481         },
 482
 483         .probe = samsung_asoc_platform_probe,
 484         .remove = __devexit_p(samsung_asoc_platform_remove),
 485 };
 486
 487 static int __init samsung_asoc_init(void)
 488 {
 489         return platform_driver_register(&asoc_dma_driver);
 490 }
 491 module_init(samsung_asoc_init);
 492
 493 static void __exit samsung_asoc_exit(void)
 494 {
 495         platform_driver_unregister(&asoc_dma_driver);
 496 }
 497 module_exit(samsung_asoc_exit);
 498
 499 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
 500 MODULE_DESCRIPTION("Samsung ASoC DMA Driver");
 501 MODULE_LICENSE("GPL");
 502 MODULE_ALIAS("platform:samsung-audio");