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