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, SSI_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         rsnd_mod_write(ssi_mod, SSI_INT_ENABLE,
 219                        rsnd_ssi_is_dma_mode(ssi_mod) ?
 220                        0x0e000000 : 0x0f000000);
 221
 222         return 0;
 223 }
 224
 225 int 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, SSI_INT_ENABLE, 0x00000000);
 234
 235         return 0;
 236 }
 237
 238 static u32 rsnd_src_convert_rate(struct rsnd_dai_stream *io,
 239                                  struct rsnd_src *src)
 240 {
 241         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 242         u32 convert_rate;
 243
 244         if (!runtime)
 245                 return 0;
 246
 247         if (!rsnd_enable_sync_convert(src))
 248                 return src->convert_rate;
 249
 250         convert_rate = src->sync.val;
 251
 252         if (!convert_rate)
 253                 convert_rate = src->convert_rate;
 254
 255         if (!convert_rate)
 256                 convert_rate = runtime->rate;
 257
 258         return convert_rate;
 259 }
 260
 261 unsigned int rsnd_src_get_ssi_rate(struct rsnd_priv *priv,
 262                                    struct rsnd_dai_stream *io,
 263                                    struct snd_pcm_runtime *runtime)
 264 {
 265         struct rsnd_mod *src_mod = rsnd_io_to_mod_src(io);
 266         struct rsnd_src *src;
 267         unsigned int rate = 0;
 268
 269         if (src_mod) {
 270                 src = rsnd_mod_to_src(src_mod);
 271
 272                 /*
 273                  * return convert rate if SRC is used,
 274                  * otherwise, return runtime->rate as usual
 275                  */
 276                 rate = rsnd_src_convert_rate(io, src);
 277         }
 278
 279         if (!rate)
 280                 rate = runtime->rate;
 281
 282         return rate;
 283 }
 284
 285 static int rsnd_src_set_convert_rate(struct rsnd_mod *mod,
 286                                      struct rsnd_dai_stream *io)
 287 {
 288         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 289         struct rsnd_src *src = rsnd_mod_to_src(mod);
 290         u32 convert_rate = rsnd_src_convert_rate(io, src);
 291         u32 fsrate = 0;
 292
 293         if (convert_rate)
 294                 fsrate = 0x0400000 / convert_rate * runtime->rate;
 295
 296         /* set/clear soft reset */
 297         rsnd_mod_write(mod, SRC_SWRSR, 0);
 298         rsnd_mod_write(mod, SRC_SWRSR, 1);
 299
 300         /* Set channel number and output bit length */
 301         rsnd_mod_write(mod, SRC_ADINR, rsnd_get_adinr(mod, io));
 302
 303         /* Enable the initial value of IFS */
 304         if (fsrate) {
 305                 rsnd_mod_write(mod, SRC_IFSCR, 1);
 306
 307                 /* Set initial value of IFS */
 308                 rsnd_mod_write(mod, SRC_IFSVR, fsrate);
 309         }
 310
 311         /* use DMA transfer */
 312         rsnd_mod_write(mod, SRC_BUSIF_MODE, 1);
 313
 314         return 0;
 315 }
 316
 317 static int rsnd_src_hw_params(struct rsnd_mod *mod,
 318                               struct rsnd_dai_stream *io,
 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
 353 static 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
 374 static int rsnd_src_quit(struct rsnd_mod *mod,
 375                          struct rsnd_dai_stream *io,
 376                          struct rsnd_priv *priv)
 377 {
 378         struct rsnd_src *src = rsnd_mod_to_src(mod);
 379         struct device *dev = rsnd_priv_to_dev(priv);
 380
 381         rsnd_mod_hw_stop(mod);
 382
 383         if (src->err)
 384                 dev_warn(dev, "%s[%d] under/over flow err = %d\n",
 385                          rsnd_mod_name(mod), rsnd_mod_id(mod), src->err);
 386
 387         src->convert_rate = 0;
 388
 389         /* reset sync convert_rate */
 390         src->sync.val = 0;
 391
 392         return 0;
 393 }
 394
 395 static int rsnd_src_start(struct rsnd_mod *mod)
 396 {
 397         /*
 398          * Cancel the initialization and operate the SRC function
 399          * see rsnd_src_init()
 400          */
 401         rsnd_mod_write(mod, SRC_SRCIR, 0);
 402
 403         return 0;
 404 }
 405
 406 static int rsnd_src_stop(struct rsnd_mod *mod)
 407 {
 408         /* nothing to do */
 409         return 0;
 410 }
 411
 412 /*
 413  *              Gen1 functions
 414  */
 415 static int rsnd_src_set_route_gen1(struct rsnd_dai_stream *io,
 416                                    struct rsnd_mod *mod)
 417 {
 418         struct src_route_config {
 419                 u32 mask;
 420                 int shift;
 421         } routes[] = {
 422                 { 0xF,  0, }, /* 0 */
 423                 { 0xF,  4, }, /* 1 */
 424                 { 0xF,  8, }, /* 2 */
 425                 { 0x7, 12, }, /* 3 */
 426                 { 0x7, 16, }, /* 4 */
 427                 { 0x7, 20, }, /* 5 */
 428                 { 0x7, 24, }, /* 6 */
 429                 { 0x3, 28, }, /* 7 */
 430                 { 0x3, 30, }, /* 8 */
 431         };
 432         u32 mask;
 433         u32 val;
 434         int id;
 435
 436         id = rsnd_mod_id(mod);
 437         if (id < 0 || id >= ARRAY_SIZE(routes))
 438                 return -EIO;
 439
 440         /*
 441          * SRC_ROUTE_SELECT
 442          */
 443         val = rsnd_io_is_play(io) ? 0x1 : 0x2;
 444         val = val               << routes[id].shift;
 445         mask = routes[id].mask  << routes[id].shift;
 446
 447         rsnd_mod_bset(mod, SRC_ROUTE_SEL, mask, val);
 448
 449         return 0;
 450 }
 451
 452 static int rsnd_src_set_convert_timing_gen1(struct rsnd_dai_stream *io,
 453                                             struct rsnd_mod *mod)
 454 {
 455         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 456         struct rsnd_src *src = rsnd_mod_to_src(mod);
 457         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 458         u32 convert_rate = rsnd_src_convert_rate(io, src);
 459         u32 mask;
 460         u32 val;
 461         int shift;
 462         int id = rsnd_mod_id(mod);
 463         int ret;
 464
 465         /*
 466          * SRC_TIMING_SELECT
 467          */
 468         shift   = (id % 4) * 8;
 469         mask    = 0x1F << shift;
 470
 471         /*
 472          * ADG is used as source clock if SRC was used,
 473          * then, SSI WS is used as destination clock.
 474          * SSI WS is used as source clock if SRC is not used
 475          * (when playback, source/destination become reverse when capture)
 476          */
 477         ret = 0;
 478         if (convert_rate) {
 479                 /* use ADG */
 480                 val = 0;
 481                 ret = rsnd_adg_set_convert_clk_gen1(priv, mod,
 482                                                     runtime->rate,
 483                                                     convert_rate);
 484         } else if (8 == id) {
 485                 /* use SSI WS, but SRU8 is special */
 486                 val = id << shift;
 487         } else {
 488                 /* use SSI WS */
 489                 val = (id + 1) << shift;
 490         }
 491
 492         if (ret < 0)
 493                 return ret;
 494
 495         switch (id / 4) {
 496         case 0:
 497                 rsnd_mod_bset(mod, SRC_TMG_SEL0, mask, val);
 498                 break;
 499         case 1:
 500                 rsnd_mod_bset(mod, SRC_TMG_SEL1, mask, val);
 501                 break;
 502         case 2:
 503                 rsnd_mod_bset(mod, SRC_TMG_SEL2, mask, val);
 504                 break;
 505         }
 506
 507         return 0;
 508 }
 509
 510 static int rsnd_src_set_convert_rate_gen1(struct rsnd_mod *mod,
 511                                           struct rsnd_dai_stream *io)
 512 {
 513         struct rsnd_src *src = rsnd_mod_to_src(mod);
 514         int ret;
 515
 516         ret = rsnd_src_set_convert_rate(mod, io);
 517         if (ret < 0)
 518                 return ret;
 519
 520         /* Select SRC mode (fixed value) */
 521         rsnd_mod_write(mod, SRC_SRCCR, 0x00010110);
 522
 523         /* Set the restriction value of the FS ratio (98%) */
 524         rsnd_mod_write(mod, SRC_MNFSR,
 525                        rsnd_mod_read(mod, SRC_IFSVR) / 100 * 98);
 526
 527         /* Gen1/Gen2 are not compatible */
 528         if (rsnd_src_convert_rate(io, src))
 529                 rsnd_mod_write(mod, SRC_ROUTE_MODE0, 1);
 530
 531         /* no SRC_BFSSR settings, since SRC_SRCCR::BUFMD is 0 */
 532
 533         return 0;
 534 }
 535
 536 static int rsnd_src_init_gen1(struct rsnd_mod *mod,
 537                               struct rsnd_dai_stream *io,
 538                               struct rsnd_priv *priv)
 539 {
 540         int ret;
 541
 542         ret = rsnd_src_init(mod, priv);
 543         if (ret < 0)
 544                 return ret;
 545
 546         ret = rsnd_src_set_route_gen1(io, mod);
 547         if (ret < 0)
 548                 return ret;
 549
 550         ret = rsnd_src_set_convert_rate_gen1(mod, io);
 551         if (ret < 0)
 552                 return ret;
 553
 554         ret = rsnd_src_set_convert_timing_gen1(io, mod);
 555         if (ret < 0)
 556                 return ret;
 557
 558         return 0;
 559 }
 560
 561 static int rsnd_src_start_gen1(struct rsnd_mod *mod,
 562                                struct rsnd_dai_stream *io,
 563                                struct rsnd_priv *priv)
 564 {
 565         int id = rsnd_mod_id(mod);
 566
 567         rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), (1 << id));
 568
 569         return rsnd_src_start(mod);
 570 }
 571
 572 static int rsnd_src_stop_gen1(struct rsnd_mod *mod,
 573                               struct rsnd_dai_stream *io,
 574                               struct rsnd_priv *priv)
 575 {
 576         int id = rsnd_mod_id(mod);
 577
 578         rsnd_mod_bset(mod, SRC_ROUTE_CTRL, (1 << id), 0);
 579
 580         return rsnd_src_stop(mod);
 581 }
 582
 583 static struct rsnd_mod_ops rsnd_src_gen1_ops = {
 584         .name   = SRC_NAME,
 585         .dma_req = rsnd_src_dma_req,
 586         .init   = rsnd_src_init_gen1,
 587         .quit   = rsnd_src_quit,
 588         .start  = rsnd_src_start_gen1,
 589         .stop   = rsnd_src_stop_gen1,
 590         .hw_params = rsnd_src_hw_params,
 591 };
 592
 593 /*
 594  *              Gen2 functions
 595  */
 596 #define rsnd_src_irq_enable_gen2(mod)  rsnd_src_irq_ctrol_gen2(mod, 1)
 597 #define rsnd_src_irq_disable_gen2(mod) rsnd_src_irq_ctrol_gen2(mod, 0)
 598 static void rsnd_src_irq_ctrol_gen2(struct rsnd_mod *mod, int enable)
 599 {
 600         struct rsnd_src *src = rsnd_mod_to_src(mod);
 601         u32 sys_int_val, int_val, sys_int_mask;
 602         int irq = src->info->irq;
 603         int id = rsnd_mod_id(mod);
 604
 605         sys_int_val =
 606         sys_int_mask = OUF_SRC(id);
 607         int_val = 0x3300;
 608
 609         /*
 610          * IRQ is not supported on non-DT
 611          * see
 612          *      rsnd_src_probe_gen2()
 613          */
 614         if ((irq <= 0) || !enable) {
 615                 sys_int_val = 0;
 616                 int_val = 0;
 617         }
 618
 619         /*
 620          * WORKAROUND
 621          *
 622          * ignore over flow error when rsnd_enable_sync_convert()
 623          */
 624         if (rsnd_enable_sync_convert(src))
 625                 sys_int_val = sys_int_val & 0xffff;
 626
 627         rsnd_mod_write(mod, SRC_INT_ENABLE0, int_val);
 628         rsnd_mod_bset(mod, SCU_SYS_INT_EN0, sys_int_mask, sys_int_val);
 629         rsnd_mod_bset(mod, SCU_SYS_INT_EN1, sys_int_mask, sys_int_val);
 630 }
 631
 632 static void rsnd_src_error_clear_gen2(struct rsnd_mod *mod)
 633 {
 634         u32 val = OUF_SRC(rsnd_mod_id(mod));
 635
 636         rsnd_mod_bset(mod, SCU_SYS_STATUS0, val, val);
 637         rsnd_mod_bset(mod, SCU_SYS_STATUS1, val, val);
 638 }
 639
 640 static bool rsnd_src_error_record_gen2(struct rsnd_mod *mod)
 641 {
 642         struct rsnd_src *src = rsnd_mod_to_src(mod);
 643         u32 val0, val1;
 644         bool ret = false;
 645
 646         val0 = val1 = OUF_SRC(rsnd_mod_id(mod));
 647
 648         /*
 649          * WORKAROUND
 650          *
 651          * ignore over flow error when rsnd_enable_sync_convert()
 652          */
 653         if (rsnd_enable_sync_convert(src))
 654                 val0 = val0 & 0xffff;
 655
 656         if ((rsnd_mod_read(mod, SCU_SYS_STATUS0) & val0) ||
 657             (rsnd_mod_read(mod, SCU_SYS_STATUS1) & val1)) {
 658                 struct rsnd_src *src = rsnd_mod_to_src(mod);
 659
 660                 src->err++;
 661                 ret = true;
 662         }
 663
 664         /* clear error static */
 665         rsnd_src_error_clear_gen2(mod);
 666
 667         return ret;
 668 }
 669
 670 static int _rsnd_src_start_gen2(struct rsnd_mod *mod,
 671                                 struct rsnd_dai_stream *io)
 672 {
 673         struct rsnd_src *src = rsnd_mod_to_src(mod);
 674         u32 val;
 675
 676         /*
 677          * WORKAROUND
 678          *
 679          * Enable SRC output if you want to use sync convert together with DVC
 680          */
 681         val = (rsnd_io_to_mod_dvc(io) && !rsnd_enable_sync_convert(src)) ?
 682                 0x01 : 0x11;
 683
 684         rsnd_mod_write(mod, SRC_CTRL, val);
 685
 686         rsnd_src_error_clear_gen2(mod);
 687
 688         rsnd_src_start(mod);
 689
 690         rsnd_src_irq_enable_gen2(mod);
 691
 692         return 0;
 693 }
 694
 695 static int _rsnd_src_stop_gen2(struct rsnd_mod *mod)
 696 {
 697         rsnd_src_irq_disable_gen2(mod);
 698
 699         rsnd_mod_write(mod, SRC_CTRL, 0);
 700
 701         rsnd_src_error_record_gen2(mod);
 702
 703         return rsnd_src_stop(mod);
 704 }
 705
 706 static void __rsnd_src_interrupt_gen2(struct rsnd_mod *mod,
 707                                       struct rsnd_dai_stream *io)
 708 {
 709         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 710
 711         spin_lock(&priv->lock);
 712
 713         /* ignore all cases if not working */
 714         if (!rsnd_io_is_working(io))
 715                 goto rsnd_src_interrupt_gen2_out;
 716
 717         if (rsnd_src_error_record_gen2(mod)) {
 718                 struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 719                 struct rsnd_src *src = rsnd_mod_to_src(mod);
 720                 struct device *dev = rsnd_priv_to_dev(priv);
 721
 722                 dev_dbg(dev, "%s[%d] restart\n",
 723                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 724
 725                 _rsnd_src_stop_gen2(mod);
 726                 if (src->err < 1024)
 727                         _rsnd_src_start_gen2(mod, io);
 728                 else
 729                         dev_warn(dev, "no more SRC restart\n");
 730         }
 731
 732 rsnd_src_interrupt_gen2_out:
 733         spin_unlock(&priv->lock);
 734 }
 735
 736 static irqreturn_t rsnd_src_interrupt_gen2(int irq, void *data)
 737 {
 738         struct rsnd_mod *mod = data;
 739
 740         rsnd_mod_interrupt(mod, __rsnd_src_interrupt_gen2);
 741
 742         return IRQ_HANDLED;
 743 }
 744
 745 static int rsnd_src_set_convert_rate_gen2(struct rsnd_mod *mod,
 746                                           struct rsnd_dai_stream *io)
 747 {
 748         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 749         struct device *dev = rsnd_priv_to_dev(priv);
 750         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 751         struct rsnd_src *src = rsnd_mod_to_src(mod);
 752         u32 convert_rate = rsnd_src_convert_rate(io, src);
 753         u32 cr, route;
 754         uint ratio;
 755         int ret;
 756
 757         /* 6 - 1/6 are very enough ratio for SRC_BSDSR */
 758         if (!convert_rate)
 759                 ratio = 0;
 760         else if (convert_rate > runtime->rate)
 761                 ratio = 100 * convert_rate / runtime->rate;
 762         else
 763                 ratio = 100 * runtime->rate / convert_rate;
 764
 765         if (ratio > 600) {
 766                 dev_err(dev, "FSO/FSI ratio error\n");
 767                 return -EINVAL;
 768         }
 769
 770         ret = rsnd_src_set_convert_rate(mod, io);
 771         if (ret < 0)
 772                 return ret;
 773
 774         cr      = 0x00011110;
 775         route   = 0x0;
 776         if (convert_rate) {
 777                 route   = 0x1;
 778
 779                 if (rsnd_enable_sync_convert(src)) {
 780                         cr |= 0x1;
 781                         route |= rsnd_io_is_play(io) ?
 782                                 (0x1 << 24) : (0x1 << 25);
 783                 }
 784         }
 785
 786         rsnd_mod_write(mod, SRC_SRCCR, cr);
 787         rsnd_mod_write(mod, SRC_ROUTE_MODE0, route);
 788
 789         switch (rsnd_mod_id(mod)) {
 790         case 5:
 791         case 6:
 792         case 7:
 793         case 8:
 794                 rsnd_mod_write(mod, SRC_BSDSR, 0x02400000);
 795                 break;
 796         default:
 797                 rsnd_mod_write(mod, SRC_BSDSR, 0x01800000);
 798                 break;
 799         }
 800
 801         rsnd_mod_write(mod, SRC_BSISR, 0x00100060);
 802
 803         return 0;
 804 }
 805
 806 static int rsnd_src_set_convert_timing_gen2(struct rsnd_dai_stream *io,
 807                                             struct rsnd_mod *mod)
 808 {
 809         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 810         struct rsnd_src *src = rsnd_mod_to_src(mod);
 811         u32 convert_rate = rsnd_src_convert_rate(io, src);
 812         int ret;
 813
 814         if (convert_rate)
 815                 ret = rsnd_adg_set_convert_clk_gen2(mod, io,
 816                                                     runtime->rate,
 817                                                     convert_rate);
 818         else
 819                 ret = rsnd_adg_set_convert_timing_gen2(mod, io);
 820
 821         return ret;
 822 }
 823
 824 static int rsnd_src_probe_gen2(struct rsnd_mod *mod,
 825                                struct rsnd_dai_stream *io,
 826                                struct rsnd_priv *priv)
 827 {
 828         struct rsnd_src *src = rsnd_mod_to_src(mod);
 829         struct device *dev = rsnd_priv_to_dev(priv);
 830         int irq = src->info->irq;
 831         int ret;
 832
 833         if (irq > 0) {
 834                 /*
 835                  * IRQ is not supported on non-DT
 836                  * see
 837                  *      rsnd_src_irq_enable_gen2()
 838                  */
 839                 ret = devm_request_irq(dev, irq,
 840                                        rsnd_src_interrupt_gen2,
 841                                        IRQF_SHARED,
 842                                        dev_name(dev), mod);
 843                 if (ret)
 844                         return ret;
 845         }
 846
 847         ret = rsnd_dma_init(io,
 848                             rsnd_mod_to_dma(mod),
 849                             src->info->dma_id);
 850
 851         return ret;
 852 }
 853
 854 static int rsnd_src_remove_gen2(struct rsnd_mod *mod,
 855                                 struct rsnd_dai_stream *io,
 856                                 struct rsnd_priv *priv)
 857 {
 858         rsnd_dma_quit(io, rsnd_mod_to_dma(mod));
 859
 860         return 0;
 861 }
 862
 863 static int rsnd_src_init_gen2(struct rsnd_mod *mod,
 864                               struct rsnd_dai_stream *io,
 865                               struct rsnd_priv *priv)
 866 {
 867         int ret;
 868
 869         ret = rsnd_src_init(mod, priv);
 870         if (ret < 0)
 871                 return ret;
 872
 873         ret = rsnd_src_set_convert_rate_gen2(mod, io);
 874         if (ret < 0)
 875                 return ret;
 876
 877         ret = rsnd_src_set_convert_timing_gen2(io, mod);
 878         if (ret < 0)
 879                 return ret;
 880
 881         return 0;
 882 }
 883
 884 static int rsnd_src_start_gen2(struct rsnd_mod *mod,
 885                                struct rsnd_dai_stream *io,
 886                                struct rsnd_priv *priv)
 887 {
 888         rsnd_dma_start(io, rsnd_mod_to_dma(mod));
 889
 890         return _rsnd_src_start_gen2(mod, io);
 891 }
 892
 893 static int rsnd_src_stop_gen2(struct rsnd_mod *mod,
 894                               struct rsnd_dai_stream *io,
 895                               struct rsnd_priv *priv)
 896 {
 897         int ret;
 898
 899         ret = _rsnd_src_stop_gen2(mod);
 900
 901         rsnd_dma_stop(io, rsnd_mod_to_dma(mod));
 902
 903         return ret;
 904 }
 905
 906 static void rsnd_src_reconvert_update(struct rsnd_dai_stream *io,
 907                                       struct rsnd_mod *mod)
 908 {
 909         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 910         struct rsnd_src *src = rsnd_mod_to_src(mod);
 911         u32 convert_rate = rsnd_src_convert_rate(io, src);
 912         u32 fsrate;
 913
 914         if (!runtime)
 915                 return;
 916
 917         if (!convert_rate)
 918                 convert_rate = runtime->rate;
 919
 920         fsrate = 0x0400000 / convert_rate * runtime->rate;
 921
 922         /* update IFS */
 923         rsnd_mod_write(mod, SRC_IFSVR, fsrate);
 924 }
 925
 926 static int rsnd_src_pcm_new(struct rsnd_mod *mod,
 927                             struct rsnd_dai_stream *io,
 928                             struct snd_soc_pcm_runtime *rtd)
 929 {
 930         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 931         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 932         struct rsnd_src *src = rsnd_mod_to_src(mod);
 933         int ret;
 934
 935         /*
 936          * enable SRC sync convert if possible
 937          */
 938
 939         /*
 940          * Gen1 is not supported
 941          */
 942         if (rsnd_is_gen1(priv))
 943                 return 0;
 944
 945         /*
 946          * SRC sync convert needs clock master
 947          */
 948         if (!rsnd_rdai_is_clk_master(rdai))
 949                 return 0;
 950
 951         /*
 952          * enable sync convert
 953          */
 954         ret = rsnd_kctrl_new_s(mod, io, rtd,
 955                                rsnd_io_is_play(io) ?
 956                                "SRC Out Rate Switch" :
 957                                "SRC In Rate Switch",
 958                                rsnd_src_reconvert_update,
 959                                &src->sen, 1);
 960         if (ret < 0)
 961                 return ret;
 962
 963         ret = rsnd_kctrl_new_s(mod, io, rtd,
 964                                rsnd_io_is_play(io) ?
 965                                "SRC Out Rate" :
 966                                "SRC In Rate",
 967                                rsnd_src_reconvert_update,
 968                                &src->sync, 192000);
 969
 970         return ret;
 971 }
 972
 973 static struct rsnd_mod_ops rsnd_src_gen2_ops = {
 974         .name   = SRC_NAME,
 975         .dma_req = rsnd_src_dma_req,
 976         .probe  = rsnd_src_probe_gen2,
 977         .remove = rsnd_src_remove_gen2,
 978         .init   = rsnd_src_init_gen2,
 979         .quit   = rsnd_src_quit,
 980         .start  = rsnd_src_start_gen2,
 981         .stop   = rsnd_src_stop_gen2,
 982         .hw_params = rsnd_src_hw_params,
 983         .pcm_new = rsnd_src_pcm_new,
 984 };
 985
 986 struct rsnd_mod *rsnd_src_mod_get(struct rsnd_priv *priv, int id)
 987 {
 988         if (WARN_ON(id < 0 || id >= rsnd_src_nr(priv)))
 989                 id = 0;
 990
 991         return &((struct rsnd_src *)(priv->src) + id)->mod;
 992 }
 993
 994 static void rsnd_of_parse_src(struct platform_device *pdev,
 995                               const struct rsnd_of_data *of_data,
 996                               struct rsnd_priv *priv)
 997 {
 998         struct device_node *src_node;
 999         struct device_node *np;
1000         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
1001         struct rsnd_src_platform_info *src_info;
1002         struct device *dev = &pdev->dev;
1003         int nr, i;
1004
1005         if (!of_data)
1006                 return;
1007
1008         src_node = rsnd_src_of_node(priv);
1009         if (!src_node)
1010                 return;
1011
1012         nr = of_get_child_count(src_node);
1013         if (!nr)
1014                 goto rsnd_of_parse_src_end;
1015
1016         src_info = devm_kzalloc(dev,
1017                                 sizeof(struct rsnd_src_platform_info) * nr,
1018                                 GFP_KERNEL);
1019         if (!src_info) {
1020                 dev_err(dev, "src info allocation error\n");
1021                 goto rsnd_of_parse_src_end;
1022         }
1023
1024         info->src_info          = src_info;
1025         info->src_info_nr       = nr;
1026
1027         i = 0;
1028         for_each_child_of_node(src_node, np) {
1029                 src_info[i].irq = irq_of_parse_and_map(np, 0);
1030
1031                 i++;
1032         }
1033
1034 rsnd_of_parse_src_end:
1035         of_node_put(src_node);
1036 }
1037
1038 int rsnd_src_probe(struct platform_device *pdev,
1039                    const struct rsnd_of_data *of_data,
1040                    struct rsnd_priv *priv)
1041 {
1042         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
1043         struct device *dev = rsnd_priv_to_dev(priv);
1044         struct rsnd_src *src;
1045         struct rsnd_mod_ops *ops;
1046         struct clk *clk;
1047         char name[RSND_SRC_NAME_SIZE];
1048         int i, nr, ret;
1049
1050         ops = NULL;
1051         if (rsnd_is_gen1(priv))
1052                 ops = &rsnd_src_gen1_ops;
1053         if (rsnd_is_gen2(priv))
1054                 ops = &rsnd_src_gen2_ops;
1055         if (!ops) {
1056                 dev_err(dev, "unknown Generation\n");
1057                 return -EIO;
1058         }
1059
1060         rsnd_of_parse_src(pdev, of_data, priv);
1061
1062         /*
1063          * init SRC
1064          */
1065         nr      = info->src_info_nr;
1066         if (!nr)
1067                 return 0;
1068
1069         src     = devm_kzalloc(dev, sizeof(*src) * nr, GFP_KERNEL);
1070         if (!src)
1071                 return -ENOMEM;
1072
1073         priv->src_nr    = nr;
1074         priv->src       = src;
1075
1076         for_each_rsnd_src(src, priv, i) {
1077                 snprintf(name, RSND_SRC_NAME_SIZE, "%s.%d",
1078                          SRC_NAME, i);
1079
1080                 clk = devm_clk_get(dev, name);
1081                 if (IS_ERR(clk))
1082                         return PTR_ERR(clk);
1083
1084                 src->info = &info->src_info[i];
1085
1086                 ret = rsnd_mod_init(priv, &src->mod, ops, clk, RSND_MOD_SRC, i);
1087                 if (ret)
1088                         return ret;
1089         }
1090
1091         return 0;
1092 }
1093
1094 void rsnd_src_remove(struct platform_device *pdev,
1095                      struct rsnd_priv *priv)
1096 {
1097         struct rsnd_src *src;
1098         int i;
1099
1100         for_each_rsnd_src(src, priv, i) {
1101                 rsnd_mod_quit(&src->mod);
1102         }
1103 }