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