Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/sound/soc/s6000/s6000-pcm.c

  1 /*
  2  * ALSA PCM interface for the Stetch s6000 family
  3  *
  4  * Author:      Daniel Gloeckner, <dg@emlix.com>
  5  * Copyright:   (C) 2009 emlix GmbH <info@emlix.com>
  6  *
  7  * This program is free software; you can redistribute it and/or modify
  8  * it under the terms of the GNU General Public License version 2 as
  9  * published by the Free Software Foundation.
 10  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/init.h>
 14 #include <linux/platform_device.h>
 15 #include <linux/slab.h>
 16 #include <linux/dma-mapping.h>
 17 #include <linux/interrupt.h>
 18 
 19 #include <sound/core.h>
 20 #include <sound/pcm.h>
 21 #include <sound/pcm_params.h>
 22 #include <sound/soc.h>
 23 
 24 #include <asm/dma.h>
 25 #include <variant/dmac.h>
 26 
 27 #include "s6000-pcm.h"
 28 
 29 #define S6_PCM_PREALLOCATE_SIZE (96 * 1024)
 30 #define S6_PCM_PREALLOCATE_MAX  (2048 * 1024)
 31 
 32 static struct snd_pcm_hardware s6000_pcm_hardware = {
 33         .info = (SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER |
 34                  SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |
 35                  SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_JOINT_DUPLEX),
 36         .buffer_bytes_max = 0x7ffffff0,
 37         .period_bytes_min = 16,
 38         .period_bytes_max = 0xfffff0,
 39         .periods_min = 2,
 40         .periods_max = 1024, /* no limit */
 41         .fifo_size = 0,
 42 };
 43 
 44 struct s6000_runtime_data {
 45         spinlock_t lock;
 46         int period;             /* current DMA period */
 47 };
 48 
 49 static void s6000_pcm_enqueue_dma(struct snd_pcm_substream *substream)
 50 {
 51         struct snd_pcm_runtime *runtime = substream->runtime;
 52         struct s6000_runtime_data *prtd = runtime->private_data;
 53         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
 54         struct s6000_pcm_dma_params *par;
 55         int channel;
 56         unsigned int period_size;
 57         unsigned int dma_offset;
 58         dma_addr_t dma_pos;
 59         dma_addr_t src, dst;
 60 
 61         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
 62 
 63         period_size = snd_pcm_lib_period_bytes(substream);
 64         dma_offset = prtd->period * period_size;
 65         dma_pos = runtime->dma_addr + dma_offset;
 66 
 67         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 68                 src = dma_pos;
 69                 dst = par->sif_out;
 70                 channel = par->dma_out;
 71         } else {
 72                 src = par->sif_in;
 73                 dst = dma_pos;
 74                 channel = par->dma_in;
 75         }
 76 
 77         if (!s6dmac_channel_enabled(DMA_MASK_DMAC(channel),
 78                                     DMA_INDEX_CHNL(channel)))
 79                 return;
 80 
 81         if (s6dmac_fifo_full(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel))) {
 82                 printk(KERN_ERR "s6000-pcm: fifo full\n");
 83                 return;
 84         }
 85 
 86         if (WARN_ON(period_size & 15))
 87                 return;
 88         s6dmac_put_fifo(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel),
 89                         src, dst, period_size);
 90 
 91         prtd->period++;
 92         if (unlikely(prtd->period >= runtime->periods))
 93                 prtd->period = 0;
 94 }
 95 
 96 static irqreturn_t s6000_pcm_irq(int irq, void *data)
 97 {
 98         struct snd_pcm *pcm = data;
 99         struct snd_soc_pcm_runtime *runtime = pcm->private_data;
100         struct s6000_runtime_data *prtd;
101         unsigned int has_xrun;
102         int i, ret = IRQ_NONE;
103 
104         for (i = 0; i < 2; ++i) {
105                 struct snd_pcm_substream *substream = pcm->streams[i].substream;
106                 struct s6000_pcm_dma_params *params =
107                                         snd_soc_dai_get_dma_data(runtime->cpu_dai, substream);
108                 u32 channel;
109                 unsigned int pending;
110 
111                 if (substream == SNDRV_PCM_STREAM_PLAYBACK)
112                         channel = params->dma_out;
113                 else
114                         channel = params->dma_in;
115 
116                 has_xrun = params->check_xrun(runtime->cpu_dai);
117 
118                 if (!channel)
119                         continue;
120 
121                 if (unlikely(has_xrun & (1 << i)) &&
122                     substream->runtime &&
123                     snd_pcm_running(substream)) {
124                         dev_dbg(pcm->dev, "xrun\n");
125                         snd_pcm_stream_lock(substream);
126                         snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
127                         snd_pcm_stream_unlock(substream);
128                         ret = IRQ_HANDLED;
129                 }
130 
131                 pending = s6dmac_int_sources(DMA_MASK_DMAC(channel),
132                                              DMA_INDEX_CHNL(channel));
133 
134                 if (pending & 1) {
135                         ret = IRQ_HANDLED;
136                         if (likely(substream->runtime &&
137                                    snd_pcm_running(substream))) {
138                                 snd_pcm_period_elapsed(substream);
139                                 dev_dbg(pcm->dev, "period elapsed %x %x\n",
140                                        s6dmac_cur_src(DMA_MASK_DMAC(channel),
141                                                    DMA_INDEX_CHNL(channel)),
142                                        s6dmac_cur_dst(DMA_MASK_DMAC(channel),
143                                                    DMA_INDEX_CHNL(channel)));
144                                 prtd = substream->runtime->private_data;
145                                 spin_lock(&prtd->lock);
146                                 s6000_pcm_enqueue_dma(substream);
147                                 spin_unlock(&prtd->lock);
148                         }
149                 }
150 
151                 if (unlikely(pending & ~7)) {
152                         if (pending & (1 << 3))
153                                 printk(KERN_WARNING
154                                        "s6000-pcm: DMA %x Underflow\n",
155                                        channel);
156                         if (pending & (1 << 4))
157                                 printk(KERN_WARNING
158                                        "s6000-pcm: DMA %x Overflow\n",
159                                        channel);
160                         if (pending & 0x1e0)
161                                 printk(KERN_WARNING
162                                        "s6000-pcm: DMA %x Master Error "
163                                        "(mask %x)\n",
164                                        channel, pending >> 5);
165 
166                 }
167         }
168 
169         return ret;
170 }
171 
172 static int s6000_pcm_start(struct snd_pcm_substream *substream)
173 {
174         struct s6000_runtime_data *prtd = substream->runtime->private_data;
175         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
176         struct s6000_pcm_dma_params *par;
177         unsigned long flags;
178         int srcinc;
179         u32 dma;
180 
181         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
182 
183         spin_lock_irqsave(&prtd->lock, flags);
184 
185         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
186                 srcinc = 1;
187                 dma = par->dma_out;
188         } else {
189                 srcinc = 0;
190                 dma = par->dma_in;
191         }
192         s6dmac_enable_chan(DMA_MASK_DMAC(dma), DMA_INDEX_CHNL(dma),
193                            1 /* priority 1 (0 is max) */,
194                            0 /* peripheral requests w/o xfer length mode */,
195                            srcinc /* source address increment */,
196                            srcinc^1 /* destination address increment */,
197                            0 /* chunksize 0 (skip impossible on this dma) */,
198                            0 /* source skip after chunk (impossible) */,
199                            0 /* destination skip after chunk (impossible) */,
200                            4 /* 16 byte burst size */,
201                            -1 /* don't conserve bandwidth */,
202                            0 /* low watermark irq descriptor threshold */,
203                            0 /* disable hardware timestamps */,
204                            1 /* enable channel */);
205 
206         s6000_pcm_enqueue_dma(substream);
207         s6000_pcm_enqueue_dma(substream);
208 
209         spin_unlock_irqrestore(&prtd->lock, flags);
210 
211         return 0;
212 }
213 
214 static int s6000_pcm_stop(struct snd_pcm_substream *substream)
215 {
216         struct s6000_runtime_data *prtd = substream->runtime->private_data;
217         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
218         struct s6000_pcm_dma_params *par;
219         unsigned long flags;
220         u32 channel;
221 
222         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
223 
224         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
225                 channel = par->dma_out;
226         else
227                 channel = par->dma_in;
228 
229         s6dmac_set_terminal_count(DMA_MASK_DMAC(channel),
230                                   DMA_INDEX_CHNL(channel), 0);
231 
232         spin_lock_irqsave(&prtd->lock, flags);
233 
234         s6dmac_disable_chan(DMA_MASK_DMAC(channel), DMA_INDEX_CHNL(channel));
235 
236         spin_unlock_irqrestore(&prtd->lock, flags);
237 
238         return 0;
239 }
240 
241 static int s6000_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
242 {
243         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
244         struct s6000_pcm_dma_params *par;
245         int ret;
246 
247         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
248 
249         ret = par->trigger(substream, cmd, 0);
250         if (ret < 0)
251                 return ret;
252 
253         switch (cmd) {
254         case SNDRV_PCM_TRIGGER_START:
255         case SNDRV_PCM_TRIGGER_RESUME:
256         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
257                 ret = s6000_pcm_start(substream);
258                 break;
259         case SNDRV_PCM_TRIGGER_STOP:
260         case SNDRV_PCM_TRIGGER_SUSPEND:
261         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
262                 ret = s6000_pcm_stop(substream);
263                 break;
264         default:
265                 ret = -EINVAL;
266         }
267         if (ret < 0)
268                 return ret;
269 
270         return par->trigger(substream, cmd, 1);
271 }
272 
273 static int s6000_pcm_prepare(struct snd_pcm_substream *substream)
274 {
275         struct s6000_runtime_data *prtd = substream->runtime->private_data;
276 
277         prtd->period = 0;
278 
279         return 0;
280 }
281 
282 static snd_pcm_uframes_t s6000_pcm_pointer(struct snd_pcm_substream *substream)
283 {
284         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
285         struct s6000_pcm_dma_params *par;
286         struct snd_pcm_runtime *runtime = substream->runtime;
287         struct s6000_runtime_data *prtd = runtime->private_data;
288         unsigned long flags;
289         unsigned int offset;
290         dma_addr_t count;
291 
292         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
293 
294         spin_lock_irqsave(&prtd->lock, flags);
295 
296         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
297                 count = s6dmac_cur_src(DMA_MASK_DMAC(par->dma_out),
298                                        DMA_INDEX_CHNL(par->dma_out));
299         else
300                 count = s6dmac_cur_dst(DMA_MASK_DMAC(par->dma_in),
301                                        DMA_INDEX_CHNL(par->dma_in));
302 
303         count -= runtime->dma_addr;
304 
305         spin_unlock_irqrestore(&prtd->lock, flags);
306 
307         offset = bytes_to_frames(runtime, count);
308         if (unlikely(offset >= runtime->buffer_size))
309                 offset = 0;
310 
311         return offset;
312 }
313 
314 static int s6000_pcm_open(struct snd_pcm_substream *substream)
315 {
316         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
317         struct s6000_pcm_dma_params *par;
318         struct snd_pcm_runtime *runtime = substream->runtime;
319         struct s6000_runtime_data *prtd;
320         int ret;
321 
322         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
323         snd_soc_set_runtime_hwparams(substream, &s6000_pcm_hardware);
324 
325         ret = snd_pcm_hw_constraint_step(runtime, 0,
326                                          SNDRV_PCM_HW_PARAM_PERIOD_BYTES, 16);
327         if (ret < 0)
328                 return ret;
329         ret = snd_pcm_hw_constraint_step(runtime, 0,
330                                          SNDRV_PCM_HW_PARAM_BUFFER_BYTES, 16);
331         if (ret < 0)
332                 return ret;
333         ret = snd_pcm_hw_constraint_integer(runtime,
334                                             SNDRV_PCM_HW_PARAM_PERIODS);
335         if (ret < 0)
336                 return ret;
337 
338         if (par->same_rate) {
339                 int rate;
340                 spin_lock(&par->lock); /* needed? */
341                 rate = par->rate;
342                 spin_unlock(&par->lock);
343                 if (rate != -1) {
344                         ret = snd_pcm_hw_constraint_minmax(runtime,
345                                                         SNDRV_PCM_HW_PARAM_RATE,
346                                                         rate, rate);
347                         if (ret < 0)
348                                 return ret;
349                 }
350         }
351 
352         prtd = kzalloc(sizeof(struct s6000_runtime_data), GFP_KERNEL);
353         if (prtd == NULL)
354                 return -ENOMEM;
355 
356         spin_lock_init(&prtd->lock);
357 
358         runtime->private_data = prtd;
359 
360         return 0;
361 }
362 
363 static int s6000_pcm_close(struct snd_pcm_substream *substream)
364 {
365         struct snd_pcm_runtime *runtime = substream->runtime;
366         struct s6000_runtime_data *prtd = runtime->private_data;
367 
368         kfree(prtd);
369 
370         return 0;
371 }
372 
373 static int s6000_pcm_hw_params(struct snd_pcm_substream *substream,
374                                  struct snd_pcm_hw_params *hw_params)
375 {
376         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
377         struct s6000_pcm_dma_params *par;
378         int ret;
379         ret = snd_pcm_lib_malloc_pages(substream,
380                                        params_buffer_bytes(hw_params));
381         if (ret < 0) {
382                 printk(KERN_WARNING "s6000-pcm: allocation of memory failed\n");
383                 return ret;
384         }
385 
386         par = snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
387 
388         if (par->same_rate) {
389                 spin_lock(&par->lock);
390                 if (par->rate == -1 ||
391                     !(par->in_use & ~(1 << substream->stream))) {
392                         par->rate = params_rate(hw_params);
393                         par->in_use |= 1 << substream->stream;
394                 } else if (params_rate(hw_params) != par->rate) {
395                         snd_pcm_lib_free_pages(substream);
396                         par->in_use &= ~(1 << substream->stream);
397                         ret = -EBUSY;
398                 }
399                 spin_unlock(&par->lock);
400         }
401         return ret;
402 }
403 
404 static int s6000_pcm_hw_free(struct snd_pcm_substream *substream)
405 {
406         struct snd_soc_pcm_runtime *soc_runtime = substream->private_data;
407         struct s6000_pcm_dma_params *par =
408                 snd_soc_dai_get_dma_data(soc_runtime->cpu_dai, substream);
409 
410         spin_lock(&par->lock);
411         par->in_use &= ~(1 << substream->stream);
412         if (!par->in_use)
413                 par->rate = -1;
414         spin_unlock(&par->lock);
415 
416         return snd_pcm_lib_free_pages(substream);
417 }
418 
419 static struct snd_pcm_ops s6000_pcm_ops = {
420         .open =         s6000_pcm_open,
421         .close =        s6000_pcm_close,
422         .ioctl =        snd_pcm_lib_ioctl,
423         .hw_params =    s6000_pcm_hw_params,
424         .hw_free =      s6000_pcm_hw_free,
425         .trigger =      s6000_pcm_trigger,
426         .prepare =      s6000_pcm_prepare,
427         .pointer =      s6000_pcm_pointer,
428 };
429 
430 static void s6000_pcm_free(struct snd_pcm *pcm)
431 {
432         struct snd_soc_pcm_runtime *runtime = pcm->private_data;
433         struct s6000_pcm_dma_params *params =
434                 snd_soc_dai_get_dma_data(runtime->cpu_dai,
435                         pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
436 
437         free_irq(params->irq, pcm);
438         snd_pcm_lib_preallocate_free_for_all(pcm);
439 }
440 
441 static int s6000_pcm_new(struct snd_soc_pcm_runtime *runtime)
442 {
443         struct snd_card *card = runtime->card->snd_card;
444         struct snd_pcm *pcm = runtime->pcm;
445         struct s6000_pcm_dma_params *params;
446         int res;
447 
448         params = snd_soc_dai_get_dma_data(runtime->cpu_dai,
449                         pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream);
450 
451         res = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32));
452         if (res)
453                 return res;
454 
455         if (params->dma_in) {
456                 s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_in),
457                                     DMA_INDEX_CHNL(params->dma_in));
458                 s6dmac_int_sources(DMA_MASK_DMAC(params->dma_in),
459                                    DMA_INDEX_CHNL(params->dma_in));
460         }
461 
462         if (params->dma_out) {
463                 s6dmac_disable_chan(DMA_MASK_DMAC(params->dma_out),
464                                     DMA_INDEX_CHNL(params->dma_out));
465                 s6dmac_int_sources(DMA_MASK_DMAC(params->dma_out),
466                                    DMA_INDEX_CHNL(params->dma_out));
467         }
468 
469         res = request_irq(params->irq, s6000_pcm_irq, IRQF_SHARED,
470                           "s6000-audio", pcm);
471         if (res) {
472                 printk(KERN_ERR "s6000-pcm couldn't get IRQ\n");
473                 return res;
474         }
475 
476         res = snd_pcm_lib_preallocate_pages_for_all(pcm,
477                                                     SNDRV_DMA_TYPE_DEV,
478                                                     card->dev,
479                                                     S6_PCM_PREALLOCATE_SIZE,
480                                                     S6_PCM_PREALLOCATE_MAX);
481         if (res)
482                 printk(KERN_WARNING "s6000-pcm: preallocation failed\n");
483 
484         spin_lock_init(&params->lock);
485         params->in_use = 0;
486         params->rate = -1;
487         return 0;
488 }
489 
490 static struct snd_soc_platform_driver s6000_soc_platform = {
491         .ops =          &s6000_pcm_ops,
492         .pcm_new =      s6000_pcm_new,
493         .pcm_free =     s6000_pcm_free,
494 };
495 
496 static int s6000_soc_platform_probe(struct platform_device *pdev)
497 {
498         return snd_soc_register_platform(&pdev->dev, &s6000_soc_platform);
499 }
500 
501 static int s6000_soc_platform_remove(struct platform_device *pdev)
502 {
503         snd_soc_unregister_platform(&pdev->dev);
504         return 0;
505 }
506 
507 static struct platform_driver s6000_pcm_driver = {
508         .driver = {
509                         .name = "s6000-pcm-audio",
510                         .owner = THIS_MODULE,
511         },
512 
513         .probe = s6000_soc_platform_probe,
514         .remove = s6000_soc_platform_remove,
515 };
516 
517 module_platform_driver(s6000_pcm_driver);
518 
519 MODULE_AUTHOR("Daniel Gloeckner");
520 MODULE_DESCRIPTION("Stretch s6000 family PCM DMA module");
521 MODULE_LICENSE("GPL");
522 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us