1 /* sound/soc/s3c24xx/s3c-pcm.c
3 * ALSA SoC Audio Layer - S3C PCM-Controller driver
5 * Copyright (c) 2009 Samsung Electronics Co. Ltd
6 * Author: Jaswinder Singh <jassi.brar@samsung.com>
7 * based upon I2S drivers by Ben Dooks.
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
14 #include <linux/init.h>
15 #include <linux/module.h>
16 #include <linux/device.h>
17 #include <linux/delay.h>
18 #include <linux/clk.h>
19 #include <linux/kernel.h>
20 #include <linux/gpio.h>
23 #include <sound/core.h>
24 #include <sound/pcm.h>
25 #include <sound/pcm_params.h>
26 #include <sound/initval.h>
27 #include <sound/soc.h>
29 #include <plat/audio.h>
35 static struct s3c2410_dma_client s3c_pcm_dma_client_out = {
36 .name = "PCM Stereo out"
39 static struct s3c2410_dma_client s3c_pcm_dma_client_in = {
40 .name = "PCM Stereo in"
43 static struct s3c_dma_params s3c_pcm_stereo_out[] = {
45 .client = &s3c_pcm_dma_client_out,
49 .client = &s3c_pcm_dma_client_out,
54 static struct s3c_dma_params s3c_pcm_stereo_in[] = {
56 .client = &s3c_pcm_dma_client_in,
60 .client = &s3c_pcm_dma_client_in,
65 static struct s3c_pcm_info s3c_pcm[2];
67 static inline struct s3c_pcm_info *to_info(struct snd_soc_dai *cpu_dai)
69 return cpu_dai->private_data;
72 static void s3c_pcm_snd_txctrl(struct s3c_pcm_info *pcm, int on)
74 void __iomem *regs = pcm->regs;
77 clkctl = readl(regs + S3C_PCM_CLKCTL);
78 ctl = readl(regs + S3C_PCM_CTL);
79 ctl &= ~(S3C_PCM_CTL_TXDIPSTICK_MASK
80 << S3C_PCM_CTL_TXDIPSTICK_SHIFT);
83 ctl |= S3C_PCM_CTL_TXDMA_EN;
84 ctl |= S3C_PCM_CTL_TXFIFO_EN;
85 ctl |= S3C_PCM_CTL_ENABLE;
86 ctl |= (0x20<<S3C_PCM_CTL_TXDIPSTICK_SHIFT);
87 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
89 ctl &= ~S3C_PCM_CTL_TXDMA_EN;
90 ctl &= ~S3C_PCM_CTL_TXFIFO_EN;
92 if (!(ctl & S3C_PCM_CTL_RXFIFO_EN)) {
93 ctl &= ~S3C_PCM_CTL_ENABLE;
95 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
99 writel(clkctl, regs + S3C_PCM_CLKCTL);
100 writel(ctl, regs + S3C_PCM_CTL);
103 static void s3c_pcm_snd_rxctrl(struct s3c_pcm_info *pcm, int on)
105 void __iomem *regs = pcm->regs;
108 ctl = readl(regs + S3C_PCM_CTL);
109 clkctl = readl(regs + S3C_PCM_CLKCTL);
112 ctl |= S3C_PCM_CTL_RXDMA_EN;
113 ctl |= S3C_PCM_CTL_RXFIFO_EN;
114 ctl |= S3C_PCM_CTL_ENABLE;
115 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
117 ctl &= ~S3C_PCM_CTL_RXDMA_EN;
118 ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
120 if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
121 ctl &= ~S3C_PCM_CTL_ENABLE;
123 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
127 writel(clkctl, regs + S3C_PCM_CLKCTL);
128 writel(ctl, regs + S3C_PCM_CTL);
131 static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
132 struct snd_soc_dai *dai)
134 struct snd_soc_pcm_runtime *rtd = substream->private_data;
135 struct s3c_pcm_info *pcm = to_info(rtd->dai->cpu_dai);
138 dev_dbg(pcm->dev, "Entered %s\n", __func__);
141 case SNDRV_PCM_TRIGGER_START:
142 case SNDRV_PCM_TRIGGER_RESUME:
143 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
144 spin_lock_irqsave(&pcm->lock, flags);
146 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
147 s3c_pcm_snd_rxctrl(pcm, 1);
149 s3c_pcm_snd_txctrl(pcm, 1);
151 spin_unlock_irqrestore(&pcm->lock, flags);
154 case SNDRV_PCM_TRIGGER_STOP:
155 case SNDRV_PCM_TRIGGER_SUSPEND:
156 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
157 spin_lock_irqsave(&pcm->lock, flags);
159 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
160 s3c_pcm_snd_rxctrl(pcm, 0);
162 s3c_pcm_snd_txctrl(pcm, 0);
164 spin_unlock_irqrestore(&pcm->lock, flags);
174 static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
175 struct snd_pcm_hw_params *params,
176 struct snd_soc_dai *socdai)
178 struct snd_soc_pcm_runtime *rtd = substream->private_data;
179 struct snd_soc_dai_link *dai = rtd->dai;
180 struct s3c_pcm_info *pcm = to_info(dai->cpu_dai);
181 struct s3c_dma_params *dma_data;
182 void __iomem *regs = pcm->regs;
184 int sclk_div, sync_div;
188 dev_dbg(pcm->dev, "Entered %s\n", __func__);
190 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
191 dma_data = pcm->dma_playback;
193 dma_data = pcm->dma_capture;
195 snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
197 /* Strictly check for sample size */
198 switch (params_format(params)) {
199 case SNDRV_PCM_FORMAT_S16_LE:
205 spin_lock_irqsave(&pcm->lock, flags);
207 /* Get hold of the PCMSOURCE_CLK */
208 clkctl = readl(regs + S3C_PCM_CLKCTL);
209 if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
214 /* Set the SCLK divider */
215 sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
216 params_rate(params) / 2 - 1;
218 clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
219 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
220 clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
221 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
223 /* Set the SYNC divider */
224 sync_div = pcm->sclk_per_fs - 1;
226 clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
227 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
228 clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
229 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
231 writel(clkctl, regs + S3C_PCM_CLKCTL);
233 spin_unlock_irqrestore(&pcm->lock, flags);
235 dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
236 clk_get_rate(clk), pcm->sclk_per_fs,
242 static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
245 struct s3c_pcm_info *pcm = to_info(cpu_dai);
246 void __iomem *regs = pcm->regs;
251 dev_dbg(pcm->dev, "Entered %s\n", __func__);
253 spin_lock_irqsave(&pcm->lock, flags);
255 ctl = readl(regs + S3C_PCM_CTL);
257 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
258 case SND_SOC_DAIFMT_NB_NF:
259 /* Nothing to do, NB_NF by default */
262 dev_err(pcm->dev, "Unsupported clock inversion!\n");
267 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
268 case SND_SOC_DAIFMT_CBS_CFS:
269 /* Nothing to do, Master by default */
272 dev_err(pcm->dev, "Unsupported master/slave format!\n");
277 switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
278 case SND_SOC_DAIFMT_CONT:
281 case SND_SOC_DAIFMT_GATED:
285 dev_err(pcm->dev, "Invalid Clock gating request!\n");
290 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
291 case SND_SOC_DAIFMT_DSP_A:
292 ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
293 ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
295 case SND_SOC_DAIFMT_DSP_B:
296 ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
297 ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
300 dev_err(pcm->dev, "Unsupported data format!\n");
305 writel(ctl, regs + S3C_PCM_CTL);
308 spin_unlock_irqrestore(&pcm->lock, flags);
313 static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
316 struct s3c_pcm_info *pcm = to_info(cpu_dai);
319 case S3C_PCM_SCLK_PER_FS:
320 pcm->sclk_per_fs = div;
330 static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
331 int clk_id, unsigned int freq, int dir)
333 struct s3c_pcm_info *pcm = to_info(cpu_dai);
334 void __iomem *regs = pcm->regs;
335 u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
338 case S3C_PCM_CLKSRC_PCLK:
339 clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
342 case S3C_PCM_CLKSRC_MUX:
343 clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
345 if (clk_get_rate(pcm->cclk) != freq)
346 clk_set_rate(pcm->cclk, freq);
354 writel(clkctl, regs + S3C_PCM_CLKCTL);
359 static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
360 .set_sysclk = s3c_pcm_set_sysclk,
361 .set_clkdiv = s3c_pcm_set_clkdiv,
362 .trigger = s3c_pcm_trigger,
363 .hw_params = s3c_pcm_hw_params,
364 .set_fmt = s3c_pcm_set_fmt,
367 #define S3C_PCM_RATES SNDRV_PCM_RATE_8000_96000
369 #define S3C_PCM_DECLARE(n) \
371 .name = "samsung-pcm", \
373 .symmetric_rates = 1, \
374 .ops = &s3c_pcm_dai_ops, \
378 .rates = S3C_PCM_RATES, \
379 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
384 .rates = S3C_PCM_RATES, \
385 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
389 struct snd_soc_dai s3c_pcm_dai[] = {
393 EXPORT_SYMBOL_GPL(s3c_pcm_dai);
395 static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
397 struct s3c_pcm_info *pcm;
398 struct snd_soc_dai *dai;
399 struct resource *mem_res, *dmatx_res, *dmarx_res;
400 struct s3c_audio_pdata *pcm_pdata;
403 /* Check for valid device index */
404 if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
405 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
409 pcm_pdata = pdev->dev.platform_data;
411 /* Check for availability of necessary resource */
412 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
414 dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
418 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
420 dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
424 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
426 dev_err(&pdev->dev, "Unable to get register resource\n");
430 if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
431 dev_err(&pdev->dev, "Unable to configure gpio\n");
435 pcm = &s3c_pcm[pdev->id];
436 pcm->dev = &pdev->dev;
438 spin_lock_init(&pcm->lock);
440 dai = &s3c_pcm_dai[pdev->id];
441 dai->dev = &pdev->dev;
443 /* Default is 128fs */
444 pcm->sclk_per_fs = 128;
446 pcm->cclk = clk_get(&pdev->dev, "audio-bus");
447 if (IS_ERR(pcm->cclk)) {
448 dev_err(&pdev->dev, "failed to get audio-bus\n");
449 ret = PTR_ERR(pcm->cclk);
452 clk_enable(pcm->cclk);
454 /* record our pcm structure for later use in the callbacks */
455 dai->private_data = pcm;
457 if (!request_mem_region(mem_res->start,
458 resource_size(mem_res), "samsung-pcm")) {
459 dev_err(&pdev->dev, "Unable to request register region\n");
464 pcm->regs = ioremap(mem_res->start, 0x100);
465 if (pcm->regs == NULL) {
466 dev_err(&pdev->dev, "cannot ioremap registers\n");
471 pcm->pclk = clk_get(&pdev->dev, "pcm");
472 if (IS_ERR(pcm->pclk)) {
473 dev_err(&pdev->dev, "failed to get pcm_clock\n");
477 clk_enable(pcm->pclk);
479 ret = snd_soc_register_dai(dai);
481 dev_err(&pdev->dev, "failed to get pcm_clock\n");
485 s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
487 s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
490 s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
491 s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
493 pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
494 pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
499 clk_disable(pcm->pclk);
504 release_mem_region(mem_res->start, resource_size(mem_res));
506 clk_disable(pcm->cclk);
512 static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
514 struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
515 struct resource *mem_res;
519 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
520 release_mem_region(mem_res->start, resource_size(mem_res));
522 clk_disable(pcm->cclk);
523 clk_disable(pcm->pclk);
530 static struct platform_driver s3c_pcm_driver = {
531 .probe = s3c_pcm_dev_probe,
532 .remove = s3c_pcm_dev_remove,
534 .name = "samsung-pcm",
535 .owner = THIS_MODULE,
539 static int __init s3c_pcm_init(void)
541 return platform_driver_register(&s3c_pcm_driver);
543 module_init(s3c_pcm_init);
545 static void __exit s3c_pcm_exit(void)
547 platform_driver_unregister(&s3c_pcm_driver);
549 module_exit(s3c_pcm_exit);
551 /* Module information */
552 MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
553 MODULE_DESCRIPTION("S3C PCM Controller Driver");
554 MODULE_LICENSE("GPL");