sound/soc/fsl/fsl_ssi.c

   1 /*
   2  * Freescale SSI ALSA SoC Digital Audio Interface (DAI) driver
   3  *
   4  * Author: Timur Tabi <timur@freescale.com>
   5  *
   6  * Copyright 2007-2010 Freescale Semiconductor, Inc.
   7  *
   8  * This file is licensed under the terms of the GNU General Public License
   9  * version 2.  This program is licensed "as is" without any warranty of any
  10  * kind, whether express or implied.
  11  *
  12  *
  13  * Some notes why imx-pcm-fiq is used instead of DMA on some boards:
  14  *
  15  * The i.MX SSI core has some nasty limitations in AC97 mode. While most
  16  * sane processor vendors have a FIFO per AC97 slot, the i.MX has only
  17  * one FIFO which combines all valid receive slots. We cannot even select
  18  * which slots we want to receive. The WM9712 with which this driver
  19  * was developed with always sends GPIO status data in slot 12 which
  20  * we receive in our (PCM-) data stream. The only chance we have is to
  21  * manually skip this data in the FIQ handler. With sampling rates different
  22  * from 48000Hz not every frame has valid receive data, so the ratio
  23  * between pcm data and GPIO status data changes. Our FIQ handler is not
  24  * able to handle this, hence this driver only works with 48000Hz sampling
  25  * rate.
  26  * Reading and writing AC97 registers is another challenge. The core
  27  * provides us status bits when the read register is updated with *another*
  28  * value. When we read the same register two times (and the register still
  29  * contains the same value) these status bits are not set. We work
  30  * around this by not polling these bits but only wait a fixed delay.
  31  */
  32
  33 #include <linux/init.h>
  34 #include <linux/io.h>
  35 #include <linux/module.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/clk.h>
  38 #include <linux/device.h>
  39 #include <linux/delay.h>
  40 #include <linux/slab.h>
  41 #include <linux/spinlock.h>
  42 #include <linux/of.h>
  43 #include <linux/of_address.h>
  44 #include <linux/of_irq.h>
  45 #include <linux/of_platform.h>
  46
  47 #include <sound/core.h>
  48 #include <sound/pcm.h>
  49 #include <sound/pcm_params.h>
  50 #include <sound/initval.h>
  51 #include <sound/soc.h>
  52 #include <sound/dmaengine_pcm.h>
  53
  54 #include "fsl_ssi.h"
  55 #include "imx-pcm.h"
  56
  57 /**
  58  * FSLSSI_I2S_RATES: sample rates supported by the I2S
  59  *
  60  * This driver currently only supports the SSI running in I2S slave mode,
  61  * which means the codec determines the sample rate.  Therefore, we tell
  62  * ALSA that we support all rates and let the codec driver decide what rates
  63  * are really supported.
  64  */
  65 #define FSLSSI_I2S_RATES SNDRV_PCM_RATE_CONTINUOUS
  66
  67 /**
  68  * FSLSSI_I2S_FORMATS: audio formats supported by the SSI
  69  *
  70  * The SSI has a limitation in that the samples must be in the same byte
  71  * order as the host CPU.  This is because when multiple bytes are written
  72  * to the STX register, the bytes and bits must be written in the same
  73  * order.  The STX is a shift register, so all the bits need to be aligned
  74  * (bit-endianness must match byte-endianness).  Processors typically write
  75  * the bits within a byte in the same order that the bytes of a word are
  76  * written in.  So if the host CPU is big-endian, then only big-endian
  77  * samples will be written to STX properly.
  78  */
  79 #ifdef __BIG_ENDIAN
  80 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_BE | \
  81          SNDRV_PCM_FMTBIT_S18_3BE | SNDRV_PCM_FMTBIT_S20_3BE | \
  82          SNDRV_PCM_FMTBIT_S24_3BE | SNDRV_PCM_FMTBIT_S24_BE)
  83 #else
  84 #define FSLSSI_I2S_FORMATS (SNDRV_PCM_FMTBIT_S8 | SNDRV_PCM_FMTBIT_S16_LE | \
  85          SNDRV_PCM_FMTBIT_S18_3LE | SNDRV_PCM_FMTBIT_S20_3LE | \
  86          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S24_LE)
  87 #endif
  88
  89 #define FSLSSI_SIER_DBG_RX_FLAGS (CCSR_SSI_SIER_RFF0_EN | \
  90                 CCSR_SSI_SIER_RLS_EN | CCSR_SSI_SIER_RFS_EN | \
  91                 CCSR_SSI_SIER_ROE0_EN | CCSR_SSI_SIER_RFRC_EN)
  92 #define FSLSSI_SIER_DBG_TX_FLAGS (CCSR_SSI_SIER_TFE0_EN | \
  93                 CCSR_SSI_SIER_TLS_EN | CCSR_SSI_SIER_TFS_EN | \
  94                 CCSR_SSI_SIER_TUE0_EN | CCSR_SSI_SIER_TFRC_EN)
  95
  96 enum fsl_ssi_type {
  97         FSL_SSI_MCP8610,
  98         FSL_SSI_MX21,
  99         FSL_SSI_MX35,
 100         FSL_SSI_MX51,
 101 };
 102
 103 struct fsl_ssi_reg_val {
 104         u32 sier;
 105         u32 srcr;
 106         u32 stcr;
 107         u32 scr;
 108 };
 109
 110 struct fsl_ssi_rxtx_reg_val {
 111         struct fsl_ssi_reg_val rx;
 112         struct fsl_ssi_reg_val tx;
 113 };
 114
 115 static bool fsl_ssi_readable_reg(struct device *dev, unsigned int reg)
 116 {
 117         switch (reg) {
 118         case CCSR_SSI_SACCEN:
 119         case CCSR_SSI_SACCDIS:
 120                 return false;
 121         default:
 122                 return true;
 123         }
 124 }
 125
 126 static bool fsl_ssi_volatile_reg(struct device *dev, unsigned int reg)
 127 {
 128         switch (reg) {
 129         case CCSR_SSI_STX0:
 130         case CCSR_SSI_STX1:
 131         case CCSR_SSI_SRX0:
 132         case CCSR_SSI_SRX1:
 133         case CCSR_SSI_SISR:
 134         case CCSR_SSI_SFCSR:
 135         case CCSR_SSI_SACNT:
 136         case CCSR_SSI_SACADD:
 137         case CCSR_SSI_SACDAT:
 138         case CCSR_SSI_SATAG:
 139         case CCSR_SSI_SACCST:
 140                 return true;
 141         default:
 142                 return false;
 143         }
 144 }
 145
 146 static bool fsl_ssi_precious_reg(struct device *dev, unsigned int reg)
 147 {
 148         switch (reg) {
 149         case CCSR_SSI_SRX0:
 150         case CCSR_SSI_SRX1:
 151         case CCSR_SSI_SISR:
 152         case CCSR_SSI_SACADD:
 153         case CCSR_SSI_SACDAT:
 154         case CCSR_SSI_SATAG:
 155                 return true;
 156         default:
 157                 return false;
 158         }
 159 }
 160
 161 static bool fsl_ssi_writeable_reg(struct device *dev, unsigned int reg)
 162 {
 163         switch (reg) {
 164         case CCSR_SSI_SRX0:
 165         case CCSR_SSI_SRX1:
 166         case CCSR_SSI_SACCST:
 167                 return false;
 168         default:
 169                 return true;
 170         }
 171 }
 172
 173 static const struct regmap_config fsl_ssi_regconfig = {
 174         .max_register = CCSR_SSI_SACCDIS,
 175         .reg_bits = 32,
 176         .val_bits = 32,
 177         .reg_stride = 4,
 178         .val_format_endian = REGMAP_ENDIAN_NATIVE,
 179         .num_reg_defaults_raw = CCSR_SSI_SACCDIS / sizeof(uint32_t) + 1,
 180         .readable_reg = fsl_ssi_readable_reg,
 181         .volatile_reg = fsl_ssi_volatile_reg,
 182         .precious_reg = fsl_ssi_precious_reg,
 183         .writeable_reg = fsl_ssi_writeable_reg,
 184         .cache_type = REGCACHE_RBTREE,
 185 };
 186
 187 struct fsl_ssi_soc_data {
 188         bool imx;
 189         bool imx21regs; /* imx21-class SSI - no SACC{ST,EN,DIS} regs */
 190         bool offline_config;
 191         u32 sisr_write_mask;
 192 };
 193
 194 /**
 195  * fsl_ssi_private: per-SSI private data
 196  *
 197  * @reg: Pointer to the regmap registers
 198  * @irq: IRQ of this SSI
 199  * @cpu_dai_drv: CPU DAI driver for this device
 200  *
 201  * @dai_fmt: DAI configuration this device is currently used with
 202  * @i2s_mode: i2s and network mode configuration of the device. Is used to
 203  * switch between normal and i2s/network mode
 204  * mode depending on the number of channels
 205  * @use_dma: DMA is used or FIQ with stream filter
 206  * @use_dual_fifo: DMA with support for both FIFOs used
 207  * @fifo_deph: Depth of the SSI FIFOs
 208  * @rxtx_reg_val: Specific register settings for receive/transmit configuration
 209  *
 210  * @clk: SSI clock
 211  * @baudclk: SSI baud clock for master mode
 212  * @baudclk_streams: Active streams that are using baudclk
 213  * @bitclk_freq: bitclock frequency set by .set_dai_sysclk
 214  *
 215  * @dma_params_tx: DMA transmit parameters
 216  * @dma_params_rx: DMA receive parameters
 217  * @ssi_phys: physical address of the SSI registers
 218  *
 219  * @fiq_params: FIQ stream filtering parameters
 220  *
 221  * @pdev: Pointer to pdev used for deprecated fsl-ssi sound card
 222  *
 223  * @dbg_stats: Debugging statistics
 224  *
 225  * @soc: SoC specific data
 226  */
 227 struct fsl_ssi_private {
 228         struct regmap *regs;
 229         int irq;
 230         struct snd_soc_dai_driver cpu_dai_drv;
 231
 232         unsigned int dai_fmt;
 233         u8 i2s_mode;
 234         bool use_dma;
 235         bool use_dual_fifo;
 236         bool has_ipg_clk_name;
 237         unsigned int fifo_depth;
 238         struct fsl_ssi_rxtx_reg_val rxtx_reg_val;
 239
 240         struct clk *clk;
 241         struct clk *baudclk;
 242         unsigned int baudclk_streams;
 243         unsigned int bitclk_freq;
 244
 245         /* regcache for volatile regs */
 246         u32 regcache_sfcsr;
 247         u32 regcache_sacnt;
 248
 249         /* DMA params */
 250         struct snd_dmaengine_dai_dma_data dma_params_tx;
 251         struct snd_dmaengine_dai_dma_data dma_params_rx;
 252         dma_addr_t ssi_phys;
 253
 254         /* params for non-dma FIQ stream filtered mode */
 255         struct imx_pcm_fiq_params fiq_params;
 256
 257         /* Used when using fsl-ssi as sound-card. This is only used by ppc and
 258          * should be replaced with simple-sound-card. */
 259         struct platform_device *pdev;
 260
 261         struct fsl_ssi_dbg dbg_stats;
 262
 263         const struct fsl_ssi_soc_data *soc;
 264         struct device *dev;
 265 };
 266
 267 /*
 268  * imx51 and later SoCs have a slightly different IP that allows the
 269  * SSI configuration while the SSI unit is running.
 270  *
 271  * More important, it is necessary on those SoCs to configure the
 272  * sperate TX/RX DMA bits just before starting the stream
 273  * (fsl_ssi_trigger). The SDMA unit has to be configured before fsl_ssi
 274  * sends any DMA requests to the SDMA unit, otherwise it is not defined
 275  * how the SDMA unit handles the DMA request.
 276  *
 277  * SDMA units are present on devices starting at imx35 but the imx35
 278  * reference manual states that the DMA bits should not be changed
 279  * while the SSI unit is running (SSIEN). So we support the necessary
 280  * online configuration of fsl-ssi starting at imx51.
 281  */
 282
 283 static struct fsl_ssi_soc_data fsl_ssi_mpc8610 = {
 284         .imx = false,
 285         .offline_config = true,
 286         .sisr_write_mask = CCSR_SSI_SISR_RFRC | CCSR_SSI_SISR_TFRC |
 287                         CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
 288                         CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
 289 };
 290
 291 static struct fsl_ssi_soc_data fsl_ssi_imx21 = {
 292         .imx = true,
 293         .imx21regs = true,
 294         .offline_config = true,
 295         .sisr_write_mask = 0,
 296 };
 297
 298 static struct fsl_ssi_soc_data fsl_ssi_imx35 = {
 299         .imx = true,
 300         .offline_config = true,
 301         .sisr_write_mask = CCSR_SSI_SISR_RFRC | CCSR_SSI_SISR_TFRC |
 302                         CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
 303                         CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
 304 };
 305
 306 static struct fsl_ssi_soc_data fsl_ssi_imx51 = {
 307         .imx = true,
 308         .offline_config = false,
 309         .sisr_write_mask = CCSR_SSI_SISR_ROE0 | CCSR_SSI_SISR_ROE1 |
 310                 CCSR_SSI_SISR_TUE0 | CCSR_SSI_SISR_TUE1,
 311 };
 312
 313 static const struct of_device_id fsl_ssi_ids[] = {
 314         { .compatible = "fsl,mpc8610-ssi", .data = &fsl_ssi_mpc8610 },
 315         { .compatible = "fsl,imx51-ssi", .data = &fsl_ssi_imx51 },
 316         { .compatible = "fsl,imx35-ssi", .data = &fsl_ssi_imx35 },
 317         { .compatible = "fsl,imx21-ssi", .data = &fsl_ssi_imx21 },
 318         {}
 319 };
 320 MODULE_DEVICE_TABLE(of, fsl_ssi_ids);
 321
 322 static bool fsl_ssi_is_ac97(struct fsl_ssi_private *ssi_private)
 323 {
 324         return (ssi_private->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK) ==
 325                 SND_SOC_DAIFMT_AC97;
 326 }
 327
 328 static bool fsl_ssi_is_i2s_master(struct fsl_ssi_private *ssi_private)
 329 {
 330         return (ssi_private->dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
 331                 SND_SOC_DAIFMT_CBS_CFS;
 332 }
 333
 334 static bool fsl_ssi_is_i2s_cbm_cfs(struct fsl_ssi_private *ssi_private)
 335 {
 336         return (ssi_private->dai_fmt & SND_SOC_DAIFMT_MASTER_MASK) ==
 337                 SND_SOC_DAIFMT_CBM_CFS;
 338 }
 339 /**
 340  * fsl_ssi_isr: SSI interrupt handler
 341  *
 342  * Although it's possible to use the interrupt handler to send and receive
 343  * data to/from the SSI, we use the DMA instead.  Programming is more
 344  * complicated, but the performance is much better.
 345  *
 346  * This interrupt handler is used only to gather statistics.
 347  *
 348  * @irq: IRQ of the SSI device
 349  * @dev_id: pointer to the ssi_private structure for this SSI device
 350  */
 351 static irqreturn_t fsl_ssi_isr(int irq, void *dev_id)
 352 {
 353         struct fsl_ssi_private *ssi_private = dev_id;
 354         struct regmap *regs = ssi_private->regs;
 355         __be32 sisr;
 356         __be32 sisr2;
 357
 358         /* We got an interrupt, so read the status register to see what we
 359            were interrupted for.  We mask it with the Interrupt Enable register
 360            so that we only check for events that we're interested in.
 361          */
 362         regmap_read(regs, CCSR_SSI_SISR, &sisr);
 363
 364         sisr2 = sisr & ssi_private->soc->sisr_write_mask;
 365         /* Clear the bits that we set */
 366         if (sisr2)
 367                 regmap_write(regs, CCSR_SSI_SISR, sisr2);
 368
 369         fsl_ssi_dbg_isr(&ssi_private->dbg_stats, sisr);
 370
 371         return IRQ_HANDLED;
 372 }
 373
 374 /*
 375  * Enable/Disable all rx/tx config flags at once.
 376  */
 377 static void fsl_ssi_rxtx_config(struct fsl_ssi_private *ssi_private,
 378                 bool enable)
 379 {
 380         struct regmap *regs = ssi_private->regs;
 381         struct fsl_ssi_rxtx_reg_val *vals = &ssi_private->rxtx_reg_val;
 382
 383         if (enable) {
 384                 regmap_update_bits(regs, CCSR_SSI_SIER,
 385                                 vals->rx.sier | vals->tx.sier,
 386                                 vals->rx.sier | vals->tx.sier);
 387                 regmap_update_bits(regs, CCSR_SSI_SRCR,
 388                                 vals->rx.srcr | vals->tx.srcr,
 389                                 vals->rx.srcr | vals->tx.srcr);
 390                 regmap_update_bits(regs, CCSR_SSI_STCR,
 391                                 vals->rx.stcr | vals->tx.stcr,
 392                                 vals->rx.stcr | vals->tx.stcr);
 393         } else {
 394                 regmap_update_bits(regs, CCSR_SSI_SRCR,
 395                                 vals->rx.srcr | vals->tx.srcr, 0);
 396                 regmap_update_bits(regs, CCSR_SSI_STCR,
 397                                 vals->rx.stcr | vals->tx.stcr, 0);
 398                 regmap_update_bits(regs, CCSR_SSI_SIER,
 399                                 vals->rx.sier | vals->tx.sier, 0);
 400         }
 401 }
 402
 403 /*
 404  * Calculate the bits that have to be disabled for the current stream that is
 405  * getting disabled. This keeps the bits enabled that are necessary for the
 406  * second stream to work if 'stream_active' is true.
 407  *
 408  * Detailed calculation:
 409  * These are the values that need to be active after disabling. For non-active
 410  * second stream, this is 0:
 411  *      vals_stream * !!stream_active
 412  *
 413  * The following computes the overall differences between the setup for the
 414  * to-disable stream and the active stream, a simple XOR:
 415  *      vals_disable ^ (vals_stream * !!(stream_active))
 416  *
 417  * The full expression adds a mask on all values we care about
 418  */
 419 #define fsl_ssi_disable_val(vals_disable, vals_stream, stream_active) \
 420         ((vals_disable) & \
 421          ((vals_disable) ^ ((vals_stream) * (u32)!!(stream_active))))
 422
 423 /*
 424  * Enable/Disable a ssi configuration. You have to pass either
 425  * ssi_private->rxtx_reg_val.rx or tx as vals parameter.
 426  */
 427 static void fsl_ssi_config(struct fsl_ssi_private *ssi_private, bool enable,
 428                 struct fsl_ssi_reg_val *vals)
 429 {
 430         struct regmap *regs = ssi_private->regs;
 431         struct fsl_ssi_reg_val *avals;
 432         int nr_active_streams;
 433         u32 scr_val;
 434         int keep_active;
 435
 436         regmap_read(regs, CCSR_SSI_SCR, &scr_val);
 437
 438         nr_active_streams = !!(scr_val & CCSR_SSI_SCR_TE) +
 439                                 !!(scr_val & CCSR_SSI_SCR_RE);
 440
 441         if (nr_active_streams - 1 > 0)
 442                 keep_active = 1;
 443         else
 444                 keep_active = 0;
 445
 446         /* Find the other direction values rx or tx which we do not want to
 447          * modify */
 448         if (&ssi_private->rxtx_reg_val.rx == vals)
 449                 avals = &ssi_private->rxtx_reg_val.tx;
 450         else
 451                 avals = &ssi_private->rxtx_reg_val.rx;
 452
 453         /* If vals should be disabled, start with disabling the unit */
 454         if (!enable) {
 455                 u32 scr = fsl_ssi_disable_val(vals->scr, avals->scr,
 456                                 keep_active);
 457                 regmap_update_bits(regs, CCSR_SSI_SCR, scr, 0);
 458         }
 459
 460         /*
 461          * We are running on a SoC which does not support online SSI
 462          * reconfiguration, so we have to enable all necessary flags at once
 463          * even if we do not use them later (capture and playback configuration)
 464          */
 465         if (ssi_private->soc->offline_config) {
 466                 if ((enable && !nr_active_streams) ||
 467                                 (!enable && !keep_active))
 468                         fsl_ssi_rxtx_config(ssi_private, enable);
 469
 470                 goto config_done;
 471         }
 472
 473         /*
 474          * Configure single direction units while the SSI unit is running
 475          * (online configuration)
 476          */
 477         if (enable) {
 478                 regmap_update_bits(regs, CCSR_SSI_SIER, vals->sier, vals->sier);
 479                 regmap_update_bits(regs, CCSR_SSI_SRCR, vals->srcr, vals->srcr);
 480                 regmap_update_bits(regs, CCSR_SSI_STCR, vals->stcr, vals->stcr);
 481         } else {
 482                 u32 sier;
 483                 u32 srcr;
 484                 u32 stcr;
 485
 486                 /*
 487                  * Disabling the necessary flags for one of rx/tx while the
 488                  * other stream is active is a little bit more difficult. We
 489                  * have to disable only those flags that differ between both
 490                  * streams (rx XOR tx) and that are set in the stream that is
 491                  * disabled now. Otherwise we could alter flags of the other
 492                  * stream
 493                  */
 494
 495                 /* These assignments are simply vals without bits set in avals*/
 496                 sier = fsl_ssi_disable_val(vals->sier, avals->sier,
 497                                 keep_active);
 498                 srcr = fsl_ssi_disable_val(vals->srcr, avals->srcr,
 499                                 keep_active);
 500                 stcr = fsl_ssi_disable_val(vals->stcr, avals->stcr,
 501                                 keep_active);
 502
 503                 regmap_update_bits(regs, CCSR_SSI_SRCR, srcr, 0);
 504                 regmap_update_bits(regs, CCSR_SSI_STCR, stcr, 0);
 505                 regmap_update_bits(regs, CCSR_SSI_SIER, sier, 0);
 506         }
 507
 508 config_done:
 509         /* Enabling of subunits is done after configuration */
 510         if (enable)
 511                 regmap_update_bits(regs, CCSR_SSI_SCR, vals->scr, vals->scr);
 512 }
 513
 514
 515 static void fsl_ssi_rx_config(struct fsl_ssi_private *ssi_private, bool enable)
 516 {
 517         fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.rx);
 518 }
 519
 520 static void fsl_ssi_tx_config(struct fsl_ssi_private *ssi_private, bool enable)
 521 {
 522         fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.tx);
 523 }
 524
 525 /*
 526  * Setup rx/tx register values used to enable/disable the streams. These will
 527  * be used later in fsl_ssi_config to setup the streams without the need to
 528  * check for all different SSI modes.
 529  */
 530 static void fsl_ssi_setup_reg_vals(struct fsl_ssi_private *ssi_private)
 531 {
 532         struct fsl_ssi_rxtx_reg_val *reg = &ssi_private->rxtx_reg_val;
 533
 534         reg->rx.sier = CCSR_SSI_SIER_RFF0_EN;
 535         reg->rx.srcr = CCSR_SSI_SRCR_RFEN0;
 536         reg->rx.scr = 0;
 537         reg->tx.sier = CCSR_SSI_SIER_TFE0_EN;
 538         reg->tx.stcr = CCSR_SSI_STCR_TFEN0;
 539         reg->tx.scr = 0;
 540
 541         if (!fsl_ssi_is_ac97(ssi_private)) {
 542                 reg->rx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_RE;
 543                 reg->rx.sier |= CCSR_SSI_SIER_RFF0_EN;
 544                 reg->tx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE;
 545                 reg->tx.sier |= CCSR_SSI_SIER_TFE0_EN;
 546         }
 547
 548         if (ssi_private->use_dma) {
 549                 reg->rx.sier |= CCSR_SSI_SIER_RDMAE;
 550                 reg->tx.sier |= CCSR_SSI_SIER_TDMAE;
 551         } else {
 552                 reg->rx.sier |= CCSR_SSI_SIER_RIE;
 553                 reg->tx.sier |= CCSR_SSI_SIER_TIE;
 554         }
 555
 556         reg->rx.sier |= FSLSSI_SIER_DBG_RX_FLAGS;
 557         reg->tx.sier |= FSLSSI_SIER_DBG_TX_FLAGS;
 558 }
 559
 560 static void fsl_ssi_setup_ac97(struct fsl_ssi_private *ssi_private)
 561 {
 562         struct regmap *regs = ssi_private->regs;
 563
 564         /*
 565          * Setup the clock control register
 566          */
 567         regmap_write(regs, CCSR_SSI_STCCR,
 568                         CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
 569         regmap_write(regs, CCSR_SSI_SRCCR,
 570                         CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
 571
 572         /*
 573          * Enable AC97 mode and startup the SSI
 574          */
 575         regmap_write(regs, CCSR_SSI_SACNT,
 576                         CCSR_SSI_SACNT_AC97EN | CCSR_SSI_SACNT_FV);
 577
 578         /* no SACC{ST,EN,DIS} regs on imx21-class SSI */
 579         if (!ssi_private->soc->imx21regs) {
 580                 regmap_write(regs, CCSR_SSI_SACCDIS, 0xff);
 581                 regmap_write(regs, CCSR_SSI_SACCEN, 0x300);
 582         }
 583
 584         /*
 585          * Enable SSI, Transmit and Receive. AC97 has to communicate with the
 586          * codec before a stream is started.
 587          */
 588         regmap_update_bits(regs, CCSR_SSI_SCR,
 589                         CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE,
 590                         CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE);
 591
 592         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_WAIT(3));
 593 }
 594
 595 /**
 596  * fsl_ssi_startup: create a new substream
 597  *
 598  * This is the first function called when a stream is opened.
 599  *
 600  * If this is the first stream open, then grab the IRQ and program most of
 601  * the SSI registers.
 602  */
 603 static int fsl_ssi_startup(struct snd_pcm_substream *substream,
 604                            struct snd_soc_dai *dai)
 605 {
 606         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 607         struct fsl_ssi_private *ssi_private =
 608                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 609         int ret;
 610
 611         ret = clk_prepare_enable(ssi_private->clk);
 612         if (ret)
 613                 return ret;
 614
 615         /* When using dual fifo mode, it is safer to ensure an even period
 616          * size. If appearing to an odd number while DMA always starts its
 617          * task from fifo0, fifo1 would be neglected at the end of each
 618          * period. But SSI would still access fifo1 with an invalid data.
 619          */
 620         if (ssi_private->use_dual_fifo)
 621                 snd_pcm_hw_constraint_step(substream->runtime, 0,
 622                                 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2);
 623
 624         return 0;
 625 }
 626
 627 /**
 628  * fsl_ssi_shutdown: shutdown the SSI
 629  *
 630  */
 631 static void fsl_ssi_shutdown(struct snd_pcm_substream *substream,
 632                                 struct snd_soc_dai *dai)
 633 {
 634         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 635         struct fsl_ssi_private *ssi_private =
 636                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 637
 638         clk_disable_unprepare(ssi_private->clk);
 639
 640 }
 641
 642 /**
 643  * fsl_ssi_set_bclk - configure Digital Audio Interface bit clock
 644  *
 645  * Note: This function can be only called when using SSI as DAI master
 646  *
 647  * Quick instruction for parameters:
 648  * freq: Output BCLK frequency = samplerate * 32 (fixed) * channels
 649  * dir: SND_SOC_CLOCK_OUT -> TxBCLK, SND_SOC_CLOCK_IN -> RxBCLK.
 650  */
 651 static int fsl_ssi_set_bclk(struct snd_pcm_substream *substream,
 652                 struct snd_soc_dai *cpu_dai,
 653                 struct snd_pcm_hw_params *hw_params)
 654 {
 655         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 656         struct regmap *regs = ssi_private->regs;
 657         int synchronous = ssi_private->cpu_dai_drv.symmetric_rates, ret;
 658         u32 pm = 999, div2, psr, stccr, mask, afreq, factor, i;
 659         unsigned long clkrate, baudrate, tmprate;
 660         u64 sub, savesub = 100000;
 661         unsigned int freq;
 662         bool baudclk_is_used;
 663
 664         /* Prefer the explicitly set bitclock frequency */
 665         if (ssi_private->bitclk_freq)
 666                 freq = ssi_private->bitclk_freq;
 667         else
 668                 freq = params_channels(hw_params) * 32 * params_rate(hw_params);
 669
 670         /* Don't apply it to any non-baudclk circumstance */
 671         if (IS_ERR(ssi_private->baudclk))
 672                 return -EINVAL;
 673
 674         /*
 675          * Hardware limitation: The bclk rate must be
 676          * never greater than 1/5 IPG clock rate
 677          */
 678         if (freq * 5 > clk_get_rate(ssi_private->clk)) {
 679                 dev_err(cpu_dai->dev, "bitclk > ipgclk/5\n");
 680                 return -EINVAL;
 681         }
 682
 683         baudclk_is_used = ssi_private->baudclk_streams & ~(BIT(substream->stream));
 684
 685         /* It should be already enough to divide clock by setting pm alone */
 686         psr = 0;
 687         div2 = 0;
 688
 689         factor = (div2 + 1) * (7 * psr + 1) * 2;
 690
 691         for (i = 0; i < 255; i++) {
 692                 tmprate = freq * factor * (i + 1);
 693
 694                 if (baudclk_is_used)
 695                         clkrate = clk_get_rate(ssi_private->baudclk);
 696                 else
 697                         clkrate = clk_round_rate(ssi_private->baudclk, tmprate);
 698
 699                 clkrate /= factor;
 700                 afreq = clkrate / (i + 1);
 701
 702                 if (freq == afreq)
 703                         sub = 0;
 704                 else if (freq / afreq == 1)
 705                         sub = freq - afreq;
 706                 else if (afreq / freq == 1)
 707                         sub = afreq - freq;
 708                 else
 709                         continue;
 710
 711                 /* Calculate the fraction */
 712                 sub *= 100000;
 713                 do_div(sub, freq);
 714
 715                 if (sub < savesub && !(i == 0 && psr == 0 && div2 == 0)) {
 716                         baudrate = tmprate;
 717                         savesub = sub;
 718                         pm = i;
 719                 }
 720
 721                 /* We are lucky */
 722                 if (savesub == 0)
 723                         break;
 724         }
 725
 726         /* No proper pm found if it is still remaining the initial value */
 727         if (pm == 999) {
 728                 dev_err(cpu_dai->dev, "failed to handle the required sysclk\n");
 729                 return -EINVAL;
 730         }
 731
 732         stccr = CCSR_SSI_SxCCR_PM(pm + 1) | (div2 ? CCSR_SSI_SxCCR_DIV2 : 0) |
 733                 (psr ? CCSR_SSI_SxCCR_PSR : 0);
 734         mask = CCSR_SSI_SxCCR_PM_MASK | CCSR_SSI_SxCCR_DIV2 |
 735                 CCSR_SSI_SxCCR_PSR;
 736
 737         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || synchronous)
 738                 regmap_update_bits(regs, CCSR_SSI_STCCR, mask, stccr);
 739         else
 740                 regmap_update_bits(regs, CCSR_SSI_SRCCR, mask, stccr);
 741
 742         if (!baudclk_is_used) {
 743                 ret = clk_set_rate(ssi_private->baudclk, baudrate);
 744                 if (ret) {
 745                         dev_err(cpu_dai->dev, "failed to set baudclk rate\n");
 746                         return -EINVAL;
 747                 }
 748         }
 749
 750         return 0;
 751 }
 752
 753 static int fsl_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
 754                 int clk_id, unsigned int freq, int dir)
 755 {
 756         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 757
 758         ssi_private->bitclk_freq = freq;
 759
 760         return 0;
 761 }
 762
 763 /**
 764  * fsl_ssi_hw_params - program the sample size
 765  *
 766  * Most of the SSI registers have been programmed in the startup function,
 767  * but the word length must be programmed here.  Unfortunately, programming
 768  * the SxCCR.WL bits requires the SSI to be temporarily disabled.  This can
 769  * cause a problem with supporting simultaneous playback and capture.  If
 770  * the SSI is already playing a stream, then that stream may be temporarily
 771  * stopped when you start capture.
 772  *
 773  * Note: The SxCCR.DC and SxCCR.PM bits are only used if the SSI is the
 774  * clock master.
 775  */
 776 static int fsl_ssi_hw_params(struct snd_pcm_substream *substream,
 777         struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *cpu_dai)
 778 {
 779         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 780         struct regmap *regs = ssi_private->regs;
 781         unsigned int channels = params_channels(hw_params);
 782         unsigned int sample_size = params_width(hw_params);
 783         u32 wl = CCSR_SSI_SxCCR_WL(sample_size);
 784         int ret;
 785         u32 scr_val;
 786         int enabled;
 787
 788         regmap_read(regs, CCSR_SSI_SCR, &scr_val);
 789         enabled = scr_val & CCSR_SSI_SCR_SSIEN;
 790
 791         /*
 792          * If we're in synchronous mode, and the SSI is already enabled,
 793          * then STCCR is already set properly.
 794          */
 795         if (enabled && ssi_private->cpu_dai_drv.symmetric_rates)
 796                 return 0;
 797
 798         if (fsl_ssi_is_i2s_master(ssi_private)) {
 799                 ret = fsl_ssi_set_bclk(substream, cpu_dai, hw_params);
 800                 if (ret)
 801                         return ret;
 802
 803                 /* Do not enable the clock if it is already enabled */
 804                 if (!(ssi_private->baudclk_streams & BIT(substream->stream))) {
 805                         ret = clk_prepare_enable(ssi_private->baudclk);
 806                         if (ret)
 807                                 return ret;
 808
 809                         ssi_private->baudclk_streams |= BIT(substream->stream);
 810                 }
 811         }
 812
 813         if (!fsl_ssi_is_ac97(ssi_private)) {
 814                 u8 i2smode;
 815                 /*
 816                  * Switch to normal net mode in order to have a frame sync
 817                  * signal every 32 bits instead of 16 bits
 818                  */
 819                 if (fsl_ssi_is_i2s_cbm_cfs(ssi_private) && sample_size == 16)
 820                         i2smode = CCSR_SSI_SCR_I2S_MODE_NORMAL |
 821                                 CCSR_SSI_SCR_NET;
 822                 else
 823                         i2smode = ssi_private->i2s_mode;
 824
 825                 regmap_update_bits(regs, CCSR_SSI_SCR,
 826                                 CCSR_SSI_SCR_NET | CCSR_SSI_SCR_I2S_MODE_MASK,
 827                                 channels == 1 ? 0 : i2smode);
 828         }
 829
 830         /*
 831          * FIXME: The documentation says that SxCCR[WL] should not be
 832          * modified while the SSI is enabled.  The only time this can
 833          * happen is if we're trying to do simultaneous playback and
 834          * capture in asynchronous mode.  Unfortunately, I have been enable
 835          * to get that to work at all on the P1022DS.  Therefore, we don't
 836          * bother to disable/enable the SSI when setting SxCCR[WL], because
 837          * the SSI will stop anyway.  Maybe one day, this will get fixed.
 838          */
 839
 840         /* In synchronous mode, the SSI uses STCCR for capture */
 841         if ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ||
 842             ssi_private->cpu_dai_drv.symmetric_rates)
 843                 regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_WL_MASK,
 844                                 wl);
 845         else
 846                 regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_WL_MASK,
 847                                 wl);
 848
 849         return 0;
 850 }
 851
 852 static int fsl_ssi_hw_free(struct snd_pcm_substream *substream,
 853                 struct snd_soc_dai *cpu_dai)
 854 {
 855         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 856         struct fsl_ssi_private *ssi_private =
 857                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 858
 859         if (fsl_ssi_is_i2s_master(ssi_private) &&
 860                         ssi_private->baudclk_streams & BIT(substream->stream)) {
 861                 clk_disable_unprepare(ssi_private->baudclk);
 862                 ssi_private->baudclk_streams &= ~BIT(substream->stream);
 863         }
 864
 865         return 0;
 866 }
 867
 868 static int _fsl_ssi_set_dai_fmt(struct device *dev,
 869                                 struct fsl_ssi_private *ssi_private,
 870                                 unsigned int fmt)
 871 {
 872         struct regmap *regs = ssi_private->regs;
 873         u32 strcr = 0, stcr, srcr, scr, mask;
 874         u8 wm;
 875
 876         ssi_private->dai_fmt = fmt;
 877
 878         if (fsl_ssi_is_i2s_master(ssi_private) && IS_ERR(ssi_private->baudclk)) {
 879                 dev_err(dev, "baudclk is missing which is necessary for master mode\n");
 880                 return -EINVAL;
 881         }
 882
 883         fsl_ssi_setup_reg_vals(ssi_private);
 884
 885         regmap_read(regs, CCSR_SSI_SCR, &scr);
 886         scr &= ~(CCSR_SSI_SCR_SYN | CCSR_SSI_SCR_I2S_MODE_MASK);
 887         scr |= CCSR_SSI_SCR_SYNC_TX_FS;
 888
 889         mask = CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR |
 890                 CCSR_SSI_STCR_TSCKP | CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TFSL |
 891                 CCSR_SSI_STCR_TEFS;
 892         regmap_read(regs, CCSR_SSI_STCR, &stcr);
 893         regmap_read(regs, CCSR_SSI_SRCR, &srcr);
 894         stcr &= ~mask;
 895         srcr &= ~mask;
 896
 897         ssi_private->i2s_mode = CCSR_SSI_SCR_NET;
 898         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 899         case SND_SOC_DAIFMT_I2S:
 900                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 901                 case SND_SOC_DAIFMT_CBM_CFS:
 902                 case SND_SOC_DAIFMT_CBS_CFS:
 903                         ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_MASTER;
 904                         regmap_update_bits(regs, CCSR_SSI_STCCR,
 905                                         CCSR_SSI_SxCCR_DC_MASK,
 906                                         CCSR_SSI_SxCCR_DC(2));
 907                         regmap_update_bits(regs, CCSR_SSI_SRCCR,
 908                                         CCSR_SSI_SxCCR_DC_MASK,
 909                                         CCSR_SSI_SxCCR_DC(2));
 910                         break;
 911                 case SND_SOC_DAIFMT_CBM_CFM:
 912                         ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_SLAVE;
 913                         break;
 914                 default:
 915                         return -EINVAL;
 916                 }
 917
 918                 /* Data on rising edge of bclk, frame low, 1clk before data */
 919                 strcr |= CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TSCKP |
 920                         CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
 921                 break;
 922         case SND_SOC_DAIFMT_LEFT_J:
 923                 /* Data on rising edge of bclk, frame high */
 924                 strcr |= CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TSCKP;
 925                 break;
 926         case SND_SOC_DAIFMT_DSP_A:
 927                 /* Data on rising edge of bclk, frame high, 1clk before data */
 928                 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
 929                         CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
 930                 break;
 931         case SND_SOC_DAIFMT_DSP_B:
 932                 /* Data on rising edge of bclk, frame high */
 933                 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
 934                         CCSR_SSI_STCR_TXBIT0;
 935                 break;
 936         case SND_SOC_DAIFMT_AC97:
 937                 ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_NORMAL;
 938                 break;
 939         default:
 940                 return -EINVAL;
 941         }
 942         scr |= ssi_private->i2s_mode;
 943
 944         /* DAI clock inversion */
 945         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 946         case SND_SOC_DAIFMT_NB_NF:
 947                 /* Nothing to do for both normal cases */
 948                 break;
 949         case SND_SOC_DAIFMT_IB_NF:
 950                 /* Invert bit clock */
 951                 strcr ^= CCSR_SSI_STCR_TSCKP;
 952                 break;
 953         case SND_SOC_DAIFMT_NB_IF:
 954                 /* Invert frame clock */
 955                 strcr ^= CCSR_SSI_STCR_TFSI;
 956                 break;
 957         case SND_SOC_DAIFMT_IB_IF:
 958                 /* Invert both clocks */
 959                 strcr ^= CCSR_SSI_STCR_TSCKP;
 960                 strcr ^= CCSR_SSI_STCR_TFSI;
 961                 break;
 962         default:
 963                 return -EINVAL;
 964         }
 965
 966         /* DAI clock master masks */
 967         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 968         case SND_SOC_DAIFMT_CBS_CFS:
 969                 strcr |= CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR;
 970                 scr |= CCSR_SSI_SCR_SYS_CLK_EN;
 971                 break;
 972         case SND_SOC_DAIFMT_CBM_CFM:
 973                 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
 974                 break;
 975         case SND_SOC_DAIFMT_CBM_CFS:
 976                 strcr &= ~CCSR_SSI_STCR_TXDIR;
 977                 strcr |= CCSR_SSI_STCR_TFDIR;
 978                 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
 979                 break;
 980         default:
 981                 if (!fsl_ssi_is_ac97(ssi_private))
 982                         return -EINVAL;
 983         }
 984
 985         stcr |= strcr;
 986         srcr |= strcr;
 987
 988         if (ssi_private->cpu_dai_drv.symmetric_rates
 989                         || fsl_ssi_is_ac97(ssi_private)) {
 990                 /* Need to clear RXDIR when using SYNC or AC97 mode */
 991                 srcr &= ~CCSR_SSI_SRCR_RXDIR;
 992                 scr |= CCSR_SSI_SCR_SYN;
 993         }
 994
 995         regmap_write(regs, CCSR_SSI_STCR, stcr);
 996         regmap_write(regs, CCSR_SSI_SRCR, srcr);
 997         regmap_write(regs, CCSR_SSI_SCR, scr);
 998
 999         /*
1000          * Set the watermark for transmit FIFI 0 and receive FIFO 0. We don't
1001          * use FIFO 1. We program the transmit water to signal a DMA transfer
1002          * if there are only two (or fewer) elements left in the FIFO. Two
1003          * elements equals one frame (left channel, right channel). This value,
1004          * however, depends on the depth of the transmit buffer.
1005          *
1006          * We set the watermark on the same level as the DMA burstsize.  For
1007          * fiq it is probably better to use the biggest possible watermark
1008          * size.
1009          */
1010         if (ssi_private->use_dma)
1011                 wm = ssi_private->fifo_depth - 2;
1012         else
1013                 wm = ssi_private->fifo_depth;
1014
1015         regmap_write(regs, CCSR_SSI_SFCSR,
1016                         CCSR_SSI_SFCSR_TFWM0(wm) | CCSR_SSI_SFCSR_RFWM0(wm) |
1017                         CCSR_SSI_SFCSR_TFWM1(wm) | CCSR_SSI_SFCSR_RFWM1(wm));
1018
1019         if (ssi_private->use_dual_fifo) {
1020                 regmap_update_bits(regs, CCSR_SSI_SRCR, CCSR_SSI_SRCR_RFEN1,
1021                                 CCSR_SSI_SRCR_RFEN1);
1022                 regmap_update_bits(regs, CCSR_SSI_STCR, CCSR_SSI_STCR_TFEN1,
1023                                 CCSR_SSI_STCR_TFEN1);
1024                 regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_TCH_EN,
1025                                 CCSR_SSI_SCR_TCH_EN);
1026         }
1027
1028         if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_AC97)
1029                 fsl_ssi_setup_ac97(ssi_private);
1030
1031         return 0;
1032
1033 }
1034
1035 /**
1036  * fsl_ssi_set_dai_fmt - configure Digital Audio Interface Format.
1037  */
1038 static int fsl_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
1039 {
1040         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
1041
1042         return _fsl_ssi_set_dai_fmt(cpu_dai->dev, ssi_private, fmt);
1043 }
1044
1045 /**
1046  * fsl_ssi_set_dai_tdm_slot - set TDM slot number
1047  *
1048  * Note: This function can be only called when using SSI as DAI master
1049  */
1050 static int fsl_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
1051                                 u32 rx_mask, int slots, int slot_width)
1052 {
1053         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
1054         struct regmap *regs = ssi_private->regs;
1055         u32 val;
1056
1057         /* The slot number should be >= 2 if using Network mode or I2S mode */
1058         regmap_read(regs, CCSR_SSI_SCR, &val);
1059         val &= CCSR_SSI_SCR_I2S_MODE_MASK | CCSR_SSI_SCR_NET;
1060         if (val && slots < 2) {
1061                 dev_err(cpu_dai->dev, "slot number should be >= 2 in I2S or NET\n");
1062                 return -EINVAL;
1063         }
1064
1065         regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_DC_MASK,
1066                         CCSR_SSI_SxCCR_DC(slots));
1067         regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_DC_MASK,
1068                         CCSR_SSI_SxCCR_DC(slots));
1069
1070         /* The register SxMSKs needs SSI to provide essential clock due to
1071          * hardware design. So we here temporarily enable SSI to set them.
1072          */
1073         regmap_read(regs, CCSR_SSI_SCR, &val);
1074         val &= CCSR_SSI_SCR_SSIEN;
1075         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN,
1076                         CCSR_SSI_SCR_SSIEN);
1077
1078         regmap_write(regs, CCSR_SSI_STMSK, ~tx_mask);
1079         regmap_write(regs, CCSR_SSI_SRMSK, ~rx_mask);
1080
1081         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN, val);
1082
1083         return 0;
1084 }
1085
1086 /**
1087  * fsl_ssi_trigger: start and stop the DMA transfer.
1088  *
1089  * This function is called by ALSA to start, stop, pause, and resume the DMA
1090  * transfer of data.
1091  *
1092  * The DMA channel is in external master start and pause mode, which
1093  * means the SSI completely controls the flow of data.
1094  */
1095 static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
1096                            struct snd_soc_dai *dai)
1097 {
1098         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1099         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(rtd->cpu_dai);
1100         struct regmap *regs = ssi_private->regs;
1101
1102         switch (cmd) {
1103         case SNDRV_PCM_TRIGGER_START:
1104         case SNDRV_PCM_TRIGGER_RESUME:
1105         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1106                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1107                         fsl_ssi_tx_config(ssi_private, true);
1108                 else
1109                         fsl_ssi_rx_config(ssi_private, true);
1110                 break;
1111
1112         case SNDRV_PCM_TRIGGER_STOP:
1113         case SNDRV_PCM_TRIGGER_SUSPEND:
1114         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1115                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1116                         fsl_ssi_tx_config(ssi_private, false);
1117                 else
1118                         fsl_ssi_rx_config(ssi_private, false);
1119                 break;
1120
1121         default:
1122                 return -EINVAL;
1123         }
1124
1125         if (fsl_ssi_is_ac97(ssi_private)) {
1126                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1127                         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_TX_CLR);
1128                 else
1129                         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_RX_CLR);
1130         }
1131
1132         return 0;
1133 }
1134
1135 static int fsl_ssi_dai_probe(struct snd_soc_dai *dai)
1136 {
1137         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(dai);
1138
1139         if (ssi_private->soc->imx && ssi_private->use_dma) {
1140                 dai->playback_dma_data = &ssi_private->dma_params_tx;
1141                 dai->capture_dma_data = &ssi_private->dma_params_rx;
1142         }
1143
1144         return 0;
1145 }
1146
1147 static const struct snd_soc_dai_ops fsl_ssi_dai_ops = {
1148         .startup        = fsl_ssi_startup,
1149         .shutdown       = fsl_ssi_shutdown,
1150         .hw_params      = fsl_ssi_hw_params,
1151         .hw_free        = fsl_ssi_hw_free,
1152         .set_fmt        = fsl_ssi_set_dai_fmt,
1153         .set_sysclk     = fsl_ssi_set_dai_sysclk,
1154         .set_tdm_slot   = fsl_ssi_set_dai_tdm_slot,
1155         .trigger        = fsl_ssi_trigger,
1156 };
1157
1158 /* Template for the CPU dai driver structure */
1159 static struct snd_soc_dai_driver fsl_ssi_dai_template = {
1160         .probe = fsl_ssi_dai_probe,
1161         .playback = {
1162                 .stream_name = "CPU-Playback",
1163                 .channels_min = 1,
1164                 .channels_max = 32,
1165                 .rates = FSLSSI_I2S_RATES,
1166                 .formats = FSLSSI_I2S_FORMATS,
1167         },
1168         .capture = {
1169                 .stream_name = "CPU-Capture",
1170                 .channels_min = 1,
1171                 .channels_max = 32,
1172                 .rates = FSLSSI_I2S_RATES,
1173                 .formats = FSLSSI_I2S_FORMATS,
1174         },
1175         .ops = &fsl_ssi_dai_ops,
1176 };
1177
1178 static const struct snd_soc_component_driver fsl_ssi_component = {
1179         .name           = "fsl-ssi",
1180 };
1181
1182 static struct snd_soc_dai_driver fsl_ssi_ac97_dai = {
1183         .bus_control = true,
1184         .probe = fsl_ssi_dai_probe,
1185         .playback = {
1186                 .stream_name = "AC97 Playback",
1187                 .channels_min = 2,
1188                 .channels_max = 2,
1189                 .rates = SNDRV_PCM_RATE_8000_48000,
1190                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1191         },
1192         .capture = {
1193                 .stream_name = "AC97 Capture",
1194                 .channels_min = 2,
1195                 .channels_max = 2,
1196                 .rates = SNDRV_PCM_RATE_48000,
1197                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1198         },
1199         .ops = &fsl_ssi_dai_ops,
1200 };
1201
1202
1203 static struct fsl_ssi_private *fsl_ac97_data;
1204
1205 static void fsl_ssi_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
1206                 unsigned short val)
1207 {
1208         struct regmap *regs = fsl_ac97_data->regs;
1209         unsigned int lreg;
1210         unsigned int lval;
1211         int ret;
1212
1213         if (reg > 0x7f)
1214                 return;
1215
1216         ret = clk_prepare_enable(fsl_ac97_data->clk);
1217         if (ret) {
1218                 pr_err("ac97 write clk_prepare_enable failed: %d\n",
1219                         ret);
1220                 return;
1221         }
1222
1223         lreg = reg <<  12;
1224         regmap_write(regs, CCSR_SSI_SACADD, lreg);
1225
1226         lval = val << 4;
1227         regmap_write(regs, CCSR_SSI_SACDAT, lval);
1228
1229         regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1230                         CCSR_SSI_SACNT_WR);
1231         udelay(100);
1232
1233         clk_disable_unprepare(fsl_ac97_data->clk);
1234 }
1235
1236 static unsigned short fsl_ssi_ac97_read(struct snd_ac97 *ac97,
1237                 unsigned short reg)
1238 {
1239         struct regmap *regs = fsl_ac97_data->regs;
1240
1241         unsigned short val = -1;
1242         u32 reg_val;
1243         unsigned int lreg;
1244         int ret;
1245
1246         ret = clk_prepare_enable(fsl_ac97_data->clk);
1247         if (ret) {
1248                 pr_err("ac97 read clk_prepare_enable failed: %d\n",
1249                         ret);
1250                 return -1;
1251         }
1252
1253         lreg = (reg & 0x7f) <<  12;
1254         regmap_write(regs, CCSR_SSI_SACADD, lreg);
1255         regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1256                         CCSR_SSI_SACNT_RD);
1257
1258         udelay(100);
1259
1260         regmap_read(regs, CCSR_SSI_SACDAT, &reg_val);
1261         val = (reg_val >> 4) & 0xffff;
1262
1263         clk_disable_unprepare(fsl_ac97_data->clk);
1264
1265         return val;
1266 }
1267
1268 static struct snd_ac97_bus_ops fsl_ssi_ac97_ops = {
1269         .read           = fsl_ssi_ac97_read,
1270         .write          = fsl_ssi_ac97_write,
1271 };
1272
1273 /**
1274  * Make every character in a string lower-case
1275  */
1276 static void make_lowercase(char *s)
1277 {
1278         char *p = s;
1279         char c;
1280
1281         while ((c = *p)) {
1282                 if ((c >= 'A') && (c <= 'Z'))
1283                         *p = c + ('a' - 'A');
1284                 p++;
1285         }
1286 }
1287
1288 static int fsl_ssi_imx_probe(struct platform_device *pdev,
1289                 struct fsl_ssi_private *ssi_private, void __iomem *iomem)
1290 {
1291         struct device_node *np = pdev->dev.of_node;
1292         u32 dmas[4];
1293         int ret;
1294
1295         if (ssi_private->has_ipg_clk_name)
1296                 ssi_private->clk = devm_clk_get(&pdev->dev, "ipg");
1297         else
1298                 ssi_private->clk = devm_clk_get(&pdev->dev, NULL);
1299         if (IS_ERR(ssi_private->clk)) {
1300                 ret = PTR_ERR(ssi_private->clk);
1301                 dev_err(&pdev->dev, "could not get clock: %d\n", ret);
1302                 return ret;
1303         }
1304
1305         if (!ssi_private->has_ipg_clk_name) {
1306                 ret = clk_prepare_enable(ssi_private->clk);
1307                 if (ret) {
1308                         dev_err(&pdev->dev, "clk_prepare_enable failed: %d\n", ret);
1309                         return ret;
1310                 }
1311         }
1312
1313         /* For those SLAVE implementations, we ignore non-baudclk cases
1314          * and, instead, abandon MASTER mode that needs baud clock.
1315          */
1316         ssi_private->baudclk = devm_clk_get(&pdev->dev, "baud");
1317         if (IS_ERR(ssi_private->baudclk))
1318                 dev_dbg(&pdev->dev, "could not get baud clock: %ld\n",
1319                          PTR_ERR(ssi_private->baudclk));
1320
1321         /*
1322          * We have burstsize be "fifo_depth - 2" to match the SSI
1323          * watermark setting in fsl_ssi_startup().
1324          */
1325         ssi_private->dma_params_tx.maxburst = ssi_private->fifo_depth - 2;
1326         ssi_private->dma_params_rx.maxburst = ssi_private->fifo_depth - 2;
1327         ssi_private->dma_params_tx.addr = ssi_private->ssi_phys + CCSR_SSI_STX0;
1328         ssi_private->dma_params_rx.addr = ssi_private->ssi_phys + CCSR_SSI_SRX0;
1329
1330         ret = of_property_read_u32_array(np, "dmas", dmas, 4);
1331         if (ssi_private->use_dma && !ret && dmas[2] == IMX_DMATYPE_SSI_DUAL) {
1332                 ssi_private->use_dual_fifo = true;
1333                 /* When using dual fifo mode, we need to keep watermark
1334                  * as even numbers due to dma script limitation.
1335                  */
1336                 ssi_private->dma_params_tx.maxburst &= ~0x1;
1337                 ssi_private->dma_params_rx.maxburst &= ~0x1;
1338         }
1339
1340         if (!ssi_private->use_dma) {
1341
1342                 /*
1343                  * Some boards use an incompatible codec. To get it
1344                  * working, we are using imx-fiq-pcm-audio, that
1345                  * can handle those codecs. DMA is not possible in this
1346                  * situation.
1347                  */
1348
1349                 ssi_private->fiq_params.irq = ssi_private->irq;
1350                 ssi_private->fiq_params.base = iomem;
1351                 ssi_private->fiq_params.dma_params_rx =
1352                         &ssi_private->dma_params_rx;
1353                 ssi_private->fiq_params.dma_params_tx =
1354                         &ssi_private->dma_params_tx;
1355
1356                 ret = imx_pcm_fiq_init(pdev, &ssi_private->fiq_params);
1357                 if (ret)
1358                         goto error_pcm;
1359         } else {
1360                 ret = imx_pcm_dma_init(pdev, IMX_SSI_DMABUF_SIZE);
1361                 if (ret)
1362                         goto error_pcm;
1363         }
1364
1365         return 0;
1366
1367 error_pcm:
1368
1369         if (!ssi_private->has_ipg_clk_name)
1370                 clk_disable_unprepare(ssi_private->clk);
1371         return ret;
1372 }
1373
1374 static void fsl_ssi_imx_clean(struct platform_device *pdev,
1375                 struct fsl_ssi_private *ssi_private)
1376 {
1377         if (!ssi_private->use_dma)
1378                 imx_pcm_fiq_exit(pdev);
1379         if (!ssi_private->has_ipg_clk_name)
1380                 clk_disable_unprepare(ssi_private->clk);
1381 }
1382
1383 static int fsl_ssi_probe(struct platform_device *pdev)
1384 {
1385         struct fsl_ssi_private *ssi_private;
1386         int ret = 0;
1387         struct device_node *np = pdev->dev.of_node;
1388         const struct of_device_id *of_id;
1389         const char *p, *sprop;
1390         const uint32_t *iprop;
1391         struct resource *res;
1392         void __iomem *iomem;
1393         char name[64];
1394         struct regmap_config regconfig = fsl_ssi_regconfig;
1395
1396         of_id = of_match_device(fsl_ssi_ids, &pdev->dev);
1397         if (!of_id || !of_id->data)
1398                 return -EINVAL;
1399
1400         ssi_private = devm_kzalloc(&pdev->dev, sizeof(*ssi_private),
1401                         GFP_KERNEL);
1402         if (!ssi_private) {
1403                 dev_err(&pdev->dev, "could not allocate DAI object\n");
1404                 return -ENOMEM;
1405         }
1406
1407         ssi_private->soc = of_id->data;
1408         ssi_private->dev = &pdev->dev;
1409
1410         sprop = of_get_property(np, "fsl,mode", NULL);
1411         if (sprop) {
1412                 if (!strcmp(sprop, "ac97-slave"))
1413                         ssi_private->dai_fmt = SND_SOC_DAIFMT_AC97;
1414         }
1415
1416         ssi_private->use_dma = !of_property_read_bool(np,
1417                         "fsl,fiq-stream-filter");
1418
1419         if (fsl_ssi_is_ac97(ssi_private)) {
1420                 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_ac97_dai,
1421                                 sizeof(fsl_ssi_ac97_dai));
1422
1423                 fsl_ac97_data = ssi_private;
1424
1425                 ret = snd_soc_set_ac97_ops_of_reset(&fsl_ssi_ac97_ops, pdev);
1426                 if (ret) {
1427                         dev_err(&pdev->dev, "could not set AC'97 ops\n");
1428                         return ret;
1429                 }
1430         } else {
1431                 /* Initialize this copy of the CPU DAI driver structure */
1432                 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template,
1433                        sizeof(fsl_ssi_dai_template));
1434         }
1435         ssi_private->cpu_dai_drv.name = dev_name(&pdev->dev);
1436
1437         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1438         iomem = devm_ioremap_resource(&pdev->dev, res);
1439         if (IS_ERR(iomem))
1440                 return PTR_ERR(iomem);
1441         ssi_private->ssi_phys = res->start;
1442
1443         if (ssi_private->soc->imx21regs) {
1444                 /*
1445                  * According to datasheet imx21-class SSI
1446                  * don't have SACC{ST,EN,DIS} regs.
1447                  */
1448                 regconfig.max_register = CCSR_SSI_SRMSK;
1449                 regconfig.num_reg_defaults_raw =
1450                         CCSR_SSI_SRMSK / sizeof(uint32_t) + 1;
1451         }
1452
1453         ret = of_property_match_string(np, "clock-names", "ipg");
1454         if (ret < 0) {
1455                 ssi_private->has_ipg_clk_name = false;
1456                 ssi_private->regs = devm_regmap_init_mmio(&pdev->dev, iomem,
1457                         &regconfig);
1458         } else {
1459                 ssi_private->has_ipg_clk_name = true;
1460                 ssi_private->regs = devm_regmap_init_mmio_clk(&pdev->dev,
1461                         "ipg", iomem, &regconfig);
1462         }
1463         if (IS_ERR(ssi_private->regs)) {
1464                 dev_err(&pdev->dev, "Failed to init register map\n");
1465                 return PTR_ERR(ssi_private->regs);
1466         }
1467
1468         ssi_private->irq = platform_get_irq(pdev, 0);
1469         if (ssi_private->irq < 0) {
1470                 dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
1471                 return ssi_private->irq;
1472         }
1473
1474         /* Are the RX and the TX clocks locked? */
1475         if (!of_find_property(np, "fsl,ssi-asynchronous", NULL)) {
1476                 if (!fsl_ssi_is_ac97(ssi_private))
1477                         ssi_private->cpu_dai_drv.symmetric_rates = 1;
1478
1479                 ssi_private->cpu_dai_drv.symmetric_channels = 1;
1480                 ssi_private->cpu_dai_drv.symmetric_samplebits = 1;
1481         }
1482
1483         /* Determine the FIFO depth. */
1484         iprop = of_get_property(np, "fsl,fifo-depth", NULL);
1485         if (iprop)
1486                 ssi_private->fifo_depth = be32_to_cpup(iprop);
1487         else
1488                 /* Older 8610 DTs didn't have the fifo-depth property */
1489                 ssi_private->fifo_depth = 8;
1490
1491         dev_set_drvdata(&pdev->dev, ssi_private);
1492
1493         if (ssi_private->soc->imx) {
1494                 ret = fsl_ssi_imx_probe(pdev, ssi_private, iomem);
1495                 if (ret)
1496                         return ret;
1497         }
1498
1499         ret = devm_snd_soc_register_component(&pdev->dev, &fsl_ssi_component,
1500                                               &ssi_private->cpu_dai_drv, 1);
1501         if (ret) {
1502                 dev_err(&pdev->dev, "failed to register DAI: %d\n", ret);
1503                 goto error_asoc_register;
1504         }
1505
1506         if (ssi_private->use_dma) {
1507                 ret = devm_request_irq(&pdev->dev, ssi_private->irq,
1508                                         fsl_ssi_isr, 0, dev_name(&pdev->dev),
1509                                         ssi_private);
1510                 if (ret < 0) {
1511                         dev_err(&pdev->dev, "could not claim irq %u\n",
1512                                         ssi_private->irq);
1513                         goto error_asoc_register;
1514                 }
1515         }
1516
1517         ret = fsl_ssi_debugfs_create(&ssi_private->dbg_stats, &pdev->dev);
1518         if (ret)
1519                 goto error_asoc_register;
1520
1521         /*
1522          * If codec-handle property is missing from SSI node, we assume
1523          * that the machine driver uses new binding which does not require
1524          * SSI driver to trigger machine driver's probe.
1525          */
1526         if (!of_get_property(np, "codec-handle", NULL))
1527                 goto done;
1528
1529         /* Trigger the machine driver's probe function.  The platform driver
1530          * name of the machine driver is taken from /compatible property of the
1531          * device tree.  We also pass the address of the CPU DAI driver
1532          * structure.
1533          */
1534         sprop = of_get_property(of_find_node_by_path("/"), "compatible", NULL);
1535         /* Sometimes the compatible name has a "fsl," prefix, so we strip it. */
1536         p = strrchr(sprop, ',');
1537         if (p)
1538                 sprop = p + 1;
1539         snprintf(name, sizeof(name), "snd-soc-%s", sprop);
1540         make_lowercase(name);
1541
1542         ssi_private->pdev =
1543                 platform_device_register_data(&pdev->dev, name, 0, NULL, 0);
1544         if (IS_ERR(ssi_private->pdev)) {
1545                 ret = PTR_ERR(ssi_private->pdev);
1546                 dev_err(&pdev->dev, "failed to register platform: %d\n", ret);
1547                 goto error_sound_card;
1548         }
1549
1550 done:
1551         if (ssi_private->dai_fmt)
1552                 _fsl_ssi_set_dai_fmt(&pdev->dev, ssi_private,
1553                                      ssi_private->dai_fmt);
1554
1555         if (fsl_ssi_is_ac97(ssi_private)) {
1556                 u32 ssi_idx;
1557
1558                 ret = of_property_read_u32(np, "cell-index", &ssi_idx);
1559                 if (ret) {
1560                         dev_err(&pdev->dev, "cannot get SSI index property\n");
1561                         goto error_sound_card;
1562                 }
1563
1564                 ssi_private->pdev =
1565                         platform_device_register_data(NULL,
1566                                         "ac97-codec", ssi_idx, NULL, 0);
1567                 if (IS_ERR(ssi_private->pdev)) {
1568                         ret = PTR_ERR(ssi_private->pdev);
1569                         dev_err(&pdev->dev,
1570                                 "failed to register AC97 codec platform: %d\n",
1571                                 ret);
1572                         goto error_sound_card;
1573                 }
1574         }
1575
1576         return 0;
1577
1578 error_sound_card:
1579         fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1580
1581 error_asoc_register:
1582         if (ssi_private->soc->imx)
1583                 fsl_ssi_imx_clean(pdev, ssi_private);
1584
1585         return ret;
1586 }
1587
1588 static int fsl_ssi_remove(struct platform_device *pdev)
1589 {
1590         struct fsl_ssi_private *ssi_private = dev_get_drvdata(&pdev->dev);
1591
1592         fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1593
1594         if (ssi_private->pdev)
1595                 platform_device_unregister(ssi_private->pdev);
1596
1597         if (ssi_private->soc->imx)
1598                 fsl_ssi_imx_clean(pdev, ssi_private);
1599
1600         if (fsl_ssi_is_ac97(ssi_private))
1601                 snd_soc_set_ac97_ops(NULL);
1602
1603         return 0;
1604 }
1605
1606 #ifdef CONFIG_PM_SLEEP
1607 static int fsl_ssi_suspend(struct device *dev)
1608 {
1609         struct fsl_ssi_private *ssi_private = dev_get_drvdata(dev);
1610         struct regmap *regs = ssi_private->regs;
1611
1612         regmap_read(regs, CCSR_SSI_SFCSR,
1613                         &ssi_private->regcache_sfcsr);
1614         regmap_read(regs, CCSR_SSI_SACNT,
1615                         &ssi_private->regcache_sacnt);
1616
1617         regcache_cache_only(regs, true);
1618         regcache_mark_dirty(regs);
1619
1620         return 0;
1621 }
1622
1623 static int fsl_ssi_resume(struct device *dev)
1624 {
1625         struct fsl_ssi_private *ssi_private = dev_get_drvdata(dev);
1626         struct regmap *regs = ssi_private->regs;
1627
1628         regcache_cache_only(regs, false);
1629
1630         regmap_update_bits(regs, CCSR_SSI_SFCSR,
1631                         CCSR_SSI_SFCSR_RFWM1_MASK | CCSR_SSI_SFCSR_TFWM1_MASK |
1632                         CCSR_SSI_SFCSR_RFWM0_MASK | CCSR_SSI_SFCSR_TFWM0_MASK,
1633                         ssi_private->regcache_sfcsr);
1634         regmap_write(regs, CCSR_SSI_SACNT,
1635                         ssi_private->regcache_sacnt);
1636
1637         return regcache_sync(regs);
1638 }
1639 #endif /* CONFIG_PM_SLEEP */
1640
1641 static const struct dev_pm_ops fsl_ssi_pm = {
1642         SET_SYSTEM_SLEEP_PM_OPS(fsl_ssi_suspend, fsl_ssi_resume)
1643 };
1644
1645 static struct platform_driver fsl_ssi_driver = {
1646         .driver = {
1647                 .name = "fsl-ssi-dai",
1648                 .of_match_table = fsl_ssi_ids,
1649                 .pm = &fsl_ssi_pm,
1650         },
1651         .probe = fsl_ssi_probe,
1652         .remove = fsl_ssi_remove,
1653 };
1654
1655 module_platform_driver(fsl_ssi_driver);
1656
1657 MODULE_ALIAS("platform:fsl-ssi-dai");
1658 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
1659 MODULE_DESCRIPTION("Freescale Synchronous Serial Interface (SSI) ASoC Driver");
1660 MODULE_LICENSE("GPL v2");