2 * ALSA SoC I2S Audio Layer for the Stretch S6000 family
4 * Author: Daniel Gloeckner, <dg@emlix.com>
5 * Copyright: (C) 2009 emlix GmbH <info@emlix.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/init.h>
13 #include <linux/module.h>
14 #include <linux/device.h>
15 #include <linux/delay.h>
16 #include <linux/clk.h>
17 #include <linux/interrupt.h>
19 #include <linux/slab.h>
21 #include <sound/core.h>
22 #include <sound/pcm.h>
23 #include <sound/pcm_params.h>
24 #include <sound/initval.h>
25 #include <sound/soc.h>
27 #include "s6000-i2s.h"
28 #include "s6000-pcm.h"
30 struct s6000_i2s_dev {
34 unsigned int channel_in;
35 unsigned int channel_out;
36 unsigned int lines_in;
37 unsigned int lines_out;
38 struct s6000_pcm_dma_params dma_params;
41 #define S6_I2S_INTERRUPT_STATUS 0x00
42 #define S6_I2S_INT_OVERRUN 1
43 #define S6_I2S_INT_UNDERRUN 2
44 #define S6_I2S_INT_ALIGNMENT 4
45 #define S6_I2S_INTERRUPT_ENABLE 0x04
46 #define S6_I2S_INTERRUPT_RAW 0x08
47 #define S6_I2S_INTERRUPT_CLEAR 0x0C
48 #define S6_I2S_INTERRUPT_SET 0x10
49 #define S6_I2S_MODE 0x20
52 #define S6_I2S_TX_DEFAULT 0x24
53 #define S6_I2S_DATA_CFG(c) (0x40 + 0x10 * (c))
56 #define S6_I2S_UNUSED 2
57 #define S6_I2S_INTERFACE_CFG(c) (0x44 + 0x10 * (c))
58 #define S6_I2S_DIV_MASK 0x001fff
59 #define S6_I2S_16BIT 0x000000
60 #define S6_I2S_20BIT 0x002000
61 #define S6_I2S_24BIT 0x004000
62 #define S6_I2S_32BIT 0x006000
63 #define S6_I2S_BITS_MASK 0x006000
64 #define S6_I2S_MEM_16BIT 0x000000
65 #define S6_I2S_MEM_32BIT 0x008000
66 #define S6_I2S_MEM_MASK 0x008000
67 #define S6_I2S_CHANNELS_SHIFT 16
68 #define S6_I2S_CHANNELS_MASK 0x030000
69 #define S6_I2S_SCK_IN 0x000000
70 #define S6_I2S_SCK_OUT 0x040000
71 #define S6_I2S_SCK_DIR 0x040000
72 #define S6_I2S_WS_IN 0x000000
73 #define S6_I2S_WS_OUT 0x080000
74 #define S6_I2S_WS_DIR 0x080000
75 #define S6_I2S_LEFT_FIRST 0x000000
76 #define S6_I2S_RIGHT_FIRST 0x100000
77 #define S6_I2S_FIRST 0x100000
78 #define S6_I2S_CUR_SCK 0x200000
79 #define S6_I2S_CUR_WS 0x400000
80 #define S6_I2S_ENABLE(c) (0x48 + 0x10 * (c))
81 #define S6_I2S_DISABLE_IF 0x02
82 #define S6_I2S_ENABLE_IF 0x03
83 #define S6_I2S_IS_BUSY 0x04
84 #define S6_I2S_DMA_ACTIVE 0x08
85 #define S6_I2S_IS_ENABLED 0x10
87 #define S6_I2S_NUM_LINES 4
89 #define S6_I2S_SIF_PORT0 0x0000000
90 #define S6_I2S_SIF_PORT1 0x0000080 /* docs say 0x0000010 */
92 static inline void s6_i2s_write_reg(struct s6000_i2s_dev *dev, int reg, u32 val)
94 writel(val, dev->scbbase + reg);
97 static inline u32 s6_i2s_read_reg(struct s6000_i2s_dev *dev, int reg)
99 return readl(dev->scbbase + reg);
102 static inline void s6_i2s_mod_reg(struct s6000_i2s_dev *dev, int reg,
105 val ^= s6_i2s_read_reg(dev, reg) & ~mask;
106 s6_i2s_write_reg(dev, reg, val);
109 static void s6000_i2s_start_channel(struct s6000_i2s_dev *dev, int channel)
114 * Wait for WCLK to toggle 5 times before enabling the channel
115 * s6000 Family Datasheet 3.6.4:
116 * "At least two cycles of WS must occur between commands
117 * to disable or enable the interface"
120 prev = ~S6_I2S_CUR_WS;
121 for (i = 1000000; --i && j < 6; ) {
122 cur = s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(channel))
130 printk(KERN_WARNING "s6000-i2s: timeout waiting for WCLK\n");
132 s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_ENABLE_IF);
135 static void s6000_i2s_stop_channel(struct s6000_i2s_dev *dev, int channel)
137 s6_i2s_write_reg(dev, S6_I2S_ENABLE(channel), S6_I2S_DISABLE_IF);
140 static void s6000_i2s_start(struct snd_pcm_substream *substream)
142 struct snd_soc_pcm_runtime *rtd = substream->private_data;
143 struct s6000_i2s_dev *dev = rtd->dai->cpu_dai->private_data;
146 channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
147 dev->channel_out : dev->channel_in;
149 s6000_i2s_start_channel(dev, channel);
152 static void s6000_i2s_stop(struct snd_pcm_substream *substream)
154 struct snd_soc_pcm_runtime *rtd = substream->private_data;
155 struct s6000_i2s_dev *dev = rtd->dai->cpu_dai->private_data;
158 channel = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
159 dev->channel_out : dev->channel_in;
161 s6000_i2s_stop_channel(dev, channel);
164 static int s6000_i2s_trigger(struct snd_pcm_substream *substream, int cmd,
168 case SNDRV_PCM_TRIGGER_START:
169 case SNDRV_PCM_TRIGGER_RESUME:
170 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
171 if ((substream->stream == SNDRV_PCM_STREAM_CAPTURE) ^ !after)
172 s6000_i2s_start(substream);
174 case SNDRV_PCM_TRIGGER_STOP:
175 case SNDRV_PCM_TRIGGER_SUSPEND:
176 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
178 s6000_i2s_stop(substream);
183 static unsigned int s6000_i2s_int_sources(struct s6000_i2s_dev *dev)
185 unsigned int pending;
186 pending = s6_i2s_read_reg(dev, S6_I2S_INTERRUPT_RAW);
187 pending &= S6_I2S_INT_ALIGNMENT |
188 S6_I2S_INT_UNDERRUN |
190 s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR, pending);
195 static unsigned int s6000_i2s_check_xrun(struct snd_soc_dai *cpu_dai)
197 struct s6000_i2s_dev *dev = cpu_dai->private_data;
201 errors = s6000_i2s_int_sources(dev);
206 if (errors & S6_I2S_INT_ALIGNMENT)
207 printk(KERN_ERR "s6000-i2s: WCLK misaligned\n");
208 if (errors & S6_I2S_INT_UNDERRUN)
209 ret |= 1 << SNDRV_PCM_STREAM_PLAYBACK;
210 if (errors & S6_I2S_INT_OVERRUN)
211 ret |= 1 << SNDRV_PCM_STREAM_CAPTURE;
215 static void s6000_i2s_wait_disabled(struct s6000_i2s_dev *dev)
219 for (channel = 0; channel < 2; channel++) {
221 int v = s6_i2s_read_reg(dev, S6_I2S_ENABLE(channel));
222 if ((v & S6_I2S_IS_ENABLED)
223 || !(v & (S6_I2S_DMA_ACTIVE | S6_I2S_IS_BUSY)))
229 printk(KERN_WARNING "s6000-i2s: timeout disabling interfaces");
232 static int s6000_i2s_set_dai_fmt(struct snd_soc_dai *cpu_dai,
235 struct s6000_i2s_dev *dev = cpu_dai->private_data;
238 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
239 case SND_SOC_DAIFMT_CBM_CFM:
240 w = S6_I2S_SCK_IN | S6_I2S_WS_IN;
242 case SND_SOC_DAIFMT_CBS_CFM:
243 w = S6_I2S_SCK_OUT | S6_I2S_WS_IN;
245 case SND_SOC_DAIFMT_CBM_CFS:
246 w = S6_I2S_SCK_IN | S6_I2S_WS_OUT;
248 case SND_SOC_DAIFMT_CBS_CFS:
249 w = S6_I2S_SCK_OUT | S6_I2S_WS_OUT;
255 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
256 case SND_SOC_DAIFMT_NB_NF:
257 w |= S6_I2S_LEFT_FIRST;
259 case SND_SOC_DAIFMT_NB_IF:
260 w |= S6_I2S_RIGHT_FIRST;
266 s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(0),
267 S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
268 s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(1),
269 S6_I2S_FIRST | S6_I2S_WS_DIR | S6_I2S_SCK_DIR, w);
274 static int s6000_i2s_set_clkdiv(struct snd_soc_dai *dai, int div_id, int div)
276 struct s6000_i2s_dev *dev = dai->private_data;
278 if (!div || (div & 1) || div > (S6_I2S_DIV_MASK + 1) * 2)
281 s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(div_id),
282 S6_I2S_DIV_MASK, div / 2 - 1);
286 static int s6000_i2s_hw_params(struct snd_pcm_substream *substream,
287 struct snd_pcm_hw_params *params,
288 struct snd_soc_dai *dai)
290 struct s6000_i2s_dev *dev = dai->private_data;
297 w |= (((params_channels(params) - 2) / 2)
298 << S6_I2S_CHANNELS_SHIFT) & S6_I2S_CHANNELS_MASK;
299 interf = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
300 ? dev->channel_out : dev->channel_in;
303 switch (params_format(params)) {
304 case SNDRV_PCM_FORMAT_S16_LE:
305 w |= S6_I2S_16BIT | S6_I2S_MEM_16BIT;
307 case SNDRV_PCM_FORMAT_S32_LE:
308 w |= S6_I2S_32BIT | S6_I2S_MEM_32BIT;
311 printk(KERN_WARNING "s6000-i2s: unsupported PCM format %x\n",
312 params_format(params));
316 if (s6_i2s_read_reg(dev, S6_I2S_INTERFACE_CFG(interf))
317 & S6_I2S_IS_ENABLED) {
318 printk(KERN_ERR "s6000-i2s: interface already enabled\n");
322 s6_i2s_mod_reg(dev, S6_I2S_INTERFACE_CFG(interf),
323 S6_I2S_CHANNELS_MASK|S6_I2S_MEM_MASK|S6_I2S_BITS_MASK,
329 static int s6000_i2s_dai_probe(struct platform_device *pdev,
330 struct snd_soc_dai *dai)
332 struct s6000_i2s_dev *dev = dai->private_data;
333 struct s6000_snd_platform_data *pdata = pdev->dev.platform_data;
338 dev->wide = pdata->wide;
339 dev->channel_in = pdata->channel_in;
340 dev->channel_out = pdata->channel_out;
341 dev->lines_in = pdata->lines_in;
342 dev->lines_out = pdata->lines_out;
344 s6_i2s_write_reg(dev, S6_I2S_MODE,
345 dev->wide ? S6_I2S_WIDE : S6_I2S_DUAL);
350 if (dev->lines_in + dev->lines_out > S6_I2S_NUM_LINES)
354 dev->channel_out = 1;
355 dai->capture.channels_min = 2 * dev->lines_in;
356 dai->capture.channels_max = dai->capture.channels_min;
357 dai->playback.channels_min = 2 * dev->lines_out;
358 dai->playback.channels_max = dai->playback.channels_min;
360 for (i = 0; i < dev->lines_out; i++)
361 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_OUT);
363 for (; i < S6_I2S_NUM_LINES - dev->lines_in; i++)
364 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i),
367 for (; i < S6_I2S_NUM_LINES; i++)
368 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(i), S6_I2S_IN);
370 unsigned int cfg[2] = {S6_I2S_UNUSED, S6_I2S_UNUSED};
372 if (dev->lines_in > 1 || dev->lines_out > 1)
375 dai->capture.channels_min = 2 * dev->lines_in;
376 dai->capture.channels_max = 8 * dev->lines_in;
377 dai->playback.channels_min = 2 * dev->lines_out;
378 dai->playback.channels_max = 8 * dev->lines_out;
381 cfg[dev->channel_in] = S6_I2S_IN;
383 cfg[dev->channel_out] = S6_I2S_OUT;
385 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(0), cfg[0]);
386 s6_i2s_write_reg(dev, S6_I2S_DATA_CFG(1), cfg[1]);
389 if (dev->lines_out) {
391 if (!dev->dma_params.dma_out)
394 dev->dma_params.dma_out = dev->dma_params.dma_in;
395 dev->dma_params.dma_in = 0;
398 dev->dma_params.sif_in = dev->sifbase + (dev->channel_in ?
399 S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
400 dev->dma_params.sif_out = dev->sifbase + (dev->channel_out ?
401 S6_I2S_SIF_PORT1 : S6_I2S_SIF_PORT0);
402 dev->dma_params.same_rate = pdata->same_rate | pdata->wide;
406 #define S6000_I2S_RATES (SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_5512 | \
407 SNDRV_PCM_RATE_8000_192000)
408 #define S6000_I2S_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S32_LE)
410 static struct snd_soc_dai_ops s6000_i2s_dai_ops = {
411 .set_fmt = s6000_i2s_set_dai_fmt,
412 .set_clkdiv = s6000_i2s_set_clkdiv,
413 .hw_params = s6000_i2s_hw_params,
416 struct snd_soc_dai s6000_i2s_dai = {
419 .probe = s6000_i2s_dai_probe,
423 .formats = S6000_I2S_FORMATS,
424 .rates = S6000_I2S_RATES,
431 .formats = S6000_I2S_FORMATS,
432 .rates = S6000_I2S_RATES,
436 .ops = &s6000_i2s_dai_ops,
438 EXPORT_SYMBOL_GPL(s6000_i2s_dai);
440 static int __devinit s6000_i2s_probe(struct platform_device *pdev)
442 struct s6000_i2s_dev *dev;
443 struct resource *scbmem, *sifmem, *region, *dma1, *dma2;
447 scbmem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
449 dev_err(&pdev->dev, "no mem resource?\n");
451 goto err_release_none;
454 region = request_mem_region(scbmem->start,
455 scbmem->end - scbmem->start + 1,
458 dev_err(&pdev->dev, "I2S SCB region already claimed\n");
460 goto err_release_none;
463 mmio = ioremap(scbmem->start, scbmem->end - scbmem->start + 1);
465 dev_err(&pdev->dev, "can't ioremap SCB region\n");
467 goto err_release_scb;
470 sifmem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
472 dev_err(&pdev->dev, "no second mem resource?\n");
474 goto err_release_map;
477 region = request_mem_region(sifmem->start,
478 sifmem->end - sifmem->start + 1,
481 dev_err(&pdev->dev, "I2S SIF region already claimed\n");
483 goto err_release_map;
486 dma1 = platform_get_resource(pdev, IORESOURCE_DMA, 0);
488 dev_err(&pdev->dev, "no dma resource?\n");
490 goto err_release_sif;
493 region = request_mem_region(dma1->start, dma1->end - dma1->start + 1,
496 dev_err(&pdev->dev, "I2S DMA region already claimed\n");
498 goto err_release_sif;
501 dma2 = platform_get_resource(pdev, IORESOURCE_DMA, 1);
503 region = request_mem_region(dma2->start,
504 dma2->end - dma2->start + 1,
508 "I2S DMA region already claimed\n");
510 goto err_release_dma1;
514 dev = kzalloc(sizeof(struct s6000_i2s_dev), GFP_KERNEL);
517 goto err_release_dma2;
520 s6000_i2s_dai.dev = &pdev->dev;
521 s6000_i2s_dai.private_data = dev;
522 s6000_i2s_dai.capture.dma_data = &dev->dma_params;
523 s6000_i2s_dai.playback.dma_data = &dev->dma_params;
525 dev->sifbase = sifmem->start;
528 s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
529 s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_CLEAR,
530 S6_I2S_INT_ALIGNMENT |
531 S6_I2S_INT_UNDERRUN |
534 s6000_i2s_stop_channel(dev, 0);
535 s6000_i2s_stop_channel(dev, 1);
536 s6000_i2s_wait_disabled(dev);
538 dev->dma_params.check_xrun = s6000_i2s_check_xrun;
539 dev->dma_params.trigger = s6000_i2s_trigger;
540 dev->dma_params.dma_in = dma1->start;
541 dev->dma_params.dma_out = dma2 ? dma2->start : 0;
542 dev->dma_params.irq = platform_get_irq(pdev, 0);
543 if (dev->dma_params.irq < 0) {
544 dev_err(&pdev->dev, "no irq resource?\n");
546 goto err_release_dev;
549 s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE,
550 S6_I2S_INT_ALIGNMENT |
551 S6_I2S_INT_UNDERRUN |
554 ret = snd_soc_register_dai(&s6000_i2s_dai);
556 goto err_release_dev;
564 release_mem_region(dma2->start, dma2->end - dma2->start + 1);
566 release_mem_region(dma1->start, dma1->end - dma1->start + 1);
568 release_mem_region(sifmem->start, (sifmem->end - sifmem->start) + 1);
572 release_mem_region(scbmem->start, (scbmem->end - scbmem->start) + 1);
577 static void __devexit s6000_i2s_remove(struct platform_device *pdev)
579 struct s6000_i2s_dev *dev = s6000_i2s_dai.private_data;
580 struct resource *region;
581 void __iomem *mmio = dev->scbbase;
583 snd_soc_unregister_dai(&s6000_i2s_dai);
585 s6000_i2s_stop_channel(dev, 0);
586 s6000_i2s_stop_channel(dev, 1);
588 s6_i2s_write_reg(dev, S6_I2S_INTERRUPT_ENABLE, 0);
589 s6000_i2s_dai.private_data = 0;
592 region = platform_get_resource(pdev, IORESOURCE_DMA, 0);
593 release_mem_region(region->start, region->end - region->start + 1);
595 region = platform_get_resource(pdev, IORESOURCE_DMA, 1);
597 release_mem_region(region->start,
598 region->end - region->start + 1);
600 region = platform_get_resource(pdev, IORESOURCE_MEM, 0);
601 release_mem_region(region->start, (region->end - region->start) + 1);
604 region = platform_get_resource(pdev, IORESOURCE_IO, 0);
605 release_mem_region(region->start, (region->end - region->start) + 1);
608 static struct platform_driver s6000_i2s_driver = {
609 .probe = s6000_i2s_probe,
610 .remove = __devexit_p(s6000_i2s_remove),
613 .owner = THIS_MODULE,
617 static int __init s6000_i2s_init(void)
619 return platform_driver_register(&s6000_i2s_driver);
621 module_init(s6000_i2s_init);
623 static void __exit s6000_i2s_exit(void)
625 platform_driver_unregister(&s6000_i2s_driver);
627 module_exit(s6000_i2s_exit);
629 MODULE_AUTHOR("Daniel Gloeckner");
630 MODULE_DESCRIPTION("Stretch s6000 family I2S SoC Interface");
631 MODULE_LICENSE("GPL");