sound/soc/sh/fsi.c

   1 /*
   2  * Fifo-attached Serial Interface (FSI) support for SH7724
   3  *
   4  * Copyright (C) 2009 Renesas Solutions Corp.
   5  * Kuninori Morimoto <morimoto.kuninori@renesas.com>
   6  *
   7  * Based on ssi.c
   8  * Copyright (c) 2007 Manuel Lauss <mano@roarinelk.homelinux.net>
   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
  15 #include <linux/delay.h>
  16 #include <linux/dma-mapping.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/io.h>
  19 #include <linux/scatterlist.h>
  20 #include <linux/sh_dma.h>
  21 #include <linux/slab.h>
  22 #include <linux/module.h>
  23 #include <sound/soc.h>
  24 #include <sound/sh_fsi.h>
  25
  26 /* PortA/PortB register */
  27 #define REG_DO_FMT      0x0000
  28 #define REG_DOFF_CTL    0x0004
  29 #define REG_DOFF_ST     0x0008
  30 #define REG_DI_FMT      0x000C
  31 #define REG_DIFF_CTL    0x0010
  32 #define REG_DIFF_ST     0x0014
  33 #define REG_CKG1        0x0018
  34 #define REG_CKG2        0x001C
  35 #define REG_DIDT        0x0020
  36 #define REG_DODT        0x0024
  37 #define REG_MUTE_ST     0x0028
  38 #define REG_OUT_DMAC    0x002C
  39 #define REG_OUT_SEL     0x0030
  40 #define REG_IN_DMAC     0x0038
  41
  42 /* master register */
  43 #define MST_CLK_RST     0x0210
  44 #define MST_SOFT_RST    0x0214
  45 #define MST_FIFO_SZ     0x0218
  46
  47 /* core register (depend on FSI version) */
  48 #define A_MST_CTLR      0x0180
  49 #define B_MST_CTLR      0x01A0
  50 #define CPU_INT_ST      0x01F4
  51 #define CPU_IEMSK       0x01F8
  52 #define CPU_IMSK        0x01FC
  53 #define INT_ST          0x0200
  54 #define IEMSK           0x0204
  55 #define IMSK            0x0208
  56
  57 /* DO_FMT */
  58 /* DI_FMT */
  59 #define CR_BWS_MASK     (0x3 << 20) /* FSI2 */
  60 #define CR_BWS_24       (0x0 << 20) /* FSI2 */
  61 #define CR_BWS_16       (0x1 << 20) /* FSI2 */
  62 #define CR_BWS_20       (0x2 << 20) /* FSI2 */
  63
  64 #define CR_DTMD_PCM             (0x0 << 8) /* FSI2 */
  65 #define CR_DTMD_SPDIF_PCM       (0x1 << 8) /* FSI2 */
  66 #define CR_DTMD_SPDIF_STREAM    (0x2 << 8) /* FSI2 */
  67
  68 #define CR_MONO         (0x0 << 4)
  69 #define CR_MONO_D       (0x1 << 4)
  70 #define CR_PCM          (0x2 << 4)
  71 #define CR_I2S          (0x3 << 4)
  72 #define CR_TDM          (0x4 << 4)
  73 #define CR_TDM_D        (0x5 << 4)
  74
  75 /* OUT_DMAC */
  76 /* IN_DMAC */
  77 #define VDMD_MASK       (0x3 << 4)
  78 #define VDMD_FRONT      (0x0 << 4) /* Package in front */
  79 #define VDMD_BACK       (0x1 << 4) /* Package in back */
  80 #define VDMD_STREAM     (0x2 << 4) /* Stream mode(16bit * 2) */
  81
  82 #define DMA_ON          (0x1 << 0)
  83
  84 /* DOFF_CTL */
  85 /* DIFF_CTL */
  86 #define IRQ_HALF        0x00100000
  87 #define FIFO_CLR        0x00000001
  88
  89 /* DOFF_ST */
  90 #define ERR_OVER        0x00000010
  91 #define ERR_UNDER       0x00000001
  92 #define ST_ERR          (ERR_OVER | ERR_UNDER)
  93
  94 /* CKG1 */
  95 #define ACKMD_MASK      0x00007000
  96 #define BPFMD_MASK      0x00000700
  97 #define DIMD            (1 << 4)
  98 #define DOMD            (1 << 0)
  99
 100 /* A/B MST_CTLR */
 101 #define BP      (1 << 4)        /* Fix the signal of Biphase output */
 102 #define SE      (1 << 0)        /* Fix the master clock */
 103
 104 /* CLK_RST */
 105 #define CRB     (1 << 4)
 106 #define CRA     (1 << 0)
 107
 108 /* IO SHIFT / MACRO */
 109 #define BI_SHIFT        12
 110 #define BO_SHIFT        8
 111 #define AI_SHIFT        4
 112 #define AO_SHIFT        0
 113 #define AB_IO(param, shift)     (param << shift)
 114
 115 /* SOFT_RST */
 116 #define PBSR            (1 << 12) /* Port B Software Reset */
 117 #define PASR            (1 <<  8) /* Port A Software Reset */
 118 #define IR              (1 <<  4) /* Interrupt Reset */
 119 #define FSISR           (1 <<  0) /* Software Reset */
 120
 121 /* OUT_SEL (FSI2) */
 122 #define DMMD            (1 << 4) /* SPDIF output timing 0: Biphase only */
 123                                  /*                     1: Biphase and serial */
 124
 125 /* FIFO_SZ */
 126 #define FIFO_SZ_MASK    0x7
 127
 128 #define FSI_RATES SNDRV_PCM_RATE_8000_96000
 129
 130 #define FSI_FMTS (SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S16_LE)
 131
 132 typedef int (*set_rate_func)(struct device *dev, int rate, int enable);
 133
 134 /*
 135  * FSI driver use below type name for variable
 136  *
 137  * xxx_num      : number of data
 138  * xxx_pos      : position of data
 139  * xxx_capa     : capacity of data
 140  */
 141
 142 /*
 143  *      period/frame/sample image
 144  *
 145  * ex) PCM (2ch)
 146  *
 147  * period pos                                      period pos
 148  *   [n]                                             [n + 1]
 149  *   |<-------------------- period--------------------->|
 150  * ==|============================================ ... =|==
 151  *   |                                                  |
 152  *   ||<-----  frame ----->|<------ frame ----->|  ...  |
 153  *   |+--------------------+--------------------+- ...  |
 154  *   ||[ sample ][ sample ]|[ sample ][ sample ]|  ...  |
 155  *   |+--------------------+--------------------+- ...  |
 156  * ==|============================================ ... =|==
 157  */
 158
 159 /*
 160  *      FSI FIFO image
 161  *
 162  *      |            |
 163  *      |            |
 164  *      | [ sample ] |
 165  *      | [ sample ] |
 166  *      | [ sample ] |
 167  *      | [ sample ] |
 168  *              --> go to codecs
 169  */
 170
 171 /*
 172  *              struct
 173  */
 174
 175 struct fsi_stream_handler;
 176 struct fsi_stream {
 177
 178         /*
 179          * these are initialized by fsi_stream_init()
 180          */
 181         struct snd_pcm_substream *substream;
 182         int fifo_sample_capa;   /* sample capacity of FSI FIFO */
 183         int buff_sample_capa;   /* sample capacity of ALSA buffer */
 184         int buff_sample_pos;    /* sample position of ALSA buffer */
 185         int period_samples;     /* sample number / 1 period */
 186         int period_pos;         /* current period position */
 187         int sample_width;       /* sample width */
 188         int uerr_num;
 189         int oerr_num;
 190
 191         /*
 192          * thse are initialized by fsi_handler_init()
 193          */
 194         struct fsi_stream_handler *handler;
 195         struct fsi_priv         *priv;
 196
 197         /*
 198          * these are for DMAEngine
 199          */
 200         struct dma_chan         *chan;
 201         struct sh_dmae_slave    slave; /* see fsi_handler_init() */
 202         struct tasklet_struct   tasklet;
 203         dma_addr_t              dma;
 204 };
 205
 206 struct fsi_priv {
 207         void __iomem *base;
 208         struct fsi_master *master;
 209         struct sh_fsi_port_info *info;
 210
 211         struct fsi_stream playback;
 212         struct fsi_stream capture;
 213
 214         u32 do_fmt;
 215         u32 di_fmt;
 216
 217         int chan_num:16;
 218         int clk_master:1;
 219         int spdif:1;
 220
 221         long rate;
 222 };
 223
 224 struct fsi_stream_handler {
 225         int (*init)(struct fsi_priv *fsi, struct fsi_stream *io);
 226         int (*quit)(struct fsi_priv *fsi, struct fsi_stream *io);
 227         int (*probe)(struct fsi_priv *fsi, struct fsi_stream *io);
 228         int (*transfer)(struct fsi_priv *fsi, struct fsi_stream *io);
 229         int (*remove)(struct fsi_priv *fsi, struct fsi_stream *io);
 230         void (*start_stop)(struct fsi_priv *fsi, struct fsi_stream *io,
 231                            int enable);
 232 };
 233 #define fsi_stream_handler_call(io, func, args...)      \
 234         (!(io) ? -ENODEV :                              \
 235          !((io)->handler->func) ? 0 :                   \
 236          (io)->handler->func(args))
 237
 238 struct fsi_core {
 239         int ver;
 240
 241         u32 int_st;
 242         u32 iemsk;
 243         u32 imsk;
 244         u32 a_mclk;
 245         u32 b_mclk;
 246 };
 247
 248 struct fsi_master {
 249         void __iomem *base;
 250         int irq;
 251         struct fsi_priv fsia;
 252         struct fsi_priv fsib;
 253         struct fsi_core *core;
 254         spinlock_t lock;
 255 };
 256
 257 static int fsi_stream_is_play(struct fsi_priv *fsi, struct fsi_stream *io);
 258
 259 /*
 260  *              basic read write function
 261  */
 262
 263 static void __fsi_reg_write(u32 __iomem *reg, u32 data)
 264 {
 265         /* valid data area is 24bit */
 266         data &= 0x00ffffff;
 267
 268         __raw_writel(data, reg);
 269 }
 270
 271 static u32 __fsi_reg_read(u32 __iomem *reg)
 272 {
 273         return __raw_readl(reg);
 274 }
 275
 276 static void __fsi_reg_mask_set(u32 __iomem *reg, u32 mask, u32 data)
 277 {
 278         u32 val = __fsi_reg_read(reg);
 279
 280         val &= ~mask;
 281         val |= data & mask;
 282
 283         __fsi_reg_write(reg, val);
 284 }
 285
 286 #define fsi_reg_write(p, r, d)\
 287         __fsi_reg_write((p->base + REG_##r), d)
 288
 289 #define fsi_reg_read(p, r)\
 290         __fsi_reg_read((p->base + REG_##r))
 291
 292 #define fsi_reg_mask_set(p, r, m, d)\
 293         __fsi_reg_mask_set((p->base + REG_##r), m, d)
 294
 295 #define fsi_master_read(p, r) _fsi_master_read(p, MST_##r)
 296 #define fsi_core_read(p, r)   _fsi_master_read(p, p->core->r)
 297 static u32 _fsi_master_read(struct fsi_master *master, u32 reg)
 298 {
 299         u32 ret;
 300         unsigned long flags;
 301
 302         spin_lock_irqsave(&master->lock, flags);
 303         ret = __fsi_reg_read(master->base + reg);
 304         spin_unlock_irqrestore(&master->lock, flags);
 305
 306         return ret;
 307 }
 308
 309 #define fsi_master_mask_set(p, r, m, d) _fsi_master_mask_set(p, MST_##r, m, d)
 310 #define fsi_core_mask_set(p, r, m, d)  _fsi_master_mask_set(p, p->core->r, m, d)
 311 static void _fsi_master_mask_set(struct fsi_master *master,
 312                                u32 reg, u32 mask, u32 data)
 313 {
 314         unsigned long flags;
 315
 316         spin_lock_irqsave(&master->lock, flags);
 317         __fsi_reg_mask_set(master->base + reg, mask, data);
 318         spin_unlock_irqrestore(&master->lock, flags);
 319 }
 320
 321 /*
 322  *              basic function
 323  */
 324
 325 static struct fsi_master *fsi_get_master(struct fsi_priv *fsi)
 326 {
 327         return fsi->master;
 328 }
 329
 330 static int fsi_is_clk_master(struct fsi_priv *fsi)
 331 {
 332         return fsi->clk_master;
 333 }
 334
 335 static int fsi_is_port_a(struct fsi_priv *fsi)
 336 {
 337         return fsi->master->base == fsi->base;
 338 }
 339
 340 static int fsi_is_spdif(struct fsi_priv *fsi)
 341 {
 342         return fsi->spdif;
 343 }
 344
 345 static int fsi_is_play(struct snd_pcm_substream *substream)
 346 {
 347         return substream->stream == SNDRV_PCM_STREAM_PLAYBACK;
 348 }
 349
 350 static struct snd_soc_dai *fsi_get_dai(struct snd_pcm_substream *substream)
 351 {
 352         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 353
 354         return  rtd->cpu_dai;
 355 }
 356
 357 static struct fsi_priv *fsi_get_priv_frm_dai(struct snd_soc_dai *dai)
 358 {
 359         struct fsi_master *master = snd_soc_dai_get_drvdata(dai);
 360
 361         if (dai->id == 0)
 362                 return &master->fsia;
 363         else
 364                 return &master->fsib;
 365 }
 366
 367 static struct fsi_priv *fsi_get_priv(struct snd_pcm_substream *substream)
 368 {
 369         return fsi_get_priv_frm_dai(fsi_get_dai(substream));
 370 }
 371
 372 static set_rate_func fsi_get_info_set_rate(struct fsi_priv *fsi)
 373 {
 374         if (!fsi->info)
 375                 return NULL;
 376
 377         return fsi->info->set_rate;
 378 }
 379
 380 static u32 fsi_get_info_flags(struct fsi_priv *fsi)
 381 {
 382         if (!fsi->info)
 383                 return 0;
 384
 385         return fsi->info->flags;
 386 }
 387
 388 static u32 fsi_get_port_shift(struct fsi_priv *fsi, struct fsi_stream *io)
 389 {
 390         int is_play = fsi_stream_is_play(fsi, io);
 391         int is_porta = fsi_is_port_a(fsi);
 392         u32 shift;
 393
 394         if (is_porta)
 395                 shift = is_play ? AO_SHIFT : AI_SHIFT;
 396         else
 397                 shift = is_play ? BO_SHIFT : BI_SHIFT;
 398
 399         return shift;
 400 }
 401
 402 static int fsi_frame2sample(struct fsi_priv *fsi, int frames)
 403 {
 404         return frames * fsi->chan_num;
 405 }
 406
 407 static int fsi_sample2frame(struct fsi_priv *fsi, int samples)
 408 {
 409         return samples / fsi->chan_num;
 410 }
 411
 412 static int fsi_get_current_fifo_samples(struct fsi_priv *fsi,
 413                                         struct fsi_stream *io)
 414 {
 415         int is_play = fsi_stream_is_play(fsi, io);
 416         u32 status;
 417         int frames;
 418
 419         status = is_play ?
 420                 fsi_reg_read(fsi, DOFF_ST) :
 421                 fsi_reg_read(fsi, DIFF_ST);
 422
 423         frames = 0x1ff & (status >> 8);
 424
 425         return fsi_frame2sample(fsi, frames);
 426 }
 427
 428 static void fsi_count_fifo_err(struct fsi_priv *fsi)
 429 {
 430         u32 ostatus = fsi_reg_read(fsi, DOFF_ST);
 431         u32 istatus = fsi_reg_read(fsi, DIFF_ST);
 432
 433         if (ostatus & ERR_OVER)
 434                 fsi->playback.oerr_num++;
 435
 436         if (ostatus & ERR_UNDER)
 437                 fsi->playback.uerr_num++;
 438
 439         if (istatus & ERR_OVER)
 440                 fsi->capture.oerr_num++;
 441
 442         if (istatus & ERR_UNDER)
 443                 fsi->capture.uerr_num++;
 444
 445         fsi_reg_write(fsi, DOFF_ST, 0);
 446         fsi_reg_write(fsi, DIFF_ST, 0);
 447 }
 448
 449 /*
 450  *              fsi_stream_xx() function
 451  */
 452 static inline int fsi_stream_is_play(struct fsi_priv *fsi,
 453                                      struct fsi_stream *io)
 454 {
 455         return &fsi->playback == io;
 456 }
 457
 458 static inline struct fsi_stream *fsi_stream_get(struct fsi_priv *fsi,
 459                                         struct snd_pcm_substream *substream)
 460 {
 461         return fsi_is_play(substream) ? &fsi->playback : &fsi->capture;
 462 }
 463
 464 static int fsi_stream_is_working(struct fsi_priv *fsi,
 465                                  struct fsi_stream *io)
 466 {
 467         struct fsi_master *master = fsi_get_master(fsi);
 468         unsigned long flags;
 469         int ret;
 470
 471         spin_lock_irqsave(&master->lock, flags);
 472         ret = !!(io->substream && io->substream->runtime);
 473         spin_unlock_irqrestore(&master->lock, flags);
 474
 475         return ret;
 476 }
 477
 478 static struct fsi_priv *fsi_stream_to_priv(struct fsi_stream *io)
 479 {
 480         return io->priv;
 481 }
 482
 483 static void fsi_stream_init(struct fsi_priv *fsi,
 484                             struct fsi_stream *io,
 485                             struct snd_pcm_substream *substream)
 486 {
 487         struct snd_pcm_runtime *runtime = substream->runtime;
 488         struct fsi_master *master = fsi_get_master(fsi);
 489         unsigned long flags;
 490
 491         spin_lock_irqsave(&master->lock, flags);
 492         io->substream   = substream;
 493         io->buff_sample_capa    = fsi_frame2sample(fsi, runtime->buffer_size);
 494         io->buff_sample_pos     = 0;
 495         io->period_samples      = fsi_frame2sample(fsi, runtime->period_size);
 496         io->period_pos          = 0;
 497         io->sample_width        = samples_to_bytes(runtime, 1);
 498         io->oerr_num    = -1; /* ignore 1st err */
 499         io->uerr_num    = -1; /* ignore 1st err */
 500         fsi_stream_handler_call(io, init, fsi, io);
 501         spin_unlock_irqrestore(&master->lock, flags);
 502 }
 503
 504 static void fsi_stream_quit(struct fsi_priv *fsi, struct fsi_stream *io)
 505 {
 506         struct snd_soc_dai *dai = fsi_get_dai(io->substream);
 507         struct fsi_master *master = fsi_get_master(fsi);
 508         unsigned long flags;
 509
 510         spin_lock_irqsave(&master->lock, flags);
 511
 512         if (io->oerr_num > 0)
 513                 dev_err(dai->dev, "over_run = %d\n", io->oerr_num);
 514
 515         if (io->uerr_num > 0)
 516                 dev_err(dai->dev, "under_run = %d\n", io->uerr_num);
 517
 518         fsi_stream_handler_call(io, quit, fsi, io);
 519         io->substream   = NULL;
 520         io->buff_sample_capa    = 0;
 521         io->buff_sample_pos     = 0;
 522         io->period_samples      = 0;
 523         io->period_pos          = 0;
 524         io->sample_width        = 0;
 525         io->oerr_num    = 0;
 526         io->uerr_num    = 0;
 527         spin_unlock_irqrestore(&master->lock, flags);
 528 }
 529
 530 static int fsi_stream_transfer(struct fsi_stream *io)
 531 {
 532         struct fsi_priv *fsi = fsi_stream_to_priv(io);
 533         if (!fsi)
 534                 return -EIO;
 535
 536         return fsi_stream_handler_call(io, transfer, fsi, io);
 537 }
 538
 539 #define fsi_stream_start(fsi, io)\
 540         fsi_stream_handler_call(io, start_stop, fsi, io, 1)
 541
 542 #define fsi_stream_stop(fsi, io)\
 543         fsi_stream_handler_call(io, start_stop, fsi, io, 0)
 544
 545 static int fsi_stream_probe(struct fsi_priv *fsi)
 546 {
 547         struct fsi_stream *io;
 548         int ret1, ret2;
 549
 550         io = &fsi->playback;
 551         ret1 = fsi_stream_handler_call(io, probe, fsi, io);
 552
 553         io = &fsi->capture;
 554         ret2 = fsi_stream_handler_call(io, probe, fsi, io);
 555
 556         if (ret1 < 0)
 557                 return ret1;
 558         if (ret2 < 0)
 559                 return ret2;
 560
 561         return 0;
 562 }
 563
 564 static int fsi_stream_remove(struct fsi_priv *fsi)
 565 {
 566         struct fsi_stream *io;
 567         int ret1, ret2;
 568
 569         io = &fsi->playback;
 570         ret1 = fsi_stream_handler_call(io, remove, fsi, io);
 571
 572         io = &fsi->capture;
 573         ret2 = fsi_stream_handler_call(io, remove, fsi, io);
 574
 575         if (ret1 < 0)
 576                 return ret1;
 577         if (ret2 < 0)
 578                 return ret2;
 579
 580         return 0;
 581 }
 582
 583 /*
 584  *              irq function
 585  */
 586
 587 static void fsi_irq_enable(struct fsi_priv *fsi, struct fsi_stream *io)
 588 {
 589         u32 data = AB_IO(1, fsi_get_port_shift(fsi, io));
 590         struct fsi_master *master = fsi_get_master(fsi);
 591
 592         fsi_core_mask_set(master, imsk,  data, data);
 593         fsi_core_mask_set(master, iemsk, data, data);
 594 }
 595
 596 static void fsi_irq_disable(struct fsi_priv *fsi, struct fsi_stream *io)
 597 {
 598         u32 data = AB_IO(1, fsi_get_port_shift(fsi, io));
 599         struct fsi_master *master = fsi_get_master(fsi);
 600
 601         fsi_core_mask_set(master, imsk,  data, 0);
 602         fsi_core_mask_set(master, iemsk, data, 0);
 603 }
 604
 605 static u32 fsi_irq_get_status(struct fsi_master *master)
 606 {
 607         return fsi_core_read(master, int_st);
 608 }
 609
 610 static void fsi_irq_clear_status(struct fsi_priv *fsi)
 611 {
 612         u32 data = 0;
 613         struct fsi_master *master = fsi_get_master(fsi);
 614
 615         data |= AB_IO(1, fsi_get_port_shift(fsi, &fsi->playback));
 616         data |= AB_IO(1, fsi_get_port_shift(fsi, &fsi->capture));
 617
 618         /* clear interrupt factor */
 619         fsi_core_mask_set(master, int_st, data, 0);
 620 }
 621
 622 /*
 623  *              SPDIF master clock function
 624  *
 625  * These functions are used later FSI2
 626  */
 627 static void fsi_spdif_clk_ctrl(struct fsi_priv *fsi, int enable)
 628 {
 629         struct fsi_master *master = fsi_get_master(fsi);
 630         u32 mask, val;
 631
 632         if (master->core->ver < 2) {
 633                 pr_err("fsi: register access err (%s)\n", __func__);
 634                 return;
 635         }
 636
 637         mask = BP | SE;
 638         val = enable ? mask : 0;
 639
 640         fsi_is_port_a(fsi) ?
 641                 fsi_core_mask_set(master, a_mclk, mask, val) :
 642                 fsi_core_mask_set(master, b_mclk, mask, val);
 643 }
 644
 645 /*
 646  *              clock function
 647  */
 648 static int fsi_set_master_clk(struct device *dev, struct fsi_priv *fsi,
 649                               long rate, int enable)
 650 {
 651         struct fsi_master *master = fsi_get_master(fsi);
 652         set_rate_func set_rate = fsi_get_info_set_rate(fsi);
 653         int fsi_ver = master->core->ver;
 654         int ret;
 655
 656         if (!set_rate)
 657                 return 0;
 658
 659         ret = set_rate(dev, rate, enable);
 660         if (ret < 0) /* error */
 661                 return ret;
 662
 663         if (!enable)
 664                 return 0;
 665
 666         if (ret > 0) {
 667                 u32 data = 0;
 668
 669                 switch (ret & SH_FSI_ACKMD_MASK) {
 670                 default:
 671                         /* FALL THROUGH */
 672                 case SH_FSI_ACKMD_512:
 673                         data |= (0x0 << 12);
 674                         break;
 675                 case SH_FSI_ACKMD_256:
 676                         data |= (0x1 << 12);
 677                         break;
 678                 case SH_FSI_ACKMD_128:
 679                         data |= (0x2 << 12);
 680                         break;
 681                 case SH_FSI_ACKMD_64:
 682                         data |= (0x3 << 12);
 683                         break;
 684                 case SH_FSI_ACKMD_32:
 685                         if (fsi_ver < 2)
 686                                 dev_err(dev, "unsupported ACKMD\n");
 687                         else
 688                                 data |= (0x4 << 12);
 689                         break;
 690                 }
 691
 692                 switch (ret & SH_FSI_BPFMD_MASK) {
 693                 default:
 694                         /* FALL THROUGH */
 695                 case SH_FSI_BPFMD_32:
 696                         data |= (0x0 << 8);
 697                         break;
 698                 case SH_FSI_BPFMD_64:
 699                         data |= (0x1 << 8);
 700                         break;
 701                 case SH_FSI_BPFMD_128:
 702                         data |= (0x2 << 8);
 703                         break;
 704                 case SH_FSI_BPFMD_256:
 705                         data |= (0x3 << 8);
 706                         break;
 707                 case SH_FSI_BPFMD_512:
 708                         data |= (0x4 << 8);
 709                         break;
 710                 case SH_FSI_BPFMD_16:
 711                         if (fsi_ver < 2)
 712                                 dev_err(dev, "unsupported ACKMD\n");
 713                         else
 714                                 data |= (0x7 << 8);
 715                         break;
 716                 }
 717
 718                 fsi_reg_mask_set(fsi, CKG1, (ACKMD_MASK | BPFMD_MASK) , data);
 719                 udelay(10);
 720                 ret = 0;
 721         }
 722
 723         return ret;
 724 }
 725
 726 /*
 727  *              pio data transfer handler
 728  */
 729 static void fsi_pio_push16(struct fsi_priv *fsi, u8 *_buf, int samples)
 730 {
 731         u16 *buf = (u16 *)_buf;
 732         int i;
 733
 734         for (i = 0; i < samples; i++)
 735                 fsi_reg_write(fsi, DODT, ((u32)*(buf + i) << 8));
 736 }
 737
 738 static void fsi_pio_pop16(struct fsi_priv *fsi, u8 *_buf, int samples)
 739 {
 740         u16 *buf = (u16 *)_buf;
 741         int i;
 742
 743         for (i = 0; i < samples; i++)
 744                 *(buf + i) = (u16)(fsi_reg_read(fsi, DIDT) >> 8);
 745 }
 746
 747 static void fsi_pio_push32(struct fsi_priv *fsi, u8 *_buf, int samples)
 748 {
 749         u32 *buf = (u32 *)_buf;
 750         int i;
 751
 752         for (i = 0; i < samples; i++)
 753                 fsi_reg_write(fsi, DODT, *(buf + i));
 754 }
 755
 756 static void fsi_pio_pop32(struct fsi_priv *fsi, u8 *_buf, int samples)
 757 {
 758         u32 *buf = (u32 *)_buf;
 759         int i;
 760
 761         for (i = 0; i < samples; i++)
 762                 *(buf + i) = fsi_reg_read(fsi, DIDT);
 763 }
 764
 765 static u8 *fsi_pio_get_area(struct fsi_priv *fsi, struct fsi_stream *io)
 766 {
 767         struct snd_pcm_runtime *runtime = io->substream->runtime;
 768
 769         return runtime->dma_area +
 770                 samples_to_bytes(runtime, io->buff_sample_pos);
 771 }
 772
 773 static int fsi_pio_transfer(struct fsi_priv *fsi, struct fsi_stream *io,
 774                 void (*run16)(struct fsi_priv *fsi, u8 *buf, int samples),
 775                 void (*run32)(struct fsi_priv *fsi, u8 *buf, int samples),
 776                 int samples)
 777 {
 778         struct snd_pcm_runtime *runtime;
 779         struct snd_pcm_substream *substream;
 780         u8 *buf;
 781         int over_period;
 782
 783         if (!fsi_stream_is_working(fsi, io))
 784                 return -EINVAL;
 785
 786         over_period     = 0;
 787         substream       = io->substream;
 788         runtime         = substream->runtime;
 789
 790         /* FSI FIFO has limit.
 791          * So, this driver can not send periods data at a time
 792          */
 793         if (io->buff_sample_pos >=
 794             io->period_samples * (io->period_pos + 1)) {
 795
 796                 over_period = 1;
 797                 io->period_pos = (io->period_pos + 1) % runtime->periods;
 798
 799                 if (0 == io->period_pos)
 800                         io->buff_sample_pos = 0;
 801         }
 802
 803         buf = fsi_pio_get_area(fsi, io);
 804
 805         switch (io->sample_width) {
 806         case 2:
 807                 run16(fsi, buf, samples);
 808                 break;
 809         case 4:
 810                 run32(fsi, buf, samples);
 811                 break;
 812         default:
 813                 return -EINVAL;
 814         }
 815
 816         /* update buff_sample_pos */
 817         io->buff_sample_pos += samples;
 818
 819         if (over_period)
 820                 snd_pcm_period_elapsed(substream);
 821
 822         return 0;
 823 }
 824
 825 static int fsi_pio_pop(struct fsi_priv *fsi, struct fsi_stream *io)
 826 {
 827         int sample_residues;    /* samples in FSI fifo */
 828         int sample_space;       /* ALSA free samples space */
 829         int samples;
 830
 831         sample_residues = fsi_get_current_fifo_samples(fsi, io);
 832         sample_space    = io->buff_sample_capa - io->buff_sample_pos;
 833
 834         samples = min(sample_residues, sample_space);
 835
 836         return fsi_pio_transfer(fsi, io,
 837                                   fsi_pio_pop16,
 838                                   fsi_pio_pop32,
 839                                   samples);
 840 }
 841
 842 static int fsi_pio_push(struct fsi_priv *fsi, struct fsi_stream *io)
 843 {
 844         int sample_residues;    /* ALSA residue samples */
 845         int sample_space;       /* FSI fifo free samples space */
 846         int samples;
 847
 848         sample_residues = io->buff_sample_capa - io->buff_sample_pos;
 849         sample_space    = io->fifo_sample_capa -
 850                 fsi_get_current_fifo_samples(fsi, io);
 851
 852         samples = min(sample_residues, sample_space);
 853
 854         return fsi_pio_transfer(fsi, io,
 855                                   fsi_pio_push16,
 856                                   fsi_pio_push32,
 857                                   samples);
 858 }
 859
 860 static void fsi_pio_start_stop(struct fsi_priv *fsi, struct fsi_stream *io,
 861                                int enable)
 862 {
 863         struct fsi_master *master = fsi_get_master(fsi);
 864         u32 clk  = fsi_is_port_a(fsi) ? CRA  : CRB;
 865
 866         if (enable)
 867                 fsi_irq_enable(fsi, io);
 868         else
 869                 fsi_irq_disable(fsi, io);
 870
 871         if (fsi_is_clk_master(fsi))
 872                 fsi_master_mask_set(master, CLK_RST, clk, (enable) ? clk : 0);
 873 }
 874
 875 static struct fsi_stream_handler fsi_pio_push_handler = {
 876         .transfer       = fsi_pio_push,
 877         .start_stop     = fsi_pio_start_stop,
 878 };
 879
 880 static struct fsi_stream_handler fsi_pio_pop_handler = {
 881         .transfer       = fsi_pio_pop,
 882         .start_stop     = fsi_pio_start_stop,
 883 };
 884
 885 static irqreturn_t fsi_interrupt(int irq, void *data)
 886 {
 887         struct fsi_master *master = data;
 888         u32 int_st = fsi_irq_get_status(master);
 889
 890         /* clear irq status */
 891         fsi_master_mask_set(master, SOFT_RST, IR, 0);
 892         fsi_master_mask_set(master, SOFT_RST, IR, IR);
 893
 894         if (int_st & AB_IO(1, AO_SHIFT))
 895                 fsi_stream_transfer(&master->fsia.playback);
 896         if (int_st & AB_IO(1, BO_SHIFT))
 897                 fsi_stream_transfer(&master->fsib.playback);
 898         if (int_st & AB_IO(1, AI_SHIFT))
 899                 fsi_stream_transfer(&master->fsia.capture);
 900         if (int_st & AB_IO(1, BI_SHIFT))
 901                 fsi_stream_transfer(&master->fsib.capture);
 902
 903         fsi_count_fifo_err(&master->fsia);
 904         fsi_count_fifo_err(&master->fsib);
 905
 906         fsi_irq_clear_status(&master->fsia);
 907         fsi_irq_clear_status(&master->fsib);
 908
 909         return IRQ_HANDLED;
 910 }
 911
 912 /*
 913  *              dma data transfer handler
 914  */
 915 static int fsi_dma_init(struct fsi_priv *fsi, struct fsi_stream *io)
 916 {
 917         struct snd_pcm_runtime *runtime = io->substream->runtime;
 918         struct snd_soc_dai *dai = fsi_get_dai(io->substream);
 919         enum dma_data_direction dir = fsi_stream_is_play(fsi, io) ?
 920                                 DMA_TO_DEVICE : DMA_FROM_DEVICE;
 921
 922         io->dma = dma_map_single(dai->dev, runtime->dma_area,
 923                                  snd_pcm_lib_buffer_bytes(io->substream), dir);
 924         return 0;
 925 }
 926
 927 static int fsi_dma_quit(struct fsi_priv *fsi, struct fsi_stream *io)
 928 {
 929         struct snd_soc_dai *dai = fsi_get_dai(io->substream);
 930         enum dma_data_direction dir = fsi_stream_is_play(fsi, io) ?
 931                 DMA_TO_DEVICE : DMA_FROM_DEVICE;
 932
 933         dma_unmap_single(dai->dev, io->dma,
 934                          snd_pcm_lib_buffer_bytes(io->substream), dir);
 935         return 0;
 936 }
 937
 938 static void fsi_dma_complete(void *data)
 939 {
 940         struct fsi_stream *io = (struct fsi_stream *)data;
 941         struct fsi_priv *fsi = fsi_stream_to_priv(io);
 942         struct snd_pcm_runtime *runtime = io->substream->runtime;
 943         struct snd_soc_dai *dai = fsi_get_dai(io->substream);
 944         enum dma_data_direction dir = fsi_stream_is_play(fsi, io) ?
 945                 DMA_TO_DEVICE : DMA_FROM_DEVICE;
 946
 947         dma_sync_single_for_cpu(dai->dev, io->dma,
 948                         samples_to_bytes(runtime, io->period_samples), dir);
 949
 950         io->buff_sample_pos += io->period_samples;
 951         io->period_pos++;
 952
 953         if (io->period_pos >= runtime->periods) {
 954                 io->period_pos = 0;
 955                 io->buff_sample_pos = 0;
 956         }
 957
 958         fsi_count_fifo_err(fsi);
 959         fsi_stream_transfer(io);
 960
 961         snd_pcm_period_elapsed(io->substream);
 962 }
 963
 964 static dma_addr_t fsi_dma_get_area(struct fsi_stream *io)
 965 {
 966         struct snd_pcm_runtime *runtime = io->substream->runtime;
 967
 968         return io->dma + samples_to_bytes(runtime, io->buff_sample_pos);
 969 }
 970
 971 static void fsi_dma_do_tasklet(unsigned long data)
 972 {
 973         struct fsi_stream *io = (struct fsi_stream *)data;
 974         struct fsi_priv *fsi = fsi_stream_to_priv(io);
 975         struct dma_chan *chan;
 976         struct snd_soc_dai *dai;
 977         struct dma_async_tx_descriptor *desc;
 978         struct scatterlist sg;
 979         struct snd_pcm_runtime *runtime;
 980         enum dma_data_direction dir;
 981         dma_cookie_t cookie;
 982         int is_play = fsi_stream_is_play(fsi, io);
 983         int len;
 984         dma_addr_t buf;
 985
 986         if (!fsi_stream_is_working(fsi, io))
 987                 return;
 988
 989         dai     = fsi_get_dai(io->substream);
 990         chan    = io->chan;
 991         runtime = io->substream->runtime;
 992         dir     = is_play ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
 993         len     = samples_to_bytes(runtime, io->period_samples);
 994         buf     = fsi_dma_get_area(io);
 995
 996         dma_sync_single_for_device(dai->dev, io->dma, len, dir);
 997
 998         sg_init_table(&sg, 1);
 999         sg_set_page(&sg, pfn_to_page(PFN_DOWN(buf)),
1000                     len , offset_in_page(buf));
1001         sg_dma_address(&sg) = buf;
1002         sg_dma_len(&sg) = len;
1003
1004         desc = chan->device->device_prep_slave_sg(chan, &sg, 1, dir,
1005                                                   DMA_PREP_INTERRUPT |
1006                                                   DMA_CTRL_ACK);
1007         if (!desc) {
1008                 dev_err(dai->dev, "device_prep_slave_sg() fail\n");
1009                 return;
1010         }
1011
1012         desc->callback          = fsi_dma_complete;
1013         desc->callback_param    = io;
1014
1015         cookie = desc->tx_submit(desc);
1016         if (cookie < 0) {
1017                 dev_err(dai->dev, "tx_submit() fail\n");
1018                 return;
1019         }
1020
1021         dma_async_issue_pending(chan);
1022
1023         /*
1024          * FIXME
1025          *
1026          * In DMAEngine case, codec and FSI cannot be started simultaneously
1027          * since FSI is using tasklet.
1028          * Therefore, in capture case, probably FSI FIFO will have got
1029          * overflow error in this point.
1030          * in that case, DMA cannot start transfer until error was cleared.
1031          */
1032         if (!is_play) {
1033                 if (ERR_OVER & fsi_reg_read(fsi, DIFF_ST)) {
1034                         fsi_reg_mask_set(fsi, DIFF_CTL, FIFO_CLR, FIFO_CLR);
1035                         fsi_reg_write(fsi, DIFF_ST, 0);
1036                 }
1037         }
1038 }
1039
1040 static bool fsi_dma_filter(struct dma_chan *chan, void *param)
1041 {
1042         struct sh_dmae_slave *slave = param;
1043
1044         chan->private = slave;
1045
1046         return true;
1047 }
1048
1049 static int fsi_dma_transfer(struct fsi_priv *fsi, struct fsi_stream *io)
1050 {
1051         tasklet_schedule(&io->tasklet);
1052
1053         return 0;
1054 }
1055
1056 static void fsi_dma_push_start_stop(struct fsi_priv *fsi, struct fsi_stream *io,
1057                                  int start)
1058 {
1059         u32 bws;
1060         u32 dma;
1061
1062         switch (io->sample_width * start) {
1063         case 2:
1064                 bws = CR_BWS_16;
1065                 dma = VDMD_STREAM | DMA_ON;
1066                 break;
1067         case 4:
1068                 bws = CR_BWS_24;
1069                 dma = VDMD_BACK | DMA_ON;
1070                 break;
1071         default:
1072                 bws = 0;
1073                 dma = 0;
1074         }
1075
1076         fsi_reg_mask_set(fsi, DO_FMT, CR_BWS_MASK, bws);
1077         fsi_reg_write(fsi, OUT_DMAC, dma);
1078 }
1079
1080 static int fsi_dma_probe(struct fsi_priv *fsi, struct fsi_stream *io)
1081 {
1082         dma_cap_mask_t mask;
1083
1084         dma_cap_zero(mask);
1085         dma_cap_set(DMA_SLAVE, mask);
1086
1087         io->chan = dma_request_channel(mask, fsi_dma_filter, &io->slave);
1088         if (!io->chan)
1089                 return -EIO;
1090
1091         tasklet_init(&io->tasklet, fsi_dma_do_tasklet, (unsigned long)io);
1092
1093         return 0;
1094 }
1095
1096 static int fsi_dma_remove(struct fsi_priv *fsi, struct fsi_stream *io)
1097 {
1098         tasklet_kill(&io->tasklet);
1099
1100         fsi_stream_stop(fsi, io);
1101
1102         if (io->chan)
1103                 dma_release_channel(io->chan);
1104
1105         io->chan = NULL;
1106         return 0;
1107 }
1108
1109 static struct fsi_stream_handler fsi_dma_push_handler = {
1110         .init           = fsi_dma_init,
1111         .quit           = fsi_dma_quit,
1112         .probe          = fsi_dma_probe,
1113         .transfer       = fsi_dma_transfer,
1114         .remove         = fsi_dma_remove,
1115         .start_stop     = fsi_dma_push_start_stop,
1116 };
1117
1118 /*
1119  *              dai ops
1120  */
1121 static void fsi_fifo_init(struct fsi_priv *fsi,
1122                           struct fsi_stream *io,
1123                           struct device *dev)
1124 {
1125         struct fsi_master *master = fsi_get_master(fsi);
1126         int is_play = fsi_stream_is_play(fsi, io);
1127         u32 shift, i;
1128         int frame_capa;
1129
1130         /* get on-chip RAM capacity */
1131         shift = fsi_master_read(master, FIFO_SZ);
1132         shift >>= fsi_get_port_shift(fsi, io);
1133         shift &= FIFO_SZ_MASK;
1134         frame_capa = 256 << shift;
1135         dev_dbg(dev, "fifo = %d words\n", frame_capa);
1136
1137         /*
1138          * The maximum number of sample data varies depending
1139          * on the number of channels selected for the format.
1140          *
1141          * FIFOs are used in 4-channel units in 3-channel mode
1142          * and in 8-channel units in 5- to 7-channel mode
1143          * meaning that more FIFOs than the required size of DPRAM
1144          * are used.
1145          *
1146          * ex) if 256 words of DP-RAM is connected
1147          * 1 channel:  256 (256 x 1 = 256)
1148          * 2 channels: 128 (128 x 2 = 256)
1149          * 3 channels:  64 ( 64 x 3 = 192)
1150          * 4 channels:  64 ( 64 x 4 = 256)
1151          * 5 channels:  32 ( 32 x 5 = 160)
1152          * 6 channels:  32 ( 32 x 6 = 192)
1153          * 7 channels:  32 ( 32 x 7 = 224)
1154          * 8 channels:  32 ( 32 x 8 = 256)
1155          */
1156         for (i = 1; i < fsi->chan_num; i <<= 1)
1157                 frame_capa >>= 1;
1158         dev_dbg(dev, "%d channel %d store\n",
1159                 fsi->chan_num, frame_capa);
1160
1161         io->fifo_sample_capa = fsi_frame2sample(fsi, frame_capa);
1162
1163         /*
1164          * set interrupt generation factor
1165          * clear FIFO
1166          */
1167         if (is_play) {
1168                 fsi_reg_write(fsi,      DOFF_CTL, IRQ_HALF);
1169                 fsi_reg_mask_set(fsi,   DOFF_CTL, FIFO_CLR, FIFO_CLR);
1170         } else {
1171                 fsi_reg_write(fsi,      DIFF_CTL, IRQ_HALF);
1172                 fsi_reg_mask_set(fsi,   DIFF_CTL, FIFO_CLR, FIFO_CLR);
1173         }
1174 }
1175
1176 static int fsi_hw_startup(struct fsi_priv *fsi,
1177                           struct fsi_stream *io,
1178                           struct device *dev)
1179 {
1180         struct fsi_master *master = fsi_get_master(fsi);
1181         int fsi_ver = master->core->ver;
1182         u32 flags = fsi_get_info_flags(fsi);
1183         u32 data = 0;
1184
1185         /* clock setting */
1186         if (fsi_is_clk_master(fsi))
1187                 data = DIMD | DOMD;
1188
1189         fsi_reg_mask_set(fsi, CKG1, (DIMD | DOMD), data);
1190
1191         /* clock inversion (CKG2) */
1192         data = 0;
1193         if (SH_FSI_LRM_INV & flags)
1194                 data |= 1 << 12;
1195         if (SH_FSI_BRM_INV & flags)
1196                 data |= 1 << 8;
1197         if (SH_FSI_LRS_INV & flags)
1198                 data |= 1 << 4;
1199         if (SH_FSI_BRS_INV & flags)
1200                 data |= 1 << 0;
1201
1202         fsi_reg_write(fsi, CKG2, data);
1203
1204         /* set format */
1205         fsi_reg_write(fsi, DO_FMT, fsi->do_fmt);
1206         fsi_reg_write(fsi, DI_FMT, fsi->di_fmt);
1207
1208         /* spdif ? */
1209         if (fsi_is_spdif(fsi)) {
1210                 fsi_spdif_clk_ctrl(fsi, 1);
1211                 fsi_reg_mask_set(fsi, OUT_SEL, DMMD, DMMD);
1212         }
1213
1214         /*
1215          * FIXME
1216          *
1217          * FSI driver assumed that data package is in-back.
1218          * FSI2 chip can select it.
1219          */
1220         if (fsi_ver >= 2) {
1221                 fsi_reg_write(fsi, OUT_DMAC,    (1 << 4));
1222                 fsi_reg_write(fsi, IN_DMAC,     (1 << 4));
1223         }
1224
1225         /* irq clear */
1226         fsi_irq_disable(fsi, io);
1227         fsi_irq_clear_status(fsi);
1228
1229         /* fifo init */
1230         fsi_fifo_init(fsi, io, dev);
1231
1232         return 0;
1233 }
1234
1235 static void fsi_hw_shutdown(struct fsi_priv *fsi,
1236                             struct device *dev)
1237 {
1238         if (fsi_is_clk_master(fsi))
1239                 fsi_set_master_clk(dev, fsi, fsi->rate, 0);
1240 }
1241
1242 static int fsi_dai_startup(struct snd_pcm_substream *substream,
1243                            struct snd_soc_dai *dai)
1244 {
1245         struct fsi_priv *fsi = fsi_get_priv(substream);
1246
1247         return fsi_hw_startup(fsi, fsi_stream_get(fsi, substream), dai->dev);
1248 }
1249
1250 static void fsi_dai_shutdown(struct snd_pcm_substream *substream,
1251                              struct snd_soc_dai *dai)
1252 {
1253         struct fsi_priv *fsi = fsi_get_priv(substream);
1254
1255         fsi_hw_shutdown(fsi, dai->dev);
1256         fsi->rate = 0;
1257 }
1258
1259 static int fsi_dai_trigger(struct snd_pcm_substream *substream, int cmd,
1260                            struct snd_soc_dai *dai)
1261 {
1262         struct fsi_priv *fsi = fsi_get_priv(substream);
1263         struct fsi_stream *io = fsi_stream_get(fsi, substream);
1264         int ret = 0;
1265
1266         switch (cmd) {
1267         case SNDRV_PCM_TRIGGER_START:
1268                 fsi_stream_init(fsi, io, substream);
1269                 ret = fsi_stream_transfer(io);
1270                 if (0 == ret)
1271                         fsi_stream_start(fsi, io);
1272                 break;
1273         case SNDRV_PCM_TRIGGER_STOP:
1274                 fsi_stream_stop(fsi, io);
1275                 fsi_stream_quit(fsi, io);
1276                 break;
1277         }
1278
1279         return ret;
1280 }
1281
1282 static int fsi_set_fmt_dai(struct fsi_priv *fsi, unsigned int fmt)
1283 {
1284         u32 data = 0;
1285
1286         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1287         case SND_SOC_DAIFMT_I2S:
1288                 data = CR_I2S;
1289                 fsi->chan_num = 2;
1290                 break;
1291         case SND_SOC_DAIFMT_LEFT_J:
1292                 data = CR_PCM;
1293                 fsi->chan_num = 2;
1294                 break;
1295         default:
1296                 return -EINVAL;
1297         }
1298
1299         fsi->do_fmt = data;
1300         fsi->di_fmt = data;
1301
1302         return 0;
1303 }
1304
1305 static int fsi_set_fmt_spdif(struct fsi_priv *fsi)
1306 {
1307         struct fsi_master *master = fsi_get_master(fsi);
1308         u32 data = 0;
1309
1310         if (master->core->ver < 2)
1311                 return -EINVAL;
1312
1313         data = CR_BWS_16 | CR_DTMD_SPDIF_PCM | CR_PCM;
1314         fsi->chan_num = 2;
1315         fsi->spdif = 1;
1316
1317         fsi->do_fmt = data;
1318         fsi->di_fmt = data;
1319
1320         return 0;
1321 }
1322
1323 static int fsi_dai_set_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1324 {
1325         struct fsi_priv *fsi = fsi_get_priv_frm_dai(dai);
1326         set_rate_func set_rate = fsi_get_info_set_rate(fsi);
1327         u32 flags = fsi_get_info_flags(fsi);
1328         int ret;
1329
1330         /* set master/slave audio interface */
1331         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1332         case SND_SOC_DAIFMT_CBM_CFM:
1333                 fsi->clk_master = 1;
1334                 break;
1335         case SND_SOC_DAIFMT_CBS_CFS:
1336                 break;
1337         default:
1338                 return -EINVAL;
1339         }
1340
1341         if (fsi_is_clk_master(fsi) && !set_rate) {
1342                 dev_err(dai->dev, "platform doesn't have set_rate\n");
1343                 return -EINVAL;
1344         }
1345
1346         /* set format */
1347         switch (flags & SH_FSI_FMT_MASK) {
1348         case SH_FSI_FMT_DAI:
1349                 ret = fsi_set_fmt_dai(fsi, fmt & SND_SOC_DAIFMT_FORMAT_MASK);
1350                 break;
1351         case SH_FSI_FMT_SPDIF:
1352                 ret = fsi_set_fmt_spdif(fsi);
1353                 break;
1354         default:
1355                 ret = -EINVAL;
1356         }
1357
1358         return ret;
1359 }
1360
1361 static int fsi_dai_hw_params(struct snd_pcm_substream *substream,
1362                              struct snd_pcm_hw_params *params,
1363                              struct snd_soc_dai *dai)
1364 {
1365         struct fsi_priv *fsi = fsi_get_priv(substream);
1366         long rate = params_rate(params);
1367         int ret;
1368
1369         if (!fsi_is_clk_master(fsi))
1370                 return 0;
1371
1372         ret = fsi_set_master_clk(dai->dev, fsi, rate, 1);
1373         if (ret < 0)
1374                 return ret;
1375
1376         fsi->rate = rate;
1377
1378         return ret;
1379 }
1380
1381 static const struct snd_soc_dai_ops fsi_dai_ops = {
1382         .startup        = fsi_dai_startup,
1383         .shutdown       = fsi_dai_shutdown,
1384         .trigger        = fsi_dai_trigger,
1385         .set_fmt        = fsi_dai_set_fmt,
1386         .hw_params      = fsi_dai_hw_params,
1387 };
1388
1389 /*
1390  *              pcm ops
1391  */
1392
1393 static struct snd_pcm_hardware fsi_pcm_hardware = {
1394         .info =         SNDRV_PCM_INFO_INTERLEAVED      |
1395                         SNDRV_PCM_INFO_MMAP             |
1396                         SNDRV_PCM_INFO_MMAP_VALID       |
1397                         SNDRV_PCM_INFO_PAUSE,
1398         .formats                = FSI_FMTS,
1399         .rates                  = FSI_RATES,
1400         .rate_min               = 8000,
1401         .rate_max               = 192000,
1402         .channels_min           = 1,
1403         .channels_max           = 2,
1404         .buffer_bytes_max       = 64 * 1024,
1405         .period_bytes_min       = 32,
1406         .period_bytes_max       = 8192,
1407         .periods_min            = 1,
1408         .periods_max            = 32,
1409         .fifo_size              = 256,
1410 };
1411
1412 static int fsi_pcm_open(struct snd_pcm_substream *substream)
1413 {
1414         struct snd_pcm_runtime *runtime = substream->runtime;
1415         int ret = 0;
1416
1417         snd_soc_set_runtime_hwparams(substream, &fsi_pcm_hardware);
1418
1419         ret = snd_pcm_hw_constraint_integer(runtime,
1420                                             SNDRV_PCM_HW_PARAM_PERIODS);
1421
1422         return ret;
1423 }
1424
1425 static int fsi_hw_params(struct snd_pcm_substream *substream,
1426                          struct snd_pcm_hw_params *hw_params)
1427 {
1428         return snd_pcm_lib_malloc_pages(substream,
1429                                         params_buffer_bytes(hw_params));
1430 }
1431
1432 static int fsi_hw_free(struct snd_pcm_substream *substream)
1433 {
1434         return snd_pcm_lib_free_pages(substream);
1435 }
1436
1437 static snd_pcm_uframes_t fsi_pointer(struct snd_pcm_substream *substream)
1438 {
1439         struct fsi_priv *fsi = fsi_get_priv(substream);
1440         struct fsi_stream *io = fsi_stream_get(fsi, substream);
1441
1442         return fsi_sample2frame(fsi, io->buff_sample_pos);
1443 }
1444
1445 static struct snd_pcm_ops fsi_pcm_ops = {
1446         .open           = fsi_pcm_open,
1447         .ioctl          = snd_pcm_lib_ioctl,
1448         .hw_params      = fsi_hw_params,
1449         .hw_free        = fsi_hw_free,
1450         .pointer        = fsi_pointer,
1451 };
1452
1453 /*
1454  *              snd_soc_platform
1455  */
1456
1457 #define PREALLOC_BUFFER         (32 * 1024)
1458 #define PREALLOC_BUFFER_MAX     (32 * 1024)
1459
1460 static void fsi_pcm_free(struct snd_pcm *pcm)
1461 {
1462         snd_pcm_lib_preallocate_free_for_all(pcm);
1463 }
1464
1465 static int fsi_pcm_new(struct snd_soc_pcm_runtime *rtd)
1466 {
1467         struct snd_pcm *pcm = rtd->pcm;
1468
1469         /*
1470          * dont use SNDRV_DMA_TYPE_DEV, since it will oops the SH kernel
1471          * in MMAP mode (i.e. aplay -M)
1472          */
1473         return snd_pcm_lib_preallocate_pages_for_all(
1474                 pcm,
1475                 SNDRV_DMA_TYPE_CONTINUOUS,
1476                 snd_dma_continuous_data(GFP_KERNEL),
1477                 PREALLOC_BUFFER, PREALLOC_BUFFER_MAX);
1478 }
1479
1480 /*
1481  *              alsa struct
1482  */
1483
1484 static struct snd_soc_dai_driver fsi_soc_dai[] = {
1485         {
1486                 .name                   = "fsia-dai",
1487                 .playback = {
1488                         .rates          = FSI_RATES,
1489                         .formats        = FSI_FMTS,
1490                         .channels_min   = 1,
1491                         .channels_max   = 8,
1492                 },
1493                 .capture = {
1494                         .rates          = FSI_RATES,
1495                         .formats        = FSI_FMTS,
1496                         .channels_min   = 1,
1497                         .channels_max   = 8,
1498                 },
1499                 .ops = &fsi_dai_ops,
1500         },
1501         {
1502                 .name                   = "fsib-dai",
1503                 .playback = {
1504                         .rates          = FSI_RATES,
1505                         .formats        = FSI_FMTS,
1506                         .channels_min   = 1,
1507                         .channels_max   = 8,
1508                 },
1509                 .capture = {
1510                         .rates          = FSI_RATES,
1511                         .formats        = FSI_FMTS,
1512                         .channels_min   = 1,
1513                         .channels_max   = 8,
1514                 },
1515                 .ops = &fsi_dai_ops,
1516         },
1517 };
1518
1519 static struct snd_soc_platform_driver fsi_soc_platform = {
1520         .ops            = &fsi_pcm_ops,
1521         .pcm_new        = fsi_pcm_new,
1522         .pcm_free       = fsi_pcm_free,
1523 };
1524
1525 /*
1526  *              platform function
1527  */
1528 static void fsi_handler_init(struct fsi_priv *fsi)
1529 {
1530         fsi->playback.handler   = &fsi_pio_push_handler; /* default PIO */
1531         fsi->playback.priv      = fsi;
1532         fsi->capture.handler    = &fsi_pio_pop_handler;  /* default PIO */
1533         fsi->capture.priv       = fsi;
1534
1535         if (fsi->info->tx_id) {
1536                 fsi->playback.slave.slave_id    = fsi->info->tx_id;
1537                 fsi->playback.handler           = &fsi_dma_push_handler;
1538         }
1539 }
1540
1541 static int fsi_probe(struct platform_device *pdev)
1542 {
1543         struct fsi_master *master;
1544         const struct platform_device_id *id_entry;
1545         struct sh_fsi_platform_info *info = pdev->dev.platform_data;
1546         struct resource *res;
1547         unsigned int irq;
1548         int ret;
1549
1550         id_entry = pdev->id_entry;
1551         if (!id_entry) {
1552                 dev_err(&pdev->dev, "unknown fsi device\n");
1553                 return -ENODEV;
1554         }
1555
1556         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1557         irq = platform_get_irq(pdev, 0);
1558         if (!res || (int)irq <= 0) {
1559                 dev_err(&pdev->dev, "Not enough FSI platform resources.\n");
1560                 ret = -ENODEV;
1561                 goto exit;
1562         }
1563
1564         master = kzalloc(sizeof(*master), GFP_KERNEL);
1565         if (!master) {
1566                 dev_err(&pdev->dev, "Could not allocate master\n");
1567                 ret = -ENOMEM;
1568                 goto exit;
1569         }
1570
1571         master->base = ioremap_nocache(res->start, resource_size(res));
1572         if (!master->base) {
1573                 ret = -ENXIO;
1574                 dev_err(&pdev->dev, "Unable to ioremap FSI registers.\n");
1575                 goto exit_kfree;
1576         }
1577
1578         /* master setting */
1579         master->irq             = irq;
1580         master->core            = (struct fsi_core *)id_entry->driver_data;
1581         spin_lock_init(&master->lock);
1582
1583         /* FSI A setting */
1584         master->fsia.base       = master->base;
1585         master->fsia.master     = master;
1586         master->fsia.info       = &info->port_a;
1587         fsi_handler_init(&master->fsia);
1588         ret = fsi_stream_probe(&master->fsia);
1589         if (ret < 0) {
1590                 dev_err(&pdev->dev, "FSIA stream probe failed\n");
1591                 goto exit_iounmap;
1592         }
1593
1594         /* FSI B setting */
1595         master->fsib.base       = master->base + 0x40;
1596         master->fsib.master     = master;
1597         master->fsib.info       = &info->port_b;
1598         fsi_handler_init(&master->fsib);
1599         ret = fsi_stream_probe(&master->fsib);
1600         if (ret < 0) {
1601                 dev_err(&pdev->dev, "FSIB stream probe failed\n");
1602                 goto exit_fsia;
1603         }
1604
1605         pm_runtime_enable(&pdev->dev);
1606         dev_set_drvdata(&pdev->dev, master);
1607
1608         ret = request_irq(irq, &fsi_interrupt, 0,
1609                           id_entry->name, master);
1610         if (ret) {
1611                 dev_err(&pdev->dev, "irq request err\n");
1612                 goto exit_fsib;
1613         }
1614
1615         ret = snd_soc_register_platform(&pdev->dev, &fsi_soc_platform);
1616         if (ret < 0) {
1617                 dev_err(&pdev->dev, "cannot snd soc register\n");
1618                 goto exit_free_irq;
1619         }
1620
1621         ret = snd_soc_register_dais(&pdev->dev, fsi_soc_dai,
1622                                     ARRAY_SIZE(fsi_soc_dai));
1623         if (ret < 0) {
1624                 dev_err(&pdev->dev, "cannot snd dai register\n");
1625                 goto exit_snd_soc;
1626         }
1627
1628         return ret;
1629
1630 exit_snd_soc:
1631         snd_soc_unregister_platform(&pdev->dev);
1632 exit_free_irq:
1633         free_irq(irq, master);
1634 exit_fsib:
1635         fsi_stream_remove(&master->fsib);
1636 exit_fsia:
1637         fsi_stream_remove(&master->fsia);
1638 exit_iounmap:
1639         iounmap(master->base);
1640         pm_runtime_disable(&pdev->dev);
1641 exit_kfree:
1642         kfree(master);
1643         master = NULL;
1644 exit:
1645         return ret;
1646 }
1647
1648 static int fsi_remove(struct platform_device *pdev)
1649 {
1650         struct fsi_master *master;
1651
1652         master = dev_get_drvdata(&pdev->dev);
1653
1654         free_irq(master->irq, master);
1655         pm_runtime_disable(&pdev->dev);
1656
1657         snd_soc_unregister_dais(&pdev->dev, ARRAY_SIZE(fsi_soc_dai));
1658         snd_soc_unregister_platform(&pdev->dev);
1659
1660         fsi_stream_remove(&master->fsia);
1661         fsi_stream_remove(&master->fsib);
1662
1663         iounmap(master->base);
1664         kfree(master);
1665
1666         return 0;
1667 }
1668
1669 static void __fsi_suspend(struct fsi_priv *fsi,
1670                           struct fsi_stream *io,
1671                           struct device *dev)
1672 {
1673         if (!fsi_stream_is_working(fsi, io))
1674                 return;
1675
1676         fsi_stream_stop(fsi, io);
1677         fsi_hw_shutdown(fsi, dev);
1678 }
1679
1680 static void __fsi_resume(struct fsi_priv *fsi,
1681                          struct fsi_stream *io,
1682                          struct device *dev)
1683 {
1684         if (!fsi_stream_is_working(fsi, io))
1685                 return;
1686
1687         fsi_hw_startup(fsi, io, dev);
1688
1689         if (fsi_is_clk_master(fsi) && fsi->rate)
1690                 fsi_set_master_clk(dev, fsi, fsi->rate, 1);
1691
1692         fsi_stream_start(fsi, io);
1693 }
1694
1695 static int fsi_suspend(struct device *dev)
1696 {
1697         struct fsi_master *master = dev_get_drvdata(dev);
1698         struct fsi_priv *fsia = &master->fsia;
1699         struct fsi_priv *fsib = &master->fsib;
1700
1701         __fsi_suspend(fsia, &fsia->playback, dev);
1702         __fsi_suspend(fsia, &fsia->capture, dev);
1703
1704         __fsi_suspend(fsib, &fsib->playback, dev);
1705         __fsi_suspend(fsib, &fsib->capture, dev);
1706
1707         return 0;
1708 }
1709
1710 static int fsi_resume(struct device *dev)
1711 {
1712         struct fsi_master *master = dev_get_drvdata(dev);
1713         struct fsi_priv *fsia = &master->fsia;
1714         struct fsi_priv *fsib = &master->fsib;
1715
1716         __fsi_resume(fsia, &fsia->playback, dev);
1717         __fsi_resume(fsia, &fsia->capture, dev);
1718
1719         __fsi_resume(fsib, &fsib->playback, dev);
1720         __fsi_resume(fsib, &fsib->capture, dev);
1721
1722         return 0;
1723 }
1724
1725 static struct dev_pm_ops fsi_pm_ops = {
1726         .suspend                = fsi_suspend,
1727         .resume                 = fsi_resume,
1728 };
1729
1730 static struct fsi_core fsi1_core = {
1731         .ver    = 1,
1732
1733         /* Interrupt */
1734         .int_st = INT_ST,
1735         .iemsk  = IEMSK,
1736         .imsk   = IMSK,
1737 };
1738
1739 static struct fsi_core fsi2_core = {
1740         .ver    = 2,
1741
1742         /* Interrupt */
1743         .int_st = CPU_INT_ST,
1744         .iemsk  = CPU_IEMSK,
1745         .imsk   = CPU_IMSK,
1746         .a_mclk = A_MST_CTLR,
1747         .b_mclk = B_MST_CTLR,
1748 };
1749
1750 static struct platform_device_id fsi_id_table[] = {
1751         { "sh_fsi",     (kernel_ulong_t)&fsi1_core },
1752         { "sh_fsi2",    (kernel_ulong_t)&fsi2_core },
1753         {},
1754 };
1755 MODULE_DEVICE_TABLE(platform, fsi_id_table);
1756
1757 static struct platform_driver fsi_driver = {
1758         .driver         = {
1759                 .name   = "fsi-pcm-audio",
1760                 .pm     = &fsi_pm_ops,
1761         },
1762         .probe          = fsi_probe,
1763         .remove         = fsi_remove,
1764         .id_table       = fsi_id_table,
1765 };
1766
1767 module_platform_driver(fsi_driver);
1768
1769 MODULE_LICENSE("GPL");
1770 MODULE_DESCRIPTION("SuperH onchip FSI audio driver");
1771 MODULE_AUTHOR("Kuninori Morimoto <morimoto.kuninori@renesas.com>");
1772 MODULE_ALIAS("platform:fsi-pcm-audio");