tracking-2.6.28-add-codec_dev-to-gta02-soc-mach-stuff.patch
[kernel.git] / sound / soc / s3c24xx / neo1973_gta02_wm8753.c
1 /*
2  * neo1973_gta02_wm8753.c  --  SoC audio for Neo1973
3  *
4  * Copyright 2007 Openmoko Inc
5  * Author: Graeme Gregory <graeme@openmoko.org>
6  * Copyright 2007 Wolfson Microelectronics PLC.
7  * Author: Graeme Gregory <linux@wolfsonmicro.com>
8  *
9  *  This program is free software; you can redistribute  it and/or modify it
10  *  under  the terms of  the GNU General  Public License as published by the
11  *  Free Software Foundation;  either version 2 of the  License, or (at your
12  *  option) any later version.
13  *
14  *  Revision history
15  *    06th Nov 2007   Changed from GTA01 to GTA02
16  *    20th Jan 2007   Initial version.
17  *    05th Feb 2007   Rename all to Neo1973
18  *
19  */
20
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/timer.h>
24 #include <linux/interrupt.h>
25 #include <linux/platform_device.h>
26 #include <linux/i2c.h>
27 #include <sound/core.h>
28 #include <sound/pcm.h>
29 #include <sound/soc.h>
30 #include <sound/soc-dapm.h>
31
32 #include <asm/mach-types.h>
33 #include <asm/hardware/scoop.h>
34 #include <asm/plat-s3c24xx/regs-iis.h>
35 #include <mach/regs-clock.h>
36 #include <mach/regs-gpio.h>
37 #include <mach/hardware.h>
38 #include <mach/audio.h>
39 #include <asm/io.h>
40 #include <mach/spi-gpio.h>
41 #include <mach/regs-gpioj.h>
42 #include <mach/gta02.h>
43 #include "../codecs/wm8753.h"
44 #include "s3c24xx-pcm.h"
45 #include "s3c24xx-i2s.h"
46
47 /* define the scenarios */
48 #define NEO_AUDIO_OFF                   0
49 #define NEO_GSM_CALL_AUDIO_HANDSET      1
50 #define NEO_GSM_CALL_AUDIO_HEADSET      2
51 #define NEO_GSM_CALL_AUDIO_BLUETOOTH    3
52 #define NEO_STEREO_TO_SPEAKERS          4
53 #define NEO_STEREO_TO_HEADPHONES        5
54 #define NEO_CAPTURE_HANDSET             6
55 #define NEO_CAPTURE_HEADSET             7
56 #define NEO_CAPTURE_BLUETOOTH           8
57 #define NEO_STEREO_TO_HANDSET_SPK       9
58
59 static struct snd_soc_machine neo1973_gta02;
60
61 static int neo1973_gta02_hifi_hw_params(struct snd_pcm_substream *substream,
62         struct snd_pcm_hw_params *params)
63 {
64         struct snd_soc_pcm_runtime *rtd = substream->private_data;
65         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
66         struct snd_soc_dai *cpu_dai = rtd->dai->cpu_dai;
67         unsigned int pll_out = 0, bclk = 0;
68         int ret = 0;
69         unsigned long iis_clkrate;
70
71         iis_clkrate = s3c24xx_i2s_get_clockrate();
72
73         switch (params_rate(params)) {
74         case 8000:
75         case 16000:
76                 pll_out = 12288000;
77                 break;
78         case 48000:
79                 bclk = WM8753_BCLK_DIV_4;
80                 pll_out = 12288000;
81                 break;
82         case 96000:
83                 bclk = WM8753_BCLK_DIV_2;
84                 pll_out = 12288000;
85                 break;
86         case 11025:
87                 bclk = WM8753_BCLK_DIV_16;
88                 pll_out = 11289600;
89                 break;
90         case 22050:
91                 bclk = WM8753_BCLK_DIV_8;
92                 pll_out = 11289600;
93                 break;
94         case 44100:
95                 bclk = WM8753_BCLK_DIV_4;
96                 pll_out = 11289600;
97                 break;
98         case 88200:
99                 bclk = WM8753_BCLK_DIV_2;
100                 pll_out = 11289600;
101                 break;
102         }
103
104         /* set codec DAI configuration */
105         ret = codec_dai->dai_ops.set_fmt(codec_dai,
106                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
107                 SND_SOC_DAIFMT_CBM_CFM);
108         if (ret < 0)
109                 return ret;
110
111         /* set cpu DAI configuration */
112         ret = cpu_dai->dai_ops.set_fmt(cpu_dai,
113                 SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF |
114                 SND_SOC_DAIFMT_CBM_CFM);
115         if (ret < 0)
116                 return ret;
117
118         /* set the codec system clock for DAC and ADC */
119         ret = codec_dai->dai_ops.set_sysclk(codec_dai, WM8753_MCLK, pll_out,
120                 SND_SOC_CLOCK_IN);
121         if (ret < 0)
122                 return ret;
123
124         /* set MCLK division for sample rate */
125         ret = cpu_dai->dai_ops.set_clkdiv(cpu_dai, S3C24XX_DIV_MCLK,
126                 S3C2410_IISMOD_32FS );
127         if (ret < 0)
128                 return ret;
129
130         /* set codec BCLK division for sample rate */
131         ret = codec_dai->dai_ops.set_clkdiv(codec_dai,
132                                         WM8753_BCLKDIV, bclk);
133         if (ret < 0)
134                 return ret;
135
136         /* set prescaler division for sample rate */
137         ret = cpu_dai->dai_ops.set_clkdiv(cpu_dai, S3C24XX_DIV_PRESCALER,
138                 S3C24XX_PRESCALE(4,4));
139         if (ret < 0)
140                 return ret;
141
142         /* codec PLL input is PCLK/4 */
143         ret = codec_dai->dai_ops.set_pll(codec_dai, WM8753_PLL1,
144                 iis_clkrate / 4, pll_out);
145         if (ret < 0)
146                 return ret;
147
148         return 0;
149 }
150
151 static int neo1973_gta02_hifi_hw_free(struct snd_pcm_substream *substream)
152 {
153         struct snd_soc_pcm_runtime *rtd = substream->private_data;
154         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
155
156         /* disable the PLL */
157         return codec_dai->dai_ops.set_pll(codec_dai, WM8753_PLL1, 0, 0);
158 }
159
160 /*
161  * Neo1973 WM8753 HiFi DAI opserations.
162  */
163 static struct snd_soc_ops neo1973_gta02_hifi_ops = {
164         .hw_params = neo1973_gta02_hifi_hw_params,
165         .hw_free = neo1973_gta02_hifi_hw_free,
166 };
167
168 static int neo1973_gta02_voice_hw_params(
169         struct snd_pcm_substream *substream,
170         struct snd_pcm_hw_params *params)
171 {
172         struct snd_soc_pcm_runtime *rtd = substream->private_data;
173         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
174         unsigned int pcmdiv = 0;
175         int ret = 0;
176         unsigned long iis_clkrate;
177
178         iis_clkrate = s3c24xx_i2s_get_clockrate();
179
180         if (params_rate(params) != 8000)
181                 return -EINVAL;
182         if (params_channels(params) != 1)
183                 return -EINVAL;
184
185         pcmdiv = WM8753_PCM_DIV_6; /* 2.048 MHz */
186
187         /* todo: gg check mode (DSP_B) against CSR datasheet */
188         /* set codec DAI configuration */
189         ret = codec_dai->dai_ops.set_fmt(codec_dai, SND_SOC_DAIFMT_DSP_B |
190                 SND_SOC_DAIFMT_NB_NF | SND_SOC_DAIFMT_CBS_CFS);
191         if (ret < 0)
192                 return ret;
193
194         /* set the codec system clock for DAC and ADC */
195         ret = codec_dai->dai_ops.set_sysclk(codec_dai, WM8753_PCMCLK,
196                 12288000, SND_SOC_CLOCK_IN);
197         if (ret < 0)
198                 return ret;
199
200         /* set codec PCM division for sample rate */
201         ret = codec_dai->dai_ops.set_clkdiv(codec_dai, WM8753_PCMDIV,
202                                         pcmdiv);
203         if (ret < 0)
204                 return ret;
205
206         /* configue and enable PLL for 12.288MHz output */
207         ret = codec_dai->dai_ops.set_pll(codec_dai, WM8753_PLL2,
208                 iis_clkrate / 4, 12288000);
209         if (ret < 0)
210                 return ret;
211
212         return 0;
213 }
214
215 static int neo1973_gta02_voice_hw_free(struct snd_pcm_substream *substream)
216 {
217         struct snd_soc_pcm_runtime *rtd = substream->private_data;
218         struct snd_soc_dai *codec_dai = rtd->dai->codec_dai;
219
220         /* disable the PLL */
221         return codec_dai->dai_ops.set_pll(codec_dai, WM8753_PLL2, 0, 0);
222 }
223
224 static struct snd_soc_ops neo1973_gta02_voice_ops = {
225         .hw_params = neo1973_gta02_voice_hw_params,
226         .hw_free = neo1973_gta02_voice_hw_free,
227 };
228
229 #define LM4853_AMP 1
230 #define LM4853_SPK 2
231
232 static u8 lm4853_state=0;
233
234 static int lm4853_set_state(struct snd_kcontrol *kcontrol,
235         struct snd_ctl_elem_value *ucontrol)
236 {
237         int val = ucontrol->value.integer.value[0];
238
239         if(val) {
240                 lm4853_state |= LM4853_AMP;
241                 s3c2410_gpio_setpin(GTA02_GPIO_AMP_SHUT,0);
242         } else {
243                 lm4853_state &= ~LM4853_AMP;
244                 s3c2410_gpio_setpin(GTA02_GPIO_AMP_SHUT,1);
245         }
246
247         return 0;
248 }
249
250 static int lm4853_get_state(struct snd_kcontrol *kcontrol,
251         struct snd_ctl_elem_value *ucontrol)
252 {
253         ucontrol->value.integer.value[0] = lm4853_state & LM4853_AMP;
254
255         return 0;
256 }
257
258 static int lm4853_set_spk(struct snd_kcontrol *kcontrol,
259         struct snd_ctl_elem_value *ucontrol)
260 {
261         int val = ucontrol->value.integer.value[0];
262
263         if(val) {
264                 lm4853_state |= LM4853_SPK;
265                 s3c2410_gpio_setpin(GTA02_GPIO_HP_IN,0);
266         } else {
267                 lm4853_state &= ~LM4853_SPK;
268                 s3c2410_gpio_setpin(GTA02_GPIO_HP_IN,1);
269         }
270
271         return 0;
272 }
273
274 static int lm4853_get_spk(struct snd_kcontrol *kcontrol,
275         struct snd_ctl_elem_value *ucontrol)
276 {
277         ucontrol->value.integer.value[0] = (lm4853_state & LM4853_SPK) >> 1;
278
279         return 0;
280 }
281
282 static int neo1973_gta02_set_stereo_out(struct snd_kcontrol *kcontrol,
283         struct snd_ctl_elem_value *ucontrol)
284 {
285         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
286         int val = ucontrol->value.integer.value[0];
287
288         snd_soc_dapm_set_endpoint(codec, "Stereo Out", val);
289
290         snd_soc_dapm_sync(codec);
291
292         return 0;
293 }
294
295 static int neo1973_gta02_get_stereo_out(struct snd_kcontrol *kcontrol,
296         struct snd_ctl_elem_value *ucontrol)
297 {
298         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
299
300         ucontrol->value.integer.value[0] =
301                 snd_soc_dapm_get_endpoint(codec, "Stereo Out");
302
303         return 0;
304 }
305
306
307 static int neo1973_gta02_set_gsm_out(struct snd_kcontrol *kcontrol,
308         struct snd_ctl_elem_value *ucontrol)
309 {
310         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
311         int val = ucontrol->value.integer.value[0];
312
313         snd_soc_dapm_set_endpoint(codec, "GSM Line Out", val);
314
315         snd_soc_dapm_sync(codec);
316
317         return 0;
318 }
319
320 static int neo1973_gta02_get_gsm_out(struct snd_kcontrol *kcontrol,
321         struct snd_ctl_elem_value *ucontrol)
322 {
323         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
324
325         ucontrol->value.integer.value[0] =
326                 snd_soc_dapm_get_endpoint(codec, "GSM Line Out");
327
328         return 0;
329 }
330
331 static int neo1973_gta02_set_gsm_in(struct snd_kcontrol *kcontrol,
332         struct snd_ctl_elem_value *ucontrol)
333 {
334         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
335         int val = ucontrol->value.integer.value[0];
336
337         snd_soc_dapm_set_endpoint(codec, "GSM Line In", val);
338
339         snd_soc_dapm_sync(codec);
340
341         return 0;
342 }
343
344 static int neo1973_gta02_get_gsm_in(struct snd_kcontrol *kcontrol,
345         struct snd_ctl_elem_value *ucontrol)
346 {
347         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
348
349         ucontrol->value.integer.value[0] =
350                 snd_soc_dapm_get_endpoint(codec, "GSM Line In");
351
352         return 0;
353 }
354
355 static int neo1973_gta02_set_headset_mic(struct snd_kcontrol *kcontrol,
356         struct snd_ctl_elem_value *ucontrol)
357 {
358         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
359         int val = ucontrol->value.integer.value[0];
360
361         snd_soc_dapm_set_endpoint(codec, "Headset Mic", val);
362
363         snd_soc_dapm_sync(codec);
364
365         return 0;
366 }
367
368 static int neo1973_gta02_get_headset_mic(struct snd_kcontrol *kcontrol,
369         struct snd_ctl_elem_value *ucontrol)
370 {
371         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
372
373         ucontrol->value.integer.value[0] =
374                 snd_soc_dapm_get_endpoint(codec, "Headset Mic");
375
376         return 0;
377 }
378
379 static int neo1973_gta02_set_handset_mic(struct snd_kcontrol *kcontrol,
380         struct snd_ctl_elem_value *ucontrol)
381 {
382         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
383         int val = ucontrol->value.integer.value[0];
384
385         snd_soc_dapm_set_endpoint(codec, "Handset Mic", val);
386
387         snd_soc_dapm_sync(codec);
388
389         return 0;
390 }
391
392 static int neo1973_gta02_get_handset_mic(struct snd_kcontrol *kcontrol,
393         struct snd_ctl_elem_value *ucontrol)
394 {
395         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
396
397         ucontrol->value.integer.value[0] =
398                 snd_soc_dapm_get_endpoint(codec, "Handset Mic");
399
400         return 0;
401 }
402
403 static int neo1973_gta02_set_handset_spk(struct snd_kcontrol *kcontrol,
404         struct snd_ctl_elem_value *ucontrol)
405 {
406         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
407         int val = ucontrol->value.integer.value[0];
408
409         snd_soc_dapm_set_endpoint(codec, "Handset Spk", val);
410
411         snd_soc_dapm_sync(codec);
412
413         return 0;
414 }
415
416 static int neo1973_gta02_get_handset_spk(struct snd_kcontrol *kcontrol,
417         struct snd_ctl_elem_value *ucontrol)
418 {
419         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
420
421         ucontrol->value.integer.value[0] =
422                 snd_soc_dapm_get_endpoint(codec, "Handset Spk");
423
424         return 0;
425 }
426
427 static const struct snd_soc_dapm_widget wm8753_dapm_widgets[] = {
428         SND_SOC_DAPM_LINE("Stereo Out", NULL),
429         SND_SOC_DAPM_LINE("GSM Line Out", NULL),
430         SND_SOC_DAPM_LINE("GSM Line In", NULL),
431         SND_SOC_DAPM_MIC("Headset Mic", NULL),
432         SND_SOC_DAPM_MIC("Handset Mic", NULL),
433         SND_SOC_DAPM_SPK("Handset Spk", NULL),
434 };
435
436
437 /* example machine audio_mapnections */
438 static const char* audio_map[][3] = {
439
440         /* Connections to the lm4853 amp */
441         {"Stereo Out", NULL, "LOUT1"},
442         {"Stereo Out", NULL, "ROUT1"},
443
444         /* Connections to the GSM Module */
445         {"GSM Line Out", NULL, "MONO1"},
446         {"GSM Line Out", NULL, "MONO2"},
447         {"RXP", NULL, "GSM Line In"},
448         {"RXN", NULL, "GSM Line In"},
449
450         /* Connections to Headset */
451         {"MIC1", NULL, "Mic Bias"},
452         {"Mic Bias", NULL, "Headset Mic"},
453
454         /* Call Mic */
455         {"MIC2", NULL, "Mic Bias"},
456         {"MIC2N", NULL, "Mic Bias"},
457         {"Mic Bias", NULL, "Handset Mic"},
458
459         /* Call Speaker */
460         {"Handset Spk", NULL, "LOUT2"},
461         {"Handset Spk", NULL, "ROUT2"},
462
463         /* Connect the ALC pins */
464         {"ACIN", NULL, "ACOP"},
465
466         {NULL, NULL, NULL},
467 };
468
469 static const struct snd_kcontrol_new wm8753_neo1973_gta02_controls[] = {
470         SOC_SINGLE_EXT("DAPM Stereo Out Switch", 0, 0, 1, 0,
471                 neo1973_gta02_get_stereo_out,
472                 neo1973_gta02_set_stereo_out),
473         SOC_SINGLE_EXT("DAPM GSM Line Out Switch", 1, 0, 1, 0,
474                 neo1973_gta02_get_gsm_out,
475                 neo1973_gta02_set_gsm_out),
476         SOC_SINGLE_EXT("DAPM GSM Line In Switch", 2, 0, 1, 0,
477                 neo1973_gta02_get_gsm_in,
478                 neo1973_gta02_set_gsm_in),
479         SOC_SINGLE_EXT("DAPM Headset Mic Switch", 3, 0, 1, 0,
480                 neo1973_gta02_get_headset_mic,
481                 neo1973_gta02_set_headset_mic),
482         SOC_SINGLE_EXT("DAPM Handset Mic Switch", 4, 0, 1, 0,
483                 neo1973_gta02_get_handset_mic,
484                 neo1973_gta02_set_handset_mic),
485         SOC_SINGLE_EXT("DAPM Handset Spk Switch", 5, 0, 1, 0,
486                 neo1973_gta02_get_handset_spk,
487                 neo1973_gta02_set_handset_spk),
488         SOC_SINGLE_EXT("Amp State Switch", 6, 0, 1, 0,
489                 lm4853_get_state,
490                 lm4853_set_state),
491         SOC_SINGLE_EXT("Amp Spk Switch", 7, 0, 1, 0,
492                 lm4853_get_spk,
493                 lm4853_set_spk),
494 };
495
496 /*
497  * This is an example machine initialisation for a wm8753 connected to a
498  * neo1973 GTA02.
499  */
500 static int neo1973_gta02_wm8753_init(struct snd_soc_codec *codec)
501 {
502         int i, err;
503
504         /* set up NC codec pins */
505         snd_soc_dapm_set_endpoint(codec, "OUT3",  0);
506         snd_soc_dapm_set_endpoint(codec, "OUT4",  0);
507         snd_soc_dapm_set_endpoint(codec, "LINE1", 0);
508         snd_soc_dapm_set_endpoint(codec, "LINE2", 0);
509
510         /* Add neo1973 gta02 specific widgets */
511         for (i = 0; i < ARRAY_SIZE(wm8753_dapm_widgets); i++)
512                 snd_soc_dapm_new_control(codec, &wm8753_dapm_widgets[i]);
513
514         /* add neo1973 gta02 specific controls */
515         for (i = 0; i < ARRAY_SIZE(wm8753_neo1973_gta02_controls); i++) {
516                 err = snd_ctl_add(codec->card,
517                         snd_soc_cnew(&wm8753_neo1973_gta02_controls[i],
518                         codec, NULL));
519                 if (err < 0)
520                         return err;
521         }
522
523         /* set up neo1973 gta02 specific audio path audio_mapnects */
524         for (i = 0; audio_map[i][0] != NULL; i++) {
525                 snd_soc_dapm_connect_input(codec, audio_map[i][0],
526                         audio_map[i][1], audio_map[i][2]);
527         }
528
529         /* set endpoints to default off mode */
530         snd_soc_dapm_set_endpoint(codec, "Stereo Out",  0);
531         snd_soc_dapm_set_endpoint(codec, "GSM Line Out",0);
532         snd_soc_dapm_set_endpoint(codec, "GSM Line In", 0);
533         snd_soc_dapm_set_endpoint(codec, "Headset Mic", 0);
534         snd_soc_dapm_set_endpoint(codec, "Handset Mic", 0);
535         snd_soc_dapm_set_endpoint(codec, "Handset Spk", 0);
536
537         snd_soc_dapm_sync(codec);
538
539         return 0;
540 }
541
542 /*
543  * BT Codec DAI
544  */
545 static struct snd_soc_dai bt_dai =
546 {       .name = "Bluetooth",
547         .id = 0,
548         .type = SND_SOC_DAI_PCM,
549         .playback = {
550                 .channels_min = 1,
551                 .channels_max = 1,
552                 .rates = SNDRV_PCM_RATE_8000,
553                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
554         .capture = {
555                 .channels_min = 1,
556                 .channels_max = 1,
557                 .rates = SNDRV_PCM_RATE_8000,
558                 .formats = SNDRV_PCM_FMTBIT_S16_LE,},
559 };
560
561 static struct snd_soc_dai_link neo1973_gta02_dai[] = {
562 { /* Hifi Playback - for similatious use with voice below */
563         .name = "WM8753",
564         .stream_name = "WM8753 HiFi",
565         .cpu_dai = &s3c24xx_i2s_dai,
566         .codec_dai = &wm8753_dai[WM8753_DAI_HIFI],
567         .init = neo1973_gta02_wm8753_init,
568         .ops = &neo1973_gta02_hifi_ops,
569 },
570 { /* Voice via BT */
571         .name = "Bluetooth",
572         .stream_name = "Voice",
573         .cpu_dai = &bt_dai,
574         .codec_dai = &wm8753_dai[WM8753_DAI_VOICE],
575         .ops = &neo1973_gta02_voice_ops,
576 },
577 };
578
579 #ifdef CONFIG_PM
580 int neo1973_gta02_suspend(struct platform_device *pdev, pm_message_t state)
581 {
582         s3c2410_gpio_setpin(GTA02_GPIO_AMP_SHUT, 1);
583
584         return 0;
585 }
586
587 int neo1973_gta02_resume(struct platform_device *pdev)
588 {
589         if(lm4853_state & LM4853_AMP)
590                 s3c2410_gpio_setpin(GTA02_GPIO_AMP_SHUT, 0);
591
592         return 0;
593 }
594 #else
595 #define neo1973_gta02_suspend NULL
596 #define neo1973_gta02_resume NULL
597 #endif
598
599 static struct snd_soc_machine neo1973_gta02 = {
600         .name = "neo1973-gta02",
601         .suspend_pre = neo1973_gta02_suspend,
602         .resume_post = neo1973_gta02_resume,
603         .dai_link = neo1973_gta02_dai,
604         .num_links = ARRAY_SIZE(neo1973_gta02_dai),
605 };
606
607 /* Audio private data */
608 static struct wm8753_setup_data soc_codec_data_wm8753_gta02 = {
609         .i2c_bus = 0,
610         .i2c_address = 0x1a,
611 //      .gpio_func[0] = AIC3X_GPIO1_FUNC_DISABLED,
612 //      .gpio_func[1] = AIC3X_GPIO2_FUNC_DIGITAL_MIC_INPUT,
613 };
614
615 static struct snd_soc_device neo1973_gta02_snd_devdata = {
616         .machine = &neo1973_gta02,
617         .platform = &s3c24xx_soc_platform,
618         .codec_dev = &soc_codec_dev_wm8753,
619         .codec_data = &soc_codec_data_wm8753_gta02,
620 };
621
622
623
624 static struct platform_device *neo1973_gta02_snd_device;
625
626 static int __init neo1973_gta02_init(void)
627 {
628         int ret;
629
630         if (!machine_is_neo1973_gta02()) {
631                 printk(KERN_INFO
632                        "Only GTA02 hardware supported by ASoc driver\n");
633                 return -ENODEV;
634         }
635
636         neo1973_gta02_snd_device = platform_device_alloc("soc-audio", -1);
637         if (!neo1973_gta02_snd_device)
638                 return -ENOMEM;
639
640         platform_set_drvdata(neo1973_gta02_snd_device,
641                         &neo1973_gta02_snd_devdata);
642         neo1973_gta02_snd_devdata.dev = &neo1973_gta02_snd_device->dev;
643         ret = platform_device_add(neo1973_gta02_snd_device);
644
645         if (ret)
646                 platform_device_put(neo1973_gta02_snd_device);
647
648         /* Initialise GPIOs used by amp */
649         s3c2410_gpio_cfgpin(GTA02_GPIO_HP_IN, S3C2410_GPIO_OUTPUT);
650         s3c2410_gpio_cfgpin(GTA02_GPIO_AMP_SHUT, S3C2410_GPIO_OUTPUT);
651
652         /* Amp off by default */
653         s3c2410_gpio_setpin(GTA02_GPIO_AMP_SHUT, 1);
654
655         /* Speaker off by default */
656         s3c2410_gpio_setpin(GTA02_GPIO_HP_IN, 1);
657
658         return ret;
659 }
660
661 static void __exit neo1973_gta02_exit(void)
662 {
663         platform_device_unregister(neo1973_gta02_snd_device);
664 }
665
666 module_init(neo1973_gta02_init);
667 module_exit(neo1973_gta02_exit);
668
669 /* Module information */
670 MODULE_AUTHOR("Graeme Gregory, graeme@openmoko.org");
671 MODULE_DESCRIPTION("ALSA SoC WM8753 Neo1973 GTA02");
672 MODULE_LICENSE("GPL");
673