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
  30 #include <sound/asoundef.h>
  31 #include <sound/core.h>
  32 #include <sound/pcm.h>
  33 #include <sound/pcm_params.h>
  34 #include <sound/initval.h>
  35 #include <sound/soc.h>
  36 #include <sound/dmaengine_pcm.h>
  37 #include <sound/omap-pcm.h>
  38
  39 #include "davinci-pcm.h"
  40 #include "edma-pcm.h"
  41 #include "davinci-mcasp.h"
  42
  43 #define MCASP_MAX_AFIFO_DEPTH   64
  44
  45 static u32 context_regs[] = {
  46         DAVINCI_MCASP_TXFMCTL_REG,
  47         DAVINCI_MCASP_RXFMCTL_REG,
  48         DAVINCI_MCASP_TXFMT_REG,
  49         DAVINCI_MCASP_RXFMT_REG,
  50         DAVINCI_MCASP_ACLKXCTL_REG,
  51         DAVINCI_MCASP_ACLKRCTL_REG,
  52         DAVINCI_MCASP_AHCLKXCTL_REG,
  53         DAVINCI_MCASP_AHCLKRCTL_REG,
  54         DAVINCI_MCASP_PDIR_REG,
  55         DAVINCI_MCASP_RXMASK_REG,
  56         DAVINCI_MCASP_TXMASK_REG,
  57         DAVINCI_MCASP_RXTDM_REG,
  58         DAVINCI_MCASP_TXTDM_REG,
  59 };
  60
  61 struct davinci_mcasp_context {
  62         u32     config_regs[ARRAY_SIZE(context_regs)];
  63         u32     afifo_regs[2]; /* for read/write fifo control registers */
  64         u32     *xrsr_regs; /* for serializer configuration */
  65 };
  66
  67 struct davinci_mcasp {
  68         struct davinci_pcm_dma_params dma_params[2];
  69         struct snd_dmaengine_dai_dma_data dma_data[2];
  70         void __iomem *base;
  71         u32 fifo_base;
  72         struct device *dev;
  73
  74         /* McASP specific data */
  75         int     tdm_slots;
  76         u8      op_mode;
  77         u8      num_serializer;
  78         u8      *serial_dir;
  79         u8      version;
  80         u8      bclk_div;
  81         u16     bclk_lrclk_ratio;
  82         int     streams;
  83
  84         int     sysclk_freq;
  85         bool    bclk_master;
  86
  87         /* McASP FIFO related */
  88         u8      txnumevt;
  89         u8      rxnumevt;
  90
  91         bool    dat_port;
  92
  93 #ifdef CONFIG_PM_SLEEP
  94         struct davinci_mcasp_context context;
  95 #endif
  96 };
  97
  98 static inline void mcasp_set_bits(struct davinci_mcasp *mcasp, u32 offset,
  99                                   u32 val)
 100 {
 101         void __iomem *reg = mcasp->base + offset;
 102         __raw_writel(__raw_readl(reg) | val, reg);
 103 }
 104
 105 static inline void mcasp_clr_bits(struct davinci_mcasp *mcasp, u32 offset,
 106                                   u32 val)
 107 {
 108         void __iomem *reg = mcasp->base + offset;
 109         __raw_writel((__raw_readl(reg) & ~(val)), reg);
 110 }
 111
 112 static inline void mcasp_mod_bits(struct davinci_mcasp *mcasp, u32 offset,
 113                                   u32 val, u32 mask)
 114 {
 115         void __iomem *reg = mcasp->base + offset;
 116         __raw_writel((__raw_readl(reg) & ~mask) | val, reg);
 117 }
 118
 119 static inline void mcasp_set_reg(struct davinci_mcasp *mcasp, u32 offset,
 120                                  u32 val)
 121 {
 122         __raw_writel(val, mcasp->base + offset);
 123 }
 124
 125 static inline u32 mcasp_get_reg(struct davinci_mcasp *mcasp, u32 offset)
 126 {
 127         return (u32)__raw_readl(mcasp->base + offset);
 128 }
 129
 130 static void mcasp_set_ctl_reg(struct davinci_mcasp *mcasp, u32 ctl_reg, u32 val)
 131 {
 132         int i = 0;
 133
 134         mcasp_set_bits(mcasp, ctl_reg, val);
 135
 136         /* programming GBLCTL needs to read back from GBLCTL and verfiy */
 137         /* loop count is to avoid the lock-up */
 138         for (i = 0; i < 1000; i++) {
 139                 if ((mcasp_get_reg(mcasp, ctl_reg) & val) == val)
 140                         break;
 141         }
 142
 143         if (i == 1000 && ((mcasp_get_reg(mcasp, ctl_reg) & val) != val))
 144                 printk(KERN_ERR "GBLCTL write error\n");
 145 }
 146
 147 static bool mcasp_is_synchronous(struct davinci_mcasp *mcasp)
 148 {
 149         u32 rxfmctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_RXFMCTL_REG);
 150         u32 aclkxctl = mcasp_get_reg(mcasp, DAVINCI_MCASP_ACLKXCTL_REG);
 151
 152         return !(aclkxctl & TX_ASYNC) && rxfmctl & AFSRE;
 153 }
 154
 155 static void mcasp_start_rx(struct davinci_mcasp *mcasp)
 156 {
 157         /* Start clocks */
 158         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
 159         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
 160         /*
 161          * When ASYNC == 0 the transmit and receive sections operate
 162          * synchronously from the transmit clock and frame sync. We need to make
 163          * sure that the TX signlas are enabled when starting reception.
 164          */
 165         if (mcasp_is_synchronous(mcasp)) {
 166                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
 167                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
 168         }
 169
 170         /* Activate serializer(s) */
 171         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
 172         /* Release RX state machine */
 173         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
 174         /* Release Frame Sync generator */
 175         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
 176         if (mcasp_is_synchronous(mcasp))
 177                 mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 178 }
 179
 180 static void mcasp_start_tx(struct davinci_mcasp *mcasp)
 181 {
 182         u32 cnt;
 183
 184         /* Start clocks */
 185         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
 186         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
 187         /* Activate serializer(s) */
 188         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
 189
 190         /* wait for XDATA to be cleared */
 191         cnt = 0;
 192         while (!(mcasp_get_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG) &
 193                  ~XRDATA) && (cnt < 100000))
 194                 cnt++;
 195
 196         /* Release TX state machine */
 197         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
 198         /* Release Frame Sync generator */
 199         mcasp_set_ctl_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
 200 }
 201
 202 static void davinci_mcasp_start(struct davinci_mcasp *mcasp, int stream)
 203 {
 204         u32 reg;
 205
 206         mcasp->streams++;
 207
 208         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 209                 if (mcasp->txnumevt) {  /* enable FIFO */
 210                         reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 211                         mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 212                         mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
 213                 }
 214                 mcasp_start_tx(mcasp);
 215         } else {
 216                 if (mcasp->rxnumevt) {  /* enable FIFO */
 217                         reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 218                         mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 219                         mcasp_set_bits(mcasp, reg, FIFO_ENABLE);
 220                 }
 221                 mcasp_start_rx(mcasp);
 222         }
 223 }
 224
 225 static void mcasp_stop_rx(struct davinci_mcasp *mcasp)
 226 {
 227         /*
 228          * In synchronous mode stop the TX clocks if no other stream is
 229          * running
 230          */
 231         if (mcasp_is_synchronous(mcasp) && !mcasp->streams)
 232                 mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, 0);
 233
 234         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLR_REG, 0);
 235         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
 236 }
 237
 238 static void mcasp_stop_tx(struct davinci_mcasp *mcasp)
 239 {
 240         u32 val = 0;
 241
 242         /*
 243          * In synchronous mode keep TX clocks running if the capture stream is
 244          * still running.
 245          */
 246         if (mcasp_is_synchronous(mcasp) && mcasp->streams)
 247                 val =  TXHCLKRST | TXCLKRST | TXFSRST;
 248
 249         mcasp_set_reg(mcasp, DAVINCI_MCASP_GBLCTLX_REG, val);
 250         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
 251 }
 252
 253 static void davinci_mcasp_stop(struct davinci_mcasp *mcasp, int stream)
 254 {
 255         u32 reg;
 256
 257         mcasp->streams--;
 258
 259         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 260                 if (mcasp->txnumevt) {  /* disable FIFO */
 261                         reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 262                         mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 263                 }
 264                 mcasp_stop_tx(mcasp);
 265         } else {
 266                 if (mcasp->rxnumevt) {  /* disable FIFO */
 267                         reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 268                         mcasp_clr_bits(mcasp, reg, FIFO_ENABLE);
 269                 }
 270                 mcasp_stop_rx(mcasp);
 271         }
 272 }
 273
 274 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
 275                                          unsigned int fmt)
 276 {
 277         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 278         int ret = 0;
 279         u32 data_delay;
 280         bool fs_pol_rising;
 281         bool inv_fs = false;
 282
 283         pm_runtime_get_sync(mcasp->dev);
 284         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 285         case SND_SOC_DAIFMT_DSP_A:
 286                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 287                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 288                 /* 1st data bit occur one ACLK cycle after the frame sync */
 289                 data_delay = 1;
 290                 break;
 291         case SND_SOC_DAIFMT_DSP_B:
 292         case SND_SOC_DAIFMT_AC97:
 293                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 294                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 295                 /* No delay after FS */
 296                 data_delay = 0;
 297                 break;
 298         case SND_SOC_DAIFMT_I2S:
 299                 /* configure a full-word SYNC pulse (LRCLK) */
 300                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 301                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 302                 /* 1st data bit occur one ACLK cycle after the frame sync */
 303                 data_delay = 1;
 304                 /* FS need to be inverted */
 305                 inv_fs = true;
 306                 break;
 307         case SND_SOC_DAIFMT_LEFT_J:
 308                 /* configure a full-word SYNC pulse (LRCLK) */
 309                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
 310                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
 311                 /* No delay after FS */
 312                 data_delay = 0;
 313                 break;
 314         default:
 315                 ret = -EINVAL;
 316                 goto out;
 317         }
 318
 319         mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, FSXDLY(data_delay),
 320                        FSXDLY(3));
 321         mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, FSRDLY(data_delay),
 322                        FSRDLY(3));
 323
 324         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 325         case SND_SOC_DAIFMT_CBS_CFS:
 326                 /* codec is clock and frame slave */
 327                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 328                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 329
 330                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 331                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 332
 333                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
 334                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
 335                 mcasp->bclk_master = 1;
 336                 break;
 337         case SND_SOC_DAIFMT_CBM_CFS:
 338                 /* codec is clock master and frame slave */
 339                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 340                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 341
 342                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 343                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 344
 345                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, ACLKX | ACLKR);
 346                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AFSX | AFSR);
 347                 mcasp->bclk_master = 0;
 348                 break;
 349         case SND_SOC_DAIFMT_CBM_CFM:
 350                 /* codec is clock and frame master */
 351                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
 352                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
 353
 354                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
 355                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
 356
 357                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG,
 358                                ACLKX | AHCLKX | AFSX | ACLKR | AHCLKR | AFSR);
 359                 mcasp->bclk_master = 0;
 360                 break;
 361         default:
 362                 ret = -EINVAL;
 363                 goto out;
 364         }
 365
 366         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 367         case SND_SOC_DAIFMT_IB_NF:
 368                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 369                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 370                 fs_pol_rising = true;
 371                 break;
 372         case SND_SOC_DAIFMT_NB_IF:
 373                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 374                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 375                 fs_pol_rising = false;
 376                 break;
 377         case SND_SOC_DAIFMT_IB_IF:
 378                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 379                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 380                 fs_pol_rising = false;
 381                 break;
 382         case SND_SOC_DAIFMT_NB_NF:
 383                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
 384                 mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
 385                 fs_pol_rising = true;
 386                 break;
 387         default:
 388                 ret = -EINVAL;
 389                 goto out;
 390         }
 391
 392         if (inv_fs)
 393                 fs_pol_rising = !fs_pol_rising;
 394
 395         if (fs_pol_rising) {
 396                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 397                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
 398         } else {
 399                 mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
 400                 mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
 401         }
 402 out:
 403         pm_runtime_put_sync(mcasp->dev);
 404         return ret;
 405 }
 406
 407 static int __davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
 408                                       int div, bool explicit)
 409 {
 410         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 411
 412         switch (div_id) {
 413         case 0:         /* MCLK divider */
 414                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG,
 415                                AHCLKXDIV(div - 1), AHCLKXDIV_MASK);
 416                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG,
 417                                AHCLKRDIV(div - 1), AHCLKRDIV_MASK);
 418                 break;
 419
 420         case 1:         /* BCLK divider */
 421                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG,
 422                                ACLKXDIV(div - 1), ACLKXDIV_MASK);
 423                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_ACLKRCTL_REG,
 424                                ACLKRDIV(div - 1), ACLKRDIV_MASK);
 425                 if (explicit)
 426                         mcasp->bclk_div = div;
 427                 break;
 428
 429         case 2:         /* BCLK/LRCLK ratio */
 430                 mcasp->bclk_lrclk_ratio = div;
 431                 break;
 432
 433         default:
 434                 return -EINVAL;
 435         }
 436
 437         return 0;
 438 }
 439
 440 static int davinci_mcasp_set_clkdiv(struct snd_soc_dai *dai, int div_id,
 441                                     int div)
 442 {
 443         return __davinci_mcasp_set_clkdiv(dai, div_id, div, 1);
 444 }
 445
 446 static int davinci_mcasp_set_sysclk(struct snd_soc_dai *dai, int clk_id,
 447                                     unsigned int freq, int dir)
 448 {
 449         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 450
 451         if (dir == SND_SOC_CLOCK_OUT) {
 452                 mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
 453                 mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
 454                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
 455         } else {
 456                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXE);
 457                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_AHCLKRCTL_REG, AHCLKRE);
 458                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AHCLKX);
 459         }
 460
 461         mcasp->sysclk_freq = freq;
 462
 463         return 0;
 464 }
 465
 466 static int davinci_config_channel_size(struct davinci_mcasp *mcasp,
 467                                        int word_length)
 468 {
 469         u32 fmt;
 470         u32 tx_rotate = (word_length / 4) & 0x7;
 471         u32 mask = (1ULL << word_length) - 1;
 472         /*
 473          * For captured data we should not rotate, inversion and masking is
 474          * enoguh to get the data to the right position:
 475          * Format         data from bus         after reverse (XRBUF)
 476          * S16_LE:      |LSB|MSB|xxx|xxx|       |xxx|xxx|MSB|LSB|
 477          * S24_3LE:     |LSB|DAT|MSB|xxx|       |xxx|MSB|DAT|LSB|
 478          * S24_LE:      |LSB|DAT|MSB|xxx|       |xxx|MSB|DAT|LSB|
 479          * S32_LE:      |LSB|DAT|DAT|MSB|       |MSB|DAT|DAT|LSB|
 480          */
 481         u32 rx_rotate = 0;
 482
 483         /*
 484          * if s BCLK-to-LRCLK ratio has been configured via the set_clkdiv()
 485          * callback, take it into account here. That allows us to for example
 486          * send 32 bits per channel to the codec, while only 16 of them carry
 487          * audio payload.
 488          * The clock ratio is given for a full period of data (for I2S format
 489          * both left and right channels), so it has to be divided by number of
 490          * tdm-slots (for I2S - divided by 2).
 491          */
 492         if (mcasp->bclk_lrclk_ratio)
 493                 word_length = mcasp->bclk_lrclk_ratio / mcasp->tdm_slots;
 494
 495         /* mapping of the XSSZ bit-field as described in the datasheet */
 496         fmt = (word_length >> 1) - 1;
 497
 498         if (mcasp->op_mode != DAVINCI_MCASP_DIT_MODE) {
 499                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXSSZ(fmt),
 500                                RXSSZ(0x0F));
 501                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXSSZ(fmt),
 502                                TXSSZ(0x0F));
 503                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(tx_rotate),
 504                                TXROT(7));
 505                 mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, RXROT(rx_rotate),
 506                                RXROT(7));
 507                 mcasp_set_reg(mcasp, DAVINCI_MCASP_RXMASK_REG, mask);
 508         }
 509
 510         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXMASK_REG, mask);
 511
 512         return 0;
 513 }
 514
 515 static int mcasp_common_hw_param(struct davinci_mcasp *mcasp, int stream,
 516                                  int period_words, int channels)
 517 {
 518         struct davinci_pcm_dma_params *dma_params = &mcasp->dma_params[stream];
 519         struct snd_dmaengine_dai_dma_data *dma_data = &mcasp->dma_data[stream];
 520         int i;
 521         u8 tx_ser = 0;
 522         u8 rx_ser = 0;
 523         u8 slots = mcasp->tdm_slots;
 524         u8 max_active_serializers = (channels + slots - 1) / slots;
 525         int active_serializers, numevt, n;
 526         u32 reg;
 527         /* Default configuration */
 528         if (mcasp->version < MCASP_VERSION_3)
 529                 mcasp_set_bits(mcasp, DAVINCI_MCASP_PWREMUMGT_REG, MCASP_SOFT);
 530
 531         /* All PINS as McASP */
 532         mcasp_set_reg(mcasp, DAVINCI_MCASP_PFUNC_REG, 0x00000000);
 533
 534         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 535                 mcasp_set_reg(mcasp, DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
 536                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
 537         } else {
 538                 mcasp_set_reg(mcasp, DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
 539                 mcasp_clr_bits(mcasp, DAVINCI_MCASP_REVTCTL_REG, RXDATADMADIS);
 540         }
 541
 542         for (i = 0; i < mcasp->num_serializer; i++) {
 543                 mcasp_set_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
 544                                mcasp->serial_dir[i]);
 545                 if (mcasp->serial_dir[i] == TX_MODE &&
 546                                         tx_ser < max_active_serializers) {
 547                         mcasp_set_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
 548                         tx_ser++;
 549                 } else if (mcasp->serial_dir[i] == RX_MODE &&
 550                                         rx_ser < max_active_serializers) {
 551                         mcasp_clr_bits(mcasp, DAVINCI_MCASP_PDIR_REG, AXR(i));
 552                         rx_ser++;
 553                 } else {
 554                         mcasp_mod_bits(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
 555                                        SRMOD_INACTIVE, SRMOD_MASK);
 556                 }
 557         }
 558
 559         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
 560                 active_serializers = tx_ser;
 561                 numevt = mcasp->txnumevt;
 562                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 563         } else {
 564                 active_serializers = rx_ser;
 565                 numevt = mcasp->rxnumevt;
 566                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 567         }
 568
 569         if (active_serializers < max_active_serializers) {
 570                 dev_warn(mcasp->dev, "stream has more channels (%d) than are "
 571                          "enabled in mcasp (%d)\n", channels,
 572                          active_serializers * slots);
 573                 return -EINVAL;
 574         }
 575
 576         /* AFIFO is not in use */
 577         if (!numevt) {
 578                 /* Configure the burst size for platform drivers */
 579                 if (active_serializers > 1) {
 580                         /*
 581                          * If more than one serializers are in use we have one
 582                          * DMA request to provide data for all serializers.
 583                          * For example if three serializers are enabled the DMA
 584                          * need to transfer three words per DMA request.
 585                          */
 586                         dma_params->fifo_level = active_serializers;
 587                         dma_data->maxburst = active_serializers;
 588                 } else {
 589                         dma_params->fifo_level = 0;
 590                         dma_data->maxburst = 0;
 591                 }
 592                 return 0;
 593         }
 594
 595         if (period_words % active_serializers) {
 596                 dev_err(mcasp->dev, "Invalid combination of period words and "
 597                         "active serializers: %d, %d\n", period_words,
 598                         active_serializers);
 599                 return -EINVAL;
 600         }
 601
 602         /*
 603          * Calculate the optimal AFIFO depth for platform side:
 604          * The number of words for numevt need to be in steps of active
 605          * serializers.
 606          */
 607         n = numevt % active_serializers;
 608         if (n)
 609                 numevt += (active_serializers - n);
 610         while (period_words % numevt && numevt > 0)
 611                 numevt -= active_serializers;
 612         if (numevt <= 0)
 613                 numevt = active_serializers;
 614
 615         mcasp_mod_bits(mcasp, reg, active_serializers, NUMDMA_MASK);
 616         mcasp_mod_bits(mcasp, reg, NUMEVT(numevt), NUMEVT_MASK);
 617
 618         /* Configure the burst size for platform drivers */
 619         if (numevt == 1)
 620                 numevt = 0;
 621         dma_params->fifo_level = numevt;
 622         dma_data->maxburst = numevt;
 623
 624         return 0;
 625 }
 626
 627 static int mcasp_i2s_hw_param(struct davinci_mcasp *mcasp, int stream)
 628 {
 629         int i, active_slots;
 630         u32 mask = 0;
 631         u32 busel = 0;
 632
 633         if ((mcasp->tdm_slots < 2) || (mcasp->tdm_slots > 32)) {
 634                 dev_err(mcasp->dev, "tdm slot %d not supported\n",
 635                         mcasp->tdm_slots);
 636                 return -EINVAL;
 637         }
 638
 639         active_slots = (mcasp->tdm_slots > 31) ? 32 : mcasp->tdm_slots;
 640         for (i = 0; i < active_slots; i++)
 641                 mask |= (1 << i);
 642
 643         mcasp_clr_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, TX_ASYNC);
 644
 645         if (!mcasp->dat_port)
 646                 busel = TXSEL;
 647
 648         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, mask);
 649         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, busel | TXORD);
 650         mcasp_mod_bits(mcasp, DAVINCI_MCASP_TXFMCTL_REG,
 651                        FSXMOD(mcasp->tdm_slots), FSXMOD(0x1FF));
 652
 653         mcasp_set_reg(mcasp, DAVINCI_MCASP_RXTDM_REG, mask);
 654         mcasp_set_bits(mcasp, DAVINCI_MCASP_RXFMT_REG, busel | RXORD);
 655         mcasp_mod_bits(mcasp, DAVINCI_MCASP_RXFMCTL_REG,
 656                        FSRMOD(mcasp->tdm_slots), FSRMOD(0x1FF));
 657
 658         return 0;
 659 }
 660
 661 /* S/PDIF */
 662 static int mcasp_dit_hw_param(struct davinci_mcasp *mcasp,
 663                               unsigned int rate)
 664 {
 665         u32 cs_value = 0;
 666         u8 *cs_bytes = (u8*) &cs_value;
 667
 668         /* Set the TX format : 24 bit right rotation, 32 bit slot, Pad 0
 669            and LSB first */
 670         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXFMT_REG, TXROT(6) | TXSSZ(15));
 671
 672         /* Set TX frame synch : DIT Mode, 1 bit width, internal, rising edge */
 673         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXFMCTL_REG, AFSXE | FSXMOD(0x180));
 674
 675         /* Set the TX tdm : for all the slots */
 676         mcasp_set_reg(mcasp, DAVINCI_MCASP_TXTDM_REG, 0xFFFFFFFF);
 677
 678         /* Set the TX clock controls : div = 1 and internal */
 679         mcasp_set_bits(mcasp, DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE | TX_ASYNC);
 680
 681         mcasp_clr_bits(mcasp, DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
 682
 683         /* Only 44100 and 48000 are valid, both have the same setting */
 684         mcasp_set_bits(mcasp, DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXDIV(3));
 685
 686         /* Enable the DIT */
 687         mcasp_set_bits(mcasp, DAVINCI_MCASP_TXDITCTL_REG, DITEN);
 688
 689         /* Set S/PDIF channel status bits */
 690         cs_bytes[0] = IEC958_AES0_CON_NOT_COPYRIGHT;
 691         cs_bytes[1] = IEC958_AES1_CON_PCM_CODER;
 692
 693         switch (rate) {
 694         case 22050:
 695                 cs_bytes[3] |= IEC958_AES3_CON_FS_22050;
 696                 break;
 697         case 24000:
 698                 cs_bytes[3] |= IEC958_AES3_CON_FS_24000;
 699                 break;
 700         case 32000:
 701                 cs_bytes[3] |= IEC958_AES3_CON_FS_32000;
 702                 break;
 703         case 44100:
 704                 cs_bytes[3] |= IEC958_AES3_CON_FS_44100;
 705                 break;
 706         case 48000:
 707                 cs_bytes[3] |= IEC958_AES3_CON_FS_48000;
 708                 break;
 709         case 88200:
 710                 cs_bytes[3] |= IEC958_AES3_CON_FS_88200;
 711                 break;
 712         case 96000:
 713                 cs_bytes[3] |= IEC958_AES3_CON_FS_96000;
 714                 break;
 715         case 176400:
 716                 cs_bytes[3] |= IEC958_AES3_CON_FS_176400;
 717                 break;
 718         case 192000:
 719                 cs_bytes[3] |= IEC958_AES3_CON_FS_192000;
 720                 break;
 721         default:
 722                 printk(KERN_WARNING "unsupported sampling rate: %d\n", rate);
 723                 return -EINVAL;
 724         }
 725
 726         mcasp_set_reg(mcasp, DAVINCI_MCASP_DITCSRA_REG, cs_value);
 727         mcasp_set_reg(mcasp, DAVINCI_MCASP_DITCSRB_REG, cs_value);
 728
 729         return 0;
 730 }
 731
 732 static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
 733                                         struct snd_pcm_hw_params *params,
 734                                         struct snd_soc_dai *cpu_dai)
 735 {
 736         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 737         struct davinci_pcm_dma_params *dma_params =
 738                                         &mcasp->dma_params[substream->stream];
 739         int word_length;
 740         int channels = params_channels(params);
 741         int period_size = params_period_size(params);
 742         int ret;
 743
 744         /*
 745          * If mcasp is BCLK master, and a BCLK divider was not provided by
 746          * the machine driver, we need to calculate the ratio.
 747          */
 748         if (mcasp->bclk_master && mcasp->bclk_div == 0 && mcasp->sysclk_freq) {
 749                 unsigned int bclk_freq = snd_soc_params_to_bclk(params);
 750                 unsigned int div = mcasp->sysclk_freq / bclk_freq;
 751                 if (mcasp->sysclk_freq % bclk_freq != 0) {
 752                         if (((mcasp->sysclk_freq / div) - bclk_freq) >
 753                             (bclk_freq - (mcasp->sysclk_freq / (div+1))))
 754                                 div++;
 755                         dev_warn(mcasp->dev,
 756                                  "Inaccurate BCLK: %u Hz / %u != %u Hz\n",
 757                                  mcasp->sysclk_freq, div, bclk_freq);
 758                 }
 759                 __davinci_mcasp_set_clkdiv(cpu_dai, 1, div, 0);
 760         }
 761
 762         ret = mcasp_common_hw_param(mcasp, substream->stream,
 763                                     period_size * channels, channels);
 764         if (ret)
 765                 return ret;
 766
 767         if (mcasp->op_mode == DAVINCI_MCASP_DIT_MODE)
 768                 ret = mcasp_dit_hw_param(mcasp, params_rate(params));
 769         else
 770                 ret = mcasp_i2s_hw_param(mcasp, substream->stream);
 771
 772         if (ret)
 773                 return ret;
 774
 775         switch (params_format(params)) {
 776         case SNDRV_PCM_FORMAT_U8:
 777         case SNDRV_PCM_FORMAT_S8:
 778                 dma_params->data_type = 1;
 779                 word_length = 8;
 780                 break;
 781
 782         case SNDRV_PCM_FORMAT_U16_LE:
 783         case SNDRV_PCM_FORMAT_S16_LE:
 784                 dma_params->data_type = 2;
 785                 word_length = 16;
 786                 break;
 787
 788         case SNDRV_PCM_FORMAT_U24_3LE:
 789         case SNDRV_PCM_FORMAT_S24_3LE:
 790                 dma_params->data_type = 3;
 791                 word_length = 24;
 792                 break;
 793
 794         case SNDRV_PCM_FORMAT_U24_LE:
 795         case SNDRV_PCM_FORMAT_S24_LE:
 796                 dma_params->data_type = 4;
 797                 word_length = 24;
 798                 break;
 799
 800         case SNDRV_PCM_FORMAT_U32_LE:
 801         case SNDRV_PCM_FORMAT_S32_LE:
 802                 dma_params->data_type = 4;
 803                 word_length = 32;
 804                 break;
 805
 806         default:
 807                 printk(KERN_WARNING "davinci-mcasp: unsupported PCM format");
 808                 return -EINVAL;
 809         }
 810
 811         if (mcasp->version == MCASP_VERSION_2 && !dma_params->fifo_level)
 812                 dma_params->acnt = 4;
 813         else
 814                 dma_params->acnt = dma_params->data_type;
 815
 816         davinci_config_channel_size(mcasp, word_length);
 817
 818         return 0;
 819 }
 820
 821 static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
 822                                      int cmd, struct snd_soc_dai *cpu_dai)
 823 {
 824         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(cpu_dai);
 825         int ret = 0;
 826
 827         switch (cmd) {
 828         case SNDRV_PCM_TRIGGER_RESUME:
 829         case SNDRV_PCM_TRIGGER_START:
 830         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 831                 davinci_mcasp_start(mcasp, substream->stream);
 832                 break;
 833         case SNDRV_PCM_TRIGGER_SUSPEND:
 834         case SNDRV_PCM_TRIGGER_STOP:
 835         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 836                 davinci_mcasp_stop(mcasp, substream->stream);
 837                 break;
 838
 839         default:
 840                 ret = -EINVAL;
 841         }
 842
 843         return ret;
 844 }
 845
 846 static const struct snd_soc_dai_ops davinci_mcasp_dai_ops = {
 847         .trigger        = davinci_mcasp_trigger,
 848         .hw_params      = davinci_mcasp_hw_params,
 849         .set_fmt        = davinci_mcasp_set_dai_fmt,
 850         .set_clkdiv     = davinci_mcasp_set_clkdiv,
 851         .set_sysclk     = davinci_mcasp_set_sysclk,
 852 };
 853
 854 static int davinci_mcasp_dai_probe(struct snd_soc_dai *dai)
 855 {
 856         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 857
 858         if (mcasp->version >= MCASP_VERSION_3) {
 859                 /* Using dmaengine PCM */
 860                 dai->playback_dma_data =
 861                                 &mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK];
 862                 dai->capture_dma_data =
 863                                 &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
 864         } else {
 865                 /* Using davinci-pcm */
 866                 dai->playback_dma_data = mcasp->dma_params;
 867                 dai->capture_dma_data = mcasp->dma_params;
 868         }
 869
 870         return 0;
 871 }
 872
 873 #ifdef CONFIG_PM_SLEEP
 874 static int davinci_mcasp_suspend(struct snd_soc_dai *dai)
 875 {
 876         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 877         struct davinci_mcasp_context *context = &mcasp->context;
 878         u32 reg;
 879         int i;
 880
 881         for (i = 0; i < ARRAY_SIZE(context_regs); i++)
 882                 context->config_regs[i] = mcasp_get_reg(mcasp, context_regs[i]);
 883
 884         if (mcasp->txnumevt) {
 885                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 886                 context->afifo_regs[0] = mcasp_get_reg(mcasp, reg);
 887         }
 888         if (mcasp->rxnumevt) {
 889                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 890                 context->afifo_regs[1] = mcasp_get_reg(mcasp, reg);
 891         }
 892
 893         for (i = 0; i < mcasp->num_serializer; i++)
 894                 context->xrsr_regs[i] = mcasp_get_reg(mcasp,
 895                                                 DAVINCI_MCASP_XRSRCTL_REG(i));
 896
 897         return 0;
 898 }
 899
 900 static int davinci_mcasp_resume(struct snd_soc_dai *dai)
 901 {
 902         struct davinci_mcasp *mcasp = snd_soc_dai_get_drvdata(dai);
 903         struct davinci_mcasp_context *context = &mcasp->context;
 904         u32 reg;
 905         int i;
 906
 907         for (i = 0; i < ARRAY_SIZE(context_regs); i++)
 908                 mcasp_set_reg(mcasp, context_regs[i], context->config_regs[i]);
 909
 910         if (mcasp->txnumevt) {
 911                 reg = mcasp->fifo_base + MCASP_WFIFOCTL_OFFSET;
 912                 mcasp_set_reg(mcasp, reg, context->afifo_regs[0]);
 913         }
 914         if (mcasp->rxnumevt) {
 915                 reg = mcasp->fifo_base + MCASP_RFIFOCTL_OFFSET;
 916                 mcasp_set_reg(mcasp, reg, context->afifo_regs[1]);
 917         }
 918
 919         for (i = 0; i < mcasp->num_serializer; i++)
 920                 mcasp_set_reg(mcasp, DAVINCI_MCASP_XRSRCTL_REG(i),
 921                               context->xrsr_regs[i]);
 922
 923         return 0;
 924 }
 925 #else
 926 #define davinci_mcasp_suspend NULL
 927 #define davinci_mcasp_resume NULL
 928 #endif
 929
 930 #define DAVINCI_MCASP_RATES     SNDRV_PCM_RATE_8000_192000
 931
 932 #define DAVINCI_MCASP_PCM_FMTS (SNDRV_PCM_FMTBIT_S8 | \
 933                                 SNDRV_PCM_FMTBIT_U8 | \
 934                                 SNDRV_PCM_FMTBIT_S16_LE | \
 935                                 SNDRV_PCM_FMTBIT_U16_LE | \
 936                                 SNDRV_PCM_FMTBIT_S24_LE | \
 937                                 SNDRV_PCM_FMTBIT_U24_LE | \
 938                                 SNDRV_PCM_FMTBIT_S24_3LE | \
 939                                 SNDRV_PCM_FMTBIT_U24_3LE | \
 940                                 SNDRV_PCM_FMTBIT_S32_LE | \
 941                                 SNDRV_PCM_FMTBIT_U32_LE)
 942
 943 static struct snd_soc_dai_driver davinci_mcasp_dai[] = {
 944         {
 945                 .name           = "davinci-mcasp.0",
 946                 .probe          = davinci_mcasp_dai_probe,
 947                 .suspend        = davinci_mcasp_suspend,
 948                 .resume         = davinci_mcasp_resume,
 949                 .playback       = {
 950                         .channels_min   = 2,
 951                         .channels_max   = 32 * 16,
 952                         .rates          = DAVINCI_MCASP_RATES,
 953                         .formats        = DAVINCI_MCASP_PCM_FMTS,
 954                 },
 955                 .capture        = {
 956                         .channels_min   = 2,
 957                         .channels_max   = 32 * 16,
 958                         .rates          = DAVINCI_MCASP_RATES,
 959                         .formats        = DAVINCI_MCASP_PCM_FMTS,
 960                 },
 961                 .ops            = &davinci_mcasp_dai_ops,
 962
 963         },
 964         {
 965                 .name           = "davinci-mcasp.1",
 966                 .probe          = davinci_mcasp_dai_probe,
 967                 .playback       = {
 968                         .channels_min   = 1,
 969                         .channels_max   = 384,
 970                         .rates          = DAVINCI_MCASP_RATES,
 971                         .formats        = DAVINCI_MCASP_PCM_FMTS,
 972                 },
 973                 .ops            = &davinci_mcasp_dai_ops,
 974         },
 975
 976 };
 977
 978 static const struct snd_soc_component_driver davinci_mcasp_component = {
 979         .name           = "davinci-mcasp",
 980 };
 981
 982 /* Some HW specific values and defaults. The rest is filled in from DT. */
 983 static struct davinci_mcasp_pdata dm646x_mcasp_pdata = {
 984         .tx_dma_offset = 0x400,
 985         .rx_dma_offset = 0x400,
 986         .asp_chan_q = EVENTQ_0,
 987         .version = MCASP_VERSION_1,
 988 };
 989
 990 static struct davinci_mcasp_pdata da830_mcasp_pdata = {
 991         .tx_dma_offset = 0x2000,
 992         .rx_dma_offset = 0x2000,
 993         .asp_chan_q = EVENTQ_0,
 994         .version = MCASP_VERSION_2,
 995 };
 996
 997 static struct davinci_mcasp_pdata am33xx_mcasp_pdata = {
 998         .tx_dma_offset = 0,
 999         .rx_dma_offset = 0,
1000         .asp_chan_q = EVENTQ_0,
1001         .version = MCASP_VERSION_3,
1002 };
1003
1004 static struct davinci_mcasp_pdata dra7_mcasp_pdata = {
1005         .tx_dma_offset = 0x200,
1006         .rx_dma_offset = 0x284,
1007         .asp_chan_q = EVENTQ_0,
1008         .version = MCASP_VERSION_4,
1009 };
1010
1011 static const struct of_device_id mcasp_dt_ids[] = {
1012         {
1013                 .compatible = "ti,dm646x-mcasp-audio",
1014                 .data = &dm646x_mcasp_pdata,
1015         },
1016         {
1017                 .compatible = "ti,da830-mcasp-audio",
1018                 .data = &da830_mcasp_pdata,
1019         },
1020         {
1021                 .compatible = "ti,am33xx-mcasp-audio",
1022                 .data = &am33xx_mcasp_pdata,
1023         },
1024         {
1025                 .compatible = "ti,dra7-mcasp-audio",
1026                 .data = &dra7_mcasp_pdata,
1027         },
1028         { /* sentinel */ }
1029 };
1030 MODULE_DEVICE_TABLE(of, mcasp_dt_ids);
1031
1032 static int mcasp_reparent_fck(struct platform_device *pdev)
1033 {
1034         struct device_node *node = pdev->dev.of_node;
1035         struct clk *gfclk, *parent_clk;
1036         const char *parent_name;
1037         int ret;
1038
1039         if (!node)
1040                 return 0;
1041
1042         parent_name = of_get_property(node, "fck_parent", NULL);
1043         if (!parent_name)
1044                 return 0;
1045
1046         gfclk = clk_get(&pdev->dev, "fck");
1047         if (IS_ERR(gfclk)) {
1048                 dev_err(&pdev->dev, "failed to get fck\n");
1049                 return PTR_ERR(gfclk);
1050         }
1051
1052         parent_clk = clk_get(NULL, parent_name);
1053         if (IS_ERR(parent_clk)) {
1054                 dev_err(&pdev->dev, "failed to get parent clock\n");
1055                 ret = PTR_ERR(parent_clk);
1056                 goto err1;
1057         }
1058
1059         ret = clk_set_parent(gfclk, parent_clk);
1060         if (ret) {
1061                 dev_err(&pdev->dev, "failed to reparent fck\n");
1062                 goto err2;
1063         }
1064
1065 err2:
1066         clk_put(parent_clk);
1067 err1:
1068         clk_put(gfclk);
1069         return ret;
1070 }
1071
1072 static struct davinci_mcasp_pdata *davinci_mcasp_set_pdata_from_of(
1073                                                 struct platform_device *pdev)
1074 {
1075         struct device_node *np = pdev->dev.of_node;
1076         struct davinci_mcasp_pdata *pdata = NULL;
1077         const struct of_device_id *match =
1078                         of_match_device(mcasp_dt_ids, &pdev->dev);
1079         struct of_phandle_args dma_spec;
1080
1081         const u32 *of_serial_dir32;
1082         u32 val;
1083         int i, ret = 0;
1084
1085         if (pdev->dev.platform_data) {
1086                 pdata = pdev->dev.platform_data;
1087                 return pdata;
1088         } else if (match) {
1089                 pdata = (struct davinci_mcasp_pdata*) match->data;
1090         } else {
1091                 /* control shouldn't reach here. something is wrong */
1092                 ret = -EINVAL;
1093                 goto nodata;
1094         }
1095
1096         ret = of_property_read_u32(np, "op-mode", &val);
1097         if (ret >= 0)
1098                 pdata->op_mode = val;
1099
1100         ret = of_property_read_u32(np, "tdm-slots", &val);
1101         if (ret >= 0) {
1102                 if (val < 2 || val > 32) {
1103                         dev_err(&pdev->dev,
1104                                 "tdm-slots must be in rage [2-32]\n");
1105                         ret = -EINVAL;
1106                         goto nodata;
1107                 }
1108
1109                 pdata->tdm_slots = val;
1110         }
1111
1112         of_serial_dir32 = of_get_property(np, "serial-dir", &val);
1113         val /= sizeof(u32);
1114         if (of_serial_dir32) {
1115                 u8 *of_serial_dir = devm_kzalloc(&pdev->dev,
1116                                                  (sizeof(*of_serial_dir) * val),
1117                                                  GFP_KERNEL);
1118                 if (!of_serial_dir) {
1119                         ret = -ENOMEM;
1120                         goto nodata;
1121                 }
1122
1123                 for (i = 0; i < val; i++)
1124                         of_serial_dir[i] = be32_to_cpup(&of_serial_dir32[i]);
1125
1126                 pdata->num_serializer = val;
1127                 pdata->serial_dir = of_serial_dir;
1128         }
1129
1130         ret = of_property_match_string(np, "dma-names", "tx");
1131         if (ret < 0)
1132                 goto nodata;
1133
1134         ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
1135                                          &dma_spec);
1136         if (ret < 0)
1137                 goto nodata;
1138
1139         pdata->tx_dma_channel = dma_spec.args[0];
1140
1141         ret = of_property_match_string(np, "dma-names", "rx");
1142         if (ret < 0)
1143                 goto nodata;
1144
1145         ret = of_parse_phandle_with_args(np, "dmas", "#dma-cells", ret,
1146                                          &dma_spec);
1147         if (ret < 0)
1148                 goto nodata;
1149
1150         pdata->rx_dma_channel = dma_spec.args[0];
1151
1152         ret = of_property_read_u32(np, "tx-num-evt", &val);
1153         if (ret >= 0)
1154                 pdata->txnumevt = val;
1155
1156         ret = of_property_read_u32(np, "rx-num-evt", &val);
1157         if (ret >= 0)
1158                 pdata->rxnumevt = val;
1159
1160         ret = of_property_read_u32(np, "sram-size-playback", &val);
1161         if (ret >= 0)
1162                 pdata->sram_size_playback = val;
1163
1164         ret = of_property_read_u32(np, "sram-size-capture", &val);
1165         if (ret >= 0)
1166                 pdata->sram_size_capture = val;
1167
1168         return  pdata;
1169
1170 nodata:
1171         if (ret < 0) {
1172                 dev_err(&pdev->dev, "Error populating platform data, err %d\n",
1173                         ret);
1174                 pdata = NULL;
1175         }
1176         return  pdata;
1177 }
1178
1179 static int davinci_mcasp_probe(struct platform_device *pdev)
1180 {
1181         struct davinci_pcm_dma_params *dma_params;
1182         struct snd_dmaengine_dai_dma_data *dma_data;
1183         struct resource *mem, *ioarea, *res, *dat;
1184         struct davinci_mcasp_pdata *pdata;
1185         struct davinci_mcasp *mcasp;
1186         int ret;
1187
1188         if (!pdev->dev.platform_data && !pdev->dev.of_node) {
1189                 dev_err(&pdev->dev, "No platform data supplied\n");
1190                 return -EINVAL;
1191         }
1192
1193         mcasp = devm_kzalloc(&pdev->dev, sizeof(struct davinci_mcasp),
1194                            GFP_KERNEL);
1195         if (!mcasp)
1196                 return  -ENOMEM;
1197
1198         pdata = davinci_mcasp_set_pdata_from_of(pdev);
1199         if (!pdata) {
1200                 dev_err(&pdev->dev, "no platform data\n");
1201                 return -EINVAL;
1202         }
1203
1204         mem = platform_get_resource_byname(pdev, IORESOURCE_MEM, "mpu");
1205         if (!mem) {
1206                 dev_warn(mcasp->dev,
1207                          "\"mpu\" mem resource not found, using index 0\n");
1208                 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1209                 if (!mem) {
1210                         dev_err(&pdev->dev, "no mem resource?\n");
1211                         return -ENODEV;
1212                 }
1213         }
1214
1215         ioarea = devm_request_mem_region(&pdev->dev, mem->start,
1216                         resource_size(mem), pdev->name);
1217         if (!ioarea) {
1218                 dev_err(&pdev->dev, "Audio region already claimed\n");
1219                 return -EBUSY;
1220         }
1221
1222         pm_runtime_enable(&pdev->dev);
1223
1224         ret = pm_runtime_get_sync(&pdev->dev);
1225         if (IS_ERR_VALUE(ret)) {
1226                 dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n");
1227                 return ret;
1228         }
1229
1230         mcasp->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
1231         if (!mcasp->base) {
1232                 dev_err(&pdev->dev, "ioremap failed\n");
1233                 ret = -ENOMEM;
1234                 goto err;
1235         }
1236
1237         mcasp->op_mode = pdata->op_mode;
1238         mcasp->tdm_slots = pdata->tdm_slots;
1239         mcasp->num_serializer = pdata->num_serializer;
1240 #ifdef CONFIG_PM_SLEEP
1241         mcasp->context.xrsr_regs = devm_kzalloc(&pdev->dev,
1242                                         sizeof(u32) * mcasp->num_serializer,
1243                                         GFP_KERNEL);
1244 #endif
1245         mcasp->serial_dir = pdata->serial_dir;
1246         mcasp->version = pdata->version;
1247         mcasp->txnumevt = pdata->txnumevt;
1248         mcasp->rxnumevt = pdata->rxnumevt;
1249
1250         mcasp->dev = &pdev->dev;
1251
1252         dat = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dat");
1253         if (dat)
1254                 mcasp->dat_port = true;
1255
1256         dma_params = &mcasp->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
1257         dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_PLAYBACK];
1258         dma_params->asp_chan_q = pdata->asp_chan_q;
1259         dma_params->ram_chan_q = pdata->ram_chan_q;
1260         dma_params->sram_pool = pdata->sram_pool;
1261         dma_params->sram_size = pdata->sram_size_playback;
1262         if (dat)
1263                 dma_params->dma_addr = dat->start;
1264         else
1265                 dma_params->dma_addr = mem->start + pdata->tx_dma_offset;
1266
1267         /* Unconditional dmaengine stuff */
1268         dma_data->addr = dma_params->dma_addr;
1269
1270         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
1271         if (res)
1272                 dma_params->channel = res->start;
1273         else
1274                 dma_params->channel = pdata->tx_dma_channel;
1275
1276         /* dmaengine filter data for DT and non-DT boot */
1277         if (pdev->dev.of_node)
1278                 dma_data->filter_data = "tx";
1279         else
1280                 dma_data->filter_data = &dma_params->channel;
1281
1282         dma_params = &mcasp->dma_params[SNDRV_PCM_STREAM_CAPTURE];
1283         dma_data = &mcasp->dma_data[SNDRV_PCM_STREAM_CAPTURE];
1284         dma_params->asp_chan_q = pdata->asp_chan_q;
1285         dma_params->ram_chan_q = pdata->ram_chan_q;
1286         dma_params->sram_pool = pdata->sram_pool;
1287         dma_params->sram_size = pdata->sram_size_capture;
1288         if (dat)
1289                 dma_params->dma_addr = dat->start;
1290         else
1291                 dma_params->dma_addr = mem->start + pdata->rx_dma_offset;
1292
1293         /* Unconditional dmaengine stuff */
1294         dma_data->addr = dma_params->dma_addr;
1295
1296         if (mcasp->version < MCASP_VERSION_3) {
1297                 mcasp->fifo_base = DAVINCI_MCASP_V2_AFIFO_BASE;
1298                 /* dma_params->dma_addr is pointing to the data port address */
1299                 mcasp->dat_port = true;
1300         } else {
1301                 mcasp->fifo_base = DAVINCI_MCASP_V3_AFIFO_BASE;
1302         }
1303
1304         res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
1305         if (res)
1306                 dma_params->channel = res->start;
1307         else
1308                 dma_params->channel = pdata->rx_dma_channel;
1309
1310         /* dmaengine filter data for DT and non-DT boot */
1311         if (pdev->dev.of_node)
1312                 dma_data->filter_data = "rx";
1313         else
1314                 dma_data->filter_data = &dma_params->channel;
1315
1316         dev_set_drvdata(&pdev->dev, mcasp);
1317
1318         mcasp_reparent_fck(pdev);
1319
1320         ret = devm_snd_soc_register_component(&pdev->dev,
1321                                         &davinci_mcasp_component,
1322                                         &davinci_mcasp_dai[pdata->op_mode], 1);
1323
1324         if (ret != 0)
1325                 goto err;
1326
1327         switch (mcasp->version) {
1328 #if IS_BUILTIN(CONFIG_SND_DAVINCI_SOC) || \
1329         (IS_MODULE(CONFIG_SND_DAVINCI_SOC_MCASP) && \
1330          IS_MODULE(CONFIG_SND_DAVINCI_SOC))
1331         case MCASP_VERSION_1:
1332         case MCASP_VERSION_2:
1333                 ret = davinci_soc_platform_register(&pdev->dev);
1334                 break;
1335 #endif
1336 #if IS_BUILTIN(CONFIG_SND_EDMA_SOC) || \
1337         (IS_MODULE(CONFIG_SND_DAVINCI_SOC_MCASP) && \
1338          IS_MODULE(CONFIG_SND_EDMA_SOC))
1339         case MCASP_VERSION_3:
1340                 ret = edma_pcm_platform_register(&pdev->dev);
1341                 break;
1342 #endif
1343 #if IS_BUILTIN(CONFIG_SND_OMAP_SOC) || \
1344         (IS_MODULE(CONFIG_SND_DAVINCI_SOC_MCASP) && \
1345          IS_MODULE(CONFIG_SND_OMAP_SOC))
1346         case MCASP_VERSION_4:
1347                 ret = omap_pcm_platform_register(&pdev->dev);
1348                 break;
1349 #endif
1350         default:
1351                 dev_err(&pdev->dev, "Invalid McASP version: %d\n",
1352                         mcasp->version);
1353                 ret = -EINVAL;
1354                 break;
1355         }
1356
1357         if (ret) {
1358                 dev_err(&pdev->dev, "register PCM failed: %d\n", ret);
1359                 goto err;
1360         }
1361
1362         return 0;
1363
1364 err:
1365         pm_runtime_put_sync(&pdev->dev);
1366         pm_runtime_disable(&pdev->dev);
1367         return ret;
1368 }
1369
1370 static int davinci_mcasp_remove(struct platform_device *pdev)
1371 {
1372         pm_runtime_put_sync(&pdev->dev);
1373         pm_runtime_disable(&pdev->dev);
1374
1375         return 0;
1376 }
1377
1378 static struct platform_driver davinci_mcasp_driver = {
1379         .probe          = davinci_mcasp_probe,
1380         .remove         = davinci_mcasp_remove,
1381         .driver         = {
1382                 .name   = "davinci-mcasp",
1383                 .owner  = THIS_MODULE,
1384                 .of_match_table = mcasp_dt_ids,
1385         },
1386 };
1387
1388 module_platform_driver(davinci_mcasp_driver);
1389
1390 MODULE_AUTHOR("Steve Chen");
1391 MODULE_DESCRIPTION("TI DAVINCI McASP SoC Interface");
1392 MODULE_LICENSE("GPL");