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 struct rsnd_src { 16 struct rsnd_src_platform_info *info; /* rcar_snd.h */ 17 struct rsnd_mod mod; 18 struct clk *clk; 19 }; 20 21 #define RSND_SRC_NAME_SIZE 16 22 23 #define rsnd_src_convert_rate(p) ((p)->info->convert_rate) 24 #define rsnd_mod_to_src(_mod) \ 25 container_of((_mod), struct rsnd_src, mod) 26 #define rsnd_src_dma_available(src) \ 27 rsnd_dma_available(rsnd_mod_to_dma(&(src)->mod)) 28 29 #define for_each_rsnd_src(pos, priv, i) \ 30 for ((i) = 0; \ 31 ((i) < rsnd_src_nr(priv)) && \ 32 ((pos) = (struct rsnd_src *)(priv)->src + i); \ 33 i++) 34 35 36 /* 37 * image of SRC (Sampling Rate Converter) 38 * 39 * 96kHz <-> +-----+ 48kHz +-----+ 48kHz +-------+ 40 * 48kHz <-> | SRC | <------> | SSI | <-----> | codec | 41 * 44.1kHz <-> +-----+ +-----+ +-------+ 42 * ... 43 * 44 */ 45 46 /* 47 * src.c is caring... 48 * 49 * Gen1 50 * 51 * [mem] -> [SRU] -> [SSI] 52 * |--------| 53 * 54 * Gen2 55 * 56 * [mem] -> [SRC] -> [SSIU] -> [SSI] 57 * |-----------------| 58 */ 59 60 /* 61 * How to use SRC bypass mode for debugging 62 * 63 * SRC has bypass mode, and it is useful for debugging. 64 * In Gen2 case, 65 * SRCm_MODE controls whether SRC is used or not 66 * SSI_MODE0 controls whether SSIU which receives SRC data 67 * is used or not. 68 * Both SRCm_MODE/SSI_MODE0 settings are needed if you use SRC, 69 * but SRC bypass mode needs SSI_MODE0 only. 70 * 71 * This driver request 72 * struct rsnd_src_platform_info { 73 * u32 convert_rate; 74 * int dma_id; 75 * } 76 * 77 * rsnd_src_convert_rate() indicates 78 * above convert_rate, and it controls 79 * whether SRC is used or not. 80 * 81 * ex) doesn't use SRC 82 * static struct rsnd_dai_platform_info rsnd_dai = { 83 * .playback = { .ssi = &rsnd_ssi[0], }, 84 * }; 85 * 86 * ex) uses SRC 87 * static struct rsnd_src_platform_info rsnd_src[] = { 88 * RSND_SCU(48000, 0), 89 * ... 90 * }; 91 * static struct rsnd_dai_platform_info rsnd_dai = { 92 * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] }, 93 * }; 94 * 95 * ex) uses SRC bypass mode 96 * static struct rsnd_src_platform_info rsnd_src[] = { 97 * RSND_SCU(0, 0), 98 * ... 99 * }; 100 * static struct rsnd_dai_platform_info rsnd_dai = { 101 * .playback = { .ssi = &rsnd_ssi[0], .src = &rsnd_src[0] }, 102 * }; 103 * 104 */ 105 106 /* 107 * Gen1/Gen2 common functions 108 */ 109 int rsnd_src_ssiu_start(struct rsnd_mod *ssi_mod, 110 struct rsnd_dai *rdai, 111 int use_busif) 112 { 113 struct rsnd_dai_stream *io = rsnd_mod_to_io(ssi_mod); 114 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 115 int ssi_id = rsnd_mod_id(ssi_mod); 116 117 /* 118 * SSI_MODE0 119 */ 120 rsnd_mod_bset(ssi_mod, SSI_MODE0, (1 << ssi_id), 121 !use_busif << ssi_id); 122 123 /* 124 * SSI_MODE1 125 */ 126 if (rsnd_ssi_is_pin_sharing(ssi_mod)) { 127 int shift = -1; 128 switch (ssi_id) { 129 case 1: 130 shift = 0; 131 break; 132 case 2: 133 shift = 2; 134 break; 135 case 4: 136 shift = 16; 137 break; 138 } 139 140 if (shift >= 0) 141 rsnd_mod_bset(ssi_mod, SSI_MODE1, 142 0x3 << shift, 143 rsnd_dai_is_clk_master(rdai) ? 144 0x2 << shift : 0x1 << shift); 145 } 146 147 /* 148 * DMA settings for SSIU 149 */ 150 if (use_busif) { 151 u32 val = 0x76543210; 152 u32 mask = ~0; 153 154 rsnd_mod_write(ssi_mod, SSI_BUSIF_ADINR, 155 rsnd_get_adinr(ssi_mod)); 156 rsnd_mod_write(ssi_mod, SSI_BUSIF_MODE, 1); 157 rsnd_mod_write(ssi_mod, SSI_CTRL, 0x1); 158 159 mask <<= runtime->channels * 4; 160 val = val & mask; 161 162 switch (runtime->sample_bits) { 163 case 16: 164 val |= 0x67452301 & ~mask; 165 break; 166 case 32: 167 val |= 0x76543210 & ~mask; 168 break; 169 } 170 rsnd_mod_write(ssi_mod, BUSIF_DALIGN, val); 171 172 } 173 174 return 0; 175 } 176 177 int rsnd_src_ssiu_stop(struct rsnd_mod *ssi_mod, 178 struct rsnd_dai *rdai, 179 int use_busif) 180 { 181 /* 182 * DMA settings for SSIU 183 */ 184 if (use_busif) 185 rsnd_mod_write(ssi_mod, SSI_CTRL, 0); 186 187 return 0; 188 } 189 190 int rsnd_src_enable_ssi_irq(struct rsnd_mod *ssi_mod, 191 struct rsnd_dai *rdai) 192 { 193 struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod); 194 195 /* enable PIO interrupt if Gen2 */ 196 if (rsnd_is_gen2(priv)) 197 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000); 198 199 return 0; 200 } 201 202 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv, 203 struct rsnd_dai_stream *io, 204 struct snd_pcm_runtime *runtime) 205 { 206 struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io); 207 struct rsnd_src *src; 208 unsigned int rate = 0; 209 210 if (src_mod) { 211 src = rsnd_mod_to_src(src_mod); 212 213 /* 214 * return convert rate if SRC is used, 215 * otherwise, return runtime->rate as usual 216 */ 217 rate = rsnd_src_convert_rate(src); 218 } 219 220 if (!rate) 221 rate = runtime->rate; 222 223 return rate; 224 } 225 226 static int rsnd_src_set_convert_rate(struct rsnd_mod *mod, 227 struct rsnd_dai *rdai) 228 { 229 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 230 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 231 struct rsnd_src *src = rsnd_mod_to_src(mod); 232 u32 convert_rate = rsnd_src_convert_rate(src); 233 u32 fsrate = 0; 234 235 if (convert_rate) 236 fsrate = 0x0400000 / convert_rate * runtime->rate; 237 238 /* set/clear soft reset */ 239 rsnd_mod_write(mod, SRC_SWRSR, 0); 240 rsnd_mod_write(mod, SRC_SWRSR, 1); 241 242 /* 243 * Initialize the operation of the SRC internal circuits 244 * see rsnd_src_start() 245 */ 246 rsnd_mod_write(mod, SRC_SRCIR, 1); 247 248 /* Set channel number and output bit length */ 249 rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod)); 250 251 /* Enable the initial value of IFS */ 252 if (fsrate) { 253 rsnd_mod_write(mod, SRC_IFSCR, 1); 254 255 /* Set initial value of IFS */ 256 rsnd_mod_write(mod, SRC_IFSVR, fsrate); 257 } 258 259 /* use DMA transfer */ 260 rsnd_mod_write(mod, SRC_BUSIF_MODE, 1); 261 262 return 0; 263 } 264 265 static int rsnd_src_init(struct rsnd_mod *mod, 266 struct rsnd_dai *rdai) 267 { 268 struct rsnd_src *src = rsnd_mod_to_src(mod); 269 270 clk_prepare_enable(src->clk); 271 272 return 0; 273 } 274 275 static int rsnd_src_quit(struct rsnd_mod *mod, 276 struct rsnd_dai *rdai) 277 { 278 struct rsnd_src *src = rsnd_mod_to_src(mod); 279 280 clk_disable_unprepare(src->clk); 281 282 return 0; 283 } 284 285 static int rsnd_src_start(struct rsnd_mod *mod, 286 struct rsnd_dai *rdai) 287 { 288 struct rsnd_src *src = rsnd_mod_to_src(mod); 289 290 /* 291 * Cancel the initialization and operate the SRC function 292 * see rsnd_src_set_convert_rate() 293 */ 294 rsnd_mod_write(mod, SRC_SRCIR, 0); 295 296 if (rsnd_src_convert_rate(src)) 297 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1); 298 299 return 0; 300 } 301 302 303 static int rsnd_src_stop(struct rsnd_mod *mod, 304 struct rsnd_dai *rdai) 305 { 306 struct rsnd_src *src = rsnd_mod_to_src(mod); 307 308 if (rsnd_src_convert_rate(src)) 309 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0); 310 311 return 0; 312 } 313 314 /* 315 * Gen1 functions 316 */ 317 static int rsnd_src_set_route_gen1(struct rsnd_mod *mod, 318 struct rsnd_dai *rdai) 319 { 320 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 321 struct src_route_config { 322 u32 mask; 323 int shift; 324 } routes[] = { 325 { 0xF, 0, }, /* 0 */ 326 { 0xF, 4, }, /* 1 */ 327 { 0xF, 8, }, /* 2 */ 328 { 0x7, 12, }, /* 3 */ 329 { 0x7, 16, }, /* 4 */ 330 { 0x7, 20, }, /* 5 */ 331 { 0x7, 24, }, /* 6 */ 332 { 0x3, 28, }, /* 7 */ 333 { 0x3, 30, }, /* 8 */ 334 }; 335 u32 mask; 336 u32 val; 337 int id; 338 339 id = rsnd_mod_id(mod); 340 if (id < 0 || id >= ARRAY_SIZE(routes)) 341 return -EIO; 342 343 /* 344 * SRC_ROUTE_SELECT 345 */ 346 val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2; 347 val = val << routes[id].shift; 348 mask = routes[id].mask << routes[id].shift; 349 350 rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val); 351 352 return 0; 353 } 354 355 static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod, 356 struct rsnd_dai *rdai) 357 { 358 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 359 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 360 struct rsnd_src *src = rsnd_mod_to_src(mod); 361 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 362 u32 convert_rate = rsnd_src_convert_rate(src); 363 u32 mask; 364 u32 val; 365 int shift; 366 int id = rsnd_mod_id(mod); 367 int ret; 368 369 /* 370 * SRC_TIMING_SELECT 371 */ 372 shift = (id % 4) * 8; 373 mask = 0x1F << shift; 374 375 /* 376 * ADG is used as source clock if SRC was used, 377 * then, SSI WS is used as destination clock. 378 * SSI WS is used as source clock if SRC is not used 379 * (when playback, source/destination become reverse when capture) 380 */ 381 ret = 0; 382 if (convert_rate) { 383 /* use ADG */ 384 val = 0; 385 ret = rsnd_adg_set_convert_clk_gen1(priv, mod, 386 runtime->rate, 387 convert_rate); 388 } else if (8 == id) { 389 /* use SSI WS, but SRU8 is special */ 390 val = id << shift; 391 } else { 392 /* use SSI WS */ 393 val = (id + 1) << shift; 394 } 395 396 if (ret < 0) 397 return ret; 398 399 switch (id / 4) { 400 case 0: 401 rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val); 402 break; 403 case 1: 404 rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val); 405 break; 406 case 2: 407 rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val); 408 break; 409 } 410 411 return 0; 412 } 413 414 static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod, 415 struct rsnd_dai *rdai) 416 { 417 int ret; 418 419 ret = rsnd_src_set_convert_rate(mod, rdai); 420 if (ret < 0) 421 return ret; 422 423 /* Select SRC mode (fixed value) */ 424 rsnd_mod_write(mod, SRC_SRCCR, 0x00010110); 425 426 /* Set the restriction value of the FS ratio (98%) */ 427 rsnd_mod_write(mod, SRC_MNFSR, 428 rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98); 429 430 /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */ 431 432 return 0; 433 } 434 435 static int rsnd_src_probe_gen1(struct rsnd_mod *mod, 436 struct rsnd_dai *rdai) 437 { 438 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 439 struct device *dev = rsnd_priv_to_dev(priv); 440 441 dev_dbg(dev, "%s (Gen1) is probed\n", rsnd_mod_name(mod)); 442 443 return 0; 444 } 445 446 static int rsnd_src_init_gen1(struct rsnd_mod *mod, 447 struct rsnd_dai *rdai) 448 { 449 int ret; 450 451 ret = rsnd_src_init(mod, rdai); 452 if (ret < 0) 453 return ret; 454 455 ret = rsnd_src_set_route_gen1(mod, rdai); 456 if (ret < 0) 457 return ret; 458 459 ret = rsnd_src_set_convert_rate_gen1(mod, rdai); 460 if (ret < 0) 461 return ret; 462 463 ret = rsnd_src_set_convert_timing_gen1(mod, rdai); 464 if (ret < 0) 465 return ret; 466 467 return 0; 468 } 469 470 static int rsnd_src_start_gen1(struct rsnd_mod *mod, 471 struct rsnd_dai *rdai) 472 { 473 int id = rsnd_mod_id(mod); 474 475 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id)); 476 477 return rsnd_src_start(mod, rdai); 478 } 479 480 static int rsnd_src_stop_gen1(struct rsnd_mod *mod, 481 struct rsnd_dai *rdai) 482 { 483 int id = rsnd_mod_id(mod); 484 485 rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0); 486 487 return rsnd_src_stop(mod, rdai); 488 } 489 490 static struct rsnd_mod_ops rsnd_src_gen1_ops = { 491 .name = SRC_NAME, 492 .probe = rsnd_src_probe_gen1, 493 .init = rsnd_src_init_gen1, 494 .quit = rsnd_src_quit, 495 .start = rsnd_src_start_gen1, 496 .stop = rsnd_src_stop_gen1, 497 }; 498 499 /* 500 * Gen2 functions 501 */ 502 static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod, 503 struct rsnd_dai *rdai) 504 { 505 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 506 struct device *dev = rsnd_priv_to_dev(priv); 507 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 508 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 509 struct rsnd_src *src = rsnd_mod_to_src(mod); 510 uint ratio; 511 int ret; 512 513 /* 6 - 1/6 are very enough ratio for SRC_BSDSR */ 514 if (!rsnd_src_convert_rate(src)) 515 ratio = 0; 516 else if (rsnd_src_convert_rate(src) > runtime->rate) 517 ratio = 100 * rsnd_src_convert_rate(src) / runtime->rate; 518 else 519 ratio = 100 * runtime->rate / rsnd_src_convert_rate(src); 520 521 if (ratio > 600) { 522 dev_err(dev, "FSO/FSI ratio error\n"); 523 return -EINVAL; 524 } 525 526 ret = rsnd_src_set_convert_rate(mod, rdai); 527 if (ret < 0) 528 return ret; 529 530 rsnd_mod_write(mod, SRC_SRCCR, 0x00011110); 531 532 switch (rsnd_mod_id(mod)) { 533 case 5: 534 case 6: 535 case 7: 536 case 8: 537 rsnd_mod_write(mod, SRC_BSDSR, 0x02400000); 538 break; 539 default: 540 rsnd_mod_write(mod, SRC_BSDSR, 0x01800000); 541 break; 542 } 543 544 rsnd_mod_write(mod, SRC_BSISR, 0x00100060); 545 546 return 0; 547 } 548 549 static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod, 550 struct rsnd_dai *rdai) 551 { 552 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 553 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io); 554 struct rsnd_src *src = rsnd_mod_to_src(mod); 555 u32 convert_rate = rsnd_src_convert_rate(src); 556 int ret; 557 558 if (convert_rate) 559 ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io, 560 runtime->rate, 561 convert_rate); 562 else 563 ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io); 564 565 return ret; 566 } 567 568 static int rsnd_src_probe_gen2(struct rsnd_mod *mod, 569 struct rsnd_dai *rdai) 570 { 571 struct rsnd_priv *priv = rsnd_mod_to_priv(mod); 572 struct rsnd_src *src = rsnd_mod_to_src(mod); 573 struct device *dev = rsnd_priv_to_dev(priv); 574 int ret; 575 576 ret = rsnd_dma_init(priv, 577 rsnd_mod_to_dma(mod), 578 rsnd_info_is_playback(priv, src), 579 src->info->dma_id); 580 if (ret < 0) 581 dev_err(dev, "SRC DMA failed\n"); 582 583 dev_dbg(dev, "%s (Gen2) is probed\n", rsnd_mod_name(mod)); 584 585 return ret; 586 } 587 588 static int rsnd_src_remove_gen2(struct rsnd_mod *mod, 589 struct rsnd_dai *rdai) 590 { 591 rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod)); 592 593 return 0; 594 } 595 596 static int rsnd_src_init_gen2(struct rsnd_mod *mod, 597 struct rsnd_dai *rdai) 598 { 599 int ret; 600 601 ret = rsnd_src_init(mod, rdai); 602 if (ret < 0) 603 return ret; 604 605 ret = rsnd_src_set_convert_rate_gen2(mod, rdai); 606 if (ret < 0) 607 return ret; 608 609 ret = rsnd_src_set_convert_timing_gen2(mod, rdai); 610 if (ret < 0) 611 return ret; 612 613 return 0; 614 } 615 616 static int rsnd_src_start_gen2(struct rsnd_mod *mod, 617 struct rsnd_dai *rdai) 618 { 619 struct rsnd_dai_stream *io = rsnd_mod_to_io(mod); 620 struct rsnd_src *src = rsnd_mod_to_src(mod); 621 u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11; 622 623 rsnd_dma_start(rsnd_mod_to_dma(&src->mod)); 624 625 rsnd_mod_write(mod, SRC_CTRL, val); 626 627 return rsnd_src_start(mod, rdai); 628 } 629 630 static int rsnd_src_stop_gen2(struct rsnd_mod *mod, 631 struct rsnd_dai *rdai) 632 { 633 struct rsnd_src *src = rsnd_mod_to_src(mod); 634 635 rsnd_mod_write(mod, SRC_CTRL, 0); 636 637 rsnd_dma_stop(rsnd_mod_to_dma(&src->mod)); 638 639 return rsnd_src_stop(mod, rdai); 640 } 641 642 static struct rsnd_mod_ops rsnd_src_gen2_ops = { 643 .name = SRC_NAME, 644 .probe = rsnd_src_probe_gen2, 645 .remove = rsnd_src_remove_gen2, 646 .init = rsnd_src_init_gen2, 647 .quit = rsnd_src_quit, 648 .start = rsnd_src_start_gen2, 649 .stop = rsnd_src_stop_gen2, 650 }; 651 652 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id) 653 { 654 if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv))) 655 id = 0; 656 657 return &((struct rsnd_src *)(priv->src) + id)->mod; 658 } 659 660 static void rsnd_of_parse_src(struct platform_device *pdev, 661 const struct rsnd_of_data *of_data, 662 struct rsnd_priv *priv) 663 { 664 struct device_node *src_node; 665 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 666 struct rsnd_src_platform_info *src_info; 667 struct device *dev = &pdev->dev; 668 int nr; 669 670 if (!of_data) 671 return; 672 673 src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src"); 674 if (!src_node) 675 return; 676 677 nr = of_get_child_count(src_node); 678 if (!nr) 679 goto rsnd_of_parse_src_end; 680 681 src_info = devm_kzalloc(dev, 682 sizeof(struct rsnd_src_platform_info) * nr, 683 GFP_KERNEL); 684 if (!src_info) { 685 dev_err(dev, "src info allocation error\n"); 686 goto rsnd_of_parse_src_end; 687 } 688 689 info->src_info = src_info; 690 info->src_info_nr = nr; 691 692 rsnd_of_parse_src_end: 693 of_node_put(src_node); 694 } 695 696 int rsnd_src_probe(struct platform_device *pdev, 697 const struct rsnd_of_data *of_data, 698 struct rsnd_priv *priv) 699 { 700 struct rcar_snd_info *info = rsnd_priv_to_info(priv); 701 struct device *dev = rsnd_priv_to_dev(priv); 702 struct rsnd_src *src; 703 struct rsnd_mod_ops *ops; 704 struct clk *clk; 705 char name[RSND_SRC_NAME_SIZE]; 706 int i, nr; 707 708 ops = NULL; 709 if (rsnd_is_gen1(priv)) 710 ops = &rsnd_src_gen1_ops; 711 if (rsnd_is_gen2(priv)) 712 ops = &rsnd_src_gen2_ops; 713 if (!ops) { 714 dev_err(dev, "unknown Generation\n"); 715 return -EIO; 716 } 717 718 rsnd_of_parse_src(pdev, of_data, priv); 719 720 /* 721 * init SRC 722 */ 723 nr = info->src_info_nr; 724 if (!nr) 725 return 0; 726 727 src = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL); 728 if (!src) { 729 dev_err(dev, "SRC allocate failed\n"); 730 return -ENOMEM; 731 } 732 733 priv->src_nr = nr; 734 priv->src = src; 735 736 for_each_rsnd_src(src, priv, i) { 737 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d", 738 SRC_NAME, i); 739 740 clk = devm_clk_get(dev, name); 741 if (IS_ERR(clk)) 742 return PTR_ERR(clk); 743 744 src->info = &info->src_info[i]; 745 src->clk = clk; 746 747 rsnd_mod_init(priv, &src->mod, ops, RSND_MOD_SRC, i); 748 749 dev_dbg(dev, "SRC%d probed\n", i); 750 } 751 752 return 0; 753 } 754