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 <sound/core.h>
27 #include <sound/pcm.h>
28 #include <sound/pcm_params.h>
29 #include <sound/soc.h>
34 static const struct snd_pcm_hardware omap_pcm_hardware
= {
35 .info
= SNDRV_PCM_INFO_MMAP
|
36 SNDRV_PCM_INFO_MMAP_VALID
|
37 SNDRV_PCM_INFO_INTERLEAVED
|
38 SNDRV_PCM_INFO_PAUSE
|
39 SNDRV_PCM_INFO_RESUME
,
40 .formats
= SNDRV_PCM_FMTBIT_S16_LE
,
41 .period_bytes_min
= 32,
42 .period_bytes_max
= 64 * 1024,
45 .buffer_bytes_max
= 128 * 1024,
48 struct omap_runtime_data
{
50 struct omap_pcm_dma_data
*dma_data
;
55 static void omap_pcm_dma_irq(int ch
, u16 stat
, void *data
)
57 struct snd_pcm_substream
*substream
= data
;
58 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
59 struct omap_runtime_data
*prtd
= runtime
->private_data
;
62 if ((cpu_is_omap1510()) &&
63 (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)) {
65 * OMAP1510 doesn't fully support DMA progress counter
66 * and there is no software emulation implemented yet,
67 * so have to maintain our own playback progress counter
68 * that can be used by omap_pcm_pointer() instead.
70 spin_lock_irqsave(&prtd
->lock
, flags
);
71 if ((stat
== OMAP_DMA_LAST_IRQ
) &&
72 (prtd
->period_index
== runtime
->periods
- 1)) {
73 /* we are in sync, do nothing */
74 spin_unlock_irqrestore(&prtd
->lock
, flags
);
77 if (prtd
->period_index
>= 0) {
78 if (stat
& OMAP_DMA_BLOCK_IRQ
) {
79 /* end of buffer reached, loop back */
80 prtd
->period_index
= 0;
81 } else if (stat
& OMAP_DMA_LAST_IRQ
) {
82 /* update the counter for the last period */
83 prtd
->period_index
= runtime
->periods
- 1;
84 } else if (++prtd
->period_index
>= runtime
->periods
) {
85 /* end of buffer missed? loop back */
86 prtd
->period_index
= 0;
89 spin_unlock_irqrestore(&prtd
->lock
, flags
);
92 snd_pcm_period_elapsed(substream
);
95 /* this may get called several times by oss emulation */
96 static int omap_pcm_hw_params(struct snd_pcm_substream
*substream
,
97 struct snd_pcm_hw_params
*params
)
99 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
100 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
101 struct omap_runtime_data
*prtd
= runtime
->private_data
;
102 struct omap_pcm_dma_data
*dma_data
= rtd
->dai
->cpu_dai
->dma_data
;
105 /* return if this is a bufferless transfer e.g.
106 * codec <--> BT codec or GSM modem -- lg FIXME */
110 snd_pcm_set_runtime_buffer(substream
, &substream
->dma_buffer
);
111 runtime
->dma_bytes
= params_buffer_bytes(params
);
115 prtd
->dma_data
= dma_data
;
116 err
= omap_request_dma(dma_data
->dma_req
, dma_data
->name
,
117 omap_pcm_dma_irq
, substream
, &prtd
->dma_ch
);
120 * Link channel with itself so DMA doesn't need any
121 * reprogramming while looping the buffer
123 omap_dma_link_lch(prtd
->dma_ch
, prtd
->dma_ch
);
129 static int omap_pcm_hw_free(struct snd_pcm_substream
*substream
)
131 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
132 struct omap_runtime_data
*prtd
= runtime
->private_data
;
134 if (prtd
->dma_data
== NULL
)
137 omap_dma_unlink_lch(prtd
->dma_ch
, prtd
->dma_ch
);
138 omap_free_dma(prtd
->dma_ch
);
139 prtd
->dma_data
= NULL
;
141 snd_pcm_set_runtime_buffer(substream
, NULL
);
146 static int omap_pcm_prepare(struct snd_pcm_substream
*substream
)
148 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
149 struct omap_runtime_data
*prtd
= runtime
->private_data
;
150 struct omap_pcm_dma_data
*dma_data
= prtd
->dma_data
;
151 struct omap_dma_channel_params dma_params
;
153 /* return if this is a bufferless transfer e.g.
154 * codec <--> BT codec or GSM modem -- lg FIXME */
158 memset(&dma_params
, 0, sizeof(dma_params
));
160 * Note: Regardless of interface data formats supported by OMAP McBSP
161 * or EAC blocks, internal representation is always fixed 16-bit/sample
163 dma_params
.data_type
= OMAP_DMA_DATA_TYPE_S16
;
164 dma_params
.trigger
= dma_data
->dma_req
;
165 dma_params
.sync_mode
= dma_data
->sync_mode
;
166 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
167 dma_params
.src_amode
= OMAP_DMA_AMODE_POST_INC
;
168 dma_params
.dst_amode
= OMAP_DMA_AMODE_CONSTANT
;
169 dma_params
.src_or_dst_synch
= OMAP_DMA_DST_SYNC
;
170 dma_params
.src_start
= runtime
->dma_addr
;
171 dma_params
.dst_start
= dma_data
->port_addr
;
172 dma_params
.dst_port
= OMAP_DMA_PORT_MPUI
;
174 dma_params
.src_amode
= OMAP_DMA_AMODE_CONSTANT
;
175 dma_params
.dst_amode
= OMAP_DMA_AMODE_POST_INC
;
176 dma_params
.src_or_dst_synch
= OMAP_DMA_SRC_SYNC
;
177 dma_params
.src_start
= dma_data
->port_addr
;
178 dma_params
.dst_start
= runtime
->dma_addr
;
179 dma_params
.src_port
= OMAP_DMA_PORT_MPUI
;
182 * Set DMA transfer frame size equal to ALSA period size and frame
183 * count as no. of ALSA periods. Then with DMA frame interrupt enabled,
184 * we can transfer the whole ALSA buffer with single DMA transfer but
185 * still can get an interrupt at each period bounary
187 dma_params
.elem_count
= snd_pcm_lib_period_bytes(substream
) / 2;
188 dma_params
.frame_count
= runtime
->periods
;
189 omap_set_dma_params(prtd
->dma_ch
, &dma_params
);
191 if ((cpu_is_omap1510()) &&
192 (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
))
193 omap_enable_dma_irq(prtd
->dma_ch
, OMAP_DMA_FRAME_IRQ
|
194 OMAP_DMA_LAST_IRQ
| OMAP_DMA_BLOCK_IRQ
);
196 omap_enable_dma_irq(prtd
->dma_ch
, OMAP_DMA_FRAME_IRQ
);
198 omap_set_dma_src_burst_mode(prtd
->dma_ch
, OMAP_DMA_DATA_BURST_16
);
199 omap_set_dma_dest_burst_mode(prtd
->dma_ch
, OMAP_DMA_DATA_BURST_16
);
204 static int omap_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
206 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
207 struct omap_runtime_data
*prtd
= runtime
->private_data
;
208 struct omap_pcm_dma_data
*dma_data
= prtd
->dma_data
;
212 spin_lock_irqsave(&prtd
->lock
, flags
);
214 case SNDRV_PCM_TRIGGER_RESUME
:
215 /* Reconfigure DMA transfer parameters
216 * in order to come back from OFF mode
218 omap_pcm_prepare(substream
);
220 case SNDRV_PCM_TRIGGER_START
:
221 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
222 prtd
->period_index
= 0;
223 /* Configure McBSP internal buffer usage */
224 if (dma_data
->set_threshold
)
225 dma_data
->set_threshold(substream
);
227 omap_start_dma(prtd
->dma_ch
);
230 case SNDRV_PCM_TRIGGER_STOP
:
231 case SNDRV_PCM_TRIGGER_SUSPEND
:
232 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
233 prtd
->period_index
= -1;
234 omap_stop_dma(prtd
->dma_ch
);
239 spin_unlock_irqrestore(&prtd
->lock
, flags
);
244 static snd_pcm_uframes_t
omap_pcm_pointer(struct snd_pcm_substream
*substream
)
246 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
247 struct omap_runtime_data
*prtd
= runtime
->private_data
;
249 snd_pcm_uframes_t offset
;
251 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
) {
252 ptr
= omap_get_dma_dst_pos(prtd
->dma_ch
);
253 offset
= bytes_to_frames(runtime
, ptr
- runtime
->dma_addr
);
254 } else if (!(cpu_is_omap1510())) {
255 ptr
= omap_get_dma_src_pos(prtd
->dma_ch
);
256 offset
= bytes_to_frames(runtime
, ptr
- runtime
->dma_addr
);
258 offset
= prtd
->period_index
* runtime
->period_size
;
260 if (offset
>= runtime
->buffer_size
)
266 static int omap_pcm_open(struct snd_pcm_substream
*substream
)
268 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
269 struct omap_runtime_data
*prtd
;
272 snd_soc_set_runtime_hwparams(substream
, &omap_pcm_hardware
);
274 /* Ensure that buffer size is a multiple of period size */
275 ret
= snd_pcm_hw_constraint_integer(runtime
,
276 SNDRV_PCM_HW_PARAM_PERIODS
);
280 prtd
= kzalloc(sizeof(*prtd
), GFP_KERNEL
);
285 spin_lock_init(&prtd
->lock
);
286 runtime
->private_data
= prtd
;
292 static int omap_pcm_close(struct snd_pcm_substream
*substream
)
294 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
296 kfree(runtime
->private_data
);
300 static int omap_pcm_mmap(struct snd_pcm_substream
*substream
,
301 struct vm_area_struct
*vma
)
303 struct snd_pcm_runtime
*runtime
= substream
->runtime
;
305 return dma_mmap_writecombine(substream
->pcm
->card
->dev
, vma
,
311 static struct snd_pcm_ops omap_pcm_ops
= {
312 .open
= omap_pcm_open
,
313 .close
= omap_pcm_close
,
314 .ioctl
= snd_pcm_lib_ioctl
,
315 .hw_params
= omap_pcm_hw_params
,
316 .hw_free
= omap_pcm_hw_free
,
317 .prepare
= omap_pcm_prepare
,
318 .trigger
= omap_pcm_trigger
,
319 .pointer
= omap_pcm_pointer
,
320 .mmap
= omap_pcm_mmap
,
323 static u64 omap_pcm_dmamask
= DMA_BIT_MASK(64);
325 static int omap_pcm_preallocate_dma_buffer(struct snd_pcm
*pcm
,
328 struct snd_pcm_substream
*substream
= pcm
->streams
[stream
].substream
;
329 struct snd_dma_buffer
*buf
= &substream
->dma_buffer
;
330 size_t size
= omap_pcm_hardware
.buffer_bytes_max
;
332 buf
->dev
.type
= SNDRV_DMA_TYPE_DEV
;
333 buf
->dev
.dev
= pcm
->card
->dev
;
334 buf
->private_data
= NULL
;
335 buf
->area
= dma_alloc_writecombine(pcm
->card
->dev
, size
,
336 &buf
->addr
, GFP_KERNEL
);
344 static void omap_pcm_free_dma_buffers(struct snd_pcm
*pcm
)
346 struct snd_pcm_substream
*substream
;
347 struct snd_dma_buffer
*buf
;
350 for (stream
= 0; stream
< 2; stream
++) {
351 substream
= pcm
->streams
[stream
].substream
;
355 buf
= &substream
->dma_buffer
;
359 dma_free_writecombine(pcm
->card
->dev
, buf
->bytes
,
360 buf
->area
, buf
->addr
);
365 static int omap_pcm_new(struct snd_card
*card
, struct snd_soc_dai
*dai
,
370 if (!card
->dev
->dma_mask
)
371 card
->dev
->dma_mask
= &omap_pcm_dmamask
;
372 if (!card
->dev
->coherent_dma_mask
)
373 card
->dev
->coherent_dma_mask
= DMA_BIT_MASK(64);
375 if (dai
->playback
.channels_min
) {
376 ret
= omap_pcm_preallocate_dma_buffer(pcm
,
377 SNDRV_PCM_STREAM_PLAYBACK
);
382 if (dai
->capture
.channels_min
) {
383 ret
= omap_pcm_preallocate_dma_buffer(pcm
,
384 SNDRV_PCM_STREAM_CAPTURE
);
393 struct snd_soc_platform omap_soc_platform
= {
394 .name
= "omap-pcm-audio",
395 .pcm_ops
= &omap_pcm_ops
,
396 .pcm_new
= omap_pcm_new
,
397 .pcm_free
= omap_pcm_free_dma_buffers
,
399 EXPORT_SYMBOL_GPL(omap_soc_platform
);
401 static int __init
omap_soc_platform_init(void)
403 return snd_soc_register_platform(&omap_soc_platform
);
405 module_init(omap_soc_platform_init
);
407 static void __exit
omap_soc_platform_exit(void)
409 snd_soc_unregister_platform(&omap_soc_platform
);
411 module_exit(omap_soc_platform_exit
);
413 MODULE_AUTHOR("Jarkko Nikula <jhnikula@gmail.com>");
414 MODULE_DESCRIPTION("OMAP PCM DMA module");
415 MODULE_LICENSE("GPL");