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
;
124 if (pcm
->config
&& pcm
->config
->pcm_hardware
)
125 return snd_soc_set_runtime_hwparams(substream
,
126 pcm
->config
->pcm_hardware
);
128 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
130 memset(&hw
, 0, sizeof(hw
));
131 hw
.info
= SNDRV_PCM_INFO_MMAP
| SNDRV_PCM_INFO_MMAP_VALID
|
132 SNDRV_PCM_INFO_INTERLEAVED
;
134 hw
.periods_max
= UINT_MAX
;
135 hw
.period_bytes_min
= 256;
136 hw
.period_bytes_max
= dma_get_max_seg_size(dma_dev
);
137 hw
.buffer_bytes_max
= SIZE_MAX
;
138 hw
.fifo_size
= dma_data
->fifo_size
;
140 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
)
141 hw
.info
|= SNDRV_PCM_INFO_BATCH
;
143 ret
= dma_get_slave_caps(chan
, &dma_caps
);
145 if (dma_caps
.cmd_pause
)
146 hw
.info
|= SNDRV_PCM_INFO_PAUSE
| SNDRV_PCM_INFO_RESUME
;
147 if (dma_caps
.residue_granularity
<= DMA_RESIDUE_GRANULARITY_SEGMENT
)
148 hw
.info
|= SNDRV_PCM_INFO_BATCH
;
151 return snd_soc_set_runtime_hwparams(substream
, &hw
);
154 static int dmaengine_pcm_open(struct snd_pcm_substream
*substream
)
156 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
157 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
158 struct dma_chan
*chan
= pcm
->chan
[substream
->stream
];
161 ret
= dmaengine_pcm_set_runtime_hwparams(substream
);
165 return snd_dmaengine_pcm_open(substream
, chan
);
168 static void dmaengine_pcm_free(struct snd_pcm
*pcm
)
170 snd_pcm_lib_preallocate_free_for_all(pcm
);
173 static struct dma_chan
*dmaengine_pcm_compat_request_channel(
174 struct snd_soc_pcm_runtime
*rtd
,
175 struct snd_pcm_substream
*substream
)
177 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
178 struct snd_dmaengine_dai_dma_data
*dma_data
;
179 dma_filter_fn fn
= NULL
;
181 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
183 if ((pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
) && pcm
->chan
[0])
186 if (pcm
->config
&& pcm
->config
->compat_request_channel
)
187 return pcm
->config
->compat_request_channel(rtd
, substream
);
190 fn
= pcm
->config
->compat_filter_fn
;
192 return snd_dmaengine_pcm_request_channel(fn
, dma_data
->filter_data
);
195 static bool dmaengine_pcm_can_report_residue(struct dma_chan
*chan
)
197 struct dma_slave_caps dma_caps
;
200 ret
= dma_get_slave_caps(chan
, &dma_caps
);
204 if (dma_caps
.residue_granularity
== DMA_RESIDUE_GRANULARITY_DESCRIPTOR
)
210 static int dmaengine_pcm_new(struct snd_soc_pcm_runtime
*rtd
)
212 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
213 const struct snd_dmaengine_pcm_config
*config
= pcm
->config
;
214 struct device
*dev
= rtd
->platform
->dev
;
215 struct snd_dmaengine_dai_dma_data
*dma_data
;
216 struct snd_pcm_substream
*substream
;
217 size_t prealloc_buffer_size
;
218 size_t max_buffer_size
;
222 if (config
&& config
->prealloc_buffer_size
) {
223 prealloc_buffer_size
= config
->prealloc_buffer_size
;
224 max_buffer_size
= config
->pcm_hardware
->buffer_bytes_max
;
226 prealloc_buffer_size
= 512 * 1024;
227 max_buffer_size
= SIZE_MAX
;
231 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
; i
++) {
232 substream
= rtd
->pcm
->streams
[i
].substream
;
236 dma_data
= snd_soc_dai_get_dma_data(rtd
->cpu_dai
, substream
);
239 (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
))
240 pcm
->chan
[i
] = dma_request_slave_channel(dev
,
241 dma_data
->chan_name
);
243 if (!pcm
->chan
[i
] && (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_COMPAT
)) {
244 pcm
->chan
[i
] = dmaengine_pcm_compat_request_channel(rtd
,
249 dev_err(rtd
->platform
->dev
,
250 "Missing dma channel for stream: %d\n", i
);
255 ret
= snd_pcm_lib_preallocate_pages(substream
,
256 SNDRV_DMA_TYPE_DEV_IRAM
,
257 dmaengine_dma_dev(pcm
, substream
),
258 prealloc_buffer_size
,
264 * This will only return false if we know for sure that at least
265 * one channel does not support residue reporting. If the DMA
266 * driver does not implement the slave_caps API we rely having
267 * the NO_RESIDUE flag set manually in case residue reporting is
270 if (!dmaengine_pcm_can_report_residue(pcm
->chan
[i
]))
271 pcm
->flags
|= SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
;
277 dmaengine_pcm_free(rtd
->pcm
);
281 static snd_pcm_uframes_t
dmaengine_pcm_pointer(
282 struct snd_pcm_substream
*substream
)
284 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
285 struct dmaengine_pcm
*pcm
= soc_platform_to_pcm(rtd
->platform
);
287 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_NO_RESIDUE
)
288 return snd_dmaengine_pcm_pointer_no_residue(substream
);
290 return snd_dmaengine_pcm_pointer(substream
);
293 static const struct snd_pcm_ops dmaengine_pcm_ops
= {
294 .open
= dmaengine_pcm_open
,
295 .close
= snd_dmaengine_pcm_close
,
296 .ioctl
= snd_pcm_lib_ioctl
,
297 .hw_params
= dmaengine_pcm_hw_params
,
298 .hw_free
= snd_pcm_lib_free_pages
,
299 .trigger
= snd_dmaengine_pcm_trigger
,
300 .pointer
= dmaengine_pcm_pointer
,
303 static const struct snd_soc_platform_driver dmaengine_pcm_platform
= {
304 .ops
= &dmaengine_pcm_ops
,
305 .pcm_new
= dmaengine_pcm_new
,
306 .pcm_free
= dmaengine_pcm_free
,
307 .probe_order
= SND_SOC_COMP_ORDER_LATE
,
310 static const char * const dmaengine_pcm_dma_channel_names
[] = {
311 [SNDRV_PCM_STREAM_PLAYBACK
] = "tx",
312 [SNDRV_PCM_STREAM_CAPTURE
] = "rx",
315 static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm
*pcm
,
316 struct device
*dev
, const struct snd_dmaengine_pcm_config
*config
)
320 struct dma_chan
*chan
;
322 if ((pcm
->flags
& (SND_DMAENGINE_PCM_FLAG_NO_DT
|
323 SND_DMAENGINE_PCM_FLAG_CUSTOM_CHANNEL_NAME
)) ||
327 if (config
&& config
->dma_dev
) {
329 * If this warning is seen, it probably means that your Linux
330 * device structure does not match your HW device structure.
331 * It would be best to refactor the Linux device structure to
332 * correctly match the HW structure.
334 dev_warn(dev
, "DMA channels sourced from device %s",
335 dev_name(config
->dma_dev
));
336 dev
= config
->dma_dev
;
339 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
341 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
344 name
= dmaengine_pcm_dma_channel_names
[i
];
345 if (config
&& config
->chan_names
[i
])
346 name
= config
->chan_names
[i
];
347 chan
= dma_request_slave_channel_reason(dev
, name
);
349 if (PTR_ERR(chan
) == -EPROBE_DEFER
)
350 return -EPROBE_DEFER
;
355 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
359 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
360 pcm
->chan
[1] = pcm
->chan
[0];
365 static void dmaengine_pcm_release_chan(struct dmaengine_pcm
*pcm
)
369 for (i
= SNDRV_PCM_STREAM_PLAYBACK
; i
<= SNDRV_PCM_STREAM_CAPTURE
;
373 dma_release_channel(pcm
->chan
[i
]);
374 if (pcm
->flags
& SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX
)
380 * snd_dmaengine_pcm_register - Register a dmaengine based PCM device
381 * @dev: The parent device for the PCM device
382 * @config: Platform specific PCM configuration
383 * @flags: Platform specific quirks
385 int snd_dmaengine_pcm_register(struct device
*dev
,
386 const struct snd_dmaengine_pcm_config
*config
, unsigned int flags
)
388 struct dmaengine_pcm
*pcm
;
391 pcm
= kzalloc(sizeof(*pcm
), GFP_KERNEL
);
395 pcm
->config
= config
;
398 ret
= dmaengine_pcm_request_chan_of(pcm
, dev
, config
);
402 ret
= snd_soc_add_platform(dev
, &pcm
->platform
,
403 &dmaengine_pcm_platform
);
410 dmaengine_pcm_release_chan(pcm
);
414 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register
);
417 * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device
418 * @dev: Parent device the PCM was register with
420 * Removes a dmaengine based PCM device previously registered with
421 * snd_dmaengine_pcm_register.
423 void snd_dmaengine_pcm_unregister(struct device
*dev
)
425 struct snd_soc_platform
*platform
;
426 struct dmaengine_pcm
*pcm
;
428 platform
= snd_soc_lookup_platform(dev
);
432 pcm
= soc_platform_to_pcm(platform
);
434 snd_soc_remove_platform(platform
);
435 dmaengine_pcm_release_chan(pcm
);
438 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister
);
440 MODULE_LICENSE("GPL");