2 * dma.c -- ALSA Soc Audio Layer
4 * (c) 2006 Wolfson Microelectronics PLC.
5 * Graeme Gregory graeme.gregory@wolfsonmicro.com or linux@wolfsonmicro.com
7 * Copyright 2004-2005 Simtec Electronics
8 * http://armlinux.simtec.co.uk/
9 * Ben Dooks <ben@simtec.co.uk>
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
17 #include <linux/slab.h>
18 #include <linux/dma-mapping.h>
19 #include <linux/module.h>
21 #include <sound/soc.h>
22 #include <sound/pcm_params.h>
25 #include <mach/hardware.h>
30 #define ST_RUNNING (1<<0)
31 #define ST_OPENED (1<<1)
33 static const struct snd_pcm_hardware dma_hardware
= {
34 .info
= SNDRV_PCM_INFO_INTERLEAVED
|
35 SNDRV_PCM_INFO_BLOCK_TRANSFER
|
37 SNDRV_PCM_INFO_MMAP_VALID
,
38 .formats
= SNDRV_PCM_FMTBIT_S16_LE
|
39 SNDRV_PCM_FMTBIT_U16_LE
|
44 .buffer_bytes_max
= 128*1024,
45 .period_bytes_min
= PAGE_SIZE
,
46 .period_bytes_max
= PAGE_SIZE
*2,
55 unsigned int dma_loaded
;
56 unsigned int dma_period
;
60 struct s3c_dma_params
*params
;
63 static void audio_buffdone(void *data
);
67 * place a dma buffer onto the queue for the dma system
70 static void dma_enqueue(struct snd_pcm_substream
*substream
)
72 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
73 dma_addr_t pos
= prtd
->dma_pos
;
75 struct samsung_dma_prep dma_info
;
77 pr_debug("Entered %s\n", __func__
);
79 limit
= (prtd
->dma_end
- prtd
->dma_start
) / prtd
->dma_period
;
81 pr_debug("%s: loaded %d, limit %d\n",
82 __func__
, prtd
->dma_loaded
, limit
);
84 dma_info
.cap
= (samsung_dma_has_circular() ? DMA_CYCLIC
: DMA_SLAVE
);
86 (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
87 ? DMA_MEM_TO_DEV
: DMA_DEV_TO_MEM
);
88 dma_info
.fp
= audio_buffdone
;
89 dma_info
.fp_param
= substream
;
90 dma_info
.period
= prtd
->dma_period
;
91 dma_info
.len
= prtd
->dma_period
*limit
;
93 while (prtd
->dma_loaded
< limit
) {
94 pr_debug("dma_loaded: %d\n", prtd
->dma_loaded
);
96 if ((pos
+ dma_info
.period
) > prtd
->dma_end
) {
97 dma_info
.period
= prtd
->dma_end
- pos
;
98 pr_debug("%s: corrected dma len %ld\n",
99 __func__
, dma_info
.period
);
103 prtd
->params
->ops
->prepare(prtd
->params
->ch
, &dma_info
);
106 pos
+= prtd
->dma_period
;
107 if (pos
>= prtd
->dma_end
)
108 pos
= prtd
->dma_start
;
114 static void audio_buffdone(void *data
)
116 struct snd_pcm_substream
*substream
= data
;
117 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
119 pr_debug("Entered %s\n", __func__
);
121 if (prtd
->state
& ST_RUNNING
) {
122 prtd
->dma_pos
+= prtd
->dma_period
;
123 if (prtd
->dma_pos
>= prtd
->dma_end
)
124 prtd
->dma_pos
= prtd
->dma_start
;
127 snd_pcm_period_elapsed(substream
);
129 spin_lock(&prtd
->lock
);
130 if (!samsung_dma_has_circular()) {
132 dma_enqueue(substream
);
134 spin_unlock(&prtd
->lock
);
138 static int dma_hw_params(struct snd_pcm_substream
*substream
,
139 struct snd_pcm_hw_params
*params
)
141 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
142 struct runtime_data
*prtd
= runtime
->private_data
;
143 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
144 unsigned long totbytes
= params_buffer_bytes(params
);
145 struct s3c_dma_params
*dma
=
146 snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
147 struct samsung_dma_req req
;
148 struct samsung_dma_config config
;
150 pr_debug("Entered %s\n", __func__
);
152 /* return if this is a bufferless transfer e.g.
153 * codec <--> BT codec or GSM modem -- lg FIXME */
157 /* this may get called several times by oss emulation
158 * with different params -HW */
159 if (prtd
->params
== NULL
) {
163 pr_debug("params %p, client %p, channel %d\n", prtd
->params
,
164 prtd
->params
->client
, prtd
->params
->channel
);
166 prtd
->params
->ops
= samsung_dma_get_ops();
168 req
.cap
= (samsung_dma_has_circular() ?
169 DMA_CYCLIC
: DMA_SLAVE
);
170 req
.client
= prtd
->params
->client
;
172 (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
173 ? DMA_MEM_TO_DEV
: DMA_DEV_TO_MEM
);
174 config
.width
= prtd
->params
->dma_size
;
175 config
.fifo
= prtd
->params
->dma_addr
;
176 prtd
->params
->ch
= prtd
->params
->ops
->request(
177 prtd
->params
->channel
, &req
, rtd
->cpu_dai
->dev
,
178 prtd
->params
->ch_name
);
179 prtd
->params
->ops
->config(prtd
->params
->ch
, &config
);
182 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
184 runtime
->dma_bytes
= totbytes
;
186 spin_lock_irq(&prtd
->lock
);
187 prtd
->dma_loaded
= 0;
188 prtd
->dma_period
= params_period_bytes(params
);
189 prtd
->dma_start
= runtime
->dma_addr
;
190 prtd
->dma_pos
= prtd
->dma_start
;
191 prtd
->dma_end
= prtd
->dma_start
+ totbytes
;
192 spin_unlock_irq(&prtd
->lock
);
197 static int dma_hw_free(struct snd_pcm_substream
*substream
)
199 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
201 pr_debug("Entered %s\n", __func__
);
203 snd_pcm_set_runtime_buffer(substream
, NULL
);
206 prtd
->params
->ops
->flush(prtd
->params
->ch
);
207 prtd
->params
->ops
->release(prtd
->params
->ch
,
208 prtd
->params
->client
);
215 static int dma_prepare(struct snd_pcm_substream
*substream
)
217 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
220 pr_debug("Entered %s\n", __func__
);
222 /* return if this is a bufferless transfer e.g.
223 * codec <--> BT codec or GSM modem -- lg FIXME */
227 /* flush the DMA channel */
228 prtd
->params
->ops
->flush(prtd
->params
->ch
);
230 prtd
->dma_loaded
= 0;
231 prtd
->dma_pos
= prtd
->dma_start
;
233 /* enqueue dma buffers */
234 dma_enqueue(substream
);
239 static int dma_trigger(struct snd_pcm_substream
*substream
, int cmd
)
241 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
244 pr_debug("Entered %s\n", __func__
);
246 spin_lock(&prtd
->lock
);
249 case SNDRV_PCM_TRIGGER_START
:
250 prtd
->state
|= ST_RUNNING
;
251 prtd
->params
->ops
->trigger(prtd
->params
->ch
);
254 case SNDRV_PCM_TRIGGER_STOP
:
255 prtd
->state
&= ~ST_RUNNING
;
256 prtd
->params
->ops
->stop(prtd
->params
->ch
);
264 spin_unlock(&prtd
->lock
);
269 static snd_pcm_uframes_t
270 dma_pointer(struct snd_pcm_substream
*substream
)
272 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
273 struct runtime_data
*prtd
= runtime
->private_data
;
276 pr_debug("Entered %s\n", __func__
);
278 res
= prtd
->dma_pos
- prtd
->dma_start
;
280 pr_debug("Pointer offset: %lu\n", res
);
282 /* we seem to be getting the odd error from the pcm library due
283 * to out-of-bounds pointers. this is maybe due to the dma engine
284 * not having loaded the new values for the channel before being
285 * called... (todo - fix )
288 if (res
>= snd_pcm_lib_buffer_bytes(substream
)) {
289 if (res
== snd_pcm_lib_buffer_bytes(substream
))
293 return bytes_to_frames(substream
->runtime
, res
);
296 static int dma_open(struct snd_pcm_substream
*substream
)
298 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
299 struct runtime_data
*prtd
;
301 pr_debug("Entered %s\n", __func__
);
303 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
304 snd_soc_set_runtime_hwparams(substream
, &dma_hardware
);
306 prtd
= kzalloc(sizeof(struct runtime_data
), GFP_KERNEL
);
310 spin_lock_init(&prtd
->lock
);
312 runtime
->private_data
= prtd
;
316 static int dma_close(struct snd_pcm_substream
*substream
)
318 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
319 struct runtime_data
*prtd
= runtime
->private_data
;
321 pr_debug("Entered %s\n", __func__
);
324 pr_debug("dma_close called with prtd == NULL\n");
331 static int dma_mmap(struct snd_pcm_substream
*substream
,
332 struct vm_area_struct
*vma
)
334 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
336 pr_debug("Entered %s\n", __func__
);
338 return dma_mmap_writecombine(substream
->pcm
->card
->dev
, vma
,
344 static struct snd_pcm_ops dma_ops
= {
347 .ioctl
= snd_pcm_lib_ioctl
,
348 .hw_params
= dma_hw_params
,
349 .hw_free
= dma_hw_free
,
350 .prepare
= dma_prepare
,
351 .trigger
= dma_trigger
,
352 .pointer
= dma_pointer
,
356 static int preallocate_dma_buffer(struct snd_pcm
*pcm
, int stream
)
358 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
359 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
360 size_t size
= dma_hardware
.buffer_bytes_max
;
362 pr_debug("Entered %s\n", __func__
);
364 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
365 buf
->dev
.dev
= pcm
->card
->dev
;
366 buf
->private_data
= NULL
;
367 buf
->area
= dma_alloc_writecombine(pcm
->card
->dev
, size
,
368 &buf
->addr
, GFP_KERNEL
);
375 static void dma_free_dma_buffers(struct snd_pcm
*pcm
)
377 struct snd_pcm_substream
*substream
;
378 struct snd_dma_buffer
*buf
;
381 pr_debug("Entered %s\n", __func__
);
383 for (stream
= 0; stream
< 2; stream
++) {
384 substream
= pcm
->streams
[stream
].substream
;
388 buf
= &substream
->dma_buffer
;
392 dma_free_writecombine(pcm
->card
->dev
, buf
->bytes
,
393 buf
->area
, buf
->addr
);
398 static u64 dma_mask
= DMA_BIT_MASK(32);
400 static int dma_new(struct snd_soc_pcm_runtime
*rtd
)
402 struct snd_card
*card
= rtd
->card
->snd_card
;
403 struct snd_pcm
*pcm
= rtd
->pcm
;
406 pr_debug("Entered %s\n", __func__
);
408 if (!card
->dev
->dma_mask
)
409 card
->dev
->dma_mask
= &dma_mask
;
410 if (!card
->dev
->coherent_dma_mask
)
411 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
413 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
) {
414 ret
= preallocate_dma_buffer(pcm
,
415 SNDRV_PCM_STREAM_PLAYBACK
);
420 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
) {
421 ret
= preallocate_dma_buffer(pcm
,
422 SNDRV_PCM_STREAM_CAPTURE
);
430 static struct snd_soc_platform_driver samsung_asoc_platform
= {
433 .pcm_free
= dma_free_dma_buffers
,
436 int asoc_dma_platform_register(struct device
*dev
)
438 return snd_soc_register_platform(dev
, &samsung_asoc_platform
);
440 EXPORT_SYMBOL_GPL(asoc_dma_platform_register
);
442 void asoc_dma_platform_unregister(struct device
*dev
)
444 snd_soc_unregister_platform(dev
);
446 EXPORT_SYMBOL_GPL(asoc_dma_platform_unregister
);
448 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
449 MODULE_DESCRIPTION("Samsung ASoC DMA Driver");
450 MODULE_LICENSE("GPL");