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