2 * omap-pcm.c -- ALSA PCM interface for the OMAP SoC
4 * Copyright (C) 2008 Nokia Corporation
6 * Contact: Jarkko Nikula <jhnikula@gmail.com>
7 * Peter Ujfalusi <peter.ujfalusi@nokia.com>
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License
11 * version 2 as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
25 #include <linux/dma-mapping.h>
26 #include <linux/slab.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
29 #include <sound/pcm_params.h>
30 #include <sound/soc.h>
35 static const struct snd_pcm_hardware omap_pcm_hardware
= {
36 .info
= SNDRV_PCM_INFO_MMAP
|
37 SNDRV_PCM_INFO_MMAP_VALID
|
38 SNDRV_PCM_INFO_INTERLEAVED
|
39 SNDRV_PCM_INFO_PAUSE
|
40 SNDRV_PCM_INFO_RESUME
,
41 .formats
= SNDRV_PCM_FMTBIT_S16_LE
|
42 SNDRV_PCM_FMTBIT_S32_LE
,
43 .period_bytes_min
= 32,
44 .period_bytes_max
= 64 * 1024,
47 .buffer_bytes_max
= 128 * 1024,
50 struct omap_runtime_data
{
52 struct omap_pcm_dma_data
*dma_data
;
57 static void omap_pcm_dma_irq(int ch
, u16 stat
, void *data
)
59 struct snd_pcm_substream
*substream
= data
;
60 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
61 struct omap_runtime_data
*prtd
= runtime
->private_data
;
64 if ((cpu_is_omap1510())) {
66 * OMAP1510 doesn't fully support DMA progress counter
67 * and there is no software emulation implemented yet,
68 * so have to maintain our own progress counters
69 * that can be used by omap_pcm_pointer() instead.
71 spin_lock_irqsave(&prtd
->lock
, flags
);
72 if ((stat
== OMAP_DMA_LAST_IRQ
) &&
73 (prtd
->period_index
== runtime
->periods
- 1)) {
74 /* we are in sync, do nothing */
75 spin_unlock_irqrestore(&prtd
->lock
, flags
);
78 if (prtd
->period_index
>= 0) {
79 if (stat
& OMAP_DMA_BLOCK_IRQ
) {
80 /* end of buffer reached, loop back */
81 prtd
->period_index
= 0;
82 } else if (stat
& OMAP_DMA_LAST_IRQ
) {
83 /* update the counter for the last period */
84 prtd
->period_index
= runtime
->periods
- 1;
85 } else if (++prtd
->period_index
>= runtime
->periods
) {
86 /* end of buffer missed? loop back */
87 prtd
->period_index
= 0;
90 spin_unlock_irqrestore(&prtd
->lock
, flags
);
93 snd_pcm_period_elapsed(substream
);
96 /* this may get called several times by oss emulation */
97 static int omap_pcm_hw_params(struct snd_pcm_substream
*substream
,
98 struct snd_pcm_hw_params
*params
)
100 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
101 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
102 struct omap_runtime_data
*prtd
= runtime
->private_data
;
103 struct omap_pcm_dma_data
*dma_data
;
106 dma_data
= snd_soc_dai_get_dma_data(rtd
->dai
->cpu_dai
, substream
);
111 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
112 runtime
->dma_bytes
= params_buffer_bytes(params
);
116 prtd
->dma_data
= dma_data
;
117 err
= omap_request_dma(dma_data
->dma_req
, dma_data
->name
,
118 omap_pcm_dma_irq
, substream
, &prtd
->dma_ch
);
121 * Link channel with itself so DMA doesn't need any
122 * reprogramming while looping the buffer
124 omap_dma_link_lch(prtd
->dma_ch
, prtd
->dma_ch
);
130 static int omap_pcm_hw_free(struct snd_pcm_substream
*substream
)
132 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
133 struct omap_runtime_data
*prtd
= runtime
->private_data
;
135 if (prtd
->dma_data
== NULL
)
138 omap_dma_unlink_lch(prtd
->dma_ch
, prtd
->dma_ch
);
139 omap_free_dma(prtd
->dma_ch
);
140 prtd
->dma_data
= NULL
;
142 snd_pcm_set_runtime_buffer(substream
, NULL
);
147 static int omap_pcm_prepare(struct snd_pcm_substream
*substream
)
149 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
150 struct omap_runtime_data
*prtd
= runtime
->private_data
;
151 struct omap_pcm_dma_data
*dma_data
= prtd
->dma_data
;
152 struct omap_dma_channel_params dma_params
;
158 memset(&dma_params
, 0, sizeof(dma_params
));
159 dma_params
.data_type
= dma_data
->data_type
;
160 dma_params
.trigger
= dma_data
->dma_req
;
161 dma_params
.sync_mode
= dma_data
->sync_mode
;
162 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
163 dma_params
.src_amode
= OMAP_DMA_AMODE_POST_INC
;
164 dma_params
.dst_amode
= OMAP_DMA_AMODE_CONSTANT
;
165 dma_params
.src_or_dst_synch
= OMAP_DMA_DST_SYNC
;
166 dma_params
.src_start
= runtime
->dma_addr
;
167 dma_params
.dst_start
= dma_data
->port_addr
;
168 dma_params
.dst_port
= OMAP_DMA_PORT_MPUI
;
169 dma_params
.dst_fi
= dma_data
->packet_size
;
171 dma_params
.src_amode
= OMAP_DMA_AMODE_CONSTANT
;
172 dma_params
.dst_amode
= OMAP_DMA_AMODE_POST_INC
;
173 dma_params
.src_or_dst_synch
= OMAP_DMA_SRC_SYNC
;
174 dma_params
.src_start
= dma_data
->port_addr
;
175 dma_params
.dst_start
= runtime
->dma_addr
;
176 dma_params
.src_port
= OMAP_DMA_PORT_MPUI
;
177 dma_params
.src_fi
= dma_data
->packet_size
;
180 * Set DMA transfer frame size equal to ALSA period size and frame
181 * count as no. of ALSA periods. Then with DMA frame interrupt enabled,
182 * we can transfer the whole ALSA buffer with single DMA transfer but
183 * still can get an interrupt at each period bounary
185 bytes
= snd_pcm_lib_period_bytes(substream
);
186 dma_params
.elem_count
= bytes
>> dma_data
->data_type
;
187 dma_params
.frame_count
= runtime
->periods
;
188 omap_set_dma_params(prtd
->dma_ch
, &dma_params
);
190 if ((cpu_is_omap1510()))
191 omap_enable_dma_irq(prtd
->dma_ch
, OMAP_DMA_FRAME_IRQ
|
192 OMAP_DMA_LAST_IRQ
| OMAP_DMA_BLOCK_IRQ
);
194 omap_enable_dma_irq(prtd
->dma_ch
, OMAP_DMA_FRAME_IRQ
);
196 if (!(cpu_class_is_omap1())) {
197 omap_set_dma_src_burst_mode(prtd
->dma_ch
,
198 OMAP_DMA_DATA_BURST_16
);
199 omap_set_dma_dest_burst_mode(prtd
->dma_ch
,
200 OMAP_DMA_DATA_BURST_16
);
206 static int omap_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
208 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
209 struct omap_runtime_data
*prtd
= runtime
->private_data
;
210 struct omap_pcm_dma_data
*dma_data
= prtd
->dma_data
;
214 spin_lock_irqsave(&prtd
->lock
, flags
);
216 case SNDRV_PCM_TRIGGER_START
:
217 case SNDRV_PCM_TRIGGER_RESUME
:
218 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
219 prtd
->period_index
= 0;
220 /* Configure McBSP internal buffer usage */
221 if (dma_data
->set_threshold
)
222 dma_data
->set_threshold(substream
);
224 omap_start_dma(prtd
->dma_ch
);
227 case SNDRV_PCM_TRIGGER_STOP
:
228 case SNDRV_PCM_TRIGGER_SUSPEND
:
229 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
230 prtd
->period_index
= -1;
231 omap_stop_dma(prtd
->dma_ch
);
236 spin_unlock_irqrestore(&prtd
->lock
, flags
);
241 static snd_pcm_uframes_t
omap_pcm_pointer(struct snd_pcm_substream
*substream
)
243 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
244 struct omap_runtime_data
*prtd
= runtime
->private_data
;
246 snd_pcm_uframes_t offset
;
248 if (cpu_is_omap1510()) {
249 offset
= prtd
->period_index
* runtime
->period_size
;
250 } else if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
) {
251 ptr
= omap_get_dma_dst_pos(prtd
->dma_ch
);
252 offset
= bytes_to_frames(runtime
, ptr
- runtime
->dma_addr
);
254 ptr
= omap_get_dma_src_pos(prtd
->dma_ch
);
255 offset
= bytes_to_frames(runtime
, ptr
- runtime
->dma_addr
);
258 if (offset
>= runtime
->buffer_size
)
264 static int omap_pcm_open(struct snd_pcm_substream
*substream
)
266 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
267 struct omap_runtime_data
*prtd
;
270 snd_soc_set_runtime_hwparams(substream
, &omap_pcm_hardware
);
272 /* Ensure that buffer size is a multiple of period size */
273 ret
= snd_pcm_hw_constraint_integer(runtime
,
274 SNDRV_PCM_HW_PARAM_PERIODS
);
278 prtd
= kzalloc(sizeof(*prtd
), GFP_KERNEL
);
283 spin_lock_init(&prtd
->lock
);
284 runtime
->private_data
= prtd
;
290 static int omap_pcm_close(struct snd_pcm_substream
*substream
)
292 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
294 kfree(runtime
->private_data
);
298 static int omap_pcm_mmap(struct snd_pcm_substream
*substream
,
299 struct vm_area_struct
*vma
)
301 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
303 return dma_mmap_writecombine(substream
->pcm
->card
->dev
, vma
,
309 static struct snd_pcm_ops omap_pcm_ops
= {
310 .open
= omap_pcm_open
,
311 .close
= omap_pcm_close
,
312 .ioctl
= snd_pcm_lib_ioctl
,
313 .hw_params
= omap_pcm_hw_params
,
314 .hw_free
= omap_pcm_hw_free
,
315 .prepare
= omap_pcm_prepare
,
316 .trigger
= omap_pcm_trigger
,
317 .pointer
= omap_pcm_pointer
,
318 .mmap
= omap_pcm_mmap
,
321 static u64 omap_pcm_dmamask
= DMA_BIT_MASK(64);
323 static int omap_pcm_preallocate_dma_buffer(struct snd_pcm
*pcm
,
326 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
327 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
328 size_t size
= omap_pcm_hardware
.buffer_bytes_max
;
330 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
331 buf
->dev
.dev
= pcm
->card
->dev
;
332 buf
->private_data
= NULL
;
333 buf
->area
= dma_alloc_writecombine(pcm
->card
->dev
, size
,
334 &buf
->addr
, GFP_KERNEL
);
342 static void omap_pcm_free_dma_buffers(struct snd_pcm
*pcm
)
344 struct snd_pcm_substream
*substream
;
345 struct snd_dma_buffer
*buf
;
348 for (stream
= 0; stream
< 2; stream
++) {
349 substream
= pcm
->streams
[stream
].substream
;
353 buf
= &substream
->dma_buffer
;
357 dma_free_writecombine(pcm
->card
->dev
, buf
->bytes
,
358 buf
->area
, buf
->addr
);
363 static int omap_pcm_new(struct snd_card
*card
, struct snd_soc_dai
*dai
,
368 if (!card
->dev
->dma_mask
)
369 card
->dev
->dma_mask
= &omap_pcm_dmamask
;
370 if (!card
->dev
->coherent_dma_mask
)
371 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(64);
373 if (dai
->playback
.channels_min
) {
374 ret
= omap_pcm_preallocate_dma_buffer(pcm
,
375 SNDRV_PCM_STREAM_PLAYBACK
);
380 if (dai
->capture
.channels_min
) {
381 ret
= omap_pcm_preallocate_dma_buffer(pcm
,
382 SNDRV_PCM_STREAM_CAPTURE
);
391 struct snd_soc_platform omap_soc_platform
= {
392 .name
= "omap-pcm-audio",
393 .pcm_ops
= &omap_pcm_ops
,
394 .pcm_new
= omap_pcm_new
,
395 .pcm_free
= omap_pcm_free_dma_buffers
,
397 EXPORT_SYMBOL_GPL(omap_soc_platform
);
399 static int __init
omap_soc_platform_init(void)
401 return snd_soc_register_platform(&omap_soc_platform
);
403 module_init(omap_soc_platform_init
);
405 static void __exit
omap_soc_platform_exit(void)
407 snd_soc_unregister_platform(&omap_soc_platform
);
409 module_exit(omap_soc_platform_exit
);
411 MODULE_AUTHOR("Jarkko Nikula <jhnikula@gmail.com>");
412 MODULE_DESCRIPTION("OMAP PCM DMA module");
413 MODULE_LICENSE("GPL");