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 /* 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_mod_is_working(mod))
 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 }