507 lines · c
1// SPDX-License-Identifier: GPL-2.0+2//3// Copyright (C) 2013, Analog Devices Inc.4// Author: Lars-Peter Clausen <lars@metafoo.de>5 6#include <linux/module.h>7#include <linux/init.h>8#include <linux/dmaengine.h>9#include <linux/slab.h>10#include <sound/pcm.h>11#include <sound/pcm_params.h>12#include <sound/soc.h>13#include <linux/dma-mapping.h>14#include <linux/of.h>15 16#include <sound/dmaengine_pcm.h>17 18static unsigned int prealloc_buffer_size_kbytes = 512;19module_param(prealloc_buffer_size_kbytes, uint, 0444);20MODULE_PARM_DESC(prealloc_buffer_size_kbytes, "Preallocate DMA buffer size (KB).");21 22/*23 * The platforms dmaengine driver does not support reporting the amount of24 * bytes that are still left to transfer.25 */26#define SND_DMAENGINE_PCM_FLAG_NO_RESIDUE BIT(31)27 28static struct device *dmaengine_dma_dev(struct dmaengine_pcm *pcm,29 struct snd_pcm_substream *substream)30{31 if (!pcm->chan[substream->stream])32 return NULL;33 34 return pcm->chan[substream->stream]->device->dev;35}36 37/**38 * snd_dmaengine_pcm_prepare_slave_config() - Generic prepare_slave_config callback39 * @substream: PCM substream40 * @params: hw_params41 * @slave_config: DMA slave config to prepare42 *43 * This function can be used as a generic prepare_slave_config callback for44 * platforms which make use of the snd_dmaengine_dai_dma_data struct for their45 * DAI DMA data. Internally the function will first call46 * snd_hwparams_to_dma_slave_config to fill in the slave config based on the47 * hw_params, followed by snd_dmaengine_pcm_set_config_from_dai_data to fill in48 * the remaining fields based on the DAI DMA data.49 */50int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream,51 struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config)52{53 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);54 struct snd_dmaengine_dai_dma_data *dma_data;55 int ret;56 57 if (rtd->dai_link->num_cpus > 1) {58 dev_err(rtd->dev,59 "%s doesn't support Multi CPU yet\n", __func__);60 return -EINVAL;61 }62 63 dma_data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream);64 65 ret = snd_hwparams_to_dma_slave_config(substream, params, slave_config);66 if (ret)67 return ret;68 69 snd_dmaengine_pcm_set_config_from_dai_data(substream, dma_data,70 slave_config);71 72 return 0;73}74EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_prepare_slave_config);75 76static int dmaengine_pcm_hw_params(struct snd_soc_component *component,77 struct snd_pcm_substream *substream,78 struct snd_pcm_hw_params *params)79{80 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);81 struct dma_chan *chan = snd_dmaengine_pcm_get_chan(substream);82 struct dma_slave_config slave_config;83 int ret;84 85 if (!pcm->config->prepare_slave_config)86 return 0;87 88 memset(&slave_config, 0, sizeof(slave_config));89 90 ret = pcm->config->prepare_slave_config(substream, params, &slave_config);91 if (ret)92 return ret;93 94 return dmaengine_slave_config(chan, &slave_config);95}96 97static int98dmaengine_pcm_set_runtime_hwparams(struct snd_soc_component *component,99 struct snd_pcm_substream *substream)100{101 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);102 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);103 struct device *dma_dev = dmaengine_dma_dev(pcm, substream);104 struct dma_chan *chan = pcm->chan[substream->stream];105 struct snd_dmaengine_dai_dma_data *dma_data;106 struct snd_pcm_hardware hw;107 108 if (rtd->dai_link->num_cpus > 1) {109 dev_err(rtd->dev,110 "%s doesn't support Multi CPU yet\n", __func__);111 return -EINVAL;112 }113 114 if (pcm->config->pcm_hardware)115 return snd_soc_set_runtime_hwparams(substream,116 pcm->config->pcm_hardware);117 118 dma_data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream);119 120 memset(&hw, 0, sizeof(hw));121 hw.info = SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID |122 SNDRV_PCM_INFO_INTERLEAVED;123 hw.periods_min = 2;124 hw.periods_max = UINT_MAX;125 hw.period_bytes_min = dma_data->maxburst * DMA_SLAVE_BUSWIDTH_8_BYTES;126 if (!hw.period_bytes_min)127 hw.period_bytes_min = 256;128 hw.period_bytes_max = dma_get_max_seg_size(dma_dev);129 hw.buffer_bytes_max = SIZE_MAX;130 hw.fifo_size = dma_data->fifo_size;131 132 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_RESIDUE)133 hw.info |= SNDRV_PCM_INFO_BATCH;134 135 /**136 * FIXME: Remove the return value check to align with the code137 * before adding snd_dmaengine_pcm_refine_runtime_hwparams138 * function.139 */140 snd_dmaengine_pcm_refine_runtime_hwparams(substream,141 dma_data,142 &hw,143 chan);144 145 return snd_soc_set_runtime_hwparams(substream, &hw);146}147 148static int dmaengine_pcm_open(struct snd_soc_component *component,149 struct snd_pcm_substream *substream)150{151 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);152 struct dma_chan *chan = pcm->chan[substream->stream];153 int ret;154 155 ret = dmaengine_pcm_set_runtime_hwparams(component, substream);156 if (ret)157 return ret;158 159 return snd_dmaengine_pcm_open(substream, chan);160}161 162static int dmaengine_pcm_close(struct snd_soc_component *component,163 struct snd_pcm_substream *substream)164{165 return snd_dmaengine_pcm_close(substream);166}167 168static int dmaengine_pcm_trigger(struct snd_soc_component *component,169 struct snd_pcm_substream *substream, int cmd)170{171 return snd_dmaengine_pcm_trigger(substream, cmd);172}173 174static struct dma_chan *dmaengine_pcm_compat_request_channel(175 struct snd_soc_component *component,176 struct snd_soc_pcm_runtime *rtd,177 struct snd_pcm_substream *substream)178{179 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);180 struct snd_dmaengine_dai_dma_data *dma_data;181 182 if (rtd->dai_link->num_cpus > 1) {183 dev_err(rtd->dev,184 "%s doesn't support Multi CPU yet\n", __func__);185 return NULL;186 }187 188 dma_data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream);189 190 if ((pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX) && pcm->chan[0])191 return pcm->chan[0];192 193 if (pcm->config->compat_request_channel)194 return pcm->config->compat_request_channel(rtd, substream);195 196 return snd_dmaengine_pcm_request_channel(pcm->config->compat_filter_fn,197 dma_data->filter_data);198}199 200static bool dmaengine_pcm_can_report_residue(struct device *dev,201 struct dma_chan *chan)202{203 struct dma_slave_caps dma_caps;204 int ret;205 206 ret = dma_get_slave_caps(chan, &dma_caps);207 if (ret != 0) {208 dev_warn(dev, "Failed to get DMA channel capabilities, falling back to period counting: %d\n",209 ret);210 return false;211 }212 213 if (dma_caps.residue_granularity == DMA_RESIDUE_GRANULARITY_DESCRIPTOR)214 return false;215 216 return true;217}218 219static int dmaengine_pcm_new(struct snd_soc_component *component,220 struct snd_soc_pcm_runtime *rtd)221{222 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);223 const struct snd_dmaengine_pcm_config *config = pcm->config;224 struct device *dev = component->dev;225 size_t prealloc_buffer_size;226 size_t max_buffer_size;227 unsigned int i;228 229 if (config->prealloc_buffer_size)230 prealloc_buffer_size = config->prealloc_buffer_size;231 else232 prealloc_buffer_size = prealloc_buffer_size_kbytes * 1024;233 234 if (config->pcm_hardware && config->pcm_hardware->buffer_bytes_max)235 max_buffer_size = config->pcm_hardware->buffer_bytes_max;236 else237 max_buffer_size = SIZE_MAX;238 239 for_each_pcm_streams(i) {240 struct snd_pcm_substream *substream = rtd->pcm->streams[i].substream;241 if (!substream)242 continue;243 244 if (!pcm->chan[i] && config->chan_names[i])245 pcm->chan[i] = dma_request_slave_channel(dev,246 config->chan_names[i]);247 248 if (!pcm->chan[i] && (pcm->flags & SND_DMAENGINE_PCM_FLAG_COMPAT)) {249 pcm->chan[i] = dmaengine_pcm_compat_request_channel(250 component, rtd, substream);251 }252 253 if (!pcm->chan[i]) {254 dev_err(component->dev,255 "Missing dma channel for stream: %d\n", i);256 return -EINVAL;257 }258 259 snd_pcm_set_managed_buffer(substream,260 SNDRV_DMA_TYPE_DEV_IRAM,261 dmaengine_dma_dev(pcm, substream),262 prealloc_buffer_size,263 max_buffer_size);264 265 if (!dmaengine_pcm_can_report_residue(dev, pcm->chan[i]))266 pcm->flags |= SND_DMAENGINE_PCM_FLAG_NO_RESIDUE;267 268 if (rtd->pcm->streams[i].pcm->name[0] == '\0') {269 strscpy_pad(rtd->pcm->streams[i].pcm->name,270 rtd->pcm->streams[i].pcm->id,271 sizeof(rtd->pcm->streams[i].pcm->name));272 }273 }274 275 return 0;276}277 278static snd_pcm_uframes_t dmaengine_pcm_pointer(279 struct snd_soc_component *component,280 struct snd_pcm_substream *substream)281{282 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);283 284 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_RESIDUE)285 return snd_dmaengine_pcm_pointer_no_residue(substream);286 else287 return snd_dmaengine_pcm_pointer(substream);288}289 290static int dmaengine_copy(struct snd_soc_component *component,291 struct snd_pcm_substream *substream,292 int channel, unsigned long hwoff,293 struct iov_iter *iter, unsigned long bytes)294{295 struct snd_pcm_runtime *runtime = substream->runtime;296 struct dmaengine_pcm *pcm = soc_component_to_pcm(component);297 int (*process)(struct snd_pcm_substream *substream,298 int channel, unsigned long hwoff,299 unsigned long bytes) = pcm->config->process;300 bool is_playback = substream->stream == SNDRV_PCM_STREAM_PLAYBACK;301 void *dma_ptr = runtime->dma_area + hwoff +302 channel * (runtime->dma_bytes / runtime->channels);303 304 if (is_playback)305 if (copy_from_iter(dma_ptr, bytes, iter) != bytes)306 return -EFAULT;307 308 if (process) {309 int ret = process(substream, channel, hwoff, bytes);310 if (ret < 0)311 return ret;312 }313 314 if (!is_playback)315 if (copy_to_iter(dma_ptr, bytes, iter) != bytes)316 return -EFAULT;317 318 return 0;319}320 321static int dmaengine_pcm_sync_stop(struct snd_soc_component *component,322 struct snd_pcm_substream *substream)323{324 return snd_dmaengine_pcm_sync_stop(substream);325}326 327static const struct snd_soc_component_driver dmaengine_pcm_component = {328 .name = SND_DMAENGINE_PCM_DRV_NAME,329 .probe_order = SND_SOC_COMP_ORDER_LATE,330 .open = dmaengine_pcm_open,331 .close = dmaengine_pcm_close,332 .hw_params = dmaengine_pcm_hw_params,333 .trigger = dmaengine_pcm_trigger,334 .pointer = dmaengine_pcm_pointer,335 .pcm_construct = dmaengine_pcm_new,336 .sync_stop = dmaengine_pcm_sync_stop,337};338 339static const struct snd_soc_component_driver dmaengine_pcm_component_process = {340 .name = SND_DMAENGINE_PCM_DRV_NAME,341 .probe_order = SND_SOC_COMP_ORDER_LATE,342 .open = dmaengine_pcm_open,343 .close = dmaengine_pcm_close,344 .hw_params = dmaengine_pcm_hw_params,345 .trigger = dmaengine_pcm_trigger,346 .pointer = dmaengine_pcm_pointer,347 .copy = dmaengine_copy,348 .pcm_construct = dmaengine_pcm_new,349 .sync_stop = dmaengine_pcm_sync_stop,350};351 352static const char * const dmaengine_pcm_dma_channel_names[] = {353 [SNDRV_PCM_STREAM_PLAYBACK] = "tx",354 [SNDRV_PCM_STREAM_CAPTURE] = "rx",355};356 357static int dmaengine_pcm_request_chan_of(struct dmaengine_pcm *pcm,358 struct device *dev, const struct snd_dmaengine_pcm_config *config)359{360 unsigned int i;361 const char *name;362 struct dma_chan *chan;363 364 if ((pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_DT) || (!dev->of_node &&365 !(config->dma_dev && config->dma_dev->of_node)))366 return 0;367 368 if (config->dma_dev) {369 /*370 * If this warning is seen, it probably means that your Linux371 * device structure does not match your HW device structure.372 * It would be best to refactor the Linux device structure to373 * correctly match the HW structure.374 */375 dev_warn(dev, "DMA channels sourced from device %s",376 dev_name(config->dma_dev));377 dev = config->dma_dev;378 }379 380 for_each_pcm_streams(i) {381 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)382 name = "rx-tx";383 else384 name = dmaengine_pcm_dma_channel_names[i];385 if (config->chan_names[i])386 name = config->chan_names[i];387 chan = dma_request_chan(dev, name);388 if (IS_ERR(chan)) {389 /*390 * Only report probe deferral errors, channels391 * might not be present for devices that392 * support only TX or only RX.393 */394 if (PTR_ERR(chan) == -EPROBE_DEFER)395 return -EPROBE_DEFER;396 pcm->chan[i] = NULL;397 } else {398 pcm->chan[i] = chan;399 }400 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)401 break;402 }403 404 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)405 pcm->chan[1] = pcm->chan[0];406 407 return 0;408}409 410static void dmaengine_pcm_release_chan(struct dmaengine_pcm *pcm)411{412 unsigned int i;413 414 for_each_pcm_streams(i) {415 if (!pcm->chan[i])416 continue;417 dma_release_channel(pcm->chan[i]);418 if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)419 break;420 }421}422 423static const struct snd_dmaengine_pcm_config snd_dmaengine_pcm_default_config = {424 .prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,425};426 427/**428 * snd_dmaengine_pcm_register - Register a dmaengine based PCM device429 * @dev: The parent device for the PCM device430 * @config: Platform specific PCM configuration431 * @flags: Platform specific quirks432 */433int snd_dmaengine_pcm_register(struct device *dev,434 const struct snd_dmaengine_pcm_config *config, unsigned int flags)435{436 const struct snd_soc_component_driver *driver;437 struct dmaengine_pcm *pcm;438 int ret;439 440 pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);441 if (!pcm)442 return -ENOMEM;443 444#ifdef CONFIG_DEBUG_FS445 pcm->component.debugfs_prefix = "dma";446#endif447 if (!config)448 config = &snd_dmaengine_pcm_default_config;449 pcm->config = config;450 pcm->flags = flags;451 452 if (config->name)453 pcm->component.name = config->name;454 455 ret = dmaengine_pcm_request_chan_of(pcm, dev, config);456 if (ret)457 goto err_free_dma;458 459 if (config->process)460 driver = &dmaengine_pcm_component_process;461 else462 driver = &dmaengine_pcm_component;463 464 ret = snd_soc_component_initialize(&pcm->component, driver, dev);465 if (ret)466 goto err_free_dma;467 468 ret = snd_soc_add_component(&pcm->component, NULL, 0);469 if (ret)470 goto err_free_dma;471 472 return 0;473 474err_free_dma:475 dmaengine_pcm_release_chan(pcm);476 kfree(pcm);477 return ret;478}479EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register);480 481/**482 * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device483 * @dev: Parent device the PCM was register with484 *485 * Removes a dmaengine based PCM device previously registered with486 * snd_dmaengine_pcm_register.487 */488void snd_dmaengine_pcm_unregister(struct device *dev)489{490 struct snd_soc_component *component;491 struct dmaengine_pcm *pcm;492 493 component = snd_soc_lookup_component(dev, SND_DMAENGINE_PCM_DRV_NAME);494 if (!component)495 return;496 497 pcm = soc_component_to_pcm(component);498 499 snd_soc_unregister_component_by_driver(dev, component->driver);500 dmaengine_pcm_release_chan(pcm);501 kfree(pcm);502}503EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister);504 505MODULE_DESCRIPTION("ASoC helpers for generic PCM dmaengine API");506MODULE_LICENSE("GPL");507