sound/soc/sh/rcar/ssi.c

   1 /*
   2  * Renesas R-Car SSIU/SSI support
   3  *
   4  * Copyright (C) 2013 Renesas Solutions Corp.
   5  * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>
   6  *
   7  * Based on fsi.c
   8  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  */
  14 #include <linux/delay.h>
  15 #include "rsnd.h"
  16 #define RSND_SSI_NAME_SIZE 16
  17
  18 /*
  19  * SSICR
  20  */
  21 #define FORCE           (1 << 31)       /* Fixed */
  22 #define DMEN            (1 << 28)       /* DMA Enable */
  23 #define UIEN            (1 << 27)       /* Underflow Interrupt Enable */
  24 #define OIEN            (1 << 26)       /* Overflow Interrupt Enable */
  25 #define IIEN            (1 << 25)       /* Idle Mode Interrupt Enable */
  26 #define DIEN            (1 << 24)       /* Data Interrupt Enable */
  27
  28 #define DWL_8           (0 << 19)       /* Data Word Length */
  29 #define DWL_16          (1 << 19)       /* Data Word Length */
  30 #define DWL_18          (2 << 19)       /* Data Word Length */
  31 #define DWL_20          (3 << 19)       /* Data Word Length */
  32 #define DWL_22          (4 << 19)       /* Data Word Length */
  33 #define DWL_24          (5 << 19)       /* Data Word Length */
  34 #define DWL_32          (6 << 19)       /* Data Word Length */
  35
  36 #define SWL_32          (3 << 16)       /* R/W System Word Length */
  37 #define SCKD            (1 << 15)       /* Serial Bit Clock Direction */
  38 #define SWSD            (1 << 14)       /* Serial WS Direction */
  39 #define SCKP            (1 << 13)       /* Serial Bit Clock Polarity */
  40 #define SWSP            (1 << 12)       /* Serial WS Polarity */
  41 #define SDTA            (1 << 10)       /* Serial Data Alignment */
  42 #define DEL             (1 <<  8)       /* Serial Data Delay */
  43 #define CKDV(v)         (v <<  4)       /* Serial Clock Division Ratio */
  44 #define TRMD            (1 <<  1)       /* Transmit/Receive Mode Select */
  45 #define EN              (1 <<  0)       /* SSI Module Enable */
  46
  47 /*
  48  * SSISR
  49  */
  50 #define UIRQ            (1 << 27)       /* Underflow Error Interrupt Status */
  51 #define OIRQ            (1 << 26)       /* Overflow Error Interrupt Status */
  52 #define IIRQ            (1 << 25)       /* Idle Mode Interrupt Status */
  53 #define DIRQ            (1 << 24)       /* Data Interrupt Status Flag */
  54
  55 /*
  56  * SSIWSR
  57  */
  58 #define CONT            (1 << 8)        /* WS Continue Function */
  59
  60 #define SSI_NAME "ssi"
  61
  62 struct rsnd_ssi {
  63         struct rsnd_ssi_platform_info *info; /* rcar_snd.h */
  64         struct rsnd_ssi *parent;
  65         struct rsnd_mod mod;
  66
  67         u32 cr_own;
  68         u32 cr_clk;
  69         int chan;
  70         int err;
  71         unsigned int usrcnt;
  72 };
  73
  74 #define for_each_rsnd_ssi(pos, priv, i)                                 \
  75         for (i = 0;                                                     \
  76              (i < rsnd_ssi_nr(priv)) &&                                 \
  77                 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i));         \
  78              i++)
  79
  80 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr)
  81 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
  82 #define rsnd_dma_to_ssi(dma)  rsnd_mod_to_ssi(rsnd_dma_to_mod(dma))
  83 #define rsnd_ssi_pio_available(ssi) ((ssi)->info->irq > 0)
  84 #define rsnd_ssi_parent(ssi) ((ssi)->parent)
  85 #define rsnd_ssi_mode_flags(p) ((p)->info->flags)
  86 #define rsnd_ssi_dai_id(ssi) ((ssi)->info->dai_id)
  87 #define rsnd_ssi_of_node(priv) \
  88         of_get_child_by_name(rsnd_priv_to_dev(priv)->of_node, "rcar_sound,ssi")
  89
  90 int rsnd_ssi_use_busif(struct rsnd_mod *mod)
  91 {
  92         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
  93         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
  94         int use_busif = 0;
  95
  96         if (!rsnd_ssi_is_dma_mode(mod))
  97                 return 0;
  98
  99         if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF))
 100                 use_busif = 1;
 101         if (rsnd_io_to_mod_src(io))
 102                 use_busif = 1;
 103
 104         return use_busif;
 105 }
 106
 107 static void rsnd_ssi_status_check(struct rsnd_mod *mod,
 108                                   u32 bit)
 109 {
 110         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 111         struct device *dev = rsnd_priv_to_dev(priv);
 112         u32 status;
 113         int i;
 114
 115         for (i = 0; i < 1024; i++) {
 116                 status = rsnd_mod_read(mod, SSISR);
 117                 if (status & bit)
 118                         return;
 119
 120                 udelay(50);
 121         }
 122
 123         dev_warn(dev, "status check failed\n");
 124 }
 125
 126 static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
 127                                      struct rsnd_dai_stream *io)
 128 {
 129         struct rsnd_priv *priv = rsnd_io_to_priv(io);
 130         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 131         struct device *dev = rsnd_priv_to_dev(priv);
 132         int i, j, ret;
 133         int adg_clk_div_table[] = {
 134                 1, 6, /* see adg.c */
 135         };
 136         int ssi_clk_mul_table[] = {
 137                 1, 2, 4, 8, 16, 6, 12,
 138         };
 139         unsigned int main_rate;
 140         unsigned int rate = rsnd_src_get_ssi_rate(priv, io, runtime);
 141
 142         /*
 143          * Find best clock, and try to start ADG
 144          */
 145         for (i = 0; i < ARRAY_SIZE(adg_clk_div_table); i++) {
 146                 for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) {
 147
 148                         /*
 149                          * this driver is assuming that
 150                          * system word is 64fs (= 2 x 32bit)
 151                          * see rsnd_ssi_init()
 152                          */
 153                         main_rate = rate / adg_clk_div_table[i]
 154                                 * 32 * 2 * ssi_clk_mul_table[j];
 155
 156                         ret = rsnd_adg_ssi_clk_try_start(&ssi->mod, main_rate);
 157                         if (0 == ret) {
 158                                 ssi->cr_clk     = FORCE | SWL_32 |
 159                                                   SCKD | SWSD | CKDV(j);
 160
 161                                 dev_dbg(dev, "%s[%d] outputs %u Hz\n",
 162                                         rsnd_mod_name(&ssi->mod),
 163                                         rsnd_mod_id(&ssi->mod), rate);
 164
 165                                 return 0;
 166                         }
 167                 }
 168         }
 169
 170         dev_err(dev, "unsupported clock rate\n");
 171         return -EIO;
 172 }
 173
 174 static void rsnd_ssi_master_clk_stop(struct rsnd_ssi *ssi)
 175 {
 176         ssi->cr_clk = 0;
 177         rsnd_adg_ssi_clk_stop(&ssi->mod);
 178 }
 179
 180 static void rsnd_ssi_hw_start(struct rsnd_ssi *ssi,
 181                               struct rsnd_dai_stream *io)
 182 {
 183         struct rsnd_priv *priv = rsnd_io_to_priv(io);
 184         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 185         struct device *dev = rsnd_priv_to_dev(priv);
 186         u32 cr_mode;
 187         u32 cr;
 188
 189         if (0 == ssi->usrcnt) {
 190                 rsnd_mod_hw_start(&ssi->mod);
 191
 192                 if (rsnd_rdai_is_clk_master(rdai)) {
 193                         struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
 194
 195                         if (ssi_parent)
 196                                 rsnd_ssi_hw_start(ssi_parent, io);
 197                         else
 198                                 rsnd_ssi_master_clk_start(ssi, io);
 199                 }
 200         }
 201
 202         if (rsnd_ssi_is_dma_mode(&ssi->mod)) {
 203                 cr_mode = UIEN | OIEN | /* over/under run */
 204                           DMEN;         /* DMA : enable DMA */
 205         } else {
 206                 cr_mode = DIEN;         /* PIO : enable Data interrupt */
 207         }
 208
 209         cr  =   ssi->cr_own     |
 210                 ssi->cr_clk     |
 211                 cr_mode         |
 212                 EN;
 213
 214         rsnd_mod_write(&ssi->mod, SSICR, cr);
 215
 216         /* enable WS continue */
 217         if (rsnd_rdai_is_clk_master(rdai))
 218                 rsnd_mod_write(&ssi->mod, SSIWSR, CONT);
 219
 220         /* clear error status */
 221         rsnd_mod_write(&ssi->mod, SSISR, 0);
 222
 223         ssi->usrcnt++;
 224
 225         dev_dbg(dev, "%s[%d] hw started\n",
 226                 rsnd_mod_name(&ssi->mod), rsnd_mod_id(&ssi->mod));
 227 }
 228
 229 static void rsnd_ssi_hw_stop(struct rsnd_ssi *ssi)
 230 {
 231         struct rsnd_priv *priv = rsnd_mod_to_priv(&ssi->mod);
 232         struct rsnd_dai_stream *io = rsnd_mod_to_io(&ssi->mod);
 233         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 234         struct device *dev = rsnd_priv_to_dev(priv);
 235         u32 cr;
 236
 237         if (0 == ssi->usrcnt) {
 238                 dev_err(dev, "%s called without starting\n", __func__);
 239                 return;
 240         }
 241
 242         ssi->usrcnt--;
 243
 244         if (0 == ssi->usrcnt) {
 245                 /*
 246                  * disable all IRQ,
 247                  * and, wait all data was sent
 248                  */
 249                 cr  =   ssi->cr_own     |
 250                         ssi->cr_clk;
 251
 252                 rsnd_mod_write(&ssi->mod, SSICR, cr | EN);
 253                 rsnd_ssi_status_check(&ssi->mod, DIRQ);
 254
 255                 /*
 256                  * disable SSI,
 257                  * and, wait idle state
 258                  */
 259                 rsnd_mod_write(&ssi->mod, SSICR, cr);   /* disabled all */
 260                 rsnd_ssi_status_check(&ssi->mod, IIRQ);
 261
 262                 if (rsnd_rdai_is_clk_master(rdai)) {
 263                         struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
 264
 265                         if (ssi_parent)
 266                                 rsnd_ssi_hw_stop(ssi_parent);
 267                         else
 268                                 rsnd_ssi_master_clk_stop(ssi);
 269                 }
 270
 271                 rsnd_mod_hw_stop(&ssi->mod);
 272
 273                 ssi->chan = 0;
 274         }
 275
 276         dev_dbg(dev, "%s[%d] hw stopped\n",
 277                 rsnd_mod_name(&ssi->mod), rsnd_mod_id(&ssi->mod));
 278 }
 279
 280 /*
 281  *      SSI mod common functions
 282  */
 283 static int rsnd_ssi_init(struct rsnd_mod *mod,
 284                          struct rsnd_dai_stream *io,
 285                          struct rsnd_priv *priv)
 286 {
 287         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 288         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 289         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 290         u32 cr;
 291
 292         cr = FORCE;
 293
 294         /*
 295          * always use 32bit system word for easy clock calculation.
 296          * see also rsnd_ssi_master_clk_enable()
 297          */
 298         cr |= SWL_32;
 299
 300         /*
 301          * init clock settings for SSICR
 302          */
 303         switch (runtime->sample_bits) {
 304         case 16:
 305                 cr |= DWL_16;
 306                 break;
 307         case 32:
 308                 cr |= DWL_24;
 309                 break;
 310         default:
 311                 return -EIO;
 312         }
 313
 314         if (rdai->bit_clk_inv)
 315                 cr |= SCKP;
 316         if (rdai->frm_clk_inv)
 317                 cr |= SWSP;
 318         if (rdai->data_alignment)
 319                 cr |= SDTA;
 320         if (rdai->sys_delay)
 321                 cr |= DEL;
 322         if (rsnd_io_is_play(io))
 323                 cr |= TRMD;
 324
 325         /*
 326          * set ssi parameter
 327          */
 328         ssi->cr_own     = cr;
 329         ssi->err        = -1; /* ignore 1st error */
 330
 331         return 0;
 332 }
 333
 334 static int rsnd_ssi_quit(struct rsnd_mod *mod,
 335                          struct rsnd_dai_stream *io,
 336                          struct rsnd_priv *priv)
 337 {
 338         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 339         struct device *dev = rsnd_priv_to_dev(priv);
 340
 341         if (ssi->err > 0)
 342                 dev_warn(dev, "%s[%d] under/over flow err = %d\n",
 343                          rsnd_mod_name(mod), rsnd_mod_id(mod), ssi->err);
 344
 345         ssi->cr_own     = 0;
 346         ssi->err        = 0;
 347
 348         return 0;
 349 }
 350
 351 static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
 352                               struct rsnd_dai_stream *io,
 353                               struct snd_pcm_substream *substream,
 354                               struct snd_pcm_hw_params *params)
 355 {
 356         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 357         struct rsnd_ssi *ssi_parent = rsnd_ssi_parent(ssi);
 358         int chan = params_channels(params);
 359
 360         /*
 361          * Already working.
 362          * It will happen if SSI has parent/child connection.
 363          */
 364         if (ssi->usrcnt) {
 365                 /*
 366                  * it is error if child <-> parent SSI uses
 367                  * different channels.
 368                  */
 369                 if (ssi->chan != chan)
 370                         return -EIO;
 371         }
 372
 373         /* It will be removed on rsnd_ssi_hw_stop */
 374         ssi->chan = chan;
 375         if (ssi_parent)
 376                 return rsnd_ssi_hw_params(&ssi_parent->mod, io,
 377                                           substream, params);
 378
 379         return 0;
 380 }
 381
 382 static void rsnd_ssi_record_error(struct rsnd_ssi *ssi, u32 status)
 383 {
 384         /* under/over flow error */
 385         if (status & (UIRQ | OIRQ)) {
 386                 ssi->err++;
 387
 388                 /* clear error status */
 389                 rsnd_mod_write(&ssi->mod, SSISR, 0);
 390         }
 391 }
 392
 393 static int rsnd_ssi_start(struct rsnd_mod *mod,
 394                           struct rsnd_dai_stream *io,
 395                           struct rsnd_priv *priv)
 396 {
 397         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 398
 399         rsnd_src_ssiu_start(mod, io, rsnd_ssi_use_busif(mod));
 400
 401         rsnd_ssi_hw_start(ssi, io);
 402
 403         rsnd_src_ssi_irq_enable(mod);
 404
 405         return 0;
 406 }
 407
 408 static int rsnd_ssi_stop(struct rsnd_mod *mod,
 409                          struct rsnd_dai_stream *io,
 410                          struct rsnd_priv *priv)
 411 {
 412         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 413
 414         rsnd_src_ssi_irq_disable(mod);
 415
 416         rsnd_ssi_record_error(ssi, rsnd_mod_read(mod, SSISR));
 417
 418         rsnd_ssi_hw_stop(ssi);
 419
 420         rsnd_src_ssiu_stop(mod, io);
 421
 422         return 0;
 423 }
 424
 425 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
 426 {
 427         struct rsnd_ssi *ssi = data;
 428         struct rsnd_mod *mod = &ssi->mod;
 429         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 430         struct rsnd_dai_stream *io = rsnd_mod_to_io(mod);
 431         int is_dma = rsnd_ssi_is_dma_mode(mod);
 432         u32 status;
 433         bool elapsed = false;
 434
 435         spin_lock(&priv->lock);
 436
 437         /* ignore all cases if not working */
 438         if (!rsnd_mod_is_working(mod))
 439                 goto rsnd_ssi_interrupt_out;
 440
 441         status = rsnd_mod_read(mod, SSISR);
 442
 443         /* PIO only */
 444         if (!is_dma && (status & DIRQ)) {
 445                 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 446                 u32 *buf = (u32 *)(runtime->dma_area +
 447                                    rsnd_dai_pointer_offset(io, 0));
 448
 449                 /*
 450                  * 8/16/32 data can be assesse to TDR/RDR register
 451                  * directly as 32bit data
 452                  * see rsnd_ssi_init()
 453                  */
 454                 if (rsnd_io_is_play(io))
 455                         rsnd_mod_write(mod, SSITDR, *buf);
 456                 else
 457                         *buf = rsnd_mod_read(mod, SSIRDR);
 458
 459                 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));
 460         }
 461
 462         /* DMA only */
 463         if (is_dma && (status & (UIRQ | OIRQ))) {
 464                 struct device *dev = rsnd_priv_to_dev(priv);
 465
 466                 /*
 467                  * restart SSI
 468                  */
 469                 dev_dbg(dev, "%s[%d] restart\n",
 470                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 471
 472                 rsnd_ssi_stop(mod, io, priv);
 473                 if (ssi->err < 1024)
 474                         rsnd_ssi_start(mod, io, priv);
 475                 else
 476                         dev_warn(dev, "no more SSI restart\n");
 477         }
 478
 479         rsnd_ssi_record_error(ssi, status);
 480
 481 rsnd_ssi_interrupt_out:
 482         spin_unlock(&priv->lock);
 483
 484         if (elapsed)
 485                 rsnd_dai_period_elapsed(io);
 486
 487         return IRQ_HANDLED;
 488 }
 489
 490 /*
 491  *              SSI PIO
 492  */
 493 static int rsnd_ssi_pio_probe(struct rsnd_mod *mod,
 494                               struct rsnd_dai_stream *io,
 495                               struct rsnd_priv *priv)
 496 {
 497         struct device *dev = rsnd_priv_to_dev(priv);
 498         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 499         int ret;
 500
 501         ret = devm_request_irq(dev, ssi->info->irq,
 502                                rsnd_ssi_interrupt,
 503                                IRQF_SHARED,
 504                                dev_name(dev), ssi);
 505
 506         return ret;
 507 }
 508
 509 static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
 510         .name   = SSI_NAME,
 511         .probe  = rsnd_ssi_pio_probe,
 512         .init   = rsnd_ssi_init,
 513         .quit   = rsnd_ssi_quit,
 514         .start  = rsnd_ssi_start,
 515         .stop   = rsnd_ssi_stop,
 516         .hw_params = rsnd_ssi_hw_params,
 517 };
 518
 519 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
 520                               struct rsnd_dai_stream *io,
 521                               struct rsnd_priv *priv)
 522 {
 523         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 524         struct device *dev = rsnd_priv_to_dev(priv);
 525         int dma_id = ssi->info->dma_id;
 526         int ret;
 527
 528         ret = devm_request_irq(dev, ssi->info->irq,
 529                                rsnd_ssi_interrupt,
 530                                IRQF_SHARED,
 531                                dev_name(dev), ssi);
 532         if (ret)
 533                 return ret;
 534
 535         ret = rsnd_dma_init(
 536                 io, rsnd_mod_to_dma(mod),
 537                 dma_id);
 538
 539         return ret;
 540 }
 541
 542 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
 543                                struct rsnd_dai_stream *io,
 544                                struct rsnd_priv *priv)
 545 {
 546         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 547         struct device *dev = rsnd_priv_to_dev(priv);
 548         int irq = ssi->info->irq;
 549
 550         rsnd_dma_quit(io, rsnd_mod_to_dma(mod));
 551
 552         /* PIO will request IRQ again */
 553         devm_free_irq(dev, irq, ssi);
 554
 555         return 0;
 556 }
 557
 558 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
 559                              struct rsnd_dai_stream *io,
 560                              struct rsnd_priv *priv)
 561 {
 562         struct device *dev = rsnd_priv_to_dev(priv);
 563
 564         /*
 565          * fallback to PIO
 566          *
 567          * SSI .probe might be called again.
 568          * see
 569          *      rsnd_rdai_continuance_probe()
 570          */
 571         mod->ops = &rsnd_ssi_pio_ops;
 572
 573         dev_info(dev, "%s[%d] fallback to PIO mode\n",
 574                  rsnd_mod_name(mod), rsnd_mod_id(mod));
 575
 576         return 0;
 577 }
 578
 579 static int rsnd_ssi_dma_start(struct rsnd_mod *mod,
 580                               struct rsnd_dai_stream *io,
 581                               struct rsnd_priv *priv)
 582 {
 583         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 584
 585         rsnd_dma_start(io, dma);
 586
 587         rsnd_ssi_start(mod, io, priv);
 588
 589         return 0;
 590 }
 591
 592 static int rsnd_ssi_dma_stop(struct rsnd_mod *mod,
 593                              struct rsnd_dai_stream *io,
 594                              struct rsnd_priv *priv)
 595 {
 596         struct rsnd_dma *dma = rsnd_mod_to_dma(mod);
 597
 598         rsnd_ssi_stop(mod, io, priv);
 599
 600         rsnd_dma_stop(io, dma);
 601
 602         return 0;
 603 }
 604
 605 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
 606                                          struct rsnd_mod *mod)
 607 {
 608         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 609         int is_play = rsnd_io_is_play(io);
 610         char *name;
 611
 612         if (rsnd_ssi_use_busif(mod))
 613                 name = is_play ? "rxu" : "txu";
 614         else
 615                 name = is_play ? "rx" : "tx";
 616
 617         return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
 618                                         mod, name);
 619 }
 620
 621 static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
 622         .name   = SSI_NAME,
 623         .dma_req = rsnd_ssi_dma_req,
 624         .probe  = rsnd_ssi_dma_probe,
 625         .remove = rsnd_ssi_dma_remove,
 626         .init   = rsnd_ssi_init,
 627         .quit   = rsnd_ssi_quit,
 628         .start  = rsnd_ssi_dma_start,
 629         .stop   = rsnd_ssi_dma_stop,
 630         .fallback = rsnd_ssi_fallback,
 631         .hw_params = rsnd_ssi_hw_params,
 632 };
 633
 634 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
 635 {
 636         return mod->ops == &rsnd_ssi_dma_ops;
 637 }
 638
 639
 640 /*
 641  *              Non SSI
 642  */
 643 static struct rsnd_mod_ops rsnd_ssi_non_ops = {
 644         .name   = SSI_NAME,
 645 };
 646
 647 /*
 648  *              ssi mod function
 649  */
 650 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id)
 651 {
 652         if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv)))
 653                 id = 0;
 654
 655         return &((struct rsnd_ssi *)(priv->ssi) + id)->mod;
 656 }
 657
 658 int rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
 659 {
 660         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 661
 662         return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE);
 663 }
 664
 665 static void rsnd_ssi_parent_setup(struct rsnd_priv *priv, struct rsnd_ssi *ssi)
 666 {
 667         if (!rsnd_ssi_is_pin_sharing(&ssi->mod))
 668                 return;
 669
 670         switch (rsnd_mod_id(&ssi->mod)) {
 671         case 1:
 672         case 2:
 673                 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 0));
 674                 break;
 675         case 4:
 676                 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 3));
 677                 break;
 678         case 8:
 679                 ssi->parent = rsnd_mod_to_ssi(rsnd_ssi_mod_get(priv, 7));
 680                 break;
 681         }
 682 }
 683
 684
 685 static void rsnd_of_parse_ssi(struct platform_device *pdev,
 686                               const struct rsnd_of_data *of_data,
 687                               struct rsnd_priv *priv)
 688 {
 689         struct device_node *node;
 690         struct device_node *np;
 691         struct rsnd_ssi_platform_info *ssi_info;
 692         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
 693         struct device *dev = &pdev->dev;
 694         int nr, i;
 695
 696         if (!of_data)
 697                 return;
 698
 699         node = rsnd_ssi_of_node(priv);
 700         if (!node)
 701                 return;
 702
 703         nr = of_get_child_count(node);
 704         if (!nr)
 705                 goto rsnd_of_parse_ssi_end;
 706
 707         ssi_info = devm_kzalloc(dev,
 708                                 sizeof(struct rsnd_ssi_platform_info) * nr,
 709                                 GFP_KERNEL);
 710         if (!ssi_info) {
 711                 dev_err(dev, "ssi info allocation error\n");
 712                 goto rsnd_of_parse_ssi_end;
 713         }
 714
 715         info->ssi_info          = ssi_info;
 716         info->ssi_info_nr       = nr;
 717
 718         i = -1;
 719         for_each_child_of_node(node, np) {
 720                 i++;
 721
 722                 ssi_info = info->ssi_info + i;
 723
 724                 /*
 725                  * pin settings
 726                  */
 727                 if (of_get_property(np, "shared-pin", NULL))
 728                         ssi_info->flags |= RSND_SSI_CLK_PIN_SHARE;
 729
 730                 /*
 731                  * irq
 732                  */
 733                 ssi_info->irq = irq_of_parse_and_map(np, 0);
 734
 735                 /*
 736                  * DMA
 737                  */
 738                 ssi_info->dma_id = of_get_property(np, "pio-transfer", NULL) ?
 739                         0 : 1;
 740
 741                 if (of_get_property(np, "no-busif", NULL))
 742                         ssi_info->flags |= RSND_SSI_NO_BUSIF;
 743         }
 744
 745 rsnd_of_parse_ssi_end:
 746         of_node_put(node);
 747 }
 748
 749 int rsnd_ssi_probe(struct platform_device *pdev,
 750                    const struct rsnd_of_data *of_data,
 751                    struct rsnd_priv *priv)
 752 {
 753         struct rcar_snd_info *info = rsnd_priv_to_info(priv);
 754         struct rsnd_ssi_platform_info *pinfo;
 755         struct device *dev = rsnd_priv_to_dev(priv);
 756         struct rsnd_mod_ops *ops;
 757         struct clk *clk;
 758         struct rsnd_ssi *ssi;
 759         char name[RSND_SSI_NAME_SIZE];
 760         int i, nr, ret;
 761
 762         rsnd_of_parse_ssi(pdev, of_data, priv);
 763
 764         /*
 765          *      init SSI
 766          */
 767         nr      = info->ssi_info_nr;
 768         ssi     = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL);
 769         if (!ssi) {
 770                 dev_err(dev, "SSI allocate failed\n");
 771                 return -ENOMEM;
 772         }
 773
 774         priv->ssi       = ssi;
 775         priv->ssi_nr    = nr;
 776
 777         for_each_rsnd_ssi(ssi, priv, i) {
 778                 pinfo = &info->ssi_info[i];
 779
 780                 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d",
 781                          SSI_NAME, i);
 782
 783                 clk = devm_clk_get(dev, name);
 784                 if (IS_ERR(clk))
 785                         return PTR_ERR(clk);
 786
 787                 ssi->info       = pinfo;
 788
 789                 ops = &rsnd_ssi_non_ops;
 790                 if (pinfo->dma_id > 0)
 791                         ops = &rsnd_ssi_dma_ops;
 792                 else if (rsnd_ssi_pio_available(ssi))
 793                         ops = &rsnd_ssi_pio_ops;
 794
 795                 ret = rsnd_mod_init(priv, &ssi->mod, ops, clk, RSND_MOD_SSI, i);
 796                 if (ret)
 797                         return ret;
 798
 799                 rsnd_ssi_parent_setup(priv, ssi);
 800         }
 801
 802         return 0;
 803 }
 804
 805 void rsnd_ssi_remove(struct platform_device *pdev,
 806                      struct rsnd_priv *priv)
 807 {
 808         struct rsnd_ssi *ssi;
 809         int i;
 810
 811         for_each_rsnd_ssi(ssi, priv, i) {
 812                 rsnd_mod_quit(&ssi->mod);
 813         }
 814 }