sound/soc/soc-generic-dmaengine-pcm.c

   1 /*
   2  *  Copyright (C) 2013, Analog Devices Inc.
   3  *      Author: Lars-Peter Clausen <lars@metafoo.de>
   4  *
   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.
   9  *
  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.
  13  *
  14  */
  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>
  23 #include <linux/of.h>
  24 #include <linux/of_dma.h>
  25
  26 #include <sound/dmaengine_pcm.h>
  27
  28 struct dmaengine_pcm {
  29         struct dma_chan *chan[SNDRV_PCM_STREAM_CAPTURE + 1];
  30         const struct snd_dmaengine_pcm_config *config;
  31         struct snd_soc_platform platform;
  32         unsigned int flags;
  33 };
  34
  35 static struct dmaengine_pcm *soc_platform_to_pcm(struct snd_soc_platform *p)
  36 {
  37         return container_of(p, struct dmaengine_pcm, platform);
  38 }
  39
  40 /**
  41  * snd_dmaengine_pcm_prepare_slave_config() - Generic prepare_slave_config callback
  42  * @substream: PCM substream
  43  * @params: hw_params
  44  * @slave_config: DMA slave config to prepare
  45  *
  46  * This function can be used as a generic prepare_slave_config callback for
  47  * platforms which make use of the snd_dmaengine_dai_dma_data struct for their
  48  * DAI DMA data. Internally the function will first call
  49  * snd_hwparams_to_dma_slave_config to fill in the slave config based on the
  50  * hw_params, followed by snd_dmaengine_set_config_from_dai_data to fill in the
  51  * remaining fields based on the DAI DMA data.
  52  */
  53 int snd_dmaengine_pcm_prepare_slave_config(struct snd_pcm_substream *substream,
  54         struct snd_pcm_hw_params *params, struct dma_slave_config *slave_config)
  55 {
  56         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  57         struct snd_dmaengine_dai_dma_data *dma_data;
  58         int ret;
  59
  60         dma_data = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream);
  61
  62         ret = snd_hwparams_to_dma_slave_config(substream, params, slave_config);
  63         if (ret)
  64                 return ret;
  65
  66         snd_dmaengine_pcm_set_config_from_dai_data(substream, dma_data,
  67                 slave_config);
  68
  69         return 0;
  70 }
  71 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_prepare_slave_config);
  72
  73 static int dmaengine_pcm_hw_params(struct snd_pcm_substream *substream,
  74         struct snd_pcm_hw_params *params)
  75 {
  76         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  77         struct dmaengine_pcm *pcm = soc_platform_to_pcm(rtd->platform);
  78         struct dma_chan *chan = snd_dmaengine_pcm_get_chan(substream);
  79         struct dma_slave_config slave_config;
  80         int ret;
  81
  82         if (pcm->config->prepare_slave_config) {
  83                 ret = pcm->config->prepare_slave_config(substream, params,
  84                                 &slave_config);
  85                 if (ret)
  86                         return ret;
  87
  88                 ret = dmaengine_slave_config(chan, &slave_config);
  89                 if (ret)
  90                         return ret;
  91         }
  92
  93         return snd_pcm_lib_malloc_pages(substream, params_buffer_bytes(params));
  94 }
  95
  96 static int dmaengine_pcm_open(struct snd_pcm_substream *substream)
  97 {
  98         struct snd_soc_pcm_runtime *rtd = substream->private_data;
  99         struct dmaengine_pcm *pcm = soc_platform_to_pcm(rtd->platform);
 100         struct dma_chan *chan = pcm->chan[substream->stream];
 101         int ret;
 102
 103         ret = snd_soc_set_runtime_hwparams(substream,
 104                                 pcm->config->pcm_hardware);
 105         if (ret)
 106                 return ret;
 107
 108         return snd_dmaengine_pcm_open(substream, chan);
 109 }
 110
 111 static struct device *dmaengine_dma_dev(struct dmaengine_pcm *pcm,
 112         struct snd_pcm_substream *substream)
 113 {
 114         if (!pcm->chan[substream->stream])
 115                 return NULL;
 116
 117         return pcm->chan[substream->stream]->device->dev;
 118 }
 119
 120 static void dmaengine_pcm_free(struct snd_pcm *pcm)
 121 {
 122         snd_pcm_lib_preallocate_free_for_all(pcm);
 123 }
 124
 125 static struct dma_chan *dmaengine_pcm_compat_request_channel(
 126         struct snd_soc_pcm_runtime *rtd,
 127         struct snd_pcm_substream *substream)
 128 {
 129         struct dmaengine_pcm *pcm = soc_platform_to_pcm(rtd->platform);
 130
 131         if ((pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX) && pcm->chan[0])
 132                 return pcm->chan[0];
 133
 134         if (pcm->config->compat_request_channel)
 135                 return pcm->config->compat_request_channel(rtd, substream);
 136
 137         return snd_dmaengine_pcm_request_channel(pcm->config->compat_filter_fn,
 138                 snd_soc_dai_get_dma_data(rtd->cpu_dai, substream));
 139 }
 140
 141 static int dmaengine_pcm_new(struct snd_soc_pcm_runtime *rtd)
 142 {
 143         struct dmaengine_pcm *pcm = soc_platform_to_pcm(rtd->platform);
 144         const struct snd_dmaengine_pcm_config *config = pcm->config;
 145         struct snd_pcm_substream *substream;
 146         unsigned int i;
 147         int ret;
 148
 149         for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_CAPTURE; i++) {
 150                 substream = rtd->pcm->streams[i].substream;
 151                 if (!substream)
 152                         continue;
 153
 154                 if (!pcm->chan[i] && (pcm->flags & SND_DMAENGINE_PCM_FLAG_COMPAT)) {
 155                         pcm->chan[i] = dmaengine_pcm_compat_request_channel(rtd,
 156                                 substream);
 157                 }
 158
 159                 if (!pcm->chan[i]) {
 160                         dev_err(rtd->platform->dev,
 161                                 "Missing dma channel for stream: %d\n", i);
 162                         ret = -EINVAL;
 163                         goto err_free;
 164                 }
 165
 166                 ret = snd_pcm_lib_preallocate_pages(substream,
 167                                 SNDRV_DMA_TYPE_DEV,
 168                                 dmaengine_dma_dev(pcm, substream),
 169                                 config->prealloc_buffer_size,
 170                                 config->pcm_hardware->buffer_bytes_max);
 171                 if (ret)
 172                         goto err_free;
 173         }
 174
 175         return 0;
 176
 177 err_free:
 178         dmaengine_pcm_free(rtd->pcm);
 179         return ret;
 180 }
 181
 182 static const struct snd_pcm_ops dmaengine_pcm_ops = {
 183         .open           = dmaengine_pcm_open,
 184         .close          = snd_dmaengine_pcm_close,
 185         .ioctl          = snd_pcm_lib_ioctl,
 186         .hw_params      = dmaengine_pcm_hw_params,
 187         .hw_free        = snd_pcm_lib_free_pages,
 188         .trigger        = snd_dmaengine_pcm_trigger,
 189         .pointer        = snd_dmaengine_pcm_pointer,
 190 };
 191
 192 static const struct snd_soc_platform_driver dmaengine_pcm_platform = {
 193         .ops            = &dmaengine_pcm_ops,
 194         .pcm_new        = dmaengine_pcm_new,
 195         .pcm_free       = dmaengine_pcm_free,
 196         .probe_order    = SND_SOC_COMP_ORDER_LATE,
 197 };
 198
 199 static const struct snd_pcm_ops dmaengine_no_residue_pcm_ops = {
 200         .open           = dmaengine_pcm_open,
 201         .close          = snd_dmaengine_pcm_close,
 202         .ioctl          = snd_pcm_lib_ioctl,
 203         .hw_params      = dmaengine_pcm_hw_params,
 204         .hw_free        = snd_pcm_lib_free_pages,
 205         .trigger        = snd_dmaengine_pcm_trigger,
 206         .pointer        = snd_dmaengine_pcm_pointer_no_residue,
 207 };
 208
 209 static const struct snd_soc_platform_driver dmaengine_no_residue_pcm_platform = {
 210         .ops            = &dmaengine_no_residue_pcm_ops,
 211         .pcm_new        = dmaengine_pcm_new,
 212         .pcm_free       = dmaengine_pcm_free,
 213         .probe_order    = SND_SOC_COMP_ORDER_LATE,
 214 };
 215
 216 static const char * const dmaengine_pcm_dma_channel_names[] = {
 217         [SNDRV_PCM_STREAM_PLAYBACK] = "tx",
 218         [SNDRV_PCM_STREAM_CAPTURE] = "rx",
 219 };
 220
 221 static void dmaengine_pcm_request_chan_of(struct dmaengine_pcm *pcm,
 222         struct device_node *of_node)
 223 {
 224         unsigned int i;
 225
 226         if ((pcm->flags & SND_DMAENGINE_PCM_FLAG_NO_DT) || !of_node)
 227                 return;
 228
 229         if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX) {
 230                 pcm->chan[0] = of_dma_request_slave_channel(of_node, "rx-tx");
 231                 pcm->chan[1] = pcm->chan[0];
 232         } else {
 233                 for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_CAPTURE; i++) {
 234                         pcm->chan[i] = of_dma_request_slave_channel(of_node,
 235                                         dmaengine_pcm_dma_channel_names[i]);
 236                 }
 237         }
 238 }
 239
 240 /**
 241  * snd_dmaengine_pcm_register - Register a dmaengine based PCM device
 242  * @dev: The parent device for the PCM device
 243  * @config: Platform specific PCM configuration
 244  * @flags: Platform specific quirks
 245  */
 246 int snd_dmaengine_pcm_register(struct device *dev,
 247         const struct snd_dmaengine_pcm_config *config, unsigned int flags)
 248 {
 249         struct dmaengine_pcm *pcm;
 250
 251         pcm = kzalloc(sizeof(*pcm), GFP_KERNEL);
 252         if (!pcm)
 253                 return -ENOMEM;
 254
 255         pcm->config = config;
 256         pcm->flags = flags;
 257
 258         dmaengine_pcm_request_chan_of(pcm, dev->of_node);
 259
 260         if (flags & SND_DMAENGINE_PCM_FLAG_NO_RESIDUE)
 261                 return snd_soc_add_platform(dev, &pcm->platform,
 262                                 &dmaengine_no_residue_pcm_platform);
 263         else
 264                 return snd_soc_add_platform(dev, &pcm->platform,
 265                                 &dmaengine_pcm_platform);
 266 }
 267 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_register);
 268
 269 /**
 270  * snd_dmaengine_pcm_unregister - Removes a dmaengine based PCM device
 271  * @dev: Parent device the PCM was register with
 272  *
 273  * Removes a dmaengine based PCM device previously registered with
 274  * snd_dmaengine_pcm_register.
 275  */
 276 void snd_dmaengine_pcm_unregister(struct device *dev)
 277 {
 278         struct snd_soc_platform *platform;
 279         struct dmaengine_pcm *pcm;
 280         unsigned int i;
 281
 282         platform = snd_soc_lookup_platform(dev);
 283         if (!platform)
 284                 return;
 285
 286         pcm = soc_platform_to_pcm(platform);
 287
 288         for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_CAPTURE; i++) {
 289                 if (pcm->chan[i]) {
 290                         dma_release_channel(pcm->chan[i]);
 291                         if (pcm->flags & SND_DMAENGINE_PCM_FLAG_HALF_DUPLEX)
 292                                 break;
 293                 }
 294         }
 295
 296         snd_soc_remove_platform(platform);
 297         kfree(pcm);
 298 }
 299 EXPORT_SYMBOL_GPL(snd_dmaengine_pcm_unregister);
 300
 301 MODULE_LICENSE("GPL");