4 * (c) 2010 Arnaud Patard <apatard@mandriva.com>
5 * (c) 2010 Arnaud Patard <arnaud.patard@rtp-net.org>
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms of the GNU General Public License as published by the
9 * Free Software Foundation; either version 2 of the License, or (at your
10 * option) any later version.
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
17 #include <linux/slab.h>
18 #include <linux/mbus.h>
19 #include <linux/delay.h>
20 #include <linux/clk.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <linux/platform_data/asoc-kirkwood.h>
29 #define KIRKWOOD_I2S_FORMATS \
30 (SNDRV_PCM_FMTBIT_S16_LE | \
31 SNDRV_PCM_FMTBIT_S24_LE | \
32 SNDRV_PCM_FMTBIT_S32_LE)
34 #define KIRKWOOD_SPDIF_FORMATS \
35 (SNDRV_PCM_FMTBIT_S16_LE | \
36 SNDRV_PCM_FMTBIT_S24_LE)
38 static int kirkwood_i2s_set_fmt(struct snd_soc_dai *cpu_dai,
41 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(cpu_dai);
45 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
46 case SND_SOC_DAIFMT_RIGHT_J:
47 mask = KIRKWOOD_I2S_CTL_RJ;
49 case SND_SOC_DAIFMT_LEFT_J:
50 mask = KIRKWOOD_I2S_CTL_LJ;
52 case SND_SOC_DAIFMT_I2S:
53 mask = KIRKWOOD_I2S_CTL_I2S;
60 * Set same format for playback and record
61 * This avoids some troubles.
63 value = readl(priv->io+KIRKWOOD_I2S_PLAYCTL);
64 value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
66 writel(value, priv->io+KIRKWOOD_I2S_PLAYCTL);
68 value = readl(priv->io+KIRKWOOD_I2S_RECCTL);
69 value &= ~KIRKWOOD_I2S_CTL_JUST_MASK;
71 writel(value, priv->io+KIRKWOOD_I2S_RECCTL);
76 static inline void kirkwood_set_dco(void __iomem *io, unsigned long rate)
80 value = KIRKWOOD_DCO_CTL_OFFSET_0;
84 value |= KIRKWOOD_DCO_CTL_FREQ_11;
87 value |= KIRKWOOD_DCO_CTL_FREQ_12;
90 value |= KIRKWOOD_DCO_CTL_FREQ_24;
93 writel(value, io + KIRKWOOD_DCO_CTL);
95 /* wait for dco locked */
98 value = readl(io + KIRKWOOD_DCO_SPCR_STATUS);
99 value &= KIRKWOOD_DCO_SPCR_STATUS_DCO_LOCK;
100 } while (value == 0);
103 static void kirkwood_set_rate(struct snd_soc_dai *dai,
104 struct kirkwood_dma_data *priv, unsigned long rate)
108 if (IS_ERR(priv->extclk)) {
109 /* use internal dco for the supported rates
110 * defined in kirkwood_i2s_dai */
111 dev_dbg(dai->dev, "%s: dco set rate = %lu\n",
113 kirkwood_set_dco(priv->io, rate);
115 clks_ctrl = KIRKWOOD_MCLK_SOURCE_DCO;
117 /* use the external clock for the other rates
118 * defined in kirkwood_i2s_dai_extclk */
119 dev_dbg(dai->dev, "%s: extclk set rate = %lu -> %lu\n",
120 __func__, rate, 256 * rate);
121 clk_set_rate(priv->extclk, 256 * rate);
123 clks_ctrl = KIRKWOOD_MCLK_SOURCE_EXTCLK;
125 writel(clks_ctrl, priv->io + KIRKWOOD_CLOCKS_CTRL);
128 static int kirkwood_i2s_startup(struct snd_pcm_substream *substream,
129 struct snd_soc_dai *dai)
131 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
133 snd_soc_dai_set_dma_data(dai, substream, priv);
137 static int kirkwood_i2s_hw_params(struct snd_pcm_substream *substream,
138 struct snd_pcm_hw_params *params,
139 struct snd_soc_dai *dai)
141 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
142 uint32_t ctl_play, ctl_rec;
143 unsigned int i2s_reg;
144 unsigned long i2s_value;
146 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
147 i2s_reg = KIRKWOOD_I2S_PLAYCTL;
149 i2s_reg = KIRKWOOD_I2S_RECCTL;
152 kirkwood_set_rate(dai, priv, params_rate(params));
154 i2s_value = readl(priv->io+i2s_reg);
155 i2s_value &= ~KIRKWOOD_I2S_CTL_SIZE_MASK;
158 * Size settings in play/rec i2s control regs and play/rec control
159 * regs must be the same.
161 switch (params_format(params)) {
162 case SNDRV_PCM_FORMAT_S16_LE:
163 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_16;
164 ctl_play = KIRKWOOD_PLAYCTL_SIZE_16_C |
165 KIRKWOOD_PLAYCTL_I2S_EN |
166 KIRKWOOD_PLAYCTL_SPDIF_EN;
167 ctl_rec = KIRKWOOD_RECCTL_SIZE_16_C |
168 KIRKWOOD_RECCTL_I2S_EN |
169 KIRKWOOD_RECCTL_SPDIF_EN;
172 * doesn't work... S20_3LE != kirkwood 20bit format ?
174 case SNDRV_PCM_FORMAT_S20_3LE:
175 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_20;
176 ctl_play = KIRKWOOD_PLAYCTL_SIZE_20 |
177 KIRKWOOD_PLAYCTL_I2S_EN;
178 ctl_rec = KIRKWOOD_RECCTL_SIZE_20 |
179 KIRKWOOD_RECCTL_I2S_EN;
182 case SNDRV_PCM_FORMAT_S24_LE:
183 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_24;
184 ctl_play = KIRKWOOD_PLAYCTL_SIZE_24 |
185 KIRKWOOD_PLAYCTL_I2S_EN |
186 KIRKWOOD_PLAYCTL_SPDIF_EN;
187 ctl_rec = KIRKWOOD_RECCTL_SIZE_24 |
188 KIRKWOOD_RECCTL_I2S_EN |
189 KIRKWOOD_RECCTL_SPDIF_EN;
191 case SNDRV_PCM_FORMAT_S32_LE:
192 i2s_value |= KIRKWOOD_I2S_CTL_SIZE_32;
193 ctl_play = KIRKWOOD_PLAYCTL_SIZE_32 |
194 KIRKWOOD_PLAYCTL_I2S_EN;
195 ctl_rec = KIRKWOOD_RECCTL_SIZE_32 |
196 KIRKWOOD_RECCTL_I2S_EN;
202 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
203 if (params_channels(params) == 1)
204 ctl_play |= KIRKWOOD_PLAYCTL_MONO_BOTH;
206 ctl_play |= KIRKWOOD_PLAYCTL_MONO_OFF;
208 priv->ctl_play &= ~(KIRKWOOD_PLAYCTL_MONO_MASK |
209 KIRKWOOD_PLAYCTL_ENABLE_MASK |
210 KIRKWOOD_PLAYCTL_SIZE_MASK);
211 priv->ctl_play |= ctl_play;
213 priv->ctl_rec &= ~(KIRKWOOD_RECCTL_ENABLE_MASK |
214 KIRKWOOD_RECCTL_SIZE_MASK);
215 priv->ctl_rec |= ctl_rec;
218 writel(i2s_value, priv->io+i2s_reg);
223 static unsigned kirkwood_i2s_play_mute(unsigned ctl)
225 if (!(ctl & KIRKWOOD_PLAYCTL_I2S_EN))
226 ctl |= KIRKWOOD_PLAYCTL_I2S_MUTE;
227 if (!(ctl & KIRKWOOD_PLAYCTL_SPDIF_EN))
228 ctl |= KIRKWOOD_PLAYCTL_SPDIF_MUTE;
232 static int kirkwood_i2s_play_trigger(struct snd_pcm_substream *substream,
233 int cmd, struct snd_soc_dai *dai)
235 struct snd_pcm_runtime *runtime = substream->runtime;
236 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
239 ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
240 if ((ctl & KIRKWOOD_PLAYCTL_ENABLE_MASK) == 0) {
241 unsigned timeout = 5000;
243 * The Armada510 spec says that if we enter pause mode, the
244 * busy bit must be read back as clear _twice_. Make sure
245 * we respect that otherwise we get DMA underruns.
249 ctl = readl(priv->io + KIRKWOOD_PLAYCTL);
250 if (!((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY))
255 if ((ctl | value) & KIRKWOOD_PLAYCTL_PLAY_BUSY)
256 dev_notice(dai->dev, "timed out waiting for busy to deassert: %08x\n",
261 case SNDRV_PCM_TRIGGER_START:
263 ctl = priv->ctl_play;
265 ctl &= ~KIRKWOOD_PLAYCTL_SPDIF_EN; /* i2s */
267 ctl &= ~KIRKWOOD_PLAYCTL_I2S_EN; /* spdif */
268 ctl = kirkwood_i2s_play_mute(ctl);
269 value = ctl & ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
270 writel(value, priv->io + KIRKWOOD_PLAYCTL);
272 /* enable interrupts */
273 if (!runtime->no_period_wakeup) {
274 value = readl(priv->io + KIRKWOOD_INT_MASK);
275 value |= KIRKWOOD_INT_CAUSE_PLAY_BYTES;
276 writel(value, priv->io + KIRKWOOD_INT_MASK);
279 /* enable playback */
280 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
283 case SNDRV_PCM_TRIGGER_STOP:
284 /* stop audio, disable interrupts */
285 ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
286 KIRKWOOD_PLAYCTL_SPDIF_MUTE;
287 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
289 value = readl(priv->io + KIRKWOOD_INT_MASK);
290 value &= ~KIRKWOOD_INT_CAUSE_PLAY_BYTES;
291 writel(value, priv->io + KIRKWOOD_INT_MASK);
293 /* disable all playbacks */
294 ctl &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
295 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
298 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
299 case SNDRV_PCM_TRIGGER_SUSPEND:
300 ctl |= KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
301 KIRKWOOD_PLAYCTL_SPDIF_MUTE;
302 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
305 case SNDRV_PCM_TRIGGER_RESUME:
306 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
307 ctl &= ~(KIRKWOOD_PLAYCTL_PAUSE | KIRKWOOD_PLAYCTL_I2S_MUTE |
308 KIRKWOOD_PLAYCTL_SPDIF_MUTE);
309 ctl = kirkwood_i2s_play_mute(ctl);
310 writel(ctl, priv->io + KIRKWOOD_PLAYCTL);
320 static int kirkwood_i2s_rec_trigger(struct snd_pcm_substream *substream,
321 int cmd, struct snd_soc_dai *dai)
323 struct kirkwood_dma_data *priv = snd_soc_dai_get_drvdata(dai);
326 value = readl(priv->io + KIRKWOOD_RECCTL);
329 case SNDRV_PCM_TRIGGER_START:
333 ctl &= ~KIRKWOOD_RECCTL_SPDIF_EN; /* i2s */
335 ctl &= ~KIRKWOOD_RECCTL_I2S_EN; /* spdif */
337 value = ctl & ~KIRKWOOD_RECCTL_ENABLE_MASK;
338 writel(value, priv->io + KIRKWOOD_RECCTL);
340 /* enable interrupts */
341 value = readl(priv->io + KIRKWOOD_INT_MASK);
342 value |= KIRKWOOD_INT_CAUSE_REC_BYTES;
343 writel(value, priv->io + KIRKWOOD_INT_MASK);
346 writel(ctl, priv->io + KIRKWOOD_RECCTL);
349 case SNDRV_PCM_TRIGGER_STOP:
350 /* stop audio, disable interrupts */
351 value = readl(priv->io + KIRKWOOD_RECCTL);
352 value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
353 writel(value, priv->io + KIRKWOOD_RECCTL);
355 value = readl(priv->io + KIRKWOOD_INT_MASK);
356 value &= ~KIRKWOOD_INT_CAUSE_REC_BYTES;
357 writel(value, priv->io + KIRKWOOD_INT_MASK);
359 /* disable all records */
360 value = readl(priv->io + KIRKWOOD_RECCTL);
361 value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
362 writel(value, priv->io + KIRKWOOD_RECCTL);
365 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
366 case SNDRV_PCM_TRIGGER_SUSPEND:
367 value = readl(priv->io + KIRKWOOD_RECCTL);
368 value |= KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE;
369 writel(value, priv->io + KIRKWOOD_RECCTL);
372 case SNDRV_PCM_TRIGGER_RESUME:
373 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
374 value = readl(priv->io + KIRKWOOD_RECCTL);
375 value &= ~(KIRKWOOD_RECCTL_PAUSE | KIRKWOOD_RECCTL_MUTE);
376 writel(value, priv->io + KIRKWOOD_RECCTL);
386 static int kirkwood_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
387 struct snd_soc_dai *dai)
389 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
390 return kirkwood_i2s_play_trigger(substream, cmd, dai);
392 return kirkwood_i2s_rec_trigger(substream, cmd, dai);
397 static int kirkwood_i2s_init(struct kirkwood_dma_data *priv)
400 unsigned int reg_data;
402 /* put system in a "safe" state : */
403 /* disable audio interrupts */
404 writel(0xffffffff, priv->io + KIRKWOOD_INT_CAUSE);
405 writel(0, priv->io + KIRKWOOD_INT_MASK);
407 reg_data = readl(priv->io + 0x1200);
408 reg_data &= (~(0x333FF8));
409 reg_data |= 0x111D18;
410 writel(reg_data, priv->io + 0x1200);
414 reg_data = readl(priv->io + 0x1200);
415 reg_data &= (~(0x333FF8));
416 reg_data |= 0x111D18;
417 writel(reg_data, priv->io + 0x1200);
419 /* disable playback/record */
420 value = readl(priv->io + KIRKWOOD_PLAYCTL);
421 value &= ~KIRKWOOD_PLAYCTL_ENABLE_MASK;
422 writel(value, priv->io + KIRKWOOD_PLAYCTL);
424 value = readl(priv->io + KIRKWOOD_RECCTL);
425 value &= ~KIRKWOOD_RECCTL_ENABLE_MASK;
426 writel(value, priv->io + KIRKWOOD_RECCTL);
432 static const struct snd_soc_dai_ops kirkwood_i2s_dai_ops = {
433 .startup = kirkwood_i2s_startup,
434 .trigger = kirkwood_i2s_trigger,
435 .hw_params = kirkwood_i2s_hw_params,
436 .set_fmt = kirkwood_i2s_set_fmt,
439 static struct snd_soc_dai_driver kirkwood_i2s_dai[2] = {
446 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
447 SNDRV_PCM_RATE_96000,
448 .formats = KIRKWOOD_I2S_FORMATS,
453 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
454 SNDRV_PCM_RATE_96000,
455 .formats = KIRKWOOD_I2S_FORMATS,
457 .ops = &kirkwood_i2s_dai_ops,
465 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
466 SNDRV_PCM_RATE_96000,
467 .formats = KIRKWOOD_SPDIF_FORMATS,
472 .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
473 SNDRV_PCM_RATE_96000,
474 .formats = KIRKWOOD_SPDIF_FORMATS,
476 .ops = &kirkwood_i2s_dai_ops,
480 static struct snd_soc_dai_driver kirkwood_i2s_dai_extclk[2] = {
487 .rates = SNDRV_PCM_RATE_CONTINUOUS,
490 .formats = KIRKWOOD_I2S_FORMATS,
495 .rates = SNDRV_PCM_RATE_CONTINUOUS,
498 .formats = KIRKWOOD_I2S_FORMATS,
500 .ops = &kirkwood_i2s_dai_ops,
508 .rates = SNDRV_PCM_RATE_CONTINUOUS,
511 .formats = KIRKWOOD_SPDIF_FORMATS,
516 .rates = SNDRV_PCM_RATE_CONTINUOUS,
519 .formats = KIRKWOOD_SPDIF_FORMATS,
521 .ops = &kirkwood_i2s_dai_ops,
525 static int kirkwood_i2s_dev_probe(struct platform_device *pdev)
527 struct kirkwood_asoc_platform_data *data = pdev->dev.platform_data;
528 struct snd_soc_dai_driver *soc_dai = kirkwood_i2s_dai;
529 struct kirkwood_dma_data *priv;
530 struct resource *mem;
531 struct device_node *np = pdev->dev.of_node;
534 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
538 dev_set_drvdata(&pdev->dev, priv);
540 mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
541 priv->io = devm_ioremap_resource(&pdev->dev, mem);
542 if (IS_ERR(priv->io))
543 return PTR_ERR(priv->io);
545 priv->irq = platform_get_irq(pdev, 0);
547 dev_err(&pdev->dev, "platform_get_irq failed: %d\n", priv->irq);
552 priv->burst = 128; /* might be 32 or 128 */
554 priv->burst = data->burst;
556 dev_err(&pdev->dev, "no DT nor platform data ?!\n");
560 priv->clk = devm_clk_get(&pdev->dev, np ? "internal" : NULL);
561 if (IS_ERR(priv->clk)) {
562 dev_err(&pdev->dev, "no clock\n");
563 return PTR_ERR(priv->clk);
566 priv->extclk = devm_clk_get(&pdev->dev, "extclk");
567 if (IS_ERR(priv->extclk)) {
568 if (PTR_ERR(priv->extclk) == -EPROBE_DEFER)
569 return -EPROBE_DEFER;
571 if (clk_is_match(priv->extclk, priv->clk)) {
572 devm_clk_put(&pdev->dev, priv->extclk);
573 priv->extclk = ERR_PTR(-EINVAL);
575 dev_info(&pdev->dev, "found external clock\n");
576 clk_prepare_enable(priv->extclk);
577 soc_dai = kirkwood_i2s_dai_extclk;
581 err = clk_prepare_enable(priv->clk);
585 /* Some sensible defaults - this reflects the powerup values */
586 priv->ctl_play = KIRKWOOD_PLAYCTL_SIZE_24;
587 priv->ctl_rec = KIRKWOOD_RECCTL_SIZE_24;
589 /* Select the burst size */
590 if (priv->burst == 32) {
591 priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_32;
592 priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_32;
594 priv->ctl_play |= KIRKWOOD_PLAYCTL_BURST_128;
595 priv->ctl_rec |= KIRKWOOD_RECCTL_BURST_128;
598 err = snd_soc_register_component(&pdev->dev, &kirkwood_soc_component,
601 dev_err(&pdev->dev, "snd_soc_register_component failed\n");
605 kirkwood_i2s_init(priv);
610 if (!IS_ERR(priv->extclk))
611 clk_disable_unprepare(priv->extclk);
612 clk_disable_unprepare(priv->clk);
617 static int kirkwood_i2s_dev_remove(struct platform_device *pdev)
619 struct kirkwood_dma_data *priv = dev_get_drvdata(&pdev->dev);
621 snd_soc_unregister_component(&pdev->dev);
622 if (!IS_ERR(priv->extclk))
623 clk_disable_unprepare(priv->extclk);
624 clk_disable_unprepare(priv->clk);
630 static const struct of_device_id mvebu_audio_of_match[] = {
631 { .compatible = "marvell,kirkwood-audio" },
632 { .compatible = "marvell,dove-audio" },
633 { .compatible = "marvell,armada370-audio" },
636 MODULE_DEVICE_TABLE(of, mvebu_audio_of_match);
639 static struct platform_driver kirkwood_i2s_driver = {
640 .probe = kirkwood_i2s_dev_probe,
641 .remove = kirkwood_i2s_dev_remove,
644 .of_match_table = of_match_ptr(mvebu_audio_of_match),
648 module_platform_driver(kirkwood_i2s_driver);
650 /* Module information */
651 MODULE_AUTHOR("Arnaud Patard, <arnaud.patard@rtp-net.org>");
652 MODULE_DESCRIPTION("Kirkwood I2S SoC Interface");
653 MODULE_LICENSE("GPL");
654 MODULE_ALIAS("platform:mvebu-audio");