sound/soc/davinci/davinci-mcasp.c

   1 /*
   2  * ALSA SoC McASP Audio Layer for TI DAVINCI processor
   3  *
   4  * Multi-channel Audio Serial Port Driver
   5  *
   6  * Author: Nirmal Pandey <n-pandey@ti.com>,
   7  *         Suresh Rajashekara <suresh.r@ti.com>
   8  *         Steve Chen <schen@.mvista.com>
   9  *
  10  * Copyright:   (C) 2009 MontaVista Software, Inc., <source@mvista.com>
  11  * Copyright:   (C) 2009  Texas Instruments, India
  12  *
  13  * This program is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License version 2 as
  15  * published by the Free Software Foundation.
  16  */
  17
  18 #include <linux/init.h>
  19 #include <linux/module.h>
  20 #include <linux/device.h>
  21 #include <linux/slab.h>
  22 #include <linux/delay.h>
  23 #include <linux/io.h>
  24 #include <linux/clk.h>
  25 #include <linux/pm_runtime.h>
  26 #include <linux/of.h>
  27 #include <linux/of_platform.h>
  28 #include <linux/of_device.h>
  29 #include <linux/platform_data/davinci_asp.h>
  30 #include <linux/math64.h>
  31
  32 #include <sound/asoundef.h>
  33 #include <sound/core.h>
  34 #include <sound/pcm.h>
  35 #include <sound/pcm_params.h>
  36 #include <sound/initval.h>
  37 #include <sound/soc.h>
  38 #include <sound/dmaengine_pcm.h>
  39 #include <sound/omap-pcm.h>
  40
  41 #include "edma-pcm.h"
  42 #include "davinci-mcasp.h"
  43
  44 #define MCASP_MAX_AFIFO_DEPTH   64
  45
  46 static u32 context_regs[] = {
  47         DAVINCI_MCASP_TXFMCTL_REG,
  48         DAVINCI_MCASP_RXFMCTL_REG,
  49         DAVINCI_MCASP_TXFMT_REG,
  50         DAVINCI_MCASP_RXFMT_REG,
  51         DAVINCI_MCASP_ACLKXCTL_REG,
  52         DAVINCI_MCASP_ACLKRCTL_REG,
  53         DAVINCI_MCASP_AHCLKXCTL_REG,
  54         DAVINCI_MCASP_AHCLKRCTL_REG,
  55         DAVINCI_MCASP_PDIR_REG,
  56         DAVINCI_MCASP_RXMASK_REG,
  57         DAVINCI_MCASP_TXMASK_REG,
  58         DAVINCI_MCASP_RXTDM_REG,
  59         DAVINCI_MCASP_TXTDM_REG,
  60 };
  61
  62 struct davinci_mcasp_context {
  63         u32     config_regs[ARRAY_SIZE(context_regs)];
  64         u32     afifo_regs[2]; /* for read/write fifo control registers */
  65         u32     *xrsr_regs; /* for serializer configuration */
  66         bool    pm_state;
  67 };
  68
  69 struct davinci_mcasp_ruledata {
  70         struct davinci_mcasp *mcasp;
  71         int serializers;
  72 };
  73
  74 struct davinci_mcasp {
  75         struct snd_dmaengine_dai_dma_data dma_data[2];
  76         void __iomem *base;
  77         u32 fifo_base;
  78         struct device *dev;
  79         struct snd_pcm_substream *substreams[2];
  80
  81         /* McASP specific data */
  82         int     tdm_slots;
  83         u8      op_mode;
  84         u8      num_serializer;
  85         u8      *serial_dir;
  86         u8      version;
  87         u8      bclk_div;
  88         u16     bclk_lrclk_ratio;
  89         int     streams;
  90         u32     irq_request[2];
  91         int     dma_request[2];
  92
  93         int     sysclk_freq;
  94         bool    bclk_master;
  95
  96         /* McASP FIFO related */
  97         u8      txnumevt;
  98         u8      rxnumevt;
  99
 100         bool    dat_port;
 101
 102         /* Used for comstraint setting on the second stream */
 103         u32     channels;
 104
 105 #ifdef CONFIG_PM_SLEEP
 106         struct davinci_mcasp_context context;
 107 #endif
 108
 109         struct davinci_mcasp_ruledata ruledata[2];
 110         struct snd_pcm_hw_constraint_list chconstr[2];
 111 };
 112
 113 static inline void mcasp_set_bits(struct davinci_mcasp *mcasp, u32 offset,
 114                                   u32 val)
 115 {
 116         void __iomem *reg = mcasp->base + offset;
 117         __raw_writel(__raw_readl(reg) | val, reg);
 118 }
 119
 120 static inline void mcasp_clr_bits(struct davinci_mcasp *mcasp, u32 offset,
 121                                   u32 val)
 122 {
 123         void __iomem *reg = mcasp->base + offset;
 124         __raw_writel((__raw_readl(reg) & ~(val)), reg);
 125 }
 126
 127 static inline void mcasp_mod_bits(struct davinci_mcasp *mcasp, u32 offset,
 128                                   u32 val, u32 mask)
 129 {
 130         void __iomem *reg = mcasp->base + offset;
 131         __raw_writel((__raw_readl(reg) & ~mask) | val, reg);
 132 }
 133
 134 static inline void mcasp_set_reg(struct davinci_mcasp *mcasp, u32 offset,
 135                                  u32 val)
 136 {
 137         __raw_writel(val, mcasp->base + offset);
 138 }
 139
 140 static inline u32 mcasp_get_reg(struct davinci_mcasp *mcasp, u32 offset)
 141 {
 142         return (u32)__raw_readl(mcasp->base + offset);
 143 }
 144
 145 static void mcasp_set_ctl_reg(struct davinci_mcasp *mcasp, u32 ctl_reg, u32 val)
 146 {
 147         int i = 0;
 148
 149         mcasp_set_bits(mcasp, ctl_reg, val);
 150
 151         /* programming GBLCTL needs to read back from GBLCTL and verfiy */
 152         /* loop count is to avoid the lock-up */
 153         for (i = 0; i < 1000; i++) {
 154                 if ((mcasp_get_reg(mcasp, ctl_reg) & val) == val)
 155                         break;
 156         }
 157
 158         if (i == 1000 && ((mcasp_get_reg(mcasp, ctl_reg) & val) != val))
 159                 printk(KERN_ERR "GBLCTL write error\n");
 160 }
 161
 162 static bool mcasp_is_synchronous(struct davinci_mcasp *mcasp)
 163 {
 164         u32 rxfmctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXFMCTL_REG);
 165         u32 aclkxctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_ACLKXCTL_REG);
 166
 167         return !(aclkxctl & TX_ASYNC) && rxfmctl & AFSRE;
 168 }
 169
 170 static void mcasp_start_rx(struct davinci_mcasp *mcasp)
 171 {
 172         if (mcasp->rxnumevt) {  /* enable FIFO */
 173                 u32 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 174
 175                 mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 176                 mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
 177         }
 178
 179         /* Start clocks */
 180         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
 181         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
 182         /*
 183          * When ASYNC == 0 the transmit and receive sections operate
 184          * synchronously from the transmit clock and frame sync. We need to make
 185          * sure that the TX signlas are enabled when starting reception.
 186          */
 187         if (mcasp_is_synchronous(mcasp)) {
 188                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
 189                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
 190         }
 191
 192         /* Activate serializer(s) */
 193         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
 194         /* Release RX state machine */
 195         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
 196         /* Release Frame Sync generator */
 197         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
 198         if (mcasp_is_synchronous(mcasp))
 199                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 200
 201         /* enable receive IRQs */
 202         mcasp_set_bits(mcasp, DAVINCI_MCASP_EVTCTLR_REG,
 203                        mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE]);
 204 }
 205
 206 static void mcasp_start_tx(struct davinci_mcasp *mcasp)
 207 {
 208         u32 cnt;
 209
 210         if (mcasp->txnumevt) {  /* enable FIFO */
 211                 u32 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 212
 213                 mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 214                 mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
 215         }
 216
 217         /* Start clocks */
 218         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
 219         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
 220         /* Activate serializer(s) */
 221         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
 222
 223         /* wait for XDATA to be cleared */
 224         cnt = 0;
 225         while (!(mcasp_get_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG) &
 226                  ~XRDATA) && (cnt < 100000))
 227                 cnt++;
 228
 229         /* Release TX state machine */
 230         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
 231         /* Release Frame Sync generator */
 232         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 233
 234         /* enable transmit IRQs */
 235         mcasp_set_bits(mcasp, DAVINCI_MCASP_EVTCTLX_REG,
 236                        mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK]);
 237 }
 238
 239 static void davinci_mcasp_start(struct davinci_mcasp *mcasp, int stream)
 240 {
 241         mcasp->streams++;
 242
 243         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
 244                 mcasp_start_tx(mcasp);
 245         else
 246                 mcasp_start_rx(mcasp);
 247 }
 248
 249 static void mcasp_stop_rx(struct davinci_mcasp *mcasp)
 250 {
 251         /* disable IRQ sources */
 252         mcasp_clr_bits(mcasp, DAVINCI_MCASP_EVTCTLR_REG,
 253                        mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE]);
 254
 255         /*
 256          * In synchronous mode stop the TX clocks if no other stream is
 257          * running
 258          */
 259         if (mcasp_is_synchronous(mcasp) && !mcasp->streams)
 260                 mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, 0);
 261
 262         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, 0);
 263         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
 264
 265         if (mcasp->rxnumevt) {  /* disable FIFO */
 266                 u32 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 267
 268                 mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 269         }
 270 }
 271
 272 static void mcasp_stop_tx(struct davinci_mcasp *mcasp)
 273 {
 274         u32 val = 0;
 275
 276         /* disable IRQ sources */
 277         mcasp_clr_bits(mcasp, DAVINCI_MCASP_EVTCTLX_REG,
 278                        mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK]);
 279
 280         /*
 281          * In synchronous mode keep TX clocks running if the capture stream is
 282          * still running.
 283          */
 284         if (mcasp_is_synchronous(mcasp) && mcasp->streams)
 285                 val =  TXHCLKRST | TXCLKRST | TXFSRST;
 286
 287         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, val);
 288         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
 289
 290         if (mcasp->txnumevt) {  /* disable FIFO */
 291                 u32 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 292
 293                 mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 294         }
 295 }
 296
 297 static void davinci_mcasp_stop(struct davinci_mcasp *mcasp, int stream)
 298 {
 299         mcasp->streams--;
 300
 301         if (stream == SNDRV_PCM_STREAM_PLAYBACK)
 302                 mcasp_stop_tx(mcasp);
 303         else
 304                 mcasp_stop_rx(mcasp);
 305 }
 306
 307 static irqreturn_t davinci_mcasp_tx_irq_handler(int irq, void *data)
 308 {
 309         struct davinci_mcasp *mcasp = (struct davinci_mcasp *)data;
 310         struct snd_pcm_substream *substream;
 311         u32 irq_mask = mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK];
 312         u32 handled_mask = 0;
 313         u32 stat;
 314
 315         stat = mcasp_get_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG);
 316         if (stat & XUNDRN & irq_mask) {
 317                 dev_warn(mcasp->dev, "Transmit buffer underflow\n");
 318                 handled_mask |= XUNDRN;
 319
 320                 substream = mcasp->substreams[SNDRV_PCM_STREAM_PLAYBACK];
 321                 if (substream) {
 322                         snd_pcm_stream_lock_irq(substream);
 323                         if (snd_pcm_running(substream))
 324                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 325                         snd_pcm_stream_unlock_irq(substream);
 326                 }
 327         }
 328
 329         if (!handled_mask)
 330                 dev_warn(mcasp->dev, "unhandled tx event. txstat: 0x%08x\n",
 331                          stat);
 332
 333         if (stat & XRERR)
 334                 handled_mask |= XRERR;
 335
 336         /* Ack the handled event only */
 337         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, handled_mask);
 338
 339         return IRQ_RETVAL(handled_mask);
 340 }
 341
 342 static irqreturn_t davinci_mcasp_rx_irq_handler(int irq, void *data)
 343 {
 344         struct davinci_mcasp *mcasp = (struct davinci_mcasp *)data;
 345         struct snd_pcm_substream *substream;
 346         u32 irq_mask = mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE];
 347         u32 handled_mask = 0;
 348         u32 stat;
 349
 350         stat = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG);
 351         if (stat & ROVRN & irq_mask) {
 352                 dev_warn(mcasp->dev, "Receive buffer overflow\n");
 353                 handled_mask |= ROVRN;
 354
 355                 substream = mcasp->substreams[SNDRV_PCM_STREAM_CAPTURE];
 356                 if (substream) {
 357                         snd_pcm_stream_lock_irq(substream);
 358                         if (snd_pcm_running(substream))
 359                                 snd_pcm_stop(substream, SNDRV_PCM_STATE_XRUN);
 360                         snd_pcm_stream_unlock_irq(substream);
 361                 }
 362         }
 363
 364         if (!handled_mask)
 365                 dev_warn(mcasp->dev, "unhandled rx event. rxstat: 0x%08x\n",
 366                          stat);
 367
 368         if (stat & XRERR)
 369                 handled_mask |= XRERR;
 370
 371         /* Ack the handled event only */
 372         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, handled_mask);
 373
 374         return IRQ_RETVAL(handled_mask);
 375 }
 376
 377 static irqreturn_t davinci_mcasp_common_irq_handler(int irq, void *data)
 378 {
 379         struct davinci_mcasp *mcasp = (struct davinci_mcasp *)data;
 380         irqreturn_t ret = IRQ_NONE;
 381
 382         if (mcasp->substreams[SNDRV_PCM_STREAM_PLAYBACK])
 383                 ret = davinci_mcasp_tx_irq_handler(irq, data);
 384
 385         if (mcasp->substreams[SNDRV_PCM_STREAM_CAPTURE])
 386                 ret |= davinci_mcasp_rx_irq_handler(irq, data);
 387
 388         return ret;
 389 }
 390
 391 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 392                                          unsigned int fmt)
 393 {
 394         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 395         int ret = 0;
 396         u32 data_delay;
 397         bool fs_pol_rising;
 398         bool inv_fs = false;
 399
 400         pm_runtime_get_sync(mcasp->dev);
 401         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 402         case SND_SOC_DAIFMT_DSP_A:
 403                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 404                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 405                 /* 1st data bit occur one ACLK cycle after the frame sync */
 406                 data_delay = 1;
 407                 break;
 408         case SND_SOC_DAIFMT_DSP_B:
 409         case SND_SOC_DAIFMT_AC97:
 410                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 411                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 412                 /* No delay after FS */
 413                 data_delay = 0;
 414                 break;
 415         case SND_SOC_DAIFMT_I2S:
 416                 /* configure a full-word SYNC pulse (LRCLK) */
 417                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 418                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 419                 /* 1st data bit occur one ACLK cycle after the frame sync */
 420                 data_delay = 1;
 421                 /* FS need to be inverted */
 422                 inv_fs = true;
 423                 break;
 424         case SND_SOC_DAIFMT_LEFT_J:
 425                 /* configure a full-word SYNC pulse (LRCLK) */
 426                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 427                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 428                 /* No delay after FS */
 429                 data_delay = 0;
 430                 break;
 431         default:
 432                 ret = -EINVAL;
 433                 goto out;
 434         }
 435
 436         mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, FSXDLY(data_delay),
 437                        FSXDLY(3));
 438         mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, FSRDLY(data_delay),
 439                        FSRDLY(3));
 440
 441         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 442         case SND_SOC_DAIFMT_CBS_CFS:
 443                 /* codec is clock and frame slave */
 444                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 445                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 446
 447                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 448                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 449
 450                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
 451                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
 452                 mcasp->bclk_master = 1;
 453                 break;
 454         case SND_SOC_DAIFMT_CBS_CFM:
 455                 /* codec is clock slave and frame master */
 456                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 457                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 458
 459                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 460                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 461
 462                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
 463                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
 464                 mcasp->bclk_master = 1;
 465                 break;
 466         case SND_SOC_DAIFMT_CBM_CFS:
 467                 /* codec is clock master and frame slave */
 468                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 469                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 470
 471                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 472                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 473
 474                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
 475                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
 476                 mcasp->bclk_master = 0;
 477                 break;
 478         case SND_SOC_DAIFMT_CBM_CFM:
 479                 /* codec is clock and frame master */
 480                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 481                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 482
 483                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 484                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 485
 486                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG,
 487                                ACLKX | AHCLKX | AFSX | ACLKR | AHCLKR | AFSR);
 488                 mcasp->bclk_master = 0;
 489                 break;
 490         default:
 491                 ret = -EINVAL;
 492                 goto out;
 493         }
 494
 495         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 496         case SND_SOC_DAIFMT_IB_NF:
 497                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 498                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 499                 fs_pol_rising = true;
 500                 break;
 501         case SND_SOC_DAIFMT_NB_IF:
 502                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 503                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 504                 fs_pol_rising = false;
 505                 break;
 506         case SND_SOC_DAIFMT_IB_IF:
 507                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 508                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 509                 fs_pol_rising = false;
 510                 break;
 511         case SND_SOC_DAIFMT_NB_NF:
 512                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 513                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 514                 fs_pol_rising = true;
 515                 break;
 516         default:
 517                 ret = -EINVAL;
 518                 goto out;
 519         }
 520
 521         if (inv_fs)
 522                 fs_pol_rising = !fs_pol_rising;
 523
 524         if (fs_pol_rising) {
 525                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 526                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
 527         } else {
 528                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 529                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
 530         }
 531 out:
 532         pm_runtime_put(mcasp->dev);
 533         return ret;
 534 }
 535
 536 static int __davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
 537                                       int div, bool explicit)
 538 {
 539         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 540
 541         pm_runtime_get_sync(mcasp->dev);
 542         switch (div_id) {
 543         case 0:         /* MCLK divider */
 544                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG,
 545                                AHCLKXDIV(div - 1), AHCLKXDIV_MASK);
 546                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG,
 547                                AHCLKRDIV(div - 1), AHCLKRDIV_MASK);
 548                 break;
 549
 550         case 1:         /* BCLK divider */
 551                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG,
 552                                ACLKXDIV(div - 1), ACLKXDIV_MASK);
 553                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG,
 554                                ACLKRDIV(div - 1), ACLKRDIV_MASK);
 555                 if (explicit)
 556                         mcasp->bclk_div = div;
 557                 break;
 558
 559         case 2:         /* BCLK/LRCLK ratio */
 560                 mcasp->bclk_lrclk_ratio = div;
 561                 break;
 562
 563         default:
 564                 return -EINVAL;
 565         }
 566
 567         pm_runtime_put(mcasp->dev);
 568         return 0;
 569 }
 570
 571 static int davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
 572                                     int div)
 573 {
 574         return __davinci_mcasp_set_clkdiv(dai, div_id, div, 1);
 575 }
 576
 577 static int davinci_mcasp_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 578                                     unsigned int freq, int dir)
 579 {
 580         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 581
 582         pm_runtime_get_sync(mcasp->dev);
 583         if (dir == SND_SOC_CLOCK_OUT) {
 584                 mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
 585                 mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
 586                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
 587         } else {
 588                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
 589                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
 590                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
 591         }
 592
 593         mcasp->sysclk_freq = freq;
 594
 595         pm_runtime_put(mcasp->dev);
 596         return 0;
 597 }
 598
 599 static int davinci_config_channel_size(struct davinci_mcasp *mcasp,
 600                                        int word_length)
 601 {
 602         u32 fmt;
 603         u32 tx_rotate = (word_length / 4) & 0x7;
 604         u32 mask = (1ULL << word_length) - 1;
 605         /*
 606          * For captured data we should not rotate, inversion and masking is
 607          * enoguh to get the data to the right position:
 608          * Format         data from bus         after reverse (XRBUF)
 609          * S16_LE:      |LSB|MSB|xxx|xxx|       |xxx|xxx|MSB|LSB|
 610          * S24_3LE:     |LSB|DAT|MSB|xxx|       |xxx|MSB|DAT|LSB|
 611          * S24_LE:      |LSB|DAT|MSB|xxx|       |xxx|MSB|DAT|LSB|
 612          * S32_LE:      |LSB|DAT|DAT|MSB|       |MSB|DAT|DAT|LSB|
 613          */
 614         u32 rx_rotate = 0;
 615
 616         /*
 617          * if s BCLK-to-LRCLK ratio has been configured via the set_clkdiv()
 618          * callback, take it into account here. That allows us to for example
 619          * send 32 bits per channel to the codec, while only 16 of them carry
 620          * audio payload.
 621          * The clock ratio is given for a full period of data (for I2S format
 622          * both left and right channels), so it has to be divided by number of
 623          * tdm-slots (for I2S - divided by 2).
 624          */
 625         if (mcasp->bclk_lrclk_ratio) {
 626                 u32 slot_length = mcasp->bclk_lrclk_ratio / mcasp->tdm_slots;
 627
 628                 /*
 629                  * When we have more bclk then it is needed for the data, we
 630                  * need to use the rotation to move the received samples to have
 631                  * correct alignment.
 632                  */
 633                 rx_rotate = (slot_length - word_length) / 4;
 634                 word_length = slot_length;
 635         }
 636
 637         /* mapping of the XSSZ bit-field as described in the datasheet */
 638         fmt = (word_length >> 1) - 1;
 639
 640         if (mcasp->op_mode != DAVINCI_MCASP_DIT_MODE) {
 641                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXSSZ(fmt),
 642                                RXSSZ(0x0F));
 643                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXSSZ(fmt),
 644                                TXSSZ(0x0F));
 645                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(tx_rotate),
 646                                TXROT(7));
 647                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXROT(rx_rotate),
 648                                RXROT(7));
 649                 mcasp_set_reg(mcasp, DAVINCI_MCASP_RXMASK_REG, mask);
 650         }
 651
 652         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXMASK_REG, mask);
 653
 654         return 0;
 655 }
 656
 657 static int mcasp_common_hw_param(struct davinci_mcasp *mcasp, int stream,
 658                                  int period_words, int channels)
 659 {
 660         struct snd_dmaengine_dai_dma_data *dma_data = &mcasp->dma_data[stream];
 661         int i;
 662         u8 tx_ser = 0;
 663         u8 rx_ser = 0;
 664         u8 slots = mcasp->tdm_slots;
 665         u8 max_active_serializers = (channels + slots - 1) / slots;
 666         int active_serializers, numevt, n;
 667         u32 reg;
 668         /* Default configuration */
 669         if (mcasp->version < MCASP_VERSION_3)
 670                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PWREMUMGT_REG, MCASP_SOFT);
 671
 672         /* All PINS as McASP */
 673         mcasp_set_reg(mcasp, DAVINCI_MCASP_PFUNC_REG, 0x00000000);
 674
 675         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 676                 mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
 677                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
 678         } else {
 679                 mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
 680                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_REVTCTL_REG, RXDATADMADIS);
 681         }
 682
 683         for (i = 0; i < mcasp->num_serializer; i++) {
 684                 mcasp_set_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
 685                                mcasp->serial_dir[i]);
 686                 if (mcasp->serial_dir[i] == TX_MODE &&
 687                                         tx_ser < max_active_serializers) {
 688                         mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
 689                         tx_ser++;
 690                 } else if (mcasp->serial_dir[i] == RX_MODE &&
 691                                         rx_ser < max_active_serializers) {
 692                         mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
 693                         rx_ser++;
 694                 } else {
 695                         mcasp_mod_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
 696                                        SRMOD_INACTIVE, SRMOD_MASK);
 697                 }
 698         }
 699
 700         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 701                 active_serializers = tx_ser;
 702                 numevt = mcasp->txnumevt;
 703                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 704         } else {
 705                 active_serializers = rx_ser;
 706                 numevt = mcasp->rxnumevt;
 707                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 708         }
 709
 710         if (active_serializers < max_active_serializers) {
 711                 dev_warn(mcasp->dev, "stream has more channels (%d) than are "
 712                          "enabled in mcasp (%d)\n", channels,
 713                          active_serializers * slots);
 714                 return -EINVAL;
 715         }
 716
 717         /* AFIFO is not in use */
 718         if (!numevt) {
 719                 /* Configure the burst size for platform drivers */
 720                 if (active_serializers > 1) {
 721                         /*
 722                          * If more than one serializers are in use we have one
 723                          * DMA request to provide data for all serializers.
 724                          * For example if three serializers are enabled the DMA
 725                          * need to transfer three words per DMA request.
 726                          */
 727                         dma_data->maxburst = active_serializers;
 728                 } else {
 729                         dma_data->maxburst = 0;
 730                 }
 731                 return 0;
 732         }
 733
 734         if (period_words % active_serializers) {
 735                 dev_err(mcasp->dev, "Invalid combination of period words and "
 736                         "active serializers: %d, %d\n", period_words,
 737                         active_serializers);
 738                 return -EINVAL;
 739         }
 740
 741         /*
 742          * Calculate the optimal AFIFO depth for platform side:
 743          * The number of words for numevt need to be in steps of active
 744          * serializers.
 745          */
 746         n = numevt % active_serializers;
 747         if (n)
 748                 numevt += (active_serializers - n);
 749         while (period_words % numevt && numevt > 0)
 750                 numevt -= active_serializers;
 751         if (numevt <= 0)
 752                 numevt = active_serializers;
 753
 754         mcasp_mod_bits(mcasp, reg, active_serializers, NUMDMA_MASK);
 755         mcasp_mod_bits(mcasp, reg, NUMEVT(numevt), NUMEVT_MASK);
 756
 757         /* Configure the burst size for platform drivers */
 758         if (numevt == 1)
 759                 numevt = 0;
 760         dma_data->maxburst = numevt;
 761
 762         return 0;
 763 }
 764
 765 static int mcasp_i2s_hw_param(struct davinci_mcasp *mcasp, int stream,
 766                               int channels)
 767 {
 768         int i, active_slots;
 769         int total_slots;
 770         int active_serializers;
 771         u32 mask = 0;
 772         u32 busel = 0;
 773
 774         total_slots = mcasp->tdm_slots;
 775
 776         /*
 777          * If more than one serializer is needed, then use them with
 778          * their specified tdm_slots count. Otherwise, one serializer
 779          * can cope with the transaction using as many slots as channels
 780          * in the stream, requires channels symmetry
 781          */
 782         active_serializers = (channels + total_slots - 1) / total_slots;
 783         if (active_serializers == 1)
 784                 active_slots = channels;
 785         else
 786                 active_slots = total_slots;
 787
 788         for (i = 0; i < active_slots; i++)
 789                 mask |= (1 << i);
 790
 791         mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, TX_ASYNC);
 792
 793         if (!mcasp->dat_port)
 794                 busel = TXSEL;
 795
 796         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, mask);
 797         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, busel | TXORD);
 798         mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG,
 799                        FSXMOD(total_slots), FSXMOD(0x1FF));
 800
 801         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXTDM_REG, mask);
 802         mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, busel | RXORD);
 803         mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG,
 804                        FSRMOD(total_slots), FSRMOD(0x1FF));
 805
 806         return 0;
 807 }
 808
 809 /* S/PDIF */
 810 static int mcasp_dit_hw_param(struct davinci_mcasp *mcasp,
 811                               unsigned int rate)
 812 {
 813         u32 cs_value = 0;
 814         u8 *cs_bytes = (u8*) &cs_value;
 815
 816         /* Set the TX format : 24 bit right rotation, 32 bit slot, Pad 0
 817            and LSB first */
 818         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(6) | TXSSZ(15));
 819
 820         /* Set TX frame synch : DIT Mode, 1 bit width, internal, rising edge */
 821         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE | FSXMOD(0x180));
 822
 823         /* Set the TX tdm : for all the slots */
 824         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, 0xFFFFFFFF);
 825
 826         /* Set the TX clock controls : div = 1 and internal */
 827         mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE | TX_ASYNC);
 828
 829         mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
 830
 831         /* Only 44100 and 48000 are valid, both have the same setting */
 832         mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXDIV(3));
 833
 834         /* Enable the DIT */
 835         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXDITCTL_REG, DITEN);
 836
 837         /* Set S/PDIF channel status bits */
 838         cs_bytes[0] = IEC958_AES0_CON_NOT_COPYRIGHT;
 839         cs_bytes[1] = IEC958_AES1_CON_PCM_CODER;
 840
 841         switch (rate) {
 842         case 22050:
 843                 cs_bytes[3] |= IEC958_AES3_CON_FS_22050;
 844                 break;
 845         case 24000:
 846                 cs_bytes[3] |= IEC958_AES3_CON_FS_24000;
 847                 break;
 848         case 32000:
 849                 cs_bytes[3] |= IEC958_AES3_CON_FS_32000;
 850                 break;
 851         case 44100:
 852                 cs_bytes[3] |= IEC958_AES3_CON_FS_44100;
 853                 break;
 854         case 48000:
 855                 cs_bytes[3] |= IEC958_AES3_CON_FS_48000;
 856                 break;
 857         case 88200:
 858                 cs_bytes[3] |= IEC958_AES3_CON_FS_88200;
 859                 break;
 860         case 96000:
 861                 cs_bytes[3] |= IEC958_AES3_CON_FS_96000;
 862                 break;
 863         case 176400:
 864                 cs_bytes[3] |= IEC958_AES3_CON_FS_176400;
 865                 break;
 866         case 192000:
 867                 cs_bytes[3] |= IEC958_AES3_CON_FS_192000;
 868                 break;
 869         default:
 870                 printk(KERN_WARNING "unsupported sampling rate: %d\n", rate);
 871                 return -EINVAL;
 872         }
 873
 874         mcasp_set_reg(mcasp, DAVINCI_MCASP_DITCSRA_REG, cs_value);
 875         mcasp_set_reg(mcasp, DAVINCI_MCASP_DITCSRB_REG, cs_value);
 876
 877         return 0;
 878 }
 879
 880 static int davinci_mcasp_calc_clk_div(struct davinci_mcasp *mcasp,
 881                                       unsigned int bclk_freq,
 882                                       int *error_ppm)
 883 {
 884         int div = mcasp->sysclk_freq / bclk_freq;
 885         int rem = mcasp->sysclk_freq % bclk_freq;
 886
 887         if (rem != 0) {
 888                 if (div == 0 ||
 889                     ((mcasp->sysclk_freq / div) - bclk_freq) >
 890                     (bclk_freq - (mcasp->sysclk_freq / (div+1)))) {
 891                         div++;
 892                         rem = rem - bclk_freq;
 893                 }
 894         }
 895         if (error_ppm)
 896                 *error_ppm =
 897                         (div*1000000 + (int)div64_long(1000000LL*rem,
 898                                                        (int)bclk_freq))
 899                         /div - 1000000;
 900
 901         return div;
 902 }
 903
 904 static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
 905                                         struct snd_pcm_hw_params *params,
 906                                         struct snd_soc_dai *cpu_dai)
 907 {
 908         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 909         int word_length;
 910         int channels = params_channels(params);
 911         int period_size = params_period_size(params);
 912         int ret;
 913
 914         /*
 915          * If mcasp is BCLK master, and a BCLK divider was not provided by
 916          * the machine driver, we need to calculate the ratio.
 917          */
 918         if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
 919                 int slots = mcasp->tdm_slots;
 920                 int rate = params_rate(params);
 921                 int sbits = params_width(params);
 922                 int ppm, div;
 923
 924                 div = davinci_mcasp_calc_clk_div(mcasp, rate*sbits*slots,
 925                                                  &ppm);
 926                 if (ppm)
 927                         dev_info(mcasp->dev, "Sample-rate is off by %d PPM\n",
 928                                  ppm);
 929
 930                 __davinci_mcasp_set_clkdiv(cpu_dai, 1, div, 0);
 931         }
 932
 933         ret = mcasp_common_hw_param(mcasp, substream->stream,
 934                                     period_size * channels, channels);
 935         if (ret)
 936                 return ret;
 937
 938         if (mcasp->op_mode == DAVINCI_MCASP_DIT_MODE)
 939                 ret = mcasp_dit_hw_param(mcasp, params_rate(params));
 940         else
 941                 ret = mcasp_i2s_hw_param(mcasp, substream->stream,
 942                                          channels);
 943
 944         if (ret)
 945                 return ret;
 946
 947         switch (params_format(params)) {
 948         case SNDRV_PCM_FORMAT_U8:
 949         case SNDRV_PCM_FORMAT_S8:
 950                 word_length = 8;
 951                 break;
 952
 953         case SNDRV_PCM_FORMAT_U16_LE:
 954         case SNDRV_PCM_FORMAT_S16_LE:
 955                 word_length = 16;
 956                 break;
 957
 958         case SNDRV_PCM_FORMAT_U24_3LE:
 959         case SNDRV_PCM_FORMAT_S24_3LE:
 960                 word_length = 24;
 961                 break;
 962
 963         case SNDRV_PCM_FORMAT_U24_LE:
 964         case SNDRV_PCM_FORMAT_S24_LE:
 965                 word_length = 24;
 966                 break;
 967
 968         case SNDRV_PCM_FORMAT_U32_LE:
 969         case SNDRV_PCM_FORMAT_S32_LE:
 970                 word_length = 32;
 971                 break;
 972
 973         default:
 974                 printk(KERN_WARNING "davinci-mcasp: unsupported PCM format");
 975                 return -EINVAL;
 976         }
 977
 978         davinci_config_channel_size(mcasp, word_length);
 979
 980         if (mcasp->op_mode == DAVINCI_MCASP_IIS_MODE)
 981                 mcasp->channels = channels;
 982
 983         return 0;
 984 }
 985
 986 static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
 987                                      int cmd, struct snd_soc_dai *cpu_dai)
 988 {
 989         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 990         int ret = 0;
 991
 992         switch (cmd) {
 993         case SNDRV_PCM_TRIGGER_RESUME:
 994         case SNDRV_PCM_TRIGGER_START:
 995         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 996                 davinci_mcasp_start(mcasp, substream->stream);
 997                 break;
 998         case SNDRV_PCM_TRIGGER_SUSPEND:
 999         case SNDRV_PCM_TRIGGER_STOP:
1000         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
1001                 davinci_mcasp_stop(mcasp, substream->stream);
1002                 break;
1003
1004         default:
1005                 ret = -EINVAL;
1006         }
1007
1008         return ret;
1009 }
1010
1011 static const unsigned int davinci_mcasp_dai_rates[] = {
1012         8000, 11025, 16000, 22050, 32000, 44100, 48000, 64000,
1013         88200, 96000, 176400, 192000,
1014 };
1015
1016 #define DAVINCI_MAX_RATE_ERROR_PPM 1000
1017
1018 static int davinci_mcasp_hw_rule_rate(struct snd_pcm_hw_params *params,
1019                                       struct snd_pcm_hw_rule *rule)
1020 {
1021         struct davinci_mcasp_ruledata *rd = rule->private;
1022         struct snd_interval *ri =
1023                 hw_param_interval(params, SNDRV_PCM_HW_PARAM_RATE);
1024         int sbits = params_width(params);
1025         int slots = rd->mcasp->tdm_slots;
1026         struct snd_interval range;
1027         int i;
1028
1029         snd_interval_any(&range);
1030         range.empty = 1;
1031
1032         for (i = 0; i < ARRAY_SIZE(davinci_mcasp_dai_rates); i++) {
1033                 if (snd_interval_test(ri, davinci_mcasp_dai_rates[i])) {
1034                         uint bclk_freq = sbits*slots*
1035                                 davinci_mcasp_dai_rates[i];
1036                         int ppm;
1037
1038                         davinci_mcasp_calc_clk_div(rd->mcasp, bclk_freq, &ppm);
1039                         if (abs(ppm) < DAVINCI_MAX_RATE_ERROR_PPM) {
1040                                 if (range.empty) {
1041                                         range.min = davinci_mcasp_dai_rates[i];
1042                                         range.empty = 0;
1043                                 }
1044                                 range.max = davinci_mcasp_dai_rates[i];
1045                         }
1046                 }
1047         }
1048
1049         dev_dbg(rd->mcasp->dev,
1050                 "Frequencies %d-%d -> %d-%d for %d sbits and %d tdm slots\n",
1051                 ri->min, ri->max, range.min, range.max, sbits, slots);
1052
1053         return snd_interval_refine(hw_param_interval(params, rule->var),
1054                                    &range);
1055 }
1056
1057 static int davinci_mcasp_hw_rule_format(struct snd_pcm_hw_params *params,
1058                                         struct snd_pcm_hw_rule *rule)
1059 {
1060         struct davinci_mcasp_ruledata *rd = rule->private;
1061         struct snd_mask *fmt = hw_param_mask(params, SNDRV_PCM_HW_PARAM_FORMAT);
1062         struct snd_mask nfmt;
1063         int rate = params_rate(params);
1064         int slots = rd->mcasp->tdm_slots;
1065         int i, count = 0;
1066
1067         snd_mask_none(&nfmt);
1068
1069         for (i = 0; i < SNDRV_PCM_FORMAT_LAST; i++) {
1070                 if (snd_mask_test(fmt, i)) {
1071                         uint bclk_freq = snd_pcm_format_width(i)*slots*rate;
1072                         int ppm;
1073
1074                         davinci_mcasp_calc_clk_div(rd->mcasp, bclk_freq, &ppm);
1075                         if (abs(ppm) < DAVINCI_MAX_RATE_ERROR_PPM) {
1076                                 snd_mask_set(&nfmt, i);
1077                                 count++;
1078                         }
1079                 }
1080         }
1081         dev_dbg(rd->mcasp->dev,
1082                 "%d possible sample format for %d Hz and %d tdm slots\n",
1083                 count, rate, slots);
1084
1085         return snd_mask_refine(fmt, &nfmt);
1086 }
1087
1088 static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
1089                                  struct snd_soc_dai *cpu_dai)
1090 {
1091         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
1092         struct davinci_mcasp_ruledata *ruledata =
1093                                         &mcasp->ruledata[substream->stream];
1094         u32 max_channels = 0;
1095         int i, dir;
1096
1097         mcasp->substreams[substream->stream] = substream;
1098
1099         if (mcasp->op_mode == DAVINCI_MCASP_DIT_MODE)
1100                 return 0;
1101
1102         /*
1103          * Limit the maximum allowed channels for the first stream:
1104          * number of serializers for the direction * tdm slots per serializer
1105          */
1106         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1107                 dir = TX_MODE;
1108         else
1109                 dir = RX_MODE;
1110
1111         for (i = 0; i < mcasp->num_serializer; i++) {
1112                 if (mcasp->serial_dir[i] == dir)
1113                         max_channels++;
1114         }
1115         ruledata->serializers = max_channels;
1116         max_channels *= mcasp->tdm_slots;
1117         /*
1118          * If the already active stream has less channels than the calculated
1119          * limnit based on the seirializers * tdm_slots, we need to use that as
1120          * a constraint for the second stream.
1121          * Otherwise (first stream or less allowed channels) we use the
1122          * calculated constraint.
1123          */
1124         if (mcasp->channels && mcasp->channels < max_channels)
1125                 max_channels = mcasp->channels;
1126
1127         snd_pcm_hw_constraint_minmax(substream->runtime,
1128                                      SNDRV_PCM_HW_PARAM_CHANNELS,
1129                                      2, max_channels);
1130
1131         if (mcasp->chconstr[substream->stream].count)
1132                 snd_pcm_hw_constraint_list(substream->runtime,
1133                                            0, SNDRV_PCM_HW_PARAM_CHANNELS,
1134                                            &mcasp->chconstr[substream->stream]);
1135
1136         /*
1137          * If we rely on implicit BCLK divider setting we should
1138          * set constraints based on what we can provide.
1139          */
1140         if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
1141                 int ret;
1142
1143                 ruledata->mcasp = mcasp;
1144
1145                 ret = snd_pcm_hw_rule_add(substream->runtime, 0,
1146                                           SNDRV_PCM_HW_PARAM_RATE,
1147                                           davinci_mcasp_hw_rule_rate,
1148                                           ruledata,
1149                                           SNDRV_PCM_HW_PARAM_FORMAT, -1);
1150                 if (ret)
1151                         return ret;
1152                 ret = snd_pcm_hw_rule_add(substream->runtime, 0,
1153                                           SNDRV_PCM_HW_PARAM_FORMAT,
1154                                           davinci_mcasp_hw_rule_format,
1155                                           ruledata,
1156                                           SNDRV_PCM_HW_PARAM_RATE, -1);
1157                 if (ret)
1158                         return ret;
1159         }
1160
1161         return 0;
1162 }
1163
1164 static void davinci_mcasp_shutdown(struct snd_pcm_substream *substream,
1165                                    struct snd_soc_dai *cpu_dai)
1166 {
1167         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
1168
1169         mcasp->substreams[substream->stream] = NULL;
1170
1171         if (mcasp->op_mode == DAVINCI_MCASP_DIT_MODE)
1172                 return;
1173
1174         if (!cpu_dai->active)
1175                 mcasp->channels = 0;
1176 }
1177
1178 static const struct snd_soc_dai_ops davinci_mcasp_dai_ops = {
1179         .startup        = davinci_mcasp_startup,
1180         .shutdown       = davinci_mcasp_shutdown,
1181         .trigger        = davinci_mcasp_trigger,
1182         .hw_params      = davinci_mcasp_hw_params,
1183         .set_fmt        = davinci_mcasp_set_dai_fmt,
1184         .set_clkdiv     = davinci_mcasp_set_clkdiv,
1185         .set_sysclk     = davinci_mcasp_set_sysclk,
1186 };
1187
1188 static int davinci_mcasp_dai_probe(struct snd_soc_dai *dai)
1189 {
1190         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
1191
1192         dai->playback_dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK];
1193         dai->capture_dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
1194
1195         return 0;
1196 }
1197
1198 #ifdef CONFIG_PM_SLEEP
1199 static int davinci_mcasp_suspend(struct snd_soc_dai *dai)
1200 {
1201         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
1202         struct davinci_mcasp_context *context = &mcasp->context;
1203         u32 reg;
1204         int i;
1205
1206         context->pm_state = pm_runtime_active(mcasp->dev);
1207         if (!context->pm_state)
1208                 pm_runtime_get_sync(mcasp->dev);
1209
1210         for (i = 0; i < ARRAY_SIZE(context_regs); i++)
1211                 context->config_regs[i] = mcasp_get_reg(mcasp, context_regs[i]);
1212
1213         if (mcasp->txnumevt) {
1214                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
1215                 context->afifo_regs[0] = mcasp_get_reg(mcasp, reg);
1216         }
1217         if (mcasp->rxnumevt) {
1218                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
1219                 context->afifo_regs[1] = mcasp_get_reg(mcasp, reg);
1220         }
1221
1222         for (i = 0; i < mcasp->num_serializer; i++)
1223                 context->xrsr_regs[i] = mcasp_get_reg(mcasp,
1224                                                 DAVINCI_MCASP_XRSRCTL_REG(i));
1225
1226         pm_runtime_put_sync(mcasp->dev);
1227
1228         return 0;
1229 }
1230
1231 static int davinci_mcasp_resume(struct snd_soc_dai *dai)
1232 {
1233         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
1234         struct davinci_mcasp_context *context = &mcasp->context;
1235         u32 reg;
1236         int i;
1237
1238         pm_runtime_get_sync(mcasp->dev);
1239
1240         for (i = 0; i < ARRAY_SIZE(context_regs); i++)
1241                 mcasp_set_reg(mcasp, context_regs[i], context->config_regs[i]);
1242
1243         if (mcasp->txnumevt) {
1244                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
1245                 mcasp_set_reg(mcasp, reg, context->afifo_regs[0]);
1246         }
1247         if (mcasp->rxnumevt) {
1248                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
1249                 mcasp_set_reg(mcasp, reg, context->afifo_regs[1]);
1250         }
1251
1252         for (i = 0; i < mcasp->num_serializer; i++)
1253                 mcasp_set_reg(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
1254                               context->xrsr_regs[i]);
1255
1256         if (!context->pm_state)
1257                 pm_runtime_put_sync(mcasp->dev);
1258
1259         return 0;
1260 }
1261 #else
1262 #define davinci_mcasp_suspend NULL
1263 #define davinci_mcasp_resume NULL
1264 #endif
1265
1266 #define DAVINCI_MCASP_RATES     SNDRV_PCM_RATE_8000_192000
1267
1268 #define DAVINCI_MCASP_PCM_FMTS (SNDRV_PCM_FMTBIT_S8 | \
1269                                 SNDRV_PCM_FMTBIT_U8 | \
1270                                 SNDRV_PCM_FMTBIT_S16_LE | \
1271                                 SNDRV_PCM_FMTBIT_U16_LE | \
1272                                 SNDRV_PCM_FMTBIT_S24_LE | \
1273                                 SNDRV_PCM_FMTBIT_U24_LE | \
1274                                 SNDRV_PCM_FMTBIT_S24_3LE | \
1275                                 SNDRV_PCM_FMTBIT_U24_3LE | \
1276                                 SNDRV_PCM_FMTBIT_S32_LE | \
1277                                 SNDRV_PCM_FMTBIT_U32_LE)
1278
1279 static struct snd_soc_dai_driver davinci_mcasp_dai[] = {
1280         {
1281                 .name           = "davinci-mcasp.0",
1282                 .probe          = davinci_mcasp_dai_probe,
1283                 .suspend        = davinci_mcasp_suspend,
1284                 .resume         = davinci_mcasp_resume,
1285                 .playback       = {
1286                         .channels_min   = 2,
1287                         .channels_max   = 32 * 16,
1288                         .rates          = DAVINCI_MCASP_RATES,
1289                         .formats        = DAVINCI_MCASP_PCM_FMTS,
1290                 },
1291                 .capture        = {
1292                         .channels_min   = 2,
1293                         .channels_max   = 32 * 16,
1294                         .rates          = DAVINCI_MCASP_RATES,
1295                         .formats        = DAVINCI_MCASP_PCM_FMTS,
1296                 },
1297                 .ops            = &davinci_mcasp_dai_ops,
1298
1299                 .symmetric_samplebits   = 1,
1300         },
1301         {
1302                 .name           = "davinci-mcasp.1",
1303                 .probe          = davinci_mcasp_dai_probe,
1304                 .playback       = {
1305                         .channels_min   = 1,
1306                         .channels_max   = 384,
1307                         .rates          = DAVINCI_MCASP_RATES,
1308                         .formats        = DAVINCI_MCASP_PCM_FMTS,
1309                 },
1310                 .ops            = &davinci_mcasp_dai_ops,
1311         },
1312
1313 };
1314
1315 static const struct snd_soc_component_driver davinci_mcasp_component = {
1316         .name           = "davinci-mcasp",
1317 };
1318
1319 /* Some HW specific values and defaults. The rest is filled in from DT. */
1320 static struct davinci_mcasp_pdata dm646x_mcasp_pdata = {
1321         .tx_dma_offset = 0x400,
1322         .rx_dma_offset = 0x400,
1323         .version = MCASP_VERSION_1,
1324 };
1325
1326 static struct davinci_mcasp_pdata da830_mcasp_pdata = {
1327         .tx_dma_offset = 0x2000,
1328         .rx_dma_offset = 0x2000,
1329         .version = MCASP_VERSION_2,
1330 };
1331
1332 static struct davinci_mcasp_pdata am33xx_mcasp_pdata = {
1333         .tx_dma_offset = 0,
1334         .rx_dma_offset = 0,
1335         .version = MCASP_VERSION_3,
1336 };
1337
1338 static struct davinci_mcasp_pdata dra7_mcasp_pdata = {
1339         .tx_dma_offset = 0x200,
1340         .rx_dma_offset = 0x284,
1341         .version = MCASP_VERSION_4,
1342 };
1343
1344 static const struct of_device_id mcasp_dt_ids[] = {
1345         {
1346                 .compatible = "ti,dm646x-mcasp-audio",
1347                 .data = &dm646x_mcasp_pdata,
1348         },
1349         {
1350                 .compatible = "ti,da830-mcasp-audio",
1351                 .data = &da830_mcasp_pdata,
1352         },
1353         {
1354                 .compatible = "ti,am33xx-mcasp-audio",
1355                 .data = &am33xx_mcasp_pdata,
1356         },
1357         {
1358                 .compatible = "ti,dra7-mcasp-audio",
1359                 .data = &dra7_mcasp_pdata,
1360         },
1361         { /* sentinel */ }
1362 };
1363 MODULE_DEVICE_TABLE(of, mcasp_dt_ids);
1364
1365 static int mcasp_reparent_fck(struct platform_device *pdev)
1366 {
1367         struct device_node *node = pdev->dev.of_node;
1368         struct clk *gfclk, *parent_clk;
1369         const char *parent_name;
1370         int ret;
1371
1372         if (!node)
1373                 return 0;
1374
1375         parent_name = of_get_property(node, "fck_parent", NULL);
1376         if (!parent_name)
1377                 return 0;
1378
1379         gfclk = clk_get(&pdev->dev, "fck");
1380         if (IS_ERR(gfclk)) {
1381                 dev_err(&pdev->dev, "failed to get fck\n");
1382                 return PTR_ERR(gfclk);
1383         }
1384
1385         parent_clk = clk_get(NULL, parent_name);
1386         if (IS_ERR(parent_clk)) {
1387                 dev_err(&pdev->dev, "failed to get parent clock\n");
1388                 ret = PTR_ERR(parent_clk);
1389                 goto err1;
1390         }
1391
1392         ret = clk_set_parent(gfclk, parent_clk);
1393         if (ret) {
1394                 dev_err(&pdev->dev, "failed to reparent fck\n");
1395                 goto err2;
1396         }
1397
1398 err2:
1399         clk_put(parent_clk);
1400 err1:
1401         clk_put(gfclk);
1402         return ret;
1403 }
1404
1405 static struct davinci_mcasp_pdata *davinci_mcasp_set_pdata_from_of(
1406                                                 struct platform_device *pdev)
1407 {
1408         struct device_node *np = pdev->dev.of_node;
1409         struct davinci_mcasp_pdata *pdata = NULL;
1410         const struct of_device_id *match =
1411                         of_match_device(mcasp_dt_ids, &pdev->dev);
1412         struct of_phandle_args dma_spec;
1413
1414         const u32 *of_serial_dir32;
1415         u32 val;
1416         int i, ret = 0;
1417
1418         if (pdev->dev.platform_data) {
1419                 pdata = pdev->dev.platform_data;
1420                 return pdata;
1421         } else if (match) {
1422                 pdata = (struct davinci_mcasp_pdata*) match->data;
1423         } else {
1424                 /* control shouldn't reach here. something is wrong */
1425                 ret = -EINVAL;
1426                 goto nodata;
1427         }
1428
1429         ret = of_property_read_u32(np, "op-mode", &val);
1430         if (ret >= 0)
1431                 pdata->op_mode = val;
1432
1433         ret = of_property_read_u32(np, "tdm-slots", &val);
1434         if (ret >= 0) {
1435                 if (val < 2 || val > 32) {
1436                         dev_err(&pdev->dev,
1437                                 "tdm-slots must be in rage [2-32]\n");
1438                         ret = -EINVAL;
1439                         goto nodata;
1440                 }
1441
1442                 pdata->tdm_slots = val;
1443         }
1444
1445         of_serial_dir32 = of_get_property(np, "serial-dir", &val);
1446         val /= sizeof(u32);
1447         if (of_serial_dir32) {
1448                 u8 *of_serial_dir = devm_kzalloc(&pdev->dev,
1449                                                  (sizeof(*of_serial_dir) * val),
1450                                                  GFP_KERNEL);
1451                 if (!of_serial_dir) {
1452                         ret = -ENOMEM;
1453                         goto nodata;
1454                 }
1455
1456                 for (i = 0; i < val; i++)
1457                         of_serial_dir[i] = be32_to_cpup(&of_serial_dir32[i]);
1458
1459                 pdata->num_serializer = val;
1460                 pdata->serial_dir = of_serial_dir;
1461         }
1462
1463         ret = of_property_match_string(np, "dma-names", "tx");
1464         if (ret < 0)
1465                 goto nodata;
1466
1467         ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
1468                                          &dma_spec);
1469         if (ret < 0)
1470                 goto nodata;
1471
1472         pdata->tx_dma_channel = dma_spec.args[0];
1473
1474         /* RX is not valid in DIT mode */
1475         if (pdata->op_mode != DAVINCI_MCASP_DIT_MODE) {
1476                 ret = of_property_match_string(np, "dma-names", "rx");
1477                 if (ret < 0)
1478                         goto nodata;
1479
1480                 ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
1481                                                  &dma_spec);
1482                 if (ret < 0)
1483                         goto nodata;
1484
1485                 pdata->rx_dma_channel = dma_spec.args[0];
1486         }
1487
1488         ret = of_property_read_u32(np, "tx-num-evt", &val);
1489         if (ret >= 0)
1490                 pdata->txnumevt = val;
1491
1492         ret = of_property_read_u32(np, "rx-num-evt", &val);
1493         if (ret >= 0)
1494                 pdata->rxnumevt = val;
1495
1496         ret = of_property_read_u32(np, "sram-size-playback", &val);
1497         if (ret >= 0)
1498                 pdata->sram_size_playback = val;
1499
1500         ret = of_property_read_u32(np, "sram-size-capture", &val);
1501         if (ret >= 0)
1502                 pdata->sram_size_capture = val;
1503
1504         return  pdata;
1505
1506 nodata:
1507         if (ret < 0) {
1508                 dev_err(&pdev->dev, "Error populating platform data, err %d\n",
1509                         ret);
1510                 pdata = NULL;
1511         }
1512         return  pdata;
1513 }
1514
1515 /* All serializers must have equal number of channels */
1516 static int davinci_mcasp_ch_constraint(struct davinci_mcasp *mcasp,
1517                                        struct snd_pcm_hw_constraint_list *cl,
1518                                        int serializers)
1519 {
1520         unsigned int *list;
1521         int i, count = 0;
1522
1523         if (serializers <= 1)
1524                 return 0;
1525
1526         list = devm_kzalloc(mcasp->dev, sizeof(unsigned int) *
1527                             (mcasp->tdm_slots + serializers - 2),
1528                             GFP_KERNEL);
1529         if (!list)
1530                 return -ENOMEM;
1531
1532         for (i = 2; i <= mcasp->tdm_slots; i++)
1533                 list[count++] = i;
1534
1535         for (i = 2; i <= serializers; i++)
1536                 list[count++] = i*mcasp->tdm_slots;
1537
1538         cl->count = count;
1539         cl->list = list;
1540
1541         return 0;
1542 }
1543
1544
1545 static int davinci_mcasp_init_ch_constraints(struct davinci_mcasp *mcasp)
1546 {
1547         int rx_serializers = 0, tx_serializers = 0, ret, i;
1548
1549         for (i = 0; i < mcasp->num_serializer; i++)
1550                 if (mcasp->serial_dir[i] == TX_MODE)
1551                         tx_serializers++;
1552                 else if (mcasp->serial_dir[i] == RX_MODE)
1553                         rx_serializers++;
1554
1555         ret = davinci_mcasp_ch_constraint(mcasp, &mcasp->chconstr[
1556                                                   SNDRV_PCM_STREAM_PLAYBACK],
1557                                           tx_serializers);
1558         if (ret)
1559                 return ret;
1560
1561         ret = davinci_mcasp_ch_constraint(mcasp, &mcasp->chconstr[
1562                                                   SNDRV_PCM_STREAM_CAPTURE],
1563                                           rx_serializers);
1564
1565         return ret;
1566 }
1567
1568 static int davinci_mcasp_probe(struct platform_device *pdev)
1569 {
1570         struct snd_dmaengine_dai_dma_data *dma_data;
1571         struct resource *mem, *ioarea, *res, *dat;
1572         struct davinci_mcasp_pdata *pdata;
1573         struct davinci_mcasp *mcasp;
1574         char *irq_name;
1575         int *dma;
1576         int irq;
1577         int ret;
1578
1579         if (!pdev->dev.platform_data && !pdev->dev.of_node) {
1580                 dev_err(&pdev->dev, "No platform data supplied\n");
1581                 return -EINVAL;
1582         }
1583
1584         mcasp = devm_kzalloc(&pdev->dev, sizeof(struct davinci_mcasp),
1585                            GFP_KERNEL);
1586         if (!mcasp)
1587                 return  -ENOMEM;
1588
1589         pdata = davinci_mcasp_set_pdata_from_of(pdev);
1590         if (!pdata) {
1591                 dev_err(&pdev->dev, "no platform data\n");
1592                 return -EINVAL;
1593         }
1594
1595         mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mpu");
1596         if (!mem) {
1597                 dev_warn(mcasp->dev,
1598                          "\"mpu\" mem resource not found, using index 0\n");
1599                 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1600                 if (!mem) {
1601                         dev_err(&pdev->dev, "no mem resource?\n");
1602                         return -ENODEV;
1603                 }
1604         }
1605
1606         ioarea = devm_request_mem_region(&pdev->dev, mem->start,
1607                         resource_size(mem), pdev->name);
1608         if (!ioarea) {
1609                 dev_err(&pdev->dev, "Audio region already claimed\n");
1610                 return -EBUSY;
1611         }
1612
1613         pm_runtime_enable(&pdev->dev);
1614
1615         mcasp->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
1616         if (!mcasp->base) {
1617                 dev_err(&pdev->dev, "ioremap failed\n");
1618                 ret = -ENOMEM;
1619                 goto err;
1620         }
1621
1622         mcasp->op_mode = pdata->op_mode;
1623         /* sanity check for tdm slots parameter */
1624         if (mcasp->op_mode == DAVINCI_MCASP_IIS_MODE) {
1625                 if (pdata->tdm_slots < 2) {
1626                         dev_err(&pdev->dev, "invalid tdm slots: %d\n",
1627                                 pdata->tdm_slots);
1628                         mcasp->tdm_slots = 2;
1629                 } else if (pdata->tdm_slots > 32) {
1630                         dev_err(&pdev->dev, "invalid tdm slots: %d\n",
1631                                 pdata->tdm_slots);
1632                         mcasp->tdm_slots = 32;
1633                 } else {
1634                         mcasp->tdm_slots = pdata->tdm_slots;
1635                 }
1636         }
1637
1638         mcasp->num_serializer = pdata->num_serializer;
1639 #ifdef CONFIG_PM_SLEEP
1640         mcasp->context.xrsr_regs = devm_kzalloc(&pdev->dev,
1641                                         sizeof(u32) * mcasp->num_serializer,
1642                                         GFP_KERNEL);
1643 #endif
1644         mcasp->serial_dir = pdata->serial_dir;
1645         mcasp->version = pdata->version;
1646         mcasp->txnumevt = pdata->txnumevt;
1647         mcasp->rxnumevt = pdata->rxnumevt;
1648
1649         mcasp->dev = &pdev->dev;
1650
1651         irq = platform_get_irq_byname(pdev, "common");
1652         if (irq >= 0) {
1653                 irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s_common\n",
1654                                           dev_name(&pdev->dev));
1655                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1656                                                 davinci_mcasp_common_irq_handler,
1657                                                 IRQF_ONESHOT | IRQF_SHARED,
1658                                                 irq_name, mcasp);
1659                 if (ret) {
1660                         dev_err(&pdev->dev, "common IRQ request failed\n");
1661                         goto err;
1662                 }
1663
1664                 mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK] = XUNDRN;
1665                 mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE] = ROVRN;
1666         }
1667
1668         irq = platform_get_irq_byname(pdev, "rx");
1669         if (irq >= 0) {
1670                 irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s_rx\n",
1671                                           dev_name(&pdev->dev));
1672                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1673                                                 davinci_mcasp_rx_irq_handler,
1674                                                 IRQF_ONESHOT, irq_name, mcasp);
1675                 if (ret) {
1676                         dev_err(&pdev->dev, "RX IRQ request failed\n");
1677                         goto err;
1678                 }
1679
1680                 mcasp->irq_request[SNDRV_PCM_STREAM_CAPTURE] = ROVRN;
1681         }
1682
1683         irq = platform_get_irq_byname(pdev, "tx");
1684         if (irq >= 0) {
1685                 irq_name = devm_kasprintf(&pdev->dev, GFP_KERNEL, "%s_tx\n",
1686                                           dev_name(&pdev->dev));
1687                 ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
1688                                                 davinci_mcasp_tx_irq_handler,
1689                                                 IRQF_ONESHOT, irq_name, mcasp);
1690                 if (ret) {
1691                         dev_err(&pdev->dev, "TX IRQ request failed\n");
1692                         goto err;
1693                 }
1694
1695                 mcasp->irq_request[SNDRV_PCM_STREAM_PLAYBACK] = XUNDRN;
1696         }
1697
1698         dat = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
1699         if (dat)
1700                 mcasp->dat_port = true;
1701
1702         dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK];
1703         if (dat)
1704                 dma_data->addr = dat->start;
1705         else
1706                 dma_data->addr = mem->start + pdata->tx_dma_offset;
1707
1708         dma = &mcasp->dma_request[SNDRV_PCM_STREAM_PLAYBACK];
1709         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1710         if (res)
1711                 *dma = res->start;
1712         else
1713                 *dma = pdata->tx_dma_channel;
1714
1715         /* dmaengine filter data for DT and non-DT boot */
1716         if (pdev->dev.of_node)
1717                 dma_data->filter_data = "tx";
1718         else
1719                 dma_data->filter_data = dma;
1720
1721         /* RX is not valid in DIT mode */
1722         if (mcasp->op_mode != DAVINCI_MCASP_DIT_MODE) {
1723                 dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
1724                 if (dat)
1725                         dma_data->addr = dat->start;
1726                 else
1727                         dma_data->addr = mem->start + pdata->rx_dma_offset;
1728
1729                 dma = &mcasp->dma_request[SNDRV_PCM_STREAM_CAPTURE];
1730                 res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1731                 if (res)
1732                         *dma = res->start;
1733                 else
1734                         *dma = pdata->rx_dma_channel;
1735
1736                 /* dmaengine filter data for DT and non-DT boot */
1737                 if (pdev->dev.of_node)
1738                         dma_data->filter_data = "rx";
1739                 else
1740                         dma_data->filter_data = dma;
1741         }
1742
1743         if (mcasp->version < MCASP_VERSION_3) {
1744                 mcasp->fifo_base = DAVINCI_MCASP_V2_AFIFO_BASE;
1745                 /* dma_params->dma_addr is pointing to the data port address */
1746                 mcasp->dat_port = true;
1747         } else {
1748                 mcasp->fifo_base = DAVINCI_MCASP_V3_AFIFO_BASE;
1749         }
1750
1751         ret = davinci_mcasp_init_ch_constraints(mcasp);
1752         if (ret)
1753                 goto err;
1754
1755         dev_set_drvdata(&pdev->dev, mcasp);
1756
1757         mcasp_reparent_fck(pdev);
1758
1759         ret = devm_snd_soc_register_component(&pdev->dev,
1760                                         &davinci_mcasp_component,
1761                                         &davinci_mcasp_dai[pdata->op_mode], 1);
1762
1763         if (ret != 0)
1764                 goto err;
1765
1766         switch (mcasp->version) {
1767 #if IS_BUILTIN(CONFIG_SND_EDMA_SOC) || \
1768         (IS_MODULE(CONFIG_SND_DAVINCI_SOC_MCASP) && \
1769          IS_MODULE(CONFIG_SND_EDMA_SOC))
1770         case MCASP_VERSION_1:
1771         case MCASP_VERSION_2:
1772         case MCASP_VERSION_3:
1773                 ret = edma_pcm_platform_register(&pdev->dev);
1774                 break;
1775 #endif
1776 #if IS_BUILTIN(CONFIG_SND_OMAP_SOC) || \
1777         (IS_MODULE(CONFIG_SND_DAVINCI_SOC_MCASP) && \
1778          IS_MODULE(CONFIG_SND_OMAP_SOC))
1779         case MCASP_VERSION_4:
1780                 ret = omap_pcm_platform_register(&pdev->dev);
1781                 break;
1782 #endif
1783         default:
1784                 dev_err(&pdev->dev, "Invalid McASP version: %d\n",
1785                         mcasp->version);
1786                 ret = -EINVAL;
1787                 break;
1788         }
1789
1790         if (ret) {
1791                 dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
1792                 goto err;
1793         }
1794
1795         return 0;
1796
1797 err:
1798         pm_runtime_disable(&pdev->dev);
1799         return ret;
1800 }
1801
1802 static int davinci_mcasp_remove(struct platform_device *pdev)
1803 {
1804         pm_runtime_disable(&pdev->dev);
1805
1806         return 0;
1807 }
1808
1809 static struct platform_driver davinci_mcasp_driver = {
1810         .probe          = davinci_mcasp_probe,
1811         .remove         = davinci_mcasp_remove,
1812         .driver         = {
1813                 .name   = "davinci-mcasp",
1814                 .of_match_table = mcasp_dt_ids,
1815         },
1816 };
1817
1818 module_platform_driver(davinci_mcasp_driver);
1819
1820 MODULE_AUTHOR("Steve Chen");
1821 MODULE_DESCRIPTION("TI DAVINCI McASP SoC Interface");
1822 MODULE_LICENSE("GPL");