1b0044f19e3ee4abb23aaf0b4eb504f52fb475d9
[kernel.git] / sound / soc / s3c24xx / neo1973_wm8753.c
1 /*
2  * neo1973_wm8753.c  --  SoC audio for Neo1973
3  *
4  * Copyright 2007 Wolfson Microelectronics PLC.
5  * Author: Graeme Gregory
6  *         graeme.gregory@wolfsonmicro.com or linux@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  */
14
15 #include <linux/module.h>
16 #include <linux/moduleparam.h>
17 #include <linux/timer.h>
18 #include <linux/interrupt.h>
19 #include <linux/platform_device.h>
20 #include <linux/i2c.h>
21 #include <sound/core.h>
22 #include <sound/pcm.h>
23 #include <sound/soc.h>
24 #include <sound/soc-dapm.h>
25 #include <sound/tlv.h>
26
27 #include <asm/mach-types.h>
28 #include <asm/hardware/scoop.h>
29 #include <mach/regs-clock.h>
30 #include <mach/regs-gpio.h>
31 #include <mach/hardware.h>
32 #include <linux/io.h>
33 #include <mach/spi-gpio.h>
34
35 #include <plat/regs-iis.h>
36
37 #include "../codecs/wm8753.h"
38 #include "lm4857.h"
39 #include "s3c-dma.h"
40 #include "s3c24xx-i2s.h"
41
42 static struct snd_soc_card neo1973;
43 static struct i2c_client *i2c;
44
45 static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
46         struct snd_pcm_hw_params *params)
47 {
48         struct snd_soc_pcm_runtime *rtd = substream->private_data;
49         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
50         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
51         unsigned int pll_out = 0, bclk = 0;
52         int ret = 0;
53         unsigned long iis_clkrate;
54
55         pr_debug("Entered %s\n", __func__);
56
57         iis_clkrate = s3c24xx_i2s_get_clockrate();
58
59         switch (params_rate(params)) {
60         case 8000:
61         case 16000:
62                 pll_out = 12288000;
63                 break;
64         case 48000:
65                 bclk = WM8753_BCLK_DIV_4;
66                 pll_out = 12288000;
67                 break;
68         case 96000:
69                 bclk = WM8753_BCLK_DIV_2;
70                 pll_out = 12288000;
71                 break;
72         case 11025:
73                 bclk = WM8753_BCLK_DIV_16;
74                 pll_out = 11289600;
75                 break;
76         case 22050:
77                 bclk = WM8753_BCLK_DIV_8;
78                 pll_out = 11289600;
79                 break;
80         case 44100:
81                 bclk = WM8753_BCLK_DIV_4;
82                 pll_out = 11289600;
83                 break;
84         case 88200:
85                 bclk = WM8753_BCLK_DIV_2;
86                 pll_out = 11289600;
87                 break;
88         }
89
90         /* set codec DAI configuration */
91         ret = snd_soc_dai_set_fmt(codec_dai,
92                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
93                 SND_SOC_DAIFMT_CBM_CFM);
94         if (ret < 0)
95                 return ret;
96
97         /* set cpu DAI configuration */
98         ret = snd_soc_dai_set_fmt(cpu_dai,
99                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
100                 SND_SOC_DAIFMT_CBM_CFM);
101         if (ret < 0)
102                 return ret;
103
104         /* set the codec system clock for DAC and ADC */
105         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
106                 SND_SOC_CLOCK_IN);
107         if (ret < 0)
108                 return ret;
109
110         /* set MCLK division for sample rate */
111         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
112                 S3C2410_IISMOD_32FS);
113         if (ret < 0)
114                 return ret;
115
116         /* set codec BCLK division for sample rate */
117         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_BCLKDIV, bclk);
118         if (ret < 0)
119                 return ret;
120
121         /* set prescaler division for sample rate */
122         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
123                 S3C24XX_PRESCALE(4, 4));
124         if (ret < 0)
125                 return ret;
126
127         /* codec PLL input is PCLK/4 */
128         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0,
129                 iis_clkrate / 4, pll_out);
130         if (ret < 0)
131                 return ret;
132
133         return 0;
134 }
135
136 static int neo1973_hifi_hw_free(struct snd_pcm_substream *substream)
137 {
138         struct snd_soc_pcm_runtime *rtd = substream->private_data;
139         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
140
141         pr_debug("Entered %s\n", __func__);
142
143         /* disable the PLL */
144         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0, 0);
145 }
146
147 /*
148  * Neo1973 WM8753 HiFi DAI opserations.
149  */
150 static struct snd_soc_ops neo1973_hifi_ops = {
151         .hw_params = neo1973_hifi_hw_params,
152         .hw_free = neo1973_hifi_hw_free,
153 };
154
155 static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
156         struct snd_pcm_hw_params *params)
157 {
158         struct snd_soc_pcm_runtime *rtd = substream->private_data;
159         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
160         unsigned int pcmdiv = 0;
161         int ret = 0;
162         unsigned long iis_clkrate;
163
164         pr_debug("Entered %s\n", __func__);
165
166         iis_clkrate = s3c24xx_i2s_get_clockrate();
167
168         if (params_rate(params) != 8000)
169                 return -EINVAL;
170         if (params_channels(params) != 1)
171                 return -EINVAL;
172
173         pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
174
175         /* todo: gg check mode (DSP_B) against CSR datasheet */
176         /* set codec DAI configuration */
177         ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
178                 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
179         if (ret < 0)
180                 return ret;
181
182         /* set the codec system clock for DAC and ADC */
183         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, 12288000,
184                 SND_SOC_CLOCK_IN);
185         if (ret < 0)
186                 return ret;
187
188         /* set codec PCM division for sample rate */
189         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV, pcmdiv);
190         if (ret < 0)
191                 return ret;
192
193         /* configue and enable PLL for 12.288MHz output */
194         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0,
195                 iis_clkrate / 4, 12288000);
196         if (ret < 0)
197                 return ret;
198
199         return 0;
200 }
201
202 static int neo1973_voice_hw_free(struct snd_pcm_substream *substream)
203 {
204         struct snd_soc_pcm_runtime *rtd = substream->private_data;
205         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
206
207         pr_debug("Entered %s\n", __func__);
208
209         /* disable the PLL */
210         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0, 0);
211 }
212
213 static struct snd_soc_ops neo1973_voice_ops = {
214         .hw_params = neo1973_voice_hw_params,
215         .hw_free = neo1973_voice_hw_free,
216 };
217
218 static u8 lm4857_regs[4] = {0x00, 0x40, 0x80, 0xC0};
219
220 static void lm4857_write_regs(void)
221 {
222         pr_debug("Entered %s\n", __func__);
223
224         if (i2c_master_send(i2c, lm4857_regs, 4) != 4)
225                 printk(KERN_ERR "lm4857: i2c write failed\n");
226 }
227
228 static int lm4857_get_reg(struct snd_kcontrol *kcontrol,
229         struct snd_ctl_elem_value *ucontrol)
230 {
231         struct soc_mixer_control *mc =
232                 (struct soc_mixer_control *)kcontrol->private_value;
233         int reg = mc->reg;
234         int shift = mc->shift;
235         int mask = mc->max;
236
237         pr_debug("Entered %s\n", __func__);
238
239         ucontrol->value.integer.value[0] = (lm4857_regs[reg] >> shift) & mask;
240         return 0;
241 }
242
243 static int lm4857_set_reg(struct snd_kcontrol *kcontrol,
244         struct snd_ctl_elem_value *ucontrol)
245 {
246         struct soc_mixer_control *mc =
247                 (struct soc_mixer_control *)kcontrol->private_value;
248         int reg = mc->reg;
249         int shift = mc->shift;
250         int mask = mc->max;
251
252         if (((lm4857_regs[reg] >> shift) & mask) ==
253                 ucontrol->value.integer.value[0])
254                 return 0;
255
256         lm4857_regs[reg] &= ~(mask << shift);
257         lm4857_regs[reg] |= ucontrol->value.integer.value[0] << shift;
258         lm4857_write_regs();
259         return 1;
260 }
261
262 static int lm4857_get_mode(struct snd_kcontrol *kcontrol,
263         struct snd_ctl_elem_value *ucontrol)
264 {
265         u8 value = lm4857_regs[LM4857_CTRL] & 0x0F;
266
267         pr_debug("Entered %s\n", __func__);
268
269         if (value)
270                 value -= 5;
271
272         ucontrol->value.integer.value[0] = value;
273         return 0;
274 }
275
276 static int lm4857_set_mode(struct snd_kcontrol *kcontrol,
277         struct snd_ctl_elem_value *ucontrol)
278 {
279         u8 value = ucontrol->value.integer.value[0];
280
281         pr_debug("Entered %s\n", __func__);
282
283         if (value)
284                 value += 5;
285
286         if ((lm4857_regs[LM4857_CTRL] & 0x0F) == value)
287                 return 0;
288
289         lm4857_regs[LM4857_CTRL] &= 0xF0;
290         lm4857_regs[LM4857_CTRL] |= value;
291         lm4857_write_regs();
292         return 1;
293 }
294
295 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
296         SND_SOC_DAPM_LINE("Audio Out", NULL),
297         SND_SOC_DAPM_LINE("GSM Line Out", NULL),
298         SND_SOC_DAPM_LINE("GSM Line In", NULL),
299         SND_SOC_DAPM_MIC("Headset Mic", NULL),
300         SND_SOC_DAPM_MIC("Call Mic", NULL),
301 };
302
303 static const struct snd_soc_dapm_route dapm_routes[] = {
304
305         /* Connections to the lm4857 amp */
306         {"Audio Out", NULL, "LOUT1"},
307         {"Audio Out", NULL, "ROUT1"},
308
309         /* Connections to the GSM Module */
310         {"GSM Line Out", NULL, "MONO1"},
311         {"GSM Line Out", NULL, "MONO2"},
312         {"RXP", NULL, "GSM Line In"},
313         {"RXN", NULL, "GSM Line In"},
314
315         /* Connections to Headset */
316         {"MIC1", NULL, "Mic Bias"},
317         {"Mic Bias", NULL, "Headset Mic"},
318
319         /* Call Mic */
320         {"MIC2", NULL, "Mic Bias"},
321         {"MIC2N", NULL, "Mic Bias"},
322         {"Mic Bias", NULL, "Call Mic"},
323
324         /* Connect the ALC pins */
325         {"ACIN", NULL, "ACOP"},
326 };
327
328 static const char *lm4857_mode[] = {
329         "Off",
330         "Call Speaker",
331         "Stereo Speakers",
332         "Stereo Speakers + Headphones",
333         "Headphones"
334 };
335
336 static const struct soc_enum lm4857_mode_enum[] = {
337         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(lm4857_mode), lm4857_mode),
338 };
339
340 static const DECLARE_TLV_DB_SCALE(stereo_tlv, -4050, 150, 0);
341 static const DECLARE_TLV_DB_SCALE(mono_tlv, -3450, 150, 0);
342
343 static const struct snd_kcontrol_new wm8753_neo1973_controls[] = {
344         SOC_SINGLE_EXT_TLV("Amp Left Playback Volume", LM4857_LVOL, 0, 31, 0,
345                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
346         SOC_SINGLE_EXT_TLV("Amp Right Playback Volume", LM4857_RVOL, 0, 31, 0,
347                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
348         SOC_SINGLE_EXT_TLV("Amp Mono Playback Volume", LM4857_MVOL, 0, 31, 0,
349                 lm4857_get_reg, lm4857_set_reg, mono_tlv),
350         SOC_ENUM_EXT("Amp Mode", lm4857_mode_enum[0],
351                 lm4857_get_mode, lm4857_set_mode),
352         SOC_SINGLE_EXT("Amp Spk 3D Playback Switch", LM4857_LVOL, 5, 1, 0,
353                 lm4857_get_reg, lm4857_set_reg),
354         SOC_SINGLE_EXT("Amp HP 3d Playback Switch", LM4857_RVOL, 5, 1, 0,
355                 lm4857_get_reg, lm4857_set_reg),
356         SOC_SINGLE_EXT("Amp Fast Wakeup Playback Switch", LM4857_CTRL, 5, 1, 0,
357                 lm4857_get_reg, lm4857_set_reg),
358         SOC_SINGLE_EXT("Amp Earpiece 6dB Playback Switch", LM4857_CTRL, 4, 1, 0,
359                 lm4857_get_reg, lm4857_set_reg),
360 };
361
362 /*
363  * This is an example machine initialisation for a wm8753 connected to a
364  * neo1973 II. It is missing logic to detect hp/mic insertions and logic
365  * to re-route the audio in such an event.
366  */
367 static int neo1973_wm8753_init(struct snd_soc_codec *codec)
368 {
369         int err;
370
371         pr_debug("Entered %s\n", __func__);
372
373         /* set up NC codec pins */
374         snd_soc_dapm_nc_pin(codec, "LOUT2");
375         snd_soc_dapm_nc_pin(codec, "ROUT2");
376         snd_soc_dapm_nc_pin(codec, "OUT3");
377         snd_soc_dapm_nc_pin(codec, "OUT4");
378         snd_soc_dapm_nc_pin(codec, "LINE1");
379         snd_soc_dapm_nc_pin(codec, "LINE2");
380
381         /* Add neo1973 specific widgets */
382         snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
383                                   ARRAY_SIZE(wm8753_dapm_widgets));
384
385         /* set endpoints to default mode */
386         snd_soc_dapm_disable_pin(codec, "Audio Out");
387         snd_soc_dapm_disable_pin(codec, "GSM Line Out");
388         snd_soc_dapm_disable_pin(codec, "GSM Line In");
389         snd_soc_dapm_disable_pin(codec, "Headset Mic");
390         snd_soc_dapm_disable_pin(codec, "Call Mic");
391
392         /* add neo1973 specific controls */
393         err = snd_soc_add_controls(codec, wm8753_neo1973_controls,
394                                 ARRAY_SIZE(8753_neo1973_controls));
395         if (err < 0)
396                 return err;
397
398         /* set up neo1973 specific audio routes */
399         err = snd_soc_dapm_add_routes(codec, dapm_routes,
400                                       ARRAY_SIZE(dapm_routes));
401
402         snd_soc_dapm_sync(codec);
403         return 0;
404 }
405
406 /*
407  * BT Codec DAI
408  */
409 static struct snd_soc_dai bt_dai = {
410         .name = "Bluetooth",
411         .id = 0,
412         .playback = {
413                 .channels_min = 1,
414                 .channels_max = 1,
415                 .rates = SNDRV_PCM_RATE_8000,
416                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
417         .capture = {
418                 .channels_min = 1,
419                 .channels_max = 1,
420                 .rates = SNDRV_PCM_RATE_8000,
421                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
422 };
423
424 static struct snd_soc_dai_link neo1973_dai[] = {
425 { /* Hifi Playback - for similatious use with voice below */
426         .name = "WM8753",
427         .stream_name = "WM8753 HiFi",
428         .cpu_dai = &s3c24xx_i2s_dai,
429         .codec_dai = &wm8753_dai[WM8753_DAI_HIFI],
430         .init = neo1973_wm8753_init,
431         .ops = &neo1973_hifi_ops,
432 },
433 { /* Voice via BT */
434         .name = "Bluetooth",
435         .stream_name = "Voice",
436         .cpu_dai = &bt_dai,
437         .codec_dai = &wm8753_dai[WM8753_DAI_VOICE],
438         .ops = &neo1973_voice_ops,
439 },
440 };
441
442 static struct snd_soc_card neo1973 = {
443         .name = "neo1973",
444         .platform = &s3c24xx_soc_platform,
445         .dai_link = neo1973_dai,
446         .num_links = ARRAY_SIZE(neo1973_dai),
447 };
448
449 static struct snd_soc_device neo1973_snd_devdata = {
450         .card = &neo1973,
451         .codec_dev = &soc_codec_dev_wm8753,
452 };
453
454 static int lm4857_i2c_probe(struct i2c_client *client,
455                             const struct i2c_device_id *id)
456 {
457         pr_debug("Entered %s\n", __func__);
458
459         i2c = client;
460
461         lm4857_write_regs();
462         return 0;
463 }
464
465 static int lm4857_i2c_remove(struct i2c_client *client)
466 {
467         pr_debug("Entered %s\n", __func__);
468
469         i2c = NULL;
470
471         return 0;
472 }
473
474 static u8 lm4857_state;
475
476 static int lm4857_suspend(struct i2c_client *dev, pm_message_t state)
477 {
478         pr_debug("Entered %s\n", __func__);
479
480         dev_dbg(&dev->dev, "lm4857_suspend\n");
481         lm4857_state = lm4857_regs[LM4857_CTRL] & 0xf;
482         if (lm4857_state) {
483                 lm4857_regs[LM4857_CTRL] &= 0xf0;
484                 lm4857_write_regs();
485         }
486         return 0;
487 }
488
489 static int lm4857_resume(struct i2c_client *dev)
490 {
491         pr_debug("Entered %s\n", __func__);
492
493         if (lm4857_state) {
494                 lm4857_regs[LM4857_CTRL] |= (lm4857_state & 0x0f);
495                 lm4857_write_regs();
496         }
497         return 0;
498 }
499
500 static void lm4857_shutdown(struct i2c_client *dev)
501 {
502         pr_debug("Entered %s\n", __func__);
503
504         dev_dbg(&dev->dev, "lm4857_shutdown\n");
505         lm4857_regs[LM4857_CTRL] &= 0xf0;
506         lm4857_write_regs();
507 }
508
509 static const struct i2c_device_id lm4857_i2c_id[] = {
510         { "neo1973_lm4857", 0 },
511         { }
512 };
513
514 static struct i2c_driver lm4857_i2c_driver = {
515         .driver = {
516                 .name = "LM4857 I2C Amp",
517                 .owner = THIS_MODULE,
518         },
519         .suspend =        lm4857_suspend,
520         .resume =         lm4857_resume,
521         .shutdown =       lm4857_shutdown,
522         .probe =          lm4857_i2c_probe,
523         .remove =         lm4857_i2c_remove,
524         .id_table =       lm4857_i2c_id,
525 };
526
527 static struct platform_device *neo1973_snd_device;
528
529 static int __init neo1973_init(void)
530 {
531         int ret;
532
533         pr_debug("Entered %s\n", __func__);
534
535         if (!machine_is_neo1973_gta01()) {
536                 printk(KERN_INFO
537                         "Only GTA01 hardware supported by ASoC driver\n");
538                 return -ENODEV;
539         }
540
541         neo1973_snd_device = platform_device_alloc("soc-audio", -1);
542         if (!neo1973_snd_device)
543                 return -ENOMEM;
544
545         platform_set_drvdata(neo1973_snd_device, &neo1973_snd_devdata);
546         neo1973_snd_devdata.dev = &neo1973_snd_device->dev;
547         ret = platform_device_add(neo1973_snd_device);
548
549         if (ret) {
550                 platform_device_put(neo1973_snd_device);
551                 return ret;
552         }
553
554         ret = i2c_add_driver(&lm4857_i2c_driver);
555
556         if (ret != 0)
557                 platform_device_unregister(neo1973_snd_device);
558
559         return ret;
560 }
561
562 static void __exit neo1973_exit(void)
563 {
564         pr_debug("Entered %s\n", __func__);
565
566         i2c_del_driver(&lm4857_i2c_driver);
567         platform_device_unregister(neo1973_snd_device);
568 }
569
570 module_init(neo1973_init);
571 module_exit(neo1973_exit);
572
573 /* Module information */
574 MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org, www.openmoko.org");
575 MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973");
576 MODULE_LICENSE("GPL");