2 * Copyright (C) 2012, Analog Devices Inc.
3 * Author: Lars-Peter Clausen <lars@metafoo.de>
6 * imx-pcm-dma-mx2.c, Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
7 * mxs-pcm.c, Copyright (C) 2011 Freescale Semiconductor, Inc.
8 * ep93xx-pcm.c, Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
9 * Copyright (C) 2006 Applied Data Systems
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.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 675 Mass Ave, Cambridge, MA 02139, USA.
21 #include <linux/module.h>
22 #include <linux/init.h>
23 #include <linux/dmaengine.h>
24 #include <linux/slab.h>
25 #include <sound/pcm.h>
26 #include <sound/pcm_params.h>
27 #include <sound/soc.h>
29 #include <sound/dmaengine_pcm.h>
31 struct dmaengine_pcm_runtime_data
{
32 struct dma_chan
*dma_chan
;
38 static inline struct dmaengine_pcm_runtime_data
*substream_to_prtd(
39 const struct snd_pcm_substream
*substream
)
41 return substream
->runtime
->private_data
;
44 struct dma_chan
*snd_dmaengine_pcm_get_chan(struct snd_pcm_substream
*substream
)
46 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
48 return prtd
->dma_chan
;
50 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_get_chan
);
53 * snd_hwparams_to_dma_slave_config - Convert hw_params to dma_slave_config
54 * @substream: PCM substream
56 * @slave_config: DMA slave config
58 * This function can be used to initialize a dma_slave_config from a substream
59 * and hw_params in a dmaengine based PCM driver implementation.
61 int snd_hwparams_to_dma_slave_config(const struct snd_pcm_substream
*substream
,
62 const struct snd_pcm_hw_params
*params
,
63 struct dma_slave_config
*slave_config
)
65 enum dma_slave_buswidth buswidth
;
67 switch (params_format(params
)) {
68 case SNDRV_PCM_FORMAT_S8
:
69 buswidth
= DMA_SLAVE_BUSWIDTH_1_BYTE
;
71 case SNDRV_PCM_FORMAT_S16_LE
:
72 buswidth
= DMA_SLAVE_BUSWIDTH_2_BYTES
;
74 case SNDRV_PCM_FORMAT_S18_3LE
:
75 case SNDRV_PCM_FORMAT_S20_3LE
:
76 case SNDRV_PCM_FORMAT_S24_LE
:
77 case SNDRV_PCM_FORMAT_S32_LE
:
78 buswidth
= DMA_SLAVE_BUSWIDTH_4_BYTES
;
84 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
85 slave_config
->direction
= DMA_MEM_TO_DEV
;
86 slave_config
->dst_addr_width
= buswidth
;
88 slave_config
->direction
= DMA_DEV_TO_MEM
;
89 slave_config
->src_addr_width
= buswidth
;
92 slave_config
->device_fc
= false;
96 EXPORT_SYMBOL_GPL(snd_hwparams_to_dma_slave_config
);
99 * snd_dmaengine_pcm_set_config_from_dai_data() - Initializes a dma slave config
100 * using DAI DMA data.
101 * @substream: PCM substream
102 * @dma_data: DAI DMA data
103 * @slave_config: DMA slave configuration
105 * Initializes the {dst,src}_addr, {dst,src}_maxburst, {dst,src}_addr_width and
106 * slave_id fields of the DMA slave config from the same fields of the DAI DMA
107 * data struct. The src and dst fields will be initialized depending on the
108 * direction of the substream. If the substream is a playback stream the dst
109 * fields will be initialized, if it is a capture stream the src fields will be
110 * initialized. The {dst,src}_addr_width field will only be initialized if the
111 * addr_width field of the DAI DMA data struct is not equal to
112 * DMA_SLAVE_BUSWIDTH_UNDEFINED.
114 void snd_dmaengine_pcm_set_config_from_dai_data(
115 const struct snd_pcm_substream
*substream
,
116 const struct snd_dmaengine_dai_dma_data
*dma_data
,
117 struct dma_slave_config
*slave_config
)
119 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
120 slave_config
->dst_addr
= dma_data
->addr
;
121 slave_config
->dst_maxburst
= dma_data
->maxburst
;
122 if (dma_data
->addr_width
!= DMA_SLAVE_BUSWIDTH_UNDEFINED
)
123 slave_config
->dst_addr_width
= dma_data
->addr_width
;
125 slave_config
->src_addr
= dma_data
->addr
;
126 slave_config
->src_maxburst
= dma_data
->maxburst
;
127 if (dma_data
->addr_width
!= DMA_SLAVE_BUSWIDTH_UNDEFINED
)
128 slave_config
->src_addr_width
= dma_data
->addr_width
;
131 slave_config
->slave_id
= dma_data
->slave_id
;
133 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_set_config_from_dai_data
);
135 static void dmaengine_pcm_dma_complete(void *arg
)
137 struct snd_pcm_substream
*substream
= arg
;
138 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
140 prtd
->pos
+= snd_pcm_lib_period_bytes(substream
);
141 if (prtd
->pos
>= snd_pcm_lib_buffer_bytes(substream
))
144 snd_pcm_period_elapsed(substream
);
147 static int dmaengine_pcm_prepare_and_submit(struct snd_pcm_substream
*substream
)
149 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
150 struct dma_chan
*chan
= prtd
->dma_chan
;
151 struct dma_async_tx_descriptor
*desc
;
152 enum dma_transfer_direction direction
;
153 unsigned long flags
= DMA_CTRL_ACK
;
155 direction
= snd_pcm_substream_to_dma_direction(substream
);
157 if (!substream
->runtime
->no_period_wakeup
)
158 flags
|= DMA_PREP_INTERRUPT
;
161 desc
= dmaengine_prep_dma_cyclic(chan
,
162 substream
->runtime
->dma_addr
,
163 snd_pcm_lib_buffer_bytes(substream
),
164 snd_pcm_lib_period_bytes(substream
), direction
, flags
);
169 desc
->callback
= dmaengine_pcm_dma_complete
;
170 desc
->callback_param
= substream
;
171 prtd
->cookie
= dmaengine_submit(desc
);
177 * snd_dmaengine_pcm_trigger - dmaengine based PCM trigger implementation
178 * @substream: PCM substream
179 * @cmd: Trigger command
181 * Returns 0 on success, a negative error code otherwise.
183 * This function can be used as the PCM trigger callback for dmaengine based PCM
184 * driver implementations.
186 int snd_dmaengine_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
)
188 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
192 case SNDRV_PCM_TRIGGER_START
:
193 ret
= dmaengine_pcm_prepare_and_submit(substream
);
196 dma_async_issue_pending(prtd
->dma_chan
);
198 case SNDRV_PCM_TRIGGER_RESUME
:
199 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
200 dmaengine_resume(prtd
->dma_chan
);
202 case SNDRV_PCM_TRIGGER_SUSPEND
:
203 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
204 dmaengine_pause(prtd
->dma_chan
);
206 case SNDRV_PCM_TRIGGER_STOP
:
207 dmaengine_terminate_all(prtd
->dma_chan
);
215 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_trigger
);
218 * snd_dmaengine_pcm_pointer_no_residue - dmaengine based PCM pointer implementation
219 * @substream: PCM substream
221 * This function is deprecated and should not be used by new drivers, as its
222 * results may be unreliable.
224 snd_pcm_uframes_t
snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream
*substream
)
226 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
227 return bytes_to_frames(substream
->runtime
, prtd
->pos
);
229 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer_no_residue
);
232 * snd_dmaengine_pcm_pointer - dmaengine based PCM pointer implementation
233 * @substream: PCM substream
235 * This function can be used as the PCM pointer callback for dmaengine based PCM
236 * driver implementations.
238 snd_pcm_uframes_t
snd_dmaengine_pcm_pointer(struct snd_pcm_substream
*substream
)
240 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
241 struct dma_tx_state state
;
242 enum dma_status status
;
243 unsigned int buf_size
;
244 unsigned int pos
= 0;
246 status
= dmaengine_tx_status(prtd
->dma_chan
, prtd
->cookie
, &state
);
247 if (status
== DMA_IN_PROGRESS
|| status
== DMA_PAUSED
) {
248 buf_size
= snd_pcm_lib_buffer_bytes(substream
);
249 if (state
.residue
> 0 && state
.residue
<= buf_size
)
250 pos
= buf_size
- state
.residue
;
253 return bytes_to_frames(substream
->runtime
, pos
);
255 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer
);
258 * snd_dmaengine_pcm_request_channel - Request channel for the dmaengine PCM
259 * @filter_fn: Filter function used to request the DMA channel
260 * @filter_data: Data passed to the DMA filter function
262 * Returns NULL or the requested DMA channel.
264 * This function request a DMA channel for usage with dmaengine PCM.
266 struct dma_chan
*snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn
,
272 dma_cap_set(DMA_SLAVE
, mask
);
273 dma_cap_set(DMA_CYCLIC
, mask
);
275 return dma_request_channel(mask
, filter_fn
, filter_data
);
277 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_request_channel
);
280 * snd_dmaengine_pcm_open - Open a dmaengine based PCM substream
281 * @substream: PCM substream
282 * @chan: DMA channel to use for data transfers
284 * Returns 0 on success, a negative error code otherwise.
286 * The function should usually be called from the pcm open callback. Note that
287 * this function will use private_data field of the substream's runtime. So it
288 * is not availabe to your pcm driver implementation.
290 int snd_dmaengine_pcm_open(struct snd_pcm_substream
*substream
,
291 struct dma_chan
*chan
)
293 struct dmaengine_pcm_runtime_data
*prtd
;
299 ret
= snd_pcm_hw_constraint_integer(substream
->runtime
,
300 SNDRV_PCM_HW_PARAM_PERIODS
);
304 prtd
= kzalloc(sizeof(*prtd
), GFP_KERNEL
);
308 prtd
->dma_chan
= chan
;
310 substream
->runtime
->private_data
= prtd
;
314 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open
);
317 * snd_dmaengine_pcm_open_request_chan - Open a dmaengine based PCM substream and request channel
318 * @substream: PCM substream
319 * @filter_fn: Filter function used to request the DMA channel
320 * @filter_data: Data passed to the DMA filter function
322 * Returns 0 on success, a negative error code otherwise.
324 * This function will request a DMA channel using the passed filter function and
325 * data. The function should usually be called from the pcm open callback. Note
326 * that this function will use private_data field of the substream's runtime. So
327 * it is not availabe to your pcm driver implementation.
329 int snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream
*substream
,
330 dma_filter_fn filter_fn
, void *filter_data
)
332 return snd_dmaengine_pcm_open(substream
,
333 snd_dmaengine_pcm_request_channel(filter_fn
, filter_data
));
335 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open_request_chan
);
338 * snd_dmaengine_pcm_close - Close a dmaengine based PCM substream
339 * @substream: PCM substream
341 int snd_dmaengine_pcm_close(struct snd_pcm_substream
*substream
)
343 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
349 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close
);
352 * snd_dmaengine_pcm_release_chan_close - Close a dmaengine based PCM substream and release channel
353 * @substream: PCM substream
355 * Releases the DMA channel associated with the PCM substream.
357 int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream
*substream
)
359 struct dmaengine_pcm_runtime_data
*prtd
= substream_to_prtd(substream
);
361 dma_release_channel(prtd
->dma_chan
);
363 return snd_dmaengine_pcm_close(substream
);
365 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close_release_chan
);
367 MODULE_LICENSE("GPL");