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