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 22struct 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 */ 120static struct dma_chan *rsnd_src_dma_req(struct rsnd_mod *mod) 121{ 122 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 123 struct rsnd_dai_stream *io = rsnd_mod_to_io(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 131int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod, 132 int use_busif) 133{ 134 struct rsnd_dai_stream *io = rsnd_mod_to_io(ssi_mod); 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)); 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 199int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod) 200{ 201 /* 202 * DMA settings for SSIU 203 */ 204 rsnd_mod_write(ssi_mod, SSI_CTRL, 0); 205 206 return 0; 207} 208 209int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod) 210{ 211 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 212 213 if (rsnd_is_gen1(priv)) 214 return 0; 215 216 /* enable SSI interrupt if Gen2 */ 217 if (rsnd_ssi_is_dma_mode(ssi_mod)) 218 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0e000000); 219 else 220 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000); 221 222 return 0; 223} 224 225int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod) 226{ 227 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 228 229 if (rsnd_is_gen1(priv)) 230 return 0; 231 232 /* disable SSI interrupt if Gen2 */ 233 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x00000000); 234 235 return 0; 236} 237 238static u32 rsnd_src_convert_rate(struct rsnd_src *src) 239{ 240 struct rsnd_mod *mod = &src->mod; 241 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 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 262unsigned 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(src); 278 } 279 280 if (!rate) 281 rate = runtime->rate; 282 283 return rate; 284} 285 286static int rsnd_src_set_convert_rate(struct rsnd_mod *mod) 287{ 288 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 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(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)); 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 318static int rsnd_src_hw_params(struct rsnd_mod *mod, 319 struct snd_pcm_substream *substream, 320 struct snd_pcm_hw_params *fe_params) 321{ 322 struct rsnd_src *src = rsnd_mod_to_src(mod); 323 struct snd_soc_pcm_runtime *fe = substream->private_data; 324 325 /* default value (mainly for non-DT) */ 326 src->convert_rate = src->info->convert_rate; 327 328 /* 329 * SRC assumes that it is used under DPCM if user want to use 330 * sampling rate convert. Then, SRC should be FE. 331 * And then, this function will be called *after* BE settings. 332 * this means, each BE already has fixuped hw_params. 333 * see 334 * dpcm_fe_dai_hw_params() 335 * dpcm_be_dai_hw_params() 336 */ 337 if (fe->dai_link->dynamic) { 338 int stream = substream->stream; 339 struct snd_soc_dpcm *dpcm; 340 struct snd_pcm_hw_params *be_params; 341 342 list_for_each_entry(dpcm, &fe->dpcm[stream].be_clients, list_be) { 343 be_params = &dpcm->hw_params; 344 345 if (params_rate(fe_params) != params_rate(be_params)) 346 src->convert_rate = params_rate(be_params); 347 } 348 } 349 350 return 0; 351} 352 353static int rsnd_src_init(struct rsnd_mod *mod, 354 struct rsnd_priv *priv) 355{ 356 struct rsnd_src *src = rsnd_mod_to_src(mod); 357 358 rsnd_mod_hw_start(mod); 359 360 src->err = 0; 361 362 /* reset sync convert_rate */ 363 src->sync.val = 0; 364 365 /* 366 * Initialize the operation of the SRC internal circuits 367 * see rsnd_src_start() 368 */ 369 rsnd_mod_write(mod, SRC_SRCIR, 1); 370 371 return 0; 372} 373 374static int rsnd_src_quit(struct rsnd_mod *mod, 375 struct rsnd_priv *priv) 376{ 377 struct rsnd_src *src = rsnd_mod_to_src(mod); 378 struct device *dev = rsnd_priv_to_dev(priv); 379 380 rsnd_mod_hw_stop(mod); 381 382 if (src->err) 383 dev_warn(dev, "%s[%d] under/over flow err = %d\n", 384 rsnd_mod_name(mod), rsnd_mod_id(mod), src->err); 385 386 src->convert_rate = 0; 387 388 /* reset sync convert_rate */ 389 src->sync.val = 0; 390 391 return 0; 392} 393 394static int rsnd_src_start(struct rsnd_mod *mod) 395{ 396 /* 397 * Cancel the initialization and operate the SRC function 398 * see rsnd_src_init() 399 */ 400 rsnd_mod_write(mod, SRC_SRCIR, 0); 401 402 return 0; 403} 404 405static int rsnd_src_stop(struct rsnd_mod *mod) 406{ 407 /* nothing to do */ 408 return 0; 409} 410 411/* 412 * Gen1 functions 413 */ 414static int rsnd_src_set_route_gen1(struct rsnd_mod *mod) 415{ 416 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 417 struct src_route_config { 418 u32 mask; 419 int shift; 420 } routes[] = { 421 { 0xF, 0, }, /* 0 */ 422 { 0xF, 4, }, /* 1 */ 423 { 0xF, 8, }, /* 2 */ 424 { 0x7, 12, }, /* 3 */ 425 { 0x7, 16, }, /* 4 */ 426 { 0x7, 20, }, /* 5 */ 427 { 0x7, 24, }, /* 6 */ 428 { 0x3, 28, }, /* 7 */ 429 { 0x3, 30, }, /* 8 */ 430 }; 431 u32 mask; 432 u32 val; 433 int id; 434 435 id = rsnd_mod_id(mod); 436 if (id < 0 || id >= ARRAY_SIZE(routes)) 437 return -EIO; 438 439 /* 440 * SRC_ROUTE_SELECT 441 */ 442 val = rsnd_io_is_play(io) ? 0x1 : 0x2; 443 val = val << routes[id].shift; 444 mask = routes[id].mask << routes[id].shift; 445 446 rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val); 447 448 return 0; 449} 450 451static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod) 452{ 453 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 454 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 455 struct rsnd_src *src = rsnd_mod_to_src(mod); 456 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 457 u32 convert_rate = rsnd_src_convert_rate(src); 458 u32 mask; 459 u32 val; 460 int shift; 461 int id = rsnd_mod_id(mod); 462 int ret; 463 464 /* 465 * SRC_TIMING_SELECT 466 */ 467 shift = (id % 4) * 8; 468 mask = 0x1F << shift; 469 470 /* 471 * ADG is used as source clock if SRC was used, 472 * then, SSI WS is used as destination clock. 473 * SSI WS is used as source clock if SRC is not used 474 * (when playback, source/destination become reverse when capture) 475 */ 476 ret = 0; 477 if (convert_rate) { 478 /* use ADG */ 479 val = 0; 480 ret = rsnd_adg_set_convert_clk_gen1(priv, mod, 481 runtime->rate, 482 convert_rate); 483 } else if (8 == id) { 484 /* use SSI WS, but SRU8 is special */ 485 val = id << shift; 486 } else { 487 /* use SSI WS */ 488 val = (id + 1) << shift; 489 } 490 491 if (ret < 0) 492 return ret; 493 494 switch (id / 4) { 495 case 0: 496 rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val); 497 break; 498 case 1: 499 rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val); 500 break; 501 case 2: 502 rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val); 503 break; 504 } 505 506 return 0; 507} 508 509static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod) 510{ 511 struct rsnd_src *src = rsnd_mod_to_src(mod); 512 int ret; 513 514 ret = rsnd_src_set_convert_rate(mod); 515 if (ret < 0) 516 return ret; 517 518 /* Select SRC mode (fixed value) */ 519 rsnd_mod_write(mod, SRC_SRCCR, 0x00010110); 520 521 /* Set the restriction value of the FS ratio (98%) */ 522 rsnd_mod_write(mod, SRC_MNFSR, 523 rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98); 524 525 /* Gen1/Gen2 are not compatible */ 526 if (rsnd_src_convert_rate(src)) 527 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1); 528 529 /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */ 530 531 return 0; 532} 533 534static int rsnd_src_init_gen1(struct rsnd_mod *mod, 535 struct rsnd_priv *priv) 536{ 537 int ret; 538 539 ret = rsnd_src_init(mod, priv); 540 if (ret < 0) 541 return ret; 542 543 ret = rsnd_src_set_route_gen1(mod); 544 if (ret < 0) 545 return ret; 546 547 ret = rsnd_src_set_convert_rate_gen1(mod); 548 if (ret < 0) 549 return ret; 550 551 ret = rsnd_src_set_convert_timing_gen1(mod); 552 if (ret < 0) 553 return ret; 554 555 return 0; 556} 557 558static int rsnd_src_start_gen1(struct rsnd_mod *mod, 559 struct rsnd_priv *priv) 560{ 561 int id = rsnd_mod_id(mod); 562 563 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id)); 564 565 return rsnd_src_start(mod); 566} 567 568static int rsnd_src_stop_gen1(struct rsnd_mod *mod, 569 struct rsnd_priv *priv) 570{ 571 int id = rsnd_mod_id(mod); 572 573 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0); 574 575 return rsnd_src_stop(mod); 576} 577 578static struct rsnd_mod_ops rsnd_src_gen1_ops = { 579 .name = SRC_NAME, 580 .dma_req = rsnd_src_dma_req, 581 .init = rsnd_src_init_gen1, 582 .quit = rsnd_src_quit, 583 .start = rsnd_src_start_gen1, 584 .stop = rsnd_src_stop_gen1, 585 .hw_params = rsnd_src_hw_params, 586}; 587 588/* 589 * Gen2 functions 590 */ 591#define rsnd_src_irq_enable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 1) 592#define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0) 593static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable) 594{ 595 struct rsnd_src *src = rsnd_mod_to_src(mod); 596 u32 sys_int_val, int_val, sys_int_mask; 597 int irq = src->info->irq; 598 int id = rsnd_mod_id(mod); 599 600 sys_int_val = 601 sys_int_mask = OUF_SRC(id); 602 int_val = 0x3300; 603 604 /* 605 * IRQ is not supported on non-DT 606 * see 607 * rsnd_src_probe_gen2() 608 */ 609 if ((irq <= 0) || !enable) { 610 sys_int_val = 0; 611 int_val = 0; 612 } 613 614 rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val); 615 rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val); 616 rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val); 617} 618 619static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod) 620{ 621 u32 val = OUF_SRC(rsnd_mod_id(mod)); 622 623 rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val); 624 rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val); 625} 626 627static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod) 628{ 629 u32 val = OUF_SRC(rsnd_mod_id(mod)); 630 bool ret = false; 631 632 if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val) || 633 (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val)) { 634 struct rsnd_src *src = rsnd_mod_to_src(mod); 635 636 src->err++; 637 ret = true; 638 } 639 640 /* clear error static */ 641 rsnd_src_error_clear_gen2(mod); 642 643 return ret; 644} 645 646static int _rsnd_src_start_gen2(struct rsnd_mod *mod) 647{ 648 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 649 u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11; 650 651 rsnd_mod_write(mod, SRC_CTRL, val); 652 653 rsnd_src_error_clear_gen2(mod); 654 655 rsnd_src_start(mod); 656 657 rsnd_src_irq_enable_gen2(mod); 658 659 return 0; 660} 661 662static int _rsnd_src_stop_gen2(struct rsnd_mod *mod) 663{ 664 rsnd_src_irq_disable_gen2(mod); 665 666 rsnd_mod_write(mod, SRC_CTRL, 0); 667 668 rsnd_src_error_record_gen2(mod); 669 670 return rsnd_src_stop(mod); 671} 672 673static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data) 674{ 675 struct rsnd_mod *mod = data; 676 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 677 678 if (!io) 679 return IRQ_NONE; 680 681 if (rsnd_src_error_record_gen2(mod)) { 682 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 683 struct rsnd_src *src = rsnd_mod_to_src(mod); 684 struct device *dev = rsnd_priv_to_dev(priv); 685 686 dev_dbg(dev, "%s[%d] restart\n", 687 rsnd_mod_name(mod), rsnd_mod_id(mod)); 688 689 _rsnd_src_stop_gen2(mod); 690 if (src->err < 1024) 691 _rsnd_src_start_gen2(mod); 692 else 693 dev_warn(dev, "no more SRC restart\n"); 694 } 695 696 return IRQ_HANDLED; 697} 698 699static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod) 700{ 701 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 702 struct device *dev = rsnd_priv_to_dev(priv); 703 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 704 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 705 struct rsnd_src *src = rsnd_mod_to_src(mod); 706 u32 convert_rate = rsnd_src_convert_rate(src); 707 u32 cr, route; 708 uint ratio; 709 int ret; 710 711 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */ 712 if (!convert_rate) 713 ratio = 0; 714 else if (convert_rate > runtime->rate) 715 ratio = 100 * convert_rate / runtime->rate; 716 else 717 ratio = 100 * runtime->rate / convert_rate; 718 719 if (ratio > 600) { 720 dev_err(dev, "FSO/FSI ratio error\n"); 721 return -EINVAL; 722 } 723 724 ret = rsnd_src_set_convert_rate(mod); 725 if (ret < 0) 726 return ret; 727 728 cr = 0x00011110; 729 route = 0x0; 730 if (convert_rate) { 731 route = 0x1; 732 733 if (rsnd_enable_sync_convert(src)) { 734 cr |= 0x1; 735 route |= rsnd_io_is_play(io) ? 736 (0x1 << 24) : (0x1 << 25); 737 } 738 } 739 740 rsnd_mod_write(mod, SRC_SRCCR, cr); 741 rsnd_mod_write(mod, SRC_ROUTE_MODE0, route); 742 743 switch (rsnd_mod_id(mod)) { 744 case 5: 745 case 6: 746 case 7: 747 case 8: 748 rsnd_mod_write(mod, SRC_BSDSR, 0x02400000); 749 break; 750 default: 751 rsnd_mod_write(mod, SRC_BSDSR, 0x01800000); 752 break; 753 } 754 755 rsnd_mod_write(mod, SRC_BSISR, 0x00100060); 756 757 return 0; 758} 759 760static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod) 761{ 762 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 763 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 764 struct rsnd_src *src = rsnd_mod_to_src(mod); 765 u32 convert_rate = rsnd_src_convert_rate(src); 766 int ret; 767 768 if (convert_rate) 769 ret = rsnd_adg_set_convert_clk_gen2(mod, io, 770 runtime->rate, 771 convert_rate); 772 else 773 ret = rsnd_adg_set_convert_timing_gen2(mod, io); 774 775 return ret; 776} 777 778static int rsnd_src_probe_gen2(struct rsnd_mod *mod, 779 struct rsnd_priv *priv) 780{ 781 struct rsnd_src *src = rsnd_mod_to_src(mod); 782 struct device *dev = rsnd_priv_to_dev(priv); 783 int irq = src->info->irq; 784 int ret; 785 786 if (irq > 0) { 787 /* 788 * IRQ is not supported on non-DT 789 * see 790 * rsnd_src_irq_enable_gen2() 791 */ 792 ret = devm_request_irq(dev, irq, 793 rsnd_src_interrupt_gen2, 794 IRQF_SHARED, 795 dev_name(dev), mod); 796 if (ret) 797 return ret; 798 } 799 800 ret = rsnd_dma_init(priv, 801 rsnd_mod_to_dma(mod), 802 src->info->dma_id); 803 804 return ret; 805} 806 807static int rsnd_src_remove_gen2(struct rsnd_mod *mod, 808 struct rsnd_priv *priv) 809{ 810 rsnd_dma_quit(rsnd_mod_to_dma(mod)); 811 812 return 0; 813} 814 815static int rsnd_src_init_gen2(struct rsnd_mod *mod, 816 struct rsnd_priv *priv) 817{ 818 int ret; 819 820 ret = rsnd_src_init(mod, priv); 821 if (ret < 0) 822 return ret; 823 824 ret = rsnd_src_set_convert_rate_gen2(mod); 825 if (ret < 0) 826 return ret; 827 828 ret = rsnd_src_set_convert_timing_gen2(mod); 829 if (ret < 0) 830 return ret; 831 832 return 0; 833} 834 835static int rsnd_src_start_gen2(struct rsnd_mod *mod, 836 struct rsnd_priv *priv) 837{ 838 rsnd_dma_start(rsnd_mod_to_dma(mod)); 839 840 return _rsnd_src_start_gen2(mod); 841} 842 843static int rsnd_src_stop_gen2(struct rsnd_mod *mod, 844 struct rsnd_priv *priv) 845{ 846 int ret; 847 848 ret = _rsnd_src_stop_gen2(mod); 849 850 rsnd_dma_stop(rsnd_mod_to_dma(mod)); 851 852 return ret; 853} 854 855static void rsnd_src_reconvert_update(struct rsnd_mod *mod) 856{ 857 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 858 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 859 struct rsnd_src *src = rsnd_mod_to_src(mod); 860 u32 convert_rate = rsnd_src_convert_rate(src); 861 u32 fsrate; 862 863 if (!runtime) 864 return; 865 866 if (!convert_rate) 867 convert_rate = runtime->rate; 868 869 fsrate = 0x0400000 / convert_rate * runtime->rate; 870 871 /* update IFS */ 872 rsnd_mod_write(mod, SRC_IFSVR, fsrate); 873} 874 875static int rsnd_src_pcm_new(struct rsnd_mod *mod, 876 struct snd_soc_pcm_runtime *rtd) 877{ 878 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 879 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 880 struct rsnd_dai *rdai = rsnd_io_to_rdai(io); 881 struct rsnd_src *src = rsnd_mod_to_src(mod); 882 int ret; 883 884 /* 885 * enable SRC sync convert if possible 886 */ 887 888 /* 889 * Gen1 is not supported 890 */ 891 if (rsnd_is_gen1(priv)) 892 return 0; 893 894 /* 895 * SRC sync convert needs clock master 896 */ 897 if (!rsnd_rdai_is_clk_master(rdai)) 898 return 0; 899 900 /* 901 * We can't use SRC sync convert 902 * if it has DVC 903 */ 904 if (rsnd_io_to_mod_dvc(io)) 905 return 0; 906 907 /* 908 * enable sync convert 909 */ 910 ret = rsnd_kctrl_new_s(mod, rtd, 911 rsnd_io_is_play(io) ? 912 "SRC Out Rate Switch" : 913 "SRC In Rate Switch", 914 rsnd_src_reconvert_update, 915 &src->sen, 1); 916 if (ret < 0) 917 return ret; 918 919 ret = rsnd_kctrl_new_s(mod, rtd, 920 rsnd_io_is_play(io) ? 921 "SRC Out Rate" : 922 "SRC In Rate", 923 rsnd_src_reconvert_update, 924 &src->sync, 192000); 925 926 return ret; 927} 928 929static struct rsnd_mod_ops rsnd_src_gen2_ops = { 930 .name = SRC_NAME, 931 .dma_req = rsnd_src_dma_req, 932 .probe = rsnd_src_probe_gen2, 933 .remove = rsnd_src_remove_gen2, 934 .init = rsnd_src_init_gen2, 935 .quit = rsnd_src_quit, 936 .start = rsnd_src_start_gen2, 937 .stop = rsnd_src_stop_gen2, 938 .hw_params = rsnd_src_hw_params, 939 .pcm_new = rsnd_src_pcm_new, 940}; 941 942struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id) 943{ 944 if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv))) 945 id = 0; 946 947 return &((struct rsnd_src *)(priv->src) + id)->mod; 948} 949 950static void rsnd_of_parse_src(struct platform_device *pdev, 951 const struct rsnd_of_data *of_data, 952 struct rsnd_priv *priv) 953{ 954 struct device_node *src_node; 955 struct device_node *np; 956 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 957 struct rsnd_src_platform_info *src_info; 958 struct device *dev = &pdev->dev; 959 int nr, i; 960 961 if (!of_data) 962 return; 963 964 src_node = rsnd_src_of_node(priv); 965 if (!src_node) 966 return; 967 968 nr = of_get_child_count(src_node); 969 if (!nr) 970 goto rsnd_of_parse_src_end; 971 972 src_info = devm_kzalloc(dev, 973 sizeof(struct rsnd_src_platform_info) * nr, 974 GFP_KERNEL); 975 if (!src_info) { 976 dev_err(dev, "src info allocation error\n"); 977 goto rsnd_of_parse_src_end; 978 } 979 980 info->src_info = src_info; 981 info->src_info_nr = nr; 982 983 i = 0; 984 for_each_child_of_node(src_node, np) { 985 src_info[i].irq = irq_of_parse_and_map(np, 0); 986 987 i++; 988 } 989 990rsnd_of_parse_src_end: 991 of_node_put(src_node); 992} 993 994int rsnd_src_probe(struct platform_device *pdev, 995 const struct rsnd_of_data *of_data, 996 struct rsnd_priv *priv) 997{ 998 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 999 struct device *dev = rsnd_priv_to_dev(priv); 1000 struct rsnd_src *src; 1001 struct rsnd_mod_ops *ops; 1002 struct clk *clk; 1003 char name[RSND_SRC_NAME_SIZE]; 1004 int i, nr, ret; 1005 1006 ops = NULL; 1007 if (rsnd_is_gen1(priv)) 1008 ops = &rsnd_src_gen1_ops; 1009 if (rsnd_is_gen2(priv)) 1010 ops = &rsnd_src_gen2_ops; 1011 if (!ops) { 1012 dev_err(dev, "unknown Generation\n"); 1013 return -EIO; 1014 } 1015 1016 rsnd_of_parse_src(pdev, of_data, priv); 1017 1018 /* 1019 * init SRC 1020 */ 1021 nr = info->src_info_nr; 1022 if (!nr) 1023 return 0; 1024 1025 src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL); 1026 if (!src) { 1027 dev_err(dev, "SRC allocate failed\n"); 1028 return -ENOMEM; 1029 } 1030 1031 priv->src_nr = nr; 1032 priv->src = src; 1033 1034 for_each_rsnd_src(src, priv, i) { 1035 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d", 1036 SRC_NAME, i); 1037 1038 clk = devm_clk_get(dev, name); 1039 if (IS_ERR(clk)) 1040 return PTR_ERR(clk); 1041 1042 src->info = &info->src_info[i]; 1043 1044 ret = rsnd_mod_init(&src->mod, ops, clk, RSND_MOD_SRC, i); 1045 if (ret) 1046 return ret; 1047 } 1048 1049 return 0; 1050} 1051 1052void rsnd_src_remove(struct platform_device *pdev, 1053 struct rsnd_priv *priv) 1054{ 1055 struct rsnd_src *src; 1056 int i; 1057 1058 for_each_rsnd_src(src, priv, i) { 1059 rsnd_mod_quit(&src->mod); 1060 } 1061} 1062