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
|= (0x4<<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
);
105 ctl
&= ~(S3C_PCM_CTL_RXDIPSTICK_MASK
106 << S3C_PCM_CTL_RXDIPSTICK_SHIFT
);
109 ctl
|= S3C_PCM_CTL_RXDMA_EN
;
110 ctl
|= S3C_PCM_CTL_RXFIFO_EN
;
111 ctl
|= S3C_PCM_CTL_ENABLE
;
112 ctl
|= (0x20<<S3C_PCM_CTL_RXDIPSTICK_SHIFT
);
113 clkctl
|= S3C_PCM_CLKCTL_SERCLK_EN
;
115 ctl
&= ~S3C_PCM_CTL_RXDMA_EN
;
116 ctl
&= ~S3C_PCM_CTL_RXFIFO_EN
;
118 if (!(ctl
& S3C_PCM_CTL_TXFIFO_EN
)) {
119 ctl
&= ~S3C_PCM_CTL_ENABLE
;
121 clkctl
|= S3C_PCM_CLKCTL_SERCLK_EN
;
125 writel(clkctl
, regs
+ S3C_PCM_CLKCTL
);
126 writel(ctl
, regs
+ S3C_PCM_CTL
);
129 static int s3c_pcm_trigger(struct snd_pcm_substream
*substream
, int cmd
,
130 struct snd_soc_dai
*dai
)
132 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
133 struct s3c_pcm_info
*pcm
= snd_soc_dai_get_drvdata(rtd
->cpu_dai
);
136 dev_dbg(pcm
->dev
, "Entered %s\n", __func__
);
139 case SNDRV_PCM_TRIGGER_START
:
140 case SNDRV_PCM_TRIGGER_RESUME
:
141 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
142 spin_lock_irqsave(&pcm
->lock
, flags
);
144 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
)
145 s3c_pcm_snd_rxctrl(pcm
, 1);
147 s3c_pcm_snd_txctrl(pcm
, 1);
149 spin_unlock_irqrestore(&pcm
->lock
, flags
);
152 case SNDRV_PCM_TRIGGER_STOP
:
153 case SNDRV_PCM_TRIGGER_SUSPEND
:
154 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
155 spin_lock_irqsave(&pcm
->lock
, flags
);
157 if (substream
->stream
== SNDRV_PCM_STREAM_CAPTURE
)
158 s3c_pcm_snd_rxctrl(pcm
, 0);
160 s3c_pcm_snd_txctrl(pcm
, 0);
162 spin_unlock_irqrestore(&pcm
->lock
, flags
);
172 static int s3c_pcm_hw_params(struct snd_pcm_substream
*substream
,
173 struct snd_pcm_hw_params
*params
,
174 struct snd_soc_dai
*socdai
)
176 struct snd_soc_pcm_runtime
*rtd
= substream
->private_data
;
177 struct s3c_pcm_info
*pcm
= snd_soc_dai_get_drvdata(rtd
->cpu_dai
);
178 struct s3c_dma_params
*dma_data
;
179 void __iomem
*regs
= pcm
->regs
;
181 int sclk_div
, sync_div
;
185 dev_dbg(pcm
->dev
, "Entered %s\n", __func__
);
187 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
188 dma_data
= pcm
->dma_playback
;
190 dma_data
= pcm
->dma_capture
;
192 snd_soc_dai_set_dma_data(rtd
->cpu_dai
, substream
, dma_data
);
194 /* Strictly check for sample size */
195 switch (params_format(params
)) {
196 case SNDRV_PCM_FORMAT_S16_LE
:
202 spin_lock_irqsave(&pcm
->lock
, flags
);
204 /* Get hold of the PCMSOURCE_CLK */
205 clkctl
= readl(regs
+ S3C_PCM_CLKCTL
);
206 if (clkctl
& S3C_PCM_CLKCTL_SERCLKSEL_PCLK
)
211 /* Set the SCLK divider */
212 sclk_div
= clk_get_rate(clk
) / pcm
->sclk_per_fs
/
213 params_rate(params
) / 2 - 1;
215 clkctl
&= ~(S3C_PCM_CLKCTL_SCLKDIV_MASK
216 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT
);
217 clkctl
|= ((sclk_div
& S3C_PCM_CLKCTL_SCLKDIV_MASK
)
218 << S3C_PCM_CLKCTL_SCLKDIV_SHIFT
);
220 /* Set the SYNC divider */
221 sync_div
= pcm
->sclk_per_fs
- 1;
223 clkctl
&= ~(S3C_PCM_CLKCTL_SYNCDIV_MASK
224 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT
);
225 clkctl
|= ((sync_div
& S3C_PCM_CLKCTL_SYNCDIV_MASK
)
226 << S3C_PCM_CLKCTL_SYNCDIV_SHIFT
);
228 writel(clkctl
, regs
+ S3C_PCM_CLKCTL
);
230 spin_unlock_irqrestore(&pcm
->lock
, flags
);
232 dev_dbg(pcm
->dev
, "PCMSOURCE_CLK-%lu SCLK=%ufs SCLK_DIV=%d SYNC_DIV=%d\n",
233 clk_get_rate(clk
), pcm
->sclk_per_fs
,
239 static int s3c_pcm_set_fmt(struct snd_soc_dai
*cpu_dai
,
242 struct s3c_pcm_info
*pcm
= snd_soc_dai_get_drvdata(cpu_dai
);
243 void __iomem
*regs
= pcm
->regs
;
248 dev_dbg(pcm
->dev
, "Entered %s\n", __func__
);
250 spin_lock_irqsave(&pcm
->lock
, flags
);
252 ctl
= readl(regs
+ S3C_PCM_CTL
);
254 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
255 case SND_SOC_DAIFMT_NB_NF
:
256 /* Nothing to do, NB_NF by default */
259 dev_err(pcm
->dev
, "Unsupported clock inversion!\n");
264 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
265 case SND_SOC_DAIFMT_CBS_CFS
:
266 /* Nothing to do, Master by default */
269 dev_err(pcm
->dev
, "Unsupported master/slave format!\n");
274 switch (fmt
& SND_SOC_DAIFMT_CLOCK_MASK
) {
275 case SND_SOC_DAIFMT_CONT
:
278 case SND_SOC_DAIFMT_GATED
:
282 dev_err(pcm
->dev
, "Invalid Clock gating request!\n");
287 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
288 case SND_SOC_DAIFMT_DSP_A
:
289 ctl
|= S3C_PCM_CTL_TXMSB_AFTER_FSYNC
;
290 ctl
|= S3C_PCM_CTL_RXMSB_AFTER_FSYNC
;
292 case SND_SOC_DAIFMT_DSP_B
:
293 ctl
&= ~S3C_PCM_CTL_TXMSB_AFTER_FSYNC
;
294 ctl
&= ~S3C_PCM_CTL_RXMSB_AFTER_FSYNC
;
297 dev_err(pcm
->dev
, "Unsupported data format!\n");
302 writel(ctl
, regs
+ S3C_PCM_CTL
);
305 spin_unlock_irqrestore(&pcm
->lock
, flags
);
310 static int s3c_pcm_set_clkdiv(struct snd_soc_dai
*cpu_dai
,
313 struct s3c_pcm_info
*pcm
= snd_soc_dai_get_drvdata(cpu_dai
);
316 case S3C_PCM_SCLK_PER_FS
:
317 pcm
->sclk_per_fs
= div
;
327 static int s3c_pcm_set_sysclk(struct snd_soc_dai
*cpu_dai
,
328 int clk_id
, unsigned int freq
, int dir
)
330 struct s3c_pcm_info
*pcm
= snd_soc_dai_get_drvdata(cpu_dai
);
331 void __iomem
*regs
= pcm
->regs
;
332 u32 clkctl
= readl(regs
+ S3C_PCM_CLKCTL
);
335 case S3C_PCM_CLKSRC_PCLK
:
336 clkctl
|= S3C_PCM_CLKCTL_SERCLKSEL_PCLK
;
339 case S3C_PCM_CLKSRC_MUX
:
340 clkctl
&= ~S3C_PCM_CLKCTL_SERCLKSEL_PCLK
;
342 if (clk_get_rate(pcm
->cclk
) != freq
)
343 clk_set_rate(pcm
->cclk
, freq
);
351 writel(clkctl
, regs
+ S3C_PCM_CLKCTL
);
356 static struct snd_soc_dai_ops s3c_pcm_dai_ops
= {
357 .set_sysclk
= s3c_pcm_set_sysclk
,
358 .set_clkdiv
= s3c_pcm_set_clkdiv
,
359 .trigger
= s3c_pcm_trigger
,
360 .hw_params
= s3c_pcm_hw_params
,
361 .set_fmt
= s3c_pcm_set_fmt
,
364 #define S3C_PCM_RATES SNDRV_PCM_RATE_8000_96000
366 #define S3C_PCM_DAI_DECLARE \
368 .name = "samsung-dai", \
369 .symmetric_rates = 1, \
370 .ops = &s3c_pcm_dai_ops, \
374 .rates = S3C_PCM_RATES, \
375 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
380 .rates = S3C_PCM_RATES, \
381 .formats = SNDRV_PCM_FMTBIT_S16_LE, \
385 struct snd_soc_dai_driver s3c_pcm_dai
[] = {
389 EXPORT_SYMBOL_GPL(s3c_pcm_dai
);
391 static __devinit
int s3c_pcm_dev_probe(struct platform_device
*pdev
)
393 struct s3c_pcm_info
*pcm
;
394 struct resource
*mem_res
, *dmatx_res
, *dmarx_res
;
395 struct s3c_audio_pdata
*pcm_pdata
;
398 /* Check for valid device index */
399 if ((pdev
->id
< 0) || pdev
->id
>= ARRAY_SIZE(s3c_pcm
)) {
400 dev_err(&pdev
->dev
, "id %d out of range\n", pdev
->id
);
404 pcm_pdata
= pdev
->dev
.platform_data
;
406 /* Check for availability of necessary resource */
407 dmatx_res
= platform_get_resource(pdev
, IORESOURCE_DMA
, 0);
409 dev_err(&pdev
->dev
, "Unable to get PCM-TX dma resource\n");
413 dmarx_res
= platform_get_resource(pdev
, IORESOURCE_DMA
, 1);
415 dev_err(&pdev
->dev
, "Unable to get PCM-RX dma resource\n");
419 mem_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
421 dev_err(&pdev
->dev
, "Unable to get register resource\n");
425 if (pcm_pdata
&& pcm_pdata
->cfg_gpio
&& pcm_pdata
->cfg_gpio(pdev
)) {
426 dev_err(&pdev
->dev
, "Unable to configure gpio\n");
430 pcm
= &s3c_pcm
[pdev
->id
];
431 pcm
->dev
= &pdev
->dev
;
433 spin_lock_init(&pcm
->lock
);
435 /* Default is 128fs */
436 pcm
->sclk_per_fs
= 128;
438 pcm
->cclk
= clk_get(&pdev
->dev
, "audio-bus");
439 if (IS_ERR(pcm
->cclk
)) {
440 dev_err(&pdev
->dev
, "failed to get audio-bus\n");
441 ret
= PTR_ERR(pcm
->cclk
);
444 clk_enable(pcm
->cclk
);
446 /* record our pcm structure for later use in the callbacks */
447 dev_set_drvdata(&pdev
->dev
, pcm
);
449 if (!request_mem_region(mem_res
->start
,
450 resource_size(mem_res
), "samsung-pcm")) {
451 dev_err(&pdev
->dev
, "Unable to request register region\n");
456 pcm
->regs
= ioremap(mem_res
->start
, 0x100);
457 if (pcm
->regs
== NULL
) {
458 dev_err(&pdev
->dev
, "cannot ioremap registers\n");
463 pcm
->pclk
= clk_get(&pdev
->dev
, "pcm");
464 if (IS_ERR(pcm
->pclk
)) {
465 dev_err(&pdev
->dev
, "failed to get pcm_clock\n");
469 clk_enable(pcm
->pclk
);
471 ret
= snd_soc_register_dai(&pdev
->dev
, s3c_pcm_dai
);
473 dev_err(&pdev
->dev
, "failed to get pcm_clock\n");
477 s3c_pcm_stereo_in
[pdev
->id
].dma_addr
= mem_res
->start
479 s3c_pcm_stereo_out
[pdev
->id
].dma_addr
= mem_res
->start
482 s3c_pcm_stereo_in
[pdev
->id
].channel
= dmarx_res
->start
;
483 s3c_pcm_stereo_out
[pdev
->id
].channel
= dmatx_res
->start
;
485 pcm
->dma_capture
= &s3c_pcm_stereo_in
[pdev
->id
];
486 pcm
->dma_playback
= &s3c_pcm_stereo_out
[pdev
->id
];
491 clk_disable(pcm
->pclk
);
496 release_mem_region(mem_res
->start
, resource_size(mem_res
));
498 clk_disable(pcm
->cclk
);
504 static __devexit
int s3c_pcm_dev_remove(struct platform_device
*pdev
)
506 struct s3c_pcm_info
*pcm
= &s3c_pcm
[pdev
->id
];
507 struct resource
*mem_res
;
509 snd_soc_unregister_dai(&pdev
->dev
);
513 mem_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
514 release_mem_region(mem_res
->start
, resource_size(mem_res
));
516 clk_disable(pcm
->cclk
);
517 clk_disable(pcm
->pclk
);
524 static struct platform_driver s3c_pcm_driver
= {
525 .probe
= s3c_pcm_dev_probe
,
526 .remove
= s3c_pcm_dev_remove
,
528 .name
= "samsung-pcm",
529 .owner
= THIS_MODULE
,
533 static int __init
s3c_pcm_init(void)
535 return platform_driver_register(&s3c_pcm_driver
);
537 module_init(s3c_pcm_init
);
539 static void __exit
s3c_pcm_exit(void)
541 platform_driver_unregister(&s3c_pcm_driver
);
543 module_exit(s3c_pcm_exit
);
545 /* Module information */
546 MODULE_AUTHOR("Jaswinder Singh, <jassi.brar@samsung.com>");
547 MODULE_DESCRIPTION("S3C PCM Controller Driver");
548 MODULE_LICENSE("GPL");
549 MODULE_ALIAS("platform:samsung-pcm");