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 | |
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 | |
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 | */ |
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(p: 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 | */ |
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 | |
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 | |
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 | buf_addr: substream->runtime->dma_addr, |
164 | buf_len: snd_pcm_lib_buffer_bytes(substream), |
165 | period_len: snd_pcm_lib_period_bytes(substream), dir: 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 | */ |
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(chan: prtd->dma_chan); |
199 | break; |
200 | case SNDRV_PCM_TRIGGER_RESUME: |
201 | case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: |
202 | dmaengine_resume(chan: prtd->dma_chan); |
203 | break; |
204 | case SNDRV_PCM_TRIGGER_SUSPEND: |
205 | if (runtime->info & SNDRV_PCM_INFO_PAUSE) |
206 | dmaengine_pause(chan: prtd->dma_chan); |
207 | else |
208 | dmaengine_terminate_async(chan: prtd->dma_chan); |
209 | break; |
210 | case SNDRV_PCM_TRIGGER_PAUSE_PUSH: |
211 | dmaengine_pause(chan: prtd->dma_chan); |
212 | break; |
213 | case SNDRV_PCM_TRIGGER_STOP: |
214 | dmaengine_terminate_async(chan: 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 | */ |
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(runtime: substream->runtime, size: 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 | */ |
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(chan: prtd->dma_chan, cookie: prtd->cookie, state: &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 | size: state.in_flight_bytes); |
266 | } |
267 | |
268 | return bytes_to_frames(runtime, size: 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 | */ |
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 | */ |
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(runtime: substream->runtime, |
315 | SNDRV_PCM_HW_PARAM_PERIODS); |
316 | if (ret < 0) |
317 | return ret; |
318 | |
319 | prtd = kzalloc(size: 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 | */ |
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 | |
352 | /** |
353 | * snd_dmaengine_pcm_close - Close a dmaengine based PCM substream |
354 | * @substream: PCM substream |
355 | * |
356 | * Return: 0 on success, a negative error code otherwise |
357 | */ |
358 | int snd_dmaengine_pcm_close(struct snd_pcm_substream *substream) |
359 | { |
360 | struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream); |
361 | |
362 | dmaengine_synchronize(chan: prtd->dma_chan); |
363 | kfree(objp: prtd); |
364 | |
365 | return 0; |
366 | } |
367 | EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close); |
368 | |
369 | /** |
370 | * snd_dmaengine_pcm_close_release_chan - Close a dmaengine based PCM |
371 | * substream and release channel |
372 | * @substream: PCM substream |
373 | * |
374 | * Releases the DMA channel associated with the PCM substream. |
375 | * |
376 | * Return: zero if successful, or a negative error code |
377 | */ |
378 | int snd_dmaengine_pcm_close_release_chan(struct snd_pcm_substream *substream) |
379 | { |
380 | struct dmaengine_pcm_runtime_data *prtd = substream_to_prtd(substream); |
381 | |
382 | dmaengine_synchronize(chan: prtd->dma_chan); |
383 | dma_release_channel(chan: prtd->dma_chan); |
384 | kfree(objp: prtd); |
385 | |
386 | return 0; |
387 | } |
388 | EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_close_release_chan); |
389 | |
390 | /** |
391 | * snd_dmaengine_pcm_refine_runtime_hwparams - Refine runtime hw params |
392 | * @substream: PCM substream |
393 | * @dma_data: DAI DMA data |
394 | * @hw: PCM hw params |
395 | * @chan: DMA channel to use for data transfers |
396 | * |
397 | * This function will query DMA capability, then refine the pcm hardware |
398 | * parameters. |
399 | * |
400 | * Return: 0 on success, a negative error code otherwise |
401 | */ |
402 | int snd_dmaengine_pcm_refine_runtime_hwparams( |
403 | struct snd_pcm_substream *substream, |
404 | struct snd_dmaengine_dai_dma_data *dma_data, |
405 | struct snd_pcm_hardware *hw, |
406 | struct dma_chan *chan) |
407 | { |
408 | struct dma_slave_caps dma_caps; |
409 | u32 addr_widths = BIT(DMA_SLAVE_BUSWIDTH_1_BYTE) | |
410 | BIT(DMA_SLAVE_BUSWIDTH_2_BYTES) | |
411 | BIT(DMA_SLAVE_BUSWIDTH_4_BYTES); |
412 | snd_pcm_format_t i; |
413 | int ret = 0; |
414 | |
415 | if (!hw || !chan || !dma_data) |
416 | return -EINVAL; |
417 | |
418 | ret = dma_get_slave_caps(chan, caps: &dma_caps); |
419 | if (ret == 0) { |
420 | if (dma_caps.cmd_pause && dma_caps.cmd_resume) |
421 | hw->info |= SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME; |
422 | if (dma_caps.residue_granularity <= DMA_RESIDUE_GRANULARITY_SEGMENT) |
423 | hw->info |= SNDRV_PCM_INFO_BATCH; |
424 | |
425 | if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) |
426 | addr_widths = dma_caps.dst_addr_widths; |
427 | else |
428 | addr_widths = dma_caps.src_addr_widths; |
429 | } |
430 | |
431 | /* |
432 | * If SND_DMAENGINE_PCM_DAI_FLAG_PACK is set keep |
433 | * hw.formats set to 0, meaning no restrictions are in place. |
434 | * In this case it's the responsibility of the DAI driver to |
435 | * provide the supported format information. |
436 | */ |
437 | if (!(dma_data->flags & SND_DMAENGINE_PCM_DAI_FLAG_PACK)) |
438 | /* |
439 | * Prepare formats mask for valid/allowed sample types. If the |
440 | * dma does not have support for the given physical word size, |
441 | * it needs to be masked out so user space can not use the |
442 | * format which produces corrupted audio. |
443 | * In case the dma driver does not implement the slave_caps the |
444 | * default assumption is that it supports 1, 2 and 4 bytes |
445 | * widths. |
446 | */ |
447 | pcm_for_each_format(i) { |
448 | int bits = snd_pcm_format_physical_width(format: i); |
449 | |
450 | /* |
451 | * Enable only samples with DMA supported physical |
452 | * widths |
453 | */ |
454 | switch (bits) { |
455 | case 8: |
456 | case 16: |
457 | case 24: |
458 | case 32: |
459 | case 64: |
460 | if (addr_widths & (1 << (bits / 8))) |
461 | hw->formats |= pcm_format_to_bits(pcm_format: i); |
462 | break; |
463 | default: |
464 | /* Unsupported types */ |
465 | break; |
466 | } |
467 | } |
468 | |
469 | return ret; |
470 | } |
471 | EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_refine_runtime_hwparams); |
472 | |
473 | MODULE_LICENSE("GPL" ); |
474 | |