sound/soc/s3c24xx/s3c24xx-pcm.c

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