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_SRCR, vals->srcr, vals->srcr);
 479                 regmap_update_bits(regs, CCSR_SSI_STCR, vals->stcr, vals->stcr);
 480                 regmap_update_bits(regs, CCSR_SSI_SIER, vals->sier, vals->sier);
 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                 if (ssi_private->use_dma && (vals->scr & CCSR_SSI_SCR_TE)) {
 512                         /*
 513                          * Be sure the Tx FIFO is filled when TE is set.
 514                          * Otherwise, there are some chances to start the
 515                          * playback with some void samples inserted first,
 516                          * generating a channel slip.
 517                          *
 518                          * First, SSIEN must be set, to let the FIFO be filled.
 519                          *
 520                          * Notes:
 521                          * - Limit this fix to the DMA case until FIQ cases can
 522                          *   be tested.
 523                          * - Limit the length of the busy loop to not lock the
 524                          *   system too long, even if 1-2 loops are sufficient
 525                          *   in general.
 526                          */
 527                         int i;
 528                         int max_loop = 100;
 529                         regmap_update_bits(regs, CCSR_SSI_SCR,
 530                                         CCSR_SSI_SCR_SSIEN, CCSR_SSI_SCR_SSIEN);
 531                         for (i = 0; i < max_loop; i++) {
 532                                 u32 sfcsr;
 533                                 regmap_read(regs, CCSR_SSI_SFCSR, &sfcsr);
 534                                 if (CCSR_SSI_SFCSR_TFCNT0(sfcsr))
 535                                         break;
 536                         }
 537                         if (i == max_loop) {
 538                                 dev_err(ssi_private->dev,
 539                                         "Timeout waiting TX FIFO filling\n");
 540                         }
 541                 }
 542                 regmap_update_bits(regs, CCSR_SSI_SCR, vals->scr, vals->scr);
 543         }
 544 }
 545
 546
 547 static void fsl_ssi_rx_config(struct fsl_ssi_private *ssi_private, bool enable)
 548 {
 549         fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.rx);
 550 }
 551
 552 static void fsl_ssi_tx_config(struct fsl_ssi_private *ssi_private, bool enable)
 553 {
 554         fsl_ssi_config(ssi_private, enable, &ssi_private->rxtx_reg_val.tx);
 555 }
 556
 557 /*
 558  * Setup rx/tx register values used to enable/disable the streams. These will
 559  * be used later in fsl_ssi_config to setup the streams without the need to
 560  * check for all different SSI modes.
 561  */
 562 static void fsl_ssi_setup_reg_vals(struct fsl_ssi_private *ssi_private)
 563 {
 564         struct fsl_ssi_rxtx_reg_val *reg = &ssi_private->rxtx_reg_val;
 565
 566         reg->rx.sier = CCSR_SSI_SIER_RFF0_EN;
 567         reg->rx.srcr = CCSR_SSI_SRCR_RFEN0;
 568         reg->rx.scr = 0;
 569         reg->tx.sier = CCSR_SSI_SIER_TFE0_EN;
 570         reg->tx.stcr = CCSR_SSI_STCR_TFEN0;
 571         reg->tx.scr = 0;
 572
 573         if (!fsl_ssi_is_ac97(ssi_private)) {
 574                 reg->rx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_RE;
 575                 reg->rx.sier |= CCSR_SSI_SIER_RFF0_EN;
 576                 reg->tx.scr = CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE;
 577                 reg->tx.sier |= CCSR_SSI_SIER_TFE0_EN;
 578         }
 579
 580         if (ssi_private->use_dma) {
 581                 reg->rx.sier |= CCSR_SSI_SIER_RDMAE;
 582                 reg->tx.sier |= CCSR_SSI_SIER_TDMAE;
 583         } else {
 584                 reg->rx.sier |= CCSR_SSI_SIER_RIE;
 585                 reg->tx.sier |= CCSR_SSI_SIER_TIE;
 586         }
 587
 588         reg->rx.sier |= FSLSSI_SIER_DBG_RX_FLAGS;
 589         reg->tx.sier |= FSLSSI_SIER_DBG_TX_FLAGS;
 590 }
 591
 592 static void fsl_ssi_setup_ac97(struct fsl_ssi_private *ssi_private)
 593 {
 594         struct regmap *regs = ssi_private->regs;
 595
 596         /*
 597          * Setup the clock control register
 598          */
 599         regmap_write(regs, CCSR_SSI_STCCR,
 600                         CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
 601         regmap_write(regs, CCSR_SSI_SRCCR,
 602                         CCSR_SSI_SxCCR_WL(17) | CCSR_SSI_SxCCR_DC(13));
 603
 604         /*
 605          * Enable AC97 mode and startup the SSI
 606          */
 607         regmap_write(regs, CCSR_SSI_SACNT,
 608                         CCSR_SSI_SACNT_AC97EN | CCSR_SSI_SACNT_FV);
 609
 610         /* no SACC{ST,EN,DIS} regs on imx21-class SSI */
 611         if (!ssi_private->soc->imx21regs) {
 612                 regmap_write(regs, CCSR_SSI_SACCDIS, 0xff);
 613                 regmap_write(regs, CCSR_SSI_SACCEN, 0x300);
 614         }
 615
 616         /*
 617          * Enable SSI, Transmit and Receive. AC97 has to communicate with the
 618          * codec before a stream is started.
 619          */
 620         regmap_update_bits(regs, CCSR_SSI_SCR,
 621                         CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE,
 622                         CCSR_SSI_SCR_SSIEN | CCSR_SSI_SCR_TE | CCSR_SSI_SCR_RE);
 623
 624         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_WAIT(3));
 625 }
 626
 627 /**
 628  * fsl_ssi_startup: create a new substream
 629  *
 630  * This is the first function called when a stream is opened.
 631  *
 632  * If this is the first stream open, then grab the IRQ and program most of
 633  * the SSI registers.
 634  */
 635 static int fsl_ssi_startup(struct snd_pcm_substream *substream,
 636                            struct snd_soc_dai *dai)
 637 {
 638         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 639         struct fsl_ssi_private *ssi_private =
 640                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 641         int ret;
 642
 643         ret = clk_prepare_enable(ssi_private->clk);
 644         if (ret)
 645                 return ret;
 646
 647         /* When using dual fifo mode, it is safer to ensure an even period
 648          * size. If appearing to an odd number while DMA always starts its
 649          * task from fifo0, fifo1 would be neglected at the end of each
 650          * period. But SSI would still access fifo1 with an invalid data.
 651          */
 652         if (ssi_private->use_dual_fifo)
 653                 snd_pcm_hw_constraint_step(substream->runtime, 0,
 654                                 SNDRV_PCM_HW_PARAM_PERIOD_SIZE, 2);
 655
 656         return 0;
 657 }
 658
 659 /**
 660  * fsl_ssi_shutdown: shutdown the SSI
 661  *
 662  */
 663 static void fsl_ssi_shutdown(struct snd_pcm_substream *substream,
 664                                 struct snd_soc_dai *dai)
 665 {
 666         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 667         struct fsl_ssi_private *ssi_private =
 668                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 669
 670         clk_disable_unprepare(ssi_private->clk);
 671
 672 }
 673
 674 /**
 675  * fsl_ssi_set_bclk - configure Digital Audio Interface bit clock
 676  *
 677  * Note: This function can be only called when using SSI as DAI master
 678  *
 679  * Quick instruction for parameters:
 680  * freq: Output BCLK frequency = samplerate * 32 (fixed) * channels
 681  * dir: SND_SOC_CLOCK_OUT -> TxBCLK, SND_SOC_CLOCK_IN -> RxBCLK.
 682  */
 683 static int fsl_ssi_set_bclk(struct snd_pcm_substream *substream,
 684                 struct snd_soc_dai *cpu_dai,
 685                 struct snd_pcm_hw_params *hw_params)
 686 {
 687         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 688         struct regmap *regs = ssi_private->regs;
 689         int synchronous = ssi_private->cpu_dai_drv.symmetric_rates, ret;
 690         u32 pm = 999, div2, psr, stccr, mask, afreq, factor, i;
 691         unsigned long clkrate, baudrate, tmprate;
 692         u64 sub, savesub = 100000;
 693         unsigned int freq;
 694         bool baudclk_is_used;
 695
 696         /* Prefer the explicitly set bitclock frequency */
 697         if (ssi_private->bitclk_freq)
 698                 freq = ssi_private->bitclk_freq;
 699         else
 700                 freq = params_channels(hw_params) * 32 * params_rate(hw_params);
 701
 702         /* Don't apply it to any non-baudclk circumstance */
 703         if (IS_ERR(ssi_private->baudclk))
 704                 return -EINVAL;
 705
 706         /*
 707          * Hardware limitation: The bclk rate must be
 708          * never greater than 1/5 IPG clock rate
 709          */
 710         if (freq * 5 > clk_get_rate(ssi_private->clk)) {
 711                 dev_err(cpu_dai->dev, "bitclk > ipgclk/5\n");
 712                 return -EINVAL;
 713         }
 714
 715         baudclk_is_used = ssi_private->baudclk_streams & ~(BIT(substream->stream));
 716
 717         /* It should be already enough to divide clock by setting pm alone */
 718         psr = 0;
 719         div2 = 0;
 720
 721         factor = (div2 + 1) * (7 * psr + 1) * 2;
 722
 723         for (i = 0; i < 255; i++) {
 724                 tmprate = freq * factor * (i + 1);
 725
 726                 if (baudclk_is_used)
 727                         clkrate = clk_get_rate(ssi_private->baudclk);
 728                 else
 729                         clkrate = clk_round_rate(ssi_private->baudclk, tmprate);
 730
 731                 clkrate /= factor;
 732                 afreq = clkrate / (i + 1);
 733
 734                 if (freq == afreq)
 735                         sub = 0;
 736                 else if (freq / afreq == 1)
 737                         sub = freq - afreq;
 738                 else if (afreq / freq == 1)
 739                         sub = afreq - freq;
 740                 else
 741                         continue;
 742
 743                 /* Calculate the fraction */
 744                 sub *= 100000;
 745                 do_div(sub, freq);
 746
 747                 if (sub < savesub && !(i == 0 && psr == 0 && div2 == 0)) {
 748                         baudrate = tmprate;
 749                         savesub = sub;
 750                         pm = i;
 751                 }
 752
 753                 /* We are lucky */
 754                 if (savesub == 0)
 755                         break;
 756         }
 757
 758         /* No proper pm found if it is still remaining the initial value */
 759         if (pm == 999) {
 760                 dev_err(cpu_dai->dev, "failed to handle the required sysclk\n");
 761                 return -EINVAL;
 762         }
 763
 764         stccr = CCSR_SSI_SxCCR_PM(pm + 1) | (div2 ? CCSR_SSI_SxCCR_DIV2 : 0) |
 765                 (psr ? CCSR_SSI_SxCCR_PSR : 0);
 766         mask = CCSR_SSI_SxCCR_PM_MASK | CCSR_SSI_SxCCR_DIV2 |
 767                 CCSR_SSI_SxCCR_PSR;
 768
 769         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK || synchronous)
 770                 regmap_update_bits(regs, CCSR_SSI_STCCR, mask, stccr);
 771         else
 772                 regmap_update_bits(regs, CCSR_SSI_SRCCR, mask, stccr);
 773
 774         if (!baudclk_is_used) {
 775                 ret = clk_set_rate(ssi_private->baudclk, baudrate);
 776                 if (ret) {
 777                         dev_err(cpu_dai->dev, "failed to set baudclk rate\n");
 778                         return -EINVAL;
 779                 }
 780         }
 781
 782         return 0;
 783 }
 784
 785 static int fsl_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
 786                 int clk_id, unsigned int freq, int dir)
 787 {
 788         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 789
 790         ssi_private->bitclk_freq = freq;
 791
 792         return 0;
 793 }
 794
 795 /**
 796  * fsl_ssi_hw_params - program the sample size
 797  *
 798  * Most of the SSI registers have been programmed in the startup function,
 799  * but the word length must be programmed here.  Unfortunately, programming
 800  * the SxCCR.WL bits requires the SSI to be temporarily disabled.  This can
 801  * cause a problem with supporting simultaneous playback and capture.  If
 802  * the SSI is already playing a stream, then that stream may be temporarily
 803  * stopped when you start capture.
 804  *
 805  * Note: The SxCCR.DC and SxCCR.PM bits are only used if the SSI is the
 806  * clock master.
 807  */
 808 static int fsl_ssi_hw_params(struct snd_pcm_substream *substream,
 809         struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *cpu_dai)
 810 {
 811         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
 812         struct regmap *regs = ssi_private->regs;
 813         unsigned int channels = params_channels(hw_params);
 814         unsigned int sample_size = params_width(hw_params);
 815         u32 wl = CCSR_SSI_SxCCR_WL(sample_size);
 816         int ret;
 817         u32 scr_val;
 818         int enabled;
 819
 820         regmap_read(regs, CCSR_SSI_SCR, &scr_val);
 821         enabled = scr_val & CCSR_SSI_SCR_SSIEN;
 822
 823         /*
 824          * If we're in synchronous mode, and the SSI is already enabled,
 825          * then STCCR is already set properly.
 826          */
 827         if (enabled && ssi_private->cpu_dai_drv.symmetric_rates)
 828                 return 0;
 829
 830         if (fsl_ssi_is_i2s_master(ssi_private)) {
 831                 ret = fsl_ssi_set_bclk(substream, cpu_dai, hw_params);
 832                 if (ret)
 833                         return ret;
 834
 835                 /* Do not enable the clock if it is already enabled */
 836                 if (!(ssi_private->baudclk_streams & BIT(substream->stream))) {
 837                         ret = clk_prepare_enable(ssi_private->baudclk);
 838                         if (ret)
 839                                 return ret;
 840
 841                         ssi_private->baudclk_streams |= BIT(substream->stream);
 842                 }
 843         }
 844
 845         if (!fsl_ssi_is_ac97(ssi_private)) {
 846                 u8 i2smode;
 847                 /*
 848                  * Switch to normal net mode in order to have a frame sync
 849                  * signal every 32 bits instead of 16 bits
 850                  */
 851                 if (fsl_ssi_is_i2s_cbm_cfs(ssi_private) && sample_size == 16)
 852                         i2smode = CCSR_SSI_SCR_I2S_MODE_NORMAL |
 853                                 CCSR_SSI_SCR_NET;
 854                 else
 855                         i2smode = ssi_private->i2s_mode;
 856
 857                 regmap_update_bits(regs, CCSR_SSI_SCR,
 858                                 CCSR_SSI_SCR_NET | CCSR_SSI_SCR_I2S_MODE_MASK,
 859                                 channels == 1 ? 0 : i2smode);
 860         }
 861
 862         /*
 863          * FIXME: The documentation says that SxCCR[WL] should not be
 864          * modified while the SSI is enabled.  The only time this can
 865          * happen is if we're trying to do simultaneous playback and
 866          * capture in asynchronous mode.  Unfortunately, I have been enable
 867          * to get that to work at all on the P1022DS.  Therefore, we don't
 868          * bother to disable/enable the SSI when setting SxCCR[WL], because
 869          * the SSI will stop anyway.  Maybe one day, this will get fixed.
 870          */
 871
 872         /* In synchronous mode, the SSI uses STCCR for capture */
 873         if ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ||
 874             ssi_private->cpu_dai_drv.symmetric_rates)
 875                 regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_WL_MASK,
 876                                 wl);
 877         else
 878                 regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_WL_MASK,
 879                                 wl);
 880
 881         return 0;
 882 }
 883
 884 static int fsl_ssi_hw_free(struct snd_pcm_substream *substream,
 885                 struct snd_soc_dai *cpu_dai)
 886 {
 887         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 888         struct fsl_ssi_private *ssi_private =
 889                 snd_soc_dai_get_drvdata(rtd->cpu_dai);
 890
 891         if (fsl_ssi_is_i2s_master(ssi_private) &&
 892                         ssi_private->baudclk_streams & BIT(substream->stream)) {
 893                 clk_disable_unprepare(ssi_private->baudclk);
 894                 ssi_private->baudclk_streams &= ~BIT(substream->stream);
 895         }
 896
 897         return 0;
 898 }
 899
 900 static int _fsl_ssi_set_dai_fmt(struct device *dev,
 901                                 struct fsl_ssi_private *ssi_private,
 902                                 unsigned int fmt)
 903 {
 904         struct regmap *regs = ssi_private->regs;
 905         u32 strcr = 0, stcr, srcr, scr, mask;
 906         u8 wm;
 907
 908         ssi_private->dai_fmt = fmt;
 909
 910         if (fsl_ssi_is_i2s_master(ssi_private) && IS_ERR(ssi_private->baudclk)) {
 911                 dev_err(dev, "baudclk is missing which is necessary for master mode\n");
 912                 return -EINVAL;
 913         }
 914
 915         fsl_ssi_setup_reg_vals(ssi_private);
 916
 917         regmap_read(regs, CCSR_SSI_SCR, &scr);
 918         scr &= ~(CCSR_SSI_SCR_SYN | CCSR_SSI_SCR_I2S_MODE_MASK);
 919         scr |= CCSR_SSI_SCR_SYNC_TX_FS;
 920
 921         mask = CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR |
 922                 CCSR_SSI_STCR_TSCKP | CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TFSL |
 923                 CCSR_SSI_STCR_TEFS;
 924         regmap_read(regs, CCSR_SSI_STCR, &stcr);
 925         regmap_read(regs, CCSR_SSI_SRCR, &srcr);
 926         stcr &= ~mask;
 927         srcr &= ~mask;
 928
 929         ssi_private->i2s_mode = CCSR_SSI_SCR_NET;
 930         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 931         case SND_SOC_DAIFMT_I2S:
 932                 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 933                 case SND_SOC_DAIFMT_CBM_CFS:
 934                 case SND_SOC_DAIFMT_CBS_CFS:
 935                         ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_MASTER;
 936                         regmap_update_bits(regs, CCSR_SSI_STCCR,
 937                                         CCSR_SSI_SxCCR_DC_MASK,
 938                                         CCSR_SSI_SxCCR_DC(2));
 939                         regmap_update_bits(regs, CCSR_SSI_SRCCR,
 940                                         CCSR_SSI_SxCCR_DC_MASK,
 941                                         CCSR_SSI_SxCCR_DC(2));
 942                         break;
 943                 case SND_SOC_DAIFMT_CBM_CFM:
 944                         ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_SLAVE;
 945                         break;
 946                 default:
 947                         return -EINVAL;
 948                 }
 949
 950                 /* Data on rising edge of bclk, frame low, 1clk before data */
 951                 strcr |= CCSR_SSI_STCR_TFSI | CCSR_SSI_STCR_TSCKP |
 952                         CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
 953                 break;
 954         case SND_SOC_DAIFMT_LEFT_J:
 955                 /* Data on rising edge of bclk, frame high */
 956                 strcr |= CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TSCKP;
 957                 break;
 958         case SND_SOC_DAIFMT_DSP_A:
 959                 /* Data on rising edge of bclk, frame high, 1clk before data */
 960                 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
 961                         CCSR_SSI_STCR_TXBIT0 | CCSR_SSI_STCR_TEFS;
 962                 break;
 963         case SND_SOC_DAIFMT_DSP_B:
 964                 /* Data on rising edge of bclk, frame high */
 965                 strcr |= CCSR_SSI_STCR_TFSL | CCSR_SSI_STCR_TSCKP |
 966                         CCSR_SSI_STCR_TXBIT0;
 967                 break;
 968         case SND_SOC_DAIFMT_AC97:
 969                 ssi_private->i2s_mode |= CCSR_SSI_SCR_I2S_MODE_NORMAL;
 970                 break;
 971         default:
 972                 return -EINVAL;
 973         }
 974         scr |= ssi_private->i2s_mode;
 975
 976         /* DAI clock inversion */
 977         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 978         case SND_SOC_DAIFMT_NB_NF:
 979                 /* Nothing to do for both normal cases */
 980                 break;
 981         case SND_SOC_DAIFMT_IB_NF:
 982                 /* Invert bit clock */
 983                 strcr ^= CCSR_SSI_STCR_TSCKP;
 984                 break;
 985         case SND_SOC_DAIFMT_NB_IF:
 986                 /* Invert frame clock */
 987                 strcr ^= CCSR_SSI_STCR_TFSI;
 988                 break;
 989         case SND_SOC_DAIFMT_IB_IF:
 990                 /* Invert both clocks */
 991                 strcr ^= CCSR_SSI_STCR_TSCKP;
 992                 strcr ^= CCSR_SSI_STCR_TFSI;
 993                 break;
 994         default:
 995                 return -EINVAL;
 996         }
 997
 998         /* DAI clock master masks */
 999         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1000         case SND_SOC_DAIFMT_CBS_CFS:
1001                 strcr |= CCSR_SSI_STCR_TFDIR | CCSR_SSI_STCR_TXDIR;
1002                 scr |= CCSR_SSI_SCR_SYS_CLK_EN;
1003                 break;
1004         case SND_SOC_DAIFMT_CBM_CFM:
1005                 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
1006                 break;
1007         case SND_SOC_DAIFMT_CBM_CFS:
1008                 strcr &= ~CCSR_SSI_STCR_TXDIR;
1009                 strcr |= CCSR_SSI_STCR_TFDIR;
1010                 scr &= ~CCSR_SSI_SCR_SYS_CLK_EN;
1011                 break;
1012         default:
1013                 if (!fsl_ssi_is_ac97(ssi_private))
1014                         return -EINVAL;
1015         }
1016
1017         stcr |= strcr;
1018         srcr |= strcr;
1019
1020         if (ssi_private->cpu_dai_drv.symmetric_rates
1021                         || fsl_ssi_is_ac97(ssi_private)) {
1022                 /* Need to clear RXDIR when using SYNC or AC97 mode */
1023                 srcr &= ~CCSR_SSI_SRCR_RXDIR;
1024                 scr |= CCSR_SSI_SCR_SYN;
1025         }
1026
1027         regmap_write(regs, CCSR_SSI_STCR, stcr);
1028         regmap_write(regs, CCSR_SSI_SRCR, srcr);
1029         regmap_write(regs, CCSR_SSI_SCR, scr);
1030
1031         /*
1032          * Set the watermark for transmit FIFI 0 and receive FIFO 0. We don't
1033          * use FIFO 1. We program the transmit water to signal a DMA transfer
1034          * if there are only two (or fewer) elements left in the FIFO. Two
1035          * elements equals one frame (left channel, right channel). This value,
1036          * however, depends on the depth of the transmit buffer.
1037          *
1038          * We set the watermark on the same level as the DMA burstsize.  For
1039          * fiq it is probably better to use the biggest possible watermark
1040          * size.
1041          */
1042         if (ssi_private->use_dma)
1043                 wm = ssi_private->fifo_depth - 2;
1044         else
1045                 wm = ssi_private->fifo_depth;
1046
1047         regmap_write(regs, CCSR_SSI_SFCSR,
1048                         CCSR_SSI_SFCSR_TFWM0(wm) | CCSR_SSI_SFCSR_RFWM0(wm) |
1049                         CCSR_SSI_SFCSR_TFWM1(wm) | CCSR_SSI_SFCSR_RFWM1(wm));
1050
1051         if (ssi_private->use_dual_fifo) {
1052                 regmap_update_bits(regs, CCSR_SSI_SRCR, CCSR_SSI_SRCR_RFEN1,
1053                                 CCSR_SSI_SRCR_RFEN1);
1054                 regmap_update_bits(regs, CCSR_SSI_STCR, CCSR_SSI_STCR_TFEN1,
1055                                 CCSR_SSI_STCR_TFEN1);
1056                 regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_TCH_EN,
1057                                 CCSR_SSI_SCR_TCH_EN);
1058         }
1059
1060         if ((fmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_AC97)
1061                 fsl_ssi_setup_ac97(ssi_private);
1062
1063         return 0;
1064
1065 }
1066
1067 /**
1068  * fsl_ssi_set_dai_fmt - configure Digital Audio Interface Format.
1069  */
1070 static int fsl_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
1071 {
1072         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
1073
1074         return _fsl_ssi_set_dai_fmt(cpu_dai->dev, ssi_private, fmt);
1075 }
1076
1077 /**
1078  * fsl_ssi_set_dai_tdm_slot - set TDM slot number
1079  *
1080  * Note: This function can be only called when using SSI as DAI master
1081  */
1082 static int fsl_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
1083                                 u32 rx_mask, int slots, int slot_width)
1084 {
1085         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(cpu_dai);
1086         struct regmap *regs = ssi_private->regs;
1087         u32 val;
1088
1089         /* The slot number should be >= 2 if using Network mode or I2S mode */
1090         regmap_read(regs, CCSR_SSI_SCR, &val);
1091         val &= CCSR_SSI_SCR_I2S_MODE_MASK | CCSR_SSI_SCR_NET;
1092         if (val && slots < 2) {
1093                 dev_err(cpu_dai->dev, "slot number should be >= 2 in I2S or NET\n");
1094                 return -EINVAL;
1095         }
1096
1097         regmap_update_bits(regs, CCSR_SSI_STCCR, CCSR_SSI_SxCCR_DC_MASK,
1098                         CCSR_SSI_SxCCR_DC(slots));
1099         regmap_update_bits(regs, CCSR_SSI_SRCCR, CCSR_SSI_SxCCR_DC_MASK,
1100                         CCSR_SSI_SxCCR_DC(slots));
1101
1102         /* The register SxMSKs needs SSI to provide essential clock due to
1103          * hardware design. So we here temporarily enable SSI to set them.
1104          */
1105         regmap_read(regs, CCSR_SSI_SCR, &val);
1106         val &= CCSR_SSI_SCR_SSIEN;
1107         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN,
1108                         CCSR_SSI_SCR_SSIEN);
1109
1110         regmap_write(regs, CCSR_SSI_STMSK, ~tx_mask);
1111         regmap_write(regs, CCSR_SSI_SRMSK, ~rx_mask);
1112
1113         regmap_update_bits(regs, CCSR_SSI_SCR, CCSR_SSI_SCR_SSIEN, val);
1114
1115         return 0;
1116 }
1117
1118 /**
1119  * fsl_ssi_trigger: start and stop the DMA transfer.
1120  *
1121  * This function is called by ALSA to start, stop, pause, and resume the DMA
1122  * transfer of data.
1123  *
1124  * The DMA channel is in external master start and pause mode, which
1125  * means the SSI completely controls the flow of data.
1126  */
1127 static int fsl_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
1128                            struct snd_soc_dai *dai)
1129 {
1130         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1131         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(rtd->cpu_dai);
1132         struct regmap *regs = ssi_private->regs;
1133
1134         switch (cmd) {
1135         case SNDRV_PCM_TRIGGER_START:
1136         case SNDRV_PCM_TRIGGER_RESUME:
1137         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
1138                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1139                         fsl_ssi_tx_config(ssi_private, true);
1140                 else
1141                         fsl_ssi_rx_config(ssi_private, true);
1142                 break;
1143
1144         case SNDRV_PCM_TRIGGER_STOP:
1145         case SNDRV_PCM_TRIGGER_SUSPEND:
1146         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1147                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1148                         fsl_ssi_tx_config(ssi_private, false);
1149                 else
1150                         fsl_ssi_rx_config(ssi_private, false);
1151                 break;
1152
1153         default:
1154                 return -EINVAL;
1155         }
1156
1157         if (fsl_ssi_is_ac97(ssi_private)) {
1158                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1159                         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_TX_CLR);
1160                 else
1161                         regmap_write(regs, CCSR_SSI_SOR, CCSR_SSI_SOR_RX_CLR);
1162         }
1163
1164         return 0;
1165 }
1166
1167 static int fsl_ssi_dai_probe(struct snd_soc_dai *dai)
1168 {
1169         struct fsl_ssi_private *ssi_private = snd_soc_dai_get_drvdata(dai);
1170
1171         if (ssi_private->soc->imx && ssi_private->use_dma) {
1172                 dai->playback_dma_data = &ssi_private->dma_params_tx;
1173                 dai->capture_dma_data = &ssi_private->dma_params_rx;
1174         }
1175
1176         return 0;
1177 }
1178
1179 static const struct snd_soc_dai_ops fsl_ssi_dai_ops = {
1180         .startup        = fsl_ssi_startup,
1181         .shutdown       = fsl_ssi_shutdown,
1182         .hw_params      = fsl_ssi_hw_params,
1183         .hw_free        = fsl_ssi_hw_free,
1184         .set_fmt        = fsl_ssi_set_dai_fmt,
1185         .set_sysclk     = fsl_ssi_set_dai_sysclk,
1186         .set_tdm_slot   = fsl_ssi_set_dai_tdm_slot,
1187         .trigger        = fsl_ssi_trigger,
1188 };
1189
1190 /* Template for the CPU dai driver structure */
1191 static struct snd_soc_dai_driver fsl_ssi_dai_template = {
1192         .probe = fsl_ssi_dai_probe,
1193         .playback = {
1194                 .stream_name = "CPU-Playback",
1195                 .channels_min = 1,
1196                 .channels_max = 32,
1197                 .rates = FSLSSI_I2S_RATES,
1198                 .formats = FSLSSI_I2S_FORMATS,
1199         },
1200         .capture = {
1201                 .stream_name = "CPU-Capture",
1202                 .channels_min = 1,
1203                 .channels_max = 32,
1204                 .rates = FSLSSI_I2S_RATES,
1205                 .formats = FSLSSI_I2S_FORMATS,
1206         },
1207         .ops = &fsl_ssi_dai_ops,
1208 };
1209
1210 static const struct snd_soc_component_driver fsl_ssi_component = {
1211         .name           = "fsl-ssi",
1212 };
1213
1214 static struct snd_soc_dai_driver fsl_ssi_ac97_dai = {
1215         .bus_control = true,
1216         .probe = fsl_ssi_dai_probe,
1217         .playback = {
1218                 .stream_name = "AC97 Playback",
1219                 .channels_min = 2,
1220                 .channels_max = 2,
1221                 .rates = SNDRV_PCM_RATE_8000_48000,
1222                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1223         },
1224         .capture = {
1225                 .stream_name = "AC97 Capture",
1226                 .channels_min = 2,
1227                 .channels_max = 2,
1228                 .rates = SNDRV_PCM_RATE_48000,
1229                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
1230         },
1231         .ops = &fsl_ssi_dai_ops,
1232 };
1233
1234
1235 static struct fsl_ssi_private *fsl_ac97_data;
1236
1237 static void fsl_ssi_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
1238                 unsigned short val)
1239 {
1240         struct regmap *regs = fsl_ac97_data->regs;
1241         unsigned int lreg;
1242         unsigned int lval;
1243         int ret;
1244
1245         if (reg > 0x7f)
1246                 return;
1247
1248         ret = clk_prepare_enable(fsl_ac97_data->clk);
1249         if (ret) {
1250                 pr_err("ac97 write clk_prepare_enable failed: %d\n",
1251                         ret);
1252                 return;
1253         }
1254
1255         lreg = reg <<  12;
1256         regmap_write(regs, CCSR_SSI_SACADD, lreg);
1257
1258         lval = val << 4;
1259         regmap_write(regs, CCSR_SSI_SACDAT, lval);
1260
1261         regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1262                         CCSR_SSI_SACNT_WR);
1263         udelay(100);
1264
1265         clk_disable_unprepare(fsl_ac97_data->clk);
1266 }
1267
1268 static unsigned short fsl_ssi_ac97_read(struct snd_ac97 *ac97,
1269                 unsigned short reg)
1270 {
1271         struct regmap *regs = fsl_ac97_data->regs;
1272
1273         unsigned short val = -1;
1274         u32 reg_val;
1275         unsigned int lreg;
1276         int ret;
1277
1278         ret = clk_prepare_enable(fsl_ac97_data->clk);
1279         if (ret) {
1280                 pr_err("ac97 read clk_prepare_enable failed: %d\n",
1281                         ret);
1282                 return -1;
1283         }
1284
1285         lreg = (reg & 0x7f) <<  12;
1286         regmap_write(regs, CCSR_SSI_SACADD, lreg);
1287         regmap_update_bits(regs, CCSR_SSI_SACNT, CCSR_SSI_SACNT_RDWR_MASK,
1288                         CCSR_SSI_SACNT_RD);
1289
1290         udelay(100);
1291
1292         regmap_read(regs, CCSR_SSI_SACDAT, &reg_val);
1293         val = (reg_val >> 4) & 0xffff;
1294
1295         clk_disable_unprepare(fsl_ac97_data->clk);
1296
1297         return val;
1298 }
1299
1300 static struct snd_ac97_bus_ops fsl_ssi_ac97_ops = {
1301         .read           = fsl_ssi_ac97_read,
1302         .write          = fsl_ssi_ac97_write,
1303 };
1304
1305 /**
1306  * Make every character in a string lower-case
1307  */
1308 static void make_lowercase(char *s)
1309 {
1310         char *p = s;
1311         char c;
1312
1313         while ((c = *p)) {
1314                 if ((c >= 'A') && (c <= 'Z'))
1315                         *p = c + ('a' - 'A');
1316                 p++;
1317         }
1318 }
1319
1320 static int fsl_ssi_imx_probe(struct platform_device *pdev,
1321                 struct fsl_ssi_private *ssi_private, void __iomem *iomem)
1322 {
1323         struct device_node *np = pdev->dev.of_node;
1324         u32 dmas[4];
1325         int ret;
1326
1327         if (ssi_private->has_ipg_clk_name)
1328                 ssi_private->clk = devm_clk_get(&pdev->dev, "ipg");
1329         else
1330                 ssi_private->clk = devm_clk_get(&pdev->dev, NULL);
1331         if (IS_ERR(ssi_private->clk)) {
1332                 ret = PTR_ERR(ssi_private->clk);
1333                 dev_err(&pdev->dev, "could not get clock: %d\n", ret);
1334                 return ret;
1335         }
1336
1337         if (!ssi_private->has_ipg_clk_name) {
1338                 ret = clk_prepare_enable(ssi_private->clk);
1339                 if (ret) {
1340                         dev_err(&pdev->dev, "clk_prepare_enable failed: %d\n", ret);
1341                         return ret;
1342                 }
1343         }
1344
1345         /* For those SLAVE implementations, we ignore non-baudclk cases
1346          * and, instead, abandon MASTER mode that needs baud clock.
1347          */
1348         ssi_private->baudclk = devm_clk_get(&pdev->dev, "baud");
1349         if (IS_ERR(ssi_private->baudclk))
1350                 dev_dbg(&pdev->dev, "could not get baud clock: %ld\n",
1351                          PTR_ERR(ssi_private->baudclk));
1352
1353         /*
1354          * We have burstsize be "fifo_depth - 2" to match the SSI
1355          * watermark setting in fsl_ssi_startup().
1356          */
1357         ssi_private->dma_params_tx.maxburst = ssi_private->fifo_depth - 2;
1358         ssi_private->dma_params_rx.maxburst = ssi_private->fifo_depth - 2;
1359         ssi_private->dma_params_tx.addr = ssi_private->ssi_phys + CCSR_SSI_STX0;
1360         ssi_private->dma_params_rx.addr = ssi_private->ssi_phys + CCSR_SSI_SRX0;
1361
1362         ret = of_property_read_u32_array(np, "dmas", dmas, 4);
1363         if (ssi_private->use_dma && !ret && dmas[2] == IMX_DMATYPE_SSI_DUAL) {
1364                 ssi_private->use_dual_fifo = true;
1365                 /* When using dual fifo mode, we need to keep watermark
1366                  * as even numbers due to dma script limitation.
1367                  */
1368                 ssi_private->dma_params_tx.maxburst &= ~0x1;
1369                 ssi_private->dma_params_rx.maxburst &= ~0x1;
1370         }
1371
1372         if (!ssi_private->use_dma) {
1373
1374                 /*
1375                  * Some boards use an incompatible codec. To get it
1376                  * working, we are using imx-fiq-pcm-audio, that
1377                  * can handle those codecs. DMA is not possible in this
1378                  * situation.
1379                  */
1380
1381                 ssi_private->fiq_params.irq = ssi_private->irq;
1382                 ssi_private->fiq_params.base = iomem;
1383                 ssi_private->fiq_params.dma_params_rx =
1384                         &ssi_private->dma_params_rx;
1385                 ssi_private->fiq_params.dma_params_tx =
1386                         &ssi_private->dma_params_tx;
1387
1388                 ret = imx_pcm_fiq_init(pdev, &ssi_private->fiq_params);
1389                 if (ret)
1390                         goto error_pcm;
1391         } else {
1392                 ret = imx_pcm_dma_init(pdev, IMX_SSI_DMABUF_SIZE);
1393                 if (ret)
1394                         goto error_pcm;
1395         }
1396
1397         return 0;
1398
1399 error_pcm:
1400
1401         if (!ssi_private->has_ipg_clk_name)
1402                 clk_disable_unprepare(ssi_private->clk);
1403         return ret;
1404 }
1405
1406 static void fsl_ssi_imx_clean(struct platform_device *pdev,
1407                 struct fsl_ssi_private *ssi_private)
1408 {
1409         if (!ssi_private->use_dma)
1410                 imx_pcm_fiq_exit(pdev);
1411         if (!ssi_private->has_ipg_clk_name)
1412                 clk_disable_unprepare(ssi_private->clk);
1413 }
1414
1415 static int fsl_ssi_probe(struct platform_device *pdev)
1416 {
1417         struct fsl_ssi_private *ssi_private;
1418         int ret = 0;
1419         struct device_node *np = pdev->dev.of_node;
1420         const struct of_device_id *of_id;
1421         const char *p, *sprop;
1422         const uint32_t *iprop;
1423         struct resource *res;
1424         void __iomem *iomem;
1425         char name[64];
1426         struct regmap_config regconfig = fsl_ssi_regconfig;
1427
1428         of_id = of_match_device(fsl_ssi_ids, &pdev->dev);
1429         if (!of_id || !of_id->data)
1430                 return -EINVAL;
1431
1432         ssi_private = devm_kzalloc(&pdev->dev, sizeof(*ssi_private),
1433                         GFP_KERNEL);
1434         if (!ssi_private) {
1435                 dev_err(&pdev->dev, "could not allocate DAI object\n");
1436                 return -ENOMEM;
1437         }
1438
1439         ssi_private->soc = of_id->data;
1440         ssi_private->dev = &pdev->dev;
1441
1442         sprop = of_get_property(np, "fsl,mode", NULL);
1443         if (sprop) {
1444                 if (!strcmp(sprop, "ac97-slave"))
1445                         ssi_private->dai_fmt = SND_SOC_DAIFMT_AC97;
1446         }
1447
1448         ssi_private->use_dma = !of_property_read_bool(np,
1449                         "fsl,fiq-stream-filter");
1450
1451         if (fsl_ssi_is_ac97(ssi_private)) {
1452                 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_ac97_dai,
1453                                 sizeof(fsl_ssi_ac97_dai));
1454
1455                 fsl_ac97_data = ssi_private;
1456
1457                 ret = snd_soc_set_ac97_ops_of_reset(&fsl_ssi_ac97_ops, pdev);
1458                 if (ret) {
1459                         dev_err(&pdev->dev, "could not set AC'97 ops\n");
1460                         return ret;
1461                 }
1462         } else {
1463                 /* Initialize this copy of the CPU DAI driver structure */
1464                 memcpy(&ssi_private->cpu_dai_drv, &fsl_ssi_dai_template,
1465                        sizeof(fsl_ssi_dai_template));
1466         }
1467         ssi_private->cpu_dai_drv.name = dev_name(&pdev->dev);
1468
1469         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1470         iomem = devm_ioremap_resource(&pdev->dev, res);
1471         if (IS_ERR(iomem))
1472                 return PTR_ERR(iomem);
1473         ssi_private->ssi_phys = res->start;
1474
1475         if (ssi_private->soc->imx21regs) {
1476                 /*
1477                  * According to datasheet imx21-class SSI
1478                  * don't have SACC{ST,EN,DIS} regs.
1479                  */
1480                 regconfig.max_register = CCSR_SSI_SRMSK;
1481                 regconfig.num_reg_defaults_raw =
1482                         CCSR_SSI_SRMSK / sizeof(uint32_t) + 1;
1483         }
1484
1485         ret = of_property_match_string(np, "clock-names", "ipg");
1486         if (ret < 0) {
1487                 ssi_private->has_ipg_clk_name = false;
1488                 ssi_private->regs = devm_regmap_init_mmio(&pdev->dev, iomem,
1489                         &regconfig);
1490         } else {
1491                 ssi_private->has_ipg_clk_name = true;
1492                 ssi_private->regs = devm_regmap_init_mmio_clk(&pdev->dev,
1493                         "ipg", iomem, &regconfig);
1494         }
1495         if (IS_ERR(ssi_private->regs)) {
1496                 dev_err(&pdev->dev, "Failed to init register map\n");
1497                 return PTR_ERR(ssi_private->regs);
1498         }
1499
1500         ssi_private->irq = platform_get_irq(pdev, 0);
1501         if (ssi_private->irq < 0) {
1502                 dev_err(&pdev->dev, "no irq for node %s\n", pdev->name);
1503                 return ssi_private->irq;
1504         }
1505
1506         /* Are the RX and the TX clocks locked? */
1507         if (!of_find_property(np, "fsl,ssi-asynchronous", NULL)) {
1508                 if (!fsl_ssi_is_ac97(ssi_private))
1509                         ssi_private->cpu_dai_drv.symmetric_rates = 1;
1510
1511                 ssi_private->cpu_dai_drv.symmetric_channels = 1;
1512                 ssi_private->cpu_dai_drv.symmetric_samplebits = 1;
1513         }
1514
1515         /* Determine the FIFO depth. */
1516         iprop = of_get_property(np, "fsl,fifo-depth", NULL);
1517         if (iprop)
1518                 ssi_private->fifo_depth = be32_to_cpup(iprop);
1519         else
1520                 /* Older 8610 DTs didn't have the fifo-depth property */
1521                 ssi_private->fifo_depth = 8;
1522
1523         dev_set_drvdata(&pdev->dev, ssi_private);
1524
1525         if (ssi_private->soc->imx) {
1526                 ret = fsl_ssi_imx_probe(pdev, ssi_private, iomem);
1527                 if (ret)
1528                         return ret;
1529         }
1530
1531         ret = devm_snd_soc_register_component(&pdev->dev, &fsl_ssi_component,
1532                                               &ssi_private->cpu_dai_drv, 1);
1533         if (ret) {
1534                 dev_err(&pdev->dev, "failed to register DAI: %d\n", ret);
1535                 goto error_asoc_register;
1536         }
1537
1538         if (ssi_private->use_dma) {
1539                 ret = devm_request_irq(&pdev->dev, ssi_private->irq,
1540                                         fsl_ssi_isr, 0, dev_name(&pdev->dev),
1541                                         ssi_private);
1542                 if (ret < 0) {
1543                         dev_err(&pdev->dev, "could not claim irq %u\n",
1544                                         ssi_private->irq);
1545                         goto error_asoc_register;
1546                 }
1547         }
1548
1549         ret = fsl_ssi_debugfs_create(&ssi_private->dbg_stats, &pdev->dev);
1550         if (ret)
1551                 goto error_asoc_register;
1552
1553         /*
1554          * If codec-handle property is missing from SSI node, we assume
1555          * that the machine driver uses new binding which does not require
1556          * SSI driver to trigger machine driver's probe.
1557          */
1558         if (!of_get_property(np, "codec-handle", NULL))
1559                 goto done;
1560
1561         /* Trigger the machine driver's probe function.  The platform driver
1562          * name of the machine driver is taken from /compatible property of the
1563          * device tree.  We also pass the address of the CPU DAI driver
1564          * structure.
1565          */
1566         sprop = of_get_property(of_find_node_by_path("/"), "compatible", NULL);
1567         /* Sometimes the compatible name has a "fsl," prefix, so we strip it. */
1568         p = strrchr(sprop, ',');
1569         if (p)
1570                 sprop = p + 1;
1571         snprintf(name, sizeof(name), "snd-soc-%s", sprop);
1572         make_lowercase(name);
1573
1574         ssi_private->pdev =
1575                 platform_device_register_data(&pdev->dev, name, 0, NULL, 0);
1576         if (IS_ERR(ssi_private->pdev)) {
1577                 ret = PTR_ERR(ssi_private->pdev);
1578                 dev_err(&pdev->dev, "failed to register platform: %d\n", ret);
1579                 goto error_sound_card;
1580         }
1581
1582 done:
1583         if (ssi_private->dai_fmt)
1584                 _fsl_ssi_set_dai_fmt(&pdev->dev, ssi_private,
1585                                      ssi_private->dai_fmt);
1586
1587         if (fsl_ssi_is_ac97(ssi_private)) {
1588                 u32 ssi_idx;
1589
1590                 ret = of_property_read_u32(np, "cell-index", &ssi_idx);
1591                 if (ret) {
1592                         dev_err(&pdev->dev, "cannot get SSI index property\n");
1593                         goto error_sound_card;
1594                 }
1595
1596                 ssi_private->pdev =
1597                         platform_device_register_data(NULL,
1598                                         "ac97-codec", ssi_idx, NULL, 0);
1599                 if (IS_ERR(ssi_private->pdev)) {
1600                         ret = PTR_ERR(ssi_private->pdev);
1601                         dev_err(&pdev->dev,
1602                                 "failed to register AC97 codec platform: %d\n",
1603                                 ret);
1604                         goto error_sound_card;
1605                 }
1606         }
1607
1608         return 0;
1609
1610 error_sound_card:
1611         fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1612
1613 error_asoc_register:
1614         if (ssi_private->soc->imx)
1615                 fsl_ssi_imx_clean(pdev, ssi_private);
1616
1617         return ret;
1618 }
1619
1620 static int fsl_ssi_remove(struct platform_device *pdev)
1621 {
1622         struct fsl_ssi_private *ssi_private = dev_get_drvdata(&pdev->dev);
1623
1624         fsl_ssi_debugfs_remove(&ssi_private->dbg_stats);
1625
1626         if (ssi_private->pdev)
1627                 platform_device_unregister(ssi_private->pdev);
1628
1629         if (ssi_private->soc->imx)
1630                 fsl_ssi_imx_clean(pdev, ssi_private);
1631
1632         if (fsl_ssi_is_ac97(ssi_private))
1633                 snd_soc_set_ac97_ops(NULL);
1634
1635         return 0;
1636 }
1637
1638 #ifdef CONFIG_PM_SLEEP
1639 static int fsl_ssi_suspend(struct device *dev)
1640 {
1641         struct fsl_ssi_private *ssi_private = dev_get_drvdata(dev);
1642         struct regmap *regs = ssi_private->regs;
1643
1644         regmap_read(regs, CCSR_SSI_SFCSR,
1645                         &ssi_private->regcache_sfcsr);
1646         regmap_read(regs, CCSR_SSI_SACNT,
1647                         &ssi_private->regcache_sacnt);
1648
1649         regcache_cache_only(regs, true);
1650         regcache_mark_dirty(regs);
1651
1652         return 0;
1653 }
1654
1655 static int fsl_ssi_resume(struct device *dev)
1656 {
1657         struct fsl_ssi_private *ssi_private = dev_get_drvdata(dev);
1658         struct regmap *regs = ssi_private->regs;
1659
1660         regcache_cache_only(regs, false);
1661
1662         regmap_update_bits(regs, CCSR_SSI_SFCSR,
1663                         CCSR_SSI_SFCSR_RFWM1_MASK | CCSR_SSI_SFCSR_TFWM1_MASK |
1664                         CCSR_SSI_SFCSR_RFWM0_MASK | CCSR_SSI_SFCSR_TFWM0_MASK,
1665                         ssi_private->regcache_sfcsr);
1666         regmap_write(regs, CCSR_SSI_SACNT,
1667                         ssi_private->regcache_sacnt);
1668
1669         return regcache_sync(regs);
1670 }
1671 #endif /* CONFIG_PM_SLEEP */
1672
1673 static const struct dev_pm_ops fsl_ssi_pm = {
1674         SET_SYSTEM_SLEEP_PM_OPS(fsl_ssi_suspend, fsl_ssi_resume)
1675 };
1676
1677 static struct platform_driver fsl_ssi_driver = {
1678         .driver = {
1679                 .name = "fsl-ssi-dai",
1680                 .of_match_table = fsl_ssi_ids,
1681                 .pm = &fsl_ssi_pm,
1682         },
1683         .probe = fsl_ssi_probe,
1684         .remove = fsl_ssi_remove,
1685 };
1686
1687 module_platform_driver(fsl_ssi_driver);
1688
1689 MODULE_ALIAS("platform:fsl-ssi-dai");
1690 MODULE_AUTHOR("Timur Tabi <timur@freescale.com>");
1691 MODULE_DESCRIPTION("Freescale Synchronous Serial Interface (SSI) ASoC Driver");
1692 MODULE_LICENSE("GPL v2");