~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/soc/fsl/imx-pcm-fiq.c

Version: ~ [ linux-5.9.1 ] ~ [ linux-5.8.16 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.72 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.152 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.202 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.240 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.240 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 }
322 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp