sound/soc/imx/imx-ssi.c

   1 /*
   2  * imx-ssi.c  --  ALSA Soc Audio Layer
   3  *
   4  * Copyright 2009 Sascha Hauer <s.hauer@pengutronix.de>
   5  *
   6  * This code is based on code copyrighted by Freescale,
   7  * Liam Girdwood, Javier Martin and probably others.
   8  *
   9  *  This program is free software; you can redistribute  it and/or modify it
  10  *  under  the terms of  the GNU General  Public License as published by the
  11  *  Free Software Foundation;  either version 2 of the  License, or (at your
  12  *  option) any later version.
  13  *
  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
  34 #include <linux/clk.h>
  35 #include <linux/delay.h>
  36 #include <linux/device.h>
  37 #include <linux/dma-mapping.h>
  38 #include <linux/init.h>
  39 #include <linux/interrupt.h>
  40 #include <linux/module.h>
  41 #include <linux/platform_device.h>
  42 #include <linux/slab.h>
  43
  44 #include <sound/core.h>
  45 #include <sound/initval.h>
  46 #include <sound/pcm.h>
  47 #include <sound/pcm_params.h>
  48 #include <sound/soc.h>
  49
  50 #include <mach/ssi.h>
  51 #include <mach/hardware.h>
  52
  53 #include "imx-ssi.h"
  54
  55 #define SSI_SACNT_DEFAULT (SSI_SACNT_AC97EN | SSI_SACNT_FV)
  56
  57 /*
  58  * SSI Network Mode or TDM slots configuration.
  59  * Should only be called when port is inactive (i.e. SSIEN = 0).
  60  */
  61 static int imx_ssi_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
  62         unsigned int tx_mask, unsigned int rx_mask, int slots, int slot_width)
  63 {
  64         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
  65         u32 sccr;
  66
  67         sccr = readl(ssi->base + SSI_STCCR);
  68         sccr &= ~SSI_STCCR_DC_MASK;
  69         sccr |= SSI_STCCR_DC(slots - 1);
  70         writel(sccr, ssi->base + SSI_STCCR);
  71
  72         sccr = readl(ssi->base + SSI_SRCCR);
  73         sccr &= ~SSI_STCCR_DC_MASK;
  74         sccr |= SSI_STCCR_DC(slots - 1);
  75         writel(sccr, ssi->base + SSI_SRCCR);
  76
  77         writel(tx_mask, ssi->base + SSI_STMSK);
  78         writel(rx_mask, ssi->base + SSI_SRMSK);
  79
  80         return 0;
  81 }
  82
  83 /*
  84  * SSI DAI format configuration.
  85  * Should only be called when port is inactive (i.e. SSIEN = 0).
  86  */
  87 static int imx_ssi_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)
  88 {
  89         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
  90         u32 strcr = 0, scr;
  91
  92         scr = readl(ssi->base + SSI_SCR) & ~(SSI_SCR_SYN | SSI_SCR_NET);
  93
  94         /* DAI mode */
  95         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
  96         case SND_SOC_DAIFMT_I2S:
  97                 /* data on rising edge of bclk, frame low 1clk before data */
  98                 strcr |= SSI_STCR_TFSI | SSI_STCR_TEFS | SSI_STCR_TXBIT0;
  99                 scr |= SSI_SCR_NET;
 100                 if (ssi->flags & IMX_SSI_USE_I2S_SLAVE) {
 101                         scr &= ~SSI_I2S_MODE_MASK;
 102                         scr |= SSI_SCR_I2S_MODE_SLAVE;
 103                 }
 104                 break;
 105         case SND_SOC_DAIFMT_LEFT_J:
 106                 /* data on rising edge of bclk, frame high with data */
 107                 strcr |= SSI_STCR_TXBIT0;
 108                 break;
 109         case SND_SOC_DAIFMT_DSP_B:
 110                 /* data on rising edge of bclk, frame high with data */
 111                 strcr |= SSI_STCR_TFSL | SSI_STCR_TXBIT0;
 112                 break;
 113         case SND_SOC_DAIFMT_DSP_A:
 114                 /* data on rising edge of bclk, frame high 1clk before data */
 115                 strcr |= SSI_STCR_TFSL | SSI_STCR_TXBIT0 | SSI_STCR_TEFS;
 116                 break;
 117         }
 118
 119         /* DAI clock inversion */
 120         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 121         case SND_SOC_DAIFMT_IB_IF:
 122                 strcr |= SSI_STCR_TFSI;
 123                 strcr &= ~SSI_STCR_TSCKP;
 124                 break;
 125         case SND_SOC_DAIFMT_IB_NF:
 126                 strcr &= ~(SSI_STCR_TSCKP | SSI_STCR_TFSI);
 127                 break;
 128         case SND_SOC_DAIFMT_NB_IF:
 129                 strcr |= SSI_STCR_TFSI | SSI_STCR_TSCKP;
 130                 break;
 131         case SND_SOC_DAIFMT_NB_NF:
 132                 strcr &= ~SSI_STCR_TFSI;
 133                 strcr |= SSI_STCR_TSCKP;
 134                 break;
 135         }
 136
 137         /* DAI clock master masks */
 138         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 139         case SND_SOC_DAIFMT_CBM_CFM:
 140                 scr &= ~SSI_I2S_MODE_MASK;
 141                 break;
 142         default:
 143                 /* Master mode not implemented, needs handling of clocks. */
 144                 return -EINVAL;
 145         }
 146
 147         strcr |= SSI_STCR_TFEN0;
 148
 149         if (ssi->flags & IMX_SSI_NET)
 150                 scr |= SSI_SCR_NET;
 151         if (ssi->flags & IMX_SSI_SYN)
 152                 scr |= SSI_SCR_SYN;
 153
 154         writel(strcr, ssi->base + SSI_STCR);
 155         writel(strcr, ssi->base + SSI_SRCR);
 156         writel(scr, ssi->base + SSI_SCR);
 157
 158         return 0;
 159 }
 160
 161 /*
 162  * SSI system clock configuration.
 163  * Should only be called when port is inactive (i.e. SSIEN = 0).
 164  */
 165 static int imx_ssi_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
 166                                   int clk_id, unsigned int freq, int dir)
 167 {
 168         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
 169         u32 scr;
 170
 171         scr = readl(ssi->base + SSI_SCR);
 172
 173         switch (clk_id) {
 174         case IMX_SSP_SYS_CLK:
 175                 if (dir == SND_SOC_CLOCK_OUT)
 176                         scr |= SSI_SCR_SYS_CLK_EN;
 177                 else
 178                         scr &= ~SSI_SCR_SYS_CLK_EN;
 179                 break;
 180         default:
 181                 return -EINVAL;
 182         }
 183
 184         writel(scr, ssi->base + SSI_SCR);
 185
 186         return 0;
 187 }
 188
 189 /*
 190  * SSI Clock dividers
 191  * Should only be called when port is inactive (i.e. SSIEN = 0).
 192  */
 193 static int imx_ssi_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
 194                                   int div_id, int div)
 195 {
 196         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
 197         u32 stccr, srccr;
 198
 199         stccr = readl(ssi->base + SSI_STCCR);
 200         srccr = readl(ssi->base + SSI_SRCCR);
 201
 202         switch (div_id) {
 203         case IMX_SSI_TX_DIV_2:
 204                 stccr &= ~SSI_STCCR_DIV2;
 205                 stccr |= div;
 206                 break;
 207         case IMX_SSI_TX_DIV_PSR:
 208                 stccr &= ~SSI_STCCR_PSR;
 209                 stccr |= div;
 210                 break;
 211         case IMX_SSI_TX_DIV_PM:
 212                 stccr &= ~0xff;
 213                 stccr |= SSI_STCCR_PM(div);
 214                 break;
 215         case IMX_SSI_RX_DIV_2:
 216                 stccr &= ~SSI_STCCR_DIV2;
 217                 stccr |= div;
 218                 break;
 219         case IMX_SSI_RX_DIV_PSR:
 220                 stccr &= ~SSI_STCCR_PSR;
 221                 stccr |= div;
 222                 break;
 223         case IMX_SSI_RX_DIV_PM:
 224                 stccr &= ~0xff;
 225                 stccr |= SSI_STCCR_PM(div);
 226                 break;
 227         default:
 228                 return -EINVAL;
 229         }
 230
 231         writel(stccr, ssi->base + SSI_STCCR);
 232         writel(srccr, ssi->base + SSI_SRCCR);
 233
 234         return 0;
 235 }
 236
 237 static int imx_ssi_startup(struct snd_pcm_substream *substream,
 238                            struct snd_soc_dai *cpu_dai)
 239 {
 240         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
 241         struct imx_pcm_dma_params *dma_data;
 242
 243         /* Tx/Rx config */
 244         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 245                 dma_data = &ssi->dma_params_tx;
 246         else
 247                 dma_data = &ssi->dma_params_rx;
 248
 249         snd_soc_dai_set_dma_data(cpu_dai, substream, dma_data);
 250
 251         return 0;
 252 }
 253
 254 /*
 255  * Should only be called when port is inactive (i.e. SSIEN = 0),
 256  * although can be called multiple times by upper layers.
 257  */
 258 static int imx_ssi_hw_params(struct snd_pcm_substream *substream,
 259                              struct snd_pcm_hw_params *params,
 260                              struct snd_soc_dai *cpu_dai)
 261 {
 262         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(cpu_dai);
 263         u32 reg, sccr;
 264
 265         /* Tx/Rx config */
 266         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 267                 reg = SSI_STCCR;
 268         else
 269                 reg = SSI_SRCCR;
 270
 271         if (ssi->flags & IMX_SSI_SYN)
 272                 reg = SSI_STCCR;
 273
 274         sccr = readl(ssi->base + reg) & ~SSI_STCCR_WL_MASK;
 275
 276         /* DAI data (word) size */
 277         switch (params_format(params)) {
 278         case SNDRV_PCM_FORMAT_S16_LE:
 279                 sccr |= SSI_SRCCR_WL(16);
 280                 break;
 281         case SNDRV_PCM_FORMAT_S20_3LE:
 282                 sccr |= SSI_SRCCR_WL(20);
 283                 break;
 284         case SNDRV_PCM_FORMAT_S24_LE:
 285                 sccr |= SSI_SRCCR_WL(24);
 286                 break;
 287         }
 288
 289         writel(sccr, ssi->base + reg);
 290
 291         return 0;
 292 }
 293
 294 static int imx_ssi_trigger(struct snd_pcm_substream *substream, int cmd,
 295                 struct snd_soc_dai *dai)
 296 {
 297         struct imx_ssi *ssi = snd_soc_dai_get_drvdata(dai);
 298         unsigned int sier_bits, sier;
 299         unsigned int scr;
 300
 301         scr = readl(ssi->base + SSI_SCR);
 302         sier = readl(ssi->base + SSI_SIER);
 303
 304         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 305                 if (ssi->flags & IMX_SSI_DMA)
 306                         sier_bits = SSI_SIER_TDMAE | SSI_SIER_TIE | SSI_SIER_TUE0_EN;
 307                 else
 308                         sier_bits = SSI_SIER_TIE | SSI_SIER_TFE0_EN;
 309         } else {
 310                 if (ssi->flags & IMX_SSI_DMA)
 311                         sier_bits = SSI_SIER_RDMAE | SSI_SIER_RIE | SSI_SIER_ROE0_EN;
 312                 else
 313                         sier_bits = SSI_SIER_RIE | SSI_SIER_RFF0_EN;
 314         }
 315
 316         switch (cmd) {
 317         case SNDRV_PCM_TRIGGER_START:
 318         case SNDRV_PCM_TRIGGER_RESUME:
 319         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 320                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 321                         scr |= SSI_SCR_TE;
 322                 else
 323                         scr |= SSI_SCR_RE;
 324                 sier |= sier_bits;
 325
 326                 if (++ssi->enabled == 1)
 327                         scr |= SSI_SCR_SSIEN;
 328
 329                 break;
 330
 331         case SNDRV_PCM_TRIGGER_STOP:
 332         case SNDRV_PCM_TRIGGER_SUSPEND:
 333         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 334                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 335                         scr &= ~SSI_SCR_TE;
 336                 else
 337                         scr &= ~SSI_SCR_RE;
 338                 sier &= ~sier_bits;
 339
 340                 if (--ssi->enabled == 0)
 341                         scr &= ~SSI_SCR_SSIEN;
 342
 343                 break;
 344         default:
 345                 return -EINVAL;
 346         }
 347
 348         if (!(ssi->flags & IMX_SSI_USE_AC97))
 349                 /* rx/tx are always enabled to access ac97 registers */
 350                 writel(scr, ssi->base + SSI_SCR);
 351
 352         writel(sier, ssi->base + SSI_SIER);
 353
 354         return 0;
 355 }
 356
 357 static const struct snd_soc_dai_ops imx_ssi_pcm_dai_ops = {
 358         .startup        = imx_ssi_startup,
 359         .hw_params      = imx_ssi_hw_params,
 360         .set_fmt        = imx_ssi_set_dai_fmt,
 361         .set_clkdiv     = imx_ssi_set_dai_clkdiv,
 362         .set_sysclk     = imx_ssi_set_dai_sysclk,
 363         .set_tdm_slot   = imx_ssi_set_dai_tdm_slot,
 364         .trigger        = imx_ssi_trigger,
 365 };
 366
 367 static int imx_ssi_dai_probe(struct snd_soc_dai *dai)
 368 {
 369         struct imx_ssi *ssi = dev_get_drvdata(dai->dev);
 370         uint32_t val;
 371
 372         snd_soc_dai_set_drvdata(dai, ssi);
 373
 374         val = SSI_SFCSR_TFWM0(ssi->dma_params_tx.burstsize) |
 375                 SSI_SFCSR_RFWM0(ssi->dma_params_rx.burstsize);
 376         writel(val, ssi->base + SSI_SFCSR);
 377
 378         return 0;
 379 }
 380
 381 static struct snd_soc_dai_driver imx_ssi_dai = {
 382         .probe = imx_ssi_dai_probe,
 383         .playback = {
 384                 .channels_min = 1,
 385                 .channels_max = 2,
 386                 .rates = SNDRV_PCM_RATE_8000_96000,
 387                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 388         },
 389         .capture = {
 390                 .channels_min = 1,
 391                 .channels_max = 2,
 392                 .rates = SNDRV_PCM_RATE_8000_96000,
 393                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 394         },
 395         .ops = &imx_ssi_pcm_dai_ops,
 396 };
 397
 398 static struct snd_soc_dai_driver imx_ac97_dai = {
 399         .probe = imx_ssi_dai_probe,
 400         .ac97_control = 1,
 401         .playback = {
 402                 .stream_name = "AC97 Playback",
 403                 .channels_min = 2,
 404                 .channels_max = 2,
 405                 .rates = SNDRV_PCM_RATE_48000,
 406                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 407         },
 408         .capture = {
 409                 .stream_name = "AC97 Capture",
 410                 .channels_min = 2,
 411                 .channels_max = 2,
 412                 .rates = SNDRV_PCM_RATE_48000,
 413                 .formats = SNDRV_PCM_FMTBIT_S16_LE,
 414         },
 415         .ops = &imx_ssi_pcm_dai_ops,
 416 };
 417
 418 static void setup_channel_to_ac97(struct imx_ssi *imx_ssi)
 419 {
 420         void __iomem *base = imx_ssi->base;
 421
 422         writel(0x0, base + SSI_SCR);
 423         writel(0x0, base + SSI_STCR);
 424         writel(0x0, base + SSI_SRCR);
 425
 426         writel(SSI_SCR_SYN | SSI_SCR_NET, base + SSI_SCR);
 427
 428         writel(SSI_SFCSR_RFWM0(8) |
 429                 SSI_SFCSR_TFWM0(8) |
 430                 SSI_SFCSR_RFWM1(8) |
 431                 SSI_SFCSR_TFWM1(8), base + SSI_SFCSR);
 432
 433         writel(SSI_STCCR_WL(16) | SSI_STCCR_DC(12), base + SSI_STCCR);
 434         writel(SSI_STCCR_WL(16) | SSI_STCCR_DC(12), base + SSI_SRCCR);
 435
 436         writel(SSI_SCR_SYN | SSI_SCR_NET | SSI_SCR_SSIEN, base + SSI_SCR);
 437         writel(SSI_SOR_WAIT(3), base + SSI_SOR);
 438
 439         writel(SSI_SCR_SYN | SSI_SCR_NET | SSI_SCR_SSIEN |
 440                         SSI_SCR_TE | SSI_SCR_RE,
 441                         base + SSI_SCR);
 442
 443         writel(SSI_SACNT_DEFAULT, base + SSI_SACNT);
 444         writel(0xff, base + SSI_SACCDIS);
 445         writel(0x300, base + SSI_SACCEN);
 446 }
 447
 448 static struct imx_ssi *ac97_ssi;
 449
 450 static void imx_ssi_ac97_write(struct snd_ac97 *ac97, unsigned short reg,
 451                 unsigned short val)
 452 {
 453         struct imx_ssi *imx_ssi = ac97_ssi;
 454         void __iomem *base = imx_ssi->base;
 455         unsigned int lreg;
 456         unsigned int lval;
 457
 458         if (reg > 0x7f)
 459                 return;
 460
 461         pr_debug("%s: 0x%02x 0x%04x\n", __func__, reg, val);
 462
 463         lreg = reg <<  12;
 464         writel(lreg, base + SSI_SACADD);
 465
 466         lval = val << 4;
 467         writel(lval , base + SSI_SACDAT);
 468
 469         writel(SSI_SACNT_DEFAULT | SSI_SACNT_WR, base + SSI_SACNT);
 470         udelay(100);
 471 }
 472
 473 static unsigned short imx_ssi_ac97_read(struct snd_ac97 *ac97,
 474                 unsigned short reg)
 475 {
 476         struct imx_ssi *imx_ssi = ac97_ssi;
 477         void __iomem *base = imx_ssi->base;
 478
 479         unsigned short val = -1;
 480         unsigned int lreg;
 481
 482         lreg = (reg & 0x7f) <<  12 ;
 483         writel(lreg, base + SSI_SACADD);
 484         writel(SSI_SACNT_DEFAULT | SSI_SACNT_RD, base + SSI_SACNT);
 485
 486         udelay(100);
 487
 488         val = (readl(base + SSI_SACDAT) >> 4) & 0xffff;
 489
 490         pr_debug("%s: 0x%02x 0x%04x\n", __func__, reg, val);
 491
 492         return val;
 493 }
 494
 495 static void imx_ssi_ac97_reset(struct snd_ac97 *ac97)
 496 {
 497         struct imx_ssi *imx_ssi = ac97_ssi;
 498
 499         if (imx_ssi->ac97_reset)
 500                 imx_ssi->ac97_reset(ac97);
 501 }
 502
 503 static void imx_ssi_ac97_warm_reset(struct snd_ac97 *ac97)
 504 {
 505         struct imx_ssi *imx_ssi = ac97_ssi;
 506
 507         if (imx_ssi->ac97_warm_reset)
 508                 imx_ssi->ac97_warm_reset(ac97);
 509 }
 510
 511 struct snd_ac97_bus_ops soc_ac97_ops = {
 512         .read           = imx_ssi_ac97_read,
 513         .write          = imx_ssi_ac97_write,
 514         .reset          = imx_ssi_ac97_reset,
 515         .warm_reset     = imx_ssi_ac97_warm_reset
 516 };
 517 EXPORT_SYMBOL_GPL(soc_ac97_ops);
 518
 519 static const struct of_device_id imx_ssi_dt_ids[] = {
 520         { .compatible = "fsl,imx-ssi", },
 521         { /* sentinel */ }
 522 };
 523
 524 static int imx_ssi_of_probe(struct platform_device *pdev,
 525                         struct imx_ssi *ssi)
 526 {
 527         struct device_node *np = pdev->dev.of_node;
 528         const unsigned long *prop;
 529
 530         ssi->dma_params_rx.dma = ssi->dma_params_tx.dma = -1;
 531
 532         prop = of_get_property(np, "rx-dma", NULL);
 533         if (prop) {
 534                 ssi->dma_params_rx.dma = be32_to_cpu(*prop);
 535         }
 536
 537         prop = of_get_property(np, "tx-dma", NULL);
 538         if (prop) {
 539                 ssi->dma_params_tx.dma = be32_to_cpu(*prop);
 540         }
 541
 542         if (ssi->dma_params_rx.dma >= 0 && ssi->dma_params_tx.dma >= 0) {
 543                 ssi->flags |= IMX_SSI_DMA;
 544         } else if ((ssi->dma_params_rx.dma < 0) ^
 545                 (ssi->dma_params_tx.dma < 0)) {
 546                 dev_err(&pdev->dev, "Incomplete DMA properties\n");
 547                 return -EINVAL;
 548         }
 549
 550         if (of_get_property(np, "i2s-slave-mode", NULL))
 551                 ssi->flags |= IMX_SSI_USE_I2S_SLAVE;
 552
 553         if (of_get_property(np, "ac97-mode", NULL))
 554                 ssi->flags |= IMX_SSI_USE_AC97;
 555
 556         if (of_get_property(np, "i2s-network-mode", NULL))
 557                 ssi->flags |= IMX_SSI_NET;
 558
 559         if (of_get_property(np, "i2s-sync-mode", NULL))
 560                 ssi->flags |= IMX_SSI_SYN;
 561
 562         return 0;
 563 }
 564
 565 static int imx_ssi_probe(struct platform_device *pdev)
 566 {
 567         struct resource *res;
 568         struct imx_ssi *ssi;
 569         struct imx_ssi_platform_data *pdata = pdev->dev.platform_data;
 570         int ret = 0;
 571         struct snd_soc_dai_driver *dai;
 572         unsigned long mapbase;
 573
 574         ssi = kzalloc(sizeof(*ssi), GFP_KERNEL);
 575         if (!ssi)
 576                 return -ENOMEM;
 577
 578         ssi->irq = platform_get_irq(pdev, 0);
 579
 580         if (pdata) {
 581                 ssi->ac97_reset = pdata->ac97_reset;
 582                 ssi->ac97_warm_reset = pdata->ac97_warm_reset;
 583                 ssi->flags = pdata->flags;
 584         } else {
 585                 ret = imx_ssi_of_probe(pdev, ssi);
 586                 if (ret)
 587                         goto failed_clk;
 588         }
 589
 590         ssi->clk = clk_get(&pdev->dev, NULL);
 591         if (IS_ERR(ssi->clk)) {
 592                 ret = PTR_ERR(ssi->clk);
 593                 dev_err(&pdev->dev, "Cannot get the '%s' clock: %d\n",
 594                         dev_name(&pdev->dev), ret);
 595                 goto failed_clk;
 596         }
 597         clk_prepare_enable(ssi->clk);
 598
 599         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 600         if (!res) {
 601                 ret = -ENODEV;
 602                 goto failed_get_resource;
 603         }
 604
 605         if (!request_mem_region(res->start, resource_size(res), DRV_NAME)) {
 606                 dev_err(&pdev->dev, "request_mem_region failed\n");
 607                 ret = -EBUSY;
 608                 goto failed_get_resource;
 609         }
 610
 611         mapbase = res->start;
 612         ssi->base = ioremap(res->start, resource_size(res));
 613         if (!ssi->base) {
 614                 dev_err(&pdev->dev, "ioremap failed\n");
 615                 ret = -ENODEV;
 616                 goto failed_ioremap;
 617         }
 618
 619         if (ssi->flags & IMX_SSI_USE_AC97) {
 620                 if (ac97_ssi) {
 621                         ret = -EBUSY;
 622                         goto failed_ac97;
 623                 }
 624                 ac97_ssi = ssi;
 625                 setup_channel_to_ac97(ssi);
 626                 dai = &imx_ac97_dai;
 627         } else
 628                 dai = &imx_ssi_dai;
 629
 630         writel(0x0, ssi->base + SSI_SIER);
 631
 632         ssi->dma_params_rx.dma_addr = res->start + SSI_SRX0;
 633         ssi->dma_params_tx.dma_addr = res->start + SSI_STX0;
 634
 635         ssi->dma_params_tx.burstsize = 6;
 636         ssi->dma_params_rx.burstsize = 4;
 637
 638         res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "tx0");
 639         if (res)
 640                 ssi->dma_params_tx.dma = res->start;
 641
 642         res = platform_get_resource_byname(pdev, IORESOURCE_DMA, "rx0");
 643         if (res)
 644                 ssi->dma_params_rx.dma = res->start;
 645
 646         platform_set_drvdata(pdev, ssi);
 647
 648         ret = snd_soc_register_dai(&pdev->dev, dai);
 649         if (ret) {
 650                 dev_err(&pdev->dev, "register DAI failed\n");
 651                 goto failed_register;
 652         }
 653
 654         ssi->soc_platform_pdev_fiq = platform_device_alloc("imx-fiq-pcm-audio",
 655                                                         pdev->id);
 656         if (!ssi->soc_platform_pdev_fiq) {
 657                 ret = -ENOMEM;
 658                 goto failed_pdev_fiq_alloc;
 659         }
 660
 661         platform_set_drvdata(ssi->soc_platform_pdev_fiq, ssi);
 662         ret = platform_device_add(ssi->soc_platform_pdev_fiq);
 663         if (ret) {
 664                 dev_err(&pdev->dev, "failed to add platform device\n");
 665                 goto failed_pdev_fiq_add;
 666         }
 667
 668         ssi->soc_platform_pdev = platform_device_alloc("imx-pcm-audio",
 669                                                 pdev->id);
 670         if (!ssi->soc_platform_pdev) {
 671                 ret = -ENOMEM;
 672                 goto failed_pdev_alloc;
 673         }
 674
 675         platform_set_drvdata(ssi->soc_platform_pdev, ssi);
 676         ret = platform_device_add(ssi->soc_platform_pdev);
 677         if (ret) {
 678                 dev_err(&pdev->dev, "failed to add platform device\n");
 679                 goto failed_pdev_add;
 680         }
 681
 682         if (ssi->dma_params_rx.dma >= 0)
 683                 dev_info(&pdev->dev, "IMX SSI @ 0x%08lx IRQ %u DMA RX: %d TX: %d\n",
 684                         mapbase, ssi->irq, ssi->dma_params_rx.dma,
 685                         ssi->dma_params_tx.dma);
 686         else
 687                 dev_info(&pdev->dev, "IMX SSI @ 0x%08lx IRQ %u FIQ\n",
 688                         mapbase, ssi->irq);
 689
 690         return 0;
 691
 692 failed_pdev_add:
 693         platform_device_put(ssi->soc_platform_pdev);
 694 failed_pdev_alloc:
 695         platform_device_del(ssi->soc_platform_pdev_fiq);
 696 failed_pdev_fiq_add:
 697         platform_device_put(ssi->soc_platform_pdev_fiq);
 698 failed_pdev_fiq_alloc:
 699         snd_soc_unregister_dai(&pdev->dev);
 700 failed_register:
 701 failed_ac97:
 702         iounmap(ssi->base);
 703 failed_ioremap:
 704         release_mem_region(res->start, resource_size(res));
 705 failed_get_resource:
 706         clk_disable_unprepare(ssi->clk);
 707         clk_put(ssi->clk);
 708 failed_clk:
 709         kfree(ssi);
 710
 711         return ret;
 712 }
 713
 714 static int __devexit imx_ssi_remove(struct platform_device *pdev)
 715 {
 716         struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 717         struct imx_ssi *ssi = platform_get_drvdata(pdev);
 718
 719         platform_device_unregister(ssi->soc_platform_pdev);
 720         platform_device_unregister(ssi->soc_platform_pdev_fiq);
 721
 722         snd_soc_unregister_dai(&pdev->dev);
 723
 724         if (ssi->flags & IMX_SSI_USE_AC97)
 725                 ac97_ssi = NULL;
 726
 727         iounmap(ssi->base);
 728         release_mem_region(res->start, resource_size(res));
 729         clk_disable_unprepare(ssi->clk);
 730         clk_put(ssi->clk);
 731         kfree(ssi);
 732
 733         return 0;
 734 }
 735
 736 static struct platform_driver imx_ssi_driver = {
 737         .probe = imx_ssi_probe,
 738         .remove = __devexit_p(imx_ssi_remove),
 739
 740         .driver = {
 741                 .name = "imx-ssi",
 742                 .owner = THIS_MODULE,
 743                 .of_match_table = imx_ssi_dt_ids,
 744         },
 745 };
 746
 747 module_platform_driver(imx_ssi_driver);
 748
 749 /* Module information */
 750 MODULE_AUTHOR("Sascha Hauer, <s.hauer@pengutronix.de>");
 751 MODULE_DESCRIPTION("i.MX I2S/ac97 SoC Interface");
 752 MODULE_LICENSE("GPL");
 753 MODULE_ALIAS("platform:imx-ssi");