xref: /openbmc/linux/sound/core/pcm_dmaengine.c (revision 0dbe2b3b)
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 
22 struct dmaengine_pcm_runtime_data {
23 	struct dma_chan *dma_chan;
24 	dma_cookie_t cookie;
25 
26 	unsigned int pos;
27 };
28 
substream_to_prtd(const struct snd_pcm_substream * substream)29 static 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 
snd_dmaengine_pcm_get_chan(struct snd_pcm_substream * substream)35 struct 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 }
41 EXPORT_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  *
52  * Return: zero if successful, or a negative error code
53  */
snd_hwparams_to_dma_slave_config(const struct snd_pcm_substream * substream,const struct snd_pcm_hw_params * params,struct dma_slave_config * slave_config)54 int snd_hwparams_to_dma_slave_config(const struct snd_pcm_substream *substream,
55 	const struct snd_pcm_hw_params *params,
56 	struct dma_slave_config *slave_config)
57 {
58 	enum dma_slave_buswidth buswidth;
59 	int bits;
60 
61 	bits = params_physical_width(params);
62 	if (bits < 8 || bits > 64)
63 		return -EINVAL;
64 	else if (bits == 8)
65 		buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
66 	else if (bits == 16)
67 		buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
68 	else if (bits == 24)
69 		buswidth = DMA_SLAVE_BUSWIDTH_3_BYTES;
70 	else if (bits <= 32)
71 		buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
72 	else
73 		buswidth = DMA_SLAVE_BUSWIDTH_8_BYTES;
74 
75 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
76 		slave_config->direction = DMA_MEM_TO_DEV;
77 		slave_config->dst_addr_width = buswidth;
78 	} else {
79 		slave_config->direction = DMA_DEV_TO_MEM;
80 		slave_config->src_addr_width = buswidth;
81 	}
82 
83 	slave_config->device_fc = false;
84 
85 	return 0;
86 }
87 EXPORT_SYMBOL_GPL(snd_hwparams_to_dma_slave_config);
88 
89 /**
90  * snd_dmaengine_pcm_set_config_from_dai_data() - Initializes a dma slave config
91  *  using DAI DMA data.
92  * @substream: PCM substream
93  * @dma_data: DAI DMA data
94  * @slave_config: DMA slave configuration
95  *
96  * Initializes the {dst,src}_addr, {dst,src}_maxburst, {dst,src}_addr_width
97  * fields of the DMA slave config from the same fields of the DAI DMA
98  * data struct. The src and dst fields will be initialized depending on the
99  * direction of the substream. If the substream is a playback stream the dst
100  * fields will be initialized, if it is a capture stream the src fields will be
101  * initialized. The {dst,src}_addr_width field will only be initialized if the
102  * SND_DMAENGINE_PCM_DAI_FLAG_PACK flag is set or if the addr_width field of
103  * the DAI DMA data struct is not equal to DMA_SLAVE_BUSWIDTH_UNDEFINED. If
104  * both conditions are met the latter takes priority.
105  */
snd_dmaengine_pcm_set_config_from_dai_data(const struct snd_pcm_substream * substream,const struct snd_dmaengine_dai_dma_data * dma_data,struct dma_slave_config * slave_config)106 void snd_dmaengine_pcm_set_config_from_dai_data(
107 	const struct snd_pcm_substream *substream,
108 	const struct snd_dmaengine_dai_dma_data *dma_data,
109 	struct dma_slave_config *slave_config)
110 {
111 	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
112 		slave_config->dst_addr = dma_data->addr;
113 		slave_config->dst_maxburst = dma_data->maxburst;
114 		if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
115 			slave_config->dst_addr_width =
116 				DMA_SLAVE_BUSWIDTH_UNDEFINED;
117 		if (dma_data->addr_width != DMA_SLAVE_BUSWIDTH_UNDEFINED)
118 			slave_config->dst_addr_width = dma_data->addr_width;
119 	} else {
120 		slave_config->src_addr = dma_data->addr;
121 		slave_config->src_maxburst = dma_data->maxburst;
122 		if (dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)
123 			slave_config->src_addr_width =
124 				DMA_SLAVE_BUSWIDTH_UNDEFINED;
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->peripheral_config = dma_data->peripheral_config;
130 	slave_config->peripheral_size = dma_data->peripheral_size;
131 }
132 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_set_config_from_dai_data);
133 
dmaengine_pcm_dma_complete(void * arg)134 static void dmaengine_pcm_dma_complete(void *arg)
135 {
136 	unsigned int new_pos;
137 	struct snd_pcm_substream *substream = arg;
138 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
139 
140 	new_pos = prtd->pos + snd_pcm_lib_period_bytes(substream);
141 	if (new_pos >= snd_pcm_lib_buffer_bytes(substream))
142 		new_pos = 0;
143 	prtd->pos = new_pos;
144 
145 	snd_pcm_period_elapsed(substream);
146 }
147 
dmaengine_pcm_prepare_and_submit(struct snd_pcm_substream * substream)148 static int dmaengine_pcm_prepare_and_submit(struct snd_pcm_substream *substream)
149 {
150 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
151 	struct dma_chan *chan = prtd->dma_chan;
152 	struct dma_async_tx_descriptor *desc;
153 	enum dma_transfer_direction direction;
154 	unsigned long flags = DMA_CTRL_ACK;
155 
156 	direction = snd_pcm_substream_to_dma_direction(substream);
157 
158 	if (!substream->runtime->no_period_wakeup)
159 		flags |= DMA_PREP_INTERRUPT;
160 
161 	prtd->pos = 0;
162 	desc = dmaengine_prep_dma_cyclic(chan,
163 		substream->runtime->dma_addr,
164 		snd_pcm_lib_buffer_bytes(substream),
165 		snd_pcm_lib_period_bytes(substream), direction, flags);
166 
167 	if (!desc)
168 		return -ENOMEM;
169 
170 	desc->callback = dmaengine_pcm_dma_complete;
171 	desc->callback_param = substream;
172 	prtd->cookie = dmaengine_submit(desc);
173 
174 	return 0;
175 }
176 
177 /**
178  * snd_dmaengine_pcm_trigger - dmaengine based PCM trigger implementation
179  * @substream: PCM substream
180  * @cmd: Trigger command
181  *
182  * This function can be used as the PCM trigger callback for dmaengine based PCM
183  * driver implementations.
184  *
185  * Return: 0 on success, a negative error code otherwise
186  */
snd_dmaengine_pcm_trigger(struct snd_pcm_substream * substream,int cmd)187 int snd_dmaengine_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
188 {
189 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
190 	struct snd_pcm_runtime *runtime = substream->runtime;
191 	int ret;
192 
193 	switch (cmd) {
194 	case SNDRV_PCM_TRIGGER_START:
195 		ret = dmaengine_pcm_prepare_and_submit(substream);
196 		if (ret)
197 			return ret;
198 		dma_async_issue_pending(prtd->dma_chan);
199 		break;
200 	case SNDRV_PCM_TRIGGER_RESUME:
201 	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
202 		dmaengine_resume(prtd->dma_chan);
203 		break;
204 	case SNDRV_PCM_TRIGGER_SUSPEND:
205 		if (runtime->info & SNDRV_PCM_INFO_PAUSE)
206 			dmaengine_pause(prtd->dma_chan);
207 		else
208 			dmaengine_terminate_async(prtd->dma_chan);
209 		break;
210 	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
211 		dmaengine_pause(prtd->dma_chan);
212 		break;
213 	case SNDRV_PCM_TRIGGER_STOP:
214 		dmaengine_terminate_async(prtd->dma_chan);
215 		break;
216 	default:
217 		return -EINVAL;
218 	}
219 
220 	return 0;
221 }
222 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_trigger);
223 
224 /**
225  * snd_dmaengine_pcm_pointer_no_residue - dmaengine based PCM pointer implementation
226  * @substream: PCM substream
227  *
228  * This function is deprecated and should not be used by new drivers, as its
229  * results may be unreliable.
230  *
231  * Return: PCM position in frames
232  */
snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream * substream)233 snd_pcm_uframes_t snd_dmaengine_pcm_pointer_no_residue(struct snd_pcm_substream *substream)
234 {
235 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
236 	return bytes_to_frames(substream->runtime, prtd->pos);
237 }
238 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer_no_residue);
239 
240 /**
241  * snd_dmaengine_pcm_pointer - dmaengine based PCM pointer implementation
242  * @substream: PCM substream
243  *
244  * This function can be used as the PCM pointer callback for dmaengine based PCM
245  * driver implementations.
246  *
247  * Return: PCM position in frames
248  */
snd_dmaengine_pcm_pointer(struct snd_pcm_substream * substream)249 snd_pcm_uframes_t snd_dmaengine_pcm_pointer(struct snd_pcm_substream *substream)
250 {
251 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
252 	struct snd_pcm_runtime *runtime = substream->runtime;
253 	struct dma_tx_state state;
254 	enum dma_status status;
255 	unsigned int buf_size;
256 	unsigned int pos = 0;
257 
258 	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
259 	if (status == DMA_IN_PROGRESS || status == DMA_PAUSED) {
260 		buf_size = snd_pcm_lib_buffer_bytes(substream);
261 		if (state.residue > 0 && state.residue <= buf_size)
262 			pos = buf_size - state.residue;
263 
264 		runtime->delay = bytes_to_frames(runtime,
265 						 state.in_flight_bytes);
266 	}
267 
268 	return bytes_to_frames(runtime, pos);
269 }
270 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_pointer);
271 
272 /**
273  * snd_dmaengine_pcm_request_channel - Request channel for the dmaengine PCM
274  * @filter_fn: Filter function used to request the DMA channel
275  * @filter_data: Data passed to the DMA filter function
276  *
277  * This function request a DMA channel for usage with dmaengine PCM.
278  *
279  * Return: NULL or the requested DMA channel
280  */
snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn,void * filter_data)281 struct dma_chan *snd_dmaengine_pcm_request_channel(dma_filter_fn filter_fn,
282 	void *filter_data)
283 {
284 	dma_cap_mask_t mask;
285 
286 	dma_cap_zero(mask);
287 	dma_cap_set(DMA_SLAVE, mask);
288 	dma_cap_set(DMA_CYCLIC, mask);
289 
290 	return dma_request_channel(mask, filter_fn, filter_data);
291 }
292 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_request_channel);
293 
294 /**
295  * snd_dmaengine_pcm_open - Open a dmaengine based PCM substream
296  * @substream: PCM substream
297  * @chan: DMA channel to use for data transfers
298  *
299  * The function should usually be called from the pcm open callback. Note that
300  * this function will use private_data field of the substream's runtime. So it
301  * is not available to your pcm driver implementation.
302  *
303  * Return: 0 on success, a negative error code otherwise
304  */
snd_dmaengine_pcm_open(struct snd_pcm_substream * substream,struct dma_chan * chan)305 int snd_dmaengine_pcm_open(struct snd_pcm_substream *substream,
306 	struct dma_chan *chan)
307 {
308 	struct dmaengine_pcm_runtime_data *prtd;
309 	int ret;
310 
311 	if (!chan)
312 		return -ENXIO;
313 
314 	ret = snd_pcm_hw_constraint_integer(substream->runtime,
315 					    SNDRV_PCM_HW_PARAM_PERIODS);
316 	if (ret < 0)
317 		return ret;
318 
319 	prtd = kzalloc(sizeof(*prtd), GFP_KERNEL);
320 	if (!prtd)
321 		return -ENOMEM;
322 
323 	prtd->dma_chan = chan;
324 
325 	substream->runtime->private_data = prtd;
326 
327 	return 0;
328 }
329 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open);
330 
331 /**
332  * snd_dmaengine_pcm_open_request_chan - Open a dmaengine based PCM substream and request channel
333  * @substream: PCM substream
334  * @filter_fn: Filter function used to request the DMA channel
335  * @filter_data: Data passed to the DMA filter function
336  *
337  * This function will request a DMA channel using the passed filter function and
338  * data. The function should usually be called from the pcm open callback. Note
339  * that this function will use private_data field of the substream's runtime. So
340  * it is not available to your pcm driver implementation.
341  *
342  * Return: 0 on success, a negative error code otherwise
343  */
snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream * substream,dma_filter_fn filter_fn,void * filter_data)344 int snd_dmaengine_pcm_open_request_chan(struct snd_pcm_substream *substream,
345 	dma_filter_fn filter_fn, void *filter_data)
346 {
347 	return snd_dmaengine_pcm_open(substream,
348 		    snd_dmaengine_pcm_request_channel(filter_fn, filter_data));
349 }
350 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_open_request_chan);
351 
snd_dmaengine_pcm_sync_stop(struct snd_pcm_substream * substream)352 int snd_dmaengine_pcm_sync_stop(struct snd_pcm_substream *substream)
353 {
354 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
355 	struct dma_tx_state state;
356 	enum dma_status status;
357 
358 	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
359 	if (status != DMA_PAUSED)
360 		dmaengine_synchronize(prtd->dma_chan);
361 
362 	return 0;
363 }
364 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_sync_stop);
365 
366 /**
367  * snd_dmaengine_pcm_close - Close a dmaengine based PCM substream
368  * @substream: PCM substream
369  *
370  * Return: 0 on success, a negative error code otherwise
371  */
snd_dmaengine_pcm_close(struct snd_pcm_substream * substream)372 int snd_dmaengine_pcm_close(struct snd_pcm_substream *substream)
373 {
374 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
375 	struct dma_tx_state state;
376 	enum dma_status status;
377 
378 	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
379 	if (status == DMA_PAUSED)
380 		dmaengine_terminate_async(prtd->dma_chan);
381 
382 	dmaengine_synchronize(prtd->dma_chan);
383 	kfree(prtd);
384 
385 	return 0;
386 }
387 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close);
388 
389 /**
390  * snd_dmaengine_pcm_close_release_chan - Close a dmaengine based PCM
391  *					  substream and release channel
392  * @substream: PCM substream
393  *
394  * Releases the DMA channel associated with the PCM substream.
395  *
396  * Return: zero if successful, or a negative error code
397  */
snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream * substream)398 int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream *substream)
399 {
400 	struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream);
401 	struct dma_tx_state state;
402 	enum dma_status status;
403 
404 	status = dmaengine_tx_status(prtd->dma_chan, prtd->cookie, &state);
405 	if (status == DMA_PAUSED)
406 		dmaengine_terminate_async(prtd->dma_chan);
407 
408 	dmaengine_synchronize(prtd->dma_chan);
409 	dma_release_channel(prtd->dma_chan);
410 	kfree(prtd);
411 
412 	return 0;
413 }
414 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close_release_chan);
415 
416 /**
417  * snd_dmaengine_pcm_refine_runtime_hwparams - Refine runtime hw params
418  * @substream: PCM substream
419  * @dma_data: DAI DMA data
420  * @hw: PCM hw params
421  * @chan: DMA channel to use for data transfers
422  *
423  * This function will query DMA capability, then refine the pcm hardware
424  * parameters.
425  *
426  * Return: 0 on success, a negative error code otherwise
427  */
snd_dmaengine_pcm_refine_runtime_hwparams(struct snd_pcm_substream * substream,struct snd_dmaengine_dai_dma_data * dma_data,struct snd_pcm_hardware * hw,struct dma_chan * chan)428 int snd_dmaengine_pcm_refine_runtime_hwparams(
429 	struct snd_pcm_substream *substream,
430 	struct snd_dmaengine_dai_dma_data *dma_data,
431 	struct snd_pcm_hardware *hw,
432 	struct dma_chan *chan)
433 {
434 	struct dma_slave_caps dma_caps;
435 	u32 addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) |
436 			  BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) |
437 			  BIT(DMA_SLAVE_BUSWIDTH_4_BYTES);
438 	snd_pcm_format_t i;
439 	int ret = 0;
440 
441 	if (!hw || !chan || !dma_data)
442 		return -EINVAL;
443 
444 	ret = dma_get_slave_caps(chan, &dma_caps);
445 	if (ret == 0) {
446 		if (dma_caps.cmd_pause && dma_caps.cmd_resume)
447 			hw->info |= SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME;
448 		if (dma_caps.residue_granularity <= DMA_RESIDUE_GRANULARITY_SEGMENT)
449 			hw->info |= SNDRV_PCM_INFO_BATCH;
450 
451 		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
452 			addr_widths = dma_caps.dst_addr_widths;
453 		else
454 			addr_widths = dma_caps.src_addr_widths;
455 	}
456 
457 	/*
458 	 * If SND_DMAENGINE_PCM_DAI_FLAG_PACK is set keep
459 	 * hw.formats set to 0, meaning no restrictions are in place.
460 	 * In this case it's the responsibility of the DAI driver to
461 	 * provide the supported format information.
462 	 */
463 	if (!(dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK))
464 		/*
465 		 * Prepare formats mask for valid/allowed sample types. If the
466 		 * dma does not have support for the given physical word size,
467 		 * it needs to be masked out so user space can not use the
468 		 * format which produces corrupted audio.
469 		 * In case the dma driver does not implement the slave_caps the
470 		 * default assumption is that it supports 1, 2 and 4 bytes
471 		 * widths.
472 		 */
473 		pcm_for_each_format(i) {
474 			int bits = snd_pcm_format_physical_width(i);
475 
476 			/*
477 			 * Enable only samples with DMA supported physical
478 			 * widths
479 			 */
480 			switch (bits) {
481 			case 8:
482 			case 16:
483 			case 24:
484 			case 32:
485 			case 64:
486 				if (addr_widths & (1 << (bits / 8)))
487 					hw->formats |= pcm_format_to_bits(i);
488 				break;
489 			default:
490 				/* Unsupported types */
491 				break;
492 			}
493 		}
494 
495 	return ret;
496 }
497 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_refine_runtime_hwparams);
498 
499 MODULE_LICENSE("GPL");
500