Quelle  kirkwood-i2s.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * kirkwood-i2s.c
 *
 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/io.h>
#include <linux/slab.h>
#include <linux/mbus.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <linux/platform_data/asoc-kirkwood.h>
#include <linux/of.h>

#include "kirkwood.h"

#define KIRKWOOD_I2S_FORMATS \
 (SNDRV_PCM_FMTBIT_S16_LE | \
  SNDRV_PCM_FMTBIT_S24_LE | \
  SNDRV_PCM_FMTBIT_S32_LE)

#define KIRKWOOD_SPDIF_FORMATS \
 (SNDRV_PCM_FMTBIT_S16_LE | \
  SNDRV_PCM_FMTBIT_S24_LE)

/* These registers are relative to the second register region -
 * audio pll configuration.
 */
#define A38X_PLL_CONF_REG0   0x0
#define     A38X_PLL_FB_CLK_DIV_OFFSET  10
#define     A38X_PLL_FB_CLK_DIV_MASK  0x7fc00
#define A38X_PLL_CONF_REG1   0x4
#define     A38X_PLL_FREQ_OFFSET_MASK  0xffff
#define     A38X_PLL_FREQ_OFFSET_VALID  BIT(16)
#define     A38X_PLL_SW_RESET   BIT(31)
#define A38X_PLL_CONF_REG2   0x8
#define     A38X_PLL_AUDIO_POSTDIV_MASK  0x7f

/* Bit below belongs to SoC control register corresponding to the third
 * register region.
 */
#define A38X_SPDIF_MODE_ENABLE   BIT(27)

static int armada_38x_i2s_init_quirk(struct platform_device *pdev,
         struct kirkwood_dma_data *priv,
         struct snd_soc_dai_driver *dai_drv)
{
 struct device_node *np = pdev->dev.of_node;
 u32 reg_val;
 int i;

 priv->pll_config = devm_platform_ioremap_resource_byname(pdev, "pll_regs");
 if (IS_ERR(priv->pll_config))
  return -ENOMEM;

 priv->soc_control = devm_platform_ioremap_resource_byname(pdev, "soc_ctrl");
 if (IS_ERR(priv->soc_control))
  return -ENOMEM;

 /* Select one of exceptive modes: I2S or S/PDIF */
 reg_val = readl(priv->soc_control);
 if (of_property_read_bool(np, "spdif-mode")) {
  reg_val |= A38X_SPDIF_MODE_ENABLE;
  dev_info(&pdev->dev, "using S/PDIF mode\n");
 } else {
  reg_val &= ~A38X_SPDIF_MODE_ENABLE;
  dev_info(&pdev->dev, "using I2S mode\n");
 }
 writel(reg_val, priv->soc_control);

 /* Update available rates of mclk's fs */
 for (i = 0; i < 2; i++) {
  dai_drv[i].playback.rates |= SNDRV_PCM_RATE_192000;
  dai_drv[i].capture.rates |= SNDRV_PCM_RATE_192000;
 }

 return 0;
}

static inline void armada_38x_set_pll(void __iomem *base, unsigned long rate)
{
 u32 reg_val;
 u16 freq_offset = 0x22b0;
 u8 audio_postdiv, fb_clk_div = 0x1d;

 /* Set frequency offset value to not valid and enable PLL reset */
 reg_val = readl(base + A38X_PLL_CONF_REG1);
 reg_val &= ~A38X_PLL_FREQ_OFFSET_VALID;
 reg_val &= ~A38X_PLL_SW_RESET;
 writel(reg_val, base + A38X_PLL_CONF_REG1);

 udelay(1);

 /* Update PLL parameters */
 switch (rate) {
 default:
 case 44100:
  freq_offset = 0x735;
  fb_clk_div = 0x1b;
  audio_postdiv = 0xc;
  break;
 case 48000:
  audio_postdiv = 0xc;
  break;
 case 96000:
  audio_postdiv = 0x6;
  break;
 case 192000:
  audio_postdiv = 0x3;
  break;
 }

 reg_val = readl(base + A38X_PLL_CONF_REG0);
 reg_val &= ~A38X_PLL_FB_CLK_DIV_MASK;
 reg_val |= (fb_clk_div << A38X_PLL_FB_CLK_DIV_OFFSET);
 writel(reg_val, base + A38X_PLL_CONF_REG0);

 reg_val = readl(base + A38X_PLL_CONF_REG2);
 reg_val &= ~A38X_PLL_AUDIO_POSTDIV_MASK;
 reg_val |= audio_postdiv;
 writel(reg_val, base + A38X_PLL_CONF_REG2);

 reg_val = readl(base + A38X_PLL_CONF_REG1);
 reg_val &= ~A38X_PLL_FREQ_OFFSET_MASK;
 reg_val |= freq_offset;
 writel(reg_val, base + A38X_PLL_CONF_REG1);

 udelay(1);

 /* Disable reset */
 reg_val |= A38X_PLL_SW_RESET;
 writel(reg_val, base + A38X_PLL_CONF_REG1);

 /* Wait 50us for PLL to lock */
 udelay(50);

 /* Restore frequency offset value validity */
 reg_val |= A38X_PLL_FREQ_OFFSET_VALID;
 writel(reg_val, base + A38X_PLL_CONF_REG1);
}

static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
  unsigned int fmt)
{
 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
 unsigned long mask;
 unsigned long value;

 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 case SND_SOC_DAIFMT_RIGHT_J:
  mask = KIRKWOOD_I2S_CTL_RJ;
  break;
 case SND_SOC_DAIFMT_LEFT_J:
  mask = KIRKWOOD_I2S_CTL_LJ;
  break;
 case SND_SOC_DAIFMT_I2S:
  mask = KIRKWOOD_I2S_CTL_I2S;
  break;
 default:
  return -EINVAL;
 }

 /*
 * Set same format for playback and record
 * This avoids some troubles.
 */
 value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
 value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
 value |= mask;
 writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);

 value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
 value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
 value |= mask;
 writel(value, priv->io+KIRKWOOD_I2S_RECCTL);

 return 0;
}

static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
{
 unsigned long value;

 value = KIRKWOOD_DCO_CTL_OFFSET_0;
 switch (rate) {
 default:
 case 44100:
  value |= KIRKWOOD_DCO_CTL_FREQ_11;
  break;
 case 48000:
  value |= KIRKWOOD_DCO_CTL_FREQ_12;
  break;
 case 96000:
  value |= KIRKWOOD_DCO_CTL_FREQ_24;
  break;
 }
 writel(value, io + KIRKWOOD_DCO_CTL);

 /* wait for dco locked */
 do {
  cpu_relax();
  value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
  value &= KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK;
 } while (value == 0);
}

static void kirkwood_set_rate(struct snd_soc_dai *dai,
 struct kirkwood_dma_data *priv, unsigned long rate)
{
 uint32_t clks_ctrl;

 if (IS_ERR(priv->extclk)) {
  /* use internal dco for the supported rates
 * defined in kirkwood_i2s_dai */
  dev_dbg(dai->dev, "%s: dco set rate = %lu\n",
   __func__, rate);
  if (priv->pll_config)
   armada_38x_set_pll(priv->pll_config, rate);
  else
   kirkwood_set_dco(priv->io, rate);

  clks_ctrl = KIRKWOOD_MCLK_SOURCE_DCO;
 } else {
  /* use the external clock for the other rates
 * defined in kirkwood_i2s_dai_extclk */
  dev_dbg(dai->dev, "%s: extclk set rate = %lu -> %lu\n",
   __func__, rate, 256 * rate);
  clk_set_rate(priv->extclk, 256 * rate);

  clks_ctrl = KIRKWOOD_MCLK_SOURCE_EXTCLK;
 }
 writel(clks_ctrl, priv->io + KIRKWOOD_CLOCKS_CTRL);
}

static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
  struct snd_soc_dai *dai)
{
 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);

 snd_soc_dai_set_dma_data(dai, substream, priv);
 return 0;
}

static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
     struct snd_pcm_hw_params *params,
     struct snd_soc_dai *dai)
{
 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
 uint32_t ctl_play, ctl_rec;
 unsigned int i2s_reg;
 unsigned long i2s_value;

 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  i2s_reg = KIRKWOOD_I2S_PLAYCTL;
 } else {
  i2s_reg = KIRKWOOD_I2S_RECCTL;
 }

 kirkwood_set_rate(dai, priv, params_rate(params));

 i2s_value = readl(priv->io+i2s_reg);
 i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;

 /*
 * Size settings in play/rec i2s control regs and play/rec control
 * regs must be the same.
 */
 switch (params_format(params)) {
 case SNDRV_PCM_FORMAT_S16_LE:
  i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
  ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C |
      KIRKWOOD_PLAYCTL_I2S_EN |
      KIRKWOOD_PLAYCTL_SPDIF_EN;
  ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C |
     KIRKWOOD_RECCTL_I2S_EN |
     KIRKWOOD_RECCTL_SPDIF_EN;
  break;
 /*
 * doesn't work... S20_3LE != kirkwood 20bit format ?
 *
case SNDRV_PCM_FORMAT_S20_3LE:
i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 |
   KIRKWOOD_PLAYCTL_I2S_EN;
ctl_rec = KIRKWOOD_RECCTL_SIZE_20 |
  KIRKWOOD_RECCTL_I2S_EN;
break;
*/
 case SNDRV_PCM_FORMAT_S24_LE:
  i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
  ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 |
      KIRKWOOD_PLAYCTL_I2S_EN |
      KIRKWOOD_PLAYCTL_SPDIF_EN;
  ctl_rec = KIRKWOOD_RECCTL_SIZE_24 |
     KIRKWOOD_RECCTL_I2S_EN |
     KIRKWOOD_RECCTL_SPDIF_EN;
  break;
 case SNDRV_PCM_FORMAT_S32_LE:
  i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
  ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 |
      KIRKWOOD_PLAYCTL_I2S_EN;
  ctl_rec = KIRKWOOD_RECCTL_SIZE_32 |
     KIRKWOOD_RECCTL_I2S_EN;
  break;
 default:
  return -EINVAL;
 }

 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
  if (params_channels(params) == 1)
   ctl_play |= KIRKWOOD_PLAYCTL_MONO_BOTH;
  else
   ctl_play |= KIRKWOOD_PLAYCTL_MONO_OFF;

  priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK |
        KIRKWOOD_PLAYCTL_ENABLE_MASK |
        KIRKWOOD_PLAYCTL_SIZE_MASK);
  priv->ctl_play |= ctl_play;
 } else {
  priv->ctl_rec &= ~(KIRKWOOD_RECCTL_ENABLE_MASK |
       KIRKWOOD_RECCTL_SIZE_MASK);
  priv->ctl_rec |= ctl_rec;
 }

 writel(i2s_value, priv->io+i2s_reg);

 return 0;
}

static unsigned kirkwood_i2s_play_mute(unsigned ctl)
{
 if (!(ctl & KIRKWOOD_PLAYCTL_I2S_EN))
  ctl |= KIRKWOOD_PLAYCTL_I2S_MUTE;
 if (!(ctl & KIRKWOOD_PLAYCTL_SPDIF_EN))
  ctl |= KIRKWOOD_PLAYCTL_SPDIF_MUTE;
 return ctl;
}

static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
    int cmd, struct snd_soc_dai *dai)
{
 struct snd_pcm_runtime *runtime = substream->runtime;
 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
 uint32_t ctl, value;

 ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
 if ((ctl & KIRKWOOD_PLAYCTL_ENABLE_MASK) == 0) {
  unsigned timeout = 5000;
  /*
 * The Armada510 spec says that if we enter pause mode, the
 * busy bit must be read back as clear _twice_.  Make sure
 * we respect that otherwise we get DMA underruns.
 */
  do {
   value = ctl;
   ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
   if (!((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
    break;
   udelay(1);
  } while (timeout--);

  if ((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
   dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
       ctl);
 }

 switch (cmd) {
 case SNDRV_PCM_TRIGGER_START:
  /* configure */
  ctl = priv->ctl_play;
  if (dai->id == 0)
   ctl &= ~KIRKWOOD_PLAYCTL_SPDIF_EN; /* i2s */
  else
   ctl &= ~KIRKWOOD_PLAYCTL_I2S_EN; /* spdif */
  ctl = kirkwood_i2s_play_mute(ctl);
  value = ctl & ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
  writel(value, priv->io + KIRKWOOD_PLAYCTL);

  /* enable interrupts */
  if (!runtime->no_period_wakeup) {
   value = readl(priv->io + KIRKWOOD_INT_MASK);
   value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
   writel(value, priv->io + KIRKWOOD_INT_MASK);
  }

  /* enable playback */
  writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  break;

 case SNDRV_PCM_TRIGGER_STOP:
  /* stop audio, disable interrupts */
  ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
    KIRKWOOD_PLAYCTL_SPDIF_MUTE;
  writel(ctl, priv->io + KIRKWOOD_PLAYCTL);

  value = readl(priv->io + KIRKWOOD_INT_MASK);
  value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
  writel(value, priv->io + KIRKWOOD_INT_MASK);

  /* disable all playbacks */
  ctl &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
  writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  break;

 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 case SNDRV_PCM_TRIGGER_SUSPEND:
  ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
    KIRKWOOD_PLAYCTL_SPDIF_MUTE;
  writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  break;

 case SNDRV_PCM_TRIGGER_RESUME:
 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
    KIRKWOOD_PLAYCTL_SPDIF_MUTE);
  ctl = kirkwood_i2s_play_mute(ctl);
  writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
  break;

 default:
  return -EINVAL;
 }

 return 0;
}

static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
    int cmd, struct snd_soc_dai *dai)
{
 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
 uint32_t ctl, value;

 value = readl(priv->io + KIRKWOOD_RECCTL);

 switch (cmd) {
 case SNDRV_PCM_TRIGGER_START:
  /* configure */
  ctl = priv->ctl_rec;
  if (dai->id == 0)
   ctl &= ~KIRKWOOD_RECCTL_SPDIF_EN; /* i2s */
  else
   ctl &= ~KIRKWOOD_RECCTL_I2S_EN;  /* spdif */

  value = ctl & ~KIRKWOOD_RECCTL_ENABLE_MASK;
  writel(value, priv->io + KIRKWOOD_RECCTL);

  /* enable interrupts */
  value = readl(priv->io + KIRKWOOD_INT_MASK);
  value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
  writel(value, priv->io + KIRKWOOD_INT_MASK);

  /* enable record */
  writel(ctl, priv->io + KIRKWOOD_RECCTL);
  break;

 case SNDRV_PCM_TRIGGER_STOP:
  /* stop audio, disable interrupts */
  value = readl(priv->io + KIRKWOOD_RECCTL);
  value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
  writel(value, priv->io + KIRKWOOD_RECCTL);

  value = readl(priv->io + KIRKWOOD_INT_MASK);
  value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
  writel(value, priv->io + KIRKWOOD_INT_MASK);

  /* disable all records */
  value = readl(priv->io + KIRKWOOD_RECCTL);
  value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
  writel(value, priv->io + KIRKWOOD_RECCTL);
  break;

 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 case SNDRV_PCM_TRIGGER_SUSPEND:
  value = readl(priv->io + KIRKWOOD_RECCTL);
  value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
  writel(value, priv->io + KIRKWOOD_RECCTL);
  break;

 case SNDRV_PCM_TRIGGER_RESUME:
 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
  value = readl(priv->io + KIRKWOOD_RECCTL);
  value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
  writel(value, priv->io + KIRKWOOD_RECCTL);
  break;

 default:
  return -EINVAL;
 }

 return 0;
}

static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
          struct snd_soc_dai *dai)
{
 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
  return kirkwood_i2s_play_trigger(substream, cmd, dai);
 else
  return kirkwood_i2s_rec_trigger(substream, cmd, dai);

 return 0;
}

static int kirkwood_i2s_init(struct kirkwood_dma_data *priv)
{
 unsigned long value;
 unsigned int reg_data;

 /* put system in a "safe" state : */
 /* disable audio interrupts */
 writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
 writel(0, priv->io + KIRKWOOD_INT_MASK);

 reg_data = readl(priv->io + 0x1200);
 reg_data &= (~(0x333FF8));
 reg_data |= 0x111D18;
 writel(reg_data, priv->io + 0x1200);

 msleep(500);

 reg_data = readl(priv->io + 0x1200);
 reg_data &= (~(0x333FF8));
 reg_data |= 0x111D18;
 writel(reg_data, priv->io + 0x1200);

 /* disable playback/record */
 value = readl(priv->io + KIRKWOOD_PLAYCTL);
 value &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
 writel(value, priv->io + KIRKWOOD_PLAYCTL);

 value = readl(priv->io + KIRKWOOD_RECCTL);
 value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
 writel(value, priv->io + KIRKWOOD_RECCTL);

 return 0;

}

static const struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
 .startup = kirkwood_i2s_startup,
 .trigger = kirkwood_i2s_trigger,
 .hw_params      = kirkwood_i2s_hw_params,
 .set_fmt        = kirkwood_i2s_set_fmt,
};

static struct snd_soc_dai_driver kirkwood_i2s_dai[2] = {
    {
 .name = "i2s",
 .id = 0,
 .playback = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    SNDRV_PCM_RATE_96000,
  .formats = KIRKWOOD_I2S_FORMATS,
 },
 .capture = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    SNDRV_PCM_RATE_96000,
  .formats = KIRKWOOD_I2S_FORMATS,
 },
 .ops = &kirkwood_i2s_dai_ops,
    },
    {
 .name = "spdif",
 .id = 1,
 .playback = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    SNDRV_PCM_RATE_96000,
  .formats = KIRKWOOD_SPDIF_FORMATS,
 },
 .capture = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
    SNDRV_PCM_RATE_96000,
  .formats = KIRKWOOD_SPDIF_FORMATS,
 },
 .ops = &kirkwood_i2s_dai_ops,
    },
};

static struct snd_soc_dai_driver kirkwood_i2s_dai_extclk[2] = {
    {
 .name = "i2s",
 .id = 0,
 .playback = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_CONTINUOUS,
  .rate_min = 5512,
  .rate_max = 192000,
  .formats = KIRKWOOD_I2S_FORMATS,
 },
 .capture = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_CONTINUOUS,
  .rate_min = 5512,
  .rate_max = 192000,
  .formats = KIRKWOOD_I2S_FORMATS,
 },
 .ops = &kirkwood_i2s_dai_ops,
    },
    {
 .name = "spdif",
 .id = 1,
 .playback = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_CONTINUOUS,
  .rate_min = 5512,
  .rate_max = 192000,
  .formats = KIRKWOOD_SPDIF_FORMATS,
 },
 .capture = {
  .channels_min = 1,
  .channels_max = 2,
  .rates = SNDRV_PCM_RATE_CONTINUOUS,
  .rate_min = 5512,
  .rate_max = 192000,
  .formats = KIRKWOOD_SPDIF_FORMATS,
 },
 .ops = &kirkwood_i2s_dai_ops,
    },
};

static int kirkwood_i2s_dev_probe(struct platform_device *pdev)
{
 struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data;
 struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai;
 struct kirkwood_dma_data *priv;
 struct device_node *np = pdev->dev.of_node;
 int err;

 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 if (!priv)
  return -ENOMEM;

 dev_set_drvdata(&pdev->dev, priv);

 if (of_device_is_compatible(np, "marvell,armada-380-audio"))
  priv->io = devm_platform_ioremap_resource_byname(pdev, "i2s_regs");
 else
  priv->io = devm_platform_ioremap_resource(pdev, 0);
 if (IS_ERR(priv->io))
  return PTR_ERR(priv->io);

 priv->irq = platform_get_irq(pdev, 0);
 if (priv->irq < 0)
  return priv->irq;

 if (of_device_is_compatible(np, "marvell,armada-380-audio")) {
  err = armada_38x_i2s_init_quirk(pdev, priv, soc_dai);
  if (err < 0)
   return err;
  /* Set initial pll frequency */
  armada_38x_set_pll(priv->pll_config, 44100);
 }

 if (np) {
  priv->burst = 128;  /* might be 32 or 128 */
 } else if (data) {
  priv->burst = data->burst;
 } else {
  dev_err(&pdev->dev, "no DT nor platform data ?!\n");
  return -EINVAL;
 }

 priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL);
 if (IS_ERR(priv->clk)) {
  dev_err(&pdev->dev, "no clock\n");
  return PTR_ERR(priv->clk);
 }

 priv->extclk = devm_clk_get(&pdev->dev, "extclk");
 if (IS_ERR(priv->extclk)) {
  if (PTR_ERR(priv->extclk) == -EPROBE_DEFER)
   return -EPROBE_DEFER;
 } else {
  if (clk_is_match(priv->extclk, priv->clk)) {
   devm_clk_put(&pdev->dev, priv->extclk);
   priv->extclk = ERR_PTR(-EINVAL);
  } else {
   dev_info(&pdev->dev, "found external clock\n");
   clk_prepare_enable(priv->extclk);
   soc_dai = kirkwood_i2s_dai_extclk;
  }
 }

 err = clk_prepare_enable(priv->clk);
 if (err < 0)
  return err;

 /* Some sensible defaults - this reflects the powerup values */
 priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
 priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;

 /* Select the burst size */
 if (priv->burst == 32) {
  priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32;
  priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32;
 } else {
  priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128;
  priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128;
 }

 err = snd_soc_register_component(&pdev->dev, &kirkwood_soc_component,
      soc_dai, 2);
 if (err) {
  dev_err(&pdev->dev, "snd_soc_register_component failed\n");
  goto err_component;
 }

 kirkwood_i2s_init(priv);

 return 0;

 err_component:
 if (!IS_ERR(priv->extclk))
  clk_disable_unprepare(priv->extclk);
 clk_disable_unprepare(priv->clk);

 return err;
}

static void kirkwood_i2s_dev_remove(struct platform_device *pdev)
{
 struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);

 snd_soc_unregister_component(&pdev->dev);
 if (!IS_ERR(priv->extclk))
  clk_disable_unprepare(priv->extclk);
 clk_disable_unprepare(priv->clk);
}

#ifdef CONFIG_OF
static const struct of_device_id mvebu_audio_of_match[] = {
 { .compatible = "marvell,kirkwood-audio" },
 { .compatible = "marvell,dove-audio" },
 { .compatible = "marvell,armada370-audio" },
 { .compatible = "marvell,armada-380-audio" },
 { }
};
MODULE_DEVICE_TABLE(of, mvebu_audio_of_match);
#endif

static struct platform_driver kirkwood_i2s_driver = {
 .probe  = kirkwood_i2s_dev_probe,
 .remove = kirkwood_i2s_dev_remove,
 .driver = {
  .name = DRV_NAME,
  .of_match_table = of_match_ptr(mvebu_audio_of_match),
 },
};

module_platform_driver(kirkwood_i2s_driver);

/* Module information */
MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:mvebu-audio");