1 /* 2 * Freescale ASRC ALSA SoC Platform (DMA) driver 3 * 4 * Copyright (C) 2014 Freescale Semiconductor, Inc. 5 * 6 * Author: Nicolin Chen <nicoleotsuka@gmail.com> 7 * 8 * This file is licensed under the terms of the GNU General Public License 9 * version 2. This program is licensed "as is" without any warranty of any 10 * kind, whether express or implied. 11 */ 12 13 #include <linux/dma-mapping.h> 14 #include <linux/module.h> 15 #include <linux/platform_data/dma-imx.h> 16 #include <sound/dmaengine_pcm.h> 17 #include <sound/pcm_params.h> 18 19 #include "fsl_asrc.h" 20 21 #define FSL_ASRC_DMABUF_SIZE (256 * 1024) 22 23 static struct snd_pcm_hardware snd_imx_hardware = { 24 .info = SNDRV_PCM_INFO_INTERLEAVED | 25 SNDRV_PCM_INFO_BLOCK_TRANSFER | 26 SNDRV_PCM_INFO_MMAP | 27 SNDRV_PCM_INFO_MMAP_VALID | 28 SNDRV_PCM_INFO_PAUSE | 29 SNDRV_PCM_INFO_RESUME, 30 .buffer_bytes_max = FSL_ASRC_DMABUF_SIZE, 31 .period_bytes_min = 128, 32 .period_bytes_max = 65535, /* Limited by SDMA engine */ 33 .periods_min = 2, 34 .periods_max = 255, 35 .fifo_size = 0, 36 }; 37 38 static bool filter(struct dma_chan *chan, void *param) 39 { 40 if (!imx_dma_is_general_purpose(chan)) 41 return false; 42 43 chan->private = param; 44 45 return true; 46 } 47 48 static void fsl_asrc_dma_complete(void *arg) 49 { 50 struct snd_pcm_substream *substream = arg; 51 struct snd_pcm_runtime *runtime = substream->runtime; 52 struct fsl_asrc_pair *pair = runtime->private_data; 53 54 pair->pos += snd_pcm_lib_period_bytes(substream); 55 if (pair->pos >= snd_pcm_lib_buffer_bytes(substream)) 56 pair->pos = 0; 57 58 snd_pcm_period_elapsed(substream); 59 } 60 61 static int fsl_asrc_dma_prepare_and_submit(struct snd_pcm_substream *substream) 62 { 63 u8 dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? OUT : IN; 64 struct snd_soc_pcm_runtime *rtd = substream->private_data; 65 struct snd_pcm_runtime *runtime = substream->runtime; 66 struct fsl_asrc_pair *pair = runtime->private_data; 67 struct device *dev = rtd->platform->dev; 68 unsigned long flags = DMA_CTRL_ACK; 69 70 /* Prepare and submit Front-End DMA channel */ 71 if (!substream->runtime->no_period_wakeup) 72 flags |= DMA_PREP_INTERRUPT; 73 74 pair->pos = 0; 75 pair->desc[!dir] = dmaengine_prep_dma_cyclic( 76 pair->dma_chan[!dir], runtime->dma_addr, 77 snd_pcm_lib_buffer_bytes(substream), 78 snd_pcm_lib_period_bytes(substream), 79 dir == OUT ? DMA_TO_DEVICE : DMA_FROM_DEVICE, flags); 80 if (!pair->desc[!dir]) { 81 dev_err(dev, "failed to prepare slave DMA for Front-End\n"); 82 return -ENOMEM; 83 } 84 85 pair->desc[!dir]->callback = fsl_asrc_dma_complete; 86 pair->desc[!dir]->callback_param = substream; 87 88 dmaengine_submit(pair->desc[!dir]); 89 90 /* Prepare and submit Back-End DMA channel */ 91 pair->desc[dir] = dmaengine_prep_dma_cyclic( 92 pair->dma_chan[dir], 0xffff, 64, 64, DMA_DEV_TO_DEV, 0); 93 if (!pair->desc[dir]) { 94 dev_err(dev, "failed to prepare slave DMA for Back-End\n"); 95 return -ENOMEM; 96 } 97 98 dmaengine_submit(pair->desc[dir]); 99 100 return 0; 101 } 102 103 static int fsl_asrc_dma_trigger(struct snd_pcm_substream *substream, int cmd) 104 { 105 struct snd_pcm_runtime *runtime = substream->runtime; 106 struct fsl_asrc_pair *pair = runtime->private_data; 107 int ret; 108 109 switch (cmd) { 110 case SNDRV_PCM_TRIGGER_START: 111 case SNDRV_PCM_TRIGGER_RESUME: 112 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 113 ret = fsl_asrc_dma_prepare_and_submit(substream); 114 if (ret) 115 return ret; 116 dma_async_issue_pending(pair->dma_chan[IN]); 117 dma_async_issue_pending(pair->dma_chan[OUT]); 118 break; 119 case SNDRV_PCM_TRIGGER_STOP: 120 case SNDRV_PCM_TRIGGER_SUSPEND: 121 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 122 dmaengine_terminate_all(pair->dma_chan[OUT]); 123 dmaengine_terminate_all(pair->dma_chan[IN]); 124 break; 125 default: 126 return -EINVAL; 127 } 128 129 return 0; 130 } 131 132 static int fsl_asrc_dma_hw_params(struct snd_pcm_substream *substream, 133 struct snd_pcm_hw_params *params) 134 { 135 enum dma_slave_buswidth buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; 136 struct snd_soc_pcm_runtime *rtd = substream->private_data; 137 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 138 struct snd_dmaengine_dai_dma_data *dma_params_fe = NULL; 139 struct snd_dmaengine_dai_dma_data *dma_params_be = NULL; 140 struct snd_pcm_runtime *runtime = substream->runtime; 141 struct fsl_asrc_pair *pair = runtime->private_data; 142 struct fsl_asrc *asrc_priv = pair->asrc_priv; 143 struct dma_slave_config config_fe, config_be; 144 enum asrc_pair_index index = pair->index; 145 struct device *dev = rtd->platform->dev; 146 int stream = substream->stream; 147 struct imx_dma_data *tmp_data; 148 struct snd_soc_dpcm *dpcm; 149 struct dma_chan *tmp_chan; 150 struct device *dev_be; 151 u8 dir = tx ? OUT : IN; 152 dma_cap_mask_t mask; 153 int ret; 154 155 /* Fetch the Back-End dma_data from DPCM */ 156 list_for_each_entry(dpcm, &rtd->dpcm[stream].be_clients, list_be) { 157 struct snd_soc_pcm_runtime *be = dpcm->be; 158 struct snd_pcm_substream *substream_be; 159 struct snd_soc_dai *dai = be->cpu_dai; 160 161 if (dpcm->fe != rtd) 162 continue; 163 164 substream_be = snd_soc_dpcm_get_substream(be, stream); 165 dma_params_be = snd_soc_dai_get_dma_data(dai, substream_be); 166 dev_be = dai->dev; 167 break; 168 } 169 170 if (!dma_params_be) { 171 dev_err(dev, "failed to get the substream of Back-End\n"); 172 return -EINVAL; 173 } 174 175 /* Override dma_data of the Front-End and config its dmaengine */ 176 dma_params_fe = snd_soc_dai_get_dma_data(rtd->cpu_dai, substream); 177 dma_params_fe->addr = asrc_priv->paddr + REG_ASRDx(!dir, index); 178 dma_params_fe->maxburst = dma_params_be->maxburst; 179 180 pair->dma_chan[!dir] = fsl_asrc_get_dma_channel(pair, !dir); 181 if (!pair->dma_chan[!dir]) { 182 dev_err(dev, "failed to request DMA channel\n"); 183 return -EINVAL; 184 } 185 186 memset(&config_fe, 0, sizeof(config_fe)); 187 ret = snd_dmaengine_pcm_prepare_slave_config(substream, params, &config_fe); 188 if (ret) { 189 dev_err(dev, "failed to prepare DMA config for Front-End\n"); 190 return ret; 191 } 192 193 ret = dmaengine_slave_config(pair->dma_chan[!dir], &config_fe); 194 if (ret) { 195 dev_err(dev, "failed to config DMA channel for Front-End\n"); 196 return ret; 197 } 198 199 /* Request and config DMA channel for Back-End */ 200 dma_cap_zero(mask); 201 dma_cap_set(DMA_SLAVE, mask); 202 dma_cap_set(DMA_CYCLIC, mask); 203 204 /* Get DMA request of Back-End */ 205 tmp_chan = dma_request_slave_channel(dev_be, tx ? "tx" : "rx"); 206 tmp_data = tmp_chan->private; 207 pair->dma_data.dma_request = tmp_data->dma_request; 208 dma_release_channel(tmp_chan); 209 210 /* Get DMA request of Front-End */ 211 tmp_chan = fsl_asrc_get_dma_channel(pair, dir); 212 tmp_data = tmp_chan->private; 213 pair->dma_data.dma_request2 = tmp_data->dma_request; 214 pair->dma_data.peripheral_type = tmp_data->peripheral_type; 215 pair->dma_data.priority = tmp_data->priority; 216 dma_release_channel(tmp_chan); 217 218 pair->dma_chan[dir] = dma_request_channel(mask, filter, &pair->dma_data); 219 if (!pair->dma_chan[dir]) { 220 dev_err(dev, "failed to request DMA channel for Back-End\n"); 221 return -EINVAL; 222 } 223 224 if (asrc_priv->asrc_width == 16) 225 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; 226 else 227 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES; 228 229 config_be.direction = DMA_DEV_TO_DEV; 230 config_be.src_addr_width = buswidth; 231 config_be.src_maxburst = dma_params_be->maxburst; 232 config_be.dst_addr_width = buswidth; 233 config_be.dst_maxburst = dma_params_be->maxburst; 234 235 if (tx) { 236 config_be.src_addr = asrc_priv->paddr + REG_ASRDO(index); 237 config_be.dst_addr = dma_params_be->addr; 238 } else { 239 config_be.dst_addr = asrc_priv->paddr + REG_ASRDI(index); 240 config_be.src_addr = dma_params_be->addr; 241 } 242 243 ret = dmaengine_slave_config(pair->dma_chan[dir], &config_be); 244 if (ret) { 245 dev_err(dev, "failed to config DMA channel for Back-End\n"); 246 return ret; 247 } 248 249 snd_pcm_set_runtime_buffer(substream, &substream->dma_buffer); 250 251 return 0; 252 } 253 254 static int fsl_asrc_dma_hw_free(struct snd_pcm_substream *substream) 255 { 256 struct snd_pcm_runtime *runtime = substream->runtime; 257 struct fsl_asrc_pair *pair = runtime->private_data; 258 259 snd_pcm_set_runtime_buffer(substream, NULL); 260 261 if (pair->dma_chan[IN]) 262 dma_release_channel(pair->dma_chan[IN]); 263 264 if (pair->dma_chan[OUT]) 265 dma_release_channel(pair->dma_chan[OUT]); 266 267 pair->dma_chan[IN] = NULL; 268 pair->dma_chan[OUT] = NULL; 269 270 return 0; 271 } 272 273 static int fsl_asrc_dma_startup(struct snd_pcm_substream *substream) 274 { 275 struct snd_soc_pcm_runtime *rtd = substream->private_data; 276 struct snd_pcm_runtime *runtime = substream->runtime; 277 struct device *dev = rtd->platform->dev; 278 struct fsl_asrc *asrc_priv = dev_get_drvdata(dev); 279 struct fsl_asrc_pair *pair; 280 281 pair = kzalloc(sizeof(struct fsl_asrc_pair), GFP_KERNEL); 282 if (!pair) { 283 dev_err(dev, "failed to allocate pair\n"); 284 return -ENOMEM; 285 } 286 287 pair->asrc_priv = asrc_priv; 288 289 runtime->private_data = pair; 290 291 snd_pcm_hw_constraint_integer(substream->runtime, 292 SNDRV_PCM_HW_PARAM_PERIODS); 293 snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware); 294 295 return 0; 296 } 297 298 static int fsl_asrc_dma_shutdown(struct snd_pcm_substream *substream) 299 { 300 struct snd_pcm_runtime *runtime = substream->runtime; 301 struct fsl_asrc_pair *pair = runtime->private_data; 302 struct fsl_asrc *asrc_priv; 303 304 if (!pair) 305 return 0; 306 307 asrc_priv = pair->asrc_priv; 308 309 if (asrc_priv->pair[pair->index] == pair) 310 asrc_priv->pair[pair->index] = NULL; 311 312 kfree(pair); 313 314 return 0; 315 } 316 317 static snd_pcm_uframes_t fsl_asrc_dma_pcm_pointer(struct snd_pcm_substream *substream) 318 { 319 struct snd_pcm_runtime *runtime = substream->runtime; 320 struct fsl_asrc_pair *pair = runtime->private_data; 321 322 return bytes_to_frames(substream->runtime, pair->pos); 323 } 324 325 static struct snd_pcm_ops fsl_asrc_dma_pcm_ops = { 326 .ioctl = snd_pcm_lib_ioctl, 327 .hw_params = fsl_asrc_dma_hw_params, 328 .hw_free = fsl_asrc_dma_hw_free, 329 .trigger = fsl_asrc_dma_trigger, 330 .open = fsl_asrc_dma_startup, 331 .close = fsl_asrc_dma_shutdown, 332 .pointer = fsl_asrc_dma_pcm_pointer, 333 }; 334 335 static int fsl_asrc_dma_pcm_new(struct snd_soc_pcm_runtime *rtd) 336 { 337 struct snd_card *card = rtd->card->snd_card; 338 struct snd_pcm_substream *substream; 339 struct snd_pcm *pcm = rtd->pcm; 340 int ret, i; 341 342 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); 343 if (ret) { 344 dev_err(card->dev, "failed to set DMA mask\n"); 345 return ret; 346 } 347 348 for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_LAST; i++) { 349 substream = pcm->streams[i].substream; 350 if (!substream) 351 continue; 352 353 ret = snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, pcm->card->dev, 354 FSL_ASRC_DMABUF_SIZE, &substream->dma_buffer); 355 if (ret) { 356 dev_err(card->dev, "failed to allocate DMA buffer\n"); 357 goto err; 358 } 359 } 360 361 return 0; 362 363 err: 364 if (--i == 0 && pcm->streams[i].substream) 365 snd_dma_free_pages(&pcm->streams[i].substream->dma_buffer); 366 367 return ret; 368 } 369 370 static void fsl_asrc_dma_pcm_free(struct snd_pcm *pcm) 371 { 372 struct snd_pcm_substream *substream; 373 int i; 374 375 for (i = SNDRV_PCM_STREAM_PLAYBACK; i <= SNDRV_PCM_STREAM_LAST; i++) { 376 substream = pcm->streams[i].substream; 377 if (!substream) 378 continue; 379 380 snd_dma_free_pages(&substream->dma_buffer); 381 substream->dma_buffer.area = NULL; 382 substream->dma_buffer.addr = 0; 383 } 384 } 385 386 struct snd_soc_platform_driver fsl_asrc_platform = { 387 .ops = &fsl_asrc_dma_pcm_ops, 388 .pcm_new = fsl_asrc_dma_pcm_new, 389 .pcm_free = fsl_asrc_dma_pcm_free, 390 }; 391 EXPORT_SYMBOL_GPL(fsl_asrc_platform); 392