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