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