Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/sfr/ofcons
[linux-2.6] / sound / soc / sh / ssi.c
1 /*
2  * Serial Sound Interface (I2S) support for SH7760/SH7780
3  *
4  * Copyright (c) 2007 Manuel Lauss <mano@roarinelk.homelinux.net>
5  *
6  *  licensed under the terms outlined in the file COPYING at the root
7  *  of the linux kernel sources.
8  *
9  * dont forget to set IPSEL/OMSEL register bits (in your board code) to
10  * enable SSI output pins!
11  */
12
13 /*
14  * LIMITATIONS:
15  *      The SSI unit has only one physical data line, so full duplex is
16  *      impossible.  This can be remedied  on the  SH7760 by  using the
17  *      other SSI unit for recording; however the SH7780 has only 1 SSI
18  *      unit, and its pins are shared with the AC97 unit,  among others.
19  *
20  * FEATURES:
21  *      The SSI features "compressed mode": in this mode it continuously
22  *      streams PCM data over the I2S lines and uses LRCK as a handshake
23  *      signal.  Can be used to send compressed data (AC3/DTS) to a DSP.
24  *      The number of bits sent over the wire in a frame can be adjusted
25  *      and can be independent from the actual sample bit depth. This is
26  *      useful to support TDM mode codecs like the AD1939 which have a
27  *      fixed TDM slot size, regardless of sample resolution.
28  */
29
30 #include <linux/init.h>
31 #include <linux/module.h>
32 #include <linux/platform_device.h>
33 #include <sound/driver.h>
34 #include <sound/core.h>
35 #include <sound/pcm.h>
36 #include <sound/initval.h>
37 #include <sound/soc.h>
38 #include <asm/io.h>
39
40 #define SSICR   0x00
41 #define SSISR   0x04
42
43 #define CR_DMAEN        (1 << 28)
44 #define CR_CHNL_SHIFT   22
45 #define CR_CHNL_MASK    (3 << CR_CHNL_SHIFT)
46 #define CR_DWL_SHIFT    19
47 #define CR_DWL_MASK     (7 << CR_DWL_SHIFT)
48 #define CR_SWL_SHIFT    16
49 #define CR_SWL_MASK     (7 << CR_SWL_SHIFT)
50 #define CR_SCK_MASTER   (1 << 15)       /* bitclock master bit */
51 #define CR_SWS_MASTER   (1 << 14)       /* wordselect master bit */
52 #define CR_SCKP         (1 << 13)       /* I2Sclock polarity */
53 #define CR_SWSP         (1 << 12)       /* LRCK polarity */
54 #define CR_SPDP         (1 << 11)
55 #define CR_SDTA         (1 << 10)       /* i2s alignment (msb/lsb) */
56 #define CR_PDTA         (1 << 9)        /* fifo data alignment */
57 #define CR_DEL          (1 << 8)        /* delay data by 1 i2sclk */
58 #define CR_BREN         (1 << 7)        /* clock gating in burst mode */
59 #define CR_CKDIV_SHIFT  4
60 #define CR_CKDIV_MASK   (7 << CR_CKDIV_SHIFT)   /* bitclock divider */
61 #define CR_MUTE         (1 << 3)        /* SSI mute */
62 #define CR_CPEN         (1 << 2)        /* compressed mode */
63 #define CR_TRMD         (1 << 1)        /* transmit/receive select */
64 #define CR_EN           (1 << 0)        /* enable SSI */
65
66 #define SSIREG(reg)     (*(unsigned long *)(ssi->mmio + (reg)))
67
68 struct ssi_priv {
69         unsigned long mmio;
70         unsigned long sysclk;
71         int inuse;
72 } ssi_cpu_data[] = {
73 #if defined(CONFIG_CPU_SUBTYPE_SH7760)
74         {
75                 .mmio   = 0xFE680000,
76         },
77         {
78                 .mmio   = 0xFE690000,
79         },
80 #elif defined(CONFIG_CPU_SUBTYPE_SH7780)
81         {
82                 .mmio   = 0xFFE70000,
83         },
84 #else
85 #error "Unsupported SuperH SoC"
86 #endif
87 };
88
89 /*
90  * track usage of the SSI; it is simplex-only so prevent attempts of
91  * concurrent playback + capture. FIXME: any locking required?
92  */
93 static int ssi_startup(struct snd_pcm_substream *substream)
94 {
95         struct snd_soc_pcm_runtime *rtd = substream->private_data;
96         struct ssi_priv *ssi = &ssi_cpu_data[rtd->dai->cpu_dai->id];
97         if (ssi->inuse) {
98                 pr_debug("ssi: already in use!\n");
99                 return -EBUSY;
100         } else
101                 ssi->inuse = 1;
102         return 0;
103 }
104
105 static void ssi_shutdown(struct snd_pcm_substream *substream)
106 {
107         struct snd_soc_pcm_runtime *rtd = substream->private_data;
108         struct ssi_priv *ssi = &ssi_cpu_data[rtd->dai->cpu_dai->id];
109
110         ssi->inuse = 0;
111 }
112
113 static int ssi_trigger(struct snd_pcm_substream *substream, int cmd)
114 {
115         struct snd_soc_pcm_runtime *rtd = substream->private_data;
116         struct ssi_priv *ssi = &ssi_cpu_data[rtd->dai->cpu_dai->id];
117
118         switch (cmd) {
119         case SNDRV_PCM_TRIGGER_START:
120                 SSIREG(SSICR) |= CR_DMAEN | CR_EN;
121                 break;
122         case SNDRV_PCM_TRIGGER_STOP:
123                 SSIREG(SSICR) &= ~(CR_DMAEN | CR_EN);
124                 break;
125         default:
126                 return -EINVAL;
127         }
128
129         return 0;
130 }
131
132 static int ssi_hw_params(struct snd_pcm_substream *substream,
133                          struct snd_pcm_hw_params *params)
134 {
135         struct snd_soc_pcm_runtime *rtd = substream->private_data;
136         struct ssi_priv *ssi = &ssi_cpu_data[rtd->dai->cpu_dai->id];
137         unsigned long ssicr = SSIREG(SSICR);
138         unsigned int bits, channels, swl, recv, i;
139
140         channels = params_channels(params);
141         bits = params->msbits;
142         recv = (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ? 0 : 1;
143
144         pr_debug("ssi_hw_params() enter\nssicr was    %08lx\n", ssicr);
145         pr_debug("bits: %d channels: %d\n", bits, channels);
146
147         ssicr &= ~(CR_TRMD | CR_CHNL_MASK | CR_DWL_MASK | CR_PDTA |
148                    CR_SWL_MASK);
149
150         /* direction (send/receive) */
151         if (!recv)
152                 ssicr |= CR_TRMD;       /* transmit */
153
154         /* channels */
155         if ((channels < 2) || (channels > 8) || (channels & 1)) {
156                 pr_debug("ssi: invalid number of channels\n");
157                 return -EINVAL;
158         }
159         ssicr |= ((channels >> 1) - 1) << CR_CHNL_SHIFT;
160
161         /* DATA WORD LENGTH (DWL): databits in audio sample */
162         i = 0;
163         switch (bits) {
164         case 32: ++i;
165         case 24: ++i;
166         case 22: ++i;
167         case 20: ++i;
168         case 18: ++i;
169         case 16: ++i;
170                  ssicr |= i << CR_DWL_SHIFT;
171         case 8:  break;
172         default:
173                 pr_debug("ssi: invalid sample width\n");
174                 return -EINVAL;
175         }
176
177         /*
178          * SYSTEM WORD LENGTH: size in bits of half a frame over the I2S
179          * wires. This is usually bits_per_sample x channels/2;  i.e. in
180          * Stereo mode  the SWL equals DWL.  SWL can  be bigger than the
181          * product of (channels_per_slot x samplebits), e.g.  for codecs
182          * like the AD1939 which  only accept 32bit wide TDM slots.  For
183          * "standard" I2S operation we set SWL = chans / 2 * DWL here.
184          * Waiting for ASoC to get TDM support ;-)
185          */
186         if ((bits > 16) && (bits <= 24)) {
187                 bits = 24;      /* these are padded by the SSI */
188                 /*ssicr |= CR_PDTA;*/ /* cpu/data endianness ? */
189         }
190         i = 0;
191         swl = (bits * channels) / 2;
192         switch (swl) {
193         case 256: ++i;
194         case 128: ++i;
195         case 64:  ++i;
196         case 48:  ++i;
197         case 32:  ++i;
198         case 16:  ++i;
199                   ssicr |= i << CR_SWL_SHIFT;
200         case 8:   break;
201         default:
202                 pr_debug("ssi: invalid system word length computed\n");
203                 return -EINVAL;
204         }
205
206         SSIREG(SSICR) = ssicr;
207
208         pr_debug("ssi_hw_params() leave\nssicr is now %08lx\n", ssicr);
209         return 0;
210 }
211
212 static int ssi_set_sysclk(struct snd_soc_cpu_dai *cpu_dai, int clk_id,
213                           unsigned int freq, int dir)
214 {
215         struct ssi_priv *ssi = &ssi_cpu_data[cpu_dai->id];
216
217         ssi->sysclk = freq;
218
219         return 0;
220 }
221
222 /*
223  * This divider is used to generate the SSI_SCK (I2S bitclock) from the
224  * clock at the HAC_BIT_CLK ("oversampling clock") pin.
225  */
226 static int ssi_set_clkdiv(struct snd_soc_cpu_dai *dai, int did, int div)
227 {
228         struct ssi_priv *ssi = &ssi_cpu_data[dai->id];
229         unsigned long ssicr;
230         int i;
231
232         i = 0;
233         ssicr = SSIREG(SSICR) & ~CR_CKDIV_MASK;
234         switch (div) {
235         case 16: ++i;
236         case 8:  ++i;
237         case 4:  ++i;
238         case 2:  ++i;
239                  SSIREG(SSICR) = ssicr | (i << CR_CKDIV_SHIFT);
240         case 1:  break;
241         default:
242                 pr_debug("ssi: invalid sck divider %d\n", div);
243                 return -EINVAL;
244         }
245
246         return 0;
247 }
248
249 static int ssi_set_fmt(struct snd_soc_cpu_dai *dai, unsigned int fmt)
250 {
251         struct ssi_priv *ssi = &ssi_cpu_data[dai->id];
252         unsigned long ssicr = SSIREG(SSICR);
253
254         pr_debug("ssi_set_fmt()\nssicr was    0x%08lx\n", ssicr);
255
256         ssicr &= ~(CR_DEL | CR_PDTA | CR_BREN | CR_SWSP | CR_SCKP |
257                    CR_SWS_MASTER | CR_SCK_MASTER);
258
259         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
260         case SND_SOC_DAIFMT_I2S:
261                 break;
262         case SND_SOC_DAIFMT_RIGHT_J:
263                 ssicr |= CR_DEL | CR_PDTA;
264                 break;
265         case SND_SOC_DAIFMT_LEFT_J:
266                 ssicr |= CR_DEL;
267                 break;
268         default:
269                 pr_debug("ssi: unsupported format\n");
270                 return -EINVAL;
271         }
272
273         switch (fmt & SND_SOC_DAIFMT_CLOCK_MASK) {
274         case SND_SOC_DAIFMT_CONT:
275                 break;
276         case SND_SOC_DAIFMT_GATED:
277                 ssicr |= CR_BREN;
278                 break;
279         }
280
281         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
282         case SND_SOC_DAIFMT_NB_NF:
283                 ssicr |= CR_SCKP;       /* sample data at low clkedge */
284                 break;
285         case SND_SOC_DAIFMT_NB_IF:
286                 ssicr |= CR_SCKP | CR_SWSP;
287                 break;
288         case SND_SOC_DAIFMT_IB_NF:
289                 break;
290         case SND_SOC_DAIFMT_IB_IF:
291                 ssicr |= CR_SWSP;       /* word select starts low */
292                 break;
293         default:
294                 pr_debug("ssi: invalid inversion\n");
295                 return -EINVAL;
296         }
297
298         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
299         case SND_SOC_DAIFMT_CBM_CFM:
300                 break;
301         case SND_SOC_DAIFMT_CBS_CFM:
302                 ssicr |= CR_SCK_MASTER;
303                 break;
304         case SND_SOC_DAIFMT_CBM_CFS:
305                 ssicr |= CR_SWS_MASTER;
306                 break;
307         case SND_SOC_DAIFMT_CBS_CFS:
308                 ssicr |= CR_SWS_MASTER | CR_SCK_MASTER;
309                 break;
310         default:
311                 pr_debug("ssi: invalid master/slave configuration\n");
312                 return -EINVAL;
313         }
314
315         SSIREG(SSICR) = ssicr;
316         pr_debug("ssi_set_fmt() leave\nssicr is now 0x%08lx\n", ssicr);
317
318         return 0;
319 }
320
321 /* the SSI depends on an external clocksource (at HAC_BIT_CLK) even in
322  * Master mode,  so really this is board specific;  the SSI can do any
323  * rate with the right bitclk and divider settings.
324  */
325 #define SSI_RATES       \
326         SNDRV_PCM_RATE_8000_192000
327
328 /* the SSI can do 8-32 bit samples, with 8 possible channels */
329 #define SSI_FMTS        \
330         (SNDRV_PCM_FMTBIT_S8      | SNDRV_PCM_FMTBIT_U8      |  \
331          SNDRV_PCM_FMTBIT_S16_LE  | SNDRV_PCM_FMTBIT_U16_LE  |  \
332          SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_U20_3LE |  \
333          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_U24_3LE |  \
334          SNDRV_PCM_FMTBIT_S32_LE  | SNDRV_PCM_FMTBIT_U32_LE)
335
336 struct snd_soc_cpu_dai sh4_ssi_dai[] = {
337 {
338         .name                   = "SSI0",
339         .id                     = 0,
340         .type                   = SND_SOC_DAI_I2S,
341         .playback = {
342                 .rates          = SSI_RATES,
343                 .formats        = SSI_FMTS,
344                 .channels_min   = 2,
345                 .channels_max   = 8,
346         },
347         .capture = {
348                 .rates          = SSI_RATES,
349                 .formats        = SSI_FMTS,
350                 .channels_min   = 2,
351                 .channels_max   = 8,
352         },
353         .ops = {
354                 .startup        = ssi_startup,
355                 .shutdown       = ssi_shutdown,
356                 .trigger        = ssi_trigger,
357                 .hw_params      = ssi_hw_params,
358         },
359         .dai_ops = {
360                 .set_sysclk     = ssi_set_sysclk,
361                 .set_clkdiv     = ssi_set_clkdiv,
362                 .set_fmt        = ssi_set_fmt,
363         },
364 },
365 #ifdef CONFIG_CPU_SUBTYPE_SH7760
366 {
367         .name                   = "SSI1",
368         .id                     = 1,
369         .type                   = SND_SOC_DAI_I2S,
370         .playback = {
371                 .rates          = SSI_RATES,
372                 .formats        = SSI_FMTS,
373                 .channels_min   = 2,
374                 .channels_max   = 8,
375         },
376         .capture = {
377                 .rates          = SSI_RATES,
378                 .formats        = SSI_FMTS,
379                 .channels_min   = 2,
380                 .channels_max   = 8,
381         },
382         .ops = {
383                 .startup        = ssi_startup,
384                 .shutdown       = ssi_shutdown,
385                 .trigger        = ssi_trigger,
386                 .hw_params      = ssi_hw_params,
387         },
388         .dai_ops = {
389                 .set_sysclk     = ssi_set_sysclk,
390                 .set_clkdiv     = ssi_set_clkdiv,
391                 .set_fmt        = ssi_set_fmt,
392         },
393 },
394 #endif
395 };
396 EXPORT_SYMBOL_GPL(sh4_ssi_dai);
397
398 MODULE_LICENSE("GPL");
399 MODULE_DESCRIPTION("SuperH onchip SSI (I2S) audio driver");
400 MODULE_AUTHOR("Manuel Lauss <mano@roarinelk.homelinux.net>");