4 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License as published by the
8 * Free Software Foundation; either version 2 of the License, or (at your
9 * option) any later version.
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/device.h>
16 #include <linux/slab.h>
17 #include <linux/interrupt.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/mbus.h>
20 #include <sound/soc.h>
23 #define KIRKWOOD_RATES \
24 (SNDRV_PCM_RATE_44100 | \
25 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000)
26 #define KIRKWOOD_FORMATS \
27 (SNDRV_PCM_FMTBIT_S16_LE | \
28 SNDRV_PCM_FMTBIT_S24_LE | \
29 SNDRV_PCM_FMTBIT_S32_LE)
31 struct kirkwood_dma_priv
{
32 struct snd_pcm_substream
*play_stream
;
33 struct snd_pcm_substream
*rec_stream
;
34 struct kirkwood_dma_data
*data
;
37 static struct snd_pcm_hardware kirkwood_dma_snd_hw
= {
38 .info
= (SNDRV_PCM_INFO_INTERLEAVED
|
40 SNDRV_PCM_INFO_MMAP_VALID
|
41 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
42 SNDRV_PCM_INFO_PAUSE
),
43 .formats
= KIRKWOOD_FORMATS
,
44 .rates
= KIRKWOOD_RATES
,
49 .buffer_bytes_max
= KIRKWOOD_SND_MAX_PERIOD_BYTES
* KIRKWOOD_SND_MAX_PERIODS
,
50 .period_bytes_min
= KIRKWOOD_SND_MIN_PERIOD_BYTES
,
51 .period_bytes_max
= KIRKWOOD_SND_MAX_PERIOD_BYTES
,
52 .periods_min
= KIRKWOOD_SND_MIN_PERIODS
,
53 .periods_max
= KIRKWOOD_SND_MAX_PERIODS
,
57 static u64 kirkwood_dma_dmamask
= 0xFFFFFFFFUL
;
59 static irqreturn_t
kirkwood_dma_irq(int irq
, void *dev_id
)
61 struct kirkwood_dma_priv
*prdata
= dev_id
;
62 struct kirkwood_dma_data
*priv
= prdata
->data
;
63 unsigned long mask
, status
, cause
;
65 mask
= readl(priv
->io
+ KIRKWOOD_INT_MASK
);
66 status
= readl(priv
->io
+ KIRKWOOD_INT_CAUSE
) & mask
;
68 cause
= readl(priv
->io
+ KIRKWOOD_ERR_CAUSE
);
69 if (unlikely(cause
)) {
70 printk(KERN_WARNING
"%s: got err interrupt 0x%lx\n",
72 writel(cause
, priv
->io
+ KIRKWOOD_ERR_CAUSE
);
76 /* we've enabled only bytes interrupts ... */
77 if (status
& ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES
| \
78 KIRKWOOD_INT_CAUSE_REC_BYTES
)) {
79 printk(KERN_WARNING
"%s: unexpected interrupt %lx\n",
85 writel(status
, priv
->io
+ KIRKWOOD_INT_CAUSE
);
87 if (status
& KIRKWOOD_INT_CAUSE_PLAY_BYTES
)
88 snd_pcm_period_elapsed(prdata
->play_stream
);
90 if (status
& KIRKWOOD_INT_CAUSE_REC_BYTES
)
91 snd_pcm_period_elapsed(prdata
->rec_stream
);
96 static void kirkwood_dma_conf_mbus_windows(void __iomem
*base
, int win
,
98 struct mbus_dram_target_info
*dram
)
102 /* First disable and clear windows */
103 writel(0, base
+ KIRKWOOD_AUDIO_WIN_CTRL_REG(win
));
104 writel(0, base
+ KIRKWOOD_AUDIO_WIN_BASE_REG(win
));
106 /* try to find matching cs for current dma address */
107 for (i
= 0; i
< dram
->num_cs
; i
++) {
108 struct mbus_dram_window
*cs
= dram
->cs
+ i
;
109 if ((cs
->base
& 0xffff0000) < (dma
& 0xffff0000)) {
110 writel(cs
->base
& 0xffff0000,
111 base
+ KIRKWOOD_AUDIO_WIN_BASE_REG(win
));
112 writel(((cs
->size
- 1) & 0xffff0000) |
113 (cs
->mbus_attr
<< 8) |
114 (dram
->mbus_dram_target_id
<< 4) | 1,
115 base
+ KIRKWOOD_AUDIO_WIN_CTRL_REG(win
));
120 static int kirkwood_dma_open(struct snd_pcm_substream
*substream
)
123 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
124 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
125 struct snd_soc_platform
*platform
= soc_runtime
->platform
;
126 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
127 struct kirkwood_dma_data
*priv
;
128 struct kirkwood_dma_priv
*prdata
= snd_soc_platform_get_drvdata(platform
);
131 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
132 snd_soc_set_runtime_hwparams(substream
, &kirkwood_dma_snd_hw
);
134 /* Ensure that all constraints linked to dma burst are fullfilled */
135 err
= snd_pcm_hw_constraint_minmax(runtime
,
136 SNDRV_PCM_HW_PARAM_BUFFER_BYTES
,
138 KIRKWOOD_AUDIO_BUF_MAX
-1);
142 err
= snd_pcm_hw_constraint_step(runtime
, 0,
143 SNDRV_PCM_HW_PARAM_BUFFER_BYTES
,
148 err
= snd_pcm_hw_constraint_step(substream
->runtime
, 0,
149 SNDRV_PCM_HW_PARAM_PERIOD_BYTES
,
154 if (prdata
== NULL
) {
155 prdata
= kzalloc(sizeof(struct kirkwood_dma_priv
), GFP_KERNEL
);
161 err
= request_irq(priv
->irq
, kirkwood_dma_irq
, IRQF_SHARED
,
162 "kirkwood-i2s", prdata
);
168 snd_soc_platform_set_drvdata(platform
, prdata
);
171 * Enable Error interrupts. We're only ack'ing them but
172 * it's usefull for diagnostics
174 writel((unsigned long)-1, priv
->io
+ KIRKWOOD_ERR_MASK
);
177 addr
= virt_to_phys(substream
->dma_buffer
.area
);
178 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
179 prdata
->play_stream
= substream
;
180 kirkwood_dma_conf_mbus_windows(priv
->io
,
181 KIRKWOOD_PLAYBACK_WIN
, addr
, priv
->dram
);
183 prdata
->rec_stream
= substream
;
184 kirkwood_dma_conf_mbus_windows(priv
->io
,
185 KIRKWOOD_RECORD_WIN
, addr
, priv
->dram
);
191 static int kirkwood_dma_close(struct snd_pcm_substream
*substream
)
193 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
194 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
195 struct snd_soc_platform
*platform
= soc_runtime
->platform
;
196 struct kirkwood_dma_priv
*prdata
= snd_soc_platform_get_drvdata(platform
);
197 struct kirkwood_dma_data
*priv
;
199 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
201 if (!prdata
|| !priv
)
204 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
205 prdata
->play_stream
= NULL
;
207 prdata
->rec_stream
= NULL
;
209 if (!prdata
->play_stream
&& !prdata
->rec_stream
) {
210 writel(0, priv
->io
+ KIRKWOOD_ERR_MASK
);
211 free_irq(priv
->irq
, prdata
);
213 snd_soc_platform_set_drvdata(platform
, NULL
);
219 static int kirkwood_dma_hw_params(struct snd_pcm_substream
*substream
,
220 struct snd_pcm_hw_params
*params
)
222 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
224 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
225 runtime
->dma_bytes
= params_buffer_bytes(params
);
230 static int kirkwood_dma_hw_free(struct snd_pcm_substream
*substream
)
232 snd_pcm_set_runtime_buffer(substream
, NULL
);
236 static int kirkwood_dma_prepare(struct snd_pcm_substream
*substream
)
238 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
239 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
240 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
241 struct kirkwood_dma_data
*priv
;
242 unsigned long size
, count
;
244 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
246 /* compute buffer size in term of "words" as requested in specs */
247 size
= frames_to_bytes(runtime
, runtime
->buffer_size
);
249 count
= snd_pcm_lib_period_bytes(substream
);
251 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
252 writel(count
, priv
->io
+ KIRKWOOD_PLAY_BYTE_INT_COUNT
);
253 writel(runtime
->dma_addr
, priv
->io
+ KIRKWOOD_PLAY_BUF_ADDR
);
254 writel(size
, priv
->io
+ KIRKWOOD_PLAY_BUF_SIZE
);
256 writel(count
, priv
->io
+ KIRKWOOD_REC_BYTE_INT_COUNT
);
257 writel(runtime
->dma_addr
, priv
->io
+ KIRKWOOD_REC_BUF_ADDR
);
258 writel(size
, priv
->io
+ KIRKWOOD_REC_BUF_SIZE
);
265 static snd_pcm_uframes_t
kirkwood_dma_pointer(struct snd_pcm_substream
268 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
269 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
270 struct kirkwood_dma_data
*priv
;
271 snd_pcm_uframes_t count
;
273 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
275 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
276 count
= bytes_to_frames(substream
->runtime
,
277 readl(priv
->io
+ KIRKWOOD_PLAY_BYTE_COUNT
));
279 count
= bytes_to_frames(substream
->runtime
,
280 readl(priv
->io
+ KIRKWOOD_REC_BYTE_COUNT
));
285 struct snd_pcm_ops kirkwood_dma_ops
= {
286 .open
= kirkwood_dma_open
,
287 .close
= kirkwood_dma_close
,
288 .ioctl
= snd_pcm_lib_ioctl
,
289 .hw_params
= kirkwood_dma_hw_params
,
290 .hw_free
= kirkwood_dma_hw_free
,
291 .prepare
= kirkwood_dma_prepare
,
292 .pointer
= kirkwood_dma_pointer
,
295 static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm
*pcm
,
298 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
299 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
300 size_t size
= kirkwood_dma_snd_hw
.buffer_bytes_max
;
302 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
303 buf
->dev
.dev
= pcm
->card
->dev
;
304 buf
->area
= dma_alloc_coherent(pcm
->card
->dev
, size
,
305 &buf
->addr
, GFP_KERNEL
);
309 buf
->private_data
= NULL
;
314 static int kirkwood_dma_new(struct snd_card
*card
,
315 struct snd_soc_dai
*dai
, struct snd_pcm
*pcm
)
319 if (!card
->dev
->dma_mask
)
320 card
->dev
->dma_mask
= &kirkwood_dma_dmamask
;
321 if (!card
->dev
->coherent_dma_mask
)
322 card
->dev
->coherent_dma_mask
= 0xffffffff;
324 if (dai
->driver
->playback
.channels_min
) {
325 ret
= kirkwood_dma_preallocate_dma_buffer(pcm
,
326 SNDRV_PCM_STREAM_PLAYBACK
);
331 if (dai
->driver
->capture
.channels_min
) {
332 ret
= kirkwood_dma_preallocate_dma_buffer(pcm
,
333 SNDRV_PCM_STREAM_CAPTURE
);
341 static void kirkwood_dma_free_dma_buffers(struct snd_pcm
*pcm
)
343 struct snd_pcm_substream
*substream
;
344 struct snd_dma_buffer
*buf
;
347 for (stream
= 0; stream
< 2; stream
++) {
348 substream
= pcm
->streams
[stream
].substream
;
351 buf
= &substream
->dma_buffer
;
355 dma_free_coherent(pcm
->card
->dev
, buf
->bytes
,
356 buf
->area
, buf
->addr
);
361 static struct snd_soc_platform_driver kirkwood_soc_platform
= {
362 .ops
= &kirkwood_dma_ops
,
363 .pcm_new
= kirkwood_dma_new
,
364 .pcm_free
= kirkwood_dma_free_dma_buffers
,
367 static int __devinit
kirkwood_soc_platform_probe(struct platform_device
*pdev
)
369 return snd_soc_register_platform(&pdev
->dev
, &kirkwood_soc_platform
);
372 static int __devexit
kirkwood_soc_platform_remove(struct platform_device
*pdev
)
374 snd_soc_unregister_platform(&pdev
->dev
);
378 static struct platform_driver kirkwood_pcm_driver
= {
380 .name
= "kirkwood-pcm-audio",
381 .owner
= THIS_MODULE
,
384 .probe
= kirkwood_soc_platform_probe
,
385 .remove
= __devexit_p(kirkwood_soc_platform_remove
),
388 static int __init
kirkwood_pcm_init(void)
390 return platform_driver_register(&kirkwood_pcm_driver
);
392 module_init(kirkwood_pcm_init
);
394 static void __exit
kirkwood_pcm_exit(void)
396 platform_driver_unregister(&kirkwood_pcm_driver
);
398 module_exit(kirkwood_pcm_exit
);
400 MODULE_AUTHOR("Arnaud Patard <apatard@mandriva.com>");
401 MODULE_DESCRIPTION("Marvell Kirkwood Audio DMA module");
402 MODULE_LICENSE("GPL");