1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Freescale ASRC ALSA SoC Platform (DMA) driver 4 // 5 // Copyright (C) 2014 Freescale Semiconductor, Inc. 6 // 7 // Author: Nicolin Chen <nicoleotsuka@gmail.com> 8 9 #include <linux/dma-mapping.h> 10 #include <linux/module.h> 11 #include <linux/dma/imx-dma.h> 12 #include <sound/dmaengine_pcm.h> 13 #include <sound/pcm_params.h> 14 15 #include "fsl_asrc_common.h" 16 17 #define FSL_ASRC_DMABUF_SIZE (256 * 1024) 18 19 static struct snd_pcm_hardware snd_imx_hardware = { 20 .info = SNDRV_PCM_INFO_INTERLEAVED | 21 SNDRV_PCM_INFO_BLOCK_TRANSFER | 22 SNDRV_PCM_INFO_MMAP | 23 SNDRV_PCM_INFO_MMAP_VALID, 24 .buffer_bytes_max = FSL_ASRC_DMABUF_SIZE, 25 .period_bytes_min = 128, 26 .period_bytes_max = 65535, /* Limited by SDMA engine */ 27 .periods_min = 2, 28 .periods_max = 255, 29 .fifo_size = 0, 30 }; 31 32 static bool filter(struct dma_chan *chan, void *param) 33 { 34 if (!imx_dma_is_general_purpose(chan)) 35 return false; 36 37 chan->private = param; 38 39 return true; 40 } 41 42 static void fsl_asrc_dma_complete(void *arg) 43 { 44 struct snd_pcm_substream *substream = arg; 45 struct snd_pcm_runtime *runtime = substream->runtime; 46 struct fsl_asrc_pair *pair = runtime->private_data; 47 48 pair->pos += snd_pcm_lib_period_bytes(substream); 49 if (pair->pos >= snd_pcm_lib_buffer_bytes(substream)) 50 pair->pos = 0; 51 52 snd_pcm_period_elapsed(substream); 53 } 54 55 static int fsl_asrc_dma_prepare_and_submit(struct snd_pcm_substream *substream, 56 struct snd_soc_component *component) 57 { 58 u8 dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? OUT : IN; 59 struct snd_pcm_runtime *runtime = substream->runtime; 60 struct fsl_asrc_pair *pair = runtime->private_data; 61 struct device *dev = component->dev; 62 unsigned long flags = DMA_CTRL_ACK; 63 64 /* Prepare and submit Front-End DMA channel */ 65 if (!substream->runtime->no_period_wakeup) 66 flags |= DMA_PREP_INTERRUPT; 67 68 pair->pos = 0; 69 pair->desc[!dir] = dmaengine_prep_dma_cyclic( 70 pair->dma_chan[!dir], runtime->dma_addr, 71 snd_pcm_lib_buffer_bytes(substream), 72 snd_pcm_lib_period_bytes(substream), 73 dir == OUT ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM, flags); 74 if (!pair->desc[!dir]) { 75 dev_err(dev, "failed to prepare slave DMA for Front-End\n"); 76 return -ENOMEM; 77 } 78 79 pair->desc[!dir]->callback = fsl_asrc_dma_complete; 80 pair->desc[!dir]->callback_param = substream; 81 82 dmaengine_submit(pair->desc[!dir]); 83 84 /* Prepare and submit Back-End DMA channel */ 85 pair->desc[dir] = dmaengine_prep_dma_cyclic( 86 pair->dma_chan[dir], 0xffff, 64, 64, DMA_DEV_TO_DEV, 0); 87 if (!pair->desc[dir]) { 88 dev_err(dev, "failed to prepare slave DMA for Back-End\n"); 89 return -ENOMEM; 90 } 91 92 dmaengine_submit(pair->desc[dir]); 93 94 return 0; 95 } 96 97 static int fsl_asrc_dma_trigger(struct snd_soc_component *component, 98 struct snd_pcm_substream *substream, int cmd) 99 { 100 struct snd_pcm_runtime *runtime = substream->runtime; 101 struct fsl_asrc_pair *pair = runtime->private_data; 102 int ret; 103 104 switch (cmd) { 105 case SNDRV_PCM_TRIGGER_START: 106 case SNDRV_PCM_TRIGGER_RESUME: 107 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 108 ret = fsl_asrc_dma_prepare_and_submit(substream, component); 109 if (ret) 110 return ret; 111 dma_async_issue_pending(pair->dma_chan[IN]); 112 dma_async_issue_pending(pair->dma_chan[OUT]); 113 break; 114 case SNDRV_PCM_TRIGGER_STOP: 115 case SNDRV_PCM_TRIGGER_SUSPEND: 116 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 117 dmaengine_terminate_async(pair->dma_chan[OUT]); 118 dmaengine_terminate_async(pair->dma_chan[IN]); 119 break; 120 default: 121 return -EINVAL; 122 } 123 124 return 0; 125 } 126 127 static int fsl_asrc_dma_hw_params(struct snd_soc_component *component, 128 struct snd_pcm_substream *substream, 129 struct snd_pcm_hw_params *params) 130 { 131 enum dma_slave_buswidth buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; 132 enum sdma_peripheral_type be_peripheral_type = IMX_DMATYPE_SSI; 133 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 134 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 135 struct snd_dmaengine_dai_dma_data *dma_params_fe = NULL; 136 struct snd_dmaengine_dai_dma_data *dma_params_be = NULL; 137 struct snd_pcm_runtime *runtime = substream->runtime; 138 struct fsl_asrc_pair *pair = runtime->private_data; 139 struct dma_chan *tmp_chan = NULL, *be_chan = NULL; 140 struct snd_soc_component *component_be = NULL; 141 struct fsl_asrc *asrc = pair->asrc; 142 struct dma_slave_config config_fe = {}, config_be = {}; 143 struct sdma_peripheral_config audio_config; 144 enum asrc_pair_index index = pair->index; 145 struct device *dev = component->dev; 146 struct device_node *of_dma_node; 147 int stream = substream->stream; 148 struct imx_dma_data *tmp_data; 149 struct snd_soc_dpcm *dpcm; 150 struct device *dev_be; 151 u8 dir = tx ? OUT : IN; 152 dma_cap_mask_t mask; 153 int ret, width; 154 155 /* Fetch the Back-End dma_data from DPCM */ 156 for_each_dpcm_be(rtd, stream, dpcm) { 157 struct snd_soc_pcm_runtime *be = dpcm->be; 158 struct snd_pcm_substream *substream_be; 159 struct snd_soc_dai *dai_cpu = snd_soc_rtd_to_cpu(be, 0); 160 struct snd_soc_dai *dai_codec = snd_soc_rtd_to_codec(be, 0); 161 struct snd_soc_dai *dai; 162 163 if (dpcm->fe != rtd) 164 continue; 165 166 /* 167 * With audio graph card, original cpu dai is changed to codec 168 * device in backend, so if cpu dai is dummy device in backend, 169 * get the codec dai device, which is the real hardware device 170 * connected. 171 */ 172 if (!snd_soc_dai_is_dummy(dai_cpu)) 173 dai = dai_cpu; 174 else 175 dai = dai_codec; 176 177 substream_be = snd_soc_dpcm_get_substream(be, stream); 178 dma_params_be = snd_soc_dai_get_dma_data(dai, substream_be); 179 dev_be = dai->dev; 180 break; 181 } 182 183 if (!dma_params_be) { 184 dev_err(dev, "failed to get the substream of Back-End\n"); 185 return -EINVAL; 186 } 187 188 /* Override dma_data of the Front-End and config its dmaengine */ 189 dma_params_fe = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream); 190 dma_params_fe->addr = asrc->paddr + asrc->get_fifo_addr(!dir, index); 191 dma_params_fe->maxburst = dma_params_be->maxburst; 192 193 pair->dma_chan[!dir] = asrc->get_dma_channel(pair, !dir); 194 if (!pair->dma_chan[!dir]) { 195 dev_err(dev, "failed to request DMA channel\n"); 196 return -EINVAL; 197 } 198 199 ret = snd_dmaengine_pcm_prepare_slave_config(substream, params, &config_fe); 200 if (ret) { 201 dev_err(dev, "failed to prepare DMA config for Front-End\n"); 202 return ret; 203 } 204 205 ret = dmaengine_slave_config(pair->dma_chan[!dir], &config_fe); 206 if (ret) { 207 dev_err(dev, "failed to config DMA channel for Front-End\n"); 208 return ret; 209 } 210 211 /* Request and config DMA channel for Back-End */ 212 dma_cap_zero(mask); 213 dma_cap_set(DMA_SLAVE, mask); 214 dma_cap_set(DMA_CYCLIC, mask); 215 216 /* 217 * The Back-End device might have already requested a DMA channel, 218 * so try to reuse it first, and then request a new one upon NULL. 219 */ 220 component_be = snd_soc_lookup_component_nolocked(dev_be, SND_DMAENGINE_PCM_DRV_NAME); 221 if (component_be) { 222 be_chan = soc_component_to_pcm(component_be)->chan[substream->stream]; 223 tmp_chan = be_chan; 224 } 225 if (!tmp_chan) { 226 tmp_chan = dma_request_chan(dev_be, tx ? "tx" : "rx"); 227 if (IS_ERR(tmp_chan)) { 228 dev_err(dev, "failed to request DMA channel for Back-End\n"); 229 return -EINVAL; 230 } 231 } 232 233 /* 234 * An EDMA DEV_TO_DEV channel is fixed and bound with DMA event of each 235 * peripheral, unlike SDMA channel that is allocated dynamically. So no 236 * need to configure dma_request and dma_request2, but get dma_chan of 237 * Back-End device directly via dma_request_chan. 238 */ 239 if (!asrc->use_edma) { 240 /* Get DMA request of Back-End */ 241 tmp_data = tmp_chan->private; 242 pair->dma_data.dma_request = tmp_data->dma_request; 243 be_peripheral_type = tmp_data->peripheral_type; 244 if (!be_chan) 245 dma_release_channel(tmp_chan); 246 247 /* Get DMA request of Front-End */ 248 tmp_chan = asrc->get_dma_channel(pair, dir); 249 tmp_data = tmp_chan->private; 250 pair->dma_data.dma_request2 = tmp_data->dma_request; 251 pair->dma_data.peripheral_type = tmp_data->peripheral_type; 252 pair->dma_data.priority = tmp_data->priority; 253 dma_release_channel(tmp_chan); 254 255 of_dma_node = pair->dma_chan[!dir]->device->dev->of_node; 256 pair->dma_chan[dir] = 257 __dma_request_channel(&mask, filter, &pair->dma_data, 258 of_dma_node); 259 pair->req_dma_chan = true; 260 } else { 261 pair->dma_chan[dir] = tmp_chan; 262 /* Do not flag to release if we are reusing the Back-End one */ 263 pair->req_dma_chan = !be_chan; 264 } 265 266 if (!pair->dma_chan[dir]) { 267 dev_err(dev, "failed to request DMA channel for Back-End\n"); 268 return -EINVAL; 269 } 270 271 width = snd_pcm_format_physical_width(asrc->asrc_format); 272 if (width < 8 || width > 64) 273 return -EINVAL; 274 else if (width == 8) 275 buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE; 276 else if (width == 16) 277 buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES; 278 else if (width == 24) 279 buswidth = DMA_SLAVE_BUSWIDTH_3_BYTES; 280 else if (width <= 32) 281 buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES; 282 else 283 buswidth = DMA_SLAVE_BUSWIDTH_8_BYTES; 284 285 config_be.direction = DMA_DEV_TO_DEV; 286 config_be.src_addr_width = buswidth; 287 config_be.src_maxburst = dma_params_be->maxburst; 288 config_be.dst_addr_width = buswidth; 289 config_be.dst_maxburst = dma_params_be->maxburst; 290 291 memset(&audio_config, 0, sizeof(audio_config)); 292 config_be.peripheral_config = &audio_config; 293 config_be.peripheral_size = sizeof(audio_config); 294 295 if (tx && (be_peripheral_type == IMX_DMATYPE_SSI_DUAL || 296 be_peripheral_type == IMX_DMATYPE_SPDIF)) 297 audio_config.n_fifos_dst = 2; 298 if (!tx && (be_peripheral_type == IMX_DMATYPE_SSI_DUAL || 299 be_peripheral_type == IMX_DMATYPE_SPDIF)) 300 audio_config.n_fifos_src = 2; 301 302 if (tx) { 303 config_be.src_addr = asrc->paddr + asrc->get_fifo_addr(OUT, index); 304 config_be.dst_addr = dma_params_be->addr; 305 } else { 306 config_be.dst_addr = asrc->paddr + asrc->get_fifo_addr(IN, index); 307 config_be.src_addr = dma_params_be->addr; 308 } 309 310 ret = dmaengine_slave_config(pair->dma_chan[dir], &config_be); 311 if (ret) { 312 dev_err(dev, "failed to config DMA channel for Back-End\n"); 313 if (pair->req_dma_chan) 314 dma_release_channel(pair->dma_chan[dir]); 315 return ret; 316 } 317 318 return 0; 319 } 320 321 static int fsl_asrc_dma_hw_free(struct snd_soc_component *component, 322 struct snd_pcm_substream *substream) 323 { 324 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 325 struct snd_pcm_runtime *runtime = substream->runtime; 326 struct fsl_asrc_pair *pair = runtime->private_data; 327 u8 dir = tx ? OUT : IN; 328 329 if (pair->dma_chan[!dir]) 330 dma_release_channel(pair->dma_chan[!dir]); 331 332 /* release dev_to_dev chan if we aren't reusing the Back-End one */ 333 if (pair->dma_chan[dir] && pair->req_dma_chan) 334 dma_release_channel(pair->dma_chan[dir]); 335 336 pair->dma_chan[!dir] = NULL; 337 pair->dma_chan[dir] = NULL; 338 339 return 0; 340 } 341 342 static int fsl_asrc_dma_startup(struct snd_soc_component *component, 343 struct snd_pcm_substream *substream) 344 { 345 bool tx = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 346 struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream); 347 struct snd_pcm_runtime *runtime = substream->runtime; 348 struct snd_dmaengine_dai_dma_data *dma_data; 349 struct device *dev = component->dev; 350 struct fsl_asrc *asrc = dev_get_drvdata(dev); 351 struct fsl_asrc_pair *pair; 352 struct dma_chan *tmp_chan = NULL; 353 u8 dir = tx ? OUT : IN; 354 bool release_pair = true; 355 int ret = 0; 356 357 ret = snd_pcm_hw_constraint_integer(substream->runtime, 358 SNDRV_PCM_HW_PARAM_PERIODS); 359 if (ret < 0) { 360 dev_err(dev, "failed to set pcm hw params periods\n"); 361 return ret; 362 } 363 364 pair = kzalloc(sizeof(*pair) + asrc->pair_priv_size, GFP_KERNEL); 365 if (!pair) 366 return -ENOMEM; 367 368 pair->asrc = asrc; 369 pair->private = (void *)pair + sizeof(struct fsl_asrc_pair); 370 371 runtime->private_data = pair; 372 373 /* Request a dummy pair, which will be released later. 374 * Request pair function needs channel num as input, for this 375 * dummy pair, we just request "1" channel temporarily. 376 */ 377 ret = asrc->request_pair(1, pair); 378 if (ret < 0) { 379 dev_err(dev, "failed to request asrc pair\n"); 380 goto req_pair_err; 381 } 382 383 /* Request a dummy dma channel, which will be released later. */ 384 tmp_chan = asrc->get_dma_channel(pair, dir); 385 if (!tmp_chan) { 386 dev_err(dev, "failed to get dma channel\n"); 387 ret = -EINVAL; 388 goto dma_chan_err; 389 } 390 391 dma_data = snd_soc_dai_get_dma_data(snd_soc_rtd_to_cpu(rtd, 0), substream); 392 393 /* Refine the snd_imx_hardware according to caps of DMA. */ 394 ret = snd_dmaengine_pcm_refine_runtime_hwparams(substream, 395 dma_data, 396 &snd_imx_hardware, 397 tmp_chan); 398 if (ret < 0) { 399 dev_err(dev, "failed to refine runtime hwparams\n"); 400 goto out; 401 } 402 403 release_pair = false; 404 snd_soc_set_runtime_hwparams(substream, &snd_imx_hardware); 405 406 out: 407 dma_release_channel(tmp_chan); 408 409 dma_chan_err: 410 asrc->release_pair(pair); 411 412 req_pair_err: 413 if (release_pair) 414 kfree(pair); 415 416 return ret; 417 } 418 419 static int fsl_asrc_dma_shutdown(struct snd_soc_component *component, 420 struct snd_pcm_substream *substream) 421 { 422 struct snd_pcm_runtime *runtime = substream->runtime; 423 struct fsl_asrc_pair *pair = runtime->private_data; 424 struct fsl_asrc *asrc; 425 426 if (!pair) 427 return 0; 428 429 asrc = pair->asrc; 430 431 if (asrc->pair[pair->index] == pair) 432 asrc->pair[pair->index] = NULL; 433 434 kfree(pair); 435 436 return 0; 437 } 438 439 static snd_pcm_uframes_t 440 fsl_asrc_dma_pcm_pointer(struct snd_soc_component *component, 441 struct snd_pcm_substream *substream) 442 { 443 struct snd_pcm_runtime *runtime = substream->runtime; 444 struct fsl_asrc_pair *pair = runtime->private_data; 445 446 return bytes_to_frames(substream->runtime, pair->pos); 447 } 448 449 static int fsl_asrc_dma_pcm_new(struct snd_soc_component *component, 450 struct snd_soc_pcm_runtime *rtd) 451 { 452 struct snd_card *card = rtd->card->snd_card; 453 struct snd_pcm *pcm = rtd->pcm; 454 int ret; 455 456 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); 457 if (ret) { 458 dev_err(card->dev, "failed to set DMA mask\n"); 459 return ret; 460 } 461 462 return snd_pcm_set_fixed_buffer_all(pcm, SNDRV_DMA_TYPE_DEV, 463 card->dev, FSL_ASRC_DMABUF_SIZE); 464 } 465 466 struct snd_soc_component_driver fsl_asrc_component = { 467 .name = DRV_NAME, 468 .hw_params = fsl_asrc_dma_hw_params, 469 .hw_free = fsl_asrc_dma_hw_free, 470 .trigger = fsl_asrc_dma_trigger, 471 .open = fsl_asrc_dma_startup, 472 .close = fsl_asrc_dma_shutdown, 473 .pointer = fsl_asrc_dma_pcm_pointer, 474 .pcm_construct = fsl_asrc_dma_pcm_new, 475 .legacy_dai_naming = 1, 476 }; 477 EXPORT_SYMBOL_GPL(fsl_asrc_component); 478