4 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
5 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/device.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/dma-mapping.h>
20 #include <linux/mbus.h>
21 #include <sound/soc.h>
24 #define KIRKWOOD_RATES \
25 (SNDRV_PCM_RATE_8000_192000 | \
26 SNDRV_PCM_RATE_CONTINUOUS | \
29 #define KIRKWOOD_FORMATS \
30 (SNDRV_PCM_FMTBIT_S16_LE | \
31 SNDRV_PCM_FMTBIT_S24_LE | \
32 SNDRV_PCM_FMTBIT_S32_LE)
34 struct kirkwood_dma_priv
{
35 struct snd_pcm_substream
*play_stream
;
36 struct snd_pcm_substream
*rec_stream
;
37 struct kirkwood_dma_data
*data
;
40 static struct snd_pcm_hardware kirkwood_dma_snd_hw
= {
41 .info
= (SNDRV_PCM_INFO_INTERLEAVED
|
43 SNDRV_PCM_INFO_MMAP_VALID
|
44 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
45 SNDRV_PCM_INFO_PAUSE
),
46 .formats
= KIRKWOOD_FORMATS
,
47 .rates
= KIRKWOOD_RATES
,
52 .buffer_bytes_max
= KIRKWOOD_SND_MAX_PERIOD_BYTES
* KIRKWOOD_SND_MAX_PERIODS
,
53 .period_bytes_min
= KIRKWOOD_SND_MIN_PERIOD_BYTES
,
54 .period_bytes_max
= KIRKWOOD_SND_MAX_PERIOD_BYTES
,
55 .periods_min
= KIRKWOOD_SND_MIN_PERIODS
,
56 .periods_max
= KIRKWOOD_SND_MAX_PERIODS
,
60 static u64 kirkwood_dma_dmamask
= DMA_BIT_MASK(32);
62 static irqreturn_t
kirkwood_dma_irq(int irq
, void *dev_id
)
64 struct kirkwood_dma_priv
*prdata
= dev_id
;
65 struct kirkwood_dma_data
*priv
= prdata
->data
;
66 unsigned long mask
, status
, cause
;
68 mask
= readl(priv
->io
+ KIRKWOOD_INT_MASK
);
69 status
= readl(priv
->io
+ KIRKWOOD_INT_CAUSE
) & mask
;
71 cause
= readl(priv
->io
+ KIRKWOOD_ERR_CAUSE
);
72 if (unlikely(cause
)) {
73 printk(KERN_WARNING
"%s: got err interrupt 0x%lx\n",
75 writel(cause
, priv
->io
+ KIRKWOOD_ERR_CAUSE
);
78 /* we've enabled only bytes interrupts ... */
79 if (status
& ~(KIRKWOOD_INT_CAUSE_PLAY_BYTES
| \
80 KIRKWOOD_INT_CAUSE_REC_BYTES
)) {
81 printk(KERN_WARNING
"%s: unexpected interrupt %lx\n",
87 writel(status
, priv
->io
+ KIRKWOOD_INT_CAUSE
);
89 if (status
& KIRKWOOD_INT_CAUSE_PLAY_BYTES
)
90 snd_pcm_period_elapsed(prdata
->play_stream
);
92 if (status
& KIRKWOOD_INT_CAUSE_REC_BYTES
)
93 snd_pcm_period_elapsed(prdata
->rec_stream
);
99 kirkwood_dma_conf_mbus_windows(void __iomem
*base
, int win
,
101 const struct mbus_dram_target_info
*dram
)
105 /* First disable and clear windows */
106 writel(0, base
+ KIRKWOOD_AUDIO_WIN_CTRL_REG(win
));
107 writel(0, base
+ KIRKWOOD_AUDIO_WIN_BASE_REG(win
));
109 /* try to find matching cs for current dma address */
110 for (i
= 0; i
< dram
->num_cs
; i
++) {
111 const struct mbus_dram_window
*cs
= dram
->cs
+ i
;
112 if ((cs
->base
& 0xffff0000) < (dma
& 0xffff0000)) {
113 writel(cs
->base
& 0xffff0000,
114 base
+ KIRKWOOD_AUDIO_WIN_BASE_REG(win
));
115 writel(((cs
->size
- 1) & 0xffff0000) |
116 (cs
->mbus_attr
<< 8) |
117 (dram
->mbus_dram_target_id
<< 4) | 1,
118 base
+ KIRKWOOD_AUDIO_WIN_CTRL_REG(win
));
123 static int kirkwood_dma_open(struct snd_pcm_substream
*substream
)
126 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
127 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
128 struct snd_soc_platform
*platform
= soc_runtime
->platform
;
129 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
130 struct kirkwood_dma_data
*priv
;
131 struct kirkwood_dma_priv
*prdata
= snd_soc_platform_get_drvdata(platform
);
132 const struct mbus_dram_target_info
*dram
;
135 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
136 snd_soc_set_runtime_hwparams(substream
, &kirkwood_dma_snd_hw
);
138 /* Ensure that all constraints linked to dma burst are fulfilled */
139 err
= snd_pcm_hw_constraint_minmax(runtime
,
140 SNDRV_PCM_HW_PARAM_BUFFER_BYTES
,
142 KIRKWOOD_AUDIO_BUF_MAX
-1);
146 err
= snd_pcm_hw_constraint_step(runtime
, 0,
147 SNDRV_PCM_HW_PARAM_BUFFER_BYTES
,
152 err
= snd_pcm_hw_constraint_step(substream
->runtime
, 0,
153 SNDRV_PCM_HW_PARAM_PERIOD_BYTES
,
158 if (prdata
== NULL
) {
159 prdata
= kzalloc(sizeof(struct kirkwood_dma_priv
), GFP_KERNEL
);
165 err
= request_irq(priv
->irq
, kirkwood_dma_irq
, IRQF_SHARED
,
166 "kirkwood-i2s", prdata
);
172 snd_soc_platform_set_drvdata(platform
, prdata
);
175 * Enable Error interrupts. We're only ack'ing them but
176 * it's useful for diagnostics
178 writel((unsigned long)-1, priv
->io
+ KIRKWOOD_ERR_MASK
);
181 dram
= mv_mbus_dram_info();
182 addr
= substream
->dma_buffer
.addr
;
183 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
184 prdata
->play_stream
= substream
;
185 kirkwood_dma_conf_mbus_windows(priv
->io
,
186 KIRKWOOD_PLAYBACK_WIN
, addr
, dram
);
188 prdata
->rec_stream
= substream
;
189 kirkwood_dma_conf_mbus_windows(priv
->io
,
190 KIRKWOOD_RECORD_WIN
, addr
, dram
);
196 static int kirkwood_dma_close(struct snd_pcm_substream
*substream
)
198 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
199 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
200 struct snd_soc_platform
*platform
= soc_runtime
->platform
;
201 struct kirkwood_dma_priv
*prdata
= snd_soc_platform_get_drvdata(platform
);
202 struct kirkwood_dma_data
*priv
;
204 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
206 if (!prdata
|| !priv
)
209 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
210 prdata
->play_stream
= NULL
;
212 prdata
->rec_stream
= NULL
;
214 if (!prdata
->play_stream
&& !prdata
->rec_stream
) {
215 writel(0, priv
->io
+ KIRKWOOD_ERR_MASK
);
216 free_irq(priv
->irq
, prdata
);
218 snd_soc_platform_set_drvdata(platform
, NULL
);
224 static int kirkwood_dma_hw_params(struct snd_pcm_substream
*substream
,
225 struct snd_pcm_hw_params
*params
)
227 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
229 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
230 runtime
->dma_bytes
= params_buffer_bytes(params
);
235 static int kirkwood_dma_hw_free(struct snd_pcm_substream
*substream
)
237 snd_pcm_set_runtime_buffer(substream
, NULL
);
241 static int kirkwood_dma_prepare(struct snd_pcm_substream
*substream
)
243 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
244 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
245 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
246 struct kirkwood_dma_data
*priv
;
247 unsigned long size
, count
;
249 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
251 /* compute buffer size in term of "words" as requested in specs */
252 size
= frames_to_bytes(runtime
, runtime
->buffer_size
);
254 count
= snd_pcm_lib_period_bytes(substream
);
256 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
257 writel(count
, priv
->io
+ KIRKWOOD_PLAY_BYTE_INT_COUNT
);
258 writel(runtime
->dma_addr
, priv
->io
+ KIRKWOOD_PLAY_BUF_ADDR
);
259 writel(size
, priv
->io
+ KIRKWOOD_PLAY_BUF_SIZE
);
261 writel(count
, priv
->io
+ KIRKWOOD_REC_BYTE_INT_COUNT
);
262 writel(runtime
->dma_addr
, priv
->io
+ KIRKWOOD_REC_BUF_ADDR
);
263 writel(size
, priv
->io
+ KIRKWOOD_REC_BUF_SIZE
);
270 static snd_pcm_uframes_t
kirkwood_dma_pointer(struct snd_pcm_substream
273 struct snd_soc_pcm_runtime
*soc_runtime
= substream
->private_data
;
274 struct snd_soc_dai
*cpu_dai
= soc_runtime
->cpu_dai
;
275 struct kirkwood_dma_data
*priv
;
276 snd_pcm_uframes_t count
;
278 priv
= snd_soc_dai_get_dma_data(cpu_dai
, substream
);
280 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
281 count
= bytes_to_frames(substream
->runtime
,
282 readl(priv
->io
+ KIRKWOOD_PLAY_BYTE_COUNT
));
284 count
= bytes_to_frames(substream
->runtime
,
285 readl(priv
->io
+ KIRKWOOD_REC_BYTE_COUNT
));
290 struct snd_pcm_ops kirkwood_dma_ops
= {
291 .open
= kirkwood_dma_open
,
292 .close
= kirkwood_dma_close
,
293 .ioctl
= snd_pcm_lib_ioctl
,
294 .hw_params
= kirkwood_dma_hw_params
,
295 .hw_free
= kirkwood_dma_hw_free
,
296 .prepare
= kirkwood_dma_prepare
,
297 .pointer
= kirkwood_dma_pointer
,
300 static int kirkwood_dma_preallocate_dma_buffer(struct snd_pcm
*pcm
,
303 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
304 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
305 size_t size
= kirkwood_dma_snd_hw
.buffer_bytes_max
;
307 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
308 buf
->dev
.dev
= pcm
->card
->dev
;
309 buf
->area
= dma_alloc_coherent(pcm
->card
->dev
, size
,
310 &buf
->addr
, GFP_KERNEL
);
314 buf
->private_data
= NULL
;
319 static int kirkwood_dma_new(struct snd_soc_pcm_runtime
*rtd
)
321 struct snd_card
*card
= rtd
->card
->snd_card
;
322 struct snd_pcm
*pcm
= rtd
->pcm
;
325 if (!card
->dev
->dma_mask
)
326 card
->dev
->dma_mask
= &kirkwood_dma_dmamask
;
327 if (!card
->dev
->coherent_dma_mask
)
328 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
330 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
) {
331 ret
= kirkwood_dma_preallocate_dma_buffer(pcm
,
332 SNDRV_PCM_STREAM_PLAYBACK
);
337 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
) {
338 ret
= kirkwood_dma_preallocate_dma_buffer(pcm
,
339 SNDRV_PCM_STREAM_CAPTURE
);
347 static void kirkwood_dma_free_dma_buffers(struct snd_pcm
*pcm
)
349 struct snd_pcm_substream
*substream
;
350 struct snd_dma_buffer
*buf
;
353 for (stream
= 0; stream
< 2; stream
++) {
354 substream
= pcm
->streams
[stream
].substream
;
357 buf
= &substream
->dma_buffer
;
361 dma_free_coherent(pcm
->card
->dev
, buf
->bytes
,
362 buf
->area
, buf
->addr
);
367 static struct snd_soc_platform_driver kirkwood_soc_platform
= {
368 .ops
= &kirkwood_dma_ops
,
369 .pcm_new
= kirkwood_dma_new
,
370 .pcm_free
= kirkwood_dma_free_dma_buffers
,
373 static int __devinit
kirkwood_soc_platform_probe(struct platform_device
*pdev
)
375 return snd_soc_register_platform(&pdev
->dev
, &kirkwood_soc_platform
);
378 static int __devexit
kirkwood_soc_platform_remove(struct platform_device
*pdev
)
380 snd_soc_unregister_platform(&pdev
->dev
);
384 static struct platform_driver kirkwood_pcm_driver
= {
386 .name
= "kirkwood-pcm-audio",
387 .owner
= THIS_MODULE
,
390 .probe
= kirkwood_soc_platform_probe
,
391 .remove
= __devexit_p(kirkwood_soc_platform_remove
),
394 module_platform_driver(kirkwood_pcm_driver
);
396 MODULE_AUTHOR("Arnaud Patard <arnaud.patard@rtp-net.org>");
397 MODULE_DESCRIPTION("Marvell Kirkwood Audio DMA module");
398 MODULE_LICENSE("GPL");
399 MODULE_ALIAS("platform:kirkwood-pcm-audio");