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 void s3c_pcm_snd_txctrl(struct s3c_pcm_info *pcm, int on)
69 void __iomem *regs = pcm->regs;
72 clkctl = readl(regs + S3C_PCM_CLKCTL);
73 ctl = readl(regs + S3C_PCM_CTL);
74 ctl &= ~(S3C_PCM_CTL_TXDIPSTICK_MASK
75 << S3C_PCM_CTL_TXDIPSTICK_SHIFT);
78 ctl |= S3C_PCM_CTL_TXDMA_EN;
79 ctl |= S3C_PCM_CTL_TXFIFO_EN;
80 ctl |= S3C_PCM_CTL_ENABLE;
81 ctl |= (0x20<<S3C_PCM_CTL_TXDIPSTICK_SHIFT);
82 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
84 ctl &= ~S3C_PCM_CTL_TXDMA_EN;
85 ctl &= ~S3C_PCM_CTL_TXFIFO_EN;
87 if (!(ctl & S3C_PCM_CTL_RXFIFO_EN)) {
88 ctl &= ~S3C_PCM_CTL_ENABLE;
90 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
94 writel(clkctl, regs + S3C_PCM_CLKCTL);
95 writel(ctl, regs + S3C_PCM_CTL);
98 static void s3c_pcm_snd_rxctrl(struct s3c_pcm_info *pcm, int on)
100 void __iomem *regs = pcm->regs;
103 ctl = readl(regs + S3C_PCM_CTL);
104 clkctl = readl(regs + S3C_PCM_CLKCTL);
107 ctl |= S3C_PCM_CTL_RXDMA_EN;
108 ctl |= S3C_PCM_CTL_RXFIFO_EN;
109 ctl |= S3C_PCM_CTL_ENABLE;
110 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
112 ctl &= ~S3C_PCM_CTL_RXDMA_EN;
113 ctl &= ~S3C_PCM_CTL_RXFIFO_EN;
115 if (!(ctl & S3C_PCM_CTL_TXFIFO_EN)) {
116 ctl &= ~S3C_PCM_CTL_ENABLE;
118 clkctl |= S3C_PCM_CLKCTL_SERCLK_EN;
122 writel(clkctl, regs + S3C_PCM_CLKCTL);
123 writel(ctl, regs + S3C_PCM_CTL);
126 static int s3c_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
127 struct snd_soc_dai *dai)
129 struct snd_soc_pcm_runtime *rtd = substream->private_data;
130 struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(rtd->cpu_dai);
133 dev_dbg(pcm->dev, "Entered %s\n", __func__);
136 case SNDRV_PCM_TRIGGER_START:
137 case SNDRV_PCM_TRIGGER_RESUME:
138 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
139 spin_lock_irqsave(&pcm->lock, flags);
141 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
142 s3c_pcm_snd_rxctrl(pcm, 1);
144 s3c_pcm_snd_txctrl(pcm, 1);
146 spin_unlock_irqrestore(&pcm->lock, flags);
149 case SNDRV_PCM_TRIGGER_STOP:
150 case SNDRV_PCM_TRIGGER_SUSPEND:
151 case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
152 spin_lock_irqsave(&pcm->lock, flags);
154 if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)
155 s3c_pcm_snd_rxctrl(pcm, 0);
157 s3c_pcm_snd_txctrl(pcm, 0);
159 spin_unlock_irqrestore(&pcm->lock, flags);
169 static int s3c_pcm_hw_params(struct snd_pcm_substream *substream,
170 struct snd_pcm_hw_params *params,
171 struct snd_soc_dai *socdai)
173 struct snd_soc_pcm_runtime *rtd = substream->private_data;
174 struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(rtd->cpu_dai);
175 struct s3c_dma_params *dma_data;
176 void __iomem *regs = pcm->regs;
178 int sclk_div, sync_div;
182 dev_dbg(pcm->dev, "Entered %s\n", __func__);
184 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
185 dma_data = pcm->dma_playback;
187 dma_data = pcm->dma_capture;
189 snd_soc_dai_set_dma_data(rtd->cpu_dai, substream, dma_data);
191 /* Strictly check for sample size */
192 switch (params_format(params)) {
193 case SNDRV_PCM_FORMAT_S16_LE:
199 spin_lock_irqsave(&pcm->lock, flags);
201 /* Get hold of the PCMSOURCE_CLK */
202 clkctl = readl(regs + S3C_PCM_CLKCTL);
203 if (clkctl & S3C_PCM_CLKCTL_SERCLKSEL_PCLK)
208 /* Set the SCLK divider */
209 sclk_div = clk_get_rate(clk) / pcm->sclk_per_fs /
210 params_rate(params) / 2 - 1;
212 clkctl &= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
213 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
214 clkctl |= ((sclk_div & S3C_PCM_CLKCTL_SCLKDIV_MASK)
215 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT);
217 /* Set the SYNC divider */
218 sync_div = pcm->sclk_per_fs - 1;
220 clkctl &= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
221 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
222 clkctl |= ((sync_div & S3C_PCM_CLKCTL_SYNCDIV_MASK)
223 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT);
225 writel(clkctl, regs + S3C_PCM_CLKCTL);
227 spin_unlock_irqrestore(&pcm->lock, flags);
229 dev_dbg(pcm->dev, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
230 clk_get_rate(clk), pcm->sclk_per_fs,
236 static int s3c_pcm_set_fmt(struct snd_soc_dai *cpu_dai,
239 struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
240 void __iomem *regs = pcm->regs;
245 dev_dbg(pcm->dev, "Entered %s\n", __func__);
247 spin_lock_irqsave(&pcm->lock, flags);
249 ctl = readl(regs + S3C_PCM_CTL);
251 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
252 case SND_SOC_DAIFMT_NB_NF:
253 /* Nothing to do, NB_NF by default */
256 dev_err(pcm->dev, "Unsupported clock inversion!\n");
261 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
262 case SND_SOC_DAIFMT_CBS_CFS:
263 /* Nothing to do, Master by default */
266 dev_err(pcm->dev, "Unsupported master/slave format!\n");
271 switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
272 case SND_SOC_DAIFMT_CONT:
275 case SND_SOC_DAIFMT_GATED:
279 dev_err(pcm->dev, "Invalid Clock gating request!\n");
284 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
285 case SND_SOC_DAIFMT_DSP_A:
286 ctl |= S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
287 ctl |= S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
289 case SND_SOC_DAIFMT_DSP_B:
290 ctl &= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC;
291 ctl &= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC;
294 dev_err(pcm->dev, "Unsupported data format!\n");
299 writel(ctl, regs + S3C_PCM_CTL);
302 spin_unlock_irqrestore(&pcm->lock, flags);
307 static int s3c_pcm_set_clkdiv(struct snd_soc_dai *cpu_dai,
310 struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
313 case S3C_PCM_SCLK_PER_FS:
314 pcm->sclk_per_fs = div;
324 static int s3c_pcm_set_sysclk(struct snd_soc_dai *cpu_dai,
325 int clk_id, unsigned int freq, int dir)
327 struct s3c_pcm_info *pcm = snd_soc_dai_get_drvdata(cpu_dai);
328 void __iomem *regs = pcm->regs;
329 u32 clkctl = readl(regs + S3C_PCM_CLKCTL);
332 case S3C_PCM_CLKSRC_PCLK:
333 clkctl |= S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
336 case S3C_PCM_CLKSRC_MUX:
337 clkctl &= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK;
339 if (clk_get_rate(pcm->cclk) != freq)
340 clk_set_rate(pcm->cclk, freq);
348 writel(clkctl, regs + S3C_PCM_CLKCTL);
353 static struct snd_soc_dai_ops s3c_pcm_dai_ops = {
354 .set_sysclk = s3c_pcm_set_sysclk,
355 .set_clkdiv = s3c_pcm_set_clkdiv,
356 .trigger = s3c_pcm_trigger,
357 .hw_params = s3c_pcm_hw_params,
358 .set_fmt = s3c_pcm_set_fmt,
361 #define S3C_PCM_RATES SNDRV_PCM_RATE_8000_96000
363 #define S3C_PCM_DAI_DECLARE \
365 .name = "samsung-dai", \
366 .symmetric_rates = 1, \
367 .ops = &s3c_pcm_dai_ops, \
371 .rates = S3C_PCM_RATES, \
372 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
377 .rates = S3C_PCM_RATES, \
378 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
382 struct snd_soc_dai_driver s3c_pcm_dai[] = {
386 EXPORT_SYMBOL_GPL(s3c_pcm_dai);
388 static __devinit int s3c_pcm_dev_probe(struct platform_device *pdev)
390 struct s3c_pcm_info *pcm;
391 struct resource *mem_res, *dmatx_res, *dmarx_res;
392 struct s3c_audio_pdata *pcm_pdata;
395 /* Check for valid device index */
396 if ((pdev->id < 0) || pdev->id >= ARRAY_SIZE(s3c_pcm)) {
397 dev_err(&pdev->dev, "id %d out of range\n", pdev->id);
401 pcm_pdata = pdev->dev.platform_data;
403 /* Check for availability of necessary resource */
404 dmatx_res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
406 dev_err(&pdev->dev, "Unable to get PCM-TX dma resource\n");
410 dmarx_res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
412 dev_err(&pdev->dev, "Unable to get PCM-RX dma resource\n");
416 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
418 dev_err(&pdev->dev, "Unable to get register resource\n");
422 if (pcm_pdata && pcm_pdata->cfg_gpio && pcm_pdata->cfg_gpio(pdev)) {
423 dev_err(&pdev->dev, "Unable to configure gpio\n");
427 pcm = &s3c_pcm[pdev->id];
428 pcm->dev = &pdev->dev;
430 spin_lock_init(&pcm->lock);
432 /* Default is 128fs */
433 pcm->sclk_per_fs = 128;
435 pcm->cclk = clk_get(&pdev->dev, "audio-bus");
436 if (IS_ERR(pcm->cclk)) {
437 dev_err(&pdev->dev, "failed to get audio-bus\n");
438 ret = PTR_ERR(pcm->cclk);
441 clk_enable(pcm->cclk);
443 /* record our pcm structure for later use in the callbacks */
444 dev_set_drvdata(&pdev->dev, pcm);
446 if (!request_mem_region(mem_res->start,
447 resource_size(mem_res), "samsung-pcm")) {
448 dev_err(&pdev->dev, "Unable to request register region\n");
453 pcm->regs = ioremap(mem_res->start, 0x100);
454 if (pcm->regs == NULL) {
455 dev_err(&pdev->dev, "cannot ioremap registers\n");
460 pcm->pclk = clk_get(&pdev->dev, "pcm");
461 if (IS_ERR(pcm->pclk)) {
462 dev_err(&pdev->dev, "failed to get pcm_clock\n");
466 clk_enable(pcm->pclk);
468 ret = snd_soc_register_dai(&pdev->dev, s3c_pcm_dai);
470 dev_err(&pdev->dev, "failed to get pcm_clock\n");
474 s3c_pcm_stereo_in[pdev->id].dma_addr = mem_res->start
476 s3c_pcm_stereo_out[pdev->id].dma_addr = mem_res->start
479 s3c_pcm_stereo_in[pdev->id].channel = dmarx_res->start;
480 s3c_pcm_stereo_out[pdev->id].channel = dmatx_res->start;
482 pcm->dma_capture = &s3c_pcm_stereo_in[pdev->id];
483 pcm->dma_playback = &s3c_pcm_stereo_out[pdev->id];
488 clk_disable(pcm->pclk);
493 release_mem_region(mem_res->start, resource_size(mem_res));
495 clk_disable(pcm->cclk);
501 static __devexit int s3c_pcm_dev_remove(struct platform_device *pdev)
503 struct s3c_pcm_info *pcm = &s3c_pcm[pdev->id];
504 struct resource *mem_res;
506 snd_soc_unregister_dai(&pdev->dev);
510 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
511 release_mem_region(mem_res->start, resource_size(mem_res));
513 clk_disable(pcm->cclk);
514 clk_disable(pcm->pclk);
521 static struct platform_driver s3c_pcm_driver = {
522 .probe = s3c_pcm_dev_probe,
523 .remove = s3c_pcm_dev_remove,
525 .name = "samsung-pcm-audio",
526 .owner = THIS_MODULE,
530 static int __init s3c_pcm_init(void)
532 return platform_driver_register(&s3c_pcm_driver);
534 module_init(s3c_pcm_init);
536 static void __exit s3c_pcm_exit(void)
538 platform_driver_unregister(&s3c_pcm_driver);
540 module_exit(s3c_pcm_exit);
542 /* Module information */
543 MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
544 MODULE_DESCRIPTION("S3C PCM Controller Driver");
545 MODULE_LICENSE("GPL");
546 MODULE_ALIAS("platform:samsung-pcm-audio");