1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * ALSA SoC using the QUICC Multichannel Controller (QMC) 4 * 5 * Copyright 2022 CS GROUP France 6 * 7 * Author: Herve Codina <herve.codina@bootlin.com> 8 */ 9 10 #include <linux/dma-mapping.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/of_platform.h> 14 #include <linux/platform_device.h> 15 #include <linux/slab.h> 16 #include <soc/fsl/qe/qmc.h> 17 #include <sound/pcm_params.h> 18 #include <sound/soc.h> 19 20 struct qmc_dai { 21 char *name; 22 int id; 23 struct device *dev; 24 struct qmc_chan *qmc_chan; 25 unsigned int nb_tx_ts; 26 unsigned int nb_rx_ts; 27 }; 28 29 struct qmc_audio { 30 struct device *dev; 31 unsigned int num_dais; 32 struct qmc_dai *dais; 33 struct snd_soc_dai_driver *dai_drivers; 34 }; 35 36 struct qmc_dai_prtd { 37 struct qmc_dai *qmc_dai; 38 dma_addr_t dma_buffer_start; 39 dma_addr_t period_ptr_submitted; 40 dma_addr_t period_ptr_ended; 41 dma_addr_t dma_buffer_end; 42 size_t period_size; 43 struct snd_pcm_substream *substream; 44 }; 45 46 static int qmc_audio_pcm_construct(struct snd_soc_component *component, 47 struct snd_soc_pcm_runtime *rtd) 48 { 49 struct snd_card *card = rtd->card->snd_card; 50 int ret; 51 52 ret = dma_coerce_mask_and_coherent(card->dev, DMA_BIT_MASK(32)); 53 if (ret) 54 return ret; 55 56 snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_DEV, card->dev, 57 64*1024, 64*1024); 58 return 0; 59 } 60 61 static int qmc_audio_pcm_hw_params(struct snd_soc_component *component, 62 struct snd_pcm_substream *substream, 63 struct snd_pcm_hw_params *params) 64 { 65 struct snd_pcm_runtime *runtime = substream->runtime; 66 struct qmc_dai_prtd *prtd = substream->runtime->private_data; 67 68 prtd->dma_buffer_start = runtime->dma_addr; 69 prtd->dma_buffer_end = runtime->dma_addr + params_buffer_bytes(params); 70 prtd->period_size = params_period_bytes(params); 71 prtd->period_ptr_submitted = prtd->dma_buffer_start; 72 prtd->period_ptr_ended = prtd->dma_buffer_start; 73 prtd->substream = substream; 74 75 return 0; 76 } 77 78 static void qmc_audio_pcm_write_complete(void *context) 79 { 80 struct qmc_dai_prtd *prtd = context; 81 int ret; 82 83 prtd->period_ptr_ended += prtd->period_size; 84 if (prtd->period_ptr_ended >= prtd->dma_buffer_end) 85 prtd->period_ptr_ended = prtd->dma_buffer_start; 86 87 prtd->period_ptr_submitted += prtd->period_size; 88 if (prtd->period_ptr_submitted >= prtd->dma_buffer_end) 89 prtd->period_ptr_submitted = prtd->dma_buffer_start; 90 91 ret = qmc_chan_write_submit(prtd->qmc_dai->qmc_chan, 92 prtd->period_ptr_submitted, prtd->period_size, 93 qmc_audio_pcm_write_complete, prtd); 94 if (ret) { 95 dev_err(prtd->qmc_dai->dev, "write_submit failed %d\n", 96 ret); 97 } 98 99 snd_pcm_period_elapsed(prtd->substream); 100 } 101 102 static void qmc_audio_pcm_read_complete(void *context, size_t length) 103 { 104 struct qmc_dai_prtd *prtd = context; 105 int ret; 106 107 if (length != prtd->period_size) { 108 dev_err(prtd->qmc_dai->dev, "read complete length = %zu, exp %zu\n", 109 length, prtd->period_size); 110 } 111 112 prtd->period_ptr_ended += prtd->period_size; 113 if (prtd->period_ptr_ended >= prtd->dma_buffer_end) 114 prtd->period_ptr_ended = prtd->dma_buffer_start; 115 116 prtd->period_ptr_submitted += prtd->period_size; 117 if (prtd->period_ptr_submitted >= prtd->dma_buffer_end) 118 prtd->period_ptr_submitted = prtd->dma_buffer_start; 119 120 ret = qmc_chan_read_submit(prtd->qmc_dai->qmc_chan, 121 prtd->period_ptr_submitted, prtd->period_size, 122 qmc_audio_pcm_read_complete, prtd); 123 if (ret) { 124 dev_err(prtd->qmc_dai->dev, "read_submit failed %d\n", 125 ret); 126 } 127 128 snd_pcm_period_elapsed(prtd->substream); 129 } 130 131 static int qmc_audio_pcm_trigger(struct snd_soc_component *component, 132 struct snd_pcm_substream *substream, int cmd) 133 { 134 struct qmc_dai_prtd *prtd = substream->runtime->private_data; 135 int ret; 136 137 if (!prtd->qmc_dai) { 138 dev_err(component->dev, "qmc_dai is not set\n"); 139 return -EINVAL; 140 } 141 142 switch (cmd) { 143 case SNDRV_PCM_TRIGGER_START: 144 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 145 /* Submit first chunk ... */ 146 ret = qmc_chan_write_submit(prtd->qmc_dai->qmc_chan, 147 prtd->period_ptr_submitted, prtd->period_size, 148 qmc_audio_pcm_write_complete, prtd); 149 if (ret) { 150 dev_err(component->dev, "write_submit failed %d\n", 151 ret); 152 return ret; 153 } 154 155 /* ... prepare next one ... */ 156 prtd->period_ptr_submitted += prtd->period_size; 157 if (prtd->period_ptr_submitted >= prtd->dma_buffer_end) 158 prtd->period_ptr_submitted = prtd->dma_buffer_start; 159 160 /* ... and send it */ 161 ret = qmc_chan_write_submit(prtd->qmc_dai->qmc_chan, 162 prtd->period_ptr_submitted, prtd->period_size, 163 qmc_audio_pcm_write_complete, prtd); 164 if (ret) { 165 dev_err(component->dev, "write_submit failed %d\n", 166 ret); 167 return ret; 168 } 169 } else { 170 /* Submit first chunk ... */ 171 ret = qmc_chan_read_submit(prtd->qmc_dai->qmc_chan, 172 prtd->period_ptr_submitted, prtd->period_size, 173 qmc_audio_pcm_read_complete, prtd); 174 if (ret) { 175 dev_err(component->dev, "read_submit failed %d\n", 176 ret); 177 return ret; 178 } 179 180 /* ... prepare next one ... */ 181 prtd->period_ptr_submitted += prtd->period_size; 182 if (prtd->period_ptr_submitted >= prtd->dma_buffer_end) 183 prtd->period_ptr_submitted = prtd->dma_buffer_start; 184 185 /* ... and send it */ 186 ret = qmc_chan_read_submit(prtd->qmc_dai->qmc_chan, 187 prtd->period_ptr_submitted, prtd->period_size, 188 qmc_audio_pcm_read_complete, prtd); 189 if (ret) { 190 dev_err(component->dev, "write_submit failed %d\n", 191 ret); 192 return ret; 193 } 194 } 195 break; 196 197 case SNDRV_PCM_TRIGGER_RESUME: 198 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 199 break; 200 201 case SNDRV_PCM_TRIGGER_STOP: 202 case SNDRV_PCM_TRIGGER_SUSPEND: 203 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 204 break; 205 206 default: 207 return -EINVAL; 208 } 209 210 return 0; 211 } 212 213 static snd_pcm_uframes_t qmc_audio_pcm_pointer(struct snd_soc_component *component, 214 struct snd_pcm_substream *substream) 215 { 216 struct qmc_dai_prtd *prtd = substream->runtime->private_data; 217 218 return bytes_to_frames(substream->runtime, 219 prtd->period_ptr_ended - prtd->dma_buffer_start); 220 } 221 222 static int qmc_audio_of_xlate_dai_name(struct snd_soc_component *component, 223 const struct of_phandle_args *args, 224 const char **dai_name) 225 { 226 struct qmc_audio *qmc_audio = dev_get_drvdata(component->dev); 227 struct snd_soc_dai_driver *dai_driver; 228 int id = args->args[0]; 229 int i; 230 231 for (i = 0; i < qmc_audio->num_dais; i++) { 232 dai_driver = qmc_audio->dai_drivers + i; 233 if (dai_driver->id == id) { 234 *dai_name = dai_driver->name; 235 return 0; 236 } 237 } 238 239 return -EINVAL; 240 } 241 242 static const struct snd_pcm_hardware qmc_audio_pcm_hardware = { 243 .info = SNDRV_PCM_INFO_MMAP | 244 SNDRV_PCM_INFO_MMAP_VALID | 245 SNDRV_PCM_INFO_INTERLEAVED | 246 SNDRV_PCM_INFO_PAUSE, 247 .period_bytes_min = 32, 248 .period_bytes_max = 64*1024, 249 .periods_min = 2, 250 .periods_max = 2*1024, 251 .buffer_bytes_max = 64*1024, 252 }; 253 254 static int qmc_audio_pcm_open(struct snd_soc_component *component, 255 struct snd_pcm_substream *substream) 256 { 257 struct snd_pcm_runtime *runtime = substream->runtime; 258 struct qmc_dai_prtd *prtd; 259 int ret; 260 261 snd_soc_set_runtime_hwparams(substream, &qmc_audio_pcm_hardware); 262 263 /* ensure that buffer size is a multiple of period size */ 264 ret = snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 265 if (ret < 0) 266 return ret; 267 268 prtd = kzalloc(sizeof(*prtd), GFP_KERNEL); 269 if (prtd == NULL) 270 return -ENOMEM; 271 272 runtime->private_data = prtd; 273 274 return 0; 275 } 276 277 static int qmc_audio_pcm_close(struct snd_soc_component *component, 278 struct snd_pcm_substream *substream) 279 { 280 struct qmc_dai_prtd *prtd = substream->runtime->private_data; 281 282 kfree(prtd); 283 return 0; 284 } 285 286 static const struct snd_soc_component_driver qmc_audio_soc_platform = { 287 .open = qmc_audio_pcm_open, 288 .close = qmc_audio_pcm_close, 289 .hw_params = qmc_audio_pcm_hw_params, 290 .trigger = qmc_audio_pcm_trigger, 291 .pointer = qmc_audio_pcm_pointer, 292 .pcm_construct = qmc_audio_pcm_construct, 293 .of_xlate_dai_name = qmc_audio_of_xlate_dai_name, 294 }; 295 296 static unsigned int qmc_dai_get_index(struct snd_soc_dai *dai) 297 { 298 struct qmc_audio *qmc_audio = snd_soc_dai_get_drvdata(dai); 299 300 return dai->driver - qmc_audio->dai_drivers; 301 } 302 303 static struct qmc_dai *qmc_dai_get_data(struct snd_soc_dai *dai) 304 { 305 struct qmc_audio *qmc_audio = snd_soc_dai_get_drvdata(dai); 306 unsigned int index; 307 308 index = qmc_dai_get_index(dai); 309 if (index > qmc_audio->num_dais) 310 return NULL; 311 312 return qmc_audio->dais + index; 313 } 314 315 /* 316 * The constraints for format/channel is to match with the number of 8bit 317 * time-slots available. 318 */ 319 static int qmc_dai_hw_rule_channels_by_format(struct qmc_dai *qmc_dai, 320 struct snd_pcm_hw_params *params, 321 unsigned int nb_ts) 322 { 323 struct snd_interval *c = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 324 snd_pcm_format_t format = params_format(params); 325 struct snd_interval ch = {0}; 326 327 switch (snd_pcm_format_physical_width(format)) { 328 case 8: 329 ch.max = nb_ts; 330 break; 331 case 16: 332 ch.max = nb_ts/2; 333 break; 334 case 32: 335 ch.max = nb_ts/4; 336 break; 337 case 64: 338 ch.max = nb_ts/8; 339 break; 340 default: 341 dev_err(qmc_dai->dev, "format physical width %u not supported\n", 342 snd_pcm_format_physical_width(format)); 343 return -EINVAL; 344 } 345 346 ch.min = ch.max ? 1 : 0; 347 348 return snd_interval_refine(c, &ch); 349 } 350 351 static int qmc_dai_hw_rule_playback_channels_by_format(struct snd_pcm_hw_params *params, 352 struct snd_pcm_hw_rule *rule) 353 { 354 struct qmc_dai *qmc_dai = rule->private; 355 356 return qmc_dai_hw_rule_channels_by_format(qmc_dai, params, qmc_dai->nb_tx_ts); 357 } 358 359 static int qmc_dai_hw_rule_capture_channels_by_format( 360 struct snd_pcm_hw_params *params, 361 struct snd_pcm_hw_rule *rule) 362 { 363 struct qmc_dai *qmc_dai = rule->private; 364 365 return qmc_dai_hw_rule_channels_by_format(qmc_dai, params, qmc_dai->nb_rx_ts); 366 } 367 368 static int qmc_dai_hw_rule_format_by_channels(struct qmc_dai *qmc_dai, 369 struct snd_pcm_hw_params *params, 370 unsigned int nb_ts) 371 { 372 struct snd_mask *f_old = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT); 373 unsigned int channels = params_channels(params); 374 unsigned int slot_width; 375 snd_pcm_format_t format; 376 struct snd_mask f_new; 377 378 if (!channels || channels > nb_ts) { 379 dev_err(qmc_dai->dev, "channels %u not supported\n", 380 nb_ts); 381 return -EINVAL; 382 } 383 384 slot_width = (nb_ts / channels) * 8; 385 386 snd_mask_none(&f_new); 387 pcm_for_each_format(format) { 388 if (snd_mask_test_format(f_old, format)) { 389 if (snd_pcm_format_physical_width(format) <= slot_width) 390 snd_mask_set_format(&f_new, format); 391 } 392 } 393 394 return snd_mask_refine(f_old, &f_new); 395 } 396 397 static int qmc_dai_hw_rule_playback_format_by_channels( 398 struct snd_pcm_hw_params *params, 399 struct snd_pcm_hw_rule *rule) 400 { 401 struct qmc_dai *qmc_dai = rule->private; 402 403 return qmc_dai_hw_rule_format_by_channels(qmc_dai, params, qmc_dai->nb_tx_ts); 404 } 405 406 static int qmc_dai_hw_rule_capture_format_by_channels( 407 struct snd_pcm_hw_params *params, 408 struct snd_pcm_hw_rule *rule) 409 { 410 struct qmc_dai *qmc_dai = rule->private; 411 412 return qmc_dai_hw_rule_format_by_channels(qmc_dai, params, qmc_dai->nb_rx_ts); 413 } 414 415 static int qmc_dai_startup(struct snd_pcm_substream *substream, 416 struct snd_soc_dai *dai) 417 { 418 struct qmc_dai_prtd *prtd = substream->runtime->private_data; 419 snd_pcm_hw_rule_func_t hw_rule_channels_by_format; 420 snd_pcm_hw_rule_func_t hw_rule_format_by_channels; 421 struct qmc_dai *qmc_dai; 422 unsigned int frame_bits; 423 int ret; 424 425 qmc_dai = qmc_dai_get_data(dai); 426 if (!qmc_dai) { 427 dev_err(dai->dev, "Invalid dai\n"); 428 return -EINVAL; 429 } 430 431 prtd->qmc_dai = qmc_dai; 432 433 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 434 hw_rule_channels_by_format = qmc_dai_hw_rule_capture_channels_by_format; 435 hw_rule_format_by_channels = qmc_dai_hw_rule_capture_format_by_channels; 436 frame_bits = qmc_dai->nb_rx_ts * 8; 437 } else { 438 hw_rule_channels_by_format = qmc_dai_hw_rule_playback_channels_by_format; 439 hw_rule_format_by_channels = qmc_dai_hw_rule_playback_format_by_channels; 440 frame_bits = qmc_dai->nb_tx_ts * 8; 441 } 442 443 ret = snd_pcm_hw_rule_add(substream->runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 444 hw_rule_channels_by_format, qmc_dai, 445 SNDRV_PCM_HW_PARAM_FORMAT, -1); 446 if (ret) { 447 dev_err(dai->dev, "Failed to add channels rule (%d)\n", ret); 448 return ret; 449 } 450 451 ret = snd_pcm_hw_rule_add(substream->runtime, 0, SNDRV_PCM_HW_PARAM_FORMAT, 452 hw_rule_format_by_channels, qmc_dai, 453 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 454 if (ret) { 455 dev_err(dai->dev, "Failed to add format rule (%d)\n", ret); 456 return ret; 457 } 458 459 ret = snd_pcm_hw_constraint_single(substream->runtime, 460 SNDRV_PCM_HW_PARAM_FRAME_BITS, 461 frame_bits); 462 if (ret < 0) { 463 dev_err(dai->dev, "Failed to add frame_bits constraint (%d)\n", ret); 464 return ret; 465 } 466 467 return 0; 468 } 469 470 static int qmc_dai_hw_params(struct snd_pcm_substream *substream, 471 struct snd_pcm_hw_params *params, 472 struct snd_soc_dai *dai) 473 { 474 struct qmc_chan_param chan_param = {0}; 475 struct qmc_dai *qmc_dai; 476 int ret; 477 478 qmc_dai = qmc_dai_get_data(dai); 479 if (!qmc_dai) { 480 dev_err(dai->dev, "Invalid dai\n"); 481 return -EINVAL; 482 } 483 484 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 485 chan_param.mode = QMC_TRANSPARENT; 486 chan_param.transp.max_rx_buf_size = params_period_bytes(params); 487 ret = qmc_chan_set_param(qmc_dai->qmc_chan, &chan_param); 488 if (ret) { 489 dev_err(dai->dev, "set param failed %d\n", 490 ret); 491 return ret; 492 } 493 } 494 495 return 0; 496 } 497 498 static int qmc_dai_trigger(struct snd_pcm_substream *substream, int cmd, 499 struct snd_soc_dai *dai) 500 { 501 struct qmc_dai *qmc_dai; 502 int direction; 503 int ret; 504 505 qmc_dai = qmc_dai_get_data(dai); 506 if (!qmc_dai) { 507 dev_err(dai->dev, "Invalid dai\n"); 508 return -EINVAL; 509 } 510 511 direction = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? 512 QMC_CHAN_WRITE : QMC_CHAN_READ; 513 514 switch (cmd) { 515 case SNDRV_PCM_TRIGGER_START: 516 case SNDRV_PCM_TRIGGER_RESUME: 517 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: 518 ret = qmc_chan_start(qmc_dai->qmc_chan, direction); 519 if (ret) 520 return ret; 521 break; 522 523 case SNDRV_PCM_TRIGGER_STOP: 524 ret = qmc_chan_stop(qmc_dai->qmc_chan, direction); 525 if (ret) 526 return ret; 527 ret = qmc_chan_reset(qmc_dai->qmc_chan, direction); 528 if (ret) 529 return ret; 530 break; 531 532 case SNDRV_PCM_TRIGGER_SUSPEND: 533 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: 534 ret = qmc_chan_stop(qmc_dai->qmc_chan, direction); 535 if (ret) 536 return ret; 537 break; 538 539 default: 540 return -EINVAL; 541 } 542 543 return 0; 544 } 545 546 static const struct snd_soc_dai_ops qmc_dai_ops = { 547 .startup = qmc_dai_startup, 548 .trigger = qmc_dai_trigger, 549 .hw_params = qmc_dai_hw_params, 550 }; 551 552 static u64 qmc_audio_formats(u8 nb_ts) 553 { 554 unsigned int format_width; 555 unsigned int chan_width; 556 snd_pcm_format_t format; 557 u64 formats_mask; 558 559 if (!nb_ts) 560 return 0; 561 562 formats_mask = 0; 563 chan_width = nb_ts * 8; 564 pcm_for_each_format(format) { 565 /* 566 * Support format other than little-endian (ie big-endian or 567 * without endianness such as 8bit formats) 568 */ 569 if (snd_pcm_format_little_endian(format) == 1) 570 continue; 571 572 /* Support physical width multiple of 8bit */ 573 format_width = snd_pcm_format_physical_width(format); 574 if (format_width == 0 || format_width % 8) 575 continue; 576 577 /* 578 * And support physical width that can fit N times in the 579 * channel 580 */ 581 if (format_width > chan_width || chan_width % format_width) 582 continue; 583 584 formats_mask |= pcm_format_to_bits(format); 585 } 586 return formats_mask; 587 } 588 589 static int qmc_audio_dai_parse(struct qmc_audio *qmc_audio, struct device_node *np, 590 struct qmc_dai *qmc_dai, struct snd_soc_dai_driver *qmc_soc_dai_driver) 591 { 592 struct qmc_chan_info info; 593 u32 val; 594 int ret; 595 596 qmc_dai->dev = qmc_audio->dev; 597 598 ret = of_property_read_u32(np, "reg", &val); 599 if (ret) { 600 dev_err(qmc_audio->dev, "%pOF: failed to read reg\n", np); 601 return ret; 602 } 603 qmc_dai->id = val; 604 605 qmc_dai->name = devm_kasprintf(qmc_audio->dev, GFP_KERNEL, "%s.%d", 606 np->parent->name, qmc_dai->id); 607 608 qmc_dai->qmc_chan = devm_qmc_chan_get_byphandle(qmc_audio->dev, np, 609 "fsl,qmc-chan"); 610 if (IS_ERR(qmc_dai->qmc_chan)) { 611 ret = PTR_ERR(qmc_dai->qmc_chan); 612 return dev_err_probe(qmc_audio->dev, ret, 613 "dai %d get QMC channel failed\n", qmc_dai->id); 614 } 615 616 qmc_soc_dai_driver->id = qmc_dai->id; 617 qmc_soc_dai_driver->name = qmc_dai->name; 618 619 ret = qmc_chan_get_info(qmc_dai->qmc_chan, &info); 620 if (ret) { 621 dev_err(qmc_audio->dev, "dai %d get QMC channel info failed %d\n", 622 qmc_dai->id, ret); 623 return ret; 624 } 625 dev_info(qmc_audio->dev, "dai %d QMC channel mode %d, nb_tx_ts %u, nb_rx_ts %u\n", 626 qmc_dai->id, info.mode, info.nb_tx_ts, info.nb_rx_ts); 627 628 if (info.mode != QMC_TRANSPARENT) { 629 dev_err(qmc_audio->dev, "dai %d QMC chan mode %d is not QMC_TRANSPARENT\n", 630 qmc_dai->id, info.mode); 631 return -EINVAL; 632 } 633 qmc_dai->nb_tx_ts = info.nb_tx_ts; 634 qmc_dai->nb_rx_ts = info.nb_rx_ts; 635 636 qmc_soc_dai_driver->playback.channels_min = 0; 637 qmc_soc_dai_driver->playback.channels_max = 0; 638 if (qmc_dai->nb_tx_ts) { 639 qmc_soc_dai_driver->playback.channels_min = 1; 640 qmc_soc_dai_driver->playback.channels_max = qmc_dai->nb_tx_ts; 641 } 642 qmc_soc_dai_driver->playback.formats = qmc_audio_formats(qmc_dai->nb_tx_ts); 643 644 qmc_soc_dai_driver->capture.channels_min = 0; 645 qmc_soc_dai_driver->capture.channels_max = 0; 646 if (qmc_dai->nb_rx_ts) { 647 qmc_soc_dai_driver->capture.channels_min = 1; 648 qmc_soc_dai_driver->capture.channels_max = qmc_dai->nb_rx_ts; 649 } 650 qmc_soc_dai_driver->capture.formats = qmc_audio_formats(qmc_dai->nb_rx_ts); 651 652 qmc_soc_dai_driver->playback.rates = snd_pcm_rate_to_rate_bit(info.tx_fs_rate); 653 qmc_soc_dai_driver->playback.rate_min = info.tx_fs_rate; 654 qmc_soc_dai_driver->playback.rate_max = info.tx_fs_rate; 655 qmc_soc_dai_driver->capture.rates = snd_pcm_rate_to_rate_bit(info.rx_fs_rate); 656 qmc_soc_dai_driver->capture.rate_min = info.rx_fs_rate; 657 qmc_soc_dai_driver->capture.rate_max = info.rx_fs_rate; 658 659 qmc_soc_dai_driver->ops = &qmc_dai_ops; 660 661 return 0; 662 } 663 664 static int qmc_audio_probe(struct platform_device *pdev) 665 { 666 struct device_node *np = pdev->dev.of_node; 667 struct qmc_audio *qmc_audio; 668 struct device_node *child; 669 unsigned int i; 670 int ret; 671 672 qmc_audio = devm_kzalloc(&pdev->dev, sizeof(*qmc_audio), GFP_KERNEL); 673 if (!qmc_audio) 674 return -ENOMEM; 675 676 qmc_audio->dev = &pdev->dev; 677 678 qmc_audio->num_dais = of_get_available_child_count(np); 679 if (qmc_audio->num_dais) { 680 qmc_audio->dais = devm_kcalloc(&pdev->dev, qmc_audio->num_dais, 681 sizeof(*qmc_audio->dais), 682 GFP_KERNEL); 683 if (!qmc_audio->dais) 684 return -ENOMEM; 685 686 qmc_audio->dai_drivers = devm_kcalloc(&pdev->dev, qmc_audio->num_dais, 687 sizeof(*qmc_audio->dai_drivers), 688 GFP_KERNEL); 689 if (!qmc_audio->dai_drivers) 690 return -ENOMEM; 691 } 692 693 i = 0; 694 for_each_available_child_of_node(np, child) { 695 ret = qmc_audio_dai_parse(qmc_audio, child, 696 qmc_audio->dais + i, 697 qmc_audio->dai_drivers + i); 698 if (ret) { 699 of_node_put(child); 700 return ret; 701 } 702 i++; 703 } 704 705 706 platform_set_drvdata(pdev, qmc_audio); 707 708 ret = devm_snd_soc_register_component(qmc_audio->dev, 709 &qmc_audio_soc_platform, 710 qmc_audio->dai_drivers, 711 qmc_audio->num_dais); 712 if (ret) 713 return ret; 714 715 return 0; 716 } 717 718 static const struct of_device_id qmc_audio_id_table[] = { 719 { .compatible = "fsl,qmc-audio" }, 720 {} /* sentinel */ 721 }; 722 MODULE_DEVICE_TABLE(of, qmc_audio_id_table); 723 724 static struct platform_driver qmc_audio_driver = { 725 .driver = { 726 .name = "fsl-qmc-audio", 727 .of_match_table = of_match_ptr(qmc_audio_id_table), 728 }, 729 .probe = qmc_audio_probe, 730 }; 731 module_platform_driver(qmc_audio_driver); 732 733 MODULE_AUTHOR("Herve Codina <herve.codina@bootlin.com>"); 734 MODULE_DESCRIPTION("CPM/QE QMC audio driver"); 735 MODULE_LICENSE("GPL"); 736