Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
atmel-pcm.c
Go to the documentation of this file.
1 /*
2  * atmel-pcm.c -- ALSA PCM interface for the Atmel atmel SoC.
3  *
4  * Copyright (C) 2005 SAN People
5  * Copyright (C) 2008 Atmel
6  *
7  * Authors: Sedji Gaouaou <[email protected]>
8  *
9  * Based on at91-pcm. by:
10  * Frank Mandarino <[email protected]>
11  * Copyright 2006 Endrelia Technologies Inc.
12  *
13  * Based on pxa2xx-pcm.c by:
14  *
15  * Author: Nicolas Pitre
16  * Created: Nov 30, 2004
17  * Copyright: (C) 2004 MontaVista Software, Inc.
18  *
19  * This program is free software; you can redistribute it and/or modify
20  * it under the terms of the GNU General Public License as published by
21  * the Free Software Foundation; either version 2 of the License, or
22  * (at your option) any later version.
23  *
24  * This program is distributed in the hope that it will be useful,
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27  * GNU General Public License for more details.
28  *
29  * You should have received a copy of the GNU General Public License
30  * along with this program; if not, write to the Free Software
31  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
32  */
33 
34 #include <linux/module.h>
35 #include <linux/init.h>
36 #include <linux/platform_device.h>
37 #include <linux/slab.h>
38 #include <linux/dma-mapping.h>
39 #include <linux/atmel_pdc.h>
40 #include <linux/atmel-ssc.h>
41 
42 #include <sound/core.h>
43 #include <sound/pcm.h>
44 #include <sound/pcm_params.h>
45 #include <sound/soc.h>
46 
47 #include "atmel-pcm.h"
48 
49 
50 /*--------------------------------------------------------------------------*\
51  * Hardware definition
52 \*--------------------------------------------------------------------------*/
53 /* TODO: These values were taken from the AT91 platform driver, check
54  * them against real values for AT32
55  */
56 static const struct snd_pcm_hardware atmel_pcm_hardware = {
57  .info = SNDRV_PCM_INFO_MMAP |
61  .formats = SNDRV_PCM_FMTBIT_S16_LE,
62  .period_bytes_min = 32,
63  .period_bytes_max = 8192,
64  .periods_min = 2,
65  .periods_max = 1024,
66  .buffer_bytes_max = 32 * 1024,
67 };
68 
69 
70 /*--------------------------------------------------------------------------*\
71  * Data types
72 \*--------------------------------------------------------------------------*/
75  dma_addr_t dma_buffer; /* physical address of dma buffer */
76  dma_addr_t dma_buffer_end; /* first address beyond DMA buffer */
77  size_t period_size;
78 
79  dma_addr_t period_ptr; /* physical address of next period */
80 
81  /* PDC register save */
86 };
87 
88 
89 /*--------------------------------------------------------------------------*\
90  * Helper functions
91 \*--------------------------------------------------------------------------*/
92 static int atmel_pcm_preallocate_dma_buffer(struct snd_pcm *pcm,
93  int stream)
94 {
95  struct snd_pcm_substream *substream = pcm->streams[stream].substream;
96  struct snd_dma_buffer *buf = &substream->dma_buffer;
97  size_t size = atmel_pcm_hardware.buffer_bytes_max;
98 
99  buf->dev.type = SNDRV_DMA_TYPE_DEV;
100  buf->dev.dev = pcm->card->dev;
101  buf->private_data = NULL;
102  buf->area = dma_alloc_coherent(pcm->card->dev, size,
103  &buf->addr, GFP_KERNEL);
104  pr_debug("atmel-pcm:"
105  "preallocate_dma_buffer: area=%p, addr=%p, size=%d\n",
106  (void *) buf->area,
107  (void *) buf->addr,
108  size);
109 
110  if (!buf->area)
111  return -ENOMEM;
112 
113  buf->bytes = size;
114  return 0;
115 }
116 /*--------------------------------------------------------------------------*\
117  * ISR
118 \*--------------------------------------------------------------------------*/
119 static void atmel_pcm_dma_irq(u32 ssc_sr,
120  struct snd_pcm_substream *substream)
121 {
122  struct atmel_runtime_data *prtd = substream->runtime->private_data;
123  struct atmel_pcm_dma_params *params = prtd->params;
124  static int count;
125 
126  count++;
127 
128  if (ssc_sr & params->mask->ssc_endbuf) {
129  pr_warning("atmel-pcm: buffer %s on %s"
130  " (SSC_SR=%#x, count=%d)\n",
131  substream->stream == SNDRV_PCM_STREAM_PLAYBACK
132  ? "underrun" : "overrun",
133  params->name, ssc_sr, count);
134 
135  /* re-start the PDC */
136  ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
137  params->mask->pdc_disable);
138  prtd->period_ptr += prtd->period_size;
139  if (prtd->period_ptr >= prtd->dma_buffer_end)
140  prtd->period_ptr = prtd->dma_buffer;
141 
142  ssc_writex(params->ssc->regs, params->pdc->xpr,
143  prtd->period_ptr);
144  ssc_writex(params->ssc->regs, params->pdc->xcr,
145  prtd->period_size / params->pdc_xfer_size);
146  ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
147  params->mask->pdc_enable);
148  }
149 
150  if (ssc_sr & params->mask->ssc_endx) {
151  /* Load the PDC next pointer and counter registers */
152  prtd->period_ptr += prtd->period_size;
153  if (prtd->period_ptr >= prtd->dma_buffer_end)
154  prtd->period_ptr = prtd->dma_buffer;
155 
156  ssc_writex(params->ssc->regs, params->pdc->xnpr,
157  prtd->period_ptr);
158  ssc_writex(params->ssc->regs, params->pdc->xncr,
159  prtd->period_size / params->pdc_xfer_size);
160  }
161 
162  snd_pcm_period_elapsed(substream);
163 }
164 
165 
166 /*--------------------------------------------------------------------------*\
167  * PCM operations
168 \*--------------------------------------------------------------------------*/
169 static int atmel_pcm_hw_params(struct snd_pcm_substream *substream,
170  struct snd_pcm_hw_params *params)
171 {
172  struct snd_pcm_runtime *runtime = substream->runtime;
173  struct atmel_runtime_data *prtd = runtime->private_data;
174  struct snd_soc_pcm_runtime *rtd = substream->private_data;
175 
176  /* this may get called several times by oss emulation
177  * with different params */
178 
179  snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer);
180  runtime->dma_bytes = params_buffer_bytes(params);
181 
182  prtd->params = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
183  prtd->params->dma_intr_handler = atmel_pcm_dma_irq;
184 
185  prtd->dma_buffer = runtime->dma_addr;
186  prtd->dma_buffer_end = runtime->dma_addr + runtime->dma_bytes;
187  prtd->period_size = params_period_bytes(params);
188 
189  pr_debug("atmel-pcm: "
190  "hw_params: DMA for %s initialized "
191  "(dma_bytes=%u, period_size=%u)\n",
192  prtd->params->name,
193  runtime->dma_bytes,
194  prtd->period_size);
195  return 0;
196 }
197 
198 static int atmel_pcm_hw_free(struct snd_pcm_substream *substream)
199 {
200  struct atmel_runtime_data *prtd = substream->runtime->private_data;
201  struct atmel_pcm_dma_params *params = prtd->params;
202 
203  if (params != NULL) {
204  ssc_writex(params->ssc->regs, SSC_PDC_PTCR,
205  params->mask->pdc_disable);
206  prtd->params->dma_intr_handler = NULL;
207  }
208 
209  return 0;
210 }
211 
212 static int atmel_pcm_prepare(struct snd_pcm_substream *substream)
213 {
214  struct atmel_runtime_data *prtd = substream->runtime->private_data;
215  struct atmel_pcm_dma_params *params = prtd->params;
216 
217  ssc_writex(params->ssc->regs, SSC_IDR,
218  params->mask->ssc_endx | params->mask->ssc_endbuf);
219  ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
220  params->mask->pdc_disable);
221  return 0;
222 }
223 
224 static int atmel_pcm_trigger(struct snd_pcm_substream *substream,
225  int cmd)
226 {
227  struct snd_pcm_runtime *rtd = substream->runtime;
228  struct atmel_runtime_data *prtd = rtd->private_data;
229  struct atmel_pcm_dma_params *params = prtd->params;
230  int ret = 0;
231 
232  pr_debug("atmel-pcm:buffer_size = %ld,"
233  "dma_area = %p, dma_bytes = %u\n",
234  rtd->buffer_size, rtd->dma_area, rtd->dma_bytes);
235 
236  switch (cmd) {
238  prtd->period_ptr = prtd->dma_buffer;
239 
240  ssc_writex(params->ssc->regs, params->pdc->xpr,
241  prtd->period_ptr);
242  ssc_writex(params->ssc->regs, params->pdc->xcr,
243  prtd->period_size / params->pdc_xfer_size);
244 
245  prtd->period_ptr += prtd->period_size;
246  ssc_writex(params->ssc->regs, params->pdc->xnpr,
247  prtd->period_ptr);
248  ssc_writex(params->ssc->regs, params->pdc->xncr,
249  prtd->period_size / params->pdc_xfer_size);
250 
251  pr_debug("atmel-pcm: trigger: "
252  "period_ptr=%lx, xpr=%u, "
253  "xcr=%u, xnpr=%u, xncr=%u\n",
254  (unsigned long)prtd->period_ptr,
255  ssc_readx(params->ssc->regs, params->pdc->xpr),
256  ssc_readx(params->ssc->regs, params->pdc->xcr),
257  ssc_readx(params->ssc->regs, params->pdc->xnpr),
258  ssc_readx(params->ssc->regs, params->pdc->xncr));
259 
260  ssc_writex(params->ssc->regs, SSC_IER,
261  params->mask->ssc_endx | params->mask->ssc_endbuf);
262  ssc_writex(params->ssc->regs, SSC_PDC_PTCR,
263  params->mask->pdc_enable);
264 
265  pr_debug("sr=%u imr=%u\n",
266  ssc_readx(params->ssc->regs, SSC_SR),
267  ssc_readx(params->ssc->regs, SSC_IER));
268  break; /* SNDRV_PCM_TRIGGER_START */
269 
273  ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
274  params->mask->pdc_disable);
275  break;
276 
279  ssc_writex(params->ssc->regs, ATMEL_PDC_PTCR,
280  params->mask->pdc_enable);
281  break;
282 
283  default:
284  ret = -EINVAL;
285  }
286 
287  return ret;
288 }
289 
290 static snd_pcm_uframes_t atmel_pcm_pointer(
291  struct snd_pcm_substream *substream)
292 {
293  struct snd_pcm_runtime *runtime = substream->runtime;
294  struct atmel_runtime_data *prtd = runtime->private_data;
295  struct atmel_pcm_dma_params *params = prtd->params;
296  dma_addr_t ptr;
298 
299  ptr = (dma_addr_t) ssc_readx(params->ssc->regs, params->pdc->xpr);
300  x = bytes_to_frames(runtime, ptr - prtd->dma_buffer);
301 
302  if (x == runtime->buffer_size)
303  x = 0;
304 
305  return x;
306 }
307 
308 static int atmel_pcm_open(struct snd_pcm_substream *substream)
309 {
310  struct snd_pcm_runtime *runtime = substream->runtime;
311  struct atmel_runtime_data *prtd;
312  int ret = 0;
313 
314  snd_soc_set_runtime_hwparams(substream, &atmel_pcm_hardware);
315 
316  /* ensure that buffer size is a multiple of period size */
317  ret = snd_pcm_hw_constraint_integer(runtime,
319  if (ret < 0)
320  goto out;
321 
322  prtd = kzalloc(sizeof(struct atmel_runtime_data), GFP_KERNEL);
323  if (prtd == NULL) {
324  ret = -ENOMEM;
325  goto out;
326  }
327  runtime->private_data = prtd;
328 
329  out:
330  return ret;
331 }
332 
333 static int atmel_pcm_close(struct snd_pcm_substream *substream)
334 {
335  struct atmel_runtime_data *prtd = substream->runtime->private_data;
336 
337  kfree(prtd);
338  return 0;
339 }
340 
341 static int atmel_pcm_mmap(struct snd_pcm_substream *substream,
342  struct vm_area_struct *vma)
343 {
344  return remap_pfn_range(vma, vma->vm_start,
345  substream->dma_buffer.addr >> PAGE_SHIFT,
346  vma->vm_end - vma->vm_start, vma->vm_page_prot);
347 }
348 
349 static struct snd_pcm_ops atmel_pcm_ops = {
350  .open = atmel_pcm_open,
351  .close = atmel_pcm_close,
352  .ioctl = snd_pcm_lib_ioctl,
353  .hw_params = atmel_pcm_hw_params,
354  .hw_free = atmel_pcm_hw_free,
355  .prepare = atmel_pcm_prepare,
356  .trigger = atmel_pcm_trigger,
357  .pointer = atmel_pcm_pointer,
358  .mmap = atmel_pcm_mmap,
359 };
360 
361 
362 /*--------------------------------------------------------------------------*\
363  * ASoC platform driver
364 \*--------------------------------------------------------------------------*/
365 static u64 atmel_pcm_dmamask = DMA_BIT_MASK(32);
366 
367 static int atmel_pcm_new(struct snd_soc_pcm_runtime *rtd)
368 {
369  struct snd_card *card = rtd->card->snd_card;
370  struct snd_pcm *pcm = rtd->pcm;
371  int ret = 0;
372 
373  if (!card->dev->dma_mask)
374  card->dev->dma_mask = &atmel_pcm_dmamask;
375  if (!card->dev->coherent_dma_mask)
376  card->dev->coherent_dma_mask = DMA_BIT_MASK(32);
377 
378  if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream) {
379  ret = atmel_pcm_preallocate_dma_buffer(pcm,
381  if (ret)
382  goto out;
383  }
384 
385  if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream) {
386  pr_debug("atmel-pcm:"
387  "Allocating PCM capture DMA buffer\n");
388  ret = atmel_pcm_preallocate_dma_buffer(pcm,
390  if (ret)
391  goto out;
392  }
393  out:
394  return ret;
395 }
396 
397 static void atmel_pcm_free_dma_buffers(struct snd_pcm *pcm)
398 {
399  struct snd_pcm_substream *substream;
400  struct snd_dma_buffer *buf;
401  int stream;
402 
403  for (stream = 0; stream < 2; stream++) {
404  substream = pcm->streams[stream].substream;
405  if (!substream)
406  continue;
407 
408  buf = &substream->dma_buffer;
409  if (!buf->area)
410  continue;
411  dma_free_coherent(pcm->card->dev, buf->bytes,
412  buf->area, buf->addr);
413  buf->area = NULL;
414  }
415 }
416 
417 #ifdef CONFIG_PM
418 static int atmel_pcm_suspend(struct snd_soc_dai *dai)
419 {
420  struct snd_pcm_runtime *runtime = dai->runtime;
421  struct atmel_runtime_data *prtd;
423 
424  if (!runtime)
425  return 0;
426 
427  prtd = runtime->private_data;
428  params = prtd->params;
429 
430  /* disable the PDC and save the PDC registers */
431 
432  ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_disable);
433 
434  prtd->pdc_xpr_save = ssc_readx(params->ssc->regs, params->pdc->xpr);
435  prtd->pdc_xcr_save = ssc_readx(params->ssc->regs, params->pdc->xcr);
436  prtd->pdc_xnpr_save = ssc_readx(params->ssc->regs, params->pdc->xnpr);
437  prtd->pdc_xncr_save = ssc_readx(params->ssc->regs, params->pdc->xncr);
438 
439  return 0;
440 }
441 
442 static int atmel_pcm_resume(struct snd_soc_dai *dai)
443 {
444  struct snd_pcm_runtime *runtime = dai->runtime;
445  struct atmel_runtime_data *prtd;
447 
448  if (!runtime)
449  return 0;
450 
451  prtd = runtime->private_data;
452  params = prtd->params;
453 
454  /* restore the PDC registers and enable the PDC */
455  ssc_writex(params->ssc->regs, params->pdc->xpr, prtd->pdc_xpr_save);
456  ssc_writex(params->ssc->regs, params->pdc->xcr, prtd->pdc_xcr_save);
457  ssc_writex(params->ssc->regs, params->pdc->xnpr, prtd->pdc_xnpr_save);
458  ssc_writex(params->ssc->regs, params->pdc->xncr, prtd->pdc_xncr_save);
459 
460  ssc_writel(params->ssc->regs, PDC_PTCR, params->mask->pdc_enable);
461  return 0;
462 }
463 #else
464 #define atmel_pcm_suspend NULL
465 #define atmel_pcm_resume NULL
466 #endif
467 
468 static struct snd_soc_platform_driver atmel_soc_platform = {
469  .ops = &atmel_pcm_ops,
470  .pcm_new = atmel_pcm_new,
471  .pcm_free = atmel_pcm_free_dma_buffers,
472  .suspend = atmel_pcm_suspend,
473  .resume = atmel_pcm_resume,
474 };
475 
476 static int __devinit atmel_soc_platform_probe(struct platform_device *pdev)
477 {
478  return snd_soc_register_platform(&pdev->dev, &atmel_soc_platform);
479 }
480 
481 static int __devexit atmel_soc_platform_remove(struct platform_device *pdev)
482 {
484  return 0;
485 }
486 
487 static struct platform_driver atmel_pcm_driver = {
488  .driver = {
489  .name = "atmel-pcm-audio",
490  .owner = THIS_MODULE,
491  },
492 
493  .probe = atmel_soc_platform_probe,
494  .remove = __devexit_p(atmel_soc_platform_remove),
495 };
496 
497 module_platform_driver(atmel_pcm_driver);
498 
499 MODULE_AUTHOR("Sedji Gaouaou <[email protected]>");
500 MODULE_DESCRIPTION("Atmel PCM module");
501 MODULE_LICENSE("GPL");