Implement enable/reset of 3D engine
[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 <plat/audio.h>
33 #include <linux/io.h>
34 #include <mach/spi-gpio.h>
35
36 #include <plat/regs-iis.h>
37
38 #include "../codecs/wm8753.h"
39 #include "lm4857.h"
40 #include "s3c24xx-pcm.h"
41 #include "s3c24xx-i2s.h"
42
43 /* Debugging stuff */
44 #define S3C24XX_SOC_NEO1973_WM8753_DEBUG 0
45 #if S3C24XX_SOC_NEO1973_WM8753_DEBUG
46 #define DBG(x...) printk(KERN_DEBUG "s3c24xx-soc-neo1973-wm8753: " x)
47 #else
48 #define DBG(x...)
49 #endif
50
51 /* define the scenarios */
52 #define NEO_AUDIO_OFF                   0
53 #define NEO_GSM_CALL_AUDIO_HANDSET      1
54 #define NEO_GSM_CALL_AUDIO_HEADSET      2
55 #define NEO_GSM_CALL_AUDIO_BLUETOOTH    3
56 #define NEO_STEREO_TO_SPEAKERS          4
57 #define NEO_STEREO_TO_HEADPHONES        5
58 #define NEO_CAPTURE_HANDSET             6
59 #define NEO_CAPTURE_HEADSET             7
60 #define NEO_CAPTURE_BLUETOOTH           8
61
62 static struct snd_soc_card neo1973;
63 static struct i2c_client *i2c;
64
65 static int neo1973_hifi_hw_params(struct snd_pcm_substream *substream,
66         struct snd_pcm_hw_params *params)
67 {
68         struct snd_soc_pcm_runtime *rtd = substream->private_data;
69         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
70         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
71         unsigned int pll_out = 0, bclk = 0;
72         int ret = 0;
73         unsigned long iis_clkrate;
74
75         DBG("Entered %s\n", __func__);
76
77         iis_clkrate = s3c24xx_i2s_get_clockrate();
78
79         switch (params_rate(params)) {
80         case 8000:
81         case 16000:
82                 pll_out = 12288000;
83                 break;
84         case 48000:
85                 bclk = WM8753_BCLK_DIV_4;
86                 pll_out = 12288000;
87                 break;
88         case 96000:
89                 bclk = WM8753_BCLK_DIV_2;
90                 pll_out = 12288000;
91                 break;
92         case 11025:
93                 bclk = WM8753_BCLK_DIV_16;
94                 pll_out = 11289600;
95                 break;
96         case 22050:
97                 bclk = WM8753_BCLK_DIV_8;
98                 pll_out = 11289600;
99                 break;
100         case 44100:
101                 bclk = WM8753_BCLK_DIV_4;
102                 pll_out = 11289600;
103                 break;
104         case 88200:
105                 bclk = WM8753_BCLK_DIV_2;
106                 pll_out = 11289600;
107                 break;
108         }
109
110         /* set codec DAI configuration */
111         ret = snd_soc_dai_set_fmt(codec_dai,
112                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
113                 SND_SOC_DAIFMT_CBM_CFM);
114         if (ret < 0)
115                 return ret;
116
117         /* set cpu DAI configuration */
118         ret = snd_soc_dai_set_fmt(cpu_dai,
119                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
120                 SND_SOC_DAIFMT_CBM_CFM);
121         if (ret < 0)
122                 return ret;
123
124         /* set the codec system clock for DAC and ADC */
125         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_MCLK, pll_out,
126                 SND_SOC_CLOCK_IN);
127         if (ret < 0)
128                 return ret;
129
130         /* set MCLK division for sample rate */
131         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
132                 S3C2410_IISMOD_32FS);
133         if (ret < 0)
134                 return ret;
135
136         /* set codec BCLK division for sample rate */
137         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_BCLKDIV, bclk);
138         if (ret < 0)
139                 return ret;
140
141         /* set prescaler division for sample rate */
142         ret = snd_soc_dai_set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
143                 S3C24XX_PRESCALE(4, 4));
144         if (ret < 0)
145                 return ret;
146
147         /* codec PLL input is PCLK/4 */
148         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL1,
149                 iis_clkrate / 4, pll_out);
150         if (ret < 0)
151                 return ret;
152
153         return 0;
154 }
155
156 static int neo1973_hifi_hw_free(struct snd_pcm_substream *substream)
157 {
158         struct snd_soc_pcm_runtime *rtd = substream->private_data;
159         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
160
161         DBG("Entered %s\n", __func__);
162
163         /* disable the PLL */
164         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL1, 0, 0);
165 }
166
167 /*
168  * Neo1973 WM8753 HiFi DAI opserations.
169  */
170 static struct snd_soc_ops neo1973_hifi_ops = {
171         .hw_params = neo1973_hifi_hw_params,
172         .hw_free = neo1973_hifi_hw_free,
173 };
174
175 static int neo1973_voice_hw_params(struct snd_pcm_substream *substream,
176         struct snd_pcm_hw_params *params)
177 {
178         struct snd_soc_pcm_runtime *rtd = substream->private_data;
179         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
180         unsigned int pcmdiv = 0;
181         int ret = 0;
182         unsigned long iis_clkrate;
183
184         DBG("Entered %s\n", __func__);
185
186         iis_clkrate = s3c24xx_i2s_get_clockrate();
187
188         if (params_rate(params) != 8000)
189                 return -EINVAL;
190         if (params_channels(params) != 1)
191                 return -EINVAL;
192
193         pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
194
195         /* todo: gg check mode (DSP_B) against CSR datasheet */
196         /* set codec DAI configuration */
197         ret = snd_soc_dai_set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
198                 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
199         if (ret < 0)
200                 return ret;
201
202         /* set the codec system clock for DAC and ADC */
203         ret = snd_soc_dai_set_sysclk(codec_dai, WM8753_PCMCLK, 12288000,
204                 SND_SOC_CLOCK_IN);
205         if (ret < 0)
206                 return ret;
207
208         /* set codec PCM division for sample rate */
209         ret = snd_soc_dai_set_clkdiv(codec_dai, WM8753_PCMDIV, pcmdiv);
210         if (ret < 0)
211                 return ret;
212
213         /* configue and enable PLL for 12.288MHz output */
214         ret = snd_soc_dai_set_pll(codec_dai, WM8753_PLL2,
215                 iis_clkrate / 4, 12288000);
216         if (ret < 0)
217                 return ret;
218
219         return 0;
220 }
221
222 static int neo1973_voice_hw_free(struct snd_pcm_substream *substream)
223 {
224         struct snd_soc_pcm_runtime *rtd = substream->private_data;
225         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
226
227         DBG("Entered %s\n", __func__);
228
229         /* disable the PLL */
230         return snd_soc_dai_set_pll(codec_dai, WM8753_PLL2, 0, 0);
231 }
232
233 static struct snd_soc_ops neo1973_voice_ops = {
234         .hw_params = neo1973_voice_hw_params,
235         .hw_free = neo1973_voice_hw_free,
236 };
237
238 static int neo1973_scenario;
239
240 static int neo1973_get_scenario(struct snd_kcontrol *kcontrol,
241         struct snd_ctl_elem_value *ucontrol)
242 {
243         ucontrol->value.integer.value[0] = neo1973_scenario;
244         return 0;
245 }
246
247 static int set_scenario_endpoints(struct snd_soc_codec *codec, int scenario)
248 {
249         DBG("Entered %s\n", __func__);
250
251         switch (neo1973_scenario) {
252         case NEO_AUDIO_OFF:
253                 snd_soc_dapm_disable_pin(codec, "Audio Out");
254                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
255                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
256                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
257                 snd_soc_dapm_disable_pin(codec, "Call Mic");
258                 break;
259         case NEO_GSM_CALL_AUDIO_HANDSET:
260                 snd_soc_dapm_enable_pin(codec, "Audio Out");
261                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
262                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
263                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
264                 snd_soc_dapm_enable_pin(codec, "Call Mic");
265                 break;
266         case NEO_GSM_CALL_AUDIO_HEADSET:
267                 snd_soc_dapm_enable_pin(codec, "Audio Out");
268                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
269                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
270                 snd_soc_dapm_enable_pin(codec, "Headset Mic");
271                 snd_soc_dapm_disable_pin(codec, "Call Mic");
272                 break;
273         case NEO_GSM_CALL_AUDIO_BLUETOOTH:
274                 snd_soc_dapm_disable_pin(codec, "Audio Out");
275                 snd_soc_dapm_enable_pin(codec, "GSM Line Out");
276                 snd_soc_dapm_enable_pin(codec, "GSM Line In");
277                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
278                 snd_soc_dapm_disable_pin(codec, "Call Mic");
279                 break;
280         case NEO_STEREO_TO_SPEAKERS:
281                 snd_soc_dapm_enable_pin(codec, "Audio Out");
282                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
283                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
284                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
285                 snd_soc_dapm_disable_pin(codec, "Call Mic");
286                 break;
287         case NEO_STEREO_TO_HEADPHONES:
288                 snd_soc_dapm_enable_pin(codec, "Audio Out");
289                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
290                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
291                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
292                 snd_soc_dapm_disable_pin(codec, "Call Mic");
293                 break;
294         case NEO_CAPTURE_HANDSET:
295                 snd_soc_dapm_disable_pin(codec, "Audio Out");
296                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
297                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
298                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
299                 snd_soc_dapm_enable_pin(codec, "Call Mic");
300                 break;
301         case NEO_CAPTURE_HEADSET:
302                 snd_soc_dapm_disable_pin(codec, "Audio Out");
303                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
304                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
305                 snd_soc_dapm_enable_pin(codec, "Headset Mic");
306                 snd_soc_dapm_disable_pin(codec, "Call Mic");
307                 break;
308         case NEO_CAPTURE_BLUETOOTH:
309                 snd_soc_dapm_disable_pin(codec, "Audio Out");
310                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
311                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
312                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
313                 snd_soc_dapm_disable_pin(codec, "Call Mic");
314                 break;
315         default:
316                 snd_soc_dapm_disable_pin(codec, "Audio Out");
317                 snd_soc_dapm_disable_pin(codec, "GSM Line Out");
318                 snd_soc_dapm_disable_pin(codec, "GSM Line In");
319                 snd_soc_dapm_disable_pin(codec, "Headset Mic");
320                 snd_soc_dapm_disable_pin(codec, "Call Mic");
321         }
322
323         snd_soc_dapm_sync(codec);
324
325         return 0;
326 }
327
328 static int neo1973_set_scenario(struct snd_kcontrol *kcontrol,
329         struct snd_ctl_elem_value *ucontrol)
330 {
331         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
332
333         DBG("Entered %s\n", __func__);
334
335         if (neo1973_scenario == ucontrol->value.integer.value[0])
336                 return 0;
337
338         neo1973_scenario = ucontrol->value.integer.value[0];
339         set_scenario_endpoints(codec, neo1973_scenario);
340         return 1;
341 }
342
343 static u8 lm4857_regs[4] = {0x00, 0x40, 0x80, 0xC0};
344
345 static void lm4857_write_regs(void)
346 {
347         DBG("Entered %s\n", __func__);
348
349         if (i2c_master_send(i2c, lm4857_regs, 4) != 4)
350                 printk(KERN_ERR "lm4857: i2c write failed\n");
351 }
352
353 static int lm4857_get_reg(struct snd_kcontrol *kcontrol,
354         struct snd_ctl_elem_value *ucontrol)
355 {
356         struct soc_mixer_control *mc =
357                 (struct soc_mixer_control *)kcontrol->private_value;
358         int reg = mc->reg;
359         int shift = mc->shift;
360         int mask = mc->max;
361
362         DBG("Entered %s\n", __func__);
363
364         ucontrol->value.integer.value[0] = (lm4857_regs[reg] >> shift) & mask;
365         return 0;
366 }
367
368 static int lm4857_set_reg(struct snd_kcontrol *kcontrol,
369         struct snd_ctl_elem_value *ucontrol)
370 {
371         struct soc_mixer_control *mc =
372                 (struct soc_mixer_control *)kcontrol->private_value;
373         int reg = mc->reg;
374         int shift = mc->shift;
375         int mask = mc->max;
376
377         if (((lm4857_regs[reg] >> shift) & mask) ==
378                 ucontrol->value.integer.value[0])
379                 return 0;
380
381         lm4857_regs[reg] &= ~(mask << shift);
382         lm4857_regs[reg] |= ucontrol->value.integer.value[0] << shift;
383         lm4857_write_regs();
384         return 1;
385 }
386
387 static int lm4857_get_mode(struct snd_kcontrol *kcontrol,
388         struct snd_ctl_elem_value *ucontrol)
389 {
390         u8 value = lm4857_regs[LM4857_CTRL] & 0x0F;
391
392         DBG("Entered %s\n", __func__);
393
394         if (value)
395                 value -= 5;
396
397         ucontrol->value.integer.value[0] = value;
398         return 0;
399 }
400
401 static int lm4857_set_mode(struct snd_kcontrol *kcontrol,
402         struct snd_ctl_elem_value *ucontrol)
403 {
404         u8 value = ucontrol->value.integer.value[0];
405
406         DBG("Entered %s\n", __func__);
407
408         if (value)
409                 value += 5;
410
411         if ((lm4857_regs[LM4857_CTRL] & 0x0F) == value)
412                 return 0;
413
414         lm4857_regs[LM4857_CTRL] &= 0xF0;
415         lm4857_regs[LM4857_CTRL] |= value;
416         lm4857_write_regs();
417         return 1;
418 }
419
420 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
421         SND_SOC_DAPM_LINE("Audio Out", NULL),
422         SND_SOC_DAPM_LINE("GSM Line Out", NULL),
423         SND_SOC_DAPM_LINE("GSM Line In", NULL),
424         SND_SOC_DAPM_MIC("Headset Mic", NULL),
425         SND_SOC_DAPM_MIC("Call Mic", NULL),
426 };
427
428
429 static const struct snd_soc_dapm_route dapm_routes[] = {
430
431         /* Connections to the lm4857 amp */
432         {"Audio Out", NULL, "LOUT1"},
433         {"Audio Out", NULL, "ROUT1"},
434
435         /* Connections to the GSM Module */
436         {"GSM Line Out", NULL, "MONO1"},
437         {"GSM Line Out", NULL, "MONO2"},
438         {"RXP", NULL, "GSM Line In"},
439         {"RXN", NULL, "GSM Line In"},
440
441         /* Connections to Headset */
442         {"MIC1", NULL, "Mic Bias"},
443         {"Mic Bias", NULL, "Headset Mic"},
444
445         /* Call Mic */
446         {"MIC2", NULL, "Mic Bias"},
447         {"MIC2N", NULL, "Mic Bias"},
448         {"Mic Bias", NULL, "Call Mic"},
449
450         /* Connect the ALC pins */
451         {"ACIN", NULL, "ACOP"},
452 };
453
454 static const char *lm4857_mode[] = {
455         "Off",
456         "Call Speaker",
457         "Stereo Speakers",
458         "Stereo Speakers + Headphones",
459         "Headphones"
460 };
461
462 static const struct soc_enum lm4857_mode_enum[] = {
463         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(lm4857_mode), lm4857_mode),
464 };
465
466 static const char *neo_scenarios[] = {
467         "Off",
468         "GSM Handset",
469         "GSM Headset",
470         "GSM Bluetooth",
471         "Speakers",
472         "Headphones",
473         "Capture Handset",
474         "Capture Headset",
475         "Capture Bluetooth"
476 };
477
478 static const struct soc_enum neo_scenario_enum[] = {
479         SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(neo_scenarios), neo_scenarios),
480 };
481
482 static const DECLARE_TLV_DB_SCALE(stereo_tlv, -4050, 150, 0);
483 static const DECLARE_TLV_DB_SCALE(mono_tlv, -3450, 150, 0);
484
485 static const struct snd_kcontrol_new wm8753_neo1973_controls[] = {
486         SOC_SINGLE_EXT_TLV("Amp Left Playback Volume", LM4857_LVOL, 0, 31, 0,
487                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
488         SOC_SINGLE_EXT_TLV("Amp Right Playback Volume", LM4857_RVOL, 0, 31, 0,
489                 lm4857_get_reg, lm4857_set_reg, stereo_tlv),
490         SOC_SINGLE_EXT_TLV("Amp Mono Playback Volume", LM4857_MVOL, 0, 31, 0,
491                 lm4857_get_reg, lm4857_set_reg, mono_tlv),
492         SOC_ENUM_EXT("Amp Mode", lm4857_mode_enum[0],
493                 lm4857_get_mode, lm4857_set_mode),
494         SOC_ENUM_EXT("Neo Mode", neo_scenario_enum[0],
495                 neo1973_get_scenario, neo1973_set_scenario),
496         SOC_SINGLE_EXT("Amp Spk 3D Playback Switch", LM4857_LVOL, 5, 1, 0,
497                 lm4857_get_reg, lm4857_set_reg),
498         SOC_SINGLE_EXT("Amp HP 3d Playback Switch", LM4857_RVOL, 5, 1, 0,
499                 lm4857_get_reg, lm4857_set_reg),
500         SOC_SINGLE_EXT("Amp Fast Wakeup Playback Switch", LM4857_CTRL, 5, 1, 0,
501                 lm4857_get_reg, lm4857_set_reg),
502         SOC_SINGLE_EXT("Amp Earpiece 6dB Playback Switch", LM4857_CTRL, 4, 1, 0,
503                 lm4857_get_reg, lm4857_set_reg),
504 };
505
506 /*
507  * This is an example machine initialisation for a wm8753 connected to a
508  * neo1973 II. It is missing logic to detect hp/mic insertions and logic
509  * to re-route the audio in such an event.
510  */
511 static int neo1973_wm8753_init(struct snd_soc_codec *codec)
512 {
513         int i, err;
514
515         DBG("Entered %s\n", __func__);
516
517         /* set up NC codec pins */
518         snd_soc_dapm_nc_pin(codec, "LOUT2");
519         snd_soc_dapm_nc_pin(codec, "ROUT2");
520         snd_soc_dapm_nc_pin(codec, "OUT3");
521         snd_soc_dapm_nc_pin(codec, "OUT4");
522         snd_soc_dapm_nc_pin(codec, "LINE1");
523         snd_soc_dapm_nc_pin(codec, "LINE2");
524
525         /* Add neo1973 specific widgets */
526         snd_soc_dapm_new_controls(codec, wm8753_dapm_widgets,
527                                   ARRAY_SIZE(wm8753_dapm_widgets));
528
529         /* set endpoints to default mode */
530         set_scenario_endpoints(codec, NEO_AUDIO_OFF);
531
532         /* add neo1973 specific controls */
533         for (i = 0; i < ARRAY_SIZE(wm8753_neo1973_controls); i++) {
534                 err = snd_ctl_add(codec->card,
535                                 snd_soc_cnew(&wm8753_neo1973_controls[i],
536                                 codec, NULL));
537                 if (err < 0)
538                         return err;
539         }
540
541         /* set up neo1973 specific audio routes */
542         err = snd_soc_dapm_add_routes(codec, dapm_routes,
543                                       ARRAY_SIZE(dapm_routes));
544
545         snd_soc_dapm_sync(codec);
546         return 0;
547 }
548
549 /*
550  * BT Codec DAI
551  */
552 static struct snd_soc_dai bt_dai = {
553         .name = "Bluetooth",
554         .id = 0,
555         .playback = {
556                 .channels_min = 1,
557                 .channels_max = 1,
558                 .rates = SNDRV_PCM_RATE_8000,
559                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
560         .capture = {
561                 .channels_min = 1,
562                 .channels_max = 1,
563                 .rates = SNDRV_PCM_RATE_8000,
564                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
565 };
566
567 static struct snd_soc_dai_link neo1973_dai[] = {
568 { /* Hifi Playback - for similatious use with voice below */
569         .name = "WM8753",
570         .stream_name = "WM8753 HiFi",
571         .cpu_dai = &s3c24xx_i2s_dai,
572         .codec_dai = &wm8753_dai[WM8753_DAI_HIFI],
573         .init = neo1973_wm8753_init,
574         .ops = &neo1973_hifi_ops,
575 },
576 { /* Voice via BT */
577         .name = "Bluetooth",
578         .stream_name = "Voice",
579         .cpu_dai = &bt_dai,
580         .codec_dai = &wm8753_dai[WM8753_DAI_VOICE],
581         .ops = &neo1973_voice_ops,
582 },
583 };
584
585 static struct snd_soc_card neo1973 = {
586         .name = "neo1973",
587         .platform = &s3c24xx_soc_platform,
588         .dai_link = neo1973_dai,
589         .num_links = ARRAY_SIZE(neo1973_dai),
590 };
591
592 static struct snd_soc_device neo1973_snd_devdata = {
593         .card = &neo1973,
594         .codec_dev = &soc_codec_dev_wm8753,
595 };
596
597 static int lm4857_i2c_probe(struct i2c_client *client,
598                             const struct i2c_device_id *id)
599 {
600         DBG("Entered %s\n", __func__);
601
602         i2c = client;
603
604         lm4857_write_regs();
605         return 0;
606 }
607
608 static int lm4857_i2c_remove(struct i2c_client *client)
609 {
610         DBG("Entered %s\n", __func__);
611
612         i2c = NULL;
613
614         return 0;
615 }
616
617 static u8 lm4857_state;
618
619 static int lm4857_suspend(struct i2c_client *dev, pm_message_t state)
620 {
621         DBG("Entered %s\n", __func__);
622
623         dev_dbg(&dev->dev, "lm4857_suspend\n");
624         lm4857_state = lm4857_regs[LM4857_CTRL] & 0xf;
625         if (lm4857_state) {
626                 lm4857_regs[LM4857_CTRL] &= 0xf0;
627                 lm4857_write_regs();
628         }
629         return 0;
630 }
631
632 static int lm4857_resume(struct i2c_client *dev)
633 {
634         DBG("Entered %s\n", __func__);
635
636         if (lm4857_state) {
637                 lm4857_regs[LM4857_CTRL] |= (lm4857_state & 0x0f);
638                 lm4857_write_regs();
639         }
640         return 0;
641 }
642
643 static void lm4857_shutdown(struct i2c_client *dev)
644 {
645         DBG("Entered %s\n", __func__);
646
647         dev_dbg(&dev->dev, "lm4857_shutdown\n");
648         lm4857_regs[LM4857_CTRL] &= 0xf0;
649         lm4857_write_regs();
650 }
651
652 static const struct i2c_device_id lm4857_i2c_id[] = {
653         { "lm4857", 0 },
654         { }
655 };
656
657 static struct i2c_driver lm4857_i2c_driver = {
658         .driver = {
659                 .name = "lm4857",
660                 .owner = THIS_MODULE,
661         },
662         .suspend =        lm4857_suspend,
663         .resume =         lm4857_resume,
664         .shutdown =       lm4857_shutdown,
665         .probe =          lm4857_i2c_probe,
666         .remove =         lm4857_i2c_remove,
667         .id_table =       lm4857_i2c_id,
668 };
669
670 static struct platform_device *neo1973_snd_device;
671
672 static int __init neo1973_init(void)
673 {
674         int ret;
675
676         printk(KERN_DEBUG "Entered %s\n", __func__);
677
678         if (!machine_is_neo1973_gta01()) {
679                 printk(KERN_INFO
680                         "Only GTA01 hardware supported by ASoC driver\n");
681                 return -ENODEV;
682         }
683
684         /* register bluetooth DAI here */
685         ret = snd_soc_register_dai(&bt_dai);
686         if (ret)
687                 return ret;
688
689         neo1973_snd_device = platform_device_alloc("soc-audio", -1);
690         if (!neo1973_snd_device)
691                 return -ENOMEM;
692
693         platform_set_drvdata(neo1973_snd_device, &neo1973_snd_devdata);
694         neo1973_snd_devdata.dev = &neo1973_snd_device->dev;
695         ret = platform_device_add(neo1973_snd_device);
696
697         if (ret) {
698                 platform_device_put(neo1973_snd_device);
699                 return ret;
700         }
701
702         ret = i2c_add_driver(&lm4857_i2c_driver);
703
704         if (ret != 0)
705                 platform_device_unregister(neo1973_snd_device);
706
707         return ret;
708 }
709
710 static void __exit neo1973_exit(void)
711 {
712         DBG("Entered %s\n", __func__);
713
714         snd_soc_unregister_dai(&bt_dai);
715         i2c_del_driver(&lm4857_i2c_driver);
716         platform_device_unregister(neo1973_snd_device);
717 }
718
719 module_init(neo1973_init);
720 module_exit(neo1973_exit);
721
722 /* Module information */
723 MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org, www.openmoko.org");
724 MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973");
725 MODULE_LICENSE("GPL");