2 * Driver for the Atmel on-chip Audio Bitstream DAC (ABDAC)
4 * Copyright (C) 2006-2009 Atmel Corporation
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 as published by
8 * the Free Software Foundation.
10 #include <linux/clk.h>
11 #include <linux/bitmap.h>
12 #include <linux/dw_dmac.h>
13 #include <linux/dmaengine.h>
14 #include <linux/dma-mapping.h>
15 #include <linux/init.h>
16 #include <linux/interrupt.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
21 #include <sound/core.h>
22 #include <sound/initval.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/atmel-abdac.h>
27 /* DAC register offsets */
28 #define DAC_DATA 0x0000
29 #define DAC_CTRL 0x0008
30 #define DAC_INT_MASK 0x000c
31 #define DAC_INT_EN 0x0010
32 #define DAC_INT_DIS 0x0014
33 #define DAC_INT_CLR 0x0018
34 #define DAC_INT_STATUS 0x001c
36 /* Bitfields in CTRL */
37 #define DAC_SWAP_OFFSET 30
38 #define DAC_SWAP_SIZE 1
39 #define DAC_EN_OFFSET 31
42 /* Bitfields in INT_MASK/INT_EN/INT_DIS/INT_STATUS/INT_CLR */
43 #define DAC_UNDERRUN_OFFSET 28
44 #define DAC_UNDERRUN_SIZE 1
45 #define DAC_TX_READY_OFFSET 29
46 #define DAC_TX_READY_SIZE 1
48 /* Bit manipulation macros */
49 #define DAC_BIT(name) \
50 (1 << DAC_##name##_OFFSET)
51 #define DAC_BF(name, value) \
52 (((value) & ((1 << DAC_##name##_SIZE) - 1)) \
53 << DAC_##name##_OFFSET)
54 #define DAC_BFEXT(name, value) \
55 (((value) >> DAC_##name##_OFFSET) \
56 & ((1 << DAC_##name##_SIZE) - 1))
57 #define DAC_BFINS(name, value, old) \
58 (((old) & ~(((1 << DAC_##name##_SIZE) - 1) \
59 << DAC_##name##_OFFSET)) \
60 | DAC_BF(name, value))
62 /* Register access macros */
63 #define dac_readl(port, reg) \
64 __raw_readl((port)->regs + DAC_##reg)
65 #define dac_writel(port, reg, value) \
66 __raw_writel((value), (port)->regs + DAC_##reg)
69 * ABDAC supports a maximum of 6 different rates from a generic clock. The
70 * generic clock has a power of two divider, which gives 6 steps from 192 kHz
73 #define MAX_NUM_RATES 6
74 /* ALSA seems to use rates between 192000 Hz and 5112 Hz. */
75 #define RATE_MAX 192000
82 struct atmel_abdac_dma
{
83 struct dma_chan
*chan
;
84 struct dw_cyclic_desc
*cdesc
;
89 struct clk
*sample_clk
;
90 struct platform_device
*pdev
;
91 struct atmel_abdac_dma dma
;
93 struct snd_pcm_hw_constraint_list constraints_rates
;
94 struct snd_pcm_substream
*substream
;
95 struct snd_card
*card
;
100 unsigned int rates
[MAX_NUM_RATES
];
101 unsigned int rates_num
;
105 #define get_dac(card) ((struct atmel_abdac *)(card)->private_data)
107 /* This function is called by the DMA driver. */
108 static void atmel_abdac_dma_period_done(void *arg
)
110 struct atmel_abdac
*dac
= arg
;
111 snd_pcm_period_elapsed(dac
->substream
);
114 static int atmel_abdac_prepare_dma(struct atmel_abdac
*dac
,
115 struct snd_pcm_substream
*substream
,
116 enum dma_data_direction direction
)
118 struct dma_chan
*chan
= dac
->dma
.chan
;
119 struct dw_cyclic_desc
*cdesc
;
120 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
121 unsigned long buffer_len
, period_len
;
124 * We don't do DMA on "complex" transfers, i.e. with
125 * non-halfword-aligned buffers or lengths.
127 if (runtime
->dma_addr
& 1 || runtime
->buffer_size
& 1) {
128 dev_dbg(&dac
->pdev
->dev
, "too complex transfer\n");
132 buffer_len
= frames_to_bytes(runtime
, runtime
->buffer_size
);
133 period_len
= frames_to_bytes(runtime
, runtime
->period_size
);
135 cdesc
= dw_dma_cyclic_prep(chan
, runtime
->dma_addr
, buffer_len
,
136 period_len
, DMA_TO_DEVICE
);
138 dev_dbg(&dac
->pdev
->dev
, "could not prepare cyclic DMA\n");
139 return PTR_ERR(cdesc
);
142 cdesc
->period_callback
= atmel_abdac_dma_period_done
;
143 cdesc
->period_callback_param
= dac
;
145 dac
->dma
.cdesc
= cdesc
;
147 set_bit(DMA_READY
, &dac
->flags
);
152 static struct snd_pcm_hardware atmel_abdac_hw
= {
153 .info
= (SNDRV_PCM_INFO_MMAP
154 | SNDRV_PCM_INFO_MMAP_VALID
155 | SNDRV_PCM_INFO_INTERLEAVED
156 | SNDRV_PCM_INFO_BLOCK_TRANSFER
157 | SNDRV_PCM_INFO_RESUME
158 | SNDRV_PCM_INFO_PAUSE
),
159 .formats
= (SNDRV_PCM_FMTBIT_S16_BE
),
160 .rates
= (SNDRV_PCM_RATE_KNOT
),
161 .rate_min
= RATE_MIN
,
162 .rate_max
= RATE_MAX
,
165 .buffer_bytes_max
= 64 * 4096,
166 .period_bytes_min
= 4096,
167 .period_bytes_max
= 4096,
172 static int atmel_abdac_open(struct snd_pcm_substream
*substream
)
174 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
176 dac
->substream
= substream
;
177 atmel_abdac_hw
.rate_max
= dac
->rates
[dac
->rates_num
- 1];
178 atmel_abdac_hw
.rate_min
= dac
->rates
[0];
179 substream
->runtime
->hw
= atmel_abdac_hw
;
181 return snd_pcm_hw_constraint_list(substream
->runtime
, 0,
182 SNDRV_PCM_HW_PARAM_RATE
, &dac
->constraints_rates
);
185 static int atmel_abdac_close(struct snd_pcm_substream
*substream
)
187 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
188 dac
->substream
= NULL
;
192 static int atmel_abdac_hw_params(struct snd_pcm_substream
*substream
,
193 struct snd_pcm_hw_params
*hw_params
)
195 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
198 retval
= snd_pcm_lib_malloc_pages(substream
,
199 params_buffer_bytes(hw_params
));
202 /* snd_pcm_lib_malloc_pages returns 1 if buffer is changed. */
204 if (test_and_clear_bit(DMA_READY
, &dac
->flags
))
205 dw_dma_cyclic_free(dac
->dma
.chan
);
210 static int atmel_abdac_hw_free(struct snd_pcm_substream
*substream
)
212 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
213 if (test_and_clear_bit(DMA_READY
, &dac
->flags
))
214 dw_dma_cyclic_free(dac
->dma
.chan
);
215 return snd_pcm_lib_free_pages(substream
);
218 static int atmel_abdac_prepare(struct snd_pcm_substream
*substream
)
220 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
223 retval
= clk_set_rate(dac
->sample_clk
, 256 * substream
->runtime
->rate
);
227 if (!test_bit(DMA_READY
, &dac
->flags
))
228 retval
= atmel_abdac_prepare_dma(dac
, substream
, DMA_TO_DEVICE
);
233 static int atmel_abdac_trigger(struct snd_pcm_substream
*substream
, int cmd
)
235 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
239 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
: /* fall through */
240 case SNDRV_PCM_TRIGGER_RESUME
: /* fall through */
241 case SNDRV_PCM_TRIGGER_START
:
242 clk_enable(dac
->sample_clk
);
243 retval
= dw_dma_cyclic_start(dac
->dma
.chan
);
246 dac_writel(dac
, CTRL
, DAC_BIT(EN
));
248 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
: /* fall through */
249 case SNDRV_PCM_TRIGGER_SUSPEND
: /* fall through */
250 case SNDRV_PCM_TRIGGER_STOP
:
251 dw_dma_cyclic_stop(dac
->dma
.chan
);
252 dac_writel(dac
, DATA
, 0);
253 dac_writel(dac
, CTRL
, 0);
254 clk_disable(dac
->sample_clk
);
264 static snd_pcm_uframes_t
265 atmel_abdac_pointer(struct snd_pcm_substream
*substream
)
267 struct atmel_abdac
*dac
= snd_pcm_substream_chip(substream
);
268 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
269 snd_pcm_uframes_t frames
;
272 bytes
= dw_dma_get_src_addr(dac
->dma
.chan
);
273 bytes
-= runtime
->dma_addr
;
275 frames
= bytes_to_frames(runtime
, bytes
);
276 if (frames
>= runtime
->buffer_size
)
277 frames
-= runtime
->buffer_size
;
282 static irqreturn_t
abdac_interrupt(int irq
, void *dev_id
)
284 struct atmel_abdac
*dac
= dev_id
;
287 status
= dac_readl(dac
, INT_STATUS
);
288 if (status
& DAC_BIT(UNDERRUN
)) {
289 dev_err(&dac
->pdev
->dev
, "underrun detected\n");
290 dac_writel(dac
, INT_CLR
, DAC_BIT(UNDERRUN
));
292 dev_err(&dac
->pdev
->dev
, "spurious interrupt (status=0x%x)\n",
294 dac_writel(dac
, INT_CLR
, status
);
300 static struct snd_pcm_ops atmel_abdac_ops
= {
301 .open
= atmel_abdac_open
,
302 .close
= atmel_abdac_close
,
303 .ioctl
= snd_pcm_lib_ioctl
,
304 .hw_params
= atmel_abdac_hw_params
,
305 .hw_free
= atmel_abdac_hw_free
,
306 .prepare
= atmel_abdac_prepare
,
307 .trigger
= atmel_abdac_trigger
,
308 .pointer
= atmel_abdac_pointer
,
311 static int __devinit
atmel_abdac_pcm_new(struct atmel_abdac
*dac
)
313 struct snd_pcm_hardware hw
= atmel_abdac_hw
;
317 retval
= snd_pcm_new(dac
->card
, dac
->card
->shortname
,
318 dac
->pdev
->id
, 1, 0, &pcm
);
322 strcpy(pcm
->name
, dac
->card
->shortname
);
323 pcm
->private_data
= dac
;
327 snd_pcm_set_ops(pcm
, SNDRV_PCM_STREAM_PLAYBACK
, &atmel_abdac_ops
);
329 retval
= snd_pcm_lib_preallocate_pages_for_all(pcm
, SNDRV_DMA_TYPE_DEV
,
330 &dac
->pdev
->dev
, hw
.periods_min
* hw
.period_bytes_min
,
331 hw
.buffer_bytes_max
);
336 static bool filter(struct dma_chan
*chan
, void *slave
)
338 struct dw_dma_slave
*dws
= slave
;
340 if (dws
->dma_dev
== chan
->device
->dev
) {
347 static int set_sample_rates(struct atmel_abdac
*dac
)
349 long new_rate
= RATE_MAX
;
350 int retval
= -EINVAL
;
353 /* we start at 192 kHz and work our way down to 5112 Hz */
354 while (new_rate
>= RATE_MIN
&& index
< (MAX_NUM_RATES
+ 1)) {
355 new_rate
= clk_round_rate(dac
->sample_clk
, 256 * new_rate
);
358 /* make sure we are below the ABDAC clock */
359 if (new_rate
<= clk_get_rate(dac
->pclk
)) {
360 dac
->rates
[index
] = new_rate
/ 256;
363 /* divide by 256 and then by two to get next rate */
370 /* reverse array, smallest go first */
371 for (i
= 0; i
< (index
/ 2); i
++) {
372 unsigned int tmp
= dac
->rates
[index
- 1 - i
];
373 dac
->rates
[index
- 1 - i
] = dac
->rates
[i
];
377 dac
->constraints_rates
.count
= index
;
378 dac
->constraints_rates
.list
= dac
->rates
;
379 dac
->constraints_rates
.mask
= 0;
380 dac
->rates_num
= index
;
388 static int __devinit
atmel_abdac_probe(struct platform_device
*pdev
)
390 struct snd_card
*card
;
391 struct atmel_abdac
*dac
;
392 struct resource
*regs
;
393 struct atmel_abdac_pdata
*pdata
;
395 struct clk
*sample_clk
;
399 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
401 dev_dbg(&pdev
->dev
, "no memory resource\n");
405 irq
= platform_get_irq(pdev
, 0);
407 dev_dbg(&pdev
->dev
, "could not get IRQ number\n");
411 pdata
= pdev
->dev
.platform_data
;
413 dev_dbg(&pdev
->dev
, "no platform data\n");
417 pclk
= clk_get(&pdev
->dev
, "pclk");
419 dev_dbg(&pdev
->dev
, "no peripheral clock\n");
420 return PTR_ERR(pclk
);
422 sample_clk
= clk_get(&pdev
->dev
, "sample_clk");
423 if (IS_ERR(sample_clk
)) {
424 dev_dbg(&pdev
->dev
, "no sample clock\n");
425 retval
= PTR_ERR(pclk
);
430 retval
= snd_card_create(SNDRV_DEFAULT_IDX1
, SNDRV_DEFAULT_STR1
,
431 THIS_MODULE
, sizeof(struct atmel_abdac
), &card
);
433 dev_dbg(&pdev
->dev
, "could not create sound card device\n");
434 goto out_put_sample_clk
;
442 dac
->sample_clk
= sample_clk
;
445 retval
= set_sample_rates(dac
);
447 dev_dbg(&pdev
->dev
, "could not set supported rates\n");
451 dac
->regs
= ioremap(regs
->start
, regs
->end
- regs
->start
+ 1);
453 dev_dbg(&pdev
->dev
, "could not remap register memory\n");
457 /* make sure the DAC is silent and disabled */
458 dac_writel(dac
, DATA
, 0);
459 dac_writel(dac
, CTRL
, 0);
461 retval
= request_irq(irq
, abdac_interrupt
, 0, "abdac", dac
);
463 dev_dbg(&pdev
->dev
, "could not request irq\n");
467 snd_card_set_dev(card
, &pdev
->dev
);
469 if (pdata
->dws
.dma_dev
) {
470 struct dw_dma_slave
*dws
= &pdata
->dws
;
473 dws
->tx_reg
= regs
->start
+ DAC_DATA
;
476 dma_cap_set(DMA_SLAVE
, mask
);
478 dac
->dma
.chan
= dma_request_channel(mask
, filter
, dws
);
480 if (!pdata
->dws
.dma_dev
|| !dac
->dma
.chan
) {
481 dev_dbg(&pdev
->dev
, "DMA not available\n");
483 goto out_unset_card_dev
;
486 strcpy(card
->driver
, "Atmel ABDAC");
487 strcpy(card
->shortname
, "Atmel ABDAC");
488 sprintf(card
->longname
, "Atmel Audio Bitstream DAC");
490 retval
= atmel_abdac_pcm_new(dac
);
492 dev_dbg(&pdev
->dev
, "could not register ABDAC pcm device\n");
493 goto out_release_dma
;
496 retval
= snd_card_register(card
);
498 dev_dbg(&pdev
->dev
, "could not register sound card\n");
499 goto out_release_dma
;
502 platform_set_drvdata(pdev
, card
);
504 dev_info(&pdev
->dev
, "Atmel ABDAC at 0x%p using %s\n",
505 dac
->regs
, dev_name(&dac
->dma
.chan
->dev
->device
));
510 dma_release_channel(dac
->dma
.chan
);
511 dac
->dma
.chan
= NULL
;
513 snd_card_set_dev(card
, NULL
);
528 static int atmel_abdac_suspend(struct platform_device
*pdev
, pm_message_t msg
)
530 struct snd_card
*card
= platform_get_drvdata(pdev
);
531 struct atmel_abdac
*dac
= card
->private_data
;
533 dw_dma_cyclic_stop(dac
->dma
.chan
);
534 clk_disable(dac
->sample_clk
);
535 clk_disable(dac
->pclk
);
540 static int atmel_abdac_resume(struct platform_device
*pdev
)
542 struct snd_card
*card
= platform_get_drvdata(pdev
);
543 struct atmel_abdac
*dac
= card
->private_data
;
545 clk_enable(dac
->pclk
);
546 clk_enable(dac
->sample_clk
);
547 if (test_bit(DMA_READY
, &dac
->flags
))
548 dw_dma_cyclic_start(dac
->dma
.chan
);
553 #define atmel_abdac_suspend NULL
554 #define atmel_abdac_resume NULL
557 static int __devexit
atmel_abdac_remove(struct platform_device
*pdev
)
559 struct snd_card
*card
= platform_get_drvdata(pdev
);
560 struct atmel_abdac
*dac
= get_dac(card
);
562 clk_put(dac
->sample_clk
);
563 clk_disable(dac
->pclk
);
566 dma_release_channel(dac
->dma
.chan
);
567 dac
->dma
.chan
= NULL
;
568 snd_card_set_dev(card
, NULL
);
570 free_irq(dac
->irq
, dac
);
573 platform_set_drvdata(pdev
, NULL
);
578 static struct platform_driver atmel_abdac_driver
= {
579 .remove
= __devexit_p(atmel_abdac_remove
),
581 .name
= "atmel_abdac",
583 .suspend
= atmel_abdac_suspend
,
584 .resume
= atmel_abdac_resume
,
587 static int __init
atmel_abdac_init(void)
589 return platform_driver_probe(&atmel_abdac_driver
,
592 module_init(atmel_abdac_init
);
594 static void __exit
atmel_abdac_exit(void)
596 platform_driver_unregister(&atmel_abdac_driver
);
598 module_exit(atmel_abdac_exit
);
600 MODULE_LICENSE("GPL");
601 MODULE_DESCRIPTION("Driver for Atmel Audio Bitstream DAC (ABDAC)");
602 MODULE_AUTHOR("Hans-Christian Egtvedt <hans-christian.egtvedt@atmel.com>");