b9b61ddca6ba07868e158ad3604cd5c6355e1f70
[sfrench/cifs-2.6.git] / sound / soc / pxa / pxa-ssp.c
1 /*
2  * pxa-ssp.c  --  ALSA Soc Audio Layer
3  *
4  * Copyright 2005,2008 Wolfson Microelectronics PLC.
5  * Author: Liam Girdwood
6  *         Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  *
13  * TODO:
14  *  o Test network mode for > 16bit sample size
15  */
16
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/platform_device.h>
20 #include <linux/clk.h>
21 #include <linux/io.h>
22
23 #include <asm/irq.h>
24
25 #include <sound/core.h>
26 #include <sound/pcm.h>
27 #include <sound/initval.h>
28 #include <sound/pcm_params.h>
29 #include <sound/soc.h>
30 #include <sound/pxa2xx-lib.h>
31
32 #include <mach/hardware.h>
33 #include <mach/dma.h>
34 #include <mach/regs-ssp.h>
35 #include <mach/audio.h>
36 #include <mach/ssp.h>
37
38 #include "pxa2xx-pcm.h"
39 #include "pxa-ssp.h"
40
41 /*
42  * SSP audio private data
43  */
44 struct ssp_priv {
45         struct ssp_dev dev;
46         unsigned int sysclk;
47         int dai_fmt;
48 #ifdef CONFIG_PM
49         struct ssp_state state;
50 #endif
51 };
52
53 #define PXA2xx_SSP1_BASE        0x41000000
54 #define PXA27x_SSP2_BASE        0x41700000
55 #define PXA27x_SSP3_BASE        0x41900000
56 #define PXA3xx_SSP4_BASE        0x41a00000
57
58 static struct pxa2xx_pcm_dma_params pxa_ssp1_pcm_mono_out = {
59         .name                   = "SSP1 PCM Mono out",
60         .dev_addr               = PXA2xx_SSP1_BASE + SSDR,
61         .drcmr                  = &DRCMR(14),
62         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
63                                   DCMD_BURST16 | DCMD_WIDTH2,
64 };
65
66 static struct pxa2xx_pcm_dma_params pxa_ssp1_pcm_mono_in = {
67         .name                   = "SSP1 PCM Mono in",
68         .dev_addr               = PXA2xx_SSP1_BASE + SSDR,
69         .drcmr                  = &DRCMR(13),
70         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
71                                   DCMD_BURST16 | DCMD_WIDTH2,
72 };
73
74 static struct pxa2xx_pcm_dma_params pxa_ssp1_pcm_stereo_out = {
75         .name                   = "SSP1 PCM Stereo out",
76         .dev_addr               = PXA2xx_SSP1_BASE + SSDR,
77         .drcmr                  = &DRCMR(14),
78         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
79                                   DCMD_BURST16 | DCMD_WIDTH4,
80 };
81
82 static struct pxa2xx_pcm_dma_params pxa_ssp1_pcm_stereo_in = {
83         .name                   = "SSP1 PCM Stereo in",
84         .dev_addr               = PXA2xx_SSP1_BASE + SSDR,
85         .drcmr                  = &DRCMR(13),
86         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
87                                   DCMD_BURST16 | DCMD_WIDTH4,
88 };
89
90 static struct pxa2xx_pcm_dma_params pxa_ssp2_pcm_mono_out = {
91         .name                   = "SSP2 PCM Mono out",
92         .dev_addr               = PXA27x_SSP2_BASE + SSDR,
93         .drcmr                  = &DRCMR(16),
94         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
95                                   DCMD_BURST16 | DCMD_WIDTH2,
96 };
97
98 static struct pxa2xx_pcm_dma_params pxa_ssp2_pcm_mono_in = {
99         .name                   = "SSP2 PCM Mono in",
100         .dev_addr               = PXA27x_SSP2_BASE + SSDR,
101         .drcmr                  = &DRCMR(15),
102         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
103                                   DCMD_BURST16 | DCMD_WIDTH2,
104 };
105
106 static struct pxa2xx_pcm_dma_params pxa_ssp2_pcm_stereo_out = {
107         .name                   = "SSP2 PCM Stereo out",
108         .dev_addr               = PXA27x_SSP2_BASE + SSDR,
109         .drcmr                  = &DRCMR(16),
110         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
111                                   DCMD_BURST16 | DCMD_WIDTH4,
112 };
113
114 static struct pxa2xx_pcm_dma_params pxa_ssp2_pcm_stereo_in = {
115         .name                   = "SSP2 PCM Stereo in",
116         .dev_addr               = PXA27x_SSP2_BASE + SSDR,
117         .drcmr                  = &DRCMR(15),
118         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
119                                   DCMD_BURST16 | DCMD_WIDTH4,
120 };
121
122 static struct pxa2xx_pcm_dma_params pxa_ssp3_pcm_mono_out = {
123         .name                   = "SSP3 PCM Mono out",
124         .dev_addr               = PXA27x_SSP3_BASE + SSDR,
125         .drcmr                  = &DRCMR(67),
126         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
127                                   DCMD_BURST16 | DCMD_WIDTH2,
128 };
129
130 static struct pxa2xx_pcm_dma_params pxa_ssp3_pcm_mono_in = {
131         .name                   = "SSP3 PCM Mono in",
132         .dev_addr               = PXA27x_SSP3_BASE + SSDR,
133         .drcmr                  = &DRCMR(66),
134         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
135                                   DCMD_BURST16 | DCMD_WIDTH2,
136 };
137
138 static struct pxa2xx_pcm_dma_params pxa_ssp3_pcm_stereo_out = {
139         .name                   = "SSP3 PCM Stereo out",
140         .dev_addr               = PXA27x_SSP3_BASE + SSDR,
141         .drcmr                  = &DRCMR(67),
142         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
143                                   DCMD_BURST16 | DCMD_WIDTH4,
144 };
145
146 static struct pxa2xx_pcm_dma_params pxa_ssp3_pcm_stereo_in = {
147         .name                   = "SSP3 PCM Stereo in",
148         .dev_addr               = PXA27x_SSP3_BASE + SSDR,
149         .drcmr                  = &DRCMR(66),
150         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
151                                   DCMD_BURST16 | DCMD_WIDTH4,
152 };
153
154 static struct pxa2xx_pcm_dma_params pxa_ssp4_pcm_mono_out = {
155         .name                   = "SSP4 PCM Mono out",
156         .dev_addr               = PXA3xx_SSP4_BASE + SSDR,
157         .drcmr                  = &DRCMR(67),
158         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
159                                   DCMD_BURST16 | DCMD_WIDTH2,
160 };
161
162 static struct pxa2xx_pcm_dma_params pxa_ssp4_pcm_mono_in = {
163         .name                   = "SSP4 PCM Mono in",
164         .dev_addr               = PXA3xx_SSP4_BASE + SSDR,
165         .drcmr                  = &DRCMR(66),
166         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
167                                   DCMD_BURST16 | DCMD_WIDTH2,
168 };
169
170 static struct pxa2xx_pcm_dma_params pxa_ssp4_pcm_stereo_out = {
171         .name                   = "SSP4 PCM Stereo out",
172         .dev_addr               = PXA3xx_SSP4_BASE + SSDR,
173         .drcmr                  = &DRCMR(67),
174         .dcmd                   = DCMD_INCSRCADDR | DCMD_FLOWTRG |
175                                   DCMD_BURST16 | DCMD_WIDTH4,
176 };
177
178 static struct pxa2xx_pcm_dma_params pxa_ssp4_pcm_stereo_in = {
179         .name                   = "SSP4 PCM Stereo in",
180         .dev_addr               = PXA3xx_SSP4_BASE + SSDR,
181         .drcmr                  = &DRCMR(66),
182         .dcmd                   = DCMD_INCTRGADDR | DCMD_FLOWSRC |
183                                   DCMD_BURST16 | DCMD_WIDTH4,
184 };
185
186 static void dump_registers(struct ssp_device *ssp)
187 {
188         dev_dbg(&ssp->pdev->dev, "SSCR0 0x%08x SSCR1 0x%08x SSTO 0x%08x\n",
189                  ssp_read_reg(ssp, SSCR0), ssp_read_reg(ssp, SSCR1),
190                  ssp_read_reg(ssp, SSTO));
191
192         dev_dbg(&ssp->pdev->dev, "SSPSP 0x%08x SSSR 0x%08x SSACD 0x%08x\n",
193                  ssp_read_reg(ssp, SSPSP), ssp_read_reg(ssp, SSSR),
194                  ssp_read_reg(ssp, SSACD));
195 }
196
197 static struct pxa2xx_pcm_dma_params *ssp_dma_params[4][4] = {
198         {
199                 &pxa_ssp1_pcm_mono_out, &pxa_ssp1_pcm_mono_in,
200                 &pxa_ssp1_pcm_stereo_out, &pxa_ssp1_pcm_stereo_in,
201         },
202         {
203                 &pxa_ssp2_pcm_mono_out, &pxa_ssp2_pcm_mono_in,
204                 &pxa_ssp2_pcm_stereo_out, &pxa_ssp2_pcm_stereo_in,
205         },
206         {
207                 &pxa_ssp3_pcm_mono_out, &pxa_ssp3_pcm_mono_in,
208                 &pxa_ssp3_pcm_stereo_out, &pxa_ssp3_pcm_stereo_in,
209         },
210         {
211                 &pxa_ssp4_pcm_mono_out, &pxa_ssp4_pcm_mono_in,
212                 &pxa_ssp4_pcm_stereo_out, &pxa_ssp4_pcm_stereo_in,
213         },
214 };
215
216 static int pxa_ssp_startup(struct snd_pcm_substream *substream,
217                            struct snd_soc_dai *dai)
218 {
219         struct snd_soc_pcm_runtime *rtd = substream->private_data;
220         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
221         struct ssp_priv *priv = cpu_dai->private_data;
222         int ret = 0;
223
224         if (!cpu_dai->active) {
225                 priv->dev.port = cpu_dai->id + 1;
226                 priv->dev.irq = NO_IRQ;
227                 clk_enable(priv->dev.ssp->clk);
228                 ssp_disable(&priv->dev);
229         }
230         return ret;
231 }
232
233 static void pxa_ssp_shutdown(struct snd_pcm_substream *substream,
234                              struct snd_soc_dai *dai)
235 {
236         struct snd_soc_pcm_runtime *rtd = substream->private_data;
237         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
238         struct ssp_priv *priv = cpu_dai->private_data;
239
240         if (!cpu_dai->active) {
241                 ssp_disable(&priv->dev);
242                 clk_disable(priv->dev.ssp->clk);
243         }
244 }
245
246 #ifdef CONFIG_PM
247
248 static int pxa_ssp_suspend(struct snd_soc_dai *cpu_dai)
249 {
250         struct ssp_priv *priv = cpu_dai->private_data;
251
252         if (!cpu_dai->active)
253                 return 0;
254
255         ssp_save_state(&priv->dev, &priv->state);
256         clk_disable(priv->dev.ssp->clk);
257         return 0;
258 }
259
260 static int pxa_ssp_resume(struct snd_soc_dai *cpu_dai)
261 {
262         struct ssp_priv *priv = cpu_dai->private_data;
263
264         if (!cpu_dai->active)
265                 return 0;
266
267         clk_enable(priv->dev.ssp->clk);
268         ssp_restore_state(&priv->dev, &priv->state);
269         ssp_enable(&priv->dev);
270
271         return 0;
272 }
273
274 #else
275 #define pxa_ssp_suspend NULL
276 #define pxa_ssp_resume  NULL
277 #endif
278
279 /**
280  * ssp_set_clkdiv - set SSP clock divider
281  * @div: serial clock rate divider
282  */
283 static void ssp_set_scr(struct ssp_device *ssp, u32 div)
284 {
285         u32 sscr0 = ssp_read_reg(ssp, SSCR0);
286
287         if (cpu_is_pxa25x() && ssp->type == PXA25x_SSP) {
288                 sscr0 &= ~0x0000ff00;
289                 sscr0 |= ((div - 2)/2) << 8; /* 2..512 */
290         } else {
291                 sscr0 &= ~0x000fff00;
292                 sscr0 |= (div - 1) << 8;     /* 1..4096 */
293         }
294         ssp_write_reg(ssp, SSCR0, sscr0);
295 }
296
297 /**
298  * ssp_get_clkdiv - get SSP clock divider
299  */
300 static u32 ssp_get_scr(struct ssp_device *ssp)
301 {
302         u32 sscr0 = ssp_read_reg(ssp, SSCR0);
303         u32 div;
304
305         if (cpu_is_pxa25x() && ssp->type == PXA25x_SSP)
306                 div = ((sscr0 >> 8) & 0xff) * 2 + 2;
307         else
308                 div = ((sscr0 >> 8) & 0xfff) + 1;
309         return div;
310 }
311
312 /*
313  * Set the SSP ports SYSCLK.
314  */
315 static int pxa_ssp_set_dai_sysclk(struct snd_soc_dai *cpu_dai,
316         int clk_id, unsigned int freq, int dir)
317 {
318         struct ssp_priv *priv = cpu_dai->private_data;
319         struct ssp_device *ssp = priv->dev.ssp;
320         int val;
321
322         u32 sscr0 = ssp_read_reg(ssp, SSCR0) &
323                 ~(SSCR0_ECS |  SSCR0_NCS | SSCR0_MOD | SSCR0_ACS);
324
325         dev_dbg(&ssp->pdev->dev,
326                 "pxa_ssp_set_dai_sysclk id: %d, clk_id %d, freq %d\n",
327                 cpu_dai->id, clk_id, freq);
328
329         switch (clk_id) {
330         case PXA_SSP_CLK_NET_PLL:
331                 sscr0 |= SSCR0_MOD;
332                 break;
333         case PXA_SSP_CLK_PLL:
334                 /* Internal PLL is fixed */
335                 if (cpu_is_pxa25x())
336                         priv->sysclk = 1843200;
337                 else
338                         priv->sysclk = 13000000;
339                 break;
340         case PXA_SSP_CLK_EXT:
341                 priv->sysclk = freq;
342                 sscr0 |= SSCR0_ECS;
343                 break;
344         case PXA_SSP_CLK_NET:
345                 priv->sysclk = freq;
346                 sscr0 |= SSCR0_NCS | SSCR0_MOD;
347                 break;
348         case PXA_SSP_CLK_AUDIO:
349                 priv->sysclk = 0;
350                 ssp_set_scr(ssp, 1);
351                 sscr0 |= SSCR0_ACS;
352                 break;
353         default:
354                 return -ENODEV;
355         }
356
357         /* The SSP clock must be disabled when changing SSP clock mode
358          * on PXA2xx.  On PXA3xx it must be enabled when doing so. */
359         if (!cpu_is_pxa3xx())
360                 clk_disable(priv->dev.ssp->clk);
361         val = ssp_read_reg(ssp, SSCR0) | sscr0;
362         ssp_write_reg(ssp, SSCR0, val);
363         if (!cpu_is_pxa3xx())
364                 clk_enable(priv->dev.ssp->clk);
365
366         return 0;
367 }
368
369 /*
370  * Set the SSP clock dividers.
371  */
372 static int pxa_ssp_set_dai_clkdiv(struct snd_soc_dai *cpu_dai,
373         int div_id, int div)
374 {
375         struct ssp_priv *priv = cpu_dai->private_data;
376         struct ssp_device *ssp = priv->dev.ssp;
377         int val;
378
379         switch (div_id) {
380         case PXA_SSP_AUDIO_DIV_ACDS:
381                 val = (ssp_read_reg(ssp, SSACD) & ~0x7) | SSACD_ACDS(div);
382                 ssp_write_reg(ssp, SSACD, val);
383                 break;
384         case PXA_SSP_AUDIO_DIV_SCDB:
385                 val = ssp_read_reg(ssp, SSACD);
386                 val &= ~SSACD_SCDB;
387 #if defined(CONFIG_PXA3xx)
388                 if (cpu_is_pxa3xx())
389                         val &= ~SSACD_SCDX8;
390 #endif
391                 switch (div) {
392                 case PXA_SSP_CLK_SCDB_1:
393                         val |= SSACD_SCDB;
394                         break;
395                 case PXA_SSP_CLK_SCDB_4:
396                         break;
397 #if defined(CONFIG_PXA3xx)
398                 case PXA_SSP_CLK_SCDB_8:
399                         if (cpu_is_pxa3xx())
400                                 val |= SSACD_SCDX8;
401                         else
402                                 return -EINVAL;
403                         break;
404 #endif
405                 default:
406                         return -EINVAL;
407                 }
408                 ssp_write_reg(ssp, SSACD, val);
409                 break;
410         case PXA_SSP_DIV_SCR:
411                 ssp_set_scr(ssp, div);
412                 break;
413         default:
414                 return -ENODEV;
415         }
416
417         return 0;
418 }
419
420 /*
421  * Configure the PLL frequency pxa27x and (afaik - pxa320 only)
422  */
423 static int pxa_ssp_set_dai_pll(struct snd_soc_dai *cpu_dai,
424         int pll_id, unsigned int freq_in, unsigned int freq_out)
425 {
426         struct ssp_priv *priv = cpu_dai->private_data;
427         struct ssp_device *ssp = priv->dev.ssp;
428         u32 ssacd = ssp_read_reg(ssp, SSACD) & ~0x70;
429
430 #if defined(CONFIG_PXA3xx)
431         if (cpu_is_pxa3xx())
432                 ssp_write_reg(ssp, SSACDD, 0);
433 #endif
434
435         switch (freq_out) {
436         case 5622000:
437                 break;
438         case 11345000:
439                 ssacd |= (0x1 << 4);
440                 break;
441         case 12235000:
442                 ssacd |= (0x2 << 4);
443                 break;
444         case 14857000:
445                 ssacd |= (0x3 << 4);
446                 break;
447         case 32842000:
448                 ssacd |= (0x4 << 4);
449                 break;
450         case 48000000:
451                 ssacd |= (0x5 << 4);
452                 break;
453         case 0:
454                 /* Disable */
455                 break;
456
457         default:
458 #ifdef CONFIG_PXA3xx
459                 /* PXA3xx has a clock ditherer which can be used to generate
460                  * a wider range of frequencies - calculate a value for it.
461                  */
462                 if (cpu_is_pxa3xx()) {
463                         u32 val;
464                         u64 tmp = 19968;
465                         tmp *= 1000000;
466                         do_div(tmp, freq_out);
467                         val = tmp;
468
469                         val = (val << 16) | 64;;
470                         ssp_write_reg(ssp, SSACDD, val);
471
472                         ssacd |= (0x6 << 4);
473
474                         dev_dbg(&ssp->pdev->dev,
475                                 "Using SSACDD %x to supply %dHz\n",
476                                 val, freq_out);
477                         break;
478                 }
479 #endif
480
481                 return -EINVAL;
482         }
483
484         ssp_write_reg(ssp, SSACD, ssacd);
485
486         return 0;
487 }
488
489 /*
490  * Set the active slots in TDM/Network mode
491  */
492 static int pxa_ssp_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai,
493         unsigned int mask, int slots)
494 {
495         struct ssp_priv *priv = cpu_dai->private_data;
496         struct ssp_device *ssp = priv->dev.ssp;
497         u32 sscr0;
498
499         sscr0 = ssp_read_reg(ssp, SSCR0) & ~SSCR0_SlotsPerFrm(7);
500
501         /* set number of active slots */
502         sscr0 |= SSCR0_SlotsPerFrm(slots);
503         ssp_write_reg(ssp, SSCR0, sscr0);
504
505         /* set active slot mask */
506         ssp_write_reg(ssp, SSTSA, mask);
507         ssp_write_reg(ssp, SSRSA, mask);
508         return 0;
509 }
510
511 /*
512  * Tristate the SSP DAI lines
513  */
514 static int pxa_ssp_set_dai_tristate(struct snd_soc_dai *cpu_dai,
515         int tristate)
516 {
517         struct ssp_priv *priv = cpu_dai->private_data;
518         struct ssp_device *ssp = priv->dev.ssp;
519         u32 sscr1;
520
521         sscr1 = ssp_read_reg(ssp, SSCR1);
522         if (tristate)
523                 sscr1 &= ~SSCR1_TTE;
524         else
525                 sscr1 |= SSCR1_TTE;
526         ssp_write_reg(ssp, SSCR1, sscr1);
527
528         return 0;
529 }
530
531 /*
532  * Set up the SSP DAI format.
533  * The SSP Port must be inactive before calling this function as the
534  * physical interface format is changed.
535  */
536 static int pxa_ssp_set_dai_fmt(struct snd_soc_dai *cpu_dai,
537                 unsigned int fmt)
538 {
539         struct ssp_priv *priv = cpu_dai->private_data;
540         struct ssp_device *ssp = priv->dev.ssp;
541         u32 sscr0;
542         u32 sscr1;
543         u32 sspsp;
544
545         /* check if we need to change anything at all */
546         if (priv->dai_fmt == fmt)
547                 return 0;
548
549         /* we can only change the settings if the port is not in use */
550         if (ssp_read_reg(ssp, SSCR0) & SSCR0_SSE) {
551                 dev_err(&ssp->pdev->dev,
552                         "can't change hardware dai format: stream is in use");
553                 return -EINVAL;
554         }
555
556         /* reset port settings */
557         sscr0 = ssp_read_reg(ssp, SSCR0) &
558                 (SSCR0_ECS |  SSCR0_NCS | SSCR0_MOD | SSCR0_ACS);
559         sscr1 = SSCR1_RxTresh(8) | SSCR1_TxTresh(7);
560         sspsp = 0;
561
562         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
563         case SND_SOC_DAIFMT_CBM_CFM:
564                 sscr1 |= SSCR1_SCLKDIR | SSCR1_SFRMDIR;
565                 break;
566         case SND_SOC_DAIFMT_CBM_CFS:
567                 sscr1 |= SSCR1_SCLKDIR;
568                 break;
569         case SND_SOC_DAIFMT_CBS_CFS:
570                 break;
571         default:
572                 return -EINVAL;
573         }
574
575         ssp_write_reg(ssp, SSCR0, sscr0);
576         ssp_write_reg(ssp, SSCR1, sscr1);
577         ssp_write_reg(ssp, SSPSP, sspsp);
578
579         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
580         case SND_SOC_DAIFMT_I2S:
581                 sscr0 |= SSCR0_PSP;
582                 sscr1 |= SSCR1_RWOT | SSCR1_TRAIL;
583
584                 /* See hw_params() */
585                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
586                 case SND_SOC_DAIFMT_NB_NF:
587                         sspsp |= SSPSP_SFRMP;
588                         break;
589                 case SND_SOC_DAIFMT_NB_IF:
590                         break;
591                 case SND_SOC_DAIFMT_IB_IF:
592                         sspsp |= SSPSP_SCMODE(2);
593                         break;
594                 case SND_SOC_DAIFMT_IB_NF:
595                         sspsp |= SSPSP_SCMODE(2) | SSPSP_SFRMP;
596                         break;
597                 default:
598                         return -EINVAL;
599                 }
600                 break;
601
602         case SND_SOC_DAIFMT_DSP_A:
603                 sspsp |= SSPSP_FSRT;
604         case SND_SOC_DAIFMT_DSP_B:
605                 sscr0 |= SSCR0_MOD | SSCR0_PSP;
606                 sscr1 |= SSCR1_TRAIL | SSCR1_RWOT;
607
608                 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
609                 case SND_SOC_DAIFMT_NB_NF:
610                         sspsp |= SSPSP_SFRMP;
611                         break;
612                 case SND_SOC_DAIFMT_NB_IF:
613                         break;
614                 case SND_SOC_DAIFMT_IB_IF:
615                         sspsp |= SSPSP_SCMODE(2);
616                         break;
617                 case SND_SOC_DAIFMT_IB_NF:
618                         sspsp |= SSPSP_SCMODE(2) | SSPSP_SFRMP;
619                         break;
620                 default:
621                         return -EINVAL;
622                 }
623                 break;
624
625         default:
626                 return -EINVAL;
627         }
628
629         ssp_write_reg(ssp, SSCR0, sscr0);
630         ssp_write_reg(ssp, SSCR1, sscr1);
631         ssp_write_reg(ssp, SSPSP, sspsp);
632
633         dump_registers(ssp);
634
635         /* Since we are configuring the timings for the format by hand
636          * we have to defer some things until hw_params() where we
637          * know parameters like the sample size.
638          */
639         priv->dai_fmt = fmt;
640
641         return 0;
642 }
643
644 /*
645  * Set the SSP audio DMA parameters and sample size.
646  * Can be called multiple times by oss emulation.
647  */
648 static int pxa_ssp_hw_params(struct snd_pcm_substream *substream,
649                                 struct snd_pcm_hw_params *params,
650                                 struct snd_soc_dai *dai)
651 {
652         struct snd_soc_pcm_runtime *rtd = substream->private_data;
653         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
654         struct ssp_priv *priv = cpu_dai->private_data;
655         struct ssp_device *ssp = priv->dev.ssp;
656         int dma = 0, chn = params_channels(params);
657         u32 sscr0;
658         u32 sspsp;
659         int width = snd_pcm_format_physical_width(params_format(params));
660         int ttsa = ssp_read_reg(ssp, SSTSA) & 0xf;
661
662         /* select correct DMA params */
663         if (substream->stream != SNDRV_PCM_STREAM_PLAYBACK)
664                 dma = 1; /* capture DMA offset is 1,3 */
665         /* Network mode with one active slot (ttsa == 1) can be used
666          * to force 16-bit frame width on the wire (for S16_LE), even
667          * with two channels. Use 16-bit DMA transfers for this case.
668          */
669         if (((chn == 2) && (ttsa != 1)) || (width == 32))
670                 dma += 2; /* 32-bit DMA offset is 2, 16-bit is 0 */
671
672         cpu_dai->dma_data = ssp_dma_params[cpu_dai->id][dma];
673
674         dev_dbg(&ssp->pdev->dev, "pxa_ssp_hw_params: dma %d\n", dma);
675
676         /* we can only change the settings if the port is not in use */
677         if (ssp_read_reg(ssp, SSCR0) & SSCR0_SSE)
678                 return 0;
679
680         /* clear selected SSP bits */
681         sscr0 = ssp_read_reg(ssp, SSCR0) & ~(SSCR0_DSS | SSCR0_EDSS);
682         ssp_write_reg(ssp, SSCR0, sscr0);
683
684         /* bit size */
685         sscr0 = ssp_read_reg(ssp, SSCR0);
686         switch (params_format(params)) {
687         case SNDRV_PCM_FORMAT_S16_LE:
688 #ifdef CONFIG_PXA3xx
689                 if (cpu_is_pxa3xx())
690                         sscr0 |= SSCR0_FPCKE;
691 #endif
692                 sscr0 |= SSCR0_DataSize(16);
693                 break;
694         case SNDRV_PCM_FORMAT_S24_LE:
695                 sscr0 |= (SSCR0_EDSS | SSCR0_DataSize(8));
696                 break;
697         case SNDRV_PCM_FORMAT_S32_LE:
698                 sscr0 |= (SSCR0_EDSS | SSCR0_DataSize(16));
699                 break;
700         }
701         ssp_write_reg(ssp, SSCR0, sscr0);
702
703         switch (priv->dai_fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
704         case SND_SOC_DAIFMT_I2S:
705                sspsp = ssp_read_reg(ssp, SSPSP);
706
707                 if ((ssp_get_scr(ssp) == 4) && (width == 16)) {
708                         /* This is a special case where the bitclk is 64fs
709                         * and we're not dealing with 2*32 bits of audio
710                         * samples.
711                         *
712                         * The SSP values used for that are all found out by
713                         * trying and failing a lot; some of the registers
714                         * needed for that mode are only available on PXA3xx.
715                         */
716
717 #ifdef CONFIG_PXA3xx
718                         if (!cpu_is_pxa3xx())
719                                 return -EINVAL;
720
721                         sspsp |= SSPSP_SFRMWDTH(width * 2);
722                         sspsp |= SSPSP_SFRMDLY(width * 4);
723                         sspsp |= SSPSP_EDMYSTOP(3);
724                         sspsp |= SSPSP_DMYSTOP(3);
725                         sspsp |= SSPSP_DMYSTRT(1);
726 #else
727                         return -EINVAL;
728 #endif
729                 } else {
730                         /* The frame width is the width the LRCLK is
731                          * asserted for; the delay is expressed in
732                          * half cycle units.  We need the extra cycle
733                          * because the data starts clocking out one BCLK
734                          * after LRCLK changes polarity.
735                          */
736                         sspsp |= SSPSP_SFRMWDTH(width + 1);
737                         sspsp |= SSPSP_SFRMDLY((width + 1) * 2);
738                         sspsp |= SSPSP_DMYSTRT(1);
739                 }
740
741                 ssp_write_reg(ssp, SSPSP, sspsp);
742                 break;
743         default:
744                 break;
745         }
746
747         /* When we use a network mode, we always require TDM slots
748          * - complain loudly and fail if they've not been set up yet.
749          */
750         if ((sscr0 & SSCR0_MOD) && !ttsa) {
751                 dev_err(&ssp->pdev->dev, "No TDM timeslot configured\n");
752                 return -EINVAL;
753         }
754
755         dump_registers(ssp);
756
757         return 0;
758 }
759
760 static int pxa_ssp_trigger(struct snd_pcm_substream *substream, int cmd,
761                            struct snd_soc_dai *dai)
762 {
763         struct snd_soc_pcm_runtime *rtd = substream->private_data;
764         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
765         int ret = 0;
766         struct ssp_priv *priv = cpu_dai->private_data;
767         struct ssp_device *ssp = priv->dev.ssp;
768         int val;
769
770         switch (cmd) {
771         case SNDRV_PCM_TRIGGER_RESUME:
772                 ssp_enable(&priv->dev);
773                 break;
774         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
775                 val = ssp_read_reg(ssp, SSCR1);
776                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
777                         val |= SSCR1_TSRE;
778                 else
779                         val |= SSCR1_RSRE;
780                 ssp_write_reg(ssp, SSCR1, val);
781                 val = ssp_read_reg(ssp, SSSR);
782                 ssp_write_reg(ssp, SSSR, val);
783                 break;
784         case SNDRV_PCM_TRIGGER_START:
785                 val = ssp_read_reg(ssp, SSCR1);
786                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
787                         val |= SSCR1_TSRE;
788                 else
789                         val |= SSCR1_RSRE;
790                 ssp_write_reg(ssp, SSCR1, val);
791                 ssp_enable(&priv->dev);
792                 break;
793         case SNDRV_PCM_TRIGGER_STOP:
794                 val = ssp_read_reg(ssp, SSCR1);
795                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
796                         val &= ~SSCR1_TSRE;
797                 else
798                         val &= ~SSCR1_RSRE;
799                 ssp_write_reg(ssp, SSCR1, val);
800                 break;
801         case SNDRV_PCM_TRIGGER_SUSPEND:
802                 ssp_disable(&priv->dev);
803                 break;
804         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
805                 val = ssp_read_reg(ssp, SSCR1);
806                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
807                         val &= ~SSCR1_TSRE;
808                 else
809                         val &= ~SSCR1_RSRE;
810                 ssp_write_reg(ssp, SSCR1, val);
811                 break;
812
813         default:
814                 ret = -EINVAL;
815         }
816
817         dump_registers(ssp);
818
819         return ret;
820 }
821
822 static int pxa_ssp_probe(struct platform_device *pdev,
823                             struct snd_soc_dai *dai)
824 {
825         struct ssp_priv *priv;
826         int ret;
827
828         priv = kzalloc(sizeof(struct ssp_priv), GFP_KERNEL);
829         if (!priv)
830                 return -ENOMEM;
831
832         priv->dev.ssp = ssp_request(dai->id + 1, "SoC audio");
833         if (priv->dev.ssp == NULL) {
834                 ret = -ENODEV;
835                 goto err_priv;
836         }
837
838         priv->dai_fmt = (unsigned int) -1;
839         dai->private_data = priv;
840
841         return 0;
842
843 err_priv:
844         kfree(priv);
845         return ret;
846 }
847
848 static void pxa_ssp_remove(struct platform_device *pdev,
849                               struct snd_soc_dai *dai)
850 {
851         struct ssp_priv *priv = dai->private_data;
852         ssp_free(priv->dev.ssp);
853 }
854
855 #define PXA_SSP_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
856                           SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | \
857                           SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \
858                           SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
859
860 #define PXA_SSP_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
861                             SNDRV_PCM_FMTBIT_S24_LE |   \
862                             SNDRV_PCM_FMTBIT_S32_LE)
863
864 static struct snd_soc_dai_ops pxa_ssp_dai_ops = {
865         .startup        = pxa_ssp_startup,
866         .shutdown       = pxa_ssp_shutdown,
867         .trigger        = pxa_ssp_trigger,
868         .hw_params      = pxa_ssp_hw_params,
869         .set_sysclk     = pxa_ssp_set_dai_sysclk,
870         .set_clkdiv     = pxa_ssp_set_dai_clkdiv,
871         .set_pll        = pxa_ssp_set_dai_pll,
872         .set_fmt        = pxa_ssp_set_dai_fmt,
873         .set_tdm_slot   = pxa_ssp_set_dai_tdm_slot,
874         .set_tristate   = pxa_ssp_set_dai_tristate,
875 };
876
877 struct snd_soc_dai pxa_ssp_dai[] = {
878         {
879                 .name = "pxa2xx-ssp1",
880                 .id = 0,
881                 .probe = pxa_ssp_probe,
882                 .remove = pxa_ssp_remove,
883                 .suspend = pxa_ssp_suspend,
884                 .resume = pxa_ssp_resume,
885                 .playback = {
886                         .channels_min = 1,
887                         .channels_max = 2,
888                         .rates = PXA_SSP_RATES,
889                         .formats = PXA_SSP_FORMATS,
890                 },
891                 .capture = {
892                          .channels_min = 1,
893                          .channels_max = 2,
894                         .rates = PXA_SSP_RATES,
895                         .formats = PXA_SSP_FORMATS,
896                  },
897                 .ops = &pxa_ssp_dai_ops,
898         },
899         {       .name = "pxa2xx-ssp2",
900                 .id = 1,
901                 .probe = pxa_ssp_probe,
902                 .remove = pxa_ssp_remove,
903                 .suspend = pxa_ssp_suspend,
904                 .resume = pxa_ssp_resume,
905                 .playback = {
906                         .channels_min = 1,
907                         .channels_max = 2,
908                         .rates = PXA_SSP_RATES,
909                         .formats = PXA_SSP_FORMATS,
910                 },
911                 .capture = {
912                         .channels_min = 1,
913                         .channels_max = 2,
914                         .rates = PXA_SSP_RATES,
915                         .formats = PXA_SSP_FORMATS,
916                  },
917                 .ops = &pxa_ssp_dai_ops,
918         },
919         {
920                 .name = "pxa2xx-ssp3",
921                 .id = 2,
922                 .probe = pxa_ssp_probe,
923                 .remove = pxa_ssp_remove,
924                 .suspend = pxa_ssp_suspend,
925                 .resume = pxa_ssp_resume,
926                 .playback = {
927                         .channels_min = 1,
928                         .channels_max = 2,
929                         .rates = PXA_SSP_RATES,
930                         .formats = PXA_SSP_FORMATS,
931                 },
932                 .capture = {
933                         .channels_min = 1,
934                         .channels_max = 2,
935                         .rates = PXA_SSP_RATES,
936                         .formats = PXA_SSP_FORMATS,
937                  },
938                 .ops = &pxa_ssp_dai_ops,
939         },
940         {
941                 .name = "pxa2xx-ssp4",
942                 .id = 3,
943                 .probe = pxa_ssp_probe,
944                 .remove = pxa_ssp_remove,
945                 .suspend = pxa_ssp_suspend,
946                 .resume = pxa_ssp_resume,
947                 .playback = {
948                         .channels_min = 1,
949                         .channels_max = 2,
950                         .rates = PXA_SSP_RATES,
951                         .formats = PXA_SSP_FORMATS,
952                 },
953                 .capture = {
954                         .channels_min = 1,
955                         .channels_max = 2,
956                         .rates = PXA_SSP_RATES,
957                         .formats = PXA_SSP_FORMATS,
958                  },
959                 .ops = &pxa_ssp_dai_ops,
960         },
961 };
962 EXPORT_SYMBOL_GPL(pxa_ssp_dai);
963
964 static int __init pxa_ssp_init(void)
965 {
966         return snd_soc_register_dais(pxa_ssp_dai, ARRAY_SIZE(pxa_ssp_dai));
967 }
968 module_init(pxa_ssp_init);
969
970 static void __exit pxa_ssp_exit(void)
971 {
972         snd_soc_unregister_dais(pxa_ssp_dai, ARRAY_SIZE(pxa_ssp_dai));
973 }
974 module_exit(pxa_ssp_exit);
975
976 /* Module information */
977 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
978 MODULE_DESCRIPTION("PXA SSP/PCM SoC Interface");
979 MODULE_LICENSE("GPL");