Linux Audio

Check our new training course

Loading...
v5.4
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3 *  Copyright (C) 2012, Analog Devices Inc.
  4 *	Author: Lars-Peter Clausen <lars@metafoo.de>
  5 *
  6 *  Based on:
  7 *	imx-pcm-dma-mx2.c, Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
  8 *	mxs-pcm.c, Copyright (C) 2011 Freescale Semiconductor, Inc.
  9 *	ep93xx-pcm.c, Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
 10 *		      Copyright (C) 2006 Applied Data Systems
 
 
 
 
 
 
 
 
 
 
 11 */
 12#include <linux/module.h>
 13#include <linux/init.h>
 14#include <linux/dmaengine.h>
 15#include <linux/slab.h>
 16#include <sound/pcm.h>
 17#include <sound/pcm_params.h>
 18#include <sound/soc.h>
 19
 20#include <sound/dmaengine_pcm.h>
 21
 22struct dmaengine_pcm_runtime_data {
 23	struct dma_chan *dma_chan;
 24	dma_cookie_t cookie;
 25
 26	unsigned int pos;
 27};
 28
 29static inline struct dmaengine_pcm_runtime_data *substream_to_prtd(
 30	const struct snd_pcm_substream *substream)
 31{
 32	return substream->runtime->private_data;
 33}
 34
 35struct dma_chan *snd_dmaengine_pcm_get_chan(struct snd_pcm_substream *substream)
 36{
 37	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
 38
 39	return prtd->dma_chan;
 40}
 41EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_get_chan);
 42
 43/**
 44 * snd_hwparams_to_dma_slave_config - Convert hw_params to dma_slave_config
 45 * @substream: PCM substream
 46 * @params: hw_params
 47 * @slave_config: DMA slave config
 48 *
 49 * This function can be used to initialize a dma_slave_config from a substream
 50 * and hw_params in a dmaengine based PCM driver implementation.
 51 */
 52int snd_hwparams_to_dma_slave_config(const struct snd_pcm_substream *substream,
 53	const struct snd_pcm_hw_params *params,
 54	struct dma_slave_config *slave_config)
 55{
 56	enum dma_slave_buswidth buswidth;
 57	int bits;
 58
 59	bits = params_physical_width(params);
 60	if (bits < 8 || bits > 64)
 61		return -EINVAL;
 62	else if (bits == 8)
 63		buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
 64	else if (bits == 16)
 65		buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
 66	else if (bits == 24)
 67		buswidth = DMA_SLAVE_BUSWIDTH_3_BYTES;
 68	else if (bits <= 32)
 69		buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
 70	else
 71		buswidth = DMA_SLAVE_BUSWIDTH_8_BYTES;
 72
 73	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 74		slave_config->direction = DMA_MEM_TO_DEV;
 75		slave_config->dst_addr_width = buswidth;
 76	} else {
 77		slave_config->direction = DMA_DEV_TO_MEM;
 78		slave_config->src_addr_width = buswidth;
 79	}
 80
 81	slave_config->device_fc = false;
 82
 83	return 0;
 84}
 85EXPORT_SYMBOL_GPL(snd_hwparams_to_dma_slave_config);
 86
 87/**
 88 * snd_dmaengine_pcm_set_config_from_dai_data() - Initializes a dma slave config
 89 *  using DAI DMA data.
 90 * @substream: PCM substream
 91 * @dma_data: DAI DMA data
 92 * @slave_config: DMA slave configuration
 93 *
 94 * Initializes the {dst,src}_addr, {dst,src}_maxburst, {dst,src}_addr_width and
 95 * slave_id fields of the DMA slave config from the same fields of the DAI DMA
 96 * data struct. The src and dst fields will be initialized depending on the
 97 * direction of the substream. If the substream is a playback stream the dst
 98 * fields will be initialized, if it is a capture stream the src fields will be
 99 * initialized. The {dst,src}_addr_width field will only be initialized if the
100 * SND_DMAENGINE_PCM_DAI_FLAG_PACK flag is set or if the addr_width field of
101 * the DAI DMA data struct is not equal to DMA_SLAVE_BUSWIDTH_UNDEFINED. If
102 * both conditions are met the latter takes priority.
103 */
104void snd_dmaengine_pcm_set_config_from_dai_data(
105	const struct snd_pcm_substream *substream,
106	const struct snd_dmaengine_dai_dma_data *dma_data,
107	struct dma_slave_config *slave_config)
108{
109	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
110		slave_config->dst_addr = dma_data->addr;
111		slave_config->dst_maxburst = dma_data->maxburst;
112		if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
113			slave_config->dst_addr_width =
114				DMA_SLAVE_BUSWIDTH_UNDEFINED;
115		if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
116			slave_config->dst_addr_width = dma_data->addr_width;
117	} else {
118		slave_config->src_addr = dma_data->addr;
119		slave_config->src_maxburst = dma_data->maxburst;
120		if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
121			slave_config->src_addr_width =
122				DMA_SLAVE_BUSWIDTH_UNDEFINED;
123		if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
124			slave_config->src_addr_width = dma_data->addr_width;
125	}
126
127	slave_config->slave_id = dma_data->slave_id;
128}
129EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_set_config_from_dai_data);
130
131static void dmaengine_pcm_dma_complete(void *arg)
132{
133	struct snd_pcm_substream *substream = arg;
134	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
135
136	prtd->pos += snd_pcm_lib_period_bytes(substream);
137	if (prtd->pos >= snd_pcm_lib_buffer_bytes(substream))
138		prtd->pos = 0;
139
140	snd_pcm_period_elapsed(substream);
141}
142
143static int dmaengine_pcm_prepare_and_submit(struct snd_pcm_substream *substream)
144{
145	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
146	struct dma_chan *chan = prtd->dma_chan;
147	struct dma_async_tx_descriptor *desc;
148	enum dma_transfer_direction direction;
149	unsigned long flags = DMA_CTRL_ACK;
150
151	direction = snd_pcm_substream_to_dma_direction(substream);
152
153	if (!substream->runtime->no_period_wakeup)
154		flags |= DMA_PREP_INTERRUPT;
155
156	prtd->pos = 0;
157	desc = dmaengine_prep_dma_cyclic(chan,
158		substream->runtime->dma_addr,
159		snd_pcm_lib_buffer_bytes(substream),
160		snd_pcm_lib_period_bytes(substream), direction, flags);
161
162	if (!desc)
163		return -ENOMEM;
164
165	desc->callback = dmaengine_pcm_dma_complete;
166	desc->callback_param = substream;
167	prtd->cookie = dmaengine_submit(desc);
168
169	return 0;
170}
171
172/**
173 * snd_dmaengine_pcm_trigger - dmaengine based PCM trigger implementation
174 * @substream: PCM substream
175 * @cmd: Trigger command
176 *
177 * Returns 0 on success, a negative error code otherwise.
178 *
179 * This function can be used as the PCM trigger callback for dmaengine based PCM
180 * driver implementations.
181 */
182int snd_dmaengine_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
183{
184	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
185	struct snd_pcm_runtime *runtime = substream->runtime;
186	int ret;
187
188	switch (cmd) {
189	case SNDRV_PCM_TRIGGER_START:
190		ret = dmaengine_pcm_prepare_and_submit(substream);
191		if (ret)
192			return ret;
193		dma_async_issue_pending(prtd->dma_chan);
194		break;
195	case SNDRV_PCM_TRIGGER_RESUME:
196	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
197		dmaengine_resume(prtd->dma_chan);
198		break;
199	case SNDRV_PCM_TRIGGER_SUSPEND:
200		if (runtime->info & SNDRV_PCM_INFO_PAUSE)
201			dmaengine_pause(prtd->dma_chan);
202		else
203			dmaengine_terminate_async(prtd->dma_chan);
204		break;
205	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
206		dmaengine_pause(prtd->dma_chan);
207		break;
208	case SNDRV_PCM_TRIGGER_STOP:
209		dmaengine_terminate_async(prtd->dma_chan);
210		break;
211	default:
212		return -EINVAL;
213	}
214
215	return 0;
216}
217EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_trigger);
218
219/**
220 * snd_dmaengine_pcm_pointer_no_residue - dmaengine based PCM pointer implementation
221 * @substream: PCM substream
222 *
223 * This function is deprecated and should not be used by new drivers, as its
224 * results may be unreliable.
225 */
226snd_pcm_uframes_t snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream *substream)
227{
228	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
229	return bytes_to_frames(substream->runtime, prtd->pos);
230}
231EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer_no_residue);
232
233/**
234 * snd_dmaengine_pcm_pointer - dmaengine based PCM pointer implementation
235 * @substream: PCM substream
236 *
237 * This function can be used as the PCM pointer callback for dmaengine based PCM
238 * driver implementations.
239 */
240snd_pcm_uframes_t snd_dmaengine_pcm_pointer(struct snd_pcm_substream *substream)
241{
242	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
243	struct dma_tx_state state;
244	enum dma_status status;
245	unsigned int buf_size;
246	unsigned int pos = 0;
247
248	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
249	if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
250		buf_size = snd_pcm_lib_buffer_bytes(substream);
251		if (state.residue > 0 && state.residue <= buf_size)
252			pos = buf_size - state.residue;
253	}
254
255	return bytes_to_frames(substream->runtime, pos);
256}
257EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer);
258
259/**
260 * snd_dmaengine_pcm_request_channel - Request channel for the dmaengine PCM
261 * @filter_fn: Filter function used to request the DMA channel
262 * @filter_data: Data passed to the DMA filter function
263 *
264 * Returns NULL or the requested DMA channel.
265 *
266 * This function request a DMA channel for usage with dmaengine PCM.
267 */
268struct dma_chan *snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn,
269	void *filter_data)
270{
271	dma_cap_mask_t mask;
272
273	dma_cap_zero(mask);
274	dma_cap_set(DMA_SLAVE, mask);
275	dma_cap_set(DMA_CYCLIC, mask);
276
277	return dma_request_channel(mask, filter_fn, filter_data);
278}
279EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_request_channel);
280
281/**
282 * snd_dmaengine_pcm_open - Open a dmaengine based PCM substream
283 * @substream: PCM substream
284 * @chan: DMA channel to use for data transfers
285 *
286 * Returns 0 on success, a negative error code otherwise.
287 *
288 * The function should usually be called from the pcm open callback. Note that
289 * this function will use private_data field of the substream's runtime. So it
290 * is not available to your pcm driver implementation.
291 */
292int snd_dmaengine_pcm_open(struct snd_pcm_substream *substream,
293	struct dma_chan *chan)
294{
295	struct dmaengine_pcm_runtime_data *prtd;
296	int ret;
297
298	if (!chan)
299		return -ENXIO;
300
301	ret = snd_pcm_hw_constraint_integer(substream->runtime,
302					    SNDRV_PCM_HW_PARAM_PERIODS);
303	if (ret < 0)
304		return ret;
305
306	prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
307	if (!prtd)
308		return -ENOMEM;
309
310	prtd->dma_chan = chan;
311
312	substream->runtime->private_data = prtd;
313
314	return 0;
315}
316EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open);
317
318/**
319 * snd_dmaengine_pcm_open_request_chan - Open a dmaengine based PCM substream and request channel
320 * @substream: PCM substream
321 * @filter_fn: Filter function used to request the DMA channel
322 * @filter_data: Data passed to the DMA filter function
323 *
324 * Returns 0 on success, a negative error code otherwise.
325 *
326 * This function will request a DMA channel using the passed filter function and
327 * data. The function should usually be called from the pcm open callback. Note
328 * that this function will use private_data field of the substream's runtime. So
329 * it is not available to your pcm driver implementation.
330 */
331int snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream *substream,
332	dma_filter_fn filter_fn, void *filter_data)
333{
334	return snd_dmaengine_pcm_open(substream,
335		    snd_dmaengine_pcm_request_channel(filter_fn, filter_data));
336}
337EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open_request_chan);
338
339/**
340 * snd_dmaengine_pcm_close - Close a dmaengine based PCM substream
341 * @substream: PCM substream
342 */
343int snd_dmaengine_pcm_close(struct snd_pcm_substream *substream)
344{
345	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
346
347	dmaengine_synchronize(prtd->dma_chan);
348	kfree(prtd);
349
350	return 0;
351}
352EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close);
353
354/**
355 * snd_dmaengine_pcm_release_chan_close - Close a dmaengine based PCM substream and release channel
356 * @substream: PCM substream
357 *
358 * Releases the DMA channel associated with the PCM substream.
359 */
360int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream *substream)
361{
362	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
363
364	dmaengine_synchronize(prtd->dma_chan);
365	dma_release_channel(prtd->dma_chan);
366	kfree(prtd);
367
368	return 0;
369}
370EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close_release_chan);
371
372MODULE_LICENSE("GPL");
v4.6
 
  1/*
  2 *  Copyright (C) 2012, Analog Devices Inc.
  3 *	Author: Lars-Peter Clausen <lars@metafoo.de>
  4 *
  5 *  Based on:
  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
 10 *
 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.
 15 *
 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.
 19 *
 20 */
 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>
 28
 29#include <sound/dmaengine_pcm.h>
 30
 31struct dmaengine_pcm_runtime_data {
 32	struct dma_chan *dma_chan;
 33	dma_cookie_t cookie;
 34
 35	unsigned int pos;
 36};
 37
 38static inline struct dmaengine_pcm_runtime_data *substream_to_prtd(
 39	const struct snd_pcm_substream *substream)
 40{
 41	return substream->runtime->private_data;
 42}
 43
 44struct dma_chan *snd_dmaengine_pcm_get_chan(struct snd_pcm_substream *substream)
 45{
 46	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
 47
 48	return prtd->dma_chan;
 49}
 50EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_get_chan);
 51
 52/**
 53 * snd_hwparams_to_dma_slave_config - Convert hw_params to dma_slave_config
 54 * @substream: PCM substream
 55 * @params: hw_params
 56 * @slave_config: DMA slave config
 57 *
 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.
 60 */
 61int 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)
 64{
 65	enum dma_slave_buswidth buswidth;
 66	int bits;
 67
 68	bits = params_physical_width(params);
 69	if (bits < 8 || bits > 64)
 70		return -EINVAL;
 71	else if (bits == 8)
 72		buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
 73	else if (bits == 16)
 74		buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
 75	else if (bits == 24)
 76		buswidth = DMA_SLAVE_BUSWIDTH_3_BYTES;
 77	else if (bits <= 32)
 78		buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
 79	else
 80		buswidth = DMA_SLAVE_BUSWIDTH_8_BYTES;
 81
 82	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 83		slave_config->direction = DMA_MEM_TO_DEV;
 84		slave_config->dst_addr_width = buswidth;
 85	} else {
 86		slave_config->direction = DMA_DEV_TO_MEM;
 87		slave_config->src_addr_width = buswidth;
 88	}
 89
 90	slave_config->device_fc = false;
 91
 92	return 0;
 93}
 94EXPORT_SYMBOL_GPL(snd_hwparams_to_dma_slave_config);
 95
 96/**
 97 * snd_dmaengine_pcm_set_config_from_dai_data() - Initializes a dma slave config
 98 *  using DAI DMA data.
 99 * @substream: PCM substream
100 * @dma_data: DAI DMA data
101 * @slave_config: DMA slave configuration
102 *
103 * Initializes the {dst,src}_addr, {dst,src}_maxburst, {dst,src}_addr_width and
104 * slave_id fields of the DMA slave config from the same fields of the DAI DMA
105 * data struct. The src and dst fields will be initialized depending on the
106 * direction of the substream. If the substream is a playback stream the dst
107 * fields will be initialized, if it is a capture stream the src fields will be
108 * initialized. The {dst,src}_addr_width field will only be initialized if the
109 * addr_width field of the DAI DMA data struct is not equal to
110 * DMA_SLAVE_BUSWIDTH_UNDEFINED.
 
111 */
112void snd_dmaengine_pcm_set_config_from_dai_data(
113	const struct snd_pcm_substream *substream,
114	const struct snd_dmaengine_dai_dma_data *dma_data,
115	struct dma_slave_config *slave_config)
116{
117	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
118		slave_config->dst_addr = dma_data->addr;
119		slave_config->dst_maxburst = dma_data->maxburst;
 
 
 
120		if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
121			slave_config->dst_addr_width = dma_data->addr_width;
122	} else {
123		slave_config->src_addr = dma_data->addr;
124		slave_config->src_maxburst = dma_data->maxburst;
 
 
 
125		if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
126			slave_config->src_addr_width = dma_data->addr_width;
127	}
128
129	slave_config->slave_id = dma_data->slave_id;
130}
131EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_set_config_from_dai_data);
132
133static void dmaengine_pcm_dma_complete(void *arg)
134{
135	struct snd_pcm_substream *substream = arg;
136	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
137
138	prtd->pos += snd_pcm_lib_period_bytes(substream);
139	if (prtd->pos >= snd_pcm_lib_buffer_bytes(substream))
140		prtd->pos = 0;
141
142	snd_pcm_period_elapsed(substream);
143}
144
145static int dmaengine_pcm_prepare_and_submit(struct snd_pcm_substream *substream)
146{
147	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
148	struct dma_chan *chan = prtd->dma_chan;
149	struct dma_async_tx_descriptor *desc;
150	enum dma_transfer_direction direction;
151	unsigned long flags = DMA_CTRL_ACK;
152
153	direction = snd_pcm_substream_to_dma_direction(substream);
154
155	if (!substream->runtime->no_period_wakeup)
156		flags |= DMA_PREP_INTERRUPT;
157
158	prtd->pos = 0;
159	desc = dmaengine_prep_dma_cyclic(chan,
160		substream->runtime->dma_addr,
161		snd_pcm_lib_buffer_bytes(substream),
162		snd_pcm_lib_period_bytes(substream), direction, flags);
163
164	if (!desc)
165		return -ENOMEM;
166
167	desc->callback = dmaengine_pcm_dma_complete;
168	desc->callback_param = substream;
169	prtd->cookie = dmaengine_submit(desc);
170
171	return 0;
172}
173
174/**
175 * snd_dmaengine_pcm_trigger - dmaengine based PCM trigger implementation
176 * @substream: PCM substream
177 * @cmd: Trigger command
178 *
179 * Returns 0 on success, a negative error code otherwise.
180 *
181 * This function can be used as the PCM trigger callback for dmaengine based PCM
182 * driver implementations.
183 */
184int snd_dmaengine_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
185{
186	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
187	struct snd_pcm_runtime *runtime = substream->runtime;
188	int ret;
189
190	switch (cmd) {
191	case SNDRV_PCM_TRIGGER_START:
192		ret = dmaengine_pcm_prepare_and_submit(substream);
193		if (ret)
194			return ret;
195		dma_async_issue_pending(prtd->dma_chan);
196		break;
197	case SNDRV_PCM_TRIGGER_RESUME:
198	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
199		dmaengine_resume(prtd->dma_chan);
200		break;
201	case SNDRV_PCM_TRIGGER_SUSPEND:
202		if (runtime->info & SNDRV_PCM_INFO_PAUSE)
203			dmaengine_pause(prtd->dma_chan);
204		else
205			dmaengine_terminate_async(prtd->dma_chan);
206		break;
207	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
208		dmaengine_pause(prtd->dma_chan);
209		break;
210	case SNDRV_PCM_TRIGGER_STOP:
211		dmaengine_terminate_async(prtd->dma_chan);
212		break;
213	default:
214		return -EINVAL;
215	}
216
217	return 0;
218}
219EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_trigger);
220
221/**
222 * snd_dmaengine_pcm_pointer_no_residue - dmaengine based PCM pointer implementation
223 * @substream: PCM substream
224 *
225 * This function is deprecated and should not be used by new drivers, as its
226 * results may be unreliable.
227 */
228snd_pcm_uframes_t snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream *substream)
229{
230	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
231	return bytes_to_frames(substream->runtime, prtd->pos);
232}
233EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer_no_residue);
234
235/**
236 * snd_dmaengine_pcm_pointer - dmaengine based PCM pointer implementation
237 * @substream: PCM substream
238 *
239 * This function can be used as the PCM pointer callback for dmaengine based PCM
240 * driver implementations.
241 */
242snd_pcm_uframes_t snd_dmaengine_pcm_pointer(struct snd_pcm_substream *substream)
243{
244	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
245	struct dma_tx_state state;
246	enum dma_status status;
247	unsigned int buf_size;
248	unsigned int pos = 0;
249
250	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
251	if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
252		buf_size = snd_pcm_lib_buffer_bytes(substream);
253		if (state.residue > 0 && state.residue <= buf_size)
254			pos = buf_size - state.residue;
255	}
256
257	return bytes_to_frames(substream->runtime, pos);
258}
259EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer);
260
261/**
262 * snd_dmaengine_pcm_request_channel - Request channel for the dmaengine PCM
263 * @filter_fn: Filter function used to request the DMA channel
264 * @filter_data: Data passed to the DMA filter function
265 *
266 * Returns NULL or the requested DMA channel.
267 *
268 * This function request a DMA channel for usage with dmaengine PCM.
269 */
270struct dma_chan *snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn,
271	void *filter_data)
272{
273	dma_cap_mask_t mask;
274
275	dma_cap_zero(mask);
276	dma_cap_set(DMA_SLAVE, mask);
277	dma_cap_set(DMA_CYCLIC, mask);
278
279	return dma_request_channel(mask, filter_fn, filter_data);
280}
281EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_request_channel);
282
283/**
284 * snd_dmaengine_pcm_open - Open a dmaengine based PCM substream
285 * @substream: PCM substream
286 * @chan: DMA channel to use for data transfers
287 *
288 * Returns 0 on success, a negative error code otherwise.
289 *
290 * The function should usually be called from the pcm open callback. Note that
291 * this function will use private_data field of the substream's runtime. So it
292 * is not available to your pcm driver implementation.
293 */
294int snd_dmaengine_pcm_open(struct snd_pcm_substream *substream,
295	struct dma_chan *chan)
296{
297	struct dmaengine_pcm_runtime_data *prtd;
298	int ret;
299
300	if (!chan)
301		return -ENXIO;
302
303	ret = snd_pcm_hw_constraint_integer(substream->runtime,
304					    SNDRV_PCM_HW_PARAM_PERIODS);
305	if (ret < 0)
306		return ret;
307
308	prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
309	if (!prtd)
310		return -ENOMEM;
311
312	prtd->dma_chan = chan;
313
314	substream->runtime->private_data = prtd;
315
316	return 0;
317}
318EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open);
319
320/**
321 * snd_dmaengine_pcm_open_request_chan - Open a dmaengine based PCM substream and request channel
322 * @substream: PCM substream
323 * @filter_fn: Filter function used to request the DMA channel
324 * @filter_data: Data passed to the DMA filter function
325 *
326 * Returns 0 on success, a negative error code otherwise.
327 *
328 * This function will request a DMA channel using the passed filter function and
329 * data. The function should usually be called from the pcm open callback. Note
330 * that this function will use private_data field of the substream's runtime. So
331 * it is not available to your pcm driver implementation.
332 */
333int snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream *substream,
334	dma_filter_fn filter_fn, void *filter_data)
335{
336	return snd_dmaengine_pcm_open(substream,
337		    snd_dmaengine_pcm_request_channel(filter_fn, filter_data));
338}
339EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open_request_chan);
340
341/**
342 * snd_dmaengine_pcm_close - Close a dmaengine based PCM substream
343 * @substream: PCM substream
344 */
345int snd_dmaengine_pcm_close(struct snd_pcm_substream *substream)
346{
347	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
348
349	dmaengine_synchronize(prtd->dma_chan);
350	kfree(prtd);
351
352	return 0;
353}
354EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close);
355
356/**
357 * snd_dmaengine_pcm_release_chan_close - Close a dmaengine based PCM substream and release channel
358 * @substream: PCM substream
359 *
360 * Releases the DMA channel associated with the PCM substream.
361 */
362int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream *substream)
363{
364	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
365
366	dmaengine_synchronize(prtd->dma_chan);
367	dma_release_channel(prtd->dma_chan);
368	kfree(prtd);
369
370	return 0;
371}
372EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close_release_chan);
373
374MODULE_LICENSE("GPL");