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
.dst_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 struct dma_chan
*dmaengine_pcm_compat_request_channel(
204 struct snd_soc_pcm_runtime
*rtd
,
205 struct snd_pcm_substream
*substream
)
207 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
208 struct snd_dmaengine_dai_dma_data
*dma_data
;
209 dma_filter_fn fn
= NULL
;
211 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
213 if ((pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
) && pcm
->chan
[0])
216 if (pcm
->config
&& pcm
->config
->compat_request_channel
)
217 return pcm
->config
->compat_request_channel(rtd
, substream
);
220 fn
= pcm
->config
->compat_filter_fn
;
222 return snd_dmaengine_pcm_request_channel(fn
, dma_data
->filter_data
);
225 static bool dmaengine_pcm_can_report_residue(struct dma_chan
*chan
)
227 struct dma_slave_caps dma_caps
;
230 ret
= dma_get_slave_caps(chan
, &dma_caps
);
234 if (dma_caps
.residue_granularity
== DMA_RESIDUE_GRANULARITY_DESCRIPTOR
)
240 static int dmaengine_pcm_new(struct snd_soc_pcm_runtime
*rtd
)
242 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
243 const struct snd_dmaengine_pcm_config
*config
= pcm
->config
;
244 struct device
*dev
= rtd
->platform
->dev
;
245 struct snd_dmaengine_dai_dma_data
*dma_data
;
246 struct snd_pcm_substream
*substream
;
247 size_t prealloc_buffer_size
;
248 size_t max_buffer_size
;
252 if (config
&& config
->prealloc_buffer_size
) {
253 prealloc_buffer_size
= config
->prealloc_buffer_size
;
254 max_buffer_size
= config
->pcm_hardware
->buffer_bytes_max
;
256 prealloc_buffer_size
= 512 * 1024;
257 max_buffer_size
= SIZE_MAX
;
261 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
; i
++) {
262 substream
= rtd
->pcm
->streams
[i
].substream
;
266 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
269 (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
))
270 pcm
->chan
[i
] = dma_request_slave_channel(dev
,
271 dma_data
->chan_name
);
273 if (!pcm
->chan
[i
] && (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_COMPAT
)) {
274 pcm
->chan
[i
] = dmaengine_pcm_compat_request_channel(rtd
,
279 dev_err(rtd
->platform
->dev
,
280 "Missing dma channel for stream: %d\n", i
);
284 ret
= snd_pcm_lib_preallocate_pages(substream
,
285 SNDRV_DMA_TYPE_DEV_IRAM
,
286 dmaengine_dma_dev(pcm
, substream
),
287 prealloc_buffer_size
,
293 * This will only return false if we know for sure that at least
294 * one channel does not support residue reporting. If the DMA
295 * driver does not implement the slave_caps API we rely having
296 * the NO_RESIDUE flag set manually in case residue reporting is
299 if (!dmaengine_pcm_can_report_residue(pcm
->chan
[i
]))
300 pcm
->flags
|= SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
;
306 static snd_pcm_uframes_t
dmaengine_pcm_pointer(
307 struct snd_pcm_substream
*substream
)
309 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
310 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
312 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
)
313 return snd_dmaengine_pcm_pointer_no_residue(substream
);
315 return snd_dmaengine_pcm_pointer(substream
);
318 static const struct snd_pcm_ops dmaengine_pcm_ops
= {
319 .open
= dmaengine_pcm_open
,
320 .close
= snd_dmaengine_pcm_close
,
321 .ioctl
= snd_pcm_lib_ioctl
,
322 .hw_params
= dmaengine_pcm_hw_params
,
323 .hw_free
= snd_pcm_lib_free_pages
,
324 .trigger
= snd_dmaengine_pcm_trigger
,
325 .pointer
= dmaengine_pcm_pointer
,
328 static const struct snd_soc_platform_driver dmaengine_pcm_platform
= {
329 .component_driver
= {
330 .probe_order
= SND_SOC_COMP_ORDER_LATE
,
332 .ops
= &dmaengine_pcm_ops
,
333 .pcm_new
= dmaengine_pcm_new
,
336 static const char * const dmaengine_pcm_dma_channel_names
[] = {
337 [SNDRV_PCM_STREAM_PLAYBACK
] = "tx",
338 [SNDRV_PCM_STREAM_CAPTURE
] = "rx",
341 static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm
*pcm
,
342 struct device
*dev
, const struct snd_dmaengine_pcm_config
*config
)
346 struct dma_chan
*chan
;
348 if ((pcm
->flags
& (SND_DMAENGINE_PCM_FLAG_NO_DT
|
349 SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
)) ||
353 if (config
&& config
->dma_dev
) {
355 * If this warning is seen, it probably means that your Linux
356 * device structure does not match your HW device structure.
357 * It would be best to refactor the Linux device structure to
358 * correctly match the HW structure.
360 dev_warn(dev
, "DMA channels sourced from device %s",
361 dev_name(config
->dma_dev
));
362 dev
= config
->dma_dev
;
365 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
367 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
370 name
= dmaengine_pcm_dma_channel_names
[i
];
371 if (config
&& config
->chan_names
[i
])
372 name
= config
->chan_names
[i
];
373 chan
= dma_request_slave_channel_reason(dev
, name
);
375 if (PTR_ERR(chan
) == -EPROBE_DEFER
)
376 return -EPROBE_DEFER
;
381 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
385 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
386 pcm
->chan
[1] = pcm
->chan
[0];
391 static void dmaengine_pcm_release_chan(struct dmaengine_pcm
*pcm
)
395 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
399 dma_release_channel(pcm
->chan
[i
]);
400 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
406 * snd_dmaengine_pcm_register - Register a dmaengine based PCM device
407 * @dev: The parent device for the PCM device
408 * @config: Platform specific PCM configuration
409 * @flags: Platform specific quirks
411 int snd_dmaengine_pcm_register(struct device
*dev
,
412 const struct snd_dmaengine_pcm_config
*config
, unsigned int flags
)
414 struct dmaengine_pcm
*pcm
;
417 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
421 pcm
->config
= config
;
424 ret
= dmaengine_pcm_request_chan_of(pcm
, dev
, config
);
428 ret
= snd_soc_add_platform(dev
, &pcm
->platform
,
429 &dmaengine_pcm_platform
);
436 dmaengine_pcm_release_chan(pcm
);
440 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register
);
443 * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device
444 * @dev: Parent device the PCM was register with
446 * Removes a dmaengine based PCM device previously registered with
447 * snd_dmaengine_pcm_register.
449 void snd_dmaengine_pcm_unregister(struct device
*dev
)
451 struct snd_soc_platform
*platform
;
452 struct dmaengine_pcm
*pcm
;
454 platform
= snd_soc_lookup_platform(dev
);
458 pcm
= soc_platform_to_pcm(platform
);
460 snd_soc_remove_platform(platform
);
461 dmaengine_pcm_release_chan(pcm
);
464 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister
);
466 MODULE_LICENSE("GPL");