sound/soc/kirkwood/kirkwood-dma.c

   1 /*
   2  * kirkwood-dma.c
   3  *
   4  * (c) 2010 Arnaud Patard <apatard@mandriva.com>
   5  *
   6  *  This program is free software; you can redistribute  it and/or modify it
   7  *  under  the terms of  the GNU General  Public License as published by the
   8  *  Free Software Foundation;  either version 2 of the  License, or (at your
   9  *  option) any later version.
  10  */
  11
  12 #include <linux/init.h>
  13 #include <linux/module.h>
  14 #include <linux/device.h>
  15 #include <linux/io.h>
  16 #include <linux/slab.h>
  17 #include <linux/interrupt.h>
  18 #include <linux/dma-mapping.h>
  19 #include <linux/mbus.h>
  20 #include <sound/soc.h>
  21 #include "kirkwood.h"
  22
  23 #define KIRKWOOD_RATES \
  24         (SNDRV_PCM_RATE_44100 | \
  25          SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
  26 #define KIRKWOOD_FORMATS \
  27         (SNDRV_PCM_FMTBIT_S16_LE | \
  28          SNDRV_PCM_FMTBIT_S24_LE | \
  29          SNDRV_PCM_FMTBIT_S32_LE)
  30
  31 struct kirkwood_dma_priv {
  32         struct snd_pcm_substream *play_stream;
  33         struct snd_pcm_substream *rec_stream;
  34         struct kirkwood_dma_data *data;
  35 };
  36
  37 static struct snd_pcm_hardware kirkwood_dma_snd_hw = {
  38         .info = (SNDRV_PCM_INFO_INTERLEAVED |
  39                  SNDRV_PCM_INFO_MMAP |
  40                  SNDRV_PCM_INFO_MMAP_VALID |
  41                  SNDRV_PCM_INFO_BLOCK_TRANSFER |
  42                  SNDRV_PCM_INFO_PAUSE),
  43         .formats                = KIRKWOOD_FORMATS,
  44         .rates                  = KIRKWOOD_RATES,
  45         .rate_min               = 44100,
  46         .rate_max               = 96000,
  47         .channels_min           = 1,
  48         .channels_max           = 2,
  49         .buffer_bytes_max       = KIRKWOOD_SND_MAX_PERIOD_BYTES * KIRKWOOD_SND_MAX_PERIODS,
  50         .period_bytes_min       = KIRKWOOD_SND_MIN_PERIOD_BYTES,
  51         .period_bytes_max       = KIRKWOOD_SND_MAX_PERIOD_BYTES,
  52         .periods_min            = KIRKWOOD_SND_MIN_PERIODS,
  53         .periods_max            = KIRKWOOD_SND_MAX_PERIODS,
  54         .fifo_size              = 0,
  55 };
  56
  57 static u64 kirkwood_dma_dmamask = 0xFFFFFFFFUL;
  58
  59 static irqreturn_t kirkwood_dma_irq(int irq, void *dev_id)
  60 {
  61         struct kirkwood_dma_priv *prdata = dev_id;
  62         struct kirkwood_dma_data *priv = prdata->data;
  63         unsigned long mask, status, cause;
  64
  65         mask = readl(priv->io + KIRKWOOD_INT_MASK);
  66         status = readl(priv->io + KIRKWOOD_INT_CAUSE) & mask;
  67
  68         cause = readl(priv->io + KIRKWOOD_ERR_CAUSE);
  69         if (unlikely(cause)) {
  70                 printk(KERN_WARNING "%s: got err interrupt 0x%lx\n",
  71                                 __func__, cause);
  72                 writel(cause, priv->io + KIRKWOOD_ERR_CAUSE);
  73                 return IRQ_HANDLED;
  74         }
  75
  76         /* we've enabled only bytes interrupts ... */
  77         if (status & ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES | \
  78                         KIRKWOOD_INT_CAUSE_REC_BYTES)) {
  79                 printk(KERN_WARNING "%s: unexpected interrupt %lx\n",
  80                         __func__, status);
  81                 return IRQ_NONE;
  82         }
  83
  84         /* ack int */
  85         writel(status, priv->io + KIRKWOOD_INT_CAUSE);
  86
  87         if (status & KIRKWOOD_INT_CAUSE_PLAY_BYTES)
  88                 snd_pcm_period_elapsed(prdata->play_stream);
  89
  90         if (status & KIRKWOOD_INT_CAUSE_REC_BYTES)
  91                 snd_pcm_period_elapsed(prdata->rec_stream);
  92
  93         return IRQ_HANDLED;
  94 }
  95
  96 static void kirkwood_dma_conf_mbus_windows(void __iomem *base, int win,
  97                                         unsigned long dma,
  98                                         struct mbus_dram_target_info *dram)
  99 {
 100         int i;
 101
 102         /* First disable and clear windows */
 103         writel(0, base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
 104         writel(0, base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
 105
 106         /* try to find matching cs for current dma address */
 107         for (i = 0; i < dram->num_cs; i++) {
 108                 struct mbus_dram_window *cs = dram->cs + i;
 109                 if ((cs->base & 0xffff0000) < (dma & 0xffff0000)) {
 110                         writel(cs->base & 0xffff0000,
 111                                 base + KIRKWOOD_AUDIO_WIN_BASE_REG(win));
 112                         writel(((cs->size - 1) & 0xffff0000) |
 113                                 (cs->mbus_attr << 8) |
 114                                 (dram->mbus_dram_target_id << 4) | 1,
 115                                 base + KIRKWOOD_AUDIO_WIN_CTRL_REG(win));
 116                 }
 117         }
 118 }
 119
 120 static int kirkwood_dma_open(struct snd_pcm_substream *substream)
 121 {
 122         int err;
 123         struct snd_pcm_runtime *runtime = substream->runtime;
 124         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
 125         struct snd_soc_platform *platform = soc_runtime->platform;
 126         struct snd_soc_dai *cpu_dai = soc_runtime->cpu_dai;
 127         struct kirkwood_dma_data *priv;
 128         struct kirkwood_dma_priv *prdata = snd_soc_platform_get_drvdata(platform);
 129         unsigned long addr;
 130
 131         priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
 132         snd_soc_set_runtime_hwparams(substream, &kirkwood_dma_snd_hw);
 133
 134         /* Ensure that all constraints linked to dma burst are fullfilled */
 135         err = snd_pcm_hw_constraint_minmax(runtime,
 136                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
 137                         priv->burst * 2,
 138                         KIRKWOOD_AUDIO_BUF_MAX-1);
 139         if (err < 0)
 140                 return err;
 141
 142         err = snd_pcm_hw_constraint_step(runtime, 0,
 143                         SNDRV_PCM_HW_PARAM_BUFFER_BYTES,
 144                         priv->burst);
 145         if (err < 0)
 146                 return err;
 147
 148         err = snd_pcm_hw_constraint_step(substream->runtime, 0,
 149                          SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
 150                          priv->burst);
 151         if (err < 0)
 152                 return err;
 153
 154         if (prdata == NULL) {
 155                 prdata = kzalloc(sizeof(struct kirkwood_dma_priv), GFP_KERNEL);
 156                 if (prdata == NULL)
 157                         return -ENOMEM;
 158
 159                 prdata->data = priv;
 160
 161                 err = request_irq(priv->irq, kirkwood_dma_irq, IRQF_SHARED,
 162                                   "kirkwood-i2s", prdata);
 163                 if (err) {
 164                         kfree(prdata);
 165                         return -EBUSY;
 166                 }
 167
 168                 snd_soc_platform_set_drvdata(platform, prdata);
 169
 170                 /*
 171                  * Enable Error interrupts. We're only ack'ing them but
 172                  * it's usefull for diagnostics
 173                  */
 174                 writel((unsigned long)-1, priv->io + KIRKWOOD_ERR_MASK);
 175         }
 176
 177         addr = virt_to_phys(substream->dma_buffer.area);
 178         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 179                 prdata->play_stream = substream;
 180                 kirkwood_dma_conf_mbus_windows(priv->io,
 181                         KIRKWOOD_PLAYBACK_WIN, addr, priv->dram);
 182         } else {
 183                 prdata->rec_stream = substream;
 184                 kirkwood_dma_conf_mbus_windows(priv->io,
 185                         KIRKWOOD_RECORD_WIN, addr, priv->dram);
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int kirkwood_dma_close(struct snd_pcm_substream *substream)
 192 {
 193         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
 194         struct snd_soc_dai *cpu_dai = soc_runtime->cpu_dai;
 195         struct snd_soc_platform *platform = soc_runtime->platform;
 196         struct kirkwood_dma_priv *prdata = snd_soc_platform_get_drvdata(platform);
 197         struct kirkwood_dma_data *priv;
 198
 199         priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
 200
 201         if (!prdata || !priv)
 202                 return 0;
 203
 204         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 205                 prdata->play_stream = NULL;
 206         else
 207                 prdata->rec_stream = NULL;
 208
 209         if (!prdata->play_stream && !prdata->rec_stream) {
 210                 writel(0, priv->io + KIRKWOOD_ERR_MASK);
 211                 free_irq(priv->irq, prdata);
 212                 kfree(prdata);
 213                 snd_soc_platform_set_drvdata(platform, NULL);
 214         }
 215
 216         return 0;
 217 }
 218
 219 static int kirkwood_dma_hw_params(struct snd_pcm_substream *substream,
 220                                 struct snd_pcm_hw_params *params)
 221 {
 222         struct snd_pcm_runtime *runtime = substream->runtime;
 223
 224         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 225         runtime->dma_bytes = params_buffer_bytes(params);
 226
 227         return 0;
 228 }
 229
 230 static int kirkwood_dma_hw_free(struct snd_pcm_substream *substream)
 231 {
 232         snd_pcm_set_runtime_buffer(substream, NULL);
 233         return 0;
 234 }
 235
 236 static int kirkwood_dma_prepare(struct snd_pcm_substream *substream)
 237 {
 238         struct snd_pcm_runtime *runtime = substream->runtime;
 239         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
 240         struct snd_soc_dai *cpu_dai = soc_runtime->cpu_dai;
 241         struct kirkwood_dma_data *priv;
 242         unsigned long size, count;
 243
 244         priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
 245
 246         /* compute buffer size in term of "words" as requested in specs */
 247         size = frames_to_bytes(runtime, runtime->buffer_size);
 248         size = (size>>2)-1;
 249         count = snd_pcm_lib_period_bytes(substream);
 250
 251         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 252                 writel(count, priv->io + KIRKWOOD_PLAY_BYTE_INT_COUNT);
 253                 writel(runtime->dma_addr, priv->io + KIRKWOOD_PLAY_BUF_ADDR);
 254                 writel(size, priv->io + KIRKWOOD_PLAY_BUF_SIZE);
 255         } else {
 256                 writel(count, priv->io + KIRKWOOD_REC_BYTE_INT_COUNT);
 257                 writel(runtime->dma_addr, priv->io + KIRKWOOD_REC_BUF_ADDR);
 258                 writel(size, priv->io + KIRKWOOD_REC_BUF_SIZE);
 259         }
 260
 261
 262         return 0;
 263 }
 264
 265 static snd_pcm_uframes_t kirkwood_dma_pointer(struct snd_pcm_substream
 266                                                 *substream)
 267 {
 268         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
 269         struct snd_soc_dai *cpu_dai = soc_runtime->cpu_dai;
 270         struct kirkwood_dma_data *priv;
 271         snd_pcm_uframes_t count;
 272
 273         priv = snd_soc_dai_get_dma_data(cpu_dai, substream);
 274
 275         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 276                 count = bytes_to_frames(substream->runtime,
 277                         readl(priv->io + KIRKWOOD_PLAY_BYTE_COUNT));
 278         else
 279                 count = bytes_to_frames(substream->runtime,
 280                         readl(priv->io + KIRKWOOD_REC_BYTE_COUNT));
 281
 282         return count;
 283 }
 284
 285 struct snd_pcm_ops kirkwood_dma_ops = {
 286         .open =         kirkwood_dma_open,
 287         .close =        kirkwood_dma_close,
 288         .ioctl =        snd_pcm_lib_ioctl,
 289         .hw_params =    kirkwood_dma_hw_params,
 290         .hw_free =      kirkwood_dma_hw_free,
 291         .prepare =      kirkwood_dma_prepare,
 292         .pointer =      kirkwood_dma_pointer,
 293 };
 294
 295 static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm *pcm,
 296                 int stream)
 297 {
 298         struct snd_pcm_substream *substream = pcm->streams[stream].substream;
 299         struct snd_dma_buffer *buf = &substream->dma_buffer;
 300         size_t size = kirkwood_dma_snd_hw.buffer_bytes_max;
 301
 302         buf->dev.type = SNDRV_DMA_TYPE_DEV;
 303         buf->dev.dev = pcm->card->dev;
 304         buf->area = dma_alloc_coherent(pcm->card->dev, size,
 305                         &buf->addr, GFP_KERNEL);
 306         if (!buf->area)
 307                 return -ENOMEM;
 308         buf->bytes = size;
 309         buf->private_data = NULL;
 310
 311         return 0;
 312 }
 313
 314 static int kirkwood_dma_new(struct snd_card *card,
 315                 struct snd_soc_dai *dai, struct snd_pcm *pcm)
 316 {
 317         int ret;
 318
 319         if (!card->dev->dma_mask)
 320                 card->dev->dma_mask = &kirkwood_dma_dmamask;
 321         if (!card->dev->coherent_dma_mask)
 322                 card->dev->coherent_dma_mask = 0xffffffff;
 323
 324         if (dai->driver->playback.channels_min) {
 325                 ret = kirkwood_dma_preallocate_dma_buffer(pcm,
 326                                 SNDRV_PCM_STREAM_PLAYBACK);
 327                 if (ret)
 328                         return ret;
 329         }
 330
 331         if (dai->driver->capture.channels_min) {
 332                 ret = kirkwood_dma_preallocate_dma_buffer(pcm,
 333                                 SNDRV_PCM_STREAM_CAPTURE);
 334                 if (ret)
 335                         return ret;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static void kirkwood_dma_free_dma_buffers(struct snd_pcm *pcm)
 342 {
 343         struct snd_pcm_substream *substream;
 344         struct snd_dma_buffer *buf;
 345         int stream;
 346
 347         for (stream = 0; stream < 2; stream++) {
 348                 substream = pcm->streams[stream].substream;
 349                 if (!substream)
 350                         continue;
 351                 buf = &substream->dma_buffer;
 352                 if (!buf->area)
 353                         continue;
 354
 355                 dma_free_coherent(pcm->card->dev, buf->bytes,
 356                                 buf->area, buf->addr);
 357                 buf->area = NULL;
 358         }
 359 }
 360
 361 static struct snd_soc_platform_driver kirkwood_soc_platform = {
 362         .ops            = &kirkwood_dma_ops,
 363         .pcm_new        = kirkwood_dma_new,
 364         .pcm_free       = kirkwood_dma_free_dma_buffers,
 365 };
 366
 367 static int __devinit kirkwood_soc_platform_probe(struct platform_device *pdev)
 368 {
 369         return snd_soc_register_platform(&pdev->dev, &kirkwood_soc_platform);
 370 }
 371
 372 static int __devexit kirkwood_soc_platform_remove(struct platform_device *pdev)
 373 {
 374         snd_soc_unregister_platform(&pdev->dev);
 375         return 0;
 376 }
 377
 378 static struct platform_driver kirkwood_pcm_driver = {
 379         .driver = {
 380                         .name = "kirkwood-pcm-audio",
 381                         .owner = THIS_MODULE,
 382         },
 383
 384         .probe = kirkwood_soc_platform_probe,
 385         .remove = __devexit_p(kirkwood_soc_platform_remove),
 386 };
 387
 388 static int __init kirkwood_pcm_init(void)
 389 {
 390         return platform_driver_register(&kirkwood_pcm_driver);
 391 }
 392 module_init(kirkwood_pcm_init);
 393
 394 static void __exit kirkwood_pcm_exit(void)
 395 {
 396         platform_driver_unregister(&kirkwood_pcm_driver);
 397 }
 398 module_exit(kirkwood_pcm_exit);
 399
 400 MODULE_AUTHOR("Arnaud Patard <apatard@mandriva.com>");
 401 MODULE_DESCRIPTION("Marvell Kirkwood Audio DMA module");
 402 MODULE_LICENSE("GPL");
 403 MODULE_ALIAS("platform:kirkwood-pcm-audio");