ea1754e2eff4c9915f35fa010c0204e540c775ba
[sitara-epos/sitara-epos-kernel.git] / sound / soc / davinci / davinci-mcasp.c
1 /*
2  * ALSA SoC McASP Audio Layer for TI DAVINCI processor
3  *
4  * Multi-channel Audio Serial Port Driver
5  *
6  * Author: Nirmal Pandey <n-pandey@ti.com>,
7  *         Suresh Rajashekara <suresh.r@ti.com>
8  *         Steve Chen <schen@.mvista.com>
9  *
10  * Copyright:   (C) 2009 MontaVista Software, Inc., <source@mvista.com>
11  * Copyright:   (C) 2009  Texas Instruments, India
12  *
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.
16  */
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>
23 #include <linux/io.h>
24 #include <linux/clk.h>
26 #include <sound/core.h>
27 #include <sound/pcm.h>
28 #include <sound/pcm_params.h>
29 #include <sound/initval.h>
30 #include <sound/soc.h>
32 #include "davinci-pcm.h"
33 #include "davinci-mcasp.h"
35 /*
36  * McASP register definitions
37  */
38 #define DAVINCI_MCASP_PID_REG           0x00
39 #define DAVINCI_MCASP_PWREMUMGT_REG     0x04
41 #define DAVINCI_MCASP_PFUNC_REG         0x10
42 #define DAVINCI_MCASP_PDIR_REG          0x14
43 #define DAVINCI_MCASP_PDOUT_REG         0x18
44 #define DAVINCI_MCASP_PDSET_REG         0x1c
46 #define DAVINCI_MCASP_PDCLR_REG         0x20
48 #define DAVINCI_MCASP_TLGC_REG          0x30
49 #define DAVINCI_MCASP_TLMR_REG          0x34
51 #define DAVINCI_MCASP_GBLCTL_REG        0x44
52 #define DAVINCI_MCASP_AMUTE_REG         0x48
53 #define DAVINCI_MCASP_LBCTL_REG         0x4c
55 #define DAVINCI_MCASP_TXDITCTL_REG      0x50
57 #define DAVINCI_MCASP_GBLCTLR_REG       0x60
58 #define DAVINCI_MCASP_RXMASK_REG        0x64
59 #define DAVINCI_MCASP_RXFMT_REG         0x68
60 #define DAVINCI_MCASP_RXFMCTL_REG       0x6c
62 #define DAVINCI_MCASP_ACLKRCTL_REG      0x70
63 #define DAVINCI_MCASP_AHCLKRCTL_REG     0x74
64 #define DAVINCI_MCASP_RXTDM_REG         0x78
65 #define DAVINCI_MCASP_EVTCTLR_REG       0x7c
67 #define DAVINCI_MCASP_RXSTAT_REG        0x80
68 #define DAVINCI_MCASP_RXTDMSLOT_REG     0x84
69 #define DAVINCI_MCASP_RXCLKCHK_REG      0x88
70 #define DAVINCI_MCASP_REVTCTL_REG       0x8c
72 #define DAVINCI_MCASP_GBLCTLX_REG       0xa0
73 #define DAVINCI_MCASP_TXMASK_REG        0xa4
74 #define DAVINCI_MCASP_TXFMT_REG         0xa8
75 #define DAVINCI_MCASP_TXFMCTL_REG       0xac
77 #define DAVINCI_MCASP_ACLKXCTL_REG      0xb0
78 #define DAVINCI_MCASP_AHCLKXCTL_REG     0xb4
79 #define DAVINCI_MCASP_TXTDM_REG         0xb8
80 #define DAVINCI_MCASP_EVTCTLX_REG       0xbc
82 #define DAVINCI_MCASP_TXSTAT_REG        0xc0
83 #define DAVINCI_MCASP_TXTDMSLOT_REG     0xc4
84 #define DAVINCI_MCASP_TXCLKCHK_REG      0xc8
85 #define DAVINCI_MCASP_XEVTCTL_REG       0xcc
87 /* Left(even TDM Slot) Channel Status Register File */
88 #define DAVINCI_MCASP_DITCSRA_REG       0x100
89 /* Right(odd TDM slot) Channel Status Register File */
90 #define DAVINCI_MCASP_DITCSRB_REG       0x118
91 /* Left(even TDM slot) User Data Register File */
92 #define DAVINCI_MCASP_DITUDRA_REG       0x130
93 /* Right(odd TDM Slot) User Data Register File */
94 #define DAVINCI_MCASP_DITUDRB_REG       0x148
96 /* Serializer n Control Register */
97 #define DAVINCI_MCASP_XRSRCTL_BASE_REG  0x180
98 #define DAVINCI_MCASP_XRSRCTL_REG(n)    (DAVINCI_MCASP_XRSRCTL_BASE_REG + \
99                                                 (n << 2))
101 /* Transmit Buffer for Serializer n */
102 #define DAVINCI_MCASP_TXBUF_REG         0x200
103 /* Receive Buffer for Serializer n */
104 #define DAVINCI_MCASP_RXBUF_REG         0x280
106 /* McASP FIFO Registers */
107 #define DAVINCI_MCASP_WFIFOCTL          (0x1010)
108 #define DAVINCI_MCASP_WFIFOSTS          (0x1014)
109 #define DAVINCI_MCASP_RFIFOCTL          (0x1018)
110 #define DAVINCI_MCASP_RFIFOSTS          (0x101C)
111 #define MCASP_VER3_WFIFOCTL             (0x1000)
112 #define MCASP_VER3_WFIFOSTS             (0x1004)
113 #define MCASP_VER3_RFIFOCTL             (0x1008)
114 #define MCASP_VER3_RFIFOSTS             (0x100C)
116 /*
117  * DAVINCI_MCASP_PWREMUMGT_REG - Power Down and Emulation Management
118  *     Register Bits
119  */
120 #define MCASP_FREE      BIT(0)
121 #define MCASP_SOFT      BIT(1)
123 /*
124  * DAVINCI_MCASP_PFUNC_REG - Pin Function / GPIO Enable Register Bits
125  */
126 #define AXR(n)          (1<<n)
127 #define PFUNC_AMUTE     BIT(25)
128 #define ACLKX           BIT(26)
129 #define AHCLKX          BIT(27)
130 #define AFSX            BIT(28)
131 #define ACLKR           BIT(29)
132 #define AHCLKR          BIT(30)
133 #define AFSR            BIT(31)
135 /*
136  * DAVINCI_MCASP_PDIR_REG - Pin Direction Register Bits
137  */
138 #define AXR(n)          (1<<n)
139 #define PDIR_AMUTE      BIT(25)
140 #define ACLKX           BIT(26)
141 #define AHCLKX          BIT(27)
142 #define AFSX            BIT(28)
143 #define ACLKR           BIT(29)
144 #define AHCLKR          BIT(30)
145 #define AFSR            BIT(31)
147 /*
148  * DAVINCI_MCASP_TXDITCTL_REG - Transmit DIT Control Register Bits
149  */
150 #define DITEN   BIT(0)  /* Transmit DIT mode enable/disable */
151 #define VA      BIT(2)
152 #define VB      BIT(3)
154 /*
155  * DAVINCI_MCASP_TXFMT_REG - Transmit Bitstream Format Register Bits
156  */
157 #define TXROT(val)      (val)
158 #define TXSEL           BIT(3)
159 #define TXSSZ(val)      (val<<4)
160 #define TXPBIT(val)     (val<<8)
161 #define TXPAD(val)      (val<<13)
162 #define TXORD           BIT(15)
163 #define FSXDLY(val)     (val<<16)
165 /*
166  * DAVINCI_MCASP_RXFMT_REG - Receive Bitstream Format Register Bits
167  */
168 #define RXROT(val)      (val)
169 #define RXSEL           BIT(3)
170 #define RXSSZ(val)      (val<<4)
171 #define RXPBIT(val)     (val<<8)
172 #define RXPAD(val)      (val<<13)
173 #define RXORD           BIT(15)
174 #define FSRDLY(val)     (val<<16)
176 /*
177  * DAVINCI_MCASP_TXFMCTL_REG -  Transmit Frame Control Register Bits
178  */
179 #define FSXPOL          BIT(0)
180 #define AFSXE           BIT(1)
181 #define FSXDUR          BIT(4)
182 #define FSXMOD(val)     (val<<7)
184 /*
185  * DAVINCI_MCASP_RXFMCTL_REG - Receive Frame Control Register Bits
186  */
187 #define FSRPOL          BIT(0)
188 #define AFSRE           BIT(1)
189 #define FSRDUR          BIT(4)
190 #define FSRMOD(val)     (val<<7)
192 /*
193  * DAVINCI_MCASP_ACLKXCTL_REG - Transmit Clock Control Register Bits
194  */
195 #define ACLKXDIV(val)   (val)
196 #define ACLKXE          BIT(5)
197 #define TX_ASYNC        BIT(6)
198 #define ACLKXPOL        BIT(7)
200 /*
201  * DAVINCI_MCASP_ACLKRCTL_REG Receive Clock Control Register Bits
202  */
203 #define ACLKRDIV(val)   (val)
204 #define ACLKRE          BIT(5)
205 #define RX_ASYNC        BIT(6)
206 #define ACLKRPOL        BIT(7)
208 /*
209  * DAVINCI_MCASP_AHCLKXCTL_REG - High Frequency Transmit Clock Control
210  *     Register Bits
211  */
212 #define AHCLKXDIV(val)  (val)
213 #define AHCLKXPOL       BIT(14)
214 #define AHCLKXE         BIT(15)
216 /*
217  * DAVINCI_MCASP_AHCLKRCTL_REG - High Frequency Receive Clock Control
218  *     Register Bits
219  */
220 #define AHCLKRDIV(val)  (val)
221 #define AHCLKRPOL       BIT(14)
222 #define AHCLKRE         BIT(15)
224 /*
225  * DAVINCI_MCASP_XRSRCTL_BASE_REG -  Serializer Control Register Bits
226  */
227 #define MODE(val)       (val)
228 #define DISMOD          (val)(val<<2)
229 #define TXSTATE         BIT(4)
230 #define RXSTATE         BIT(5)
232 /*
233  * DAVINCI_MCASP_LBCTL_REG - Loop Back Control Register Bits
234  */
235 #define LBEN            BIT(0)
236 #define LBORD           BIT(1)
237 #define LBGENMODE(val)  (val<<2)
239 /*
240  * DAVINCI_MCASP_TXTDMSLOT_REG - Transmit TDM Slot Register configuration
241  */
242 #define TXTDMS(n)       (1<<n)
244 /*
245  * DAVINCI_MCASP_RXTDMSLOT_REG - Receive TDM Slot Register configuration
246  */
247 #define RXTDMS(n)       (1<<n)
249 /*
250  * DAVINCI_MCASP_GBLCTL_REG -  Global Control Register Bits
251  */
252 #define RXCLKRST        BIT(0)  /* Receiver Clock Divider Reset */
253 #define RXHCLKRST       BIT(1)  /* Receiver High Frequency Clock Divider */
254 #define RXSERCLR        BIT(2)  /* Receiver Serializer Clear */
255 #define RXSMRST         BIT(3)  /* Receiver State Machine Reset */
256 #define RXFSRST         BIT(4)  /* Frame Sync Generator Reset */
257 #define TXCLKRST        BIT(8)  /* Transmitter Clock Divider Reset */
258 #define TXHCLKRST       BIT(9)  /* Transmitter High Frequency Clock Divider*/
259 #define TXSERCLR        BIT(10) /* Transmit Serializer Clear */
260 #define TXSMRST         BIT(11) /* Transmitter State Machine Reset */
261 #define TXFSRST         BIT(12) /* Frame Sync Generator Reset */
263 /*
264  * DAVINCI_MCASP_AMUTE_REG -  Mute Control Register Bits
265  */
266 #define MUTENA(val)     (val)
267 #define MUTEINPOL       BIT(2)
268 #define MUTEINENA       BIT(3)
269 #define MUTEIN          BIT(4)
270 #define MUTER           BIT(5)
271 #define MUTEX           BIT(6)
272 #define MUTEFSR         BIT(7)
273 #define MUTEFSX         BIT(8)
274 #define MUTEBADCLKR     BIT(9)
275 #define MUTEBADCLKX     BIT(10)
276 #define MUTERXDMAERR    BIT(11)
277 #define MUTETXDMAERR    BIT(12)
279 /*
280  * DAVINCI_MCASP_REVTCTL_REG - Receiver DMA Event Control Register bits
281  */
282 #define RXDATADMADIS    BIT(0)
284 /*
285  * DAVINCI_MCASP_XEVTCTL_REG - Transmitter DMA Event Control Register bits
286  */
287 #define TXDATADMADIS    BIT(0)
289 /*
290  * DAVINCI_MCASP_W[R]FIFOCTL - Write/Read FIFO Control Register bits
291  */
292 #define FIFO_ENABLE     BIT(16)
293 #define NUMEVT_MASK     (0xFF << 8)
294 #define NUMDMA_MASK     (0xFF)
296 #define DAVINCI_MCASP_NUM_SERIALIZER    16
298 static inline void mcasp_set_bits(void __iomem *reg, u32 val)
300         __raw_writel(__raw_readl(reg) | val, reg);
303 static inline void mcasp_clr_bits(void __iomem *reg, u32 val)
305         __raw_writel((__raw_readl(reg) & ~(val)), reg);
308 static inline void mcasp_mod_bits(void __iomem *reg, u32 val, u32 mask)
310         __raw_writel((__raw_readl(reg) & ~mask) | val, reg);
313 static inline void mcasp_set_reg(void __iomem *reg, u32 val)
315         __raw_writel(val, reg);
318 static inline u32 mcasp_get_reg(void __iomem *reg)
320         return (unsigned int)__raw_readl(reg);
323 static inline void mcasp_set_ctl_reg(void __iomem *regs, u32 val)
325         int i = 0;
327         mcasp_set_bits(regs, val);
329         /* programming GBLCTL needs to read back from GBLCTL and verfiy */
330         /* loop count is to avoid the lock-up */
331         for (i = 0; i < 1000; i++) {
332                 if ((mcasp_get_reg(regs) & val) == val)
333                         break;
334         }
336         if (i == 1000 && ((mcasp_get_reg(regs) & val) != val))
337                 printk(KERN_ERR "GBLCTL write error\n");
340 static void mcasp_start_rx(struct davinci_audio_dev *dev)
342         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXHCLKRST);
343         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXCLKRST);
344         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSERCLR);
345         mcasp_set_reg(dev->base + DAVINCI_MCASP_RXBUF_REG, 0);
347         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
348         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
349         mcasp_set_reg(dev->base + DAVINCI_MCASP_RXBUF_REG, 0);
351         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXSMRST);
352         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, RXFSRST);
355 static void mcasp_start_tx(struct davinci_audio_dev *dev)
357         u8 offset = 0, i;
358         u32 cnt;
360         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXHCLKRST);
361         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXCLKRST);
362         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXSERCLR);
363         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
365         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXSMRST);
366         mcasp_set_ctl_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, TXFSRST);
367         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
368         for (i = 0; i < dev->num_serializer; i++) {
369                 if (dev->serial_dir[i] == TX_MODE) {
370                         offset = i;
371                         break;
372                 }
373         }
375         /* wait for TX ready */
376         cnt = 0;
377         while (!(mcasp_get_reg(dev->base + DAVINCI_MCASP_XRSRCTL_REG(offset)) &
378                  TXSTATE) && (cnt < 100000))
379                 cnt++;
381         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXBUF_REG, 0);
384 static void davinci_mcasp_start(struct davinci_audio_dev *dev, int stream)
386         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
387                 if (dev->txnumevt) {    /* enable FIFO */
388                         if (dev->version == MCASP_VERSION_3)
389                                 mcasp_set_bits(dev->base +
390                                                 MCASP_VER3_WFIFOCTL,
391                                                 FIFO_ENABLE);
392                         else
393                                 mcasp_set_bits(dev->base +
394                                                 DAVINCI_MCASP_WFIFOCTL,
395                                                 FIFO_ENABLE);
396                 }
397                 mcasp_start_tx(dev);
398         } else {
399                 if (dev->rxnumevt) {    /* enable FIFO */
400                         if (dev->version == MCASP_VERSION_3)
401                                 mcasp_set_bits(dev->base +
402                                                 MCASP_VER3_WFIFOCTL,
403                                                 FIFO_ENABLE);
404                         else
405                                 mcasp_set_bits(dev->base +
406                                                 DAVINCI_MCASP_RFIFOCTL,
407                                                 FIFO_ENABLE);
408                 }
409                 mcasp_start_rx(dev);
410         }
413 static void mcasp_stop_rx(struct davinci_audio_dev *dev)
415         mcasp_set_reg(dev->base + DAVINCI_MCASP_GBLCTLR_REG, 0);
416         mcasp_set_reg(dev->base + DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
419 static void mcasp_stop_tx(struct davinci_audio_dev *dev)
421         mcasp_set_reg(dev->base + DAVINCI_MCASP_GBLCTLX_REG, 0);
422         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
425 static void davinci_mcasp_stop(struct davinci_audio_dev *dev, int stream)
427         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
428                 if (dev->txnumevt) {    /* disable FIFO */
429                         if (dev->version == MCASP_VERSION_3)
430                                 mcasp_clr_bits(dev->base +
431                                                 MCASP_VER3_WFIFOCTL,
432                                                 FIFO_ENABLE);
433                         else
434                                 mcasp_clr_bits(dev->base +
435                                                 DAVINCI_MCASP_WFIFOCTL,
436                                                 FIFO_ENABLE);
437                 }
438                 mcasp_stop_tx(dev);
439         } else {
440                 if (dev->rxnumevt) {    /* disable FIFO */
441                         if (dev->version == MCASP_VERSION_3)
442                                 mcasp_clr_bits(dev->base +
443                                                 MCASP_VER3_RFIFOCTL,
444                                                 FIFO_ENABLE);
445                         else
446                                 mcasp_clr_bits(dev->base +
447                                                 DAVINCI_MCASP_RFIFOCTL,
448                                                 FIFO_ENABLE);
449                 }
450                 mcasp_stop_rx(dev);
451         }
454 static int davinci_mcasp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
455                                          unsigned int fmt)
457         struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
458         void __iomem *base = dev->base;
460         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
461         case SND_SOC_DAIFMT_CBS_CFS:
462                 /* codec is clock and frame slave */
463                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
464                 mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
466                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
467                 mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
469                 mcasp_set_bits(base + DAVINCI_MCASP_PDIR_REG,
470                                 ACLKX | AHCLKX | AFSX);
471                 break;
472         case SND_SOC_DAIFMT_CBM_CFS:
473                 /* codec is clock master and frame slave */
474                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
475                 mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
477                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
478                 mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
480                 mcasp_clr_bits(base + DAVINCI_MCASP_PDIR_REG,
481                                 ACLKX | ACLKR);
482                 mcasp_set_bits(base + DAVINCI_MCASP_PDIR_REG,
483                                 AFSX | AFSR);
484                 break;
485         case SND_SOC_DAIFMT_CBM_CFM:
486                 /* codec is clock and frame master */
487                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXE);
488                 mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, AFSXE);
490                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRE);
491                 mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, AFSRE);
493                 mcasp_clr_bits(base + DAVINCI_MCASP_PDIR_REG,
494                                 ACLKX | AHCLKX | AFSX | ACLKR | AHCLKR | AFSR);
495                 break;
497         default:
498                 return -EINVAL;
499         }
501         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
502         case SND_SOC_DAIFMT_IB_NF:
503                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
504                 mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
506                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
507                 mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
508                 break;
510         case SND_SOC_DAIFMT_NB_IF:
511                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
512                 mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
514                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
515                 mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
516                 break;
518         case SND_SOC_DAIFMT_IB_IF:
519                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
520                 mcasp_set_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
522                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
523                 mcasp_set_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
524                 break;
526         case SND_SOC_DAIFMT_NB_NF:
527                 mcasp_set_bits(base + DAVINCI_MCASP_ACLKXCTL_REG, ACLKXPOL);
528                 mcasp_clr_bits(base + DAVINCI_MCASP_TXFMCTL_REG, FSXPOL);
530                 mcasp_clr_bits(base + DAVINCI_MCASP_ACLKRCTL_REG, ACLKRPOL);
531                 mcasp_clr_bits(base + DAVINCI_MCASP_RXFMCTL_REG, FSRPOL);
532                 break;
534         default:
535                 return -EINVAL;
536         }
538         return 0;
541 static int davinci_config_channel_size(struct davinci_audio_dev *dev,
542                                        int channel_size)
544         u32 fmt = 0;
545         u32 mask, rotate;
547         switch (channel_size) {
548         case DAVINCI_AUDIO_WORD_8:
549                 fmt = 0x03;
550                 rotate = 6;
551                 mask = 0x000000ff;
552                 break;
554         case DAVINCI_AUDIO_WORD_12:
555                 fmt = 0x05;
556                 rotate = 5;
557                 mask = 0x00000fff;
558                 break;
560         case DAVINCI_AUDIO_WORD_16:
561                 fmt = 0x07;
562                 rotate = 4;
563                 mask = 0x0000ffff;
564                 break;
566         case DAVINCI_AUDIO_WORD_20:
567                 fmt = 0x09;
568                 rotate = 3;
569                 mask = 0x000fffff;
570                 break;
572         case DAVINCI_AUDIO_WORD_24:
573                 fmt = 0x0B;
574                 rotate = 2;
575                 mask = 0x00ffffff;
576                 break;
578         case DAVINCI_AUDIO_WORD_28:
579                 fmt = 0x0D;
580                 rotate = 1;
581                 mask = 0x0fffffff;
582                 break;
584         case DAVINCI_AUDIO_WORD_32:
585                 fmt = 0x0F;
586                 rotate = 0;
587                 mask = 0xffffffff;
588                 break;
590         default:
591                 return -EINVAL;
592         }
594         mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMT_REG,
595                                         RXSSZ(fmt), RXSSZ(0x0F));
596         mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMT_REG,
597                                         TXSSZ(fmt), TXSSZ(0x0F));
598         mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMT_REG, TXROT(rotate),
599                                                         TXROT(7));
600         mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMT_REG, RXROT(rotate),
601                                                         RXROT(7));
602         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXMASK_REG, mask);
603         mcasp_set_reg(dev->base + DAVINCI_MCASP_RXMASK_REG, mask);
605         return 0;
608 static void davinci_hw_common_param(struct davinci_audio_dev *dev, int stream)
610         int i;
611         u8 tx_ser = 0;
612         u8 rx_ser = 0;
614         /* Default configuration */
615         mcasp_set_bits(dev->base + DAVINCI_MCASP_PWREMUMGT_REG, MCASP_SOFT);
617         /* All PINS as McASP */
618         mcasp_set_reg(dev->base + DAVINCI_MCASP_PFUNC_REG, 0x00000000);
620         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
621                 mcasp_set_reg(dev->base + DAVINCI_MCASP_TXSTAT_REG, 0xFFFFFFFF);
622                 mcasp_clr_bits(dev->base + DAVINCI_MCASP_XEVTCTL_REG,
623                                 TXDATADMADIS);
624         } else {
625                 mcasp_set_reg(dev->base + DAVINCI_MCASP_RXSTAT_REG, 0xFFFFFFFF);
626                 mcasp_clr_bits(dev->base + DAVINCI_MCASP_REVTCTL_REG,
627                                 RXDATADMADIS);
628         }
630         for (i = 0; i < dev->num_serializer; i++) {
631                 mcasp_set_bits(dev->base + DAVINCI_MCASP_XRSRCTL_REG(i),
632                                         dev->serial_dir[i]);
633                 if (dev->serial_dir[i] == TX_MODE) {
634                         mcasp_set_bits(dev->base + DAVINCI_MCASP_PDIR_REG,
635                                         AXR(i));
636                         tx_ser++;
637                 } else if (dev->serial_dir[i] == RX_MODE) {
638                         mcasp_clr_bits(dev->base + DAVINCI_MCASP_PDIR_REG,
639                                         AXR(i));
640                         rx_ser++;
641                 }
642         }
644         if (dev->txnumevt && stream == SNDRV_PCM_STREAM_PLAYBACK) {
645                 if (dev->txnumevt * tx_ser > 64)
646                         dev->txnumevt = 1;
648                 if (dev->version == MCASP_VERSION_3) {
649                         mcasp_mod_bits(dev->base + MCASP_VER3_WFIFOCTL, tx_ser,
650                                                                 NUMDMA_MASK);
651                         mcasp_mod_bits(dev->base + MCASP_VER3_WFIFOCTL,
652                                 ((dev->txnumevt * tx_ser) << 8), NUMEVT_MASK);
653                 } else {
654                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_WFIFOCTL,
655                                                         tx_ser, NUMDMA_MASK);
656                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_WFIFOCTL,
657                                 ((dev->txnumevt * tx_ser) << 8), NUMEVT_MASK);
658                 }
659         }
661         if (dev->rxnumevt && stream == SNDRV_PCM_STREAM_CAPTURE) {
662                 if (dev->rxnumevt * rx_ser > 64)
663                         dev->rxnumevt = 1;
665                 if (dev->version == MCASP_VERSION_3) {
666                         mcasp_mod_bits(dev->base + MCASP_VER3_RFIFOCTL, rx_ser,
667                                                                 NUMDMA_MASK);
668                         mcasp_mod_bits(dev->base + MCASP_VER3_RFIFOCTL,
669                                         ((dev->rxnumevt * rx_ser) << 8),
670                                         NUMEVT_MASK);
671                 } else {
672                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_RFIFOCTL,
673                                                         rx_ser, NUMDMA_MASK);
674                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_RFIFOCTL,
675                                         ((dev->rxnumevt * rx_ser) << 8),
676                                         NUMEVT_MASK);
677                 }
678         }
681 static void davinci_hw_param(struct davinci_audio_dev *dev, int stream)
683         int i, active_slots;
684         u32 mask = 0;
686         active_slots = (dev->tdm_slots > 31) ? 32 : dev->tdm_slots;
687         for (i = 0; i < active_slots; i++)
688                 mask |= (1 << i);
690         mcasp_clr_bits(dev->base + DAVINCI_MCASP_ACLKXCTL_REG, TX_ASYNC);
692         if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
693                 /* bit stream is MSB first  with no delay */
694                 /* DSP_B mode */
695                 mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG,
696                                 AHCLKXE);
697                 mcasp_set_reg(dev->base + DAVINCI_MCASP_TXTDM_REG, mask);
698                 mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMT_REG, TXORD);
700                 if ((dev->tdm_slots >= 2) && (dev->tdm_slots <= 32))
701                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_TXFMCTL_REG,
702                                         FSXMOD(dev->tdm_slots), FSXMOD(0x1FF));
703                 else
704                         printk(KERN_ERR "playback tdm slot %d not supported\n",
705                                 dev->tdm_slots);
707                 mcasp_clr_bits(dev->base + DAVINCI_MCASP_TXFMCTL_REG, FSXDUR);
708         } else {
709                 /* bit stream is MSB first with no delay */
710                 /* DSP_B mode */
711                 mcasp_set_bits(dev->base + DAVINCI_MCASP_RXFMT_REG, RXORD);
712                 mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKRCTL_REG,
713                                 AHCLKRE);
714                 mcasp_set_reg(dev->base + DAVINCI_MCASP_RXTDM_REG, mask);
716                 if ((dev->tdm_slots >= 2) && (dev->tdm_slots <= 32))
717                         mcasp_mod_bits(dev->base + DAVINCI_MCASP_RXFMCTL_REG,
718                                         FSRMOD(dev->tdm_slots), FSRMOD(0x1FF));
719                 else
720                         printk(KERN_ERR "capture tdm slot %d not supported\n",
721                                 dev->tdm_slots);
723                 mcasp_clr_bits(dev->base + DAVINCI_MCASP_RXFMCTL_REG, FSRDUR);
724         }
727 /* S/PDIF */
728 static void davinci_hw_dit_param(struct davinci_audio_dev *dev)
730         /* Set the PDIR for Serialiser as output */
731         mcasp_set_bits(dev->base + DAVINCI_MCASP_PDIR_REG, AFSX);
733         /* TXMASK for 24 bits */
734         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXMASK_REG, 0x00FFFFFF);
736         /* Set the TX format : 24 bit right rotation, 32 bit slot, Pad 0
737            and LSB first */
738         mcasp_set_bits(dev->base + DAVINCI_MCASP_TXFMT_REG,
739                                                 TXROT(6) | TXSSZ(15));
741         /* Set TX frame synch : DIT Mode, 1 bit width, internal, rising edge */
742         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXFMCTL_REG,
743                                                 AFSXE | FSXMOD(0x180));
745         /* Set the TX tdm : for all the slots */
746         mcasp_set_reg(dev->base + DAVINCI_MCASP_TXTDM_REG, 0xFFFFFFFF);
748         /* Set the TX clock controls : div = 1 and internal */
749         mcasp_set_bits(dev->base + DAVINCI_MCASP_ACLKXCTL_REG,
750                                                 ACLKXE | TX_ASYNC);
752         mcasp_clr_bits(dev->base + DAVINCI_MCASP_XEVTCTL_REG, TXDATADMADIS);
754         /* Only 44100 and 48000 are valid, both have the same setting */
755         mcasp_set_bits(dev->base + DAVINCI_MCASP_AHCLKXCTL_REG, AHCLKXDIV(3));
757         /* Enable the DIT */
758         mcasp_set_bits(dev->base + DAVINCI_MCASP_TXDITCTL_REG, DITEN);
761 static int davinci_mcasp_hw_params(struct snd_pcm_substream *substream,
762                                         struct snd_pcm_hw_params *params,
763                                         struct snd_soc_dai *cpu_dai)
765         struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
766         struct davinci_pcm_dma_params *dma_params =
767                                         &dev->dma_params[substream->stream];
768         int word_length;
769         u8 fifo_level;
771         davinci_hw_common_param(dev, substream->stream);
772         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
773                 fifo_level = dev->txnumevt;
774         else
775                 fifo_level = dev->rxnumevt;
777         if (dev->op_mode == DAVINCI_MCASP_DIT_MODE)
778                 davinci_hw_dit_param(dev);
779         else
780                 davinci_hw_param(dev, substream->stream);
782         switch (params_format(params)) {
783         case SNDRV_PCM_FORMAT_U8:
784         case SNDRV_PCM_FORMAT_S8:
785                 dma_params->data_type = 1;
786                 word_length = DAVINCI_AUDIO_WORD_8;
787                 break;
789         case SNDRV_PCM_FORMAT_U16_LE:
790         case SNDRV_PCM_FORMAT_S16_LE:
791                 dma_params->data_type = 2;
792                 word_length = DAVINCI_AUDIO_WORD_16;
793                 break;
795         case SNDRV_PCM_FORMAT_U32_LE:
796         case SNDRV_PCM_FORMAT_S32_LE:
797                 dma_params->data_type = 4;
798                 word_length = DAVINCI_AUDIO_WORD_32;
799                 break;
801         default:
802                 printk(KERN_WARNING "davinci-mcasp: unsupported PCM format");
803                 return -EINVAL;
804         }
806         if (dev->version == MCASP_VERSION_2 && !fifo_level)
807                 dma_params->acnt = 4;
808         else
809                 dma_params->acnt = dma_params->data_type;
811         dma_params->fifo_level = fifo_level;
812         davinci_config_channel_size(dev, word_length);
814         return 0;
817 static int davinci_mcasp_trigger(struct snd_pcm_substream *substream,
818                                      int cmd, struct snd_soc_dai *cpu_dai)
820         struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(cpu_dai);
821         int ret = 0;
823         switch (cmd) {
824         case SNDRV_PCM_TRIGGER_RESUME:
825         case SNDRV_PCM_TRIGGER_START:
826         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
827                 if (!dev->clk_active) {
828                         clk_enable(dev->clk);
829                         dev->clk_active = 1;
830                 }
831                 davinci_mcasp_start(dev, substream->stream);
832                 break;
834         case SNDRV_PCM_TRIGGER_SUSPEND:
835                 davinci_mcasp_stop(dev, substream->stream);
836                 if (dev->clk_active) {
837                         clk_disable(dev->clk);
838                         dev->clk_active = 0;
839                 }
841                 break;
843         case SNDRV_PCM_TRIGGER_STOP:
844         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
845                 davinci_mcasp_stop(dev, substream->stream);
846                 break;
848         default:
849                 ret = -EINVAL;
850         }
852         return ret;
855 static int davinci_mcasp_startup(struct snd_pcm_substream *substream,
856                                  struct snd_soc_dai *dai)
858         struct davinci_audio_dev *dev = snd_soc_dai_get_drvdata(dai);
860         snd_soc_dai_set_dma_data(dai, substream, dev->dma_params);
861         return 0;
864 static struct snd_soc_dai_ops davinci_mcasp_dai_ops = {
865         .startup        = davinci_mcasp_startup,
866         .trigger        = davinci_mcasp_trigger,
867         .hw_params      = davinci_mcasp_hw_params,
868         .set_fmt        = davinci_mcasp_set_dai_fmt,
870 };
872 #define DAVINCI_MCASP_PCM_FMTS (SNDRV_PCM_FMTBIT_S8 | \
873                                 SNDRV_PCM_FMTBIT_U8 | \
874                                 SNDRV_PCM_FMTBIT_S16_LE | \
875                                 SNDRV_PCM_FMTBIT_U16_LE | \
876                                 SNDRV_PCM_FMTBIT_S32_LE | \
877                                 SNDRV_PCM_FMTBIT_U32_LE)
879 static struct snd_soc_dai_driver davinci_mcasp_dai[] = {
880         {
881                 .name           = "davinci-mcasp.0",
882                 .playback       = {
883                         .channels_min   = 2,
884                         .channels_max   = 2,
885                         .rates          = DAVINCI_MCASP_RATES,
886                         .formats        = DAVINCI_MCASP_PCM_FMTS,
887                 },
888                 .capture        = {
889                         .channels_min   = 2,
890                         .channels_max   = 2,
891                         .rates          = DAVINCI_MCASP_RATES,
892                         .formats        = DAVINCI_MCASP_PCM_FMTS,
893                 },
894                 .ops            = &davinci_mcasp_dai_ops,
896         },
897         {
898                 "davinci-mcasp.1",
899                 .playback       = {
900                         .channels_min   = 1,
901                         .channels_max   = 384,
902                         .rates          = DAVINCI_MCASP_RATES,
903                         .formats        = DAVINCI_MCASP_PCM_FMTS,
904                 },
905                 .ops            = &davinci_mcasp_dai_ops,
906         },
908 };
910 static int davinci_mcasp_probe(struct platform_device *pdev)
912         struct davinci_pcm_dma_params *dma_data;
913         struct resource *mem, *ioarea, *res;
914         struct snd_platform_data *pdata;
915         struct davinci_audio_dev *dev;
916         int ret = 0;
918         dev = kzalloc(sizeof(struct davinci_audio_dev), GFP_KERNEL);
919         if (!dev)
920                 return  -ENOMEM;
922         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
923         if (!mem) {
924                 dev_err(&pdev->dev, "no mem resource?\n");
925                 ret = -ENODEV;
926                 goto err_release_data;
927         }
929         ioarea = request_mem_region(mem->start,
930                         resource_size(mem), pdev->name);
931         if (!ioarea) {
932                 dev_err(&pdev->dev, "Audio region already claimed\n");
933                 ret = -EBUSY;
934                 goto err_release_data;
935         }
937         pdata = pdev->dev.platform_data;
938         dev->clk = clk_get(&pdev->dev, NULL);
939         if (IS_ERR(dev->clk)) {
940                 ret = -ENODEV;
941                 goto err_release_region;
942         }
944         clk_enable(dev->clk);
945         dev->clk_active = 1;
947         dev->base = ioremap(mem->start, resource_size(mem));
948         if (!dev->base) {
949                 dev_err(&pdev->dev, "ioremap failed\n");
950                 ret = -ENOMEM;
951                 goto err_release_clk;
952         }
954         dev->op_mode = pdata->op_mode;
955         dev->tdm_slots = pdata->tdm_slots;
956         dev->num_serializer = pdata->num_serializer;
957         dev->serial_dir = pdata->serial_dir;
958         dev->codec_fmt = pdata->codec_fmt;
959         dev->version = pdata->version;
960         dev->txnumevt = pdata->txnumevt;
961         dev->rxnumevt = pdata->rxnumevt;
963         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_PLAYBACK];
964         dma_data->asp_chan_q = pdata->asp_chan_q;
965         dma_data->ram_chan_q = pdata->ram_chan_q;
966         dma_data->sram_size = pdata->sram_size_playback;
967         if (dev->version == MCASP_VERSION_3)
968                 dma_data->dma_addr = (dma_addr_t) (pdata->tx_dma_offset);
969         else
970                 dma_data->dma_addr = (dma_addr_t) (pdata->tx_dma_offset +
971                                                         mem->start);
973         /* first TX, then RX */
974         res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
975         if (!res) {
976                 dev_err(&pdev->dev, "no DMA resource\n");
977                 ret = -ENODEV;
978                 goto err_iounmap;
979         }
981         dma_data->channel = res->start;
983         dma_data = &dev->dma_params[SNDRV_PCM_STREAM_CAPTURE];
984         dma_data->asp_chan_q = pdata->asp_chan_q;
985         dma_data->ram_chan_q = pdata->ram_chan_q;
986         dma_data->sram_size = pdata->sram_size_capture;
987         if (dev->version == MCASP_VERSION_3)
988                 dma_data->dma_addr = (dma_addr_t) (pdata->rx_dma_offset);
989         else
990                 dma_data->dma_addr = (dma_addr_t)(pdata->rx_dma_offset +
991                                                         mem->start);
993         res = platform_get_resource(pdev, IORESOURCE_DMA, 1);
994         if (!res) {
995                 dev_err(&pdev->dev, "no DMA resource\n");
996                 ret = -ENODEV;
997                 goto err_iounmap;
998         }
1000         dma_data->channel = res->start;
1001         dev_set_drvdata(&pdev->dev, dev);
1002         ret = snd_soc_register_dai(&pdev->dev, &davinci_mcasp_dai[pdata->op_mode]);
1004         if (ret != 0)
1005                 goto err_iounmap;
1006         return 0;
1008 err_iounmap:
1009         iounmap(dev->base);
1010 err_release_clk:
1011         clk_disable(dev->clk);
1012         clk_put(dev->clk);
1013 err_release_region:
1014         release_mem_region(mem->start, resource_size(mem));
1015 err_release_data:
1016         kfree(dev);
1018         return ret;
1021 static int davinci_mcasp_remove(struct platform_device *pdev)
1023         struct davinci_audio_dev *dev = dev_get_drvdata(&pdev->dev);
1024         struct resource *mem;
1026         snd_soc_unregister_dai(&pdev->dev);
1027         clk_disable(dev->clk);
1028         clk_put(dev->clk);
1029         dev->clk = NULL;
1031         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1032         release_mem_region(mem->start, resource_size(mem));
1034         kfree(dev);
1036         return 0;
1039 static struct platform_driver davinci_mcasp_driver = {
1040         .probe          = davinci_mcasp_probe,
1041         .remove         = davinci_mcasp_remove,
1042         .driver         = {
1043                 .name   = "davinci-mcasp",
1044                 .owner  = THIS_MODULE,
1045         },
1046 };
1048 static int __init davinci_mcasp_init(void)
1050         return platform_driver_register(&davinci_mcasp_driver);
1052 module_init(davinci_mcasp_init);
1054 static void __exit davinci_mcasp_exit(void)
1056         platform_driver_unregister(&davinci_mcasp_driver);
1058 module_exit(davinci_mcasp_exit);
1060 MODULE_AUTHOR("Steve Chen");
1061 MODULE_DESCRIPTION("TI DAVINCI McASP SoC Interface");
1062 MODULE_LICENSE("GPL");