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 #define CHNL_4          (1 << 22)       /* Channels */
  28 #define CHNL_6          (2 << 22)       /* Channels */
  29 #define CHNL_8          (3 << 22)       /* Channels */
  30 #define DWL_8           (0 << 19)       /* Data Word Length */
  31 #define DWL_16          (1 << 19)       /* Data Word Length */
  32 #define DWL_18          (2 << 19)       /* Data Word Length */
  33 #define DWL_20          (3 << 19)       /* Data Word Length */
  34 #define DWL_22          (4 << 19)       /* Data Word Length */
  35 #define DWL_24          (5 << 19)       /* Data Word Length */
  36 #define DWL_32          (6 << 19)       /* Data Word Length */
  37
  38 #define SWL_32          (3 << 16)       /* R/W System Word Length */
  39 #define SCKD            (1 << 15)       /* Serial Bit Clock Direction */
  40 #define SWSD            (1 << 14)       /* Serial WS Direction */
  41 #define SCKP            (1 << 13)       /* Serial Bit Clock Polarity */
  42 #define SWSP            (1 << 12)       /* Serial WS Polarity */
  43 #define SDTA            (1 << 10)       /* Serial Data Alignment */
  44 #define PDTA            (1 <<  9)       /* Parallel Data Alignment */
  45 #define DEL             (1 <<  8)       /* Serial Data Delay */
  46 #define CKDV(v)         (v <<  4)       /* Serial Clock Division Ratio */
  47 #define TRMD            (1 <<  1)       /* Transmit/Receive Mode Select */
  48 #define EN              (1 <<  0)       /* SSI Module Enable */
  49
  50 /*
  51  * SSISR
  52  */
  53 #define UIRQ            (1 << 27)       /* Underflow Error Interrupt Status */
  54 #define OIRQ            (1 << 26)       /* Overflow Error Interrupt Status */
  55 #define IIRQ            (1 << 25)       /* Idle Mode Interrupt Status */
  56 #define DIRQ            (1 << 24)       /* Data Interrupt Status Flag */
  57
  58 /*
  59  * SSIWSR
  60  */
  61 #define CONT            (1 << 8)        /* WS Continue Function */
  62 #define WS_MODE         (1 << 0)        /* WS Mode */
  63
  64 #define SSI_NAME "ssi"
  65
  66 struct rsnd_ssi {
  67         struct rsnd_mod mod;
  68         struct rsnd_mod *dma;
  69
  70         u32 flags;
  71         u32 cr_own;
  72         u32 cr_clk;
  73         u32 cr_mode;
  74         u32 wsr;
  75         int chan;
  76         int rate;
  77         int irq;
  78         unsigned int usrcnt;
  79 };
  80
  81 /* flags */
  82 #define RSND_SSI_CLK_PIN_SHARE          (1 << 0)
  83 #define RSND_SSI_NO_BUSIF               (1 << 1) /* SSI+DMA without BUSIF */
  84
  85 #define for_each_rsnd_ssi(pos, priv, i)                                 \
  86         for (i = 0;                                                     \
  87              (i < rsnd_ssi_nr(priv)) &&                                 \
  88                 ((pos) = ((struct rsnd_ssi *)(priv)->ssi + i));         \
  89              i++)
  90
  91 #define rsnd_ssi_get(priv, id) ((struct rsnd_ssi *)(priv->ssi) + id)
  92 #define rsnd_ssi_to_dma(mod) ((ssi)->dma)
  93 #define rsnd_ssi_nr(priv) ((priv)->ssi_nr)
  94 #define rsnd_mod_to_ssi(_mod) container_of((_mod), struct rsnd_ssi, mod)
  95 #define rsnd_ssi_mode_flags(p) ((p)->flags)
  96 #define rsnd_ssi_is_parent(ssi, io) ((ssi) == rsnd_io_to_mod_ssip(io))
  97 #define rsnd_ssi_is_multi_slave(mod, io) \
  98         (rsnd_ssi_multi_slaves(io) & (1 << rsnd_mod_id(mod)))
  99
 100 int rsnd_ssi_use_busif(struct rsnd_dai_stream *io)
 101 {
 102         struct rsnd_mod *mod = rsnd_io_to_mod_ssi(io);
 103         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 104         int use_busif = 0;
 105
 106         if (!rsnd_ssi_is_dma_mode(mod))
 107                 return 0;
 108
 109         if (!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_NO_BUSIF))
 110                 use_busif = 1;
 111         if (rsnd_io_to_mod_src(io))
 112                 use_busif = 1;
 113
 114         return use_busif;
 115 }
 116
 117 static void rsnd_ssi_status_clear(struct rsnd_mod *mod)
 118 {
 119         rsnd_mod_write(mod, SSISR, 0);
 120 }
 121
 122 static u32 rsnd_ssi_status_get(struct rsnd_mod *mod)
 123 {
 124         return rsnd_mod_read(mod, SSISR);
 125 }
 126
 127 static void rsnd_ssi_status_check(struct rsnd_mod *mod,
 128                                   u32 bit)
 129 {
 130         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 131         struct device *dev = rsnd_priv_to_dev(priv);
 132         u32 status;
 133         int i;
 134
 135         for (i = 0; i < 1024; i++) {
 136                 status = rsnd_ssi_status_get(mod);
 137                 if (status & bit)
 138                         return;
 139
 140                 udelay(50);
 141         }
 142
 143         dev_warn(dev, "status check failed\n");
 144 }
 145
 146 static int rsnd_ssi_irq(struct rsnd_mod *mod,
 147                         struct rsnd_dai_stream *io,
 148                         struct rsnd_priv *priv,
 149                         int enable)
 150 {
 151         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 152         u32 val = 0;
 153
 154         if (rsnd_is_gen1(priv))
 155                 return 0;
 156
 157         if (ssi->usrcnt != 1)
 158                 return 0;
 159
 160         if (enable)
 161                 val = rsnd_ssi_is_dma_mode(mod) ? 0x0e000000 : 0x0f000000;
 162
 163         rsnd_mod_write(mod, SSI_INT_ENABLE, val);
 164
 165         return 0;
 166 }
 167
 168 u32 rsnd_ssi_multi_slaves(struct rsnd_dai_stream *io)
 169 {
 170         struct rsnd_mod *mod;
 171         enum rsnd_mod_type types[] = {
 172                 RSND_MOD_SSIM1,
 173                 RSND_MOD_SSIM2,
 174                 RSND_MOD_SSIM3,
 175         };
 176         int i, mask;
 177
 178         mask = 0;
 179         for (i = 0; i < ARRAY_SIZE(types); i++) {
 180                 mod = rsnd_io_to_mod(io, types[i]);
 181                 if (!mod)
 182                         continue;
 183
 184                 mask |= 1 << rsnd_mod_id(mod);
 185         }
 186
 187         return mask;
 188 }
 189
 190 static int rsnd_ssi_master_clk_start(struct rsnd_ssi *ssi,
 191                                      struct rsnd_dai_stream *io)
 192 {
 193         struct rsnd_priv *priv = rsnd_io_to_priv(io);
 194         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 195         struct device *dev = rsnd_priv_to_dev(priv);
 196         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 197         struct rsnd_mod *mod = rsnd_mod_get(ssi);
 198         struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
 199         int slots = rsnd_get_slot_width(io);
 200         int j, ret;
 201         int ssi_clk_mul_table[] = {
 202                 1, 2, 4, 8, 16, 6, 12,
 203         };
 204         unsigned int main_rate;
 205         unsigned int rate = rsnd_src_get_ssi_rate(priv, io, runtime);
 206
 207         if (!rsnd_rdai_is_clk_master(rdai))
 208                 return 0;
 209
 210         if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
 211                 return 0;
 212
 213         if (rsnd_ssi_is_multi_slave(mod, io))
 214                 return 0;
 215
 216         if (ssi->usrcnt > 1) {
 217                 if (ssi->rate != rate) {
 218                         dev_err(dev, "SSI parent/child should use same rate\n");
 219                         return -EINVAL;
 220                 }
 221
 222                 return 0;
 223         }
 224
 225         /*
 226          * Find best clock, and try to start ADG
 227          */
 228         for (j = 0; j < ARRAY_SIZE(ssi_clk_mul_table); j++) {
 229
 230                 /*
 231                  * this driver is assuming that
 232                  * system word is 32bit x slots
 233                  * see rsnd_ssi_init()
 234                  */
 235                 main_rate = rate * 32 * slots * ssi_clk_mul_table[j];
 236
 237                 ret = rsnd_adg_ssi_clk_try_start(mod, main_rate);
 238                 if (0 == ret) {
 239                         ssi->cr_clk     = FORCE | SWL_32 |
 240                                 SCKD | SWSD | CKDV(j);
 241                         ssi->wsr = CONT;
 242
 243                         ssi->rate = rate;
 244
 245                         dev_dbg(dev, "%s[%d] outputs %u Hz\n",
 246                                 rsnd_mod_name(mod),
 247                                 rsnd_mod_id(mod), rate);
 248
 249                         return 0;
 250                 }
 251         }
 252
 253         dev_err(dev, "unsupported clock rate\n");
 254         return -EIO;
 255 }
 256
 257 static void rsnd_ssi_master_clk_stop(struct rsnd_ssi *ssi,
 258                                      struct rsnd_dai_stream *io)
 259 {
 260         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 261         struct rsnd_mod *mod = rsnd_mod_get(ssi);
 262         struct rsnd_mod *ssi_parent_mod = rsnd_io_to_mod_ssip(io);
 263
 264         if (!rsnd_rdai_is_clk_master(rdai))
 265                 return;
 266
 267         if (ssi_parent_mod && !rsnd_ssi_is_parent(mod, io))
 268                 return;
 269
 270         if (ssi->usrcnt > 1)
 271                 return;
 272
 273         ssi->cr_clk     = 0;
 274         ssi->rate       = 0;
 275
 276         rsnd_adg_ssi_clk_stop(mod);
 277 }
 278
 279 static int rsnd_ssi_config_init(struct rsnd_ssi *ssi,
 280                                 struct rsnd_dai_stream *io)
 281 {
 282         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 283         struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 284         u32 cr_own;
 285         u32 cr_mode;
 286         u32 wsr;
 287         int is_tdm;
 288
 289         is_tdm = (rsnd_get_slot_width(io) >= 6) ? 1 : 0;
 290
 291         /*
 292          * always use 32bit system word.
 293          * see also rsnd_ssi_master_clk_enable()
 294          */
 295         cr_own = FORCE | SWL_32 | PDTA;
 296
 297         if (rdai->bit_clk_inv)
 298                 cr_own |= SCKP;
 299         if (rdai->frm_clk_inv ^ is_tdm)
 300                 cr_own |= SWSP;
 301         if (rdai->data_alignment)
 302                 cr_own |= SDTA;
 303         if (rdai->sys_delay)
 304                 cr_own |= DEL;
 305         if (rsnd_io_is_play(io))
 306                 cr_own |= TRMD;
 307
 308         switch (runtime->sample_bits) {
 309         case 16:
 310                 cr_own |= DWL_16;
 311                 break;
 312         case 32:
 313                 cr_own |= DWL_24;
 314                 break;
 315         default:
 316                 return -EINVAL;
 317         }
 318
 319         if (rsnd_ssi_is_dma_mode(rsnd_mod_get(ssi))) {
 320                 cr_mode = UIEN | OIEN | /* over/under run */
 321                           DMEN;         /* DMA : enable DMA */
 322         } else {
 323                 cr_mode = DIEN;         /* PIO : enable Data interrupt */
 324         }
 325
 326         /*
 327          * TDM Extend Mode
 328          * see
 329          *      rsnd_ssiu_init_gen2()
 330          */
 331         wsr = ssi->wsr;
 332         if (is_tdm) {
 333                 wsr     |= WS_MODE;
 334                 cr_own  |= CHNL_8;
 335         }
 336
 337         ssi->cr_own     = cr_own;
 338         ssi->cr_mode    = cr_mode;
 339         ssi->wsr        = wsr;
 340
 341         return 0;
 342 }
 343
 344 /*
 345  *      SSI mod common functions
 346  */
 347 static int rsnd_ssi_init(struct rsnd_mod *mod,
 348                          struct rsnd_dai_stream *io,
 349                          struct rsnd_priv *priv)
 350 {
 351         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 352         int ret;
 353
 354         ssi->usrcnt++;
 355
 356         rsnd_mod_power_on(mod);
 357
 358         ret = rsnd_ssi_master_clk_start(ssi, io);
 359         if (ret < 0)
 360                 return ret;
 361
 362         if (rsnd_ssi_is_parent(mod, io))
 363                 return 0;
 364
 365         ret = rsnd_ssi_config_init(ssi, io);
 366         if (ret < 0)
 367                 return ret;
 368
 369         /* clear error status */
 370         rsnd_ssi_status_clear(mod);
 371
 372         return 0;
 373 }
 374
 375 static int rsnd_ssi_quit(struct rsnd_mod *mod,
 376                          struct rsnd_dai_stream *io,
 377                          struct rsnd_priv *priv)
 378 {
 379         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 380         struct device *dev = rsnd_priv_to_dev(priv);
 381
 382         if (!ssi->usrcnt) {
 383                 dev_err(dev, "%s[%d] usrcnt error\n",
 384                         rsnd_mod_name(mod), rsnd_mod_id(mod));
 385                 return -EIO;
 386         }
 387
 388         if (!rsnd_ssi_is_parent(mod, io))
 389                 ssi->cr_own     = 0;
 390
 391         rsnd_ssi_master_clk_stop(ssi, io);
 392
 393         rsnd_mod_power_off(mod);
 394
 395         ssi->usrcnt--;
 396
 397         return 0;
 398 }
 399
 400 static int rsnd_ssi_hw_params(struct rsnd_mod *mod,
 401                               struct rsnd_dai_stream *io,
 402                               struct snd_pcm_substream *substream,
 403                               struct snd_pcm_hw_params *params)
 404 {
 405         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 406         int chan = params_channels(params);
 407
 408         /*
 409          * Already working.
 410          * It will happen if SSI has parent/child connection.
 411          */
 412         if (ssi->usrcnt > 1) {
 413                 /*
 414                  * it is error if child <-> parent SSI uses
 415                  * different channels.
 416                  */
 417                 if (ssi->chan != chan)
 418                         return -EIO;
 419         }
 420
 421         ssi->chan = chan;
 422
 423         return 0;
 424 }
 425
 426 static int rsnd_ssi_start(struct rsnd_mod *mod,
 427                           struct rsnd_dai_stream *io,
 428                           struct rsnd_priv *priv)
 429 {
 430         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 431         u32 cr;
 432
 433         cr  =   ssi->cr_own     |
 434                 ssi->cr_clk     |
 435                 ssi->cr_mode;
 436
 437         /*
 438          * EN will be set via SSIU :: SSI_CONTROL
 439          * if Multi channel mode
 440          */
 441         if (!rsnd_ssi_multi_slaves(io))
 442                 cr |= EN;
 443
 444         rsnd_mod_write(mod, SSICR, cr);
 445         rsnd_mod_write(mod, SSIWSR, ssi->wsr);
 446
 447         return 0;
 448 }
 449
 450 static int rsnd_ssi_stop(struct rsnd_mod *mod,
 451                          struct rsnd_dai_stream *io,
 452                          struct rsnd_priv *priv)
 453 {
 454         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 455         u32 cr;
 456
 457         /*
 458          * don't stop if not last user
 459          * see also
 460          *      rsnd_ssi_start
 461          *      rsnd_ssi_interrupt
 462          */
 463         if (ssi->usrcnt > 1)
 464                 return 0;
 465
 466         /*
 467          * disable all IRQ,
 468          * and, wait all data was sent
 469          */
 470         cr  =   ssi->cr_own     |
 471                 ssi->cr_clk;
 472
 473         rsnd_mod_write(mod, SSICR, cr | EN);
 474         rsnd_ssi_status_check(mod, DIRQ);
 475
 476         /*
 477          * disable SSI,
 478          * and, wait idle state
 479          */
 480         rsnd_mod_write(mod, SSICR, cr); /* disabled all */
 481         rsnd_ssi_status_check(mod, IIRQ);
 482
 483         return 0;
 484 }
 485
 486 static void __rsnd_ssi_interrupt(struct rsnd_mod *mod,
 487                                  struct rsnd_dai_stream *io)
 488 {
 489         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 490         int is_dma = rsnd_ssi_is_dma_mode(mod);
 491         u32 status;
 492         bool elapsed = false;
 493         bool stop = false;
 494
 495         spin_lock(&priv->lock);
 496
 497         /* ignore all cases if not working */
 498         if (!rsnd_io_is_working(io))
 499                 goto rsnd_ssi_interrupt_out;
 500
 501         status = rsnd_ssi_status_get(mod);
 502
 503         /* PIO only */
 504         if (!is_dma && (status & DIRQ)) {
 505                 struct snd_pcm_runtime *runtime = rsnd_io_to_runtime(io);
 506                 u32 *buf = (u32 *)(runtime->dma_area +
 507                                    rsnd_dai_pointer_offset(io, 0));
 508
 509                 /*
 510                  * 8/16/32 data can be assesse to TDR/RDR register
 511                  * directly as 32bit data
 512                  * see rsnd_ssi_init()
 513                  */
 514                 if (rsnd_io_is_play(io))
 515                         rsnd_mod_write(mod, SSITDR, *buf);
 516                 else
 517                         *buf = rsnd_mod_read(mod, SSIRDR);
 518
 519                 elapsed = rsnd_dai_pointer_update(io, sizeof(*buf));
 520         }
 521
 522         /* DMA only */
 523         if (is_dma && (status & (UIRQ | OIRQ)))
 524                 stop = true;
 525
 526         rsnd_ssi_status_clear(mod);
 527 rsnd_ssi_interrupt_out:
 528         spin_unlock(&priv->lock);
 529
 530         if (elapsed)
 531                 rsnd_dai_period_elapsed(io);
 532
 533         if (stop)
 534                 snd_pcm_stop_xrun(io->substream);
 535
 536 }
 537
 538 static irqreturn_t rsnd_ssi_interrupt(int irq, void *data)
 539 {
 540         struct rsnd_mod *mod = data;
 541
 542         rsnd_mod_interrupt(mod, __rsnd_ssi_interrupt);
 543
 544         return IRQ_HANDLED;
 545 }
 546
 547 /*
 548  *              SSI PIO
 549  */
 550 static void rsnd_ssi_parent_attach(struct rsnd_mod *mod,
 551                                    struct rsnd_dai_stream *io,
 552                                    struct rsnd_priv *priv)
 553 {
 554         if (!__rsnd_ssi_is_pin_sharing(mod))
 555                 return;
 556
 557         switch (rsnd_mod_id(mod)) {
 558         case 1:
 559         case 2:
 560                 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 0), io, RSND_MOD_SSIP);
 561                 break;
 562         case 4:
 563                 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 3), io, RSND_MOD_SSIP);
 564                 break;
 565         case 8:
 566                 rsnd_dai_connect(rsnd_ssi_mod_get(priv, 7), io, RSND_MOD_SSIP);
 567                 break;
 568         }
 569 }
 570
 571 static int rsnd_ssi_common_probe(struct rsnd_mod *mod,
 572                                  struct rsnd_dai_stream *io,
 573                                  struct rsnd_priv *priv)
 574 {
 575         struct device *dev = rsnd_priv_to_dev(priv);
 576         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 577         int ret;
 578
 579         /*
 580          * SSIP/SSIU/IRQ are not needed on
 581          * SSI Multi slaves
 582          */
 583         if (rsnd_ssi_is_multi_slave(mod, io))
 584                 return 0;
 585
 586         rsnd_ssi_parent_attach(mod, io, priv);
 587
 588         ret = rsnd_ssiu_attach(io, mod);
 589         if (ret < 0)
 590                 return ret;
 591
 592         ret = devm_request_irq(dev, ssi->irq,
 593                                rsnd_ssi_interrupt,
 594                                IRQF_SHARED,
 595                                dev_name(dev), mod);
 596
 597         return ret;
 598 }
 599
 600 static struct rsnd_mod_ops rsnd_ssi_pio_ops = {
 601         .name   = SSI_NAME,
 602         .probe  = rsnd_ssi_common_probe,
 603         .init   = rsnd_ssi_init,
 604         .quit   = rsnd_ssi_quit,
 605         .start  = rsnd_ssi_start,
 606         .stop   = rsnd_ssi_stop,
 607         .irq    = rsnd_ssi_irq,
 608         .hw_params = rsnd_ssi_hw_params,
 609 };
 610
 611 static int rsnd_ssi_dma_probe(struct rsnd_mod *mod,
 612                               struct rsnd_dai_stream *io,
 613                               struct rsnd_priv *priv)
 614 {
 615         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 616         int dma_id = 0; /* not needed */
 617         int ret;
 618
 619         /*
 620          * SSIP/SSIU/IRQ/DMA are not needed on
 621          * SSI Multi slaves
 622          */
 623         if (rsnd_ssi_is_multi_slave(mod, io))
 624                 return 0;
 625
 626         ret = rsnd_ssi_common_probe(mod, io, priv);
 627         if (ret)
 628                 return ret;
 629
 630         /* SSI probe might be called many times in MUX multi path */
 631         ret = rsnd_dma_attach(io, mod, &ssi->dma, dma_id);
 632
 633         return ret;
 634 }
 635
 636 static int rsnd_ssi_dma_remove(struct rsnd_mod *mod,
 637                                struct rsnd_dai_stream *io,
 638                                struct rsnd_priv *priv)
 639 {
 640         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 641         struct device *dev = rsnd_priv_to_dev(priv);
 642         int irq = ssi->irq;
 643
 644         /* PIO will request IRQ again */
 645         devm_free_irq(dev, irq, mod);
 646
 647         return 0;
 648 }
 649
 650 static int rsnd_ssi_fallback(struct rsnd_mod *mod,
 651                              struct rsnd_dai_stream *io,
 652                              struct rsnd_priv *priv)
 653 {
 654         struct device *dev = rsnd_priv_to_dev(priv);
 655
 656         /*
 657          * fallback to PIO
 658          *
 659          * SSI .probe might be called again.
 660          * see
 661          *      rsnd_rdai_continuance_probe()
 662          */
 663         mod->ops = &rsnd_ssi_pio_ops;
 664
 665         dev_info(dev, "%s[%d] fallback to PIO mode\n",
 666                  rsnd_mod_name(mod), rsnd_mod_id(mod));
 667
 668         return 0;
 669 }
 670
 671 static struct dma_chan *rsnd_ssi_dma_req(struct rsnd_dai_stream *io,
 672                                          struct rsnd_mod *mod)
 673 {
 674         struct rsnd_priv *priv = rsnd_mod_to_priv(mod);
 675         int is_play = rsnd_io_is_play(io);
 676         char *name;
 677
 678         if (rsnd_ssi_use_busif(io))
 679                 name = is_play ? "rxu" : "txu";
 680         else
 681                 name = is_play ? "rx" : "tx";
 682
 683         return rsnd_dma_request_channel(rsnd_ssi_of_node(priv),
 684                                         mod, name);
 685 }
 686
 687 static struct rsnd_mod_ops rsnd_ssi_dma_ops = {
 688         .name   = SSI_NAME,
 689         .dma_req = rsnd_ssi_dma_req,
 690         .probe  = rsnd_ssi_dma_probe,
 691         .remove = rsnd_ssi_dma_remove,
 692         .init   = rsnd_ssi_init,
 693         .quit   = rsnd_ssi_quit,
 694         .start  = rsnd_ssi_start,
 695         .stop   = rsnd_ssi_stop,
 696         .fallback = rsnd_ssi_fallback,
 697         .hw_params = rsnd_ssi_hw_params,
 698 };
 699
 700 int rsnd_ssi_is_dma_mode(struct rsnd_mod *mod)
 701 {
 702         return mod->ops == &rsnd_ssi_dma_ops;
 703 }
 704
 705
 706 /*
 707  *              Non SSI
 708  */
 709 static struct rsnd_mod_ops rsnd_ssi_non_ops = {
 710         .name   = SSI_NAME,
 711 };
 712
 713 /*
 714  *              ssi mod function
 715  */
 716 static void rsnd_ssi_connect(struct rsnd_mod *mod,
 717                              struct rsnd_dai_stream *io)
 718 {
 719         struct rsnd_dai *rdai = rsnd_io_to_rdai(io);
 720         enum rsnd_mod_type types[] = {
 721                 RSND_MOD_SSI,
 722                 RSND_MOD_SSIM1,
 723                 RSND_MOD_SSIM2,
 724                 RSND_MOD_SSIM3,
 725         };
 726         enum rsnd_mod_type type;
 727         int i;
 728
 729         /* try SSI -> SSIM1 -> SSIM2 -> SSIM3 */
 730         for (i = 0; i < ARRAY_SIZE(types); i++) {
 731                 type = types[i];
 732                 if (!rsnd_io_to_mod(io, type)) {
 733                         rsnd_dai_connect(mod, io, type);
 734                         rsnd_set_slot(rdai, 2 * (i + 1), (i + 1));
 735                         return;
 736                 }
 737         }
 738 }
 739
 740 void rsnd_parse_connect_ssi(struct rsnd_dai *rdai,
 741                             struct device_node *playback,
 742                             struct device_node *capture)
 743 {
 744         struct rsnd_priv *priv = rsnd_rdai_to_priv(rdai);
 745         struct device_node *node;
 746         struct device_node *np;
 747         struct rsnd_mod *mod;
 748         int i;
 749
 750         node = rsnd_ssi_of_node(priv);
 751         if (!node)
 752                 return;
 753
 754         i = 0;
 755         for_each_child_of_node(node, np) {
 756                 mod = rsnd_ssi_mod_get(priv, i);
 757                 if (np == playback)
 758                         rsnd_ssi_connect(mod, &rdai->playback);
 759                 if (np == capture)
 760                         rsnd_ssi_connect(mod, &rdai->capture);
 761                 i++;
 762         }
 763
 764         of_node_put(node);
 765 }
 766
 767 struct rsnd_mod *rsnd_ssi_mod_get(struct rsnd_priv *priv, int id)
 768 {
 769         if (WARN_ON(id < 0 || id >= rsnd_ssi_nr(priv)))
 770                 id = 0;
 771
 772         return rsnd_mod_get(rsnd_ssi_get(priv, id));
 773 }
 774
 775 int __rsnd_ssi_is_pin_sharing(struct rsnd_mod *mod)
 776 {
 777         struct rsnd_ssi *ssi = rsnd_mod_to_ssi(mod);
 778
 779         return !!(rsnd_ssi_mode_flags(ssi) & RSND_SSI_CLK_PIN_SHARE);
 780 }
 781
 782 static u32 *rsnd_ssi_get_status(struct rsnd_dai_stream *io,
 783                                 struct rsnd_mod *mod,
 784                                 enum rsnd_mod_type type)
 785 {
 786         /*
 787          * SSIP (= SSI parent) needs to be special, otherwise,
 788          * 2nd SSI might doesn't start. see also rsnd_mod_call()
 789          *
 790          * We can't include parent SSI status on SSI, because we don't know
 791          * how many SSI requests parent SSI. Thus, it is localed on "io" now.
 792          * ex) trouble case
 793          *      Playback: SSI0
 794          *      Capture : SSI1 (needs SSI0)
 795          *
 796          * 1) start Capture  -> SSI0/SSI1 are started.
 797          * 2) start Playback -> SSI0 doesn't work, because it is already
 798          *                      marked as "started" on 1)
 799          *
 800          * OTOH, using each mod's status is good for MUX case.
 801          * It doesn't need to start in 2nd start
 802          * ex)
 803          *      IO-0: SRC0 -> CTU1 -+-> MUX -> DVC -> SSIU -> SSI0
 804          *                          |
 805          *      IO-1: SRC1 -> CTU2 -+
 806          *
 807          * 1) start IO-0 ->     start SSI0
 808          * 2) start IO-1 ->     SSI0 doesn't need to start, because it is
 809          *                      already started on 1)
 810          */
 811         if (type == RSND_MOD_SSIP)
 812                 return &io->parent_ssi_status;
 813
 814         return rsnd_mod_get_status(io, mod, type);
 815 }
 816
 817 int rsnd_ssi_probe(struct rsnd_priv *priv)
 818 {
 819         struct device_node *node;
 820         struct device_node *np;
 821         struct device *dev = rsnd_priv_to_dev(priv);
 822         struct rsnd_mod_ops *ops;
 823         struct clk *clk;
 824         struct rsnd_ssi *ssi;
 825         char name[RSND_SSI_NAME_SIZE];
 826         int i, nr, ret;
 827
 828         node = rsnd_ssi_of_node(priv);
 829         if (!node)
 830                 return -EINVAL;
 831
 832         nr = of_get_child_count(node);
 833         if (!nr) {
 834                 ret = -EINVAL;
 835                 goto rsnd_ssi_probe_done;
 836         }
 837
 838         ssi     = devm_kzalloc(dev, sizeof(*ssi) * nr, GFP_KERNEL);
 839         if (!ssi) {
 840                 ret = -ENOMEM;
 841                 goto rsnd_ssi_probe_done;
 842         }
 843
 844         priv->ssi       = ssi;
 845         priv->ssi_nr    = nr;
 846
 847         i = 0;
 848         for_each_child_of_node(node, np) {
 849                 ssi = rsnd_ssi_get(priv, i);
 850
 851                 snprintf(name, RSND_SSI_NAME_SIZE, "%s.%d",
 852                          SSI_NAME, i);
 853
 854                 clk = devm_clk_get(dev, name);
 855                 if (IS_ERR(clk)) {
 856                         ret = PTR_ERR(clk);
 857                         goto rsnd_ssi_probe_done;
 858                 }
 859
 860                 if (of_get_property(np, "shared-pin", NULL))
 861                         ssi->flags |= RSND_SSI_CLK_PIN_SHARE;
 862
 863                 if (of_get_property(np, "no-busif", NULL))
 864                         ssi->flags |= RSND_SSI_NO_BUSIF;
 865
 866                 ssi->irq = irq_of_parse_and_map(np, 0);
 867                 if (!ssi->irq) {
 868                         ret = -EINVAL;
 869                         goto rsnd_ssi_probe_done;
 870                 }
 871
 872                 ops = &rsnd_ssi_non_ops;
 873                 if (of_get_property(np, "pio-transfer", NULL))
 874                         ops = &rsnd_ssi_pio_ops;
 875                 else
 876                         ops = &rsnd_ssi_dma_ops;
 877
 878                 ret = rsnd_mod_init(priv, rsnd_mod_get(ssi), ops, clk,
 879                                     rsnd_ssi_get_status, RSND_MOD_SSI, i);
 880                 if (ret)
 881                         goto rsnd_ssi_probe_done;
 882
 883                 i++;
 884         }
 885
 886         ret = 0;
 887
 888 rsnd_ssi_probe_done:
 889         of_node_put(node);
 890
 891         return ret;
 892 }
 893
 894 void rsnd_ssi_remove(struct rsnd_priv *priv)
 895 {
 896         struct rsnd_ssi *ssi;
 897         int i;
 898
 899         for_each_rsnd_ssi(ssi, priv, i) {
 900                 rsnd_mod_quit(rsnd_mod_get(ssi));
 901         }
 902 }