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);
110 ctl &= ~(S3C_PCM_CTL_RXDIPSTICK_MASK
111 << S3C_PCM_CTL_RXDIPSTICK_SHIFT);
114 ctl |= S3C_PCM_CTL_RXDMA_EN;
115 ctl |= S3C_PCM_CTL_RXFIFO_EN;
116 ctl |= S3C_PCM_CTL_ENABLE;
117 ctl |= (0x20<<S3C_PCM_CTL_RXDIPSTICK_SHIFT);
118 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
120 ctl &= ~S3C_PCM_CTL_RXDMA_EN;
121 ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
123 if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
124 ctl &= ~S3C_PCM_CTL_ENABLE;
126 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
130 writel(clkctl, regs + S3C_PCM_CLKCTL);
131 writel(ctl, regs + S3C_PCM_CTL);
134 static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
135 struct snd_soc_dai *dai)
137 struct snd_soc_pcm_runtime *rtd = substream->private_data;
138 struct s3c_pcm_info *pcm = to_info(rtd->dai->cpu_dai);
141 dev_dbg(pcm->dev, "Entered %s\n", __func__);
144 case SNDRV_PCM_TRIGGER_START:
145 case SNDRV_PCM_TRIGGER_RESUME:
146 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
147 spin_lock_irqsave(&pcm->lock, flags);
149 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
150 s3c_pcm_snd_rxctrl(pcm, 1);
152 s3c_pcm_snd_txctrl(pcm, 1);
154 spin_unlock_irqrestore(&pcm->lock, flags);
157 case SNDRV_PCM_TRIGGER_STOP:
158 case SNDRV_PCM_TRIGGER_SUSPEND:
159 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
160 spin_lock_irqsave(&pcm->lock, flags);
162 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
163 s3c_pcm_snd_rxctrl(pcm, 0);
165 s3c_pcm_snd_txctrl(pcm, 0);
167 spin_unlock_irqrestore(&pcm->lock, flags);
177 static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
178 struct snd_pcm_hw_params *params,
179 struct snd_soc_dai *socdai)
181 struct snd_soc_pcm_runtime *rtd = substream->private_data;
182 struct snd_soc_dai_link *dai = rtd->dai;
183 struct s3c_pcm_info *pcm = to_info(dai->cpu_dai);
184 struct s3c_dma_params *dma_data;
185 void __iomem *regs = pcm->regs;
187 int sclk_div, sync_div;
191 dev_dbg(pcm->dev, "Entered %s\n", __func__);
193 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
194 dma_data = pcm->dma_playback;
196 dma_data = pcm->dma_capture;
198 snd_soc_dai_set_dma_data(dai->cpu_dai, substream, dma_data);
200 /* Strictly check for sample size */
201 switch (params_format(params)) {
202 case SNDRV_PCM_FORMAT_S16_LE:
208 spin_lock_irqsave(&pcm->lock, flags);
210 /* Get hold of the PCMSOURCE_CLK */
211 clkctl = readl(regs + S3C_PCM_CLKCTL);
212 if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
217 /* Set the SCLK divider */
218 sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
219 params_rate(params) / 2 - 1;
221 #if defined(CONFIG_ARCH_S5PV310)
222 if (clk_get_rate(clk) != (pcm->sclk_per_fs*params_rate(params)))
223 clk_set_rate(clk, pcm->sclk_per_fs*params_rate(params));
225 clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
226 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
227 clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
228 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
231 /* Set the SYNC divider */
232 sync_div = pcm->sclk_per_fs - 1;
234 clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
235 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
236 clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
237 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
239 writel(clkctl, regs + S3C_PCM_CLKCTL);
241 spin_unlock_irqrestore(&pcm->lock, flags);
243 dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
244 clk_get_rate(clk), pcm->sclk_per_fs,
250 static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
253 struct s3c_pcm_info *pcm = to_info(cpu_dai);
254 void __iomem *regs = pcm->regs;
259 dev_dbg(pcm->dev, "Entered %s\n", __func__);
261 spin_lock_irqsave(&pcm->lock, flags);
263 ctl = readl(regs + S3C_PCM_CTL);
265 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
266 case SND_SOC_DAIFMT_IB_NF:
267 /* Nothing to do, IB_NF by default */
270 dev_err(pcm->dev, "Unsupported clock inversion!\n");
275 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
276 case SND_SOC_DAIFMT_CBS_CFS:
277 /* Nothing to do, Master by default */
280 dev_err(pcm->dev, "Unsupported master/slave format!\n");
285 switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
286 case SND_SOC_DAIFMT_CONT:
289 case SND_SOC_DAIFMT_GATED:
293 dev_err(pcm->dev, "Invalid Clock gating request!\n");
298 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
299 case SND_SOC_DAIFMT_DSP_A:
300 ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
301 ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
303 case SND_SOC_DAIFMT_DSP_B:
304 ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
305 ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
308 dev_err(pcm->dev, "Unsupported data format!\n");
313 writel(ctl, regs + S3C_PCM_CTL);
316 spin_unlock_irqrestore(&pcm->lock, flags);
321 static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
324 struct s3c_pcm_info *pcm = to_info(cpu_dai);
327 case S3C_PCM_SCLK_PER_FS:
328 pcm->sclk_per_fs = div;
338 static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
339 int clk_id, unsigned int freq, int dir)
341 struct s3c_pcm_info *pcm = to_info(cpu_dai);
342 void __iomem *regs = pcm->regs;
343 u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
346 case S3C_PCM_CLKSRC_PCLK:
347 clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
350 case S3C_PCM_CLKSRC_MUX:
351 clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
353 if (clk_get_rate(pcm->cclk) != freq)
354 clk_set_rate(pcm->cclk, freq);
362 writel(clkctl, regs + S3C_PCM_CLKCTL);
367 static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
368 .set_sysclk = s3c_pcm_set_sysclk,
369 .set_clkdiv = s3c_pcm_set_clkdiv,
370 .trigger = s3c_pcm_trigger,
371 .hw_params = s3c_pcm_hw_params,
372 .set_fmt = s3c_pcm_set_fmt,
376 static int s3c_pcm_suspend(struct snd_soc_dai *dai)
378 struct s3c_pcm_info *pcm = to_info(dai);
380 pcm->backup_pcmctl = readl(pcm->regs + S3C_PCM_CTL);
381 pcm->backup_pcmclkctl = readl(pcm->regs + S3C_PCM_CLKCTL);
385 static int s3c_pcm_resume(struct snd_soc_dai *dai)
387 struct s3c_pcm_info *pcm = to_info(dai);
389 writel(pcm->backup_pcmctl, pcm->regs + S3C_PCM_CTL);
390 writel(pcm->backup_pcmclkctl, pcm->regs + S3C_PCM_CLKCTL);
395 #define s3c_pcm_suspend NULL
396 #define s3c_pcm_resume NULL
400 #define S3C_PCM_RATES SNDRV_PCM_RATE_8000_96000
402 #define S3C_PCM_DECLARE(n) \
404 .name = "samsung-pcm", \
406 .symmetric_rates = 1, \
407 .ops = &s3c_pcm_dai_ops, \
411 .rates = S3C_PCM_RATES, \
412 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
417 .rates = S3C_PCM_RATES, \
418 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
420 .suspend = s3c_pcm_suspend, \
421 .resume = s3c_pcm_resume, \
424 struct snd_soc_dai s3c_pcm_dai[] = {
428 EXPORT_SYMBOL_GPL(s3c_pcm_dai);
430 static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
432 struct s3c_pcm_info *pcm;
433 struct snd_soc_dai *dai;
434 struct resource *mem_res, *dmatx_res, *dmarx_res;
435 struct s3c_audio_pdata *pcm_pdata;
438 /* Check for valid device index */
439 if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
440 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
444 pcm_pdata = pdev->dev.platform_data;
446 /* Check for availability of necessary resource */
447 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
449 dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
453 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
455 dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
459 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
461 dev_err(&pdev->dev, "Unable to get register resource\n");
465 if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
466 dev_err(&pdev->dev, "Unable to configure gpio\n");
470 pcm = &s3c_pcm[pdev->id];
471 pcm->dev = &pdev->dev;
473 spin_lock_init(&pcm->lock);
475 dai = &s3c_pcm_dai[pdev->id];
476 dai->dev = &pdev->dev;
478 /* Default is 128fs */
479 pcm->sclk_per_fs = 128;
481 #if defined(CONFIG_ARCH_S5PV310)
482 pcm->cclk = clk_get(&pdev->dev, "sclk_pcm");
484 pcm->cclk = clk_get(&pdev->dev, "audio-bus");
486 if (IS_ERR(pcm->cclk)) {
487 dev_err(&pdev->dev, "failed to get audio-bus\n");
488 ret = PTR_ERR(pcm->cclk);
491 clk_enable(pcm->cclk);
493 /* record our pcm structure for later use in the callbacks */
494 dai->private_data = pcm;
496 if (!request_mem_region(mem_res->start,
497 resource_size(mem_res), "samsung-pcm")) {
498 dev_err(&pdev->dev, "Unable to request register region\n");
503 pcm->regs = ioremap(mem_res->start, 0x100);
504 if (pcm->regs == NULL) {
505 dev_err(&pdev->dev, "cannot ioremap registers\n");
510 pcm->pclk = clk_get(&pdev->dev, "pcm");
511 if (IS_ERR(pcm->pclk)) {
512 dev_err(&pdev->dev, "failed to get pcm_clock\n");
516 clk_enable(pcm->pclk);
518 ret = snd_soc_register_dai(dai);
520 dev_err(&pdev->dev, "failed to get pcm_clock\n");
524 s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
526 s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
529 s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
530 s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
532 pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
533 pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
538 clk_disable(pcm->pclk);
543 release_mem_region(mem_res->start, resource_size(mem_res));
545 clk_disable(pcm->cclk);
551 static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
553 struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
554 struct resource *mem_res;
558 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
559 release_mem_region(mem_res->start, resource_size(mem_res));
561 clk_disable(pcm->cclk);
562 clk_disable(pcm->pclk);
569 static struct platform_driver s3c_pcm_driver = {
570 .probe = s3c_pcm_dev_probe,
571 .remove = s3c_pcm_dev_remove,
573 .name = "samsung-pcm",
574 .owner = THIS_MODULE,
578 static int __init s3c_pcm_init(void)
580 return platform_driver_register(&s3c_pcm_driver);
582 module_init(s3c_pcm_init);
584 static void __exit s3c_pcm_exit(void)
586 platform_driver_unregister(&s3c_pcm_driver);
588 module_exit(s3c_pcm_exit);
590 /* Module information */
591 MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
592 MODULE_DESCRIPTION("S3C PCM Controller Driver");
593 MODULE_LICENSE("GPL");