sound/soc/fsl/imx-pcm-fiq.c

   1 /*
   2  * imx-pcm-fiq.c  --  ALSA Soc Audio Layer
   3  *
   4  * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
   5  *
   6  * This code is based on code copyrighted by Freescale,
   7  * Liam Girdwood, Javier Martin and probably others.
   8  *
   9  *  This program is free software; you can redistribute  it and/or modify it
  10  *  under  the terms of  the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the  License, or (at your
  12  *  option) any later version.
  13  */
  14 #include <linux/clk.h>
  15 #include <linux/delay.h>
  16 #include <linux/device.h>
  17 #include <linux/dma-mapping.h>
  18 #include <linux/init.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/module.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/slab.h>
  23
  24 #include <sound/core.h>
  25 #include <sound/initval.h>
  26 #include <sound/pcm.h>
  27 #include <sound/pcm_params.h>
  28 #include <sound/soc.h>
  29
  30 #include <asm/fiq.h>
  31
  32 #include <linux/platform_data/asoc-imx-ssi.h>
  33
  34 #include "imx-ssi.h"
  35
  36 struct imx_pcm_runtime_data {
  37         unsigned int period;
  38         int periods;
  39         unsigned long offset;
  40         unsigned long last_offset;
  41         unsigned long size;
  42         struct hrtimer hrt;
  43         int poll_time_ns;
  44         struct snd_pcm_substream *substream;
  45         atomic_t playing;
  46         atomic_t capturing;
  47 };
  48
  49 static enum hrtimer_restart snd_hrtimer_callback(struct hrtimer *hrt)
  50 {
  51         struct imx_pcm_runtime_data *iprtd =
  52                 container_of(hrt, struct imx_pcm_runtime_data, hrt);
  53         struct snd_pcm_substream *substream = iprtd->substream;
  54         struct snd_pcm_runtime *runtime = substream->runtime;
  55         struct pt_regs regs;
  56         unsigned long delta;
  57
  58         if (!atomic_read(&iprtd->playing) && !atomic_read(&iprtd->capturing))
  59                 return HRTIMER_NORESTART;
  60
  61         get_fiq_regs(&regs);
  62
  63         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  64                 iprtd->offset = regs.ARM_r8 & 0xffff;
  65         else
  66                 iprtd->offset = regs.ARM_r9 & 0xffff;
  67
  68         /* How much data have we transferred since the last period report? */
  69         if (iprtd->offset >= iprtd->last_offset)
  70                 delta = iprtd->offset - iprtd->last_offset;
  71         else
  72                 delta = runtime->buffer_size + iprtd->offset
  73                         - iprtd->last_offset;
  74
  75         /* If we've transferred at least a period then report it and
  76          * reset our poll time */
  77         if (delta >= iprtd->period) {
  78                 snd_pcm_period_elapsed(substream);
  79                 iprtd->last_offset = iprtd->offset;
  80         }
  81
  82         hrtimer_forward_now(hrt, ns_to_ktime(iprtd->poll_time_ns));
  83
  84         return HRTIMER_RESTART;
  85 }
  86
  87 static struct fiq_handler fh = {
  88         .name           = DRV_NAME,
  89 };
  90
  91 static int snd_imx_pcm_hw_params(struct snd_pcm_substream *substream,
  92                                 struct snd_pcm_hw_params *params)
  93 {
  94         struct snd_pcm_runtime *runtime = substream->runtime;
  95         struct imx_pcm_runtime_data *iprtd = runtime->private_data;
  96
  97         iprtd->size = params_buffer_bytes(params);
  98         iprtd->periods = params_periods(params);
  99         iprtd->period = params_period_bytes(params) ;
 100         iprtd->offset = 0;
 101         iprtd->last_offset = 0;
 102         iprtd->poll_time_ns = 1000000000 / params_rate(params) *
 103                                 params_period_size(params);
 104         snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
 105
 106         return 0;
 107 }
 108
 109 static int snd_imx_pcm_prepare(struct snd_pcm_substream *substream)
 110 {
 111         struct snd_pcm_runtime *runtime = substream->runtime;
 112         struct imx_pcm_runtime_data *iprtd = runtime->private_data;
 113         struct pt_regs regs;
 114
 115         get_fiq_regs(&regs);
 116         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 117                 regs.ARM_r8 = (iprtd->period * iprtd->periods - 1) << 16;
 118         else
 119                 regs.ARM_r9 = (iprtd->period * iprtd->periods - 1) << 16;
 120
 121         set_fiq_regs(&regs);
 122
 123         return 0;
 124 }
 125
 126 static int imx_pcm_fiq;
 127
 128 static int snd_imx_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 129 {
 130         struct snd_pcm_runtime *runtime = substream->runtime;
 131         struct imx_pcm_runtime_data *iprtd = runtime->private_data;
 132
 133         switch (cmd) {
 134         case SNDRV_PCM_TRIGGER_START:
 135         case SNDRV_PCM_TRIGGER_RESUME:
 136         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 137                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 138                         atomic_set(&iprtd->playing, 1);
 139                 else
 140                         atomic_set(&iprtd->capturing, 1);
 141                 hrtimer_start(&iprtd->hrt, ns_to_ktime(iprtd->poll_time_ns),
 142                       HRTIMER_MODE_REL);
 143                 enable_fiq(imx_pcm_fiq);
 144                 break;
 145
 146         case SNDRV_PCM_TRIGGER_STOP:
 147         case SNDRV_PCM_TRIGGER_SUSPEND:
 148         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 149                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 150                         atomic_set(&iprtd->playing, 0);
 151                 else
 152                         atomic_set(&iprtd->capturing, 0);
 153                 if (!atomic_read(&iprtd->playing) &&
 154                                 !atomic_read(&iprtd->capturing))
 155                         disable_fiq(imx_pcm_fiq);
 156                 break;
 157
 158         default:
 159                 return -EINVAL;
 160         }
 161
 162         return 0;
 163 }
 164
 165 static snd_pcm_uframes_t snd_imx_pcm_pointer(struct snd_pcm_substream *substream)
 166 {
 167         struct snd_pcm_runtime *runtime = substream->runtime;
 168         struct imx_pcm_runtime_data *iprtd = runtime->private_data;
 169
 170         return bytes_to_frames(substream->runtime, iprtd->offset);
 171 }
 172
 173 static struct snd_pcm_hardware snd_imx_hardware = {
 174         .info = SNDRV_PCM_INFO_INTERLEAVED |
 175                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
 176                 SNDRV_PCM_INFO_MMAP |
 177                 SNDRV_PCM_INFO_MMAP_VALID |
 178                 SNDRV_PCM_INFO_PAUSE |
 179                 SNDRV_PCM_INFO_RESUME,
 180         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 181         .rate_min = 8000,
 182         .channels_min = 2,
 183         .channels_max = 2,
 184         .buffer_bytes_max = IMX_SSI_DMABUF_SIZE,
 185         .period_bytes_min = 128,
 186         .period_bytes_max = 16 * 1024,
 187         .periods_min = 4,
 188         .periods_max = 255,
 189         .fifo_size = 0,
 190 };
 191
 192 static int snd_imx_open(struct snd_pcm_substream *substream)
 193 {
 194         struct snd_pcm_runtime *runtime = substream->runtime;
 195         struct imx_pcm_runtime_data *iprtd;
 196         int ret;
 197
 198         iprtd = kzalloc(sizeof(*iprtd), GFP_KERNEL);
 199         if (iprtd == NULL)
 200                 return -ENOMEM;
 201         runtime->private_data = iprtd;
 202
 203         iprtd->substream = substream;
 204
 205         atomic_set(&iprtd->playing, 0);
 206         atomic_set(&iprtd->capturing, 0);
 207         hrtimer_init(&iprtd->hrt, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
 208         iprtd->hrt.function = snd_hrtimer_callback;
 209
 210         ret = snd_pcm_hw_constraint_integer(substream->runtime,
 211                         SNDRV_PCM_HW_PARAM_PERIODS);
 212         if (ret < 0) {
 213                 kfree(iprtd);
 214                 return ret;
 215         }
 216
 217         snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware);
 218         return 0;
 219 }
 220
 221 static int snd_imx_close(struct snd_pcm_substream *substream)
 222 {
 223         struct snd_pcm_runtime *runtime = substream->runtime;
 224         struct imx_pcm_runtime_data *iprtd = runtime->private_data;
 225
 226         hrtimer_cancel(&iprtd->hrt);
 227
 228         kfree(iprtd);
 229
 230         return 0;
 231 }
 232
 233 static struct snd_pcm_ops imx_pcm_ops = {
 234         .open           = snd_imx_open,
 235         .close          = snd_imx_close,
 236         .ioctl          = snd_pcm_lib_ioctl,
 237         .hw_params      = snd_imx_pcm_hw_params,
 238         .prepare        = snd_imx_pcm_prepare,
 239         .trigger        = snd_imx_pcm_trigger,
 240         .pointer        = snd_imx_pcm_pointer,
 241         .mmap           = snd_imx_pcm_mmap,
 242 };
 243
 244 static int ssi_irq = 0;
 245
 246 static int imx_pcm_fiq_new(struct snd_soc_pcm_runtime *rtd)
 247 {
 248         struct snd_pcm *pcm = rtd->pcm;
 249         struct snd_pcm_substream *substream;
 250         int ret;
 251
 252         ret = imx_pcm_new(rtd);
 253         if (ret)
 254                 return ret;
 255
 256         substream = pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
 257         if (substream) {
 258                 struct snd_dma_buffer *buf = &substream->dma_buffer;
 259
 260                 imx_ssi_fiq_tx_buffer = (unsigned long)buf->area;
 261         }
 262
 263         substream = pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream;
 264         if (substream) {
 265                 struct snd_dma_buffer *buf = &substream->dma_buffer;
 266
 267                 imx_ssi_fiq_rx_buffer = (unsigned long)buf->area;
 268         }
 269
 270         set_fiq_handler(&imx_ssi_fiq_start,
 271                 &imx_ssi_fiq_end - &imx_ssi_fiq_start);
 272
 273         return 0;
 274 }
 275
 276 static void imx_pcm_fiq_free(struct snd_pcm *pcm)
 277 {
 278         mxc_set_irq_fiq(ssi_irq, 0);
 279         release_fiq(&fh);
 280         imx_pcm_free(pcm);
 281 }
 282
 283 static struct snd_soc_platform_driver imx_soc_platform_fiq = {
 284         .ops            = &imx_pcm_ops,
 285         .pcm_new        = imx_pcm_fiq_new,
 286         .pcm_free       = imx_pcm_fiq_free,
 287 };
 288
 289 int imx_pcm_fiq_init(struct platform_device *pdev)
 290 {
 291         struct imx_ssi *ssi = platform_get_drvdata(pdev);
 292         int ret;
 293
 294         ret = claim_fiq(&fh);
 295         if (ret) {
 296                 dev_err(&pdev->dev, "failed to claim fiq: %d", ret);
 297                 return ret;
 298         }
 299
 300         mxc_set_irq_fiq(ssi->irq, 1);
 301         ssi_irq = ssi->irq;
 302
 303         imx_pcm_fiq = ssi->irq;
 304
 305         imx_ssi_fiq_base = (unsigned long)ssi->base;
 306
 307         ssi->dma_params_tx.maxburst = 4;
 308         ssi->dma_params_rx.maxburst = 6;
 309
 310         ret = snd_soc_register_platform(&pdev->dev, &imx_soc_platform_fiq);
 311         if (ret)
 312                 goto failed_register;
 313
 314         return 0;
 315
 316 failed_register:
 317         mxc_set_irq_fiq(ssi_irq, 0);
 318         release_fiq(&fh);
 319
 320         return ret;
 321 }