1 /* 2 * Renesas R-Car SRC support 3 * 4 * Copyright (C) 2013 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License version 2 as 9 * published by the Free Software Foundation. 10 */ 11 #include "rsnd.h" 12 13 #define SRC_NAME "src" 14 15 /* SRCx_STATUS */ 16 #define OUF_SRCO ((1 << 12) | (1 << 13)) 17 #define OUF_SRCI ((1 << 9) | (1 << 8)) 18 19 /* SCU_SYSTEM_STATUS0/1 */ 20 #define OUF_SRC(id) ((1 << (id + 16)) | (1 << id)) 21 22 struct rsnd_src { 23 struct rsnd_src_platform_info *info; /* rcar_snd.h */ 24 struct rsnd_mod mod; 25 struct rsnd_kctrl_cfg_s sen; /* sync convert enable */ 26 struct rsnd_kctrl_cfg_s sync; /* sync convert */ 27 u32 convert_rate; /* sampling rate convert */ 28 int err; 29 }; 30 31 #define RSND_SRC_NAME_SIZE 16 32 33 #define rsnd_enable_sync_convert(src) ((src)->sen.val) 34 #define rsnd_src_of_node(priv) \ 35 of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,src") 36 37 #define rsnd_mod_to_src(_mod) \ 38 container_of((_mod), struct rsnd_src, mod) 39 40 #define for_each_rsnd_src(pos, priv, i) \ 41 for ((i) = 0; \ 42 ((i) < rsnd_src_nr(priv)) && \ 43 ((pos) = (struct rsnd_src *)(priv)->src + i); \ 44 i++) 45 46 47 /* 48 * image of SRC (Sampling Rate Converter) 49 * 50 * 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+ 51 * 48kHz <-> | SRC | <------> | SSI | <-----> | codec | 52 * 44.1kHz <-> +-----+ +-----+ +-------+ 53 * ... 54 * 55 */ 56 57 /* 58 * src.c is caring... 59 * 60 * Gen1 61 * 62 * [mem] -> [SRU] -> [SSI] 63 * |--------| 64 * 65 * Gen2 66 * 67 * [mem] -> [SRC] -> [SSIU] -> [SSI] 68 * |-----------------| 69 */ 70 71 /* 72 * How to use SRC bypass mode for debugging 73 * 74 * SRC has bypass mode, and it is useful for debugging. 75 * In Gen2 case, 76 * SRCm_MODE controls whether SRC is used or not 77 * SSI_MODE0 controls whether SSIU which receives SRC data 78 * is used or not. 79 * Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC, 80 * but SRC bypass mode needs SSI_MODE0 only. 81 * 82 * This driver request 83 * struct rsnd_src_platform_info { 84 * u32 convert_rate; 85 * int dma_id; 86 * } 87 * 88 * rsnd_src_convert_rate() indicates 89 * above convert_rate, and it controls 90 * whether SRC is used or not. 91 * 92 * ex) doesn't use SRC 93 * static struct rsnd_dai_platform_info rsnd_dai = { 94 * .playback = { .ssi = &rsnd_ssi[0], }, 95 * }; 96 * 97 * ex) uses SRC 98 * static struct rsnd_src_platform_info rsnd_src[] = { 99 * RSND_SCU(48000, 0), 100 * ... 101 * }; 102 * static struct rsnd_dai_platform_info rsnd_dai = { 103 * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] }, 104 * }; 105 * 106 * ex) uses SRC bypass mode 107 * static struct rsnd_src_platform_info rsnd_src[] = { 108 * RSND_SCU(0, 0), 109 * ... 110 * }; 111 * static struct rsnd_dai_platform_info rsnd_dai = { 112 * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] }, 113 * }; 114 * 115 */ 116 117 /* 118 * Gen1/Gen2 common functions 119 */ 120 static struct dma_chan *rsnd_src_dma_req(struct rsnd_dai_stream *io, 121 struct rsnd_mod *mod) 122 { 123 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 124 int is_play = rsnd_io_is_play(io); 125 126 return rsnd_dma_request_channel(rsnd_src_of_node(priv), 127 mod, 128 is_play ? "rx" : "tx"); 129 } 130 131 int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod, 132 struct rsnd_dai_stream *io, 133 int use_busif) 134 { 135 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 136 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 137 int ssi_id = rsnd_mod_id(ssi_mod); 138 139 /* 140 * SSI_MODE0 141 */ 142 rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id), 143 !use_busif << ssi_id); 144 145 /* 146 * SSI_MODE1 147 */ 148 if (rsnd_ssi_is_pin_sharing(ssi_mod)) { 149 int shift = -1; 150 switch (ssi_id) { 151 case 1: 152 shift = 0; 153 break; 154 case 2: 155 shift = 2; 156 break; 157 case 4: 158 shift = 16; 159 break; 160 } 161 162 if (shift >= 0) 163 rsnd_mod_bset(ssi_mod, SSI_MODE1, 164 0x3 << shift, 165 rsnd_rdai_is_clk_master(rdai) ? 166 0x2 << shift : 0x1 << shift); 167 } 168 169 /* 170 * DMA settings for SSIU 171 */ 172 if (use_busif) { 173 u32 val = 0x76543210; 174 u32 mask = ~0; 175 176 rsnd_mod_write(ssi_mod, SSI_BUSIF_ADINR, 177 rsnd_get_adinr(ssi_mod, io)); 178 rsnd_mod_write(ssi_mod, SSI_BUSIF_MODE, 1); 179 rsnd_mod_write(ssi_mod, SSI_CTRL, 0x1); 180 181 mask <<= runtime->channels * 4; 182 val = val & mask; 183 184 switch (runtime->sample_bits) { 185 case 16: 186 val |= 0x67452301 & ~mask; 187 break; 188 case 32: 189 val |= 0x76543210 & ~mask; 190 break; 191 } 192 rsnd_mod_write(ssi_mod, BUSIF_DALIGN, val); 193 194 } 195 196 return 0; 197 } 198 199 int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod, 200 struct rsnd_dai_stream *io) 201 { 202 /* 203 * DMA settings for SSIU 204 */ 205 rsnd_mod_write(ssi_mod, SSI_CTRL, 0); 206 207 return 0; 208 } 209 210 int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod) 211 { 212 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 213 214 if (rsnd_is_gen1(priv)) 215 return 0; 216 217 /* enable SSI interrupt if Gen2 */ 218 if (rsnd_ssi_is_dma_mode(ssi_mod)) 219 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0e000000); 220 else 221 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000); 222 223 return 0; 224 } 225 226 int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod) 227 { 228 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 229 230 if (rsnd_is_gen1(priv)) 231 return 0; 232 233 /* disable SSI interrupt if Gen2 */ 234 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x00000000); 235 236 return 0; 237 } 238 239 static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io, 240 struct rsnd_src *src) 241 { 242 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 243 u32 convert_rate; 244 245 if (!runtime) 246 return 0; 247 248 if (!rsnd_enable_sync_convert(src)) 249 return src->convert_rate; 250 251 convert_rate = src->sync.val; 252 253 if (!convert_rate) 254 convert_rate = src->convert_rate; 255 256 if (!convert_rate) 257 convert_rate = runtime->rate; 258 259 return convert_rate; 260 } 261 262 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv, 263 struct rsnd_dai_stream *io, 264 struct snd_pcm_runtime *runtime) 265 { 266 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); 267 struct rsnd_src *src; 268 unsigned int rate = 0; 269 270 if (src_mod) { 271 src = rsnd_mod_to_src(src_mod); 272 273 /* 274 * return convert rate if SRC is used, 275 * otherwise, return runtime->rate as usual 276 */ 277 rate = rsnd_src_convert_rate(io, src); 278 } 279 280 if (!rate) 281 rate = runtime->rate; 282 283 return rate; 284 } 285 286 static int rsnd_src_set_convert_rate(struct rsnd_mod *mod, 287 struct rsnd_dai_stream *io) 288 { 289 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 290 struct rsnd_src *src = rsnd_mod_to_src(mod); 291 u32 convert_rate = rsnd_src_convert_rate(io, src); 292 u32 fsrate = 0; 293 294 if (convert_rate) 295 fsrate = 0x0400000 / convert_rate * runtime->rate; 296 297 /* set/clear soft reset */ 298 rsnd_mod_write(mod, SRC_SWRSR, 0); 299 rsnd_mod_write(mod, SRC_SWRSR, 1); 300 301 /* Set channel number and output bit length */ 302 rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod, io)); 303 304 /* Enable the initial value of IFS */ 305 if (fsrate) { 306 rsnd_mod_write(mod, SRC_IFSCR, 1); 307 308 /* Set initial value of IFS */ 309 rsnd_mod_write(mod, SRC_IFSVR, fsrate); 310 } 311 312 /* use DMA transfer */ 313 rsnd_mod_write(mod, SRC_BUSIF_MODE, 1); 314 315 return 0; 316 } 317 318 static int rsnd_src_hw_params(struct rsnd_mod *mod, 319 struct rsnd_dai_stream *io, 320 struct snd_pcm_substream *substream, 321 struct snd_pcm_hw_params *fe_params) 322 { 323 struct rsnd_src *src = rsnd_mod_to_src(mod); 324 struct snd_soc_pcm_runtime *fe = substream->private_data; 325 326 /* default value (mainly for non-DT) */ 327 src->convert_rate = src->info->convert_rate; 328 329 /* 330 * SRC assumes that it is used under DPCM if user want to use 331 * sampling rate convert. Then, SRC should be FE. 332 * And then, this function will be called *after* BE settings. 333 * this means, each BE already has fixuped hw_params. 334 * see 335 * dpcm_fe_dai_hw_params() 336 * dpcm_be_dai_hw_params() 337 */ 338 if (fe->dai_link->dynamic) { 339 int stream = substream->stream; 340 struct snd_soc_dpcm *dpcm; 341 struct snd_pcm_hw_params *be_params; 342 343 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 344 be_params = &dpcm->hw_params; 345 346 if (params_rate(fe_params) != params_rate(be_params)) 347 src->convert_rate = params_rate(be_params); 348 } 349 } 350 351 return 0; 352 } 353 354 static int rsnd_src_init(struct rsnd_mod *mod, 355 struct rsnd_priv *priv) 356 { 357 struct rsnd_src *src = rsnd_mod_to_src(mod); 358 359 rsnd_mod_hw_start(mod); 360 361 src->err = 0; 362 363 /* reset sync convert_rate */ 364 src->sync.val = 0; 365 366 /* 367 * Initialize the operation of the SRC internal circuits 368 * see rsnd_src_start() 369 */ 370 rsnd_mod_write(mod, SRC_SRCIR, 1); 371 372 return 0; 373 } 374 375 static int rsnd_src_quit(struct rsnd_mod *mod, 376 struct rsnd_dai_stream *io, 377 struct rsnd_priv *priv) 378 { 379 struct rsnd_src *src = rsnd_mod_to_src(mod); 380 struct device *dev = rsnd_priv_to_dev(priv); 381 382 rsnd_mod_hw_stop(mod); 383 384 if (src->err) 385 dev_warn(dev, "%s[%d] under/over flow err = %d\n", 386 rsnd_mod_name(mod), rsnd_mod_id(mod), src->err); 387 388 src->convert_rate = 0; 389 390 /* reset sync convert_rate */ 391 src->sync.val = 0; 392 393 return 0; 394 } 395 396 static int rsnd_src_start(struct rsnd_mod *mod) 397 { 398 /* 399 * Cancel the initialization and operate the SRC function 400 * see rsnd_src_init() 401 */ 402 rsnd_mod_write(mod, SRC_SRCIR, 0); 403 404 return 0; 405 } 406 407 static int rsnd_src_stop(struct rsnd_mod *mod) 408 { 409 /* nothing to do */ 410 return 0; 411 } 412 413 /* 414 * Gen1 functions 415 */ 416 static int rsnd_src_set_route_gen1(struct rsnd_dai_stream *io, 417 struct rsnd_mod *mod) 418 { 419 struct src_route_config { 420 u32 mask; 421 int shift; 422 } routes[] = { 423 { 0xF, 0, }, /* 0 */ 424 { 0xF, 4, }, /* 1 */ 425 { 0xF, 8, }, /* 2 */ 426 { 0x7, 12, }, /* 3 */ 427 { 0x7, 16, }, /* 4 */ 428 { 0x7, 20, }, /* 5 */ 429 { 0x7, 24, }, /* 6 */ 430 { 0x3, 28, }, /* 7 */ 431 { 0x3, 30, }, /* 8 */ 432 }; 433 u32 mask; 434 u32 val; 435 int id; 436 437 id = rsnd_mod_id(mod); 438 if (id < 0 || id >= ARRAY_SIZE(routes)) 439 return -EIO; 440 441 /* 442 * SRC_ROUTE_SELECT 443 */ 444 val = rsnd_io_is_play(io) ? 0x1 : 0x2; 445 val = val << routes[id].shift; 446 mask = routes[id].mask << routes[id].shift; 447 448 rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val); 449 450 return 0; 451 } 452 453 static int rsnd_src_set_convert_timing_gen1(struct rsnd_dai_stream *io, 454 struct rsnd_mod *mod) 455 { 456 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 457 struct rsnd_src *src = rsnd_mod_to_src(mod); 458 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 459 u32 convert_rate = rsnd_src_convert_rate(io, src); 460 u32 mask; 461 u32 val; 462 int shift; 463 int id = rsnd_mod_id(mod); 464 int ret; 465 466 /* 467 * SRC_TIMING_SELECT 468 */ 469 shift = (id % 4) * 8; 470 mask = 0x1F << shift; 471 472 /* 473 * ADG is used as source clock if SRC was used, 474 * then, SSI WS is used as destination clock. 475 * SSI WS is used as source clock if SRC is not used 476 * (when playback, source/destination become reverse when capture) 477 */ 478 ret = 0; 479 if (convert_rate) { 480 /* use ADG */ 481 val = 0; 482 ret = rsnd_adg_set_convert_clk_gen1(priv, mod, 483 runtime->rate, 484 convert_rate); 485 } else if (8 == id) { 486 /* use SSI WS, but SRU8 is special */ 487 val = id << shift; 488 } else { 489 /* use SSI WS */ 490 val = (id + 1) << shift; 491 } 492 493 if (ret < 0) 494 return ret; 495 496 switch (id / 4) { 497 case 0: 498 rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val); 499 break; 500 case 1: 501 rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val); 502 break; 503 case 2: 504 rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val); 505 break; 506 } 507 508 return 0; 509 } 510 511 static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod, 512 struct rsnd_dai_stream *io) 513 { 514 struct rsnd_src *src = rsnd_mod_to_src(mod); 515 int ret; 516 517 ret = rsnd_src_set_convert_rate(mod, io); 518 if (ret < 0) 519 return ret; 520 521 /* Select SRC mode (fixed value) */ 522 rsnd_mod_write(mod, SRC_SRCCR, 0x00010110); 523 524 /* Set the restriction value of the FS ratio (98%) */ 525 rsnd_mod_write(mod, SRC_MNFSR, 526 rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98); 527 528 /* Gen1/Gen2 are not compatible */ 529 if (rsnd_src_convert_rate(io, src)) 530 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1); 531 532 /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */ 533 534 return 0; 535 } 536 537 static int rsnd_src_init_gen1(struct rsnd_mod *mod, 538 struct rsnd_dai_stream *io, 539 struct rsnd_priv *priv) 540 { 541 int ret; 542 543 ret = rsnd_src_init(mod, priv); 544 if (ret < 0) 545 return ret; 546 547 ret = rsnd_src_set_route_gen1(io, mod); 548 if (ret < 0) 549 return ret; 550 551 ret = rsnd_src_set_convert_rate_gen1(mod, io); 552 if (ret < 0) 553 return ret; 554 555 ret = rsnd_src_set_convert_timing_gen1(io, mod); 556 if (ret < 0) 557 return ret; 558 559 return 0; 560 } 561 562 static int rsnd_src_start_gen1(struct rsnd_mod *mod, 563 struct rsnd_dai_stream *io, 564 struct rsnd_priv *priv) 565 { 566 int id = rsnd_mod_id(mod); 567 568 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id)); 569 570 return rsnd_src_start(mod); 571 } 572 573 static int rsnd_src_stop_gen1(struct rsnd_mod *mod, 574 struct rsnd_dai_stream *io, 575 struct rsnd_priv *priv) 576 { 577 int id = rsnd_mod_id(mod); 578 579 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0); 580 581 return rsnd_src_stop(mod); 582 } 583 584 static struct rsnd_mod_ops rsnd_src_gen1_ops = { 585 .name = SRC_NAME, 586 .dma_req = rsnd_src_dma_req, 587 .init = rsnd_src_init_gen1, 588 .quit = rsnd_src_quit, 589 .start = rsnd_src_start_gen1, 590 .stop = rsnd_src_stop_gen1, 591 .hw_params = rsnd_src_hw_params, 592 }; 593 594 /* 595 * Gen2 functions 596 */ 597 #define rsnd_src_irq_enable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 1) 598 #define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0) 599 static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable) 600 { 601 struct rsnd_src *src = rsnd_mod_to_src(mod); 602 u32 sys_int_val, int_val, sys_int_mask; 603 int irq = src->info->irq; 604 int id = rsnd_mod_id(mod); 605 606 sys_int_val = 607 sys_int_mask = OUF_SRC(id); 608 int_val = 0x3300; 609 610 /* 611 * IRQ is not supported on non-DT 612 * see 613 * rsnd_src_probe_gen2() 614 */ 615 if ((irq <= 0) || !enable) { 616 sys_int_val = 0; 617 int_val = 0; 618 } 619 620 rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val); 621 rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val); 622 rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val); 623 } 624 625 static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod) 626 { 627 u32 val = OUF_SRC(rsnd_mod_id(mod)); 628 629 rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val); 630 rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val); 631 } 632 633 static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod) 634 { 635 u32 val = OUF_SRC(rsnd_mod_id(mod)); 636 bool ret = false; 637 638 if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val) || 639 (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val)) { 640 struct rsnd_src *src = rsnd_mod_to_src(mod); 641 642 src->err++; 643 ret = true; 644 } 645 646 /* clear error static */ 647 rsnd_src_error_clear_gen2(mod); 648 649 return ret; 650 } 651 652 static int _rsnd_src_start_gen2(struct rsnd_mod *mod, 653 struct rsnd_dai_stream *io) 654 { 655 u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11; 656 657 rsnd_mod_write(mod, SRC_CTRL, val); 658 659 rsnd_src_error_clear_gen2(mod); 660 661 rsnd_src_start(mod); 662 663 rsnd_src_irq_enable_gen2(mod); 664 665 return 0; 666 } 667 668 static int _rsnd_src_stop_gen2(struct rsnd_mod *mod) 669 { 670 rsnd_src_irq_disable_gen2(mod); 671 672 rsnd_mod_write(mod, SRC_CTRL, 0); 673 674 rsnd_src_error_record_gen2(mod); 675 676 return rsnd_src_stop(mod); 677 } 678 679 static void __rsnd_src_interrupt_gen2(struct rsnd_mod *mod, 680 struct rsnd_dai_stream *io) 681 { 682 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 683 684 spin_lock(&priv->lock); 685 686 /* ignore all cases if not working */ 687 if (!rsnd_io_is_working(io)) 688 goto rsnd_src_interrupt_gen2_out; 689 690 if (rsnd_src_error_record_gen2(mod)) { 691 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 692 struct rsnd_src *src = rsnd_mod_to_src(mod); 693 struct device *dev = rsnd_priv_to_dev(priv); 694 695 dev_dbg(dev, "%s[%d] restart\n", 696 rsnd_mod_name(mod), rsnd_mod_id(mod)); 697 698 _rsnd_src_stop_gen2(mod); 699 if (src->err < 1024) 700 _rsnd_src_start_gen2(mod, io); 701 else 702 dev_warn(dev, "no more SRC restart\n"); 703 } 704 705 rsnd_src_interrupt_gen2_out: 706 spin_unlock(&priv->lock); 707 } 708 709 static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data) 710 { 711 struct rsnd_mod *mod = data; 712 713 rsnd_mod_interrupt(mod, __rsnd_src_interrupt_gen2); 714 715 return IRQ_HANDLED; 716 } 717 718 static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod, 719 struct rsnd_dai_stream *io) 720 { 721 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 722 struct device *dev = rsnd_priv_to_dev(priv); 723 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 724 struct rsnd_src *src = rsnd_mod_to_src(mod); 725 u32 convert_rate = rsnd_src_convert_rate(io, src); 726 u32 cr, route; 727 uint ratio; 728 int ret; 729 730 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */ 731 if (!convert_rate) 732 ratio = 0; 733 else if (convert_rate > runtime->rate) 734 ratio = 100 * convert_rate / runtime->rate; 735 else 736 ratio = 100 * runtime->rate / convert_rate; 737 738 if (ratio > 600) { 739 dev_err(dev, "FSO/FSI ratio error\n"); 740 return -EINVAL; 741 } 742 743 ret = rsnd_src_set_convert_rate(mod, io); 744 if (ret < 0) 745 return ret; 746 747 cr = 0x00011110; 748 route = 0x0; 749 if (convert_rate) { 750 route = 0x1; 751 752 if (rsnd_enable_sync_convert(src)) { 753 cr |= 0x1; 754 route |= rsnd_io_is_play(io) ? 755 (0x1 << 24) : (0x1 << 25); 756 } 757 } 758 759 rsnd_mod_write(mod, SRC_SRCCR, cr); 760 rsnd_mod_write(mod, SRC_ROUTE_MODE0, route); 761 762 switch (rsnd_mod_id(mod)) { 763 case 5: 764 case 6: 765 case 7: 766 case 8: 767 rsnd_mod_write(mod, SRC_BSDSR, 0x02400000); 768 break; 769 default: 770 rsnd_mod_write(mod, SRC_BSDSR, 0x01800000); 771 break; 772 } 773 774 rsnd_mod_write(mod, SRC_BSISR, 0x00100060); 775 776 return 0; 777 } 778 779 static int rsnd_src_set_convert_timing_gen2(struct rsnd_dai_stream *io, 780 struct rsnd_mod *mod) 781 { 782 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 783 struct rsnd_src *src = rsnd_mod_to_src(mod); 784 u32 convert_rate = rsnd_src_convert_rate(io, src); 785 int ret; 786 787 if (convert_rate) 788 ret = rsnd_adg_set_convert_clk_gen2(mod, io, 789 runtime->rate, 790 convert_rate); 791 else 792 ret = rsnd_adg_set_convert_timing_gen2(mod, io); 793 794 return ret; 795 } 796 797 static int rsnd_src_probe_gen2(struct rsnd_mod *mod, 798 struct rsnd_dai_stream *io, 799 struct rsnd_priv *priv) 800 { 801 struct rsnd_src *src = rsnd_mod_to_src(mod); 802 struct device *dev = rsnd_priv_to_dev(priv); 803 int irq = src->info->irq; 804 int ret; 805 806 if (irq > 0) { 807 /* 808 * IRQ is not supported on non-DT 809 * see 810 * rsnd_src_irq_enable_gen2() 811 */ 812 ret = devm_request_irq(dev, irq, 813 rsnd_src_interrupt_gen2, 814 IRQF_SHARED, 815 dev_name(dev), mod); 816 if (ret) 817 return ret; 818 } 819 820 ret = rsnd_dma_init(io, 821 rsnd_mod_to_dma(mod), 822 src->info->dma_id); 823 824 return ret; 825 } 826 827 static int rsnd_src_remove_gen2(struct rsnd_mod *mod, 828 struct rsnd_dai_stream *io, 829 struct rsnd_priv *priv) 830 { 831 rsnd_dma_quit(io, rsnd_mod_to_dma(mod)); 832 833 return 0; 834 } 835 836 static int rsnd_src_init_gen2(struct rsnd_mod *mod, 837 struct rsnd_dai_stream *io, 838 struct rsnd_priv *priv) 839 { 840 int ret; 841 842 ret = rsnd_src_init(mod, priv); 843 if (ret < 0) 844 return ret; 845 846 ret = rsnd_src_set_convert_rate_gen2(mod, io); 847 if (ret < 0) 848 return ret; 849 850 ret = rsnd_src_set_convert_timing_gen2(io, mod); 851 if (ret < 0) 852 return ret; 853 854 return 0; 855 } 856 857 static int rsnd_src_start_gen2(struct rsnd_mod *mod, 858 struct rsnd_dai_stream *io, 859 struct rsnd_priv *priv) 860 { 861 rsnd_dma_start(io, rsnd_mod_to_dma(mod)); 862 863 return _rsnd_src_start_gen2(mod, io); 864 } 865 866 static int rsnd_src_stop_gen2(struct rsnd_mod *mod, 867 struct rsnd_dai_stream *io, 868 struct rsnd_priv *priv) 869 { 870 int ret; 871 872 ret = _rsnd_src_stop_gen2(mod); 873 874 rsnd_dma_stop(io, rsnd_mod_to_dma(mod)); 875 876 return ret; 877 } 878 879 static void rsnd_src_reconvert_update(struct rsnd_dai_stream *io, 880 struct rsnd_mod *mod) 881 { 882 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 883 struct rsnd_src *src = rsnd_mod_to_src(mod); 884 u32 convert_rate = rsnd_src_convert_rate(io, src); 885 u32 fsrate; 886 887 if (!runtime) 888 return; 889 890 if (!convert_rate) 891 convert_rate = runtime->rate; 892 893 fsrate = 0x0400000 / convert_rate * runtime->rate; 894 895 /* update IFS */ 896 rsnd_mod_write(mod, SRC_IFSVR, fsrate); 897 } 898 899 static int rsnd_src_pcm_new(struct rsnd_mod *mod, 900 struct rsnd_dai_stream *io, 901 struct snd_soc_pcm_runtime *rtd) 902 { 903 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 904 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 905 struct rsnd_src *src = rsnd_mod_to_src(mod); 906 int ret; 907 908 /* 909 * enable SRC sync convert if possible 910 */ 911 912 /* 913 * Gen1 is not supported 914 */ 915 if (rsnd_is_gen1(priv)) 916 return 0; 917 918 /* 919 * SRC sync convert needs clock master 920 */ 921 if (!rsnd_rdai_is_clk_master(rdai)) 922 return 0; 923 924 /* 925 * We can't use SRC sync convert 926 * if it has DVC 927 */ 928 if (rsnd_io_to_mod_dvc(io)) 929 return 0; 930 931 /* 932 * enable sync convert 933 */ 934 ret = rsnd_kctrl_new_s(mod, io, rtd, 935 rsnd_io_is_play(io) ? 936 "SRC Out Rate Switch" : 937 "SRC In Rate Switch", 938 rsnd_src_reconvert_update, 939 &src->sen, 1); 940 if (ret < 0) 941 return ret; 942 943 ret = rsnd_kctrl_new_s(mod, io, rtd, 944 rsnd_io_is_play(io) ? 945 "SRC Out Rate" : 946 "SRC In Rate", 947 rsnd_src_reconvert_update, 948 &src->sync, 192000); 949 950 return ret; 951 } 952 953 static struct rsnd_mod_ops rsnd_src_gen2_ops = { 954 .name = SRC_NAME, 955 .dma_req = rsnd_src_dma_req, 956 .probe = rsnd_src_probe_gen2, 957 .remove = rsnd_src_remove_gen2, 958 .init = rsnd_src_init_gen2, 959 .quit = rsnd_src_quit, 960 .start = rsnd_src_start_gen2, 961 .stop = rsnd_src_stop_gen2, 962 .hw_params = rsnd_src_hw_params, 963 .pcm_new = rsnd_src_pcm_new, 964 }; 965 966 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id) 967 { 968 if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv))) 969 id = 0; 970 971 return &((struct rsnd_src *)(priv->src) + id)->mod; 972 } 973 974 static void rsnd_of_parse_src(struct platform_device *pdev, 975 const struct rsnd_of_data *of_data, 976 struct rsnd_priv *priv) 977 { 978 struct device_node *src_node; 979 struct device_node *np; 980 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 981 struct rsnd_src_platform_info *src_info; 982 struct device *dev = &pdev->dev; 983 int nr, i; 984 985 if (!of_data) 986 return; 987 988 src_node = rsnd_src_of_node(priv); 989 if (!src_node) 990 return; 991 992 nr = of_get_child_count(src_node); 993 if (!nr) 994 goto rsnd_of_parse_src_end; 995 996 src_info = devm_kzalloc(dev, 997 sizeof(struct rsnd_src_platform_info) * nr, 998 GFP_KERNEL); 999 if (!src_info) { 1000 dev_err(dev, "src info allocation error\n"); 1001 goto rsnd_of_parse_src_end; 1002 } 1003 1004 info->src_info = src_info; 1005 info->src_info_nr = nr; 1006 1007 i = 0; 1008 for_each_child_of_node(src_node, np) { 1009 src_info[i].irq = irq_of_parse_and_map(np, 0); 1010 1011 i++; 1012 } 1013 1014 rsnd_of_parse_src_end: 1015 of_node_put(src_node); 1016 } 1017 1018 int rsnd_src_probe(struct platform_device *pdev, 1019 const struct rsnd_of_data *of_data, 1020 struct rsnd_priv *priv) 1021 { 1022 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 1023 struct device *dev = rsnd_priv_to_dev(priv); 1024 struct rsnd_src *src; 1025 struct rsnd_mod_ops *ops; 1026 struct clk *clk; 1027 char name[RSND_SRC_NAME_SIZE]; 1028 int i, nr, ret; 1029 1030 ops = NULL; 1031 if (rsnd_is_gen1(priv)) 1032 ops = &rsnd_src_gen1_ops; 1033 if (rsnd_is_gen2(priv)) 1034 ops = &rsnd_src_gen2_ops; 1035 if (!ops) { 1036 dev_err(dev, "unknown Generation\n"); 1037 return -EIO; 1038 } 1039 1040 rsnd_of_parse_src(pdev, of_data, priv); 1041 1042 /* 1043 * init SRC 1044 */ 1045 nr = info->src_info_nr; 1046 if (!nr) 1047 return 0; 1048 1049 src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL); 1050 if (!src) { 1051 dev_err(dev, "SRC allocate failed\n"); 1052 return -ENOMEM; 1053 } 1054 1055 priv->src_nr = nr; 1056 priv->src = src; 1057 1058 for_each_rsnd_src(src, priv, i) { 1059 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d", 1060 SRC_NAME, i); 1061 1062 clk = devm_clk_get(dev, name); 1063 if (IS_ERR(clk)) 1064 return PTR_ERR(clk); 1065 1066 src->info = &info->src_info[i]; 1067 1068 ret = rsnd_mod_init(priv, &src->mod, ops, clk, RSND_MOD_SRC, i); 1069 if (ret) 1070 return ret; 1071 } 1072 1073 return 0; 1074 } 1075 1076 void rsnd_src_remove(struct platform_device *pdev, 1077 struct rsnd_priv *priv) 1078 { 1079 struct rsnd_src *src; 1080 int i; 1081 1082 for_each_rsnd_src(src, priv, i) { 1083 rsnd_mod_quit(&src->mod); 1084 } 1085 } 1086