sound/soc/at91/at91-ssc.c

   1 /*
   2  * at91-ssc.c  --  ALSA SoC AT91 SSC Audio Layer Platform driver
   3  *
   4  * Author: Frank Mandarino <fmandarino@endrelia.com>
   5  *         Endrelia Technologies Inc.
   6  *
   7  * Based on pxa2xx Platform drivers by
   8  * Liam Girdwood <liam.girdwood@wolfsonmicro.com>
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  *
  15  */
  16
  17 #include <linux/init.h>
  18 #include <linux/module.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/device.h>
  21 #include <linux/delay.h>
  22 #include <linux/clk.h>
  23 #include <linux/atmel_pdc.h>
  24
  25 #include <sound/core.h>
  26 #include <sound/pcm.h>
  27 #include <sound/pcm_params.h>
  28 #include <sound/initval.h>
  29 #include <sound/soc.h>
  30
  31 #include <asm/arch/hardware.h>
  32 #include <asm/arch/at91_pmc.h>
  33 #include <asm/arch/at91_ssc.h>
  34
  35 #include "at91-pcm.h"
  36 #include "at91-ssc.h"
  37
  38 #if 0
  39 #define DBG(x...)       printk(KERN_DEBUG "at91-ssc:" x)
  40 #else
  41 #define DBG(x...)
  42 #endif
  43
  44 #if defined(CONFIG_ARCH_AT91SAM9260)
  45 #define NUM_SSC_DEVICES         1
  46 #else
  47 #define NUM_SSC_DEVICES         3
  48 #endif
  49
  50
  51 /*
  52  * SSC PDC registers required by the PCM DMA engine.
  53  */
  54 static struct at91_pdc_regs pdc_tx_reg = {
  55         .xpr            = ATMEL_PDC_TPR,
  56         .xcr            = ATMEL_PDC_TCR,
  57         .xnpr           = ATMEL_PDC_TNPR,
  58         .xncr           = ATMEL_PDC_TNCR,
  59 };
  60
  61 static struct at91_pdc_regs pdc_rx_reg = {
  62         .xpr            = ATMEL_PDC_RPR,
  63         .xcr            = ATMEL_PDC_RCR,
  64         .xnpr           = ATMEL_PDC_RNPR,
  65         .xncr           = ATMEL_PDC_RNCR,
  66 };
  67
  68 /*
  69  * SSC & PDC status bits for transmit and receive.
  70  */
  71 static struct at91_ssc_mask ssc_tx_mask = {
  72         .ssc_enable     = AT91_SSC_TXEN,
  73         .ssc_disable    = AT91_SSC_TXDIS,
  74         .ssc_endx       = AT91_SSC_ENDTX,
  75         .ssc_endbuf     = AT91_SSC_TXBUFE,
  76         .pdc_enable     = ATMEL_PDC_TXTEN,
  77         .pdc_disable    = ATMEL_PDC_TXTDIS,
  78 };
  79
  80 static struct at91_ssc_mask ssc_rx_mask = {
  81         .ssc_enable     = AT91_SSC_RXEN,
  82         .ssc_disable    = AT91_SSC_RXDIS,
  83         .ssc_endx       = AT91_SSC_ENDRX,
  84         .ssc_endbuf     = AT91_SSC_RXBUFF,
  85         .pdc_enable     = ATMEL_PDC_RXTEN,
  86         .pdc_disable    = ATMEL_PDC_RXTDIS,
  87 };
  88
  89
  90 /*
  91  * DMA parameters.
  92  */
  93 static struct at91_pcm_dma_params ssc_dma_params[NUM_SSC_DEVICES][2] = {
  94         {{
  95         .name           = "SSC0 PCM out",
  96         .pdc            = &pdc_tx_reg,
  97         .mask           = &ssc_tx_mask,
  98         },
  99         {
 100         .name           = "SSC0 PCM in",
 101         .pdc            = &pdc_rx_reg,
 102         .mask           = &ssc_rx_mask,
 103         }},
 104 #if NUM_SSC_DEVICES == 3
 105         {{
 106         .name           = "SSC1 PCM out",
 107         .pdc            = &pdc_tx_reg,
 108         .mask           = &ssc_tx_mask,
 109         },
 110         {
 111         .name           = "SSC1 PCM in",
 112         .pdc            = &pdc_rx_reg,
 113         .mask           = &ssc_rx_mask,
 114         }},
 115         {{
 116         .name           = "SSC2 PCM out",
 117         .pdc            = &pdc_tx_reg,
 118         .mask           = &ssc_tx_mask,
 119         },
 120         {
 121         .name           = "SSC2 PCM in",
 122         .pdc            = &pdc_rx_reg,
 123         .mask           = &ssc_rx_mask,
 124         }},
 125 #endif
 126 };
 127
 128 struct at91_ssc_state {
 129         u32     ssc_cmr;
 130         u32     ssc_rcmr;
 131         u32     ssc_rfmr;
 132         u32     ssc_tcmr;
 133         u32     ssc_tfmr;
 134         u32     ssc_sr;
 135         u32     ssc_imr;
 136 };
 137
 138 static struct at91_ssc_info {
 139         char            *name;
 140         struct at91_ssc_periph ssc;
 141         spinlock_t      lock;           /* lock for dir_mask */
 142         unsigned short  dir_mask;       /* 0=unused, 1=playback, 2=capture */
 143         unsigned short  initialized;    /* 1=SSC has been initialized */
 144         unsigned short  daifmt;
 145         unsigned short  cmr_div;
 146         unsigned short  tcmr_period;
 147         unsigned short  rcmr_period;
 148         struct at91_pcm_dma_params *dma_params[2];
 149         struct at91_ssc_state ssc_state;
 150
 151 } ssc_info[NUM_SSC_DEVICES] = {
 152         {
 153         .name           = "ssc0",
 154         .lock           = __SPIN_LOCK_UNLOCKED(ssc_info[0].lock),
 155         .dir_mask       = 0,
 156         .initialized    = 0,
 157         },
 158 #if NUM_SSC_DEVICES == 3
 159         {
 160         .name           = "ssc1",
 161         .lock           = __SPIN_LOCK_UNLOCKED(ssc_info[1].lock),
 162         .dir_mask       = 0,
 163         .initialized    = 0,
 164         },
 165         {
 166         .name           = "ssc2",
 167         .lock           = __SPIN_LOCK_UNLOCKED(ssc_info[2].lock),
 168         .dir_mask       = 0,
 169         .initialized    = 0,
 170         },
 171 #endif
 172 };
 173
 174 static unsigned int at91_ssc_sysclk;
 175
 176 /*
 177  * SSC interrupt handler.  Passes PDC interrupts to the DMA
 178  * interrupt handler in the PCM driver.
 179  */
 180 static irqreturn_t at91_ssc_interrupt(int irq, void *dev_id)
 181 {
 182         struct at91_ssc_info *ssc_p = dev_id;
 183         struct at91_pcm_dma_params *dma_params;
 184         u32 ssc_sr;
 185         int i;
 186
 187         ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR)
 188                         & at91_ssc_read(ssc_p->ssc.base + AT91_SSC_IMR);
 189
 190         /*
 191          * Loop through the substreams attached to this SSC.  If
 192          * a DMA-related interrupt occurred on that substream, call
 193          * the DMA interrupt handler function, if one has been
 194          * registered in the dma_params structure by the PCM driver.
 195          */
 196         for (i = 0; i < ARRAY_SIZE(ssc_p->dma_params); i++) {
 197                 dma_params = ssc_p->dma_params[i];
 198
 199                 if (dma_params != NULL && dma_params->dma_intr_handler != NULL &&
 200                         (ssc_sr &
 201                         (dma_params->mask->ssc_endx | dma_params->mask->ssc_endbuf)))
 202
 203                         dma_params->dma_intr_handler(ssc_sr, dma_params->substream);
 204         }
 205
 206         return IRQ_HANDLED;
 207 }
 208
 209 /*
 210  * Startup.  Only that one substream allowed in each direction.
 211  */
 212 static int at91_ssc_startup(struct snd_pcm_substream *substream)
 213 {
 214         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 215         struct at91_ssc_info *ssc_p = &ssc_info[rtd->dai->cpu_dai->id];
 216         int dir_mask;
 217
 218         DBG("ssc_startup: SSC_SR=0x%08lx\n",
 219                         at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR));
 220         dir_mask = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0x1 : 0x2;
 221
 222         spin_lock_irq(&ssc_p->lock);
 223         if (ssc_p->dir_mask & dir_mask) {
 224                 spin_unlock_irq(&ssc_p->lock);
 225                 return -EBUSY;
 226         }
 227         ssc_p->dir_mask |= dir_mask;
 228         spin_unlock_irq(&ssc_p->lock);
 229
 230         return 0;
 231 }
 232
 233 /*
 234  * Shutdown.  Clear DMA parameters and shutdown the SSC if there
 235  * are no other substreams open.
 236  */
 237 static void at91_ssc_shutdown(struct snd_pcm_substream *substream)
 238 {
 239         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 240         struct at91_ssc_info *ssc_p = &ssc_info[rtd->dai->cpu_dai->id];
 241         struct at91_pcm_dma_params *dma_params;
 242         int dir, dir_mask;
 243
 244         dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
 245         dma_params = ssc_p->dma_params[dir];
 246
 247         if (dma_params != NULL) {
 248                 at91_ssc_write(dma_params->ssc_base + AT91_SSC_CR,
 249                                 dma_params->mask->ssc_disable);
 250                 DBG("%s disabled SSC_SR=0x%08lx\n", (dir ? "receive" : "transmit"),
 251                         at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR));
 252
 253                 dma_params->ssc_base = NULL;
 254                 dma_params->substream = NULL;
 255                 ssc_p->dma_params[dir] = NULL;
 256         }
 257
 258         dir_mask = 1 << dir;
 259
 260         spin_lock_irq(&ssc_p->lock);
 261         ssc_p->dir_mask &= ~dir_mask;
 262         if (!ssc_p->dir_mask) {
 263                 /* Shutdown the SSC clock. */
 264                 DBG("Stopping pid %d clock\n", ssc_p->ssc.pid);
 265                 at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->ssc.pid);
 266
 267                 if (ssc_p->initialized) {
 268                         free_irq(ssc_p->ssc.pid, ssc_p);
 269                         ssc_p->initialized = 0;
 270                 }
 271
 272                 /* Reset the SSC */
 273                 at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR, AT91_SSC_SWRST);
 274
 275                 /* Clear the SSC dividers */
 276                 ssc_p->cmr_div = ssc_p->tcmr_period = ssc_p->rcmr_period = 0;
 277         }
 278         spin_unlock_irq(&ssc_p->lock);
 279 }
 280
 281 /*
 282  * Record the SSC system clock rate.
 283  */
 284 static int at91_ssc_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
 285                 int clk_id, unsigned int freq, int dir)
 286 {
 287         /*
 288          * The only clock supplied to the SSC is the AT91 master clock,
 289          * which is only used if the SSC is generating BCLK and/or
 290          * LRC clocks.
 291          */
 292         switch (clk_id) {
 293         case AT91_SYSCLK_MCK:
 294                 at91_ssc_sysclk = freq;
 295                 break;
 296         default:
 297                 return -EINVAL;
 298         }
 299
 300         return 0;
 301 }
 302
 303 /*
 304  * Record the DAI format for use in hw_params().
 305  */
 306 static int at91_ssc_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 307                 unsigned int fmt)
 308 {
 309         struct at91_ssc_info *ssc_p = &ssc_info[cpu_dai->id];
 310
 311         ssc_p->daifmt = fmt;
 312         return 0;
 313 }
 314
 315 /*
 316  * Record SSC clock dividers for use in hw_params().
 317  */
 318 static int at91_ssc_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
 319         int div_id, int div)
 320 {
 321         struct at91_ssc_info *ssc_p = &ssc_info[cpu_dai->id];
 322
 323         switch (div_id) {
 324         case AT91SSC_CMR_DIV:
 325                 /*
 326                  * The same master clock divider is used for both
 327                  * transmit and receive, so if a value has already
 328                  * been set, it must match this value.
 329                  */
 330                 if (ssc_p->cmr_div == 0)
 331                         ssc_p->cmr_div = div;
 332                 else
 333                         if (div != ssc_p->cmr_div)
 334                                 return -EBUSY;
 335                 break;
 336
 337         case AT91SSC_TCMR_PERIOD:
 338                 ssc_p->tcmr_period = div;
 339                 break;
 340
 341         case AT91SSC_RCMR_PERIOD:
 342                 ssc_p->rcmr_period = div;
 343                 break;
 344
 345         default:
 346                 return -EINVAL;
 347         }
 348
 349         return 0;
 350 }
 351
 352 /*
 353  * Configure the SSC.
 354  */
 355 static int at91_ssc_hw_params(struct snd_pcm_substream *substream,
 356         struct snd_pcm_hw_params *params)
 357 {
 358         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 359         int id = rtd->dai->cpu_dai->id;
 360         struct at91_ssc_info *ssc_p = &ssc_info[id];
 361         struct at91_pcm_dma_params *dma_params;
 362         int dir, channels, bits;
 363         u32 tfmr, rfmr, tcmr, rcmr;
 364         int start_event;
 365         int ret;
 366
 367         /*
 368          * Currently, there is only one set of dma params for
 369          * each direction.  If more are added, this code will
 370          * have to be changed to select the proper set.
 371          */
 372         dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
 373
 374         dma_params = &ssc_dma_params[id][dir];
 375         dma_params->ssc_base = ssc_p->ssc.base;
 376         dma_params->substream = substream;
 377
 378         ssc_p->dma_params[dir] = dma_params;
 379
 380         /*
 381          * The cpu_dai->dma_data field is only used to communicate the
 382          * appropriate DMA parameters to the pcm driver hw_params()
 383          * function.  It should not be used for other purposes
 384          * as it is common to all substreams.
 385          */
 386         rtd->dai->cpu_dai->dma_data = dma_params;
 387
 388         channels = params_channels(params);
 389
 390         /*
 391          * Determine sample size in bits and the PDC increment.
 392          */
 393         switch(params_format(params)) {
 394         case SNDRV_PCM_FORMAT_S8:
 395                 bits = 8;
 396                 dma_params->pdc_xfer_size = 1;
 397                 break;
 398         case SNDRV_PCM_FORMAT_S16_LE:
 399                 bits = 16;
 400                 dma_params->pdc_xfer_size = 2;
 401                 break;
 402         case SNDRV_PCM_FORMAT_S24_LE:
 403                 bits = 24;
 404                 dma_params->pdc_xfer_size = 4;
 405                 break;
 406         case SNDRV_PCM_FORMAT_S32_LE:
 407                 bits = 32;
 408                 dma_params->pdc_xfer_size = 4;
 409                 break;
 410         default:
 411                 printk(KERN_WARNING "at91-ssc: unsupported PCM format");
 412                 return -EINVAL;
 413         }
 414
 415         /*
 416          * The SSC only supports up to 16-bit samples in I2S format, due
 417          * to the size of the Frame Mode Register FSLEN field.
 418          */
 419         if ((ssc_p->daifmt & SND_SOC_DAIFMT_FORMAT_MASK) == SND_SOC_DAIFMT_I2S
 420                 && bits > 16) {
 421                 printk(KERN_WARNING
 422                         "at91-ssc: sample size %d is too large for I2S\n", bits);
 423                 return -EINVAL;
 424         }
 425
 426         /*
 427          * Compute SSC register settings.
 428          */
 429         switch (ssc_p->daifmt
 430                 & (SND_SOC_DAIFMT_FORMAT_MASK | SND_SOC_DAIFMT_MASTER_MASK)) {
 431
 432         case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBS_CFS:
 433                 /*
 434                  * I2S format, SSC provides BCLK and LRC clocks.
 435                  *
 436                  * The SSC transmit and receive clocks are generated from the
 437                  * MCK divider, and the BCLK signal is output on the SSC TK line.
 438                  */
 439                 rcmr =    (( ssc_p->rcmr_period         << 24) & AT91_SSC_PERIOD)
 440                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 441                         | (( AT91_SSC_START_FALLING_RF       ) & AT91_SSC_START)
 442                         | (( AT91_SSC_CK_RISING              ) & AT91_SSC_CKI)
 443                         | (( AT91_SSC_CKO_NONE               ) & AT91_SSC_CKO)
 444                         | (( AT91_SSC_CKS_DIV                ) & AT91_SSC_CKS);
 445
 446                 rfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 447                         | (( AT91_SSC_FSOS_NEGATIVE          ) & AT91_SSC_FSOS)
 448                         | (((bits - 1)                  << 16) & AT91_SSC_FSLEN)
 449                         | (((channels - 1)              <<  8) & AT91_SSC_DATNB)
 450                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 451                         | (( 0                          <<  5) & AT91_SSC_LOOP)
 452                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 453
 454                 tcmr =    (( ssc_p->tcmr_period         << 24) & AT91_SSC_PERIOD)
 455                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 456                         | (( AT91_SSC_START_FALLING_RF       ) & AT91_SSC_START)
 457                         | (( AT91_SSC_CKI_FALLING            ) & AT91_SSC_CKI)
 458                         | (( AT91_SSC_CKO_CONTINUOUS         ) & AT91_SSC_CKO)
 459                         | (( AT91_SSC_CKS_DIV                ) & AT91_SSC_CKS);
 460
 461                 tfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 462                         | (( 0                          << 23) & AT91_SSC_FSDEN)
 463                         | (( AT91_SSC_FSOS_NEGATIVE          ) & AT91_SSC_FSOS)
 464                         | (((bits - 1)                  << 16) & AT91_SSC_FSLEN)
 465                         | (((channels - 1)              <<  8) & AT91_SSC_DATNB)
 466                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 467                         | (( 0                          <<  5) & AT91_SSC_DATDEF)
 468                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 469                 break;
 470
 471         case SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_CBM_CFM:
 472                 /*
 473                  * I2S format, CODEC supplies BCLK and LRC clocks.
 474                  *
 475                  * The SSC transmit clock is obtained from the BCLK signal on
 476                  * on the TK line, and the SSC receive clock is generated from the
 477                  * transmit clock.
 478                  *
 479                  * For single channel data, one sample is transferred on the falling
 480                  * edge of the LRC clock.  For two channel data, one sample is
 481                  * transferred on both edges of the LRC clock.
 482                  */
 483                 start_event = channels == 1
 484                                 ? AT91_SSC_START_FALLING_RF
 485                                 : AT91_SSC_START_EDGE_RF;
 486
 487                 rcmr =    (( 0                          << 24) & AT91_SSC_PERIOD)
 488                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 489                         | (( start_event                     ) & AT91_SSC_START)
 490                         | (( AT91_SSC_CK_RISING              ) & AT91_SSC_CKI)
 491                         | (( AT91_SSC_CKO_NONE               ) & AT91_SSC_CKO)
 492                         | (( AT91_SSC_CKS_CLOCK              ) & AT91_SSC_CKS);
 493
 494                 rfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 495                         | (( AT91_SSC_FSOS_NONE              ) & AT91_SSC_FSOS)
 496                         | (( 0                          << 16) & AT91_SSC_FSLEN)
 497                         | (( 0                          <<  8) & AT91_SSC_DATNB)
 498                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 499                         | (( 0                          <<  5) & AT91_SSC_LOOP)
 500                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 501
 502                 tcmr =    (( 0                          << 24) & AT91_SSC_PERIOD)
 503                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 504                         | (( start_event                     ) & AT91_SSC_START)
 505                         | (( AT91_SSC_CKI_FALLING            ) & AT91_SSC_CKI)
 506                         | (( AT91_SSC_CKO_NONE               ) & AT91_SSC_CKO)
 507                         | (( AT91_SSC_CKS_PIN                ) & AT91_SSC_CKS);
 508
 509                 tfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 510                         | (( 0                          << 23) & AT91_SSC_FSDEN)
 511                         | (( AT91_SSC_FSOS_NONE              ) & AT91_SSC_FSOS)
 512                         | (( 0                          << 16) & AT91_SSC_FSLEN)
 513                         | (( 0                          <<  8) & AT91_SSC_DATNB)
 514                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 515                         | (( 0                          <<  5) & AT91_SSC_DATDEF)
 516                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 517                 break;
 518
 519         case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBS_CFS:
 520                 /*
 521                  * DSP/PCM Mode A format, SSC provides BCLK and LRC clocks.
 522                  *
 523                  * The SSC transmit and receive clocks are generated from the
 524                  * MCK divider, and the BCLK signal is output on the SSC TK line.
 525                  */
 526                 rcmr =    (( ssc_p->rcmr_period         << 24) & AT91_SSC_PERIOD)
 527                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 528                         | (( AT91_SSC_START_RISING_RF        ) & AT91_SSC_START)
 529                         | (( AT91_SSC_CK_RISING              ) & AT91_SSC_CKI)
 530                         | (( AT91_SSC_CKO_NONE               ) & AT91_SSC_CKO)
 531                         | (( AT91_SSC_CKS_DIV                ) & AT91_SSC_CKS);
 532
 533                 rfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 534                         | (( AT91_SSC_FSOS_POSITIVE          ) & AT91_SSC_FSOS)
 535                         | (( 0                          << 16) & AT91_SSC_FSLEN)
 536                         | (((channels - 1)              <<  8) & AT91_SSC_DATNB)
 537                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 538                         | (( 0                          <<  5) & AT91_SSC_LOOP)
 539                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 540
 541                 tcmr =    (( ssc_p->tcmr_period         << 24) & AT91_SSC_PERIOD)
 542                         | (( 1                          << 16) & AT91_SSC_STTDLY)
 543                         | (( AT91_SSC_START_RISING_RF        ) & AT91_SSC_START)
 544                         | (( AT91_SSC_CK_RISING              ) & AT91_SSC_CKI)
 545                         | (( AT91_SSC_CKO_CONTINUOUS         ) & AT91_SSC_CKO)
 546                         | (( AT91_SSC_CKS_DIV                ) & AT91_SSC_CKS);
 547
 548                 tfmr =    (( AT91_SSC_FSEDGE_POSITIVE        ) & AT91_SSC_FSEDGE)
 549                         | (( 0                          << 23) & AT91_SSC_FSDEN)
 550                         | (( AT91_SSC_FSOS_POSITIVE          ) & AT91_SSC_FSOS)
 551                         | (( 0                          << 16) & AT91_SSC_FSLEN)
 552                         | (((channels - 1)              <<  8) & AT91_SSC_DATNB)
 553                         | (( 1                          <<  7) & AT91_SSC_MSBF)
 554                         | (( 0                          <<  5) & AT91_SSC_DATDEF)
 555                         | (((bits - 1)                  <<  0) & AT91_SSC_DATALEN);
 556
 557
 558
 559                         break;
 560
 561         case SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_CBM_CFM:
 562         default:
 563                 printk(KERN_WARNING "at91-ssc: unsupported DAI format 0x%x.\n",
 564                         ssc_p->daifmt);
 565                 return -EINVAL;
 566                 break;
 567         }
 568         DBG("RCMR=%08x RFMR=%08x TCMR=%08x TFMR=%08x\n", rcmr, rfmr, tcmr, tfmr);
 569
 570         if (!ssc_p->initialized) {
 571
 572                 /* Enable PMC peripheral clock for this SSC */
 573                 DBG("Starting pid %d clock\n", ssc_p->ssc.pid);
 574                 at91_sys_write(AT91_PMC_PCER, 1<<ssc_p->ssc.pid);
 575
 576                 /* Reset the SSC and its PDC registers */
 577                 at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR, AT91_SSC_SWRST);
 578
 579                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_RPR, 0);
 580                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_RCR, 0);
 581                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_RNPR, 0);
 582                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_RNCR, 0);
 583                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_TPR, 0);
 584                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_TCR, 0);
 585                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_TNPR, 0);
 586                 at91_ssc_write(ssc_p->ssc.base + ATMEL_PDC_TNCR, 0);
 587
 588                 if ((ret = request_irq(ssc_p->ssc.pid, at91_ssc_interrupt,
 589                                         0, ssc_p->name, ssc_p)) < 0) {
 590                         printk(KERN_WARNING "at91-ssc: request_irq failure\n");
 591
 592                         DBG("Stopping pid %d clock\n", ssc_p->ssc.pid);
 593                         at91_sys_write(AT91_PMC_PCDR, 1<<ssc_p->ssc.pid);
 594                         return ret;
 595                 }
 596
 597                 ssc_p->initialized = 1;
 598         }
 599
 600         /* set SSC clock mode register */
 601         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CMR, ssc_p->cmr_div);
 602
 603         /* set receive clock mode and format */
 604         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, rcmr);
 605         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RFMR, rfmr);
 606
 607         /* set transmit clock mode and format */
 608         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TCMR, tcmr);
 609         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TFMR, tfmr);
 610
 611         DBG("hw_params: SSC initialized\n");
 612         return 0;
 613 }
 614
 615
 616 static int at91_ssc_prepare(struct snd_pcm_substream *substream)
 617 {
 618         struct snd_soc_pcm_runtime *rtd = substream->private_data;
 619         struct at91_ssc_info *ssc_p = &ssc_info[rtd->dai->cpu_dai->id];
 620         struct at91_pcm_dma_params *dma_params;
 621         int dir;
 622
 623         dir = substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? 0 : 1;
 624         dma_params = ssc_p->dma_params[dir];
 625
 626         at91_ssc_write(dma_params->ssc_base + AT91_SSC_CR,
 627                         dma_params->mask->ssc_enable);
 628
 629         DBG("%s enabled SSC_SR=0x%08lx\n", dir ? "receive" : "transmit",
 630                 at91_ssc_read(dma_params->ssc_base + AT91_SSC_SR));
 631         return 0;
 632 }
 633
 634
 635 #ifdef CONFIG_PM
 636 static int at91_ssc_suspend(struct platform_device *pdev,
 637         struct snd_soc_dai *cpu_dai)
 638 {
 639         struct at91_ssc_info *ssc_p;
 640
 641         if(!cpu_dai->active)
 642                 return 0;
 643
 644         ssc_p = &ssc_info[cpu_dai->id];
 645
 646         /* Save the status register before disabling transmit and receive. */
 647         ssc_p->ssc_state.ssc_sr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_SR);
 648         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR,
 649                         AT91_SSC_TXDIS | AT91_SSC_RXDIS);
 650
 651         /* Save the current interrupt mask, then disable unmasked interrupts. */
 652         ssc_p->ssc_state.ssc_imr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_IMR);
 653         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_IDR, ssc_p->ssc_state.ssc_imr);
 654
 655         ssc_p->ssc_state.ssc_cmr  = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_CMR);
 656         ssc_p->ssc_state.ssc_rcmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RCMR);
 657         ssc_p->ssc_state.ssc_rfmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_RFMR);
 658         ssc_p->ssc_state.ssc_tcmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_TCMR);
 659         ssc_p->ssc_state.ssc_tfmr = at91_ssc_read(ssc_p->ssc.base + AT91_SSC_TFMR);
 660
 661         return 0;
 662 }
 663
 664 static int at91_ssc_resume(struct platform_device *pdev,
 665         struct snd_soc_dai *cpu_dai)
 666 {
 667         struct at91_ssc_info *ssc_p;
 668
 669         if(!cpu_dai->active)
 670                 return 0;
 671
 672         ssc_p = &ssc_info[cpu_dai->id];
 673
 674         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TFMR, ssc_p->ssc_state.ssc_tfmr);
 675         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_TCMR, ssc_p->ssc_state.ssc_tcmr);
 676         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RFMR, ssc_p->ssc_state.ssc_rfmr);
 677         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_RCMR, ssc_p->ssc_state.ssc_rcmr);
 678         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CMR,  ssc_p->ssc_state.ssc_cmr);
 679
 680         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_IER,  ssc_p->ssc_state.ssc_imr);
 681
 682         at91_ssc_write(ssc_p->ssc.base + AT91_SSC_CR,
 683                 ((ssc_p->ssc_state.ssc_sr & AT91_SSC_RXENA) ? AT91_SSC_RXEN : 0) |
 684                 ((ssc_p->ssc_state.ssc_sr & AT91_SSC_TXENA) ? AT91_SSC_TXEN : 0));
 685
 686         return 0;
 687 }
 688
 689 #else
 690 #define at91_ssc_suspend        NULL
 691 #define at91_ssc_resume         NULL
 692 #endif
 693
 694 #define AT91_SSC_RATES (SNDRV_PCM_RATE_8000  | SNDRV_PCM_RATE_11025 |\
 695                         SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\
 696                         SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 |\
 697                         SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 |\
 698                         SNDRV_PCM_RATE_96000)
 699
 700 #define AT91_SSC_FORMATS (SNDRV_PCM_FMTBIT_S8     | SNDRV_PCM_FMTBIT_S16_LE |\
 701                           SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S32_LE)
 702
 703 struct snd_soc_dai at91_ssc_dai[NUM_SSC_DEVICES] = {
 704         {       .name = "at91-ssc0",
 705                 .id = 0,
 706                 .type = SND_SOC_DAI_PCM,
 707                 .suspend = at91_ssc_suspend,
 708                 .resume = at91_ssc_resume,
 709                 .playback = {
 710                         .channels_min = 1,
 711                         .channels_max = 2,
 712                         .rates = AT91_SSC_RATES,
 713                         .formats = AT91_SSC_FORMATS,},
 714                 .capture = {
 715                         .channels_min = 1,
 716                         .channels_max = 2,
 717                         .rates = AT91_SSC_RATES,
 718                         .formats = AT91_SSC_FORMATS,},
 719                 .ops = {
 720                         .startup = at91_ssc_startup,
 721                         .shutdown = at91_ssc_shutdown,
 722                         .prepare = at91_ssc_prepare,
 723                         .hw_params = at91_ssc_hw_params,},
 724                 .dai_ops = {
 725                         .set_sysclk = at91_ssc_set_dai_sysclk,
 726                         .set_fmt = at91_ssc_set_dai_fmt,
 727                         .set_clkdiv = at91_ssc_set_dai_clkdiv,},
 728                 .private_data = &ssc_info[0].ssc,
 729         },
 730 #if NUM_SSC_DEVICES == 3
 731         {       .name = "at91-ssc1",
 732                 .id = 1,
 733                 .type = SND_SOC_DAI_PCM,
 734                 .suspend = at91_ssc_suspend,
 735                 .resume = at91_ssc_resume,
 736                 .playback = {
 737                         .channels_min = 1,
 738                         .channels_max = 2,
 739                         .rates = AT91_SSC_RATES,
 740                         .formats = AT91_SSC_FORMATS,},
 741                 .capture = {
 742                         .channels_min = 1,
 743                         .channels_max = 2,
 744                         .rates = AT91_SSC_RATES,
 745                         .formats = AT91_SSC_FORMATS,},
 746                 .ops = {
 747                         .startup = at91_ssc_startup,
 748                         .shutdown = at91_ssc_shutdown,
 749                         .prepare = at91_ssc_prepare,
 750                         .hw_params = at91_ssc_hw_params,},
 751                 .dai_ops = {
 752                         .set_sysclk = at91_ssc_set_dai_sysclk,
 753                         .set_fmt = at91_ssc_set_dai_fmt,
 754                         .set_clkdiv = at91_ssc_set_dai_clkdiv,},
 755                 .private_data = &ssc_info[1].ssc,
 756         },
 757         {       .name = "at91-ssc2",
 758                 .id = 2,
 759                 .type = SND_SOC_DAI_PCM,
 760                 .suspend = at91_ssc_suspend,
 761                 .resume = at91_ssc_resume,
 762                 .playback = {
 763                         .channels_min = 1,
 764                         .channels_max = 2,
 765                         .rates = AT91_SSC_RATES,
 766                         .formats = AT91_SSC_FORMATS,},
 767                 .capture = {
 768                         .channels_min = 1,
 769                         .channels_max = 2,
 770                         .rates = AT91_SSC_RATES,
 771                         .formats = AT91_SSC_FORMATS,},
 772                 .ops = {
 773                         .startup = at91_ssc_startup,
 774                         .shutdown = at91_ssc_shutdown,
 775                         .prepare = at91_ssc_prepare,
 776                         .hw_params = at91_ssc_hw_params,},
 777                 .dai_ops = {
 778                         .set_sysclk = at91_ssc_set_dai_sysclk,
 779                         .set_fmt = at91_ssc_set_dai_fmt,
 780                         .set_clkdiv = at91_ssc_set_dai_clkdiv,},
 781                 .private_data = &ssc_info[2].ssc,
 782         },
 783 #endif
 784 };
 785
 786 EXPORT_SYMBOL_GPL(at91_ssc_dai);
 787
 788 /* Module information */
 789 MODULE_AUTHOR("Frank Mandarino, fmandarino@endrelia.com, www.endrelia.com");
 790 MODULE_DESCRIPTION("AT91 SSC ASoC Interface");
 791 MODULE_LICENSE("GPL");