2 * ALSA SoC McASP Audio Layer for TI DAVINCI processor
4 * Multi-channel Audio Serial Port Driver
6 * Author: Nirmal Pandey <n-pandey@ti.com>,
7 * Suresh Rajashekara <suresh.r@ti.com>
8 * Steve Chen <schen@.mvista.com>
10 * Copyright: (C) 2009 MontaVista Software, Inc., <source@mvista.com>
11 * Copyright: (C) 2009 Texas Instruments, India
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License version 2 as
15 * published by the Free Software Foundation.
18 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/device.h>
21 #include <linux/slab.h>
22 #include <linux/delay.h>
24 #include <linux/clk.h>
25 #include <linux/pm_runtime.h>
27 #include <linux/of_platform.h>
28 #include <linux/of_device.h>
30 #include <sound/core.h>
31 #include <sound/pcm.h>
32 #include <sound/pcm_params.h>
33 #include <sound/initval.h>
34 #include <sound/soc.h>
35 #include <sound/dmaengine_pcm.h>
37 #include "davinci-pcm.h"
38 #include "davinci-mcasp.h"
40 #define MCASP_MAX_AFIFO_DEPTH 64
42 struct davinci_mcasp_context
{
52 struct davinci_mcasp
{
53 struct davinci_pcm_dma_params dma_params
[2];
54 struct snd_dmaengine_dai_dma_data dma_data
[2];
59 /* McASP specific data */
71 /* McASP FIFO related */
77 #ifdef CONFIG_PM_SLEEP
78 struct davinci_mcasp_context context
;
82 static inline void mcasp_set_bits(struct davinci_mcasp
*mcasp
, u32 offset
,
85 void __iomem
*reg
= mcasp
->base
+ offset
;
86 __raw_writel(__raw_readl(reg
) | val
, reg
);
89 static inline void mcasp_clr_bits(struct davinci_mcasp
*mcasp
, u32 offset
,
92 void __iomem
*reg
= mcasp
->base
+ offset
;
93 __raw_writel((__raw_readl(reg
) & ~(val
)), reg
);
96 static inline void mcasp_mod_bits(struct davinci_mcasp
*mcasp
, u32 offset
,
99 void __iomem
*reg
= mcasp
->base
+ offset
;
100 __raw_writel((__raw_readl(reg
) & ~mask
) | val
, reg
);
103 static inline void mcasp_set_reg(struct davinci_mcasp
*mcasp
, u32 offset
,
106 __raw_writel(val
, mcasp
->base
+ offset
);
109 static inline u32
mcasp_get_reg(struct davinci_mcasp
*mcasp
, u32 offset
)
111 return (u32
)__raw_readl(mcasp
->base
+ offset
);
114 static void mcasp_set_ctl_reg(struct davinci_mcasp
*mcasp
, u32 ctl_reg
, u32 val
)
118 mcasp_set_bits(mcasp
, ctl_reg
, val
);
120 /* programming GBLCTL needs to read back from GBLCTL and verfiy */
121 /* loop count is to avoid the lock-up */
122 for (i
= 0; i
< 1000; i
++) {
123 if ((mcasp_get_reg(mcasp
, ctl_reg
) & val
) == val
)
127 if (i
== 1000 && ((mcasp_get_reg(mcasp
, ctl_reg
) & val
) != val
))
128 printk(KERN_ERR
"GBLCTL write error\n");
131 static bool mcasp_is_synchronous(struct davinci_mcasp
*mcasp
)
133 u32 rxfmctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
);
134 u32 aclkxctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
);
136 return !(aclkxctl
& TX_ASYNC
) && rxfmctl
& AFSRE
;
139 static void mcasp_start_rx(struct davinci_mcasp
*mcasp
)
141 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXHCLKRST
);
142 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXCLKRST
);
145 * When ASYNC == 0 the transmit and receive sections operate
146 * synchronously from the transmit clock and frame sync. We need to make
147 * sure that the TX signlas are enabled when starting reception.
149 if (mcasp_is_synchronous(mcasp
)) {
150 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXHCLKRST
);
151 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXCLKRST
);
154 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXSERCLR
);
155 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXBUF_REG
, 0);
157 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXSMRST
);
158 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXFSRST
);
159 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXBUF_REG
, 0);
161 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXSMRST
);
162 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, RXFSRST
);
164 if (mcasp_is_synchronous(mcasp
))
165 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXFSRST
);
168 static void mcasp_start_tx(struct davinci_mcasp
*mcasp
)
173 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXHCLKRST
);
174 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXCLKRST
);
175 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXSERCLR
);
176 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXBUF_REG
, 0);
178 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXSMRST
);
179 mcasp_set_ctl_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, TXFSRST
);
180 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXBUF_REG
, 0);
181 for (i
= 0; i
< mcasp
->num_serializer
; i
++) {
182 if (mcasp
->serial_dir
[i
] == TX_MODE
) {
188 /* wait for TX ready */
190 while (!(mcasp_get_reg(mcasp
, DAVINCI_MCASP_XRSRCTL_REG(offset
)) &
191 TXSTATE
) && (cnt
< 100000))
194 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXBUF_REG
, 0);
197 static void davinci_mcasp_start(struct davinci_mcasp
*mcasp
, int stream
)
203 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
204 if (mcasp
->txnumevt
) { /* enable FIFO */
205 reg
= mcasp
->fifo_base
+ MCASP_WFIFOCTL_OFFSET
;
206 mcasp_clr_bits(mcasp
, reg
, FIFO_ENABLE
);
207 mcasp_set_bits(mcasp
, reg
, FIFO_ENABLE
);
209 mcasp_start_tx(mcasp
);
211 if (mcasp
->rxnumevt
) { /* enable FIFO */
212 reg
= mcasp
->fifo_base
+ MCASP_RFIFOCTL_OFFSET
;
213 mcasp_clr_bits(mcasp
, reg
, FIFO_ENABLE
);
214 mcasp_set_bits(mcasp
, reg
, FIFO_ENABLE
);
216 mcasp_start_rx(mcasp
);
220 static void mcasp_stop_rx(struct davinci_mcasp
*mcasp
)
223 * In synchronous mode stop the TX clocks if no other stream is
226 if (mcasp_is_synchronous(mcasp
) && !mcasp
->streams
)
227 mcasp_set_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, 0);
229 mcasp_set_reg(mcasp
, DAVINCI_MCASP_GBLCTLR_REG
, 0);
230 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXSTAT_REG
, 0xFFFFFFFF);
233 static void mcasp_stop_tx(struct davinci_mcasp
*mcasp
)
238 * In synchronous mode keep TX clocks running if the capture stream is
241 if (mcasp_is_synchronous(mcasp
) && mcasp
->streams
)
242 val
= TXHCLKRST
| TXCLKRST
| TXFSRST
;
244 mcasp_set_reg(mcasp
, DAVINCI_MCASP_GBLCTLX_REG
, val
);
245 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXSTAT_REG
, 0xFFFFFFFF);
248 static void davinci_mcasp_stop(struct davinci_mcasp
*mcasp
, int stream
)
254 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
255 if (mcasp
->txnumevt
) { /* disable FIFO */
256 reg
= mcasp
->fifo_base
+ MCASP_WFIFOCTL_OFFSET
;
257 mcasp_clr_bits(mcasp
, reg
, FIFO_ENABLE
);
259 mcasp_stop_tx(mcasp
);
261 if (mcasp
->rxnumevt
) { /* disable FIFO */
262 reg
= mcasp
->fifo_base
+ MCASP_RFIFOCTL_OFFSET
;
263 mcasp_clr_bits(mcasp
, reg
, FIFO_ENABLE
);
265 mcasp_stop_rx(mcasp
);
269 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai
*cpu_dai
,
272 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(cpu_dai
);
275 pm_runtime_get_sync(mcasp
->dev
);
276 switch (fmt
& SND_SOC_DAIFMT_FORMAT_MASK
) {
277 case SND_SOC_DAIFMT_DSP_B
:
278 case SND_SOC_DAIFMT_AC97
:
279 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXDUR
);
280 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRDUR
);
283 /* configure a full-word SYNC pulse (LRCLK) */
284 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXDUR
);
285 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRDUR
);
287 /* make 1st data bit occur one ACLK cycle after the frame sync */
288 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMT_REG
, FSXDLY(1));
289 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMT_REG
, FSRDLY(1));
293 switch (fmt
& SND_SOC_DAIFMT_MASTER_MASK
) {
294 case SND_SOC_DAIFMT_CBS_CFS
:
295 /* codec is clock and frame slave */
296 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXE
);
297 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, AFSXE
);
299 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRE
);
300 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, AFSRE
);
302 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, ACLKX
| ACLKR
);
303 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AFSX
| AFSR
);
304 mcasp
->bclk_master
= 1;
306 case SND_SOC_DAIFMT_CBM_CFS
:
307 /* codec is clock master and frame slave */
308 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXE
);
309 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, AFSXE
);
311 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRE
);
312 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, AFSRE
);
314 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, ACLKX
| ACLKR
);
315 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AFSX
| AFSR
);
316 mcasp
->bclk_master
= 0;
318 case SND_SOC_DAIFMT_CBM_CFM
:
319 /* codec is clock and frame master */
320 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXE
);
321 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, AFSXE
);
323 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRE
);
324 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, AFSRE
);
326 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
,
327 ACLKX
| AHCLKX
| AFSX
| ACLKR
| AHCLKR
| AFSR
);
328 mcasp
->bclk_master
= 0;
336 switch (fmt
& SND_SOC_DAIFMT_INV_MASK
) {
337 case SND_SOC_DAIFMT_IB_NF
:
338 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXPOL
);
339 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXPOL
);
341 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRPOL
);
342 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRPOL
);
345 case SND_SOC_DAIFMT_NB_IF
:
346 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXPOL
);
347 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXPOL
);
349 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRPOL
);
350 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRPOL
);
353 case SND_SOC_DAIFMT_IB_IF
:
354 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXPOL
);
355 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXPOL
);
357 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRPOL
);
358 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRPOL
);
361 case SND_SOC_DAIFMT_NB_NF
:
362 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXPOL
);
363 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, FSXPOL
);
365 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, ACLKRPOL
);
366 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, FSRPOL
);
374 pm_runtime_put_sync(mcasp
->dev
);
378 static int davinci_mcasp_set_clkdiv(struct snd_soc_dai
*dai
, int div_id
, int div
)
380 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(dai
);
383 case 0: /* MCLK divider */
384 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_AHCLKXCTL_REG
,
385 AHCLKXDIV(div
- 1), AHCLKXDIV_MASK
);
386 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_AHCLKRCTL_REG
,
387 AHCLKRDIV(div
- 1), AHCLKRDIV_MASK
);
390 case 1: /* BCLK divider */
391 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
,
392 ACLKXDIV(div
- 1), ACLKXDIV_MASK
);
393 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
,
394 ACLKRDIV(div
- 1), ACLKRDIV_MASK
);
397 case 2: /* BCLK/LRCLK ratio */
398 mcasp
->bclk_lrclk_ratio
= div
;
408 static int davinci_mcasp_set_sysclk(struct snd_soc_dai
*dai
, int clk_id
,
409 unsigned int freq
, int dir
)
411 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(dai
);
413 if (dir
== SND_SOC_CLOCK_OUT
) {
414 mcasp_set_bits(mcasp
, DAVINCI_MCASP_AHCLKXCTL_REG
, AHCLKXE
);
415 mcasp_set_bits(mcasp
, DAVINCI_MCASP_AHCLKRCTL_REG
, AHCLKRE
);
416 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AHCLKX
);
418 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_AHCLKXCTL_REG
, AHCLKXE
);
419 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_AHCLKRCTL_REG
, AHCLKRE
);
420 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AHCLKX
);
423 mcasp
->sysclk_freq
= freq
;
428 static int davinci_config_channel_size(struct davinci_mcasp
*mcasp
,
432 u32 tx_rotate
= (word_length
/ 4) & 0x7;
433 u32 rx_rotate
= (32 - word_length
) / 4;
434 u32 mask
= (1ULL << word_length
) - 1;
437 * if s BCLK-to-LRCLK ratio has been configured via the set_clkdiv()
438 * callback, take it into account here. That allows us to for example
439 * send 32 bits per channel to the codec, while only 16 of them carry
441 * The clock ratio is given for a full period of data (for I2S format
442 * both left and right channels), so it has to be divided by number of
443 * tdm-slots (for I2S - divided by 2).
445 if (mcasp
->bclk_lrclk_ratio
)
446 word_length
= mcasp
->bclk_lrclk_ratio
/ mcasp
->tdm_slots
;
448 /* mapping of the XSSZ bit-field as described in the datasheet */
449 fmt
= (word_length
>> 1) - 1;
451 if (mcasp
->op_mode
!= DAVINCI_MCASP_DIT_MODE
) {
452 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_RXFMT_REG
, RXSSZ(fmt
),
454 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_TXFMT_REG
, TXSSZ(fmt
),
456 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_TXFMT_REG
, TXROT(tx_rotate
),
458 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_RXFMT_REG
, RXROT(rx_rotate
),
460 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXMASK_REG
, mask
);
463 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXMASK_REG
, mask
);
468 static int mcasp_common_hw_param(struct davinci_mcasp
*mcasp
, int stream
,
474 u8 slots
= mcasp
->tdm_slots
;
475 u8 max_active_serializers
= (channels
+ slots
- 1) / slots
;
476 u8 active_serializers
, numevt
;
478 /* Default configuration */
479 if (mcasp
->version
!= MCASP_VERSION_4
)
480 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PWREMUMGT_REG
, MCASP_SOFT
);
482 /* All PINS as McASP */
483 mcasp_set_reg(mcasp
, DAVINCI_MCASP_PFUNC_REG
, 0x00000000);
485 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
486 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXSTAT_REG
, 0xFFFFFFFF);
487 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_XEVTCTL_REG
, TXDATADMADIS
);
489 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXSTAT_REG
, 0xFFFFFFFF);
490 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_REVTCTL_REG
, RXDATADMADIS
);
493 for (i
= 0; i
< mcasp
->num_serializer
; i
++) {
494 mcasp_set_bits(mcasp
, DAVINCI_MCASP_XRSRCTL_REG(i
),
495 mcasp
->serial_dir
[i
]);
496 if (mcasp
->serial_dir
[i
] == TX_MODE
&&
497 tx_ser
< max_active_serializers
) {
498 mcasp_set_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AXR(i
));
500 } else if (mcasp
->serial_dir
[i
] == RX_MODE
&&
501 rx_ser
< max_active_serializers
) {
502 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_PDIR_REG
, AXR(i
));
505 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_XRSRCTL_REG(i
),
506 SRMOD_INACTIVE
, SRMOD_MASK
);
510 if (stream
== SNDRV_PCM_STREAM_PLAYBACK
) {
511 active_serializers
= tx_ser
;
512 numevt
= mcasp
->txnumevt
;
513 reg
= mcasp
->fifo_base
+ MCASP_WFIFOCTL_OFFSET
;
515 active_serializers
= rx_ser
;
516 numevt
= mcasp
->rxnumevt
;
517 reg
= mcasp
->fifo_base
+ MCASP_RFIFOCTL_OFFSET
;
520 if (active_serializers
< max_active_serializers
) {
521 dev_warn(mcasp
->dev
, "stream has more channels (%d) than are "
522 "enabled in mcasp (%d)\n", channels
,
523 active_serializers
* slots
);
527 /* AFIFO is not in use */
531 if (numevt
* active_serializers
> MCASP_MAX_AFIFO_DEPTH
)
532 numevt
= active_serializers
;
534 /* Configure the AFIFO */
535 numevt
*= active_serializers
;
536 mcasp_mod_bits(mcasp
, reg
, active_serializers
, NUMDMA_MASK
);
537 mcasp_mod_bits(mcasp
, reg
, NUMEVT(numevt
), NUMEVT_MASK
);
542 static int mcasp_i2s_hw_param(struct davinci_mcasp
*mcasp
, int stream
)
548 if ((mcasp
->tdm_slots
< 2) || (mcasp
->tdm_slots
> 32)) {
549 dev_err(mcasp
->dev
, "tdm slot %d not supported\n",
554 active_slots
= (mcasp
->tdm_slots
> 31) ? 32 : mcasp
->tdm_slots
;
555 for (i
= 0; i
< active_slots
; i
++)
558 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, TX_ASYNC
);
560 if (!mcasp
->dat_port
)
563 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXTDM_REG
, mask
);
564 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMT_REG
, busel
| TXORD
);
565 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
,
566 FSXMOD(mcasp
->tdm_slots
), FSXMOD(0x1FF));
568 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXTDM_REG
, mask
);
569 mcasp_set_bits(mcasp
, DAVINCI_MCASP_RXFMT_REG
, busel
| RXORD
);
570 mcasp_mod_bits(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
,
571 FSRMOD(mcasp
->tdm_slots
), FSRMOD(0x1FF));
577 static int mcasp_dit_hw_param(struct davinci_mcasp
*mcasp
)
579 /* Set the TX format : 24 bit right rotation, 32 bit slot, Pad 0
581 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXFMT_REG
, TXROT(6) | TXSSZ(15));
583 /* Set TX frame synch : DIT Mode, 1 bit width, internal, rising edge */
584 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, AFSXE
| FSXMOD(0x180));
586 /* Set the TX tdm : for all the slots */
587 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXTDM_REG
, 0xFFFFFFFF);
589 /* Set the TX clock controls : div = 1 and internal */
590 mcasp_set_bits(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, ACLKXE
| TX_ASYNC
);
592 mcasp_clr_bits(mcasp
, DAVINCI_MCASP_XEVTCTL_REG
, TXDATADMADIS
);
594 /* Only 44100 and 48000 are valid, both have the same setting */
595 mcasp_set_bits(mcasp
, DAVINCI_MCASP_AHCLKXCTL_REG
, AHCLKXDIV(3));
598 mcasp_set_bits(mcasp
, DAVINCI_MCASP_TXDITCTL_REG
, DITEN
);
603 static int davinci_mcasp_hw_params(struct snd_pcm_substream
*substream
,
604 struct snd_pcm_hw_params
*params
,
605 struct snd_soc_dai
*cpu_dai
)
607 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(cpu_dai
);
608 struct davinci_pcm_dma_params
*dma_params
=
609 &mcasp
->dma_params
[substream
->stream
];
610 struct snd_dmaengine_dai_dma_data
*dma_data
=
611 &mcasp
->dma_data
[substream
->stream
];
614 u8 slots
= mcasp
->tdm_slots
;
615 u8 active_serializers
;
616 int channels
= params_channels(params
);
619 /* If mcasp is BCLK master we need to set BCLK divider */
620 if (mcasp
->bclk_master
) {
621 unsigned int bclk_freq
= snd_soc_params_to_bclk(params
);
622 if (mcasp
->sysclk_freq
% bclk_freq
!= 0) {
623 dev_err(mcasp
->dev
, "Can't produce required BCLK\n");
626 davinci_mcasp_set_clkdiv(
627 cpu_dai
, 1, mcasp
->sysclk_freq
/ bclk_freq
);
630 ret
= mcasp_common_hw_param(mcasp
, substream
->stream
, channels
);
634 if (mcasp
->op_mode
== DAVINCI_MCASP_DIT_MODE
)
635 ret
= mcasp_dit_hw_param(mcasp
);
637 ret
= mcasp_i2s_hw_param(mcasp
, substream
->stream
);
642 switch (params_format(params
)) {
643 case SNDRV_PCM_FORMAT_U8
:
644 case SNDRV_PCM_FORMAT_S8
:
645 dma_params
->data_type
= 1;
649 case SNDRV_PCM_FORMAT_U16_LE
:
650 case SNDRV_PCM_FORMAT_S16_LE
:
651 dma_params
->data_type
= 2;
655 case SNDRV_PCM_FORMAT_U24_3LE
:
656 case SNDRV_PCM_FORMAT_S24_3LE
:
657 dma_params
->data_type
= 3;
661 case SNDRV_PCM_FORMAT_U24_LE
:
662 case SNDRV_PCM_FORMAT_S24_LE
:
663 case SNDRV_PCM_FORMAT_U32_LE
:
664 case SNDRV_PCM_FORMAT_S32_LE
:
665 dma_params
->data_type
= 4;
670 printk(KERN_WARNING
"davinci-mcasp: unsupported PCM format");
674 /* Calculate FIFO level */
675 active_serializers
= (channels
+ slots
- 1) / slots
;
676 if (substream
->stream
== SNDRV_PCM_STREAM_PLAYBACK
)
677 fifo_level
= mcasp
->txnumevt
* active_serializers
;
679 fifo_level
= mcasp
->rxnumevt
* active_serializers
;
681 if (mcasp
->version
== MCASP_VERSION_2
&& !fifo_level
)
682 dma_params
->acnt
= 4;
684 dma_params
->acnt
= dma_params
->data_type
;
686 dma_params
->fifo_level
= fifo_level
;
687 dma_data
->maxburst
= fifo_level
;
689 davinci_config_channel_size(mcasp
, word_length
);
694 static int davinci_mcasp_trigger(struct snd_pcm_substream
*substream
,
695 int cmd
, struct snd_soc_dai
*cpu_dai
)
697 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(cpu_dai
);
701 case SNDRV_PCM_TRIGGER_RESUME
:
702 case SNDRV_PCM_TRIGGER_START
:
703 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE
:
704 davinci_mcasp_start(mcasp
, substream
->stream
);
706 case SNDRV_PCM_TRIGGER_SUSPEND
:
707 case SNDRV_PCM_TRIGGER_STOP
:
708 case SNDRV_PCM_TRIGGER_PAUSE_PUSH
:
709 davinci_mcasp_stop(mcasp
, substream
->stream
);
719 static const struct snd_soc_dai_ops davinci_mcasp_dai_ops
= {
720 .trigger
= davinci_mcasp_trigger
,
721 .hw_params
= davinci_mcasp_hw_params
,
722 .set_fmt
= davinci_mcasp_set_dai_fmt
,
723 .set_clkdiv
= davinci_mcasp_set_clkdiv
,
724 .set_sysclk
= davinci_mcasp_set_sysclk
,
727 static int davinci_mcasp_dai_probe(struct snd_soc_dai
*dai
)
729 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(dai
);
731 if (mcasp
->version
== MCASP_VERSION_4
) {
732 /* Using dmaengine PCM */
733 dai
->playback_dma_data
=
734 &mcasp
->dma_data
[SNDRV_PCM_STREAM_PLAYBACK
];
735 dai
->capture_dma_data
=
736 &mcasp
->dma_data
[SNDRV_PCM_STREAM_CAPTURE
];
738 /* Using davinci-pcm */
739 dai
->playback_dma_data
= mcasp
->dma_params
;
740 dai
->capture_dma_data
= mcasp
->dma_params
;
746 #ifdef CONFIG_PM_SLEEP
747 static int davinci_mcasp_suspend(struct snd_soc_dai
*dai
)
749 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(dai
);
750 struct davinci_mcasp_context
*context
= &mcasp
->context
;
752 context
->txfmtctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
);
753 context
->rxfmtctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
);
754 context
->txfmt
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_TXFMT_REG
);
755 context
->rxfmt
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_RXFMT_REG
);
756 context
->aclkxctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
);
757 context
->aclkrctl
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
);
758 context
->pdir
= mcasp_get_reg(mcasp
, DAVINCI_MCASP_PDIR_REG
);
763 static int davinci_mcasp_resume(struct snd_soc_dai
*dai
)
765 struct davinci_mcasp
*mcasp
= snd_soc_dai_get_drvdata(dai
);
766 struct davinci_mcasp_context
*context
= &mcasp
->context
;
768 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXFMCTL_REG
, context
->txfmtctl
);
769 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXFMCTL_REG
, context
->rxfmtctl
);
770 mcasp_set_reg(mcasp
, DAVINCI_MCASP_TXFMT_REG
, context
->txfmt
);
771 mcasp_set_reg(mcasp
, DAVINCI_MCASP_RXFMT_REG
, context
->rxfmt
);
772 mcasp_set_reg(mcasp
, DAVINCI_MCASP_ACLKXCTL_REG
, context
->aclkxctl
);
773 mcasp_set_reg(mcasp
, DAVINCI_MCASP_ACLKRCTL_REG
, context
->aclkrctl
);
774 mcasp_set_reg(mcasp
, DAVINCI_MCASP_PDIR_REG
, context
->pdir
);
779 #define davinci_mcasp_suspend NULL
780 #define davinci_mcasp_resume NULL
783 #define DAVINCI_MCASP_RATES SNDRV_PCM_RATE_8000_192000
785 #define DAVINCI_MCASP_PCM_FMTS (SNDRV_PCM_FMTBIT_S8 | \
786 SNDRV_PCM_FMTBIT_U8 | \
787 SNDRV_PCM_FMTBIT_S16_LE | \
788 SNDRV_PCM_FMTBIT_U16_LE | \
789 SNDRV_PCM_FMTBIT_S24_LE | \
790 SNDRV_PCM_FMTBIT_U24_LE | \
791 SNDRV_PCM_FMTBIT_S24_3LE | \
792 SNDRV_PCM_FMTBIT_U24_3LE | \
793 SNDRV_PCM_FMTBIT_S32_LE | \
794 SNDRV_PCM_FMTBIT_U32_LE)
796 static struct snd_soc_dai_driver davinci_mcasp_dai
[] = {
798 .name
= "davinci-mcasp.0",
799 .probe
= davinci_mcasp_dai_probe
,
800 .suspend
= davinci_mcasp_suspend
,
801 .resume
= davinci_mcasp_resume
,
804 .channels_max
= 32 * 16,
805 .rates
= DAVINCI_MCASP_RATES
,
806 .formats
= DAVINCI_MCASP_PCM_FMTS
,
810 .channels_max
= 32 * 16,
811 .rates
= DAVINCI_MCASP_RATES
,
812 .formats
= DAVINCI_MCASP_PCM_FMTS
,
814 .ops
= &davinci_mcasp_dai_ops
,
818 .name
= "davinci-mcasp.1",
819 .probe
= davinci_mcasp_dai_probe
,
823 .rates
= DAVINCI_MCASP_RATES
,
824 .formats
= DAVINCI_MCASP_PCM_FMTS
,
826 .ops
= &davinci_mcasp_dai_ops
,
831 static const struct snd_soc_component_driver davinci_mcasp_component
= {
832 .name
= "davinci-mcasp",
835 /* Some HW specific values and defaults. The rest is filled in from DT. */
836 static struct davinci_mcasp_pdata dm646x_mcasp_pdata
= {
837 .tx_dma_offset
= 0x400,
838 .rx_dma_offset
= 0x400,
839 .asp_chan_q
= EVENTQ_0
,
840 .version
= MCASP_VERSION_1
,
843 static struct davinci_mcasp_pdata da830_mcasp_pdata
= {
844 .tx_dma_offset
= 0x2000,
845 .rx_dma_offset
= 0x2000,
846 .asp_chan_q
= EVENTQ_0
,
847 .version
= MCASP_VERSION_2
,
850 static struct davinci_mcasp_pdata am33xx_mcasp_pdata
= {
853 .asp_chan_q
= EVENTQ_0
,
854 .version
= MCASP_VERSION_3
,
857 static struct davinci_mcasp_pdata dra7_mcasp_pdata
= {
858 .tx_dma_offset
= 0x200,
859 .rx_dma_offset
= 0x284,
860 .asp_chan_q
= EVENTQ_0
,
861 .version
= MCASP_VERSION_4
,
864 static const struct of_device_id mcasp_dt_ids
[] = {
866 .compatible
= "ti,dm646x-mcasp-audio",
867 .data
= &dm646x_mcasp_pdata
,
870 .compatible
= "ti,da830-mcasp-audio",
871 .data
= &da830_mcasp_pdata
,
874 .compatible
= "ti,am33xx-mcasp-audio",
875 .data
= &am33xx_mcasp_pdata
,
878 .compatible
= "ti,dra7-mcasp-audio",
879 .data
= &dra7_mcasp_pdata
,
883 MODULE_DEVICE_TABLE(of
, mcasp_dt_ids
);
885 static int mcasp_reparent_fck(struct platform_device
*pdev
)
887 struct device_node
*node
= pdev
->dev
.of_node
;
888 struct clk
*gfclk
, *parent_clk
;
889 const char *parent_name
;
895 parent_name
= of_get_property(node
, "fck_parent", NULL
);
899 gfclk
= clk_get(&pdev
->dev
, "fck");
901 dev_err(&pdev
->dev
, "failed to get fck\n");
902 return PTR_ERR(gfclk
);
905 parent_clk
= clk_get(NULL
, parent_name
);
906 if (IS_ERR(parent_clk
)) {
907 dev_err(&pdev
->dev
, "failed to get parent clock\n");
908 ret
= PTR_ERR(parent_clk
);
912 ret
= clk_set_parent(gfclk
, parent_clk
);
914 dev_err(&pdev
->dev
, "failed to reparent fck\n");
925 static struct davinci_mcasp_pdata
*davinci_mcasp_set_pdata_from_of(
926 struct platform_device
*pdev
)
928 struct device_node
*np
= pdev
->dev
.of_node
;
929 struct davinci_mcasp_pdata
*pdata
= NULL
;
930 const struct of_device_id
*match
=
931 of_match_device(mcasp_dt_ids
, &pdev
->dev
);
932 struct of_phandle_args dma_spec
;
934 const u32
*of_serial_dir32
;
938 if (pdev
->dev
.platform_data
) {
939 pdata
= pdev
->dev
.platform_data
;
942 pdata
= (struct davinci_mcasp_pdata
*) match
->data
;
944 /* control shouldn't reach here. something is wrong */
949 ret
= of_property_read_u32(np
, "op-mode", &val
);
951 pdata
->op_mode
= val
;
953 ret
= of_property_read_u32(np
, "tdm-slots", &val
);
955 if (val
< 2 || val
> 32) {
957 "tdm-slots must be in rage [2-32]\n");
962 pdata
->tdm_slots
= val
;
965 of_serial_dir32
= of_get_property(np
, "serial-dir", &val
);
967 if (of_serial_dir32
) {
968 u8
*of_serial_dir
= devm_kzalloc(&pdev
->dev
,
969 (sizeof(*of_serial_dir
) * val
),
971 if (!of_serial_dir
) {
976 for (i
= 0; i
< val
; i
++)
977 of_serial_dir
[i
] = be32_to_cpup(&of_serial_dir32
[i
]);
979 pdata
->num_serializer
= val
;
980 pdata
->serial_dir
= of_serial_dir
;
983 ret
= of_property_match_string(np
, "dma-names", "tx");
987 ret
= of_parse_phandle_with_args(np
, "dmas", "#dma-cells", ret
,
992 pdata
->tx_dma_channel
= dma_spec
.args
[0];
994 ret
= of_property_match_string(np
, "dma-names", "rx");
998 ret
= of_parse_phandle_with_args(np
, "dmas", "#dma-cells", ret
,
1003 pdata
->rx_dma_channel
= dma_spec
.args
[0];
1005 ret
= of_property_read_u32(np
, "tx-num-evt", &val
);
1007 pdata
->txnumevt
= val
;
1009 ret
= of_property_read_u32(np
, "rx-num-evt", &val
);
1011 pdata
->rxnumevt
= val
;
1013 ret
= of_property_read_u32(np
, "sram-size-playback", &val
);
1015 pdata
->sram_size_playback
= val
;
1017 ret
= of_property_read_u32(np
, "sram-size-capture", &val
);
1019 pdata
->sram_size_capture
= val
;
1025 dev_err(&pdev
->dev
, "Error populating platform data, err %d\n",
1032 static int davinci_mcasp_probe(struct platform_device
*pdev
)
1034 struct davinci_pcm_dma_params
*dma_params
;
1035 struct snd_dmaengine_dai_dma_data
*dma_data
;
1036 struct resource
*mem
, *ioarea
, *res
, *dat
;
1037 struct davinci_mcasp_pdata
*pdata
;
1038 struct davinci_mcasp
*mcasp
;
1041 if (!pdev
->dev
.platform_data
&& !pdev
->dev
.of_node
) {
1042 dev_err(&pdev
->dev
, "No platform data supplied\n");
1046 mcasp
= devm_kzalloc(&pdev
->dev
, sizeof(struct davinci_mcasp
),
1051 pdata
= davinci_mcasp_set_pdata_from_of(pdev
);
1053 dev_err(&pdev
->dev
, "no platform data\n");
1057 mem
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "mpu");
1059 dev_warn(mcasp
->dev
,
1060 "\"mpu\" mem resource not found, using index 0\n");
1061 mem
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1063 dev_err(&pdev
->dev
, "no mem resource?\n");
1068 ioarea
= devm_request_mem_region(&pdev
->dev
, mem
->start
,
1069 resource_size(mem
), pdev
->name
);
1071 dev_err(&pdev
->dev
, "Audio region already claimed\n");
1075 pm_runtime_enable(&pdev
->dev
);
1077 ret
= pm_runtime_get_sync(&pdev
->dev
);
1078 if (IS_ERR_VALUE(ret
)) {
1079 dev_err(&pdev
->dev
, "pm_runtime_get_sync() failed\n");
1083 mcasp
->base
= devm_ioremap(&pdev
->dev
, mem
->start
, resource_size(mem
));
1085 dev_err(&pdev
->dev
, "ioremap failed\n");
1087 goto err_release_clk
;
1090 mcasp
->op_mode
= pdata
->op_mode
;
1091 mcasp
->tdm_slots
= pdata
->tdm_slots
;
1092 mcasp
->num_serializer
= pdata
->num_serializer
;
1093 mcasp
->serial_dir
= pdata
->serial_dir
;
1094 mcasp
->version
= pdata
->version
;
1095 mcasp
->txnumevt
= pdata
->txnumevt
;
1096 mcasp
->rxnumevt
= pdata
->rxnumevt
;
1098 mcasp
->dev
= &pdev
->dev
;
1100 dat
= platform_get_resource_byname(pdev
, IORESOURCE_MEM
, "dat");
1102 mcasp
->dat_port
= true;
1104 dma_params
= &mcasp
->dma_params
[SNDRV_PCM_STREAM_PLAYBACK
];
1105 dma_data
= &mcasp
->dma_data
[SNDRV_PCM_STREAM_PLAYBACK
];
1106 dma_params
->asp_chan_q
= pdata
->asp_chan_q
;
1107 dma_params
->ram_chan_q
= pdata
->ram_chan_q
;
1108 dma_params
->sram_pool
= pdata
->sram_pool
;
1109 dma_params
->sram_size
= pdata
->sram_size_playback
;
1111 dma_params
->dma_addr
= dat
->start
;
1113 dma_params
->dma_addr
= mem
->start
+ pdata
->tx_dma_offset
;
1115 /* Unconditional dmaengine stuff */
1116 dma_data
->addr
= dma_params
->dma_addr
;
1118 res
= platform_get_resource(pdev
, IORESOURCE_DMA
, 0);
1120 dma_params
->channel
= res
->start
;
1122 dma_params
->channel
= pdata
->tx_dma_channel
;
1124 /* dmaengine filter data for DT and non-DT boot */
1125 if (pdev
->dev
.of_node
)
1126 dma_data
->filter_data
= "tx";
1128 dma_data
->filter_data
= &dma_params
->channel
;
1130 dma_params
= &mcasp
->dma_params
[SNDRV_PCM_STREAM_CAPTURE
];
1131 dma_data
= &mcasp
->dma_data
[SNDRV_PCM_STREAM_CAPTURE
];
1132 dma_params
->asp_chan_q
= pdata
->asp_chan_q
;
1133 dma_params
->ram_chan_q
= pdata
->ram_chan_q
;
1134 dma_params
->sram_pool
= pdata
->sram_pool
;
1135 dma_params
->sram_size
= pdata
->sram_size_capture
;
1137 dma_params
->dma_addr
= dat
->start
;
1139 dma_params
->dma_addr
= mem
->start
+ pdata
->rx_dma_offset
;
1141 /* Unconditional dmaengine stuff */
1142 dma_data
->addr
= dma_params
->dma_addr
;
1144 if (mcasp
->version
< MCASP_VERSION_3
) {
1145 mcasp
->fifo_base
= DAVINCI_MCASP_V2_AFIFO_BASE
;
1146 /* dma_params->dma_addr is pointing to the data port address */
1147 mcasp
->dat_port
= true;
1149 mcasp
->fifo_base
= DAVINCI_MCASP_V3_AFIFO_BASE
;
1152 res
= platform_get_resource(pdev
, IORESOURCE_DMA
, 1);
1154 dma_params
->channel
= res
->start
;
1156 dma_params
->channel
= pdata
->rx_dma_channel
;
1158 /* dmaengine filter data for DT and non-DT boot */
1159 if (pdev
->dev
.of_node
)
1160 dma_data
->filter_data
= "rx";
1162 dma_data
->filter_data
= &dma_params
->channel
;
1164 dev_set_drvdata(&pdev
->dev
, mcasp
);
1166 mcasp_reparent_fck(pdev
);
1168 ret
= snd_soc_register_component(&pdev
->dev
, &davinci_mcasp_component
,
1169 &davinci_mcasp_dai
[pdata
->op_mode
], 1);
1172 goto err_release_clk
;
1174 if (mcasp
->version
!= MCASP_VERSION_4
) {
1175 ret
= davinci_soc_platform_register(&pdev
->dev
);
1177 dev_err(&pdev
->dev
, "register PCM failed: %d\n", ret
);
1178 goto err_unregister_component
;
1184 err_unregister_component
:
1185 snd_soc_unregister_component(&pdev
->dev
);
1187 pm_runtime_put_sync(&pdev
->dev
);
1188 pm_runtime_disable(&pdev
->dev
);
1192 static int davinci_mcasp_remove(struct platform_device
*pdev
)
1194 struct davinci_mcasp
*mcasp
= dev_get_drvdata(&pdev
->dev
);
1196 snd_soc_unregister_component(&pdev
->dev
);
1197 if (mcasp
->version
!= MCASP_VERSION_4
)
1198 davinci_soc_platform_unregister(&pdev
->dev
);
1200 pm_runtime_put_sync(&pdev
->dev
);
1201 pm_runtime_disable(&pdev
->dev
);
1206 static struct platform_driver davinci_mcasp_driver
= {
1207 .probe
= davinci_mcasp_probe
,
1208 .remove
= davinci_mcasp_remove
,
1210 .name
= "davinci-mcasp",
1211 .owner
= THIS_MODULE
,
1212 .of_match_table
= mcasp_dt_ids
,
1216 module_platform_driver(davinci_mcasp_driver
);
1218 MODULE_AUTHOR("Steve Chen");
1219 MODULE_DESCRIPTION("TI DAVINCI McASP SoC Interface");
1220 MODULE_LICENSE("GPL");