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 if (!prtd
->params
->ch
) {
180 pr_err("Failed to allocate DMA channel\n");
183 prtd
->params
->ops
->config(prtd
->params
->ch
, &config
);
186 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
188 runtime
->dma_bytes
= totbytes
;
190 spin_lock_irq(&prtd
->lock
);
191 prtd
->dma_loaded
= 0;
192 prtd
->dma_period
= params_period_bytes(params
);
193 prtd
->dma_start
= runtime
->dma_addr
;
194 prtd
->dma_pos
= prtd
->dma_start
;
195 prtd
->dma_end
= prtd
->dma_start
+ totbytes
;
196 spin_unlock_irq(&prtd
->lock
);
201 static int dma_hw_free(struct snd_pcm_substream
*substream
)
203 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
205 pr_debug("Entered %s\n", __func__
);
207 snd_pcm_set_runtime_buffer(substream
, NULL
);
210 prtd
->params
->ops
->flush(prtd
->params
->ch
);
211 prtd
->params
->ops
->release(prtd
->params
->ch
,
212 prtd
->params
->client
);
219 static int dma_prepare(struct snd_pcm_substream
*substream
)
221 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
224 pr_debug("Entered %s\n", __func__
);
226 /* return if this is a bufferless transfer e.g.
227 * codec <--> BT codec or GSM modem -- lg FIXME */
231 /* flush the DMA channel */
232 prtd
->params
->ops
->flush(prtd
->params
->ch
);
234 prtd
->dma_loaded
= 0;
235 prtd
->dma_pos
= prtd
->dma_start
;
237 /* enqueue dma buffers */
238 dma_enqueue(substream
);
243 static int dma_trigger(struct snd_pcm_substream
*substream
, int cmd
)
245 struct runtime_data
*prtd
= substream
->runtime
->private_data
;
248 pr_debug("Entered %s\n", __func__
);
250 spin_lock(&prtd
->lock
);
253 case SNDRV_PCM_TRIGGER_START
:
254 prtd
->state
|= ST_RUNNING
;
255 prtd
->params
->ops
->trigger(prtd
->params
->ch
);
258 case SNDRV_PCM_TRIGGER_STOP
:
259 prtd
->state
&= ~ST_RUNNING
;
260 prtd
->params
->ops
->stop(prtd
->params
->ch
);
268 spin_unlock(&prtd
->lock
);
273 static snd_pcm_uframes_t
274 dma_pointer(struct snd_pcm_substream
*substream
)
276 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
277 struct runtime_data
*prtd
= runtime
->private_data
;
280 pr_debug("Entered %s\n", __func__
);
282 res
= prtd
->dma_pos
- prtd
->dma_start
;
284 pr_debug("Pointer offset: %lu\n", res
);
286 /* we seem to be getting the odd error from the pcm library due
287 * to out-of-bounds pointers. this is maybe due to the dma engine
288 * not having loaded the new values for the channel before being
289 * called... (todo - fix )
292 if (res
>= snd_pcm_lib_buffer_bytes(substream
)) {
293 if (res
== snd_pcm_lib_buffer_bytes(substream
))
297 return bytes_to_frames(substream
->runtime
, res
);
300 static int dma_open(struct snd_pcm_substream
*substream
)
302 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
303 struct runtime_data
*prtd
;
305 pr_debug("Entered %s\n", __func__
);
307 snd_pcm_hw_constraint_integer(runtime
, SNDRV_PCM_HW_PARAM_PERIODS
);
308 snd_soc_set_runtime_hwparams(substream
, &dma_hardware
);
310 prtd
= kzalloc(sizeof(struct runtime_data
), GFP_KERNEL
);
314 spin_lock_init(&prtd
->lock
);
316 runtime
->private_data
= prtd
;
320 static int dma_close(struct snd_pcm_substream
*substream
)
322 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
323 struct runtime_data
*prtd
= runtime
->private_data
;
325 pr_debug("Entered %s\n", __func__
);
328 pr_debug("dma_close called with prtd == NULL\n");
335 static int dma_mmap(struct snd_pcm_substream
*substream
,
336 struct vm_area_struct
*vma
)
338 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
340 pr_debug("Entered %s\n", __func__
);
342 return dma_mmap_writecombine(substream
->pcm
->card
->dev
, vma
,
348 static struct snd_pcm_ops dma_ops
= {
351 .ioctl
= snd_pcm_lib_ioctl
,
352 .hw_params
= dma_hw_params
,
353 .hw_free
= dma_hw_free
,
354 .prepare
= dma_prepare
,
355 .trigger
= dma_trigger
,
356 .pointer
= dma_pointer
,
360 static int preallocate_dma_buffer(struct snd_pcm
*pcm
, int stream
)
362 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
363 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
364 size_t size
= dma_hardware
.buffer_bytes_max
;
366 pr_debug("Entered %s\n", __func__
);
368 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
369 buf
->dev
.dev
= pcm
->card
->dev
;
370 buf
->private_data
= NULL
;
371 buf
->area
= dma_alloc_writecombine(pcm
->card
->dev
, size
,
372 &buf
->addr
, GFP_KERNEL
);
379 static void dma_free_dma_buffers(struct snd_pcm
*pcm
)
381 struct snd_pcm_substream
*substream
;
382 struct snd_dma_buffer
*buf
;
385 pr_debug("Entered %s\n", __func__
);
387 for (stream
= 0; stream
< 2; stream
++) {
388 substream
= pcm
->streams
[stream
].substream
;
392 buf
= &substream
->dma_buffer
;
396 dma_free_writecombine(pcm
->card
->dev
, buf
->bytes
,
397 buf
->area
, buf
->addr
);
402 static u64 dma_mask
= DMA_BIT_MASK(32);
404 static int dma_new(struct snd_soc_pcm_runtime
*rtd
)
406 struct snd_card
*card
= rtd
->card
->snd_card
;
407 struct snd_pcm
*pcm
= rtd
->pcm
;
410 pr_debug("Entered %s\n", __func__
);
412 if (!card
->dev
->dma_mask
)
413 card
->dev
->dma_mask
= &dma_mask
;
414 if (!card
->dev
->coherent_dma_mask
)
415 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(32);
417 if (pcm
->streams
[SNDRV_PCM_STREAM_PLAYBACK
].substream
) {
418 ret
= preallocate_dma_buffer(pcm
,
419 SNDRV_PCM_STREAM_PLAYBACK
);
424 if (pcm
->streams
[SNDRV_PCM_STREAM_CAPTURE
].substream
) {
425 ret
= preallocate_dma_buffer(pcm
,
426 SNDRV_PCM_STREAM_CAPTURE
);
434 static struct snd_soc_platform_driver samsung_asoc_platform
= {
437 .pcm_free
= dma_free_dma_buffers
,
440 int asoc_dma_platform_register(struct device
*dev
)
442 return snd_soc_register_platform(dev
, &samsung_asoc_platform
);
444 EXPORT_SYMBOL_GPL(asoc_dma_platform_register
);
446 void asoc_dma_platform_unregister(struct device
*dev
)
448 snd_soc_unregister_platform(dev
);
450 EXPORT_SYMBOL_GPL(asoc_dma_platform_unregister
);
452 MODULE_AUTHOR("Ben Dooks, <ben@simtec.co.uk>");
453 MODULE_DESCRIPTION("Samsung ASoC DMA Driver");
454 MODULE_LICENSE("GPL");