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