2 * Copyright (C) 2013, Analog Devices Inc.
3 * Author: Lars-Peter Clausen <lars@metafoo.de>
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License as published by the
7 * Free Software Foundation; either version 2 of the License, or (at your
8 * option) any later version.
10 * You should have received a copy of the GNU General Public License along
11 * with this program; if not, write to the Free Software Foundation, Inc.,
12 * 675 Mass Ave, Cambridge, MA 02139, USA.
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/dmaengine.h>
18 #include <linux/slab.h>
19 #include <sound/pcm.h>
20 #include <sound/pcm_params.h>
21 #include <sound/soc.h>
22 #include <linux/dma-mapping.h>
25 #include <sound/dmaengine_pcm.h>
27 struct dmaengine_pcm
{
28 struct dma_chan
*chan
[SNDRV_PCM_STREAM_LAST
+ 1];
29 const struct snd_dmaengine_pcm_config
*config
;
30 struct snd_soc_platform platform
;
34 static struct dmaengine_pcm
*soc_platform_to_pcm(struct snd_soc_platform
*p
)
36 return container_of(p
, struct dmaengine_pcm
, platform
);
39 static struct device
*dmaengine_dma_dev(struct dmaengine_pcm
*pcm
,
40 struct snd_pcm_substream
*substream
)
42 if (!pcm
->chan
[substream
->stream
])
45 return pcm
->chan
[substream
->stream
]->device
->dev
;
49 * snd_dmaengine_pcm_prepare_slave_config() - Generic prepare_slave_config callback
50 * @substream: PCM substream
52 * @slave_config: DMA slave config to prepare
54 * This function can be used as a generic prepare_slave_config callback for
55 * platforms which make use of the snd_dmaengine_dai_dma_data struct for their
56 * DAI DMA data. Internally the function will first call
57 * snd_hwparams_to_dma_slave_config to fill in the slave config based on the
58 * hw_params, followed by snd_dmaengine_set_config_from_dai_data to fill in the
59 * remaining fields based on the DAI DMA data.
61 int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream
*substream
,
62 struct snd_pcm_hw_params
*params
, struct dma_slave_config
*slave_config
)
64 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
65 struct snd_dmaengine_dai_dma_data
*dma_data
;
68 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
70 ret
= snd_hwparams_to_dma_slave_config(substream
, params
, slave_config
);
74 snd_dmaengine_pcm_set_config_from_dai_data(substream
, dma_data
,
79 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_prepare_slave_config
);
81 static int dmaengine_pcm_hw_params(struct snd_pcm_substream
*substream
,
82 struct snd_pcm_hw_params
*params
)
84 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
85 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
86 struct dma_chan
*chan
= snd_dmaengine_pcm_get_chan(substream
);
87 int (*prepare_slave_config
)(struct snd_pcm_substream
*substream
,
88 struct snd_pcm_hw_params
*params
,
89 struct dma_slave_config
*slave_config
);
90 struct dma_slave_config slave_config
;
93 memset(&slave_config
, 0, sizeof(slave_config
));
96 prepare_slave_config
= snd_dmaengine_pcm_prepare_slave_config
;
98 prepare_slave_config
= pcm
->config
->prepare_slave_config
;
100 if (prepare_slave_config
) {
101 ret
= prepare_slave_config(substream
, params
, &slave_config
);
105 ret
= dmaengine_slave_config(chan
, &slave_config
);
110 return snd_pcm_lib_malloc_pages(substream
, params_buffer_bytes(params
));
113 static int dmaengine_pcm_set_runtime_hwparams(struct snd_pcm_substream
*substream
)
115 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
116 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
117 struct device
*dma_dev
= dmaengine_dma_dev(pcm
, substream
);
118 struct dma_chan
*chan
= pcm
->chan
[substream
->stream
];
119 struct snd_dmaengine_dai_dma_data
*dma_data
;
120 struct dma_slave_caps dma_caps
;
121 struct snd_pcm_hardware hw
;
122 u32 addr_widths
= BIT(DMA_SLAVE_BUSWIDTH_1_BYTE
) |
123 BIT(DMA_SLAVE_BUSWIDTH_2_BYTES
) |
124 BIT(DMA_SLAVE_BUSWIDTH_4_BYTES
);
127 if (pcm
->config
&& pcm
->config
->pcm_hardware
)
128 return snd_soc_set_runtime_hwparams(substream
,
129 pcm
->config
->pcm_hardware
);
131 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
133 memset(&hw
, 0, sizeof(hw
));
134 hw
.info
= SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_MMAP_VALID
|
135 SNDRV_PCM_INFO_INTERLEAVED
;
137 hw
.periods_max
= UINT_MAX
;
138 hw
.period_bytes_min
= 256;
139 hw
.period_bytes_max
= dma_get_max_seg_size(dma_dev
);
140 hw
.buffer_bytes_max
= SIZE_MAX
;
141 hw
.fifo_size
= dma_data
->fifo_size
;
143 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
)
144 hw
.info
|= SNDRV_PCM_INFO_BATCH
;
146 ret
= dma_get_slave_caps(chan
, &dma_caps
);
148 if (dma_caps
.cmd_pause
)
149 hw
.info
|= SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_RESUME
;
150 if (dma_caps
.residue_granularity
<= DMA_RESIDUE_GRANULARITY_SEGMENT
)
151 hw
.info
|= SNDRV_PCM_INFO_BATCH
;
153 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
154 addr_widths
= dma_caps
.dstn_addr_widths
;
156 addr_widths
= dma_caps
.src_addr_widths
;
160 * Prepare formats mask for valid/allowed sample types. If the dma does
161 * not have support for the given physical word size, it needs to be
162 * masked out so user space can not use the format which produces
164 * In case the dma driver does not implement the slave_caps the default
165 * assumption is that it supports 1, 2 and 4 bytes widths.
167 for (i
= 0; i
<= SNDRV_PCM_FORMAT_LAST
; i
++) {
168 int bits
= snd_pcm_format_physical_width(i
);
170 /* Enable only samples with DMA supported physical widths */
177 if (addr_widths
& (1 << (bits
/ 8)))
178 hw
.formats
|= (1LL << i
);
181 /* Unsupported types */
186 return snd_soc_set_runtime_hwparams(substream
, &hw
);
189 static int dmaengine_pcm_open(struct snd_pcm_substream
*substream
)
191 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
192 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
193 struct dma_chan
*chan
= pcm
->chan
[substream
->stream
];
196 ret
= dmaengine_pcm_set_runtime_hwparams(substream
);
200 return snd_dmaengine_pcm_open(substream
, chan
);
203 static void dmaengine_pcm_free(struct snd_pcm
*pcm
)
205 snd_pcm_lib_preallocate_free_for_all(pcm
);
208 static struct dma_chan
*dmaengine_pcm_compat_request_channel(
209 struct snd_soc_pcm_runtime
*rtd
,
210 struct snd_pcm_substream
*substream
)
212 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
213 struct snd_dmaengine_dai_dma_data
*dma_data
;
214 dma_filter_fn fn
= NULL
;
216 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
218 if ((pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
) && pcm
->chan
[0])
221 if (pcm
->config
&& pcm
->config
->compat_request_channel
)
222 return pcm
->config
->compat_request_channel(rtd
, substream
);
225 fn
= pcm
->config
->compat_filter_fn
;
227 return snd_dmaengine_pcm_request_channel(fn
, dma_data
->filter_data
);
230 static bool dmaengine_pcm_can_report_residue(struct dma_chan
*chan
)
232 struct dma_slave_caps dma_caps
;
235 ret
= dma_get_slave_caps(chan
, &dma_caps
);
239 if (dma_caps
.residue_granularity
== DMA_RESIDUE_GRANULARITY_DESCRIPTOR
)
245 static int dmaengine_pcm_new(struct snd_soc_pcm_runtime
*rtd
)
247 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
248 const struct snd_dmaengine_pcm_config
*config
= pcm
->config
;
249 struct device
*dev
= rtd
->platform
->dev
;
250 struct snd_dmaengine_dai_dma_data
*dma_data
;
251 struct snd_pcm_substream
*substream
;
252 size_t prealloc_buffer_size
;
253 size_t max_buffer_size
;
257 if (config
&& config
->prealloc_buffer_size
) {
258 prealloc_buffer_size
= config
->prealloc_buffer_size
;
259 max_buffer_size
= config
->pcm_hardware
->buffer_bytes_max
;
261 prealloc_buffer_size
= 512 * 1024;
262 max_buffer_size
= SIZE_MAX
;
266 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
; i
++) {
267 substream
= rtd
->pcm
->streams
[i
].substream
;
271 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
274 (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
))
275 pcm
->chan
[i
] = dma_request_slave_channel(dev
,
276 dma_data
->chan_name
);
278 if (!pcm
->chan
[i
] && (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_COMPAT
)) {
279 pcm
->chan
[i
] = dmaengine_pcm_compat_request_channel(rtd
,
284 dev_err(rtd
->platform
->dev
,
285 "Missing dma channel for stream: %d\n", i
);
290 ret
= snd_pcm_lib_preallocate_pages(substream
,
291 SNDRV_DMA_TYPE_DEV_IRAM
,
292 dmaengine_dma_dev(pcm
, substream
),
293 prealloc_buffer_size
,
299 * This will only return false if we know for sure that at least
300 * one channel does not support residue reporting. If the DMA
301 * driver does not implement the slave_caps API we rely having
302 * the NO_RESIDUE flag set manually in case residue reporting is
305 if (!dmaengine_pcm_can_report_residue(pcm
->chan
[i
]))
306 pcm
->flags
|= SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
;
312 dmaengine_pcm_free(rtd
->pcm
);
316 static snd_pcm_uframes_t
dmaengine_pcm_pointer(
317 struct snd_pcm_substream
*substream
)
319 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
320 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
322 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
)
323 return snd_dmaengine_pcm_pointer_no_residue(substream
);
325 return snd_dmaengine_pcm_pointer(substream
);
328 static const struct snd_pcm_ops dmaengine_pcm_ops
= {
329 .open
= dmaengine_pcm_open
,
330 .close
= snd_dmaengine_pcm_close
,
331 .ioctl
= snd_pcm_lib_ioctl
,
332 .hw_params
= dmaengine_pcm_hw_params
,
333 .hw_free
= snd_pcm_lib_free_pages
,
334 .trigger
= snd_dmaengine_pcm_trigger
,
335 .pointer
= dmaengine_pcm_pointer
,
338 static const struct snd_soc_platform_driver dmaengine_pcm_platform
= {
339 .component_driver
= {
340 .probe_order
= SND_SOC_COMP_ORDER_LATE
,
342 .ops
= &dmaengine_pcm_ops
,
343 .pcm_new
= dmaengine_pcm_new
,
344 .pcm_free
= dmaengine_pcm_free
,
347 static const char * const dmaengine_pcm_dma_channel_names
[] = {
348 [SNDRV_PCM_STREAM_PLAYBACK
] = "tx",
349 [SNDRV_PCM_STREAM_CAPTURE
] = "rx",
352 static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm
*pcm
,
353 struct device
*dev
, const struct snd_dmaengine_pcm_config
*config
)
357 struct dma_chan
*chan
;
359 if ((pcm
->flags
& (SND_DMAENGINE_PCM_FLAG_NO_DT
|
360 SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
)) ||
364 if (config
&& config
->dma_dev
) {
366 * If this warning is seen, it probably means that your Linux
367 * device structure does not match your HW device structure.
368 * It would be best to refactor the Linux device structure to
369 * correctly match the HW structure.
371 dev_warn(dev
, "DMA channels sourced from device %s",
372 dev_name(config
->dma_dev
));
373 dev
= config
->dma_dev
;
376 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
378 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
381 name
= dmaengine_pcm_dma_channel_names
[i
];
382 if (config
&& config
->chan_names
[i
])
383 name
= config
->chan_names
[i
];
384 chan
= dma_request_slave_channel_reason(dev
, name
);
386 if (PTR_ERR(chan
) == -EPROBE_DEFER
)
387 return -EPROBE_DEFER
;
392 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
396 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
397 pcm
->chan
[1] = pcm
->chan
[0];
402 static void dmaengine_pcm_release_chan(struct dmaengine_pcm
*pcm
)
406 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
410 dma_release_channel(pcm
->chan
[i
]);
411 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
417 * snd_dmaengine_pcm_register - Register a dmaengine based PCM device
418 * @dev: The parent device for the PCM device
419 * @config: Platform specific PCM configuration
420 * @flags: Platform specific quirks
422 int snd_dmaengine_pcm_register(struct device
*dev
,
423 const struct snd_dmaengine_pcm_config
*config
, unsigned int flags
)
425 struct dmaengine_pcm
*pcm
;
428 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
432 pcm
->config
= config
;
435 ret
= dmaengine_pcm_request_chan_of(pcm
, dev
, config
);
439 ret
= snd_soc_add_platform(dev
, &pcm
->platform
,
440 &dmaengine_pcm_platform
);
447 dmaengine_pcm_release_chan(pcm
);
451 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register
);
454 * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device
455 * @dev: Parent device the PCM was register with
457 * Removes a dmaengine based PCM device previously registered with
458 * snd_dmaengine_pcm_register.
460 void snd_dmaengine_pcm_unregister(struct device
*dev
)
462 struct snd_soc_platform
*platform
;
463 struct dmaengine_pcm
*pcm
;
465 platform
= snd_soc_lookup_platform(dev
);
469 pcm
= soc_platform_to_pcm(platform
);
471 snd_soc_remove_platform(platform
);
472 dmaengine_pcm_release_chan(pcm
);
475 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister
);
477 MODULE_LICENSE("GPL");