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