mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
646 lines
16 KiB
646 lines
16 KiB
// SPDX-License-Identifier: GPL-2.0-or-later |
|
/* |
|
* kirkwood-i2s.c |
|
* |
|
* (c) 2010 Arnaud Patard <[email protected]> |
|
* (c) 2010 Arnaud Patard <[email protected]> |
|
*/ |
|
|
|
#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) |
|
|
|
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); |
|
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); |
|
|
|
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 (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 int 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); |
|
|
|
return 0; |
|
} |
|
|
|
#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" }, |
|
{ } |
|
}; |
|
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, <[email protected]>"); |
|
MODULE_DESCRIPTION("Kirkwood I2S SoC Interface"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_ALIAS("platform:mvebu-audio");
|
|
|