1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Renesas R-Car SRU/SCU/SSIU/SSI support 4 // 5 // Copyright (C) 2013 Renesas Solutions Corp. 6 // Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 7 // 8 // Based on fsi.c 9 // Kuninori Morimoto <morimoto.kuninori@renesas.com> 10 11 /* 12 * Renesas R-Car sound device structure 13 * 14 * Gen1 15 * 16 * SRU : Sound Routing Unit 17 * - SRC : Sampling Rate Converter 18 * - CMD 19 * - CTU : Channel Count Conversion Unit 20 * - MIX : Mixer 21 * - DVC : Digital Volume and Mute Function 22 * - SSI : Serial Sound Interface 23 * 24 * Gen2 25 * 26 * SCU : Sampling Rate Converter Unit 27 * - SRC : Sampling Rate Converter 28 * - CMD 29 * - CTU : Channel Count Conversion Unit 30 * - MIX : Mixer 31 * - DVC : Digital Volume and Mute Function 32 * SSIU : Serial Sound Interface Unit 33 * - SSI : Serial Sound Interface 34 */ 35 36 /* 37 * driver data Image 38 * 39 * rsnd_priv 40 * | 41 * | ** this depends on Gen1/Gen2 42 * | 43 * +- gen 44 * | 45 * | ** these depend on data path 46 * | ** gen and platform data control it 47 * | 48 * +- rdai[0] 49 * | | sru ssiu ssi 50 * | +- playback -> [mod] -> [mod] -> [mod] -> ... 51 * | | 52 * | | sru ssiu ssi 53 * | +- capture -> [mod] -> [mod] -> [mod] -> ... 54 * | 55 * +- rdai[1] 56 * | | sru ssiu ssi 57 * | +- playback -> [mod] -> [mod] -> [mod] -> ... 58 * | | 59 * | | sru ssiu ssi 60 * | +- capture -> [mod] -> [mod] -> [mod] -> ... 61 * ... 62 * | 63 * | ** these control ssi 64 * | 65 * +- ssi 66 * | | 67 * | +- ssi[0] 68 * | +- ssi[1] 69 * | +- ssi[2] 70 * | ... 71 * | 72 * | ** these control src 73 * | 74 * +- src 75 * | 76 * +- src[0] 77 * +- src[1] 78 * +- src[2] 79 * ... 80 * 81 * 82 * for_each_rsnd_dai(xx, priv, xx) 83 * rdai[0] => rdai[1] => rdai[2] => ... 84 * 85 * for_each_rsnd_mod(xx, rdai, xx) 86 * [mod] => [mod] => [mod] => ... 87 * 88 * rsnd_dai_call(xxx, fn ) 89 * [mod]->fn() -> [mod]->fn() -> [mod]->fn()... 90 * 91 */ 92 93 #include <linux/pm_runtime.h> 94 #include "rsnd.h" 95 96 #define RSND_RATES SNDRV_PCM_RATE_8000_192000 97 #define RSND_FMTS (SNDRV_PCM_FMTBIT_S8 |\ 98 SNDRV_PCM_FMTBIT_S16_LE |\ 99 SNDRV_PCM_FMTBIT_S24_LE) 100 101 static const struct of_device_id rsnd_of_match[] = { 102 { .compatible = "renesas,rcar_sound-gen1", .data = (void *)RSND_GEN1 }, 103 { .compatible = "renesas,rcar_sound-gen2", .data = (void *)RSND_GEN2 }, 104 { .compatible = "renesas,rcar_sound-gen3", .data = (void *)RSND_GEN3 }, 105 /* Special Handling */ 106 { .compatible = "renesas,rcar_sound-r8a77990", .data = (void *)(RSND_GEN3 | RSND_SOC_E) }, 107 {}, 108 }; 109 MODULE_DEVICE_TABLE(of, rsnd_of_match); 110 111 /* 112 * rsnd_mod functions 113 */ 114 void rsnd_mod_make_sure(struct rsnd_mod *mod, enum rsnd_mod_type type) 115 { 116 if (mod->type != type) { 117 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 118 struct device *dev = rsnd_priv_to_dev(priv); 119 120 dev_warn(dev, "%s is not your expected module\n", 121 rsnd_mod_name(mod)); 122 } 123 } 124 125 struct dma_chan *rsnd_mod_dma_req(struct rsnd_dai_stream *io, 126 struct rsnd_mod *mod) 127 { 128 if (!mod || !mod->ops || !mod->ops->dma_req) 129 return NULL; 130 131 return mod->ops->dma_req(io, mod); 132 } 133 134 #define MOD_NAME_NUM 5 135 #define MOD_NAME_SIZE 16 136 char *rsnd_mod_name(struct rsnd_mod *mod) 137 { 138 static char names[MOD_NAME_NUM][MOD_NAME_SIZE]; 139 static int num; 140 char *name = names[num]; 141 142 num++; 143 if (num >= MOD_NAME_NUM) 144 num = 0; 145 146 /* 147 * Let's use same char to avoid pointlessness memory 148 * Thus, rsnd_mod_name() should be used immediately 149 * Don't keep pointer 150 */ 151 if ((mod)->ops->id_sub) { 152 snprintf(name, MOD_NAME_SIZE, "%s[%d%d]", 153 mod->ops->name, 154 rsnd_mod_id(mod), 155 rsnd_mod_id_sub(mod)); 156 } else { 157 snprintf(name, MOD_NAME_SIZE, "%s[%d]", 158 mod->ops->name, 159 rsnd_mod_id(mod)); 160 } 161 162 return name; 163 } 164 165 u32 *rsnd_mod_get_status(struct rsnd_mod *mod, 166 struct rsnd_dai_stream *io, 167 enum rsnd_mod_type type) 168 { 169 return &mod->status; 170 } 171 172 int rsnd_mod_id_raw(struct rsnd_mod *mod) 173 { 174 return mod->id; 175 } 176 177 int rsnd_mod_id(struct rsnd_mod *mod) 178 { 179 if ((mod)->ops->id) 180 return (mod)->ops->id(mod); 181 182 return rsnd_mod_id_raw(mod); 183 } 184 185 int rsnd_mod_id_sub(struct rsnd_mod *mod) 186 { 187 if ((mod)->ops->id_sub) 188 return (mod)->ops->id_sub(mod); 189 190 return 0; 191 } 192 193 int rsnd_mod_init(struct rsnd_priv *priv, 194 struct rsnd_mod *mod, 195 struct rsnd_mod_ops *ops, 196 struct clk *clk, 197 enum rsnd_mod_type type, 198 int id) 199 { 200 int ret = clk_prepare(clk); 201 202 if (ret) 203 return ret; 204 205 mod->id = id; 206 mod->ops = ops; 207 mod->type = type; 208 mod->clk = clk; 209 mod->priv = priv; 210 211 return 0; 212 } 213 214 void rsnd_mod_quit(struct rsnd_mod *mod) 215 { 216 clk_unprepare(mod->clk); 217 mod->clk = NULL; 218 } 219 220 void rsnd_mod_interrupt(struct rsnd_mod *mod, 221 void (*callback)(struct rsnd_mod *mod, 222 struct rsnd_dai_stream *io)) 223 { 224 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 225 struct rsnd_dai *rdai; 226 int i; 227 228 for_each_rsnd_dai(rdai, priv, i) { 229 struct rsnd_dai_stream *io = &rdai->playback; 230 231 if (mod == io->mod[mod->type]) 232 callback(mod, io); 233 234 io = &rdai->capture; 235 if (mod == io->mod[mod->type]) 236 callback(mod, io); 237 } 238 } 239 240 int rsnd_io_is_working(struct rsnd_dai_stream *io) 241 { 242 /* see rsnd_dai_stream_init/quit() */ 243 if (io->substream) 244 return snd_pcm_running(io->substream); 245 246 return 0; 247 } 248 249 int rsnd_runtime_channel_original_with_params(struct rsnd_dai_stream *io, 250 struct snd_pcm_hw_params *params) 251 { 252 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 253 254 /* 255 * params will be added when refine 256 * see 257 * __rsnd_soc_hw_rule_rate() 258 * __rsnd_soc_hw_rule_channels() 259 */ 260 if (params) 261 return params_channels(params); 262 else if (runtime) 263 return runtime->channels; 264 return 0; 265 } 266 267 int rsnd_runtime_channel_after_ctu_with_params(struct rsnd_dai_stream *io, 268 struct snd_pcm_hw_params *params) 269 { 270 int chan = rsnd_runtime_channel_original_with_params(io, params); 271 struct rsnd_mod *ctu_mod = rsnd_io_to_mod_ctu(io); 272 273 if (ctu_mod) { 274 u32 converted_chan = rsnd_io_converted_chan(io); 275 276 /* 277 * !! Note !! 278 * 279 * converted_chan will be used for CTU, 280 * or TDM Split mode. 281 * User shouldn't use CTU with TDM Split mode. 282 */ 283 if (rsnd_runtime_is_tdm_split(io)) { 284 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); 285 286 dev_err(dev, "CTU and TDM Split should be used\n"); 287 } 288 289 if (converted_chan) 290 return converted_chan; 291 } 292 293 return chan; 294 } 295 296 int rsnd_channel_normalization(int chan) 297 { 298 if (WARN_ON((chan > 8) || (chan < 0))) 299 return 0; 300 301 /* TDM Extend Mode needs 8ch */ 302 if (chan == 6) 303 chan = 8; 304 305 return chan; 306 } 307 308 int rsnd_runtime_channel_for_ssi_with_params(struct rsnd_dai_stream *io, 309 struct snd_pcm_hw_params *params) 310 { 311 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 312 int chan = rsnd_io_is_play(io) ? 313 rsnd_runtime_channel_after_ctu_with_params(io, params) : 314 rsnd_runtime_channel_original_with_params(io, params); 315 316 /* Use Multi SSI */ 317 if (rsnd_runtime_is_multi_ssi(io)) 318 chan /= rsnd_rdai_ssi_lane_get(rdai); 319 320 return rsnd_channel_normalization(chan); 321 } 322 323 int rsnd_runtime_is_multi_ssi(struct rsnd_dai_stream *io) 324 { 325 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 326 int lane = rsnd_rdai_ssi_lane_get(rdai); 327 int chan = rsnd_io_is_play(io) ? 328 rsnd_runtime_channel_after_ctu(io) : 329 rsnd_runtime_channel_original(io); 330 331 return (chan > 2) && (lane > 1); 332 } 333 334 int rsnd_runtime_is_tdm(struct rsnd_dai_stream *io) 335 { 336 return rsnd_runtime_channel_for_ssi(io) >= 6; 337 } 338 339 int rsnd_runtime_is_tdm_split(struct rsnd_dai_stream *io) 340 { 341 return !!rsnd_flags_has(io, RSND_STREAM_TDM_SPLIT); 342 } 343 344 /* 345 * ADINR function 346 */ 347 u32 rsnd_get_adinr_bit(struct rsnd_mod *mod, struct rsnd_dai_stream *io) 348 { 349 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 350 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 351 struct device *dev = rsnd_priv_to_dev(priv); 352 353 switch (snd_pcm_format_width(runtime->format)) { 354 case 8: 355 return 16 << 16; 356 case 16: 357 return 8 << 16; 358 case 24: 359 return 0 << 16; 360 } 361 362 dev_warn(dev, "not supported sample bits\n"); 363 364 return 0; 365 } 366 367 /* 368 * DALIGN function 369 */ 370 u32 rsnd_get_dalign(struct rsnd_mod *mod, struct rsnd_dai_stream *io) 371 { 372 static const u32 dalign_values[8] = { 373 0x76543210, 0x00000032, 0x00007654, 0x00000076, 374 0xfedcba98, 0x000000ba, 0x0000fedc, 0x000000fe, 375 }; 376 int id = 0; 377 struct rsnd_mod *ssiu = rsnd_io_to_mod_ssiu(io); 378 struct rsnd_mod *target; 379 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 380 u32 dalign; 381 382 /* 383 * *Hardware* L/R and *Software* L/R are inverted for 16bit data. 384 * 31..16 15...0 385 * HW: [L ch] [R ch] 386 * SW: [R ch] [L ch] 387 * We need to care about inversion timing to control 388 * Playback/Capture correctly. 389 * The point is [DVC] needs *Hardware* L/R, [MEM] needs *Software* L/R 390 * 391 * sL/R : software L/R 392 * hL/R : hardware L/R 393 * (*) : conversion timing 394 * 395 * Playback 396 * sL/R (*) hL/R hL/R hL/R hL/R hL/R 397 * [MEM] -> [SRC] -> [DVC] -> [CMD] -> [SSIU] -> [SSI] -> codec 398 * 399 * Capture 400 * hL/R hL/R hL/R hL/R hL/R (*) sL/R 401 * codec -> [SSI] -> [SSIU] -> [SRC] -> [DVC] -> [CMD] -> [MEM] 402 */ 403 if (rsnd_io_is_play(io)) { 404 struct rsnd_mod *src = rsnd_io_to_mod_src(io); 405 406 target = src ? src : ssiu; 407 } else { 408 struct rsnd_mod *cmd = rsnd_io_to_mod_cmd(io); 409 410 target = cmd ? cmd : ssiu; 411 } 412 413 if (mod == ssiu) 414 id = rsnd_mod_id_sub(mod); 415 416 dalign = dalign_values[id]; 417 418 if (mod == target && snd_pcm_format_width(runtime->format) == 16) { 419 /* Target mod needs inverted DALIGN when 16bit */ 420 dalign = (dalign & 0xf0f0f0f0) >> 4 | 421 (dalign & 0x0f0f0f0f) << 4; 422 } 423 424 return dalign; 425 } 426 427 u32 rsnd_get_busif_shift(struct rsnd_dai_stream *io, struct rsnd_mod *mod) 428 { 429 static const enum rsnd_mod_type playback_mods[] = { 430 RSND_MOD_SRC, 431 RSND_MOD_CMD, 432 RSND_MOD_SSIU, 433 }; 434 static const enum rsnd_mod_type capture_mods[] = { 435 RSND_MOD_CMD, 436 RSND_MOD_SRC, 437 RSND_MOD_SSIU, 438 }; 439 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 440 struct rsnd_mod *tmod = NULL; 441 const enum rsnd_mod_type *mods = 442 rsnd_io_is_play(io) ? 443 playback_mods : capture_mods; 444 int i; 445 446 /* 447 * This is needed for 24bit data 448 * We need to shift 8bit 449 * 450 * Linux 24bit data is located as 0x00****** 451 * HW 24bit data is located as 0x******00 452 * 453 */ 454 if (snd_pcm_format_width(runtime->format) != 24) 455 return 0; 456 457 for (i = 0; i < ARRAY_SIZE(playback_mods); i++) { 458 tmod = rsnd_io_to_mod(io, mods[i]); 459 if (tmod) 460 break; 461 } 462 463 if (tmod != mod) 464 return 0; 465 466 if (rsnd_io_is_play(io)) 467 return (0 << 20) | /* shift to Left */ 468 (8 << 16); /* 8bit */ 469 else 470 return (1 << 20) | /* shift to Right */ 471 (8 << 16); /* 8bit */ 472 } 473 474 /* 475 * rsnd_dai functions 476 */ 477 struct rsnd_mod *rsnd_mod_next(int *iterator, 478 struct rsnd_dai_stream *io, 479 enum rsnd_mod_type *array, 480 int array_size) 481 { 482 int max = array ? array_size : RSND_MOD_MAX; 483 484 for (; *iterator < max; (*iterator)++) { 485 enum rsnd_mod_type type = (array) ? array[*iterator] : *iterator; 486 struct rsnd_mod *mod = rsnd_io_to_mod(io, type); 487 488 if (mod) 489 return mod; 490 } 491 492 return NULL; 493 } 494 495 static enum rsnd_mod_type rsnd_mod_sequence[][RSND_MOD_MAX] = { 496 { 497 /* CAPTURE */ 498 RSND_MOD_AUDMAPP, 499 RSND_MOD_AUDMA, 500 RSND_MOD_DVC, 501 RSND_MOD_MIX, 502 RSND_MOD_CTU, 503 RSND_MOD_CMD, 504 RSND_MOD_SRC, 505 RSND_MOD_SSIU, 506 RSND_MOD_SSIM3, 507 RSND_MOD_SSIM2, 508 RSND_MOD_SSIM1, 509 RSND_MOD_SSIP, 510 RSND_MOD_SSI, 511 }, { 512 /* PLAYBACK */ 513 RSND_MOD_AUDMAPP, 514 RSND_MOD_AUDMA, 515 RSND_MOD_SSIM3, 516 RSND_MOD_SSIM2, 517 RSND_MOD_SSIM1, 518 RSND_MOD_SSIP, 519 RSND_MOD_SSI, 520 RSND_MOD_SSIU, 521 RSND_MOD_DVC, 522 RSND_MOD_MIX, 523 RSND_MOD_CTU, 524 RSND_MOD_CMD, 525 RSND_MOD_SRC, 526 }, 527 }; 528 529 static int rsnd_status_update(struct rsnd_dai_stream *io, 530 struct rsnd_mod *mod, enum rsnd_mod_type type, 531 int shift, int add, int timing) 532 { 533 u32 *status = mod->ops->get_status(mod, io, type); 534 u32 mask = 0xF << shift; 535 u8 val = (*status >> shift) & 0xF; 536 u8 next_val = (val + add) & 0xF; 537 int func_call = (val == timing); 538 539 /* no status update */ 540 if (add == 0 || shift == 28) 541 return 1; 542 543 if (next_val == 0xF) /* underflow case */ 544 func_call = -1; 545 else 546 *status = (*status & ~mask) + (next_val << shift); 547 548 return func_call; 549 } 550 551 #define rsnd_dai_call(fn, io, param...) \ 552 ({ \ 553 struct device *dev = rsnd_priv_to_dev(rsnd_io_to_priv(io)); \ 554 struct rsnd_mod *mod; \ 555 int is_play = rsnd_io_is_play(io); \ 556 int ret = 0, i; \ 557 enum rsnd_mod_type *types = rsnd_mod_sequence[is_play]; \ 558 for_each_rsnd_mod_arrays(i, mod, io, types, RSND_MOD_MAX) { \ 559 int tmp = 0; \ 560 int func_call = rsnd_status_update(io, mod, types[i], \ 561 __rsnd_mod_shift_##fn, \ 562 __rsnd_mod_add_##fn, \ 563 __rsnd_mod_call_##fn); \ 564 if (func_call > 0 && (mod)->ops->fn) \ 565 tmp = (mod)->ops->fn(mod, io, param); \ 566 if (unlikely(func_call < 0) || \ 567 unlikely(tmp && (tmp != -EPROBE_DEFER))) \ 568 dev_err(dev, "%s : %s error (%d, %d)\n", \ 569 rsnd_mod_name(mod), #fn, tmp, func_call);\ 570 ret |= tmp; \ 571 } \ 572 ret; \ 573 }) 574 575 int rsnd_dai_connect(struct rsnd_mod *mod, 576 struct rsnd_dai_stream *io, 577 enum rsnd_mod_type type) 578 { 579 struct rsnd_priv *priv; 580 struct device *dev; 581 582 if (!mod) 583 return -EIO; 584 585 if (io->mod[type] == mod) 586 return 0; 587 588 if (io->mod[type]) 589 return -EINVAL; 590 591 priv = rsnd_mod_to_priv(mod); 592 dev = rsnd_priv_to_dev(priv); 593 594 io->mod[type] = mod; 595 596 dev_dbg(dev, "%s is connected to io (%s)\n", 597 rsnd_mod_name(mod), 598 rsnd_io_is_play(io) ? "Playback" : "Capture"); 599 600 return 0; 601 } 602 603 static void rsnd_dai_disconnect(struct rsnd_mod *mod, 604 struct rsnd_dai_stream *io, 605 enum rsnd_mod_type type) 606 { 607 io->mod[type] = NULL; 608 } 609 610 int rsnd_rdai_channels_ctrl(struct rsnd_dai *rdai, 611 int max_channels) 612 { 613 if (max_channels > 0) 614 rdai->max_channels = max_channels; 615 616 return rdai->max_channels; 617 } 618 619 int rsnd_rdai_ssi_lane_ctrl(struct rsnd_dai *rdai, 620 int ssi_lane) 621 { 622 if (ssi_lane > 0) 623 rdai->ssi_lane = ssi_lane; 624 625 return rdai->ssi_lane; 626 } 627 628 int rsnd_rdai_width_ctrl(struct rsnd_dai *rdai, int width) 629 { 630 if (width > 0) 631 rdai->chan_width = width; 632 633 return rdai->chan_width; 634 } 635 636 struct rsnd_dai *rsnd_rdai_get(struct rsnd_priv *priv, int id) 637 { 638 if ((id < 0) || (id >= rsnd_rdai_nr(priv))) 639 return NULL; 640 641 return priv->rdai + id; 642 } 643 644 static struct snd_soc_dai_driver 645 *rsnd_daidrv_get(struct rsnd_priv *priv, int id) 646 { 647 if ((id < 0) || (id >= rsnd_rdai_nr(priv))) 648 return NULL; 649 650 return priv->daidrv + id; 651 } 652 653 #define rsnd_dai_to_priv(dai) snd_soc_dai_get_drvdata(dai) 654 static struct rsnd_dai *rsnd_dai_to_rdai(struct snd_soc_dai *dai) 655 { 656 struct rsnd_priv *priv = rsnd_dai_to_priv(dai); 657 658 return rsnd_rdai_get(priv, dai->id); 659 } 660 661 /* 662 * rsnd_soc_dai functions 663 */ 664 void rsnd_dai_period_elapsed(struct rsnd_dai_stream *io) 665 { 666 struct snd_pcm_substream *substream = io->substream; 667 668 /* 669 * this function should be called... 670 * 671 * - if rsnd_dai_pointer_update() returns true 672 * - without spin lock 673 */ 674 675 snd_pcm_period_elapsed(substream); 676 } 677 678 static void rsnd_dai_stream_init(struct rsnd_dai_stream *io, 679 struct snd_pcm_substream *substream) 680 { 681 io->substream = substream; 682 } 683 684 static void rsnd_dai_stream_quit(struct rsnd_dai_stream *io) 685 { 686 io->substream = NULL; 687 } 688 689 static 690 struct snd_soc_dai *rsnd_substream_to_dai(struct snd_pcm_substream *substream) 691 { 692 struct snd_soc_pcm_runtime *rtd = asoc_substream_to_rtd(substream); 693 694 return asoc_rtd_to_cpu(rtd, 0); 695 } 696 697 static 698 struct rsnd_dai_stream *rsnd_rdai_to_io(struct rsnd_dai *rdai, 699 struct snd_pcm_substream *substream) 700 { 701 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 702 return &rdai->playback; 703 else 704 return &rdai->capture; 705 } 706 707 static int rsnd_soc_dai_trigger(struct snd_pcm_substream *substream, int cmd, 708 struct snd_soc_dai *dai) 709 { 710 struct rsnd_priv *priv = rsnd_dai_to_priv(dai); 711 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 712 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 713 int ret; 714 unsigned long flags; 715 716 spin_lock_irqsave(&priv->lock, flags); 717 718 switch (cmd) { 719 case SNDRV_PCM_TRIGGER_START: 720 case SNDRV_PCM_TRIGGER_RESUME: 721 ret = rsnd_dai_call(init, io, priv); 722 if (ret < 0) 723 goto dai_trigger_end; 724 725 ret = rsnd_dai_call(start, io, priv); 726 if (ret < 0) 727 goto dai_trigger_end; 728 729 ret = rsnd_dai_call(irq, io, priv, 1); 730 if (ret < 0) 731 goto dai_trigger_end; 732 733 break; 734 case SNDRV_PCM_TRIGGER_STOP: 735 case SNDRV_PCM_TRIGGER_SUSPEND: 736 ret = rsnd_dai_call(irq, io, priv, 0); 737 738 ret |= rsnd_dai_call(stop, io, priv); 739 740 ret |= rsnd_dai_call(quit, io, priv); 741 742 break; 743 default: 744 ret = -EINVAL; 745 } 746 747 dai_trigger_end: 748 spin_unlock_irqrestore(&priv->lock, flags); 749 750 return ret; 751 } 752 753 static int rsnd_soc_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) 754 { 755 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 756 757 /* set clock master for audio interface */ 758 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 759 case SND_SOC_DAIFMT_CBP_CFP: 760 rdai->clk_master = 0; 761 break; 762 case SND_SOC_DAIFMT_CBC_CFC: 763 rdai->clk_master = 1; /* cpu is master */ 764 break; 765 default: 766 return -EINVAL; 767 } 768 769 /* set format */ 770 rdai->bit_clk_inv = 0; 771 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 772 case SND_SOC_DAIFMT_I2S: 773 rdai->sys_delay = 0; 774 rdai->data_alignment = 0; 775 rdai->frm_clk_inv = 0; 776 break; 777 case SND_SOC_DAIFMT_LEFT_J: 778 case SND_SOC_DAIFMT_DSP_B: 779 rdai->sys_delay = 1; 780 rdai->data_alignment = 0; 781 rdai->frm_clk_inv = 1; 782 break; 783 case SND_SOC_DAIFMT_RIGHT_J: 784 rdai->sys_delay = 1; 785 rdai->data_alignment = 1; 786 rdai->frm_clk_inv = 1; 787 break; 788 case SND_SOC_DAIFMT_DSP_A: 789 rdai->sys_delay = 0; 790 rdai->data_alignment = 0; 791 rdai->frm_clk_inv = 1; 792 break; 793 } 794 795 /* set clock inversion */ 796 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 797 case SND_SOC_DAIFMT_NB_IF: 798 rdai->frm_clk_inv = !rdai->frm_clk_inv; 799 break; 800 case SND_SOC_DAIFMT_IB_NF: 801 rdai->bit_clk_inv = !rdai->bit_clk_inv; 802 break; 803 case SND_SOC_DAIFMT_IB_IF: 804 rdai->bit_clk_inv = !rdai->bit_clk_inv; 805 rdai->frm_clk_inv = !rdai->frm_clk_inv; 806 break; 807 case SND_SOC_DAIFMT_NB_NF: 808 default: 809 break; 810 } 811 812 return 0; 813 } 814 815 static int rsnd_soc_set_dai_tdm_slot(struct snd_soc_dai *dai, 816 u32 tx_mask, u32 rx_mask, 817 int slots, int slot_width) 818 { 819 struct rsnd_priv *priv = rsnd_dai_to_priv(dai); 820 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 821 struct device *dev = rsnd_priv_to_dev(priv); 822 823 switch (slot_width) { 824 case 16: 825 case 24: 826 case 32: 827 break; 828 default: 829 /* use default */ 830 slot_width = 32; 831 } 832 833 switch (slots) { 834 case 2: 835 /* TDM Split Mode */ 836 case 6: 837 case 8: 838 /* TDM Extend Mode */ 839 rsnd_rdai_channels_set(rdai, slots); 840 rsnd_rdai_ssi_lane_set(rdai, 1); 841 rsnd_rdai_width_set(rdai, slot_width); 842 break; 843 default: 844 dev_err(dev, "unsupported TDM slots (%d)\n", slots); 845 return -EINVAL; 846 } 847 848 return 0; 849 } 850 851 static unsigned int rsnd_soc_hw_channels_list[] = { 852 2, 6, 8, 853 }; 854 855 static unsigned int rsnd_soc_hw_rate_list[] = { 856 8000, 857 11025, 858 16000, 859 22050, 860 32000, 861 44100, 862 48000, 863 64000, 864 88200, 865 96000, 866 176400, 867 192000, 868 }; 869 870 static int rsnd_soc_hw_rule(struct rsnd_dai *rdai, 871 unsigned int *list, int list_num, 872 struct snd_interval *baseline, struct snd_interval *iv) 873 { 874 struct snd_interval p; 875 unsigned int rate; 876 int i; 877 878 snd_interval_any(&p); 879 p.min = UINT_MAX; 880 p.max = 0; 881 882 for (i = 0; i < list_num; i++) { 883 884 if (!snd_interval_test(iv, list[i])) 885 continue; 886 887 rate = rsnd_ssi_clk_query(rdai, 888 baseline->min, list[i], NULL); 889 if (rate > 0) { 890 p.min = min(p.min, list[i]); 891 p.max = max(p.max, list[i]); 892 } 893 894 rate = rsnd_ssi_clk_query(rdai, 895 baseline->max, list[i], NULL); 896 if (rate > 0) { 897 p.min = min(p.min, list[i]); 898 p.max = max(p.max, list[i]); 899 } 900 } 901 902 return snd_interval_refine(iv, &p); 903 } 904 905 static int rsnd_soc_hw_rule_rate(struct snd_pcm_hw_params *params, 906 struct snd_pcm_hw_rule *rule) 907 { 908 struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 909 struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 910 struct snd_interval ic; 911 struct rsnd_dai_stream *io = rule->private; 912 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 913 914 /* 915 * possible sampling rate limitation is same as 916 * 2ch if it supports multi ssi 917 * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init()) 918 */ 919 ic = *ic_; 920 ic.min = 921 ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params); 922 923 return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_rate_list, 924 ARRAY_SIZE(rsnd_soc_hw_rate_list), 925 &ic, ir); 926 } 927 928 static int rsnd_soc_hw_rule_channels(struct snd_pcm_hw_params *params, 929 struct snd_pcm_hw_rule *rule) 930 { 931 struct snd_interval *ic_ = hw_param_interval(params, SNDRV_PCM_HW_PARAM_CHANNELS); 932 struct snd_interval *ir = hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE); 933 struct snd_interval ic; 934 struct rsnd_dai_stream *io = rule->private; 935 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 936 937 /* 938 * possible sampling rate limitation is same as 939 * 2ch if it supports multi ssi 940 * and same as 8ch if TDM 6ch (see rsnd_ssi_config_init()) 941 */ 942 ic = *ic_; 943 ic.min = 944 ic.max = rsnd_runtime_channel_for_ssi_with_params(io, params); 945 946 return rsnd_soc_hw_rule(rdai, rsnd_soc_hw_channels_list, 947 ARRAY_SIZE(rsnd_soc_hw_channels_list), 948 ir, &ic); 949 } 950 951 static const struct snd_pcm_hardware rsnd_pcm_hardware = { 952 .info = SNDRV_PCM_INFO_INTERLEAVED | 953 SNDRV_PCM_INFO_MMAP | 954 SNDRV_PCM_INFO_MMAP_VALID, 955 .buffer_bytes_max = 64 * 1024, 956 .period_bytes_min = 32, 957 .period_bytes_max = 8192, 958 .periods_min = 1, 959 .periods_max = 32, 960 .fifo_size = 256, 961 }; 962 963 static int rsnd_soc_dai_startup(struct snd_pcm_substream *substream, 964 struct snd_soc_dai *dai) 965 { 966 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 967 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 968 struct snd_pcm_hw_constraint_list *constraint = &rdai->constraint; 969 struct snd_pcm_runtime *runtime = substream->runtime; 970 unsigned int max_channels = rsnd_rdai_channels_get(rdai); 971 int i; 972 973 rsnd_dai_stream_init(io, substream); 974 975 /* 976 * Channel Limitation 977 * It depends on Platform design 978 */ 979 constraint->list = rsnd_soc_hw_channels_list; 980 constraint->count = 0; 981 constraint->mask = 0; 982 983 for (i = 0; i < ARRAY_SIZE(rsnd_soc_hw_channels_list); i++) { 984 if (rsnd_soc_hw_channels_list[i] > max_channels) 985 break; 986 constraint->count = i + 1; 987 } 988 989 snd_soc_set_runtime_hwparams(substream, &rsnd_pcm_hardware); 990 991 snd_pcm_hw_constraint_list(runtime, 0, 992 SNDRV_PCM_HW_PARAM_CHANNELS, constraint); 993 994 snd_pcm_hw_constraint_integer(runtime, 995 SNDRV_PCM_HW_PARAM_PERIODS); 996 997 /* 998 * Sampling Rate / Channel Limitation 999 * It depends on Clock Master Mode 1000 */ 1001 if (rsnd_rdai_is_clk_master(rdai)) { 1002 int is_play = substream->stream == SNDRV_PCM_STREAM_PLAYBACK; 1003 1004 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_RATE, 1005 rsnd_soc_hw_rule_rate, 1006 is_play ? &rdai->playback : &rdai->capture, 1007 SNDRV_PCM_HW_PARAM_CHANNELS, -1); 1008 snd_pcm_hw_rule_add(runtime, 0, SNDRV_PCM_HW_PARAM_CHANNELS, 1009 rsnd_soc_hw_rule_channels, 1010 is_play ? &rdai->playback : &rdai->capture, 1011 SNDRV_PCM_HW_PARAM_RATE, -1); 1012 } 1013 1014 return 0; 1015 } 1016 1017 static void rsnd_soc_dai_shutdown(struct snd_pcm_substream *substream, 1018 struct snd_soc_dai *dai) 1019 { 1020 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1021 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1022 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 1023 1024 /* 1025 * call rsnd_dai_call without spinlock 1026 */ 1027 rsnd_dai_call(cleanup, io, priv); 1028 1029 rsnd_dai_stream_quit(io); 1030 } 1031 1032 static int rsnd_soc_dai_prepare(struct snd_pcm_substream *substream, 1033 struct snd_soc_dai *dai) 1034 { 1035 struct rsnd_priv *priv = rsnd_dai_to_priv(dai); 1036 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1037 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 1038 1039 return rsnd_dai_call(prepare, io, priv); 1040 } 1041 1042 static u64 rsnd_soc_dai_formats[] = { 1043 /* 1044 * 1st Priority 1045 * 1046 * Well tested formats. 1047 * Select below from Sound Card, not auto 1048 * SND_SOC_DAIFMT_CBC_CFC 1049 * SND_SOC_DAIFMT_CBP_CFP 1050 */ 1051 SND_SOC_POSSIBLE_DAIFMT_I2S | 1052 SND_SOC_POSSIBLE_DAIFMT_RIGHT_J | 1053 SND_SOC_POSSIBLE_DAIFMT_LEFT_J | 1054 SND_SOC_POSSIBLE_DAIFMT_NB_NF | 1055 SND_SOC_POSSIBLE_DAIFMT_NB_IF | 1056 SND_SOC_POSSIBLE_DAIFMT_IB_NF | 1057 SND_SOC_POSSIBLE_DAIFMT_IB_IF, 1058 /* 1059 * 2nd Priority 1060 * 1061 * Supported, but not well tested 1062 */ 1063 SND_SOC_POSSIBLE_DAIFMT_DSP_A | 1064 SND_SOC_POSSIBLE_DAIFMT_DSP_B, 1065 }; 1066 1067 static const struct snd_soc_dai_ops rsnd_soc_dai_ops = { 1068 .startup = rsnd_soc_dai_startup, 1069 .shutdown = rsnd_soc_dai_shutdown, 1070 .trigger = rsnd_soc_dai_trigger, 1071 .set_fmt = rsnd_soc_dai_set_fmt, 1072 .set_tdm_slot = rsnd_soc_set_dai_tdm_slot, 1073 .prepare = rsnd_soc_dai_prepare, 1074 .auto_selectable_formats = rsnd_soc_dai_formats, 1075 .num_auto_selectable_formats = ARRAY_SIZE(rsnd_soc_dai_formats), 1076 }; 1077 1078 static void rsnd_parse_tdm_split_mode(struct rsnd_priv *priv, 1079 struct rsnd_dai_stream *io, 1080 struct device_node *dai_np) 1081 { 1082 struct device *dev = rsnd_priv_to_dev(priv); 1083 struct device_node *ssiu_np = rsnd_ssiu_of_node(priv); 1084 struct device_node *np; 1085 int is_play = rsnd_io_is_play(io); 1086 int i; 1087 1088 if (!ssiu_np) 1089 return; 1090 1091 /* 1092 * This driver assumes that it is TDM Split mode 1093 * if it includes ssiu node 1094 */ 1095 for (i = 0;; i++) { 1096 struct device_node *node = is_play ? 1097 of_parse_phandle(dai_np, "playback", i) : 1098 of_parse_phandle(dai_np, "capture", i); 1099 1100 if (!node) 1101 break; 1102 1103 for_each_child_of_node(ssiu_np, np) { 1104 if (np == node) { 1105 rsnd_flags_set(io, RSND_STREAM_TDM_SPLIT); 1106 dev_dbg(dev, "%s is part of TDM Split\n", io->name); 1107 } 1108 } 1109 1110 of_node_put(node); 1111 } 1112 1113 of_node_put(ssiu_np); 1114 } 1115 1116 static void rsnd_parse_connect_simple(struct rsnd_priv *priv, 1117 struct rsnd_dai_stream *io, 1118 struct device_node *dai_np) 1119 { 1120 if (!rsnd_io_to_mod_ssi(io)) 1121 return; 1122 1123 rsnd_parse_tdm_split_mode(priv, io, dai_np); 1124 } 1125 1126 static void rsnd_parse_connect_graph(struct rsnd_priv *priv, 1127 struct rsnd_dai_stream *io, 1128 struct device_node *endpoint) 1129 { 1130 struct device *dev = rsnd_priv_to_dev(priv); 1131 struct device_node *remote_node; 1132 1133 if (!rsnd_io_to_mod_ssi(io)) 1134 return; 1135 1136 remote_node = of_graph_get_remote_port_parent(endpoint); 1137 1138 /* HDMI0 */ 1139 if (strstr(remote_node->full_name, "hdmi@fead0000")) { 1140 rsnd_flags_set(io, RSND_STREAM_HDMI0); 1141 dev_dbg(dev, "%s connected to HDMI0\n", io->name); 1142 } 1143 1144 /* HDMI1 */ 1145 if (strstr(remote_node->full_name, "hdmi@feae0000")) { 1146 rsnd_flags_set(io, RSND_STREAM_HDMI1); 1147 dev_dbg(dev, "%s connected to HDMI1\n", io->name); 1148 } 1149 1150 rsnd_parse_tdm_split_mode(priv, io, endpoint); 1151 1152 of_node_put(remote_node); 1153 } 1154 1155 void rsnd_parse_connect_common(struct rsnd_dai *rdai, char *name, 1156 struct rsnd_mod* (*mod_get)(struct rsnd_priv *priv, int id), 1157 struct device_node *node, 1158 struct device_node *playback, 1159 struct device_node *capture) 1160 { 1161 struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai); 1162 struct device_node *np; 1163 int i; 1164 1165 if (!node) 1166 return; 1167 1168 i = 0; 1169 for_each_child_of_node(node, np) { 1170 struct rsnd_mod *mod; 1171 1172 i = rsnd_node_fixed_index(np, name, i); 1173 1174 mod = mod_get(priv, i); 1175 1176 if (np == playback) 1177 rsnd_dai_connect(mod, &rdai->playback, mod->type); 1178 if (np == capture) 1179 rsnd_dai_connect(mod, &rdai->capture, mod->type); 1180 i++; 1181 } 1182 1183 of_node_put(node); 1184 } 1185 1186 int rsnd_node_fixed_index(struct device_node *node, char *name, int idx) 1187 { 1188 char node_name[16]; 1189 1190 /* 1191 * rsnd is assuming each device nodes are sequential numbering, 1192 * but some of them are not. 1193 * This function adjusts index for it. 1194 * 1195 * ex) 1196 * Normal case, special case 1197 * ssi-0 1198 * ssi-1 1199 * ssi-2 1200 * ssi-3 ssi-3 1201 * ssi-4 ssi-4 1202 * ... 1203 * 1204 * assume Max 64 node 1205 */ 1206 for (; idx < 64; idx++) { 1207 snprintf(node_name, sizeof(node_name), "%s-%d", name, idx); 1208 1209 if (strncmp(node_name, of_node_full_name(node), sizeof(node_name)) == 0) 1210 return idx; 1211 } 1212 1213 return -EINVAL; 1214 } 1215 1216 int rsnd_node_count(struct rsnd_priv *priv, struct device_node *node, char *name) 1217 { 1218 struct device *dev = rsnd_priv_to_dev(priv); 1219 struct device_node *np; 1220 int i; 1221 1222 i = 0; 1223 for_each_child_of_node(node, np) { 1224 i = rsnd_node_fixed_index(np, name, i); 1225 if (i < 0) { 1226 dev_err(dev, "strange node numbering (%s)", 1227 of_node_full_name(node)); 1228 return 0; 1229 } 1230 i++; 1231 } 1232 1233 return i; 1234 } 1235 1236 static struct device_node *rsnd_dai_of_node(struct rsnd_priv *priv, 1237 int *is_graph) 1238 { 1239 struct device *dev = rsnd_priv_to_dev(priv); 1240 struct device_node *np = dev->of_node; 1241 struct device_node *dai_node; 1242 struct device_node *ret; 1243 1244 *is_graph = 0; 1245 1246 /* 1247 * parse both previous dai (= rcar_sound,dai), and 1248 * graph dai (= ports/port) 1249 */ 1250 dai_node = of_get_child_by_name(np, RSND_NODE_DAI); 1251 if (dai_node) { 1252 ret = dai_node; 1253 goto of_node_compatible; 1254 } 1255 1256 ret = np; 1257 1258 dai_node = of_graph_get_next_endpoint(np, NULL); 1259 if (dai_node) 1260 goto of_node_graph; 1261 1262 return NULL; 1263 1264 of_node_graph: 1265 *is_graph = 1; 1266 of_node_compatible: 1267 of_node_put(dai_node); 1268 1269 return ret; 1270 } 1271 1272 1273 #define PREALLOC_BUFFER (32 * 1024) 1274 #define PREALLOC_BUFFER_MAX (32 * 1024) 1275 1276 static int rsnd_preallocate_pages(struct snd_soc_pcm_runtime *rtd, 1277 struct rsnd_dai_stream *io, 1278 int stream) 1279 { 1280 struct rsnd_priv *priv = rsnd_io_to_priv(io); 1281 struct device *dev = rsnd_priv_to_dev(priv); 1282 struct snd_pcm_substream *substream; 1283 1284 /* 1285 * use Audio-DMAC dev if we can use IPMMU 1286 * see 1287 * rsnd_dmaen_attach() 1288 */ 1289 if (io->dmac_dev) 1290 dev = io->dmac_dev; 1291 1292 for (substream = rtd->pcm->streams[stream].substream; 1293 substream; 1294 substream = substream->next) { 1295 snd_pcm_set_managed_buffer(substream, 1296 SNDRV_DMA_TYPE_DEV, 1297 dev, 1298 PREALLOC_BUFFER, PREALLOC_BUFFER_MAX); 1299 } 1300 1301 return 0; 1302 } 1303 1304 static int rsnd_pcm_new(struct snd_soc_pcm_runtime *rtd, 1305 struct snd_soc_dai *dai) 1306 { 1307 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1308 int ret; 1309 1310 ret = rsnd_dai_call(pcm_new, &rdai->playback, rtd); 1311 if (ret) 1312 return ret; 1313 1314 ret = rsnd_dai_call(pcm_new, &rdai->capture, rtd); 1315 if (ret) 1316 return ret; 1317 1318 ret = rsnd_preallocate_pages(rtd, &rdai->playback, 1319 SNDRV_PCM_STREAM_PLAYBACK); 1320 if (ret) 1321 return ret; 1322 1323 ret = rsnd_preallocate_pages(rtd, &rdai->capture, 1324 SNDRV_PCM_STREAM_CAPTURE); 1325 if (ret) 1326 return ret; 1327 1328 return 0; 1329 } 1330 1331 static void __rsnd_dai_probe(struct rsnd_priv *priv, 1332 struct device_node *dai_np, 1333 int dai_i) 1334 { 1335 struct rsnd_dai_stream *io_playback; 1336 struct rsnd_dai_stream *io_capture; 1337 struct snd_soc_dai_driver *drv; 1338 struct rsnd_dai *rdai; 1339 struct device *dev = rsnd_priv_to_dev(priv); 1340 int io_i; 1341 1342 rdai = rsnd_rdai_get(priv, dai_i); 1343 drv = rsnd_daidrv_get(priv, dai_i); 1344 io_playback = &rdai->playback; 1345 io_capture = &rdai->capture; 1346 1347 snprintf(rdai->name, RSND_DAI_NAME_SIZE, "rsnd-dai.%d", dai_i); 1348 1349 rdai->priv = priv; 1350 drv->name = rdai->name; 1351 drv->ops = &rsnd_soc_dai_ops; 1352 drv->pcm_new = rsnd_pcm_new; 1353 1354 snprintf(io_playback->name, RSND_DAI_NAME_SIZE, 1355 "DAI%d Playback", dai_i); 1356 drv->playback.rates = RSND_RATES; 1357 drv->playback.formats = RSND_FMTS; 1358 drv->playback.channels_min = 2; 1359 drv->playback.channels_max = 8; 1360 drv->playback.stream_name = io_playback->name; 1361 1362 snprintf(io_capture->name, RSND_DAI_NAME_SIZE, 1363 "DAI%d Capture", dai_i); 1364 drv->capture.rates = RSND_RATES; 1365 drv->capture.formats = RSND_FMTS; 1366 drv->capture.channels_min = 2; 1367 drv->capture.channels_max = 8; 1368 drv->capture.stream_name = io_capture->name; 1369 1370 io_playback->rdai = rdai; 1371 io_capture->rdai = rdai; 1372 rsnd_rdai_channels_set(rdai, 2); /* default 2ch */ 1373 rsnd_rdai_ssi_lane_set(rdai, 1); /* default 1lane */ 1374 rsnd_rdai_width_set(rdai, 32); /* default 32bit width */ 1375 1376 for (io_i = 0;; io_i++) { 1377 struct device_node *playback = of_parse_phandle(dai_np, "playback", io_i); 1378 struct device_node *capture = of_parse_phandle(dai_np, "capture", io_i); 1379 1380 if (!playback && !capture) 1381 break; 1382 1383 rsnd_parse_connect_ssi(rdai, playback, capture); 1384 rsnd_parse_connect_ssiu(rdai, playback, capture); 1385 rsnd_parse_connect_src(rdai, playback, capture); 1386 rsnd_parse_connect_ctu(rdai, playback, capture); 1387 rsnd_parse_connect_mix(rdai, playback, capture); 1388 rsnd_parse_connect_dvc(rdai, playback, capture); 1389 1390 of_node_put(playback); 1391 of_node_put(capture); 1392 } 1393 1394 if (rsnd_ssi_is_pin_sharing(io_capture) || 1395 rsnd_ssi_is_pin_sharing(io_playback)) { 1396 /* should have symmetric_rate if pin sharing */ 1397 drv->symmetric_rate = 1; 1398 } 1399 1400 dev_dbg(dev, "%s (%s/%s)\n", rdai->name, 1401 rsnd_io_to_mod_ssi(io_playback) ? "play" : " -- ", 1402 rsnd_io_to_mod_ssi(io_capture) ? "capture" : " -- "); 1403 } 1404 1405 static int rsnd_dai_probe(struct rsnd_priv *priv) 1406 { 1407 struct device_node *dai_node; 1408 struct device_node *dai_np; 1409 struct snd_soc_dai_driver *rdrv; 1410 struct device *dev = rsnd_priv_to_dev(priv); 1411 struct rsnd_dai *rdai; 1412 int nr; 1413 int is_graph; 1414 int dai_i; 1415 1416 dai_node = rsnd_dai_of_node(priv, &is_graph); 1417 if (is_graph) 1418 nr = of_graph_get_endpoint_count(dai_node); 1419 else 1420 nr = of_get_child_count(dai_node); 1421 1422 if (!nr) 1423 return -EINVAL; 1424 1425 rdrv = devm_kcalloc(dev, nr, sizeof(*rdrv), GFP_KERNEL); 1426 rdai = devm_kcalloc(dev, nr, sizeof(*rdai), GFP_KERNEL); 1427 if (!rdrv || !rdai) 1428 return -ENOMEM; 1429 1430 priv->rdai_nr = nr; 1431 priv->daidrv = rdrv; 1432 priv->rdai = rdai; 1433 1434 /* 1435 * parse all dai 1436 */ 1437 dai_i = 0; 1438 if (is_graph) { 1439 for_each_endpoint_of_node(dai_node, dai_np) { 1440 __rsnd_dai_probe(priv, dai_np, dai_i); 1441 if (rsnd_is_gen3(priv)) { 1442 rdai = rsnd_rdai_get(priv, dai_i); 1443 1444 rsnd_parse_connect_graph(priv, &rdai->playback, dai_np); 1445 rsnd_parse_connect_graph(priv, &rdai->capture, dai_np); 1446 } 1447 dai_i++; 1448 } 1449 } else { 1450 for_each_child_of_node(dai_node, dai_np) { 1451 __rsnd_dai_probe(priv, dai_np, dai_i); 1452 if (rsnd_is_gen3(priv)) { 1453 rdai = rsnd_rdai_get(priv, dai_i); 1454 1455 rsnd_parse_connect_simple(priv, &rdai->playback, dai_np); 1456 rsnd_parse_connect_simple(priv, &rdai->capture, dai_np); 1457 } 1458 dai_i++; 1459 } 1460 } 1461 1462 return 0; 1463 } 1464 1465 /* 1466 * pcm ops 1467 */ 1468 static int rsnd_hw_update(struct snd_pcm_substream *substream, 1469 struct snd_pcm_hw_params *hw_params) 1470 { 1471 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); 1472 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1473 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 1474 struct rsnd_priv *priv = rsnd_io_to_priv(io); 1475 unsigned long flags; 1476 int ret; 1477 1478 spin_lock_irqsave(&priv->lock, flags); 1479 if (hw_params) 1480 ret = rsnd_dai_call(hw_params, io, substream, hw_params); 1481 else 1482 ret = rsnd_dai_call(hw_free, io, substream); 1483 spin_unlock_irqrestore(&priv->lock, flags); 1484 1485 return ret; 1486 } 1487 1488 static int rsnd_hw_params(struct snd_soc_component *component, 1489 struct snd_pcm_substream *substream, 1490 struct snd_pcm_hw_params *hw_params) 1491 { 1492 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); 1493 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1494 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 1495 struct snd_soc_pcm_runtime *fe = asoc_substream_to_rtd(substream); 1496 1497 /* 1498 * rsnd assumes that it might be used under DPCM if user want to use 1499 * channel / rate convert. Then, rsnd should be FE. 1500 * And then, this function will be called *after* BE settings. 1501 * this means, each BE already has fixuped hw_params. 1502 * see 1503 * dpcm_fe_dai_hw_params() 1504 * dpcm_be_dai_hw_params() 1505 */ 1506 io->converted_rate = 0; 1507 io->converted_chan = 0; 1508 if (fe->dai_link->dynamic) { 1509 struct rsnd_priv *priv = rsnd_io_to_priv(io); 1510 struct device *dev = rsnd_priv_to_dev(priv); 1511 struct snd_soc_dpcm *dpcm; 1512 int stream = substream->stream; 1513 1514 for_each_dpcm_be(fe, stream, dpcm) { 1515 struct snd_pcm_hw_params *be_params = &dpcm->hw_params; 1516 1517 if (params_channels(hw_params) != params_channels(be_params)) 1518 io->converted_chan = params_channels(be_params); 1519 if (params_rate(hw_params) != params_rate(be_params)) 1520 io->converted_rate = params_rate(be_params); 1521 } 1522 if (io->converted_chan) 1523 dev_dbg(dev, "convert channels = %d\n", io->converted_chan); 1524 if (io->converted_rate) { 1525 /* 1526 * SRC supports convert rates from params_rate(hw_params)/k_down 1527 * to params_rate(hw_params)*k_up, where k_up is always 6, and 1528 * k_down depends on number of channels and SRC unit. 1529 * So all SRC units can upsample audio up to 6 times regardless 1530 * its number of channels. And all SRC units can downsample 1531 * 2 channel audio up to 6 times too. 1532 */ 1533 int k_up = 6; 1534 int k_down = 6; 1535 int channel; 1536 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); 1537 1538 dev_dbg(dev, "convert rate = %d\n", io->converted_rate); 1539 1540 channel = io->converted_chan ? io->converted_chan : 1541 params_channels(hw_params); 1542 1543 switch (rsnd_mod_id(src_mod)) { 1544 /* 1545 * SRC0 can downsample 4, 6 and 8 channel audio up to 4 times. 1546 * SRC1, SRC3 and SRC4 can downsample 4 channel audio 1547 * up to 4 times. 1548 * SRC1, SRC3 and SRC4 can downsample 6 and 8 channel audio 1549 * no more than twice. 1550 */ 1551 case 1: 1552 case 3: 1553 case 4: 1554 if (channel > 4) { 1555 k_down = 2; 1556 break; 1557 } 1558 fallthrough; 1559 case 0: 1560 if (channel > 2) 1561 k_down = 4; 1562 break; 1563 1564 /* Other SRC units do not support more than 2 channels */ 1565 default: 1566 if (channel > 2) 1567 return -EINVAL; 1568 } 1569 1570 if (params_rate(hw_params) > io->converted_rate * k_down) { 1571 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min = 1572 io->converted_rate * k_down; 1573 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max = 1574 io->converted_rate * k_down; 1575 hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE; 1576 } else if (params_rate(hw_params) * k_up < io->converted_rate) { 1577 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->min = 1578 (io->converted_rate + k_up - 1) / k_up; 1579 hw_param_interval(hw_params, SNDRV_PCM_HW_PARAM_RATE)->max = 1580 (io->converted_rate + k_up - 1) / k_up; 1581 hw_params->cmask |= SNDRV_PCM_HW_PARAM_RATE; 1582 } 1583 1584 /* 1585 * TBD: Max SRC input and output rates also depend on number 1586 * of channels and SRC unit: 1587 * SRC1, SRC3 and SRC4 do not support more than 128kHz 1588 * for 6 channel and 96kHz for 8 channel audio. 1589 * Perhaps this function should return EINVAL if the input or 1590 * the output rate exceeds the limitation. 1591 */ 1592 } 1593 } 1594 1595 return rsnd_hw_update(substream, hw_params); 1596 } 1597 1598 static int rsnd_hw_free(struct snd_soc_component *component, 1599 struct snd_pcm_substream *substream) 1600 { 1601 return rsnd_hw_update(substream, NULL); 1602 } 1603 1604 static snd_pcm_uframes_t rsnd_pointer(struct snd_soc_component *component, 1605 struct snd_pcm_substream *substream) 1606 { 1607 struct snd_soc_dai *dai = rsnd_substream_to_dai(substream); 1608 struct rsnd_dai *rdai = rsnd_dai_to_rdai(dai); 1609 struct rsnd_dai_stream *io = rsnd_rdai_to_io(rdai, substream); 1610 snd_pcm_uframes_t pointer = 0; 1611 1612 rsnd_dai_call(pointer, io, &pointer); 1613 1614 return pointer; 1615 } 1616 1617 /* 1618 * snd_kcontrol 1619 */ 1620 static int rsnd_kctrl_info(struct snd_kcontrol *kctrl, 1621 struct snd_ctl_elem_info *uinfo) 1622 { 1623 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); 1624 1625 if (cfg->texts) { 1626 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 1627 uinfo->count = cfg->size; 1628 uinfo->value.enumerated.items = cfg->max; 1629 if (uinfo->value.enumerated.item >= cfg->max) 1630 uinfo->value.enumerated.item = cfg->max - 1; 1631 strscpy(uinfo->value.enumerated.name, 1632 cfg->texts[uinfo->value.enumerated.item], 1633 sizeof(uinfo->value.enumerated.name)); 1634 } else { 1635 uinfo->count = cfg->size; 1636 uinfo->value.integer.min = 0; 1637 uinfo->value.integer.max = cfg->max; 1638 uinfo->type = (cfg->max == 1) ? 1639 SNDRV_CTL_ELEM_TYPE_BOOLEAN : 1640 SNDRV_CTL_ELEM_TYPE_INTEGER; 1641 } 1642 1643 return 0; 1644 } 1645 1646 static int rsnd_kctrl_get(struct snd_kcontrol *kctrl, 1647 struct snd_ctl_elem_value *uc) 1648 { 1649 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); 1650 int i; 1651 1652 for (i = 0; i < cfg->size; i++) 1653 if (cfg->texts) 1654 uc->value.enumerated.item[i] = cfg->val[i]; 1655 else 1656 uc->value.integer.value[i] = cfg->val[i]; 1657 1658 return 0; 1659 } 1660 1661 static int rsnd_kctrl_put(struct snd_kcontrol *kctrl, 1662 struct snd_ctl_elem_value *uc) 1663 { 1664 struct rsnd_kctrl_cfg *cfg = snd_kcontrol_chip(kctrl); 1665 int i, change = 0; 1666 1667 if (!cfg->accept(cfg->io)) 1668 return 0; 1669 1670 for (i = 0; i < cfg->size; i++) { 1671 if (cfg->texts) { 1672 change |= (uc->value.enumerated.item[i] != cfg->val[i]); 1673 cfg->val[i] = uc->value.enumerated.item[i]; 1674 } else { 1675 change |= (uc->value.integer.value[i] != cfg->val[i]); 1676 cfg->val[i] = uc->value.integer.value[i]; 1677 } 1678 } 1679 1680 if (change && cfg->update) 1681 cfg->update(cfg->io, cfg->mod); 1682 1683 return change; 1684 } 1685 1686 int rsnd_kctrl_accept_anytime(struct rsnd_dai_stream *io) 1687 { 1688 return 1; 1689 } 1690 1691 int rsnd_kctrl_accept_runtime(struct rsnd_dai_stream *io) 1692 { 1693 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 1694 struct rsnd_priv *priv = rsnd_io_to_priv(io); 1695 struct device *dev = rsnd_priv_to_dev(priv); 1696 1697 if (!runtime) { 1698 dev_warn(dev, "Can't update kctrl when idle\n"); 1699 return 0; 1700 } 1701 1702 return 1; 1703 } 1704 1705 struct rsnd_kctrl_cfg *rsnd_kctrl_init_m(struct rsnd_kctrl_cfg_m *cfg) 1706 { 1707 cfg->cfg.val = cfg->val; 1708 1709 return &cfg->cfg; 1710 } 1711 1712 struct rsnd_kctrl_cfg *rsnd_kctrl_init_s(struct rsnd_kctrl_cfg_s *cfg) 1713 { 1714 cfg->cfg.val = &cfg->val; 1715 1716 return &cfg->cfg; 1717 } 1718 1719 const char * const volume_ramp_rate[] = { 1720 "128 dB/1 step", /* 00000 */ 1721 "64 dB/1 step", /* 00001 */ 1722 "32 dB/1 step", /* 00010 */ 1723 "16 dB/1 step", /* 00011 */ 1724 "8 dB/1 step", /* 00100 */ 1725 "4 dB/1 step", /* 00101 */ 1726 "2 dB/1 step", /* 00110 */ 1727 "1 dB/1 step", /* 00111 */ 1728 "0.5 dB/1 step", /* 01000 */ 1729 "0.25 dB/1 step", /* 01001 */ 1730 "0.125 dB/1 step", /* 01010 = VOLUME_RAMP_MAX_MIX */ 1731 "0.125 dB/2 steps", /* 01011 */ 1732 "0.125 dB/4 steps", /* 01100 */ 1733 "0.125 dB/8 steps", /* 01101 */ 1734 "0.125 dB/16 steps", /* 01110 */ 1735 "0.125 dB/32 steps", /* 01111 */ 1736 "0.125 dB/64 steps", /* 10000 */ 1737 "0.125 dB/128 steps", /* 10001 */ 1738 "0.125 dB/256 steps", /* 10010 */ 1739 "0.125 dB/512 steps", /* 10011 */ 1740 "0.125 dB/1024 steps", /* 10100 */ 1741 "0.125 dB/2048 steps", /* 10101 */ 1742 "0.125 dB/4096 steps", /* 10110 */ 1743 "0.125 dB/8192 steps", /* 10111 = VOLUME_RAMP_MAX_DVC */ 1744 }; 1745 1746 int rsnd_kctrl_new(struct rsnd_mod *mod, 1747 struct rsnd_dai_stream *io, 1748 struct snd_soc_pcm_runtime *rtd, 1749 const unsigned char *name, 1750 int (*accept)(struct rsnd_dai_stream *io), 1751 void (*update)(struct rsnd_dai_stream *io, 1752 struct rsnd_mod *mod), 1753 struct rsnd_kctrl_cfg *cfg, 1754 const char * const *texts, 1755 int size, 1756 u32 max) 1757 { 1758 struct snd_card *card = rtd->card->snd_card; 1759 struct snd_kcontrol *kctrl; 1760 struct snd_kcontrol_new knew = { 1761 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1762 .name = name, 1763 .info = rsnd_kctrl_info, 1764 .index = rtd->num, 1765 .get = rsnd_kctrl_get, 1766 .put = rsnd_kctrl_put, 1767 }; 1768 int ret; 1769 1770 /* 1771 * 1) Avoid duplicate register for DVC with MIX case 1772 * 2) Allow duplicate register for MIX 1773 * 3) re-register if card was rebinded 1774 */ 1775 list_for_each_entry(kctrl, &card->controls, list) { 1776 struct rsnd_kctrl_cfg *c = kctrl->private_data; 1777 1778 if (c == cfg) 1779 return 0; 1780 } 1781 1782 if (size > RSND_MAX_CHANNELS) 1783 return -EINVAL; 1784 1785 kctrl = snd_ctl_new1(&knew, cfg); 1786 if (!kctrl) 1787 return -ENOMEM; 1788 1789 ret = snd_ctl_add(card, kctrl); 1790 if (ret < 0) 1791 return ret; 1792 1793 cfg->texts = texts; 1794 cfg->max = max; 1795 cfg->size = size; 1796 cfg->accept = accept; 1797 cfg->update = update; 1798 cfg->card = card; 1799 cfg->kctrl = kctrl; 1800 cfg->io = io; 1801 cfg->mod = mod; 1802 1803 return 0; 1804 } 1805 1806 /* 1807 * snd_soc_component 1808 */ 1809 static const struct snd_soc_component_driver rsnd_soc_component = { 1810 .name = "rsnd", 1811 .probe = rsnd_debugfs_probe, 1812 .hw_params = rsnd_hw_params, 1813 .hw_free = rsnd_hw_free, 1814 .pointer = rsnd_pointer, 1815 }; 1816 1817 static int rsnd_rdai_continuance_probe(struct rsnd_priv *priv, 1818 struct rsnd_dai_stream *io) 1819 { 1820 int ret; 1821 1822 ret = rsnd_dai_call(probe, io, priv); 1823 if (ret == -EAGAIN) { 1824 struct rsnd_mod *ssi_mod = rsnd_io_to_mod_ssi(io); 1825 struct rsnd_mod *mod; 1826 int i; 1827 1828 /* 1829 * Fallback to PIO mode 1830 */ 1831 1832 /* 1833 * call "remove" for SSI/SRC/DVC 1834 * SSI will be switch to PIO mode if it was DMA mode 1835 * see 1836 * rsnd_dma_init() 1837 * rsnd_ssi_fallback() 1838 */ 1839 rsnd_dai_call(remove, io, priv); 1840 1841 /* 1842 * remove all mod from io 1843 * and, re connect ssi 1844 */ 1845 for_each_rsnd_mod(i, mod, io) 1846 rsnd_dai_disconnect(mod, io, i); 1847 rsnd_dai_connect(ssi_mod, io, RSND_MOD_SSI); 1848 1849 /* 1850 * fallback 1851 */ 1852 rsnd_dai_call(fallback, io, priv); 1853 1854 /* 1855 * retry to "probe". 1856 * DAI has SSI which is PIO mode only now. 1857 */ 1858 ret = rsnd_dai_call(probe, io, priv); 1859 } 1860 1861 return ret; 1862 } 1863 1864 /* 1865 * rsnd probe 1866 */ 1867 static int rsnd_probe(struct platform_device *pdev) 1868 { 1869 struct rsnd_priv *priv; 1870 struct device *dev = &pdev->dev; 1871 struct rsnd_dai *rdai; 1872 int (*probe_func[])(struct rsnd_priv *priv) = { 1873 rsnd_gen_probe, 1874 rsnd_dma_probe, 1875 rsnd_ssi_probe, 1876 rsnd_ssiu_probe, 1877 rsnd_src_probe, 1878 rsnd_ctu_probe, 1879 rsnd_mix_probe, 1880 rsnd_dvc_probe, 1881 rsnd_cmd_probe, 1882 rsnd_adg_probe, 1883 rsnd_dai_probe, 1884 }; 1885 int ret, i; 1886 1887 /* 1888 * init priv data 1889 */ 1890 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 1891 if (!priv) 1892 return -ENODEV; 1893 1894 priv->pdev = pdev; 1895 priv->flags = (unsigned long)of_device_get_match_data(dev); 1896 spin_lock_init(&priv->lock); 1897 1898 /* 1899 * init each module 1900 */ 1901 for (i = 0; i < ARRAY_SIZE(probe_func); i++) { 1902 ret = probe_func[i](priv); 1903 if (ret) 1904 return ret; 1905 } 1906 1907 for_each_rsnd_dai(rdai, priv, i) { 1908 ret = rsnd_rdai_continuance_probe(priv, &rdai->playback); 1909 if (ret) 1910 goto exit_snd_probe; 1911 1912 ret = rsnd_rdai_continuance_probe(priv, &rdai->capture); 1913 if (ret) 1914 goto exit_snd_probe; 1915 } 1916 1917 dev_set_drvdata(dev, priv); 1918 1919 /* 1920 * asoc register 1921 */ 1922 ret = devm_snd_soc_register_component(dev, &rsnd_soc_component, 1923 priv->daidrv, rsnd_rdai_nr(priv)); 1924 if (ret < 0) { 1925 dev_err(dev, "cannot snd dai register\n"); 1926 goto exit_snd_probe; 1927 } 1928 1929 pm_runtime_enable(dev); 1930 1931 dev_info(dev, "probed\n"); 1932 return ret; 1933 1934 exit_snd_probe: 1935 for_each_rsnd_dai(rdai, priv, i) { 1936 rsnd_dai_call(remove, &rdai->playback, priv); 1937 rsnd_dai_call(remove, &rdai->capture, priv); 1938 } 1939 1940 /* 1941 * adg is very special mod which can't use rsnd_dai_call(remove), 1942 * and it registers ADG clock on probe. 1943 * It should be unregister if probe failed. 1944 * Mainly it is assuming -EPROBE_DEFER case 1945 */ 1946 rsnd_adg_remove(priv); 1947 1948 return ret; 1949 } 1950 1951 static int rsnd_remove(struct platform_device *pdev) 1952 { 1953 struct rsnd_priv *priv = dev_get_drvdata(&pdev->dev); 1954 struct rsnd_dai *rdai; 1955 void (*remove_func[])(struct rsnd_priv *priv) = { 1956 rsnd_ssi_remove, 1957 rsnd_ssiu_remove, 1958 rsnd_src_remove, 1959 rsnd_ctu_remove, 1960 rsnd_mix_remove, 1961 rsnd_dvc_remove, 1962 rsnd_cmd_remove, 1963 rsnd_adg_remove, 1964 }; 1965 int ret = 0, i; 1966 1967 pm_runtime_disable(&pdev->dev); 1968 1969 for_each_rsnd_dai(rdai, priv, i) { 1970 ret |= rsnd_dai_call(remove, &rdai->playback, priv); 1971 ret |= rsnd_dai_call(remove, &rdai->capture, priv); 1972 } 1973 1974 for (i = 0; i < ARRAY_SIZE(remove_func); i++) 1975 remove_func[i](priv); 1976 1977 return ret; 1978 } 1979 1980 static int __maybe_unused rsnd_suspend(struct device *dev) 1981 { 1982 struct rsnd_priv *priv = dev_get_drvdata(dev); 1983 1984 rsnd_adg_clk_disable(priv); 1985 1986 return 0; 1987 } 1988 1989 static int __maybe_unused rsnd_resume(struct device *dev) 1990 { 1991 struct rsnd_priv *priv = dev_get_drvdata(dev); 1992 1993 rsnd_adg_clk_enable(priv); 1994 1995 return 0; 1996 } 1997 1998 static const struct dev_pm_ops rsnd_pm_ops = { 1999 SET_SYSTEM_SLEEP_PM_OPS(rsnd_suspend, rsnd_resume) 2000 }; 2001 2002 static struct platform_driver rsnd_driver = { 2003 .driver = { 2004 .name = "rcar_sound", 2005 .pm = &rsnd_pm_ops, 2006 .of_match_table = rsnd_of_match, 2007 }, 2008 .probe = rsnd_probe, 2009 .remove = rsnd_remove, 2010 }; 2011 module_platform_driver(rsnd_driver); 2012 2013 MODULE_LICENSE("GPL v2"); 2014 MODULE_DESCRIPTION("Renesas R-Car audio driver"); 2015 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 2016 MODULE_ALIAS("platform:rcar-pcm-audio"); 2017