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,
 222                                       prtd->params->dma_addr);
 223         } else {
 224                 s3c2410_dma_devconfig(prtd->params->channel,
 225                                       S3C2410_DMASRC_HW,
 226                                       prtd->params->dma_addr);
 227         }
 228
 229         s3c2410_dma_config(prtd->params->channel,
 230                            prtd->params->dma_size);
 231
 232         /* flush the DMA channel */
 233         s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_FLUSH);
 234         prtd->dma_loaded = 0;
 235         prtd->dma_pos = prtd->dma_start;
 236
 237         /* enqueue dma buffers */
 238         s3c24xx_pcm_enqueue(substream);
 239
 240         return ret;
 241 }
 242
 243 static int s3c24xx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 244 {
 245         struct s3c24xx_runtime_data *prtd = substream->runtime->private_data;
 246         int ret = 0;
 247
 248         pr_debug("Entered %s\n", __func__);
 249
 250         spin_lock(&prtd->lock);
 251
 252         switch (cmd) {
 253         case SNDRV_PCM_TRIGGER_START:
 254         case SNDRV_PCM_TRIGGER_RESUME:
 255         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 256                 prtd->state |= ST_RUNNING;
 257                 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_START);
 258                 break;
 259
 260         case SNDRV_PCM_TRIGGER_STOP:
 261         case SNDRV_PCM_TRIGGER_SUSPEND:
 262         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 263                 prtd->state &= ~ST_RUNNING;
 264                 s3c2410_dma_ctrl(prtd->params->channel, S3C2410_DMAOP_STOP);
 265                 break;
 266
 267         default:
 268                 ret = -EINVAL;
 269                 break;
 270         }
 271
 272         spin_unlock(&prtd->lock);
 273
 274         return ret;
 275 }
 276
 277 static snd_pcm_uframes_t
 278 s3c24xx_pcm_pointer(struct snd_pcm_substream *substream)
 279 {
 280         struct snd_pcm_runtime *runtime = substream->runtime;
 281         struct s3c24xx_runtime_data *prtd = runtime->private_data;
 282         unsigned long res;
 283         dma_addr_t src, dst;
 284
 285         pr_debug("Entered %s\n", __func__);
 286
 287         spin_lock(&prtd->lock);
 288         s3c2410_dma_getposition(prtd->params->channel, &src, &dst);
 289
 290         if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
 291                 res = dst - prtd->dma_start;
 292         else
 293                 res = src - prtd->dma_start;
 294
 295         spin_unlock(&prtd->lock);
 296
 297         pr_debug("Pointer %x %x\n", src, dst);
 298
 299         /* we seem to be getting the odd error from the pcm library due
 300          * to out-of-bounds pointers. this is maybe due to the dma engine
 301          * not having loaded the new values for the channel before being
 302          * callled... (todo - fix )
 303          */
 304
 305         if (res >= snd_pcm_lib_buffer_bytes(substream)) {
 306                 if (res == snd_pcm_lib_buffer_bytes(substream))
 307                         res = 0;
 308         }
 309
 310         return bytes_to_frames(substream->runtime, res);
 311 }
 312
 313 static int s3c24xx_pcm_open(struct snd_pcm_substream *substream)
 314 {
 315         struct snd_pcm_runtime *runtime = substream->runtime;
 316         struct s3c24xx_runtime_data *prtd;
 317
 318         pr_debug("Entered %s\n", __func__);
 319
 320         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 321         snd_soc_set_runtime_hwparams(substream, &s3c24xx_pcm_hardware);
 322
 323         prtd = kzalloc(sizeof(struct s3c24xx_runtime_data), GFP_KERNEL);
 324         if (prtd == NULL)
 325                 return -ENOMEM;
 326
 327         spin_lock_init(&prtd->lock);
 328
 329         runtime->private_data = prtd;
 330         return 0;
 331 }
 332
 333 static int s3c24xx_pcm_close(struct snd_pcm_substream *substream)
 334 {
 335         struct snd_pcm_runtime *runtime = substream->runtime;
 336         struct s3c24xx_runtime_data *prtd = runtime->private_data;
 337
 338         pr_debug("Entered %s\n", __func__);
 339
 340         if (!prtd)
 341                 pr_debug("s3c24xx_pcm_close called with prtd == NULL\n");
 342
 343         kfree(prtd);
 344
 345         return 0;
 346 }
 347
 348 static int s3c24xx_pcm_mmap(struct snd_pcm_substream *substream,
 349         struct vm_area_struct *vma)
 350 {
 351         struct snd_pcm_runtime *runtime = substream->runtime;
 352
 353         pr_debug("Entered %s\n", __func__);
 354
 355         return dma_mmap_writecombine(substream->pcm->card->dev, vma,
 356                                      runtime->dma_area,
 357                                      runtime->dma_addr,
 358                                      runtime->dma_bytes);
 359 }
 360
 361 static struct snd_pcm_ops s3c24xx_pcm_ops = {
 362         .open           = s3c24xx_pcm_open,
 363         .close          = s3c24xx_pcm_close,
 364         .ioctl          = snd_pcm_lib_ioctl,
 365         .hw_params      = s3c24xx_pcm_hw_params,
 366         .hw_free        = s3c24xx_pcm_hw_free,
 367         .prepare        = s3c24xx_pcm_prepare,
 368         .trigger        = s3c24xx_pcm_trigger,
 369         .pointer        = s3c24xx_pcm_pointer,
 370         .mmap           = s3c24xx_pcm_mmap,
 371 };
 372
 373 static int s3c24xx_pcm_preallocate_dma_buffer(struct snd_pcm *pcm, int stream)
 374 {
 375         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
 376         struct snd_dma_buffer *buf = &substream->dma_buffer;
 377         size_t size = s3c24xx_pcm_hardware.buffer_bytes_max;
 378
 379         pr_debug("Entered %s\n", __func__);
 380
 381         buf->dev.type = SNDRV_DMA_TYPE_DEV;
 382         buf->dev.dev = pcm->card->dev;
 383         buf->private_data = NULL;
 384         buf->area = dma_alloc_writecombine(pcm->card->dev, size,
 385                                            &buf->addr, GFP_KERNEL);
 386         if (!buf->area)
 387                 return -ENOMEM;
 388         buf->bytes = size;
 389         return 0;
 390 }
 391
 392 static void s3c24xx_pcm_free_dma_buffers(struct snd_pcm *pcm)
 393 {
 394         struct snd_pcm_substream *substream;
 395         struct snd_dma_buffer *buf;
 396         int stream;
 397
 398         pr_debug("Entered %s\n", __func__);
 399
 400         for (stream = 0; stream < 2; stream++) {
 401                 substream = pcm->streams[stream].substream;
 402                 if (!substream)
 403                         continue;
 404
 405                 buf = &substream->dma_buffer;
 406                 if (!buf->area)
 407                         continue;
 408
 409                 dma_free_writecombine(pcm->card->dev, buf->bytes,
 410                                       buf->area, buf->addr);
 411                 buf->area = NULL;
 412         }
 413 }
 414
 415 static u64 s3c24xx_pcm_dmamask = DMA_BIT_MASK(32);
 416
 417 static int s3c24xx_pcm_new(struct snd_card *card,
 418         struct snd_soc_dai *dai, struct snd_pcm *pcm)
 419 {
 420         int ret = 0;
 421
 422         pr_debug("Entered %s\n", __func__);
 423
 424         if (!card->dev->dma_mask)
 425                 card->dev->dma_mask = &s3c24xx_pcm_dmamask;
 426         if (!card->dev->coherent_dma_mask)
 427                 card->dev->coherent_dma_mask = 0xffffffff;
 428
 429         if (dai->playback.channels_min) {
 430                 ret = s3c24xx_pcm_preallocate_dma_buffer(pcm,
 431                         SNDRV_PCM_STREAM_PLAYBACK);
 432                 if (ret)
 433                         goto out;
 434         }
 435
 436         if (dai->capture.channels_min) {
 437                 ret = s3c24xx_pcm_preallocate_dma_buffer(pcm,
 438                         SNDRV_PCM_STREAM_CAPTURE);
 439                 if (ret)
 440                         goto out;
 441         }
 442  out:
 443         return ret;
 444 }
 445
 446 struct snd_soc_platform s3c24xx_soc_platform = {
 447         .name           = "s3c24xx-audio",
 448         .pcm_ops        = &s3c24xx_pcm_ops,
 449         .pcm_new        = s3c24xx_pcm_new,
 450         .pcm_free       = s3c24xx_pcm_free_dma_buffers,
 451 };
 452 EXPORT_SYMBOL_GPL(s3c24xx_soc_platform);
 453
 454 static int __init s3c24xx_soc_platform_init(void)
 455 {
 456         return snd_soc_register_platform(&s3c24xx_soc_platform);
 457 }
 458 module_init(s3c24xx_soc_platform_init);
 459
 460 static void __exit s3c24xx_soc_platform_exit(void)
 461 {
 462         snd_soc_unregister_platform(&s3c24xx_soc_platform);
 463 }
 464 module_exit(s3c24xx_soc_platform_exit);
 465
 466 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
 467 MODULE_DESCRIPTION("Samsung S3C24XX PCM DMA module");
 468 MODULE_LICENSE("GPL");