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
);
178 prtd
->params
->ops
->config(prtd
->params
->ch
, &config
);
181 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
183 runtime
->dma_bytes
= totbytes
;
185 spin_lock_irq(&prtd
->lock
);
186 prtd
->dma_loaded
= 0;
187 prtd
->dma_period
= params_period_bytes(params
);
188 prtd
->dma_start
= runtime
->dma_addr
;
189 prtd
->dma_pos
= prtd
->dma_start
;
190 prtd
->dma_end
= prtd
->dma_start
+ totbytes
;
191 spin_unlock_irq(&prtd
->lock
);
196 static int dma_hw_free(struct snd_pcm_substream
*substream
)
198 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
200 pr_debug("Entered %s\n", __func__
);
202 snd_pcm_set_runtime_buffer(substream
, NULL
);
205 prtd
->params
->ops
->flush(prtd
->params
->ch
);
206 prtd
->params
->ops
->release(prtd
->params
->ch
,
207 prtd
->params
->client
);
214 static int dma_prepare(struct snd_pcm_substream
*substream
)
216 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
219 pr_debug("Entered %s\n", __func__
);
221 /* return if this is a bufferless transfer e.g.
222 * codec <--> BT codec or GSM modem -- lg FIXME */
226 /* flush the DMA channel */
227 prtd
->params
->ops
->flush(prtd
->params
->ch
);
229 prtd
->dma_loaded
= 0;
230 prtd
->dma_pos
= prtd
->dma_start
;
232 /* enqueue dma buffers */
233 dma_enqueue(substream
);
238 static int dma_trigger(struct snd_pcm_substream
*substream
, int cmd
)
240 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
243 pr_debug("Entered %s\n", __func__
);
245 spin_lock(&prtd
->lock
);
248 case SNDRV_PCM_TRIGGER_START
:
249 prtd
->state
|= ST_RUNNING
;
250 prtd
->params
->ops
->trigger(prtd
->params
->ch
);
253 case SNDRV_PCM_TRIGGER_STOP
:
254 prtd
->state
&= ~ST_RUNNING
;
255 prtd
->params
->ops
->stop(prtd
->params
->ch
);
263 spin_unlock(&prtd
->lock
);
268 static snd_pcm_uframes_t
269 dma_pointer(struct snd_pcm_substream
*substream
)
271 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
272 struct runtime_data
*prtd
= runtime
->private_data
;
275 pr_debug("Entered %s\n", __func__
);
277 res
= prtd
->dma_pos
- prtd
->dma_start
;
279 pr_debug("Pointer offset: %lu\n", res
);
281 /* we seem to be getting the odd error from the pcm library due
282 * to out-of-bounds pointers. this is maybe due to the dma engine
283 * not having loaded the new values for the channel before being
284 * called... (todo - fix )
287 if (res
>= snd_pcm_lib_buffer_bytes(substream
)) {
288 if (res
== snd_pcm_lib_buffer_bytes(substream
))
292 return bytes_to_frames(substream
->runtime
, res
);
295 static int dma_open(struct snd_pcm_substream
*substream
)
297 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
298 struct runtime_data
*prtd
;
300 pr_debug("Entered %s\n", __func__
);
302 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
303 snd_soc_set_runtime_hwparams(substream
, &dma_hardware
);
305 prtd
= kzalloc(sizeof(struct runtime_data
), GFP_KERNEL
);
309 spin_lock_init(&prtd
->lock
);
311 runtime
->private_data
= prtd
;
315 static int dma_close(struct snd_pcm_substream
*substream
)
317 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
318 struct runtime_data
*prtd
= runtime
->private_data
;
320 pr_debug("Entered %s\n", __func__
);
323 pr_debug("dma_close called with prtd == NULL\n");
330 static int dma_mmap(struct snd_pcm_substream
*substream
,
331 struct vm_area_struct
*vma
)
333 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
335 pr_debug("Entered %s\n", __func__
);
337 return dma_mmap_writecombine(substream
->pcm
->card
->dev
, vma
,
343 static struct snd_pcm_ops dma_ops
= {
346 .ioctl
= snd_pcm_lib_ioctl
,
347 .hw_params
= dma_hw_params
,
348 .hw_free
= dma_hw_free
,
349 .prepare
= dma_prepare
,
350 .trigger
= dma_trigger
,
351 .pointer
= dma_pointer
,
355 static int preallocate_dma_buffer(struct snd_pcm
*pcm
, int stream
)
357 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
358 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
359 size_t size
= dma_hardware
.buffer_bytes_max
;
361 pr_debug("Entered %s\n", __func__
);
363 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
364 buf
->dev
.dev
= pcm
->card
->dev
;
365 buf
->private_data
= NULL
;
366 buf
->area
= dma_alloc_writecombine(pcm
->card
->dev
, size
,
367 &buf
->addr
, GFP_KERNEL
);
374 static void dma_free_dma_buffers(struct snd_pcm
*pcm
)
376 struct snd_pcm_substream
*substream
;
377 struct snd_dma_buffer
*buf
;
380 pr_debug("Entered %s\n", __func__
);
382 for (stream
= 0; stream
< 2; stream
++) {
383 substream
= pcm
->streams
[stream
].substream
;
387 buf
= &substream
->dma_buffer
;
391 dma_free_writecombine(pcm
->card
->dev
, buf
->bytes
,
392 buf
->area
, buf
->addr
);
397 static u64 dma_mask
= DMA_BIT_MASK(32);
399 static int dma_new(struct snd_soc_pcm_runtime
*rtd
)
401 struct snd_card
*card
= rtd
->card
->snd_card
;
402 struct snd_pcm
*pcm
= rtd
->pcm
;
405 pr_debug("Entered %s\n", __func__
);
407 if (!card
->dev
->dma_mask
)
408 card
->dev
->dma_mask
= &dma_mask
;
409 if (!card
->dev
->coherent_dma_mask
)
410 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
412 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
) {
413 ret
= preallocate_dma_buffer(pcm
,
414 SNDRV_PCM_STREAM_PLAYBACK
);
419 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
) {
420 ret
= preallocate_dma_buffer(pcm
,
421 SNDRV_PCM_STREAM_CAPTURE
);
429 static struct snd_soc_platform_driver samsung_asoc_platform
= {
432 .pcm_free
= dma_free_dma_buffers
,
435 int asoc_dma_platform_register(struct device
*dev
)
437 return snd_soc_register_platform(dev
, &samsung_asoc_platform
);
439 EXPORT_SYMBOL_GPL(asoc_dma_platform_register
);
441 void asoc_dma_platform_unregister(struct device
*dev
)
443 snd_soc_unregister_platform(dev
);
445 EXPORT_SYMBOL_GPL(asoc_dma_platform_unregister
);
447 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
448 MODULE_DESCRIPTION("Samsung ASoC DMA Driver");
449 MODULE_LICENSE("GPL");