sound/soc/sh/rcar/src.c

   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 {
 180         /*
 181          * DMA settings for SSIU
 182          */
 183         rsnd_mod_write(ssi_mod, SSI_CTRL, 0);
 184
 185         return 0;
 186 }
 187
 188 int rsnd_src_ssi_irq_enable(struct rsnd_mod *ssi_mod,
 189                             struct rsnd_dai *rdai)
 190 {
 191         struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
 192
 193         if (rsnd_is_gen1(priv))
 194                 return 0;
 195
 196         /* enable SSI interrupt if Gen2 */
 197         if (rsnd_ssi_is_dma_mode(ssi_mod))
 198                 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0e000000);
 199         else
 200                 rsnd_mod_write(ssi_mod, INT_ENABLE, 0x0f000000);
 201
 202         return 0;
 203 }
 204
 205 int rsnd_src_ssi_irq_disable(struct rsnd_mod *ssi_mod,
 206                             struct rsnd_dai *rdai)
 207 {
 208         struct rsnd_priv *priv = rsnd_mod_to_priv(ssi_mod);
 209
 210         if (rsnd_is_gen1(priv))
 211                 return 0;
 212
 213         /* disable SSI interrupt if Gen2 */
 214         rsnd_mod_write(ssi_mod, INT_ENABLE, 0x00000000);
 215
 216         return 0;
 217 }
 218
 219 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
 220                                    struct rsnd_dai_stream *io,
 221                                    struct snd_pcm_runtime *runtime)
 222 {
 223         struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
 224         struct rsnd_src *src;
 225         unsigned int rate = 0;
 226
 227         if (src_mod) {
 228                 src = rsnd_mod_to_src(src_mod);
 229
 230                 /*
 231                  * return convert rate if SRC is used,
 232                  * otherwise, return runtime->rate as usual
 233                  */
 234                 rate = rsnd_src_convert_rate(src);
 235         }
 236
 237         if (!rate)
 238                 rate = runtime->rate;
 239
 240         return rate;
 241 }
 242
 243 static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
 244                                      struct rsnd_dai *rdai)
 245 {
 246         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 247         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 248         struct rsnd_src *src = rsnd_mod_to_src(mod);
 249         u32 convert_rate = rsnd_src_convert_rate(src);
 250         u32 fsrate = 0;
 251
 252         if (convert_rate)
 253                 fsrate = 0x0400000 / convert_rate * runtime->rate;
 254
 255         /* set/clear soft reset */
 256         rsnd_mod_write(mod, SRC_SWRSR, 0);
 257         rsnd_mod_write(mod, SRC_SWRSR, 1);
 258
 259         /*
 260          * Initialize the operation of the SRC internal circuits
 261          * see rsnd_src_start()
 262          */
 263         rsnd_mod_write(mod, SRC_SRCIR, 1);
 264
 265         /* Set channel number and output bit length */
 266         rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod));
 267
 268         /* Enable the initial value of IFS */
 269         if (fsrate) {
 270                 rsnd_mod_write(mod, SRC_IFSCR, 1);
 271
 272                 /* Set initial value of IFS */
 273                 rsnd_mod_write(mod, SRC_IFSVR, fsrate);
 274         }
 275
 276         /* use DMA transfer */
 277         rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);
 278
 279         return 0;
 280 }
 281
 282 static int rsnd_src_init(struct rsnd_mod *mod,
 283                          struct rsnd_dai *rdai)
 284 {
 285         struct rsnd_src *src = rsnd_mod_to_src(mod);
 286
 287         clk_prepare_enable(src->clk);
 288
 289         return 0;
 290 }
 291
 292 static int rsnd_src_quit(struct rsnd_mod *mod,
 293                          struct rsnd_dai *rdai)
 294 {
 295         struct rsnd_src *src = rsnd_mod_to_src(mod);
 296
 297         clk_disable_unprepare(src->clk);
 298
 299         return 0;
 300 }
 301
 302 static int rsnd_src_start(struct rsnd_mod *mod,
 303                           struct rsnd_dai *rdai)
 304 {
 305         struct rsnd_src *src = rsnd_mod_to_src(mod);
 306
 307         /*
 308          * Cancel the initialization and operate the SRC function
 309          * see rsnd_src_set_convert_rate()
 310          */
 311         rsnd_mod_write(mod, SRC_SRCIR, 0);
 312
 313         if (rsnd_src_convert_rate(src))
 314                 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
 315
 316         return 0;
 317 }
 318
 319
 320 static int rsnd_src_stop(struct rsnd_mod *mod,
 321                          struct rsnd_dai *rdai)
 322 {
 323         struct rsnd_src *src = rsnd_mod_to_src(mod);
 324
 325         if (rsnd_src_convert_rate(src))
 326                 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 0);
 327
 328         return 0;
 329 }
 330
 331 /*
 332  *              Gen1 functions
 333  */
 334 static int rsnd_src_set_route_gen1(struct rsnd_mod *mod,
 335                                    struct rsnd_dai *rdai)
 336 {
 337         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 338         struct src_route_config {
 339                 u32 mask;
 340                 int shift;
 341         } routes[] = {
 342                 { 0xF,  0, }, /* 0 */
 343                 { 0xF,  4, }, /* 1 */
 344                 { 0xF,  8, }, /* 2 */
 345                 { 0x7, 12, }, /* 3 */
 346                 { 0x7, 16, }, /* 4 */
 347                 { 0x7, 20, }, /* 5 */
 348                 { 0x7, 24, }, /* 6 */
 349                 { 0x3, 28, }, /* 7 */
 350                 { 0x3, 30, }, /* 8 */
 351         };
 352         u32 mask;
 353         u32 val;
 354         int id;
 355
 356         id = rsnd_mod_id(mod);
 357         if (id < 0 || id >= ARRAY_SIZE(routes))
 358                 return -EIO;
 359
 360         /*
 361          * SRC_ROUTE_SELECT
 362          */
 363         val = rsnd_dai_is_play(rdai, io) ? 0x1 : 0x2;
 364         val = val               << routes[id].shift;
 365         mask = routes[id].mask  << routes[id].shift;
 366
 367         rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);
 368
 369         return 0;
 370 }
 371
 372 static int rsnd_src_set_convert_timing_gen1(struct rsnd_mod *mod,
 373                                             struct rsnd_dai *rdai)
 374 {
 375         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 376         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 377         struct rsnd_src *src = rsnd_mod_to_src(mod);
 378         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 379         u32 convert_rate = rsnd_src_convert_rate(src);
 380         u32 mask;
 381         u32 val;
 382         int shift;
 383         int id = rsnd_mod_id(mod);
 384         int ret;
 385
 386         /*
 387          * SRC_TIMING_SELECT
 388          */
 389         shift   = (id % 4) * 8;
 390         mask    = 0x1F << shift;
 391
 392         /*
 393          * ADG is used as source clock if SRC was used,
 394          * then, SSI WS is used as destination clock.
 395          * SSI WS is used as source clock if SRC is not used
 396          * (when playback, source/destination become reverse when capture)
 397          */
 398         ret = 0;
 399         if (convert_rate) {
 400                 /* use ADG */
 401                 val = 0;
 402                 ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
 403                                                     runtime->rate,
 404                                                     convert_rate);
 405         } else if (8 == id) {
 406                 /* use SSI WS, but SRU8 is special */
 407                 val = id << shift;
 408         } else {
 409                 /* use SSI WS */
 410                 val = (id + 1) << shift;
 411         }
 412
 413         if (ret < 0)
 414                 return ret;
 415
 416         switch (id / 4) {
 417         case 0:
 418                 rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
 419                 break;
 420         case 1:
 421                 rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
 422                 break;
 423         case 2:
 424                 rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
 425                 break;
 426         }
 427
 428         return 0;
 429 }
 430
 431 static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
 432                                           struct rsnd_dai *rdai)
 433 {
 434         int ret;
 435
 436         ret = rsnd_src_set_convert_rate(mod, rdai);
 437         if (ret < 0)
 438                 return ret;
 439
 440         /* Select SRC mode (fixed value) */
 441         rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
 442
 443         /* Set the restriction value of the FS ratio (98%) */
 444         rsnd_mod_write(mod, SRC_MNFSR,
 445                        rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
 446
 447         /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
 448
 449         return 0;
 450 }
 451
 452 static int rsnd_src_probe_gen1(struct rsnd_mod *mod,
 453                               struct rsnd_dai *rdai)
 454 {
 455         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 456         struct device *dev = rsnd_priv_to_dev(priv);
 457
 458         dev_dbg(dev, "%s[%d] (Gen1) is probed\n",
 459                 rsnd_mod_name(mod), rsnd_mod_id(mod));
 460
 461         return 0;
 462 }
 463
 464 static int rsnd_src_init_gen1(struct rsnd_mod *mod,
 465                               struct rsnd_dai *rdai)
 466 {
 467         int ret;
 468
 469         ret = rsnd_src_init(mod, rdai);
 470         if (ret < 0)
 471                 return ret;
 472
 473         ret = rsnd_src_set_route_gen1(mod, rdai);
 474         if (ret < 0)
 475                 return ret;
 476
 477         ret = rsnd_src_set_convert_rate_gen1(mod, rdai);
 478         if (ret < 0)
 479                 return ret;
 480
 481         ret = rsnd_src_set_convert_timing_gen1(mod, rdai);
 482         if (ret < 0)
 483                 return ret;
 484
 485         return 0;
 486 }
 487
 488 static int rsnd_src_start_gen1(struct rsnd_mod *mod,
 489                                struct rsnd_dai *rdai)
 490 {
 491         int id = rsnd_mod_id(mod);
 492
 493         rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
 494
 495         return rsnd_src_start(mod, rdai);
 496 }
 497
 498 static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
 499                               struct rsnd_dai *rdai)
 500 {
 501         int id = rsnd_mod_id(mod);
 502
 503         rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
 504
 505         return rsnd_src_stop(mod, rdai);
 506 }
 507
 508 static struct rsnd_mod_ops rsnd_src_gen1_ops = {
 509         .name   = SRC_NAME,
 510         .probe  = rsnd_src_probe_gen1,
 511         .init   = rsnd_src_init_gen1,
 512         .quit   = rsnd_src_quit,
 513         .start  = rsnd_src_start_gen1,
 514         .stop   = rsnd_src_stop_gen1,
 515 };
 516
 517 /*
 518  *              Gen2 functions
 519  */
 520 static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
 521                                           struct rsnd_dai *rdai)
 522 {
 523         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 524         struct device *dev = rsnd_priv_to_dev(priv);
 525         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 526         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 527         struct rsnd_src *src = rsnd_mod_to_src(mod);
 528         uint ratio;
 529         int ret;
 530
 531         /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
 532         if (!rsnd_src_convert_rate(src))
 533                 ratio = 0;
 534         else if (rsnd_src_convert_rate(src) > runtime->rate)
 535                 ratio = 100 * rsnd_src_convert_rate(src) / runtime->rate;
 536         else
 537                 ratio = 100 * runtime->rate / rsnd_src_convert_rate(src);
 538
 539         if (ratio > 600) {
 540                 dev_err(dev, "FSO/FSI ratio error\n");
 541                 return -EINVAL;
 542         }
 543
 544         ret = rsnd_src_set_convert_rate(mod, rdai);
 545         if (ret < 0)
 546                 return ret;
 547
 548         rsnd_mod_write(mod, SRC_SRCCR, 0x00011110);
 549
 550         switch (rsnd_mod_id(mod)) {
 551         case 5:
 552         case 6:
 553         case 7:
 554         case 8:
 555                 rsnd_mod_write(mod, SRC_BSDSR, 0x02400000);
 556                 break;
 557         default:
 558                 rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
 559                 break;
 560         }
 561
 562         rsnd_mod_write(mod, SRC_BSISR, 0x00100060);
 563
 564         return 0;
 565 }
 566
 567 static int rsnd_src_set_convert_timing_gen2(struct rsnd_mod *mod,
 568                                             struct rsnd_dai *rdai)
 569 {
 570         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 571         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 572         struct rsnd_src *src = rsnd_mod_to_src(mod);
 573         u32 convert_rate = rsnd_src_convert_rate(src);
 574         int ret;
 575
 576         if (convert_rate)
 577                 ret = rsnd_adg_set_convert_clk_gen2(mod, rdai, io,
 578                                                     runtime->rate,
 579                                                     convert_rate);
 580         else
 581                 ret = rsnd_adg_set_convert_timing_gen2(mod, rdai, io);
 582
 583         return ret;
 584 }
 585
 586 static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
 587                                struct rsnd_dai *rdai)
 588 {
 589         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 590         struct rsnd_src *src = rsnd_mod_to_src(mod);
 591         struct device *dev = rsnd_priv_to_dev(priv);
 592         int ret;
 593
 594         ret = rsnd_dma_init(priv,
 595                             rsnd_mod_to_dma(mod),
 596                             rsnd_info_is_playback(priv, src),
 597                             src->info->dma_id);
 598         if (ret < 0)
 599                 dev_err(dev, "%s[%d] (Gen2) failed\n",
 600                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 601         else
 602                 dev_dbg(dev, "%s[%d] (Gen2) is probed\n",
 603                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 604
 605         return ret;
 606 }
 607
 608 static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
 609                                 struct rsnd_dai *rdai)
 610 {
 611         rsnd_dma_quit(rsnd_mod_to_priv(mod), rsnd_mod_to_dma(mod));
 612
 613         return 0;
 614 }
 615
 616 static int rsnd_src_init_gen2(struct rsnd_mod *mod,
 617                               struct rsnd_dai *rdai)
 618 {
 619         int ret;
 620
 621         ret = rsnd_src_init(mod, rdai);
 622         if (ret < 0)
 623                 return ret;
 624
 625         ret = rsnd_src_set_convert_rate_gen2(mod, rdai);
 626         if (ret < 0)
 627                 return ret;
 628
 629         ret = rsnd_src_set_convert_timing_gen2(mod, rdai);
 630         if (ret < 0)
 631                 return ret;
 632
 633         return 0;
 634 }
 635
 636 static int rsnd_src_start_gen2(struct rsnd_mod *mod,
 637                                struct rsnd_dai *rdai)
 638 {
 639         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 640         struct rsnd_src *src = rsnd_mod_to_src(mod);
 641         u32 val = rsnd_io_to_mod_dvc(io) ? 0x01 : 0x11;
 642
 643         rsnd_dma_start(rsnd_mod_to_dma(&src->mod));
 644
 645         rsnd_mod_write(mod, SRC_CTRL, val);
 646
 647         return rsnd_src_start(mod, rdai);
 648 }
 649
 650 static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
 651                               struct rsnd_dai *rdai)
 652 {
 653         struct rsnd_src *src = rsnd_mod_to_src(mod);
 654
 655         rsnd_mod_write(mod, SRC_CTRL, 0);
 656
 657         rsnd_dma_stop(rsnd_mod_to_dma(&src->mod));
 658
 659         return rsnd_src_stop(mod, rdai);
 660 }
 661
 662 static struct rsnd_mod_ops rsnd_src_gen2_ops = {
 663         .name   = SRC_NAME,
 664         .probe  = rsnd_src_probe_gen2,
 665         .remove = rsnd_src_remove_gen2,
 666         .init   = rsnd_src_init_gen2,
 667         .quit   = rsnd_src_quit,
 668         .start  = rsnd_src_start_gen2,
 669         .stop   = rsnd_src_stop_gen2,
 670 };
 671
 672 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
 673 {
 674         if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
 675                 id = 0;
 676
 677         return &((struct rsnd_src *)(priv->src) + id)->mod;
 678 }
 679
 680 static void rsnd_of_parse_src(struct platform_device *pdev,
 681                               const struct rsnd_of_data *of_data,
 682                               struct rsnd_priv *priv)
 683 {
 684         struct device_node *src_node;
 685         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
 686         struct rsnd_src_platform_info *src_info;
 687         struct device *dev = &pdev->dev;
 688         int nr;
 689
 690         if (!of_data)
 691                 return;
 692
 693         src_node = of_get_child_by_name(dev->of_node, "rcar_sound,src");
 694         if (!src_node)
 695                 return;
 696
 697         nr = of_get_child_count(src_node);
 698         if (!nr)
 699                 goto rsnd_of_parse_src_end;
 700
 701         src_info = devm_kzalloc(dev,
 702                                 sizeof(struct rsnd_src_platform_info) * nr,
 703                                 GFP_KERNEL);
 704         if (!src_info) {
 705                 dev_err(dev, "src info allocation error\n");
 706                 goto rsnd_of_parse_src_end;
 707         }
 708
 709         info->src_info          = src_info;
 710         info->src_info_nr       = nr;
 711
 712 rsnd_of_parse_src_end:
 713         of_node_put(src_node);
 714 }
 715
 716 int rsnd_src_probe(struct platform_device *pdev,
 717                    const struct rsnd_of_data *of_data,
 718                    struct rsnd_priv *priv)
 719 {
 720         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
 721         struct device *dev = rsnd_priv_to_dev(priv);
 722         struct rsnd_src *src;
 723         struct rsnd_mod_ops *ops;
 724         struct clk *clk;
 725         char name[RSND_SRC_NAME_SIZE];
 726         int i, nr;
 727
 728         ops = NULL;
 729         if (rsnd_is_gen1(priv))
 730                 ops = &rsnd_src_gen1_ops;
 731         if (rsnd_is_gen2(priv))
 732                 ops = &rsnd_src_gen2_ops;
 733         if (!ops) {
 734                 dev_err(dev, "unknown Generation\n");
 735                 return -EIO;
 736         }
 737
 738         rsnd_of_parse_src(pdev, of_data, priv);
 739
 740         /*
 741          * init SRC
 742          */
 743         nr      = info->src_info_nr;
 744         if (!nr)
 745                 return 0;
 746
 747         src     = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
 748         if (!src) {
 749                 dev_err(dev, "SRC allocate failed\n");
 750                 return -ENOMEM;
 751         }
 752
 753         priv->src_nr    = nr;
 754         priv->src       = src;
 755
 756         for_each_rsnd_src(src, priv, i) {
 757                 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
 758                          SRC_NAME, i);
 759
 760                 clk = devm_clk_get(dev, name);
 761                 if (IS_ERR(clk))
 762                         return PTR_ERR(clk);
 763
 764                 src->info = &info->src_info[i];
 765                 src->clk = clk;
 766
 767                 rsnd_mod_init(priv, &src->mod, ops, RSND_MOD_SRC, i);
 768
 769                 dev_dbg(dev, "SRC%d probed\n", i);
 770         }
 771
 772         return 0;
 773 }