Merge branch 'topic/fix/misc' into topic/misc
[linux-2.6.git] / sound / soc / codecs / tlv320aic23.c
1 /*
2  * ALSA SoC TLV320AIC23 codec driver
3  *
4  * Author:      Arun KS, <arunks@mistralsolutions.com>
5  * Copyright:   (C) 2008 Mistral Solutions Pvt Ltd.,
6  *
7  * Based on sound/soc/codecs/wm8731.c by Richard Purdie
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  *
13  * Notes:
14  *  The AIC23 is a driver for a low power stereo audio
15  *  codec tlv320aic23
16  *
17  *  The machine layer should disable unsupported inputs/outputs by
18  *  snd_soc_dapm_disable_pin(codec, "LHPOUT"), etc.
19  */
20
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/init.h>
24 #include <linux/delay.h>
25 #include <linux/pm.h>
26 #include <linux/i2c.h>
27 #include <linux/platform_device.h>
28 #include <sound/core.h>
29 #include <sound/pcm.h>
30 #include <sound/pcm_params.h>
31 #include <sound/soc.h>
32 #include <sound/soc-dapm.h>
33 #include <sound/tlv.h>
34 #include <sound/initval.h>
35
36 #include "tlv320aic23.h"
37
38 #define AIC23_VERSION "0.1"
39
40 struct tlv320aic23_srate_reg_info {
41         u32 sample_rate;
42         u8 control;             /* SR3, SR2, SR1, SR0 and BOSR */
43         u8 divider;             /* if 0 CLKIN = MCLK, if 1 CLKIN = MCLK/2 */
44 };
45
46 /*
47  * AIC23 register cache
48  */
49 static const u16 tlv320aic23_reg[] = {
50         0x0097, 0x0097, 0x00F9, 0x00F9, /* 0 */
51         0x001A, 0x0004, 0x0007, 0x0001, /* 4 */
52         0x0020, 0x0000, 0x0000, 0x0000, /* 8 */
53         0x0000, 0x0000, 0x0000, 0x0000, /* 12 */
54 };
55
56 /*
57  * read tlv320aic23 register cache
58  */
59 static inline unsigned int tlv320aic23_read_reg_cache(struct snd_soc_codec
60                                                       *codec, unsigned int reg)
61 {
62         u16 *cache = codec->reg_cache;
63         if (reg >= ARRAY_SIZE(tlv320aic23_reg))
64                 return -1;
65         return cache[reg];
66 }
67
68 /*
69  * write tlv320aic23 register cache
70  */
71 static inline void tlv320aic23_write_reg_cache(struct snd_soc_codec *codec,
72                                                u8 reg, u16 value)
73 {
74         u16 *cache = codec->reg_cache;
75         if (reg >= ARRAY_SIZE(tlv320aic23_reg))
76                 return;
77         cache[reg] = value;
78 }
79
80 /*
81  * write to the tlv320aic23 register space
82  */
83 static int tlv320aic23_write(struct snd_soc_codec *codec, unsigned int reg,
84                              unsigned int value)
85 {
86
87         u8 data[2];
88
89         /* TLV320AIC23 has 7 bit address and 9 bits of data
90          * so we need to switch one data bit into reg and rest
91          * of data into val
92          */
93
94         if ((reg < 0 || reg > 9) && (reg != 15)) {
95                 printk(KERN_WARNING "%s Invalid register R%d\n", __func__, reg);
96                 return -1;
97         }
98
99         data[0] = (reg << 1) | (value >> 8 & 0x01);
100         data[1] = value & 0xff;
101
102         tlv320aic23_write_reg_cache(codec, reg, value);
103
104         if (codec->hw_write(codec->control_data, data, 2) == 2)
105                 return 0;
106
107         printk(KERN_ERR "%s cannot write %03x to register R%d\n", __func__,
108                value, reg);
109
110         return -EIO;
111 }
112
113 static const char *rec_src_text[] = { "Line", "Mic" };
114 static const char *deemph_text[] = {"None", "32Khz", "44.1Khz", "48Khz"};
115
116 static const struct soc_enum rec_src_enum =
117         SOC_ENUM_SINGLE(TLV320AIC23_ANLG, 2, 2, rec_src_text);
118
119 static const struct snd_kcontrol_new tlv320aic23_rec_src_mux_controls =
120 SOC_DAPM_ENUM("Input Select", rec_src_enum);
121
122 static const struct soc_enum tlv320aic23_rec_src =
123         SOC_ENUM_SINGLE(TLV320AIC23_ANLG, 2, 2, rec_src_text);
124 static const struct soc_enum tlv320aic23_deemph =
125         SOC_ENUM_SINGLE(TLV320AIC23_DIGT, 1, 4, deemph_text);
126
127 static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -12100, 100, 0);
128 static const DECLARE_TLV_DB_SCALE(input_gain_tlv, -1725, 75, 0);
129 static const DECLARE_TLV_DB_SCALE(sidetone_vol_tlv, -1800, 300, 0);
130
131 static int snd_soc_tlv320aic23_put_volsw(struct snd_kcontrol *kcontrol,
132         struct snd_ctl_elem_value *ucontrol)
133 {
134         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
135         u16 val, reg;
136
137         val = (ucontrol->value.integer.value[0] & 0x07);
138
139         /* linear conversion to userspace
140         * 000   =       -6db
141         * 001   =       -9db
142         * 010   =       -12db
143         * 011   =       -18db (Min)
144         * 100   =       0db (Max)
145         */
146         val = (val >= 4) ? 4  : (3 - val);
147
148         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG) & (~0x1C0);
149         tlv320aic23_write(codec, TLV320AIC23_ANLG, reg | (val << 6));
150
151         return 0;
152 }
153
154 static int snd_soc_tlv320aic23_get_volsw(struct snd_kcontrol *kcontrol,
155         struct snd_ctl_elem_value *ucontrol)
156 {
157         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
158         u16 val;
159
160         val = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG) & (0x1C0);
161         val = val >> 6;
162         val = (val >= 4) ? 4  : (3 -  val);
163         ucontrol->value.integer.value[0] = val;
164         return 0;
165
166 }
167
168 #define SOC_TLV320AIC23_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
169 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
170         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
171                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
172         .tlv.p = (tlv_array), \
173         .info = snd_soc_info_volsw, .get = snd_soc_tlv320aic23_get_volsw,\
174         .put = snd_soc_tlv320aic23_put_volsw, \
175         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
176
177 static const struct snd_kcontrol_new tlv320aic23_snd_controls[] = {
178         SOC_DOUBLE_R_TLV("Digital Playback Volume", TLV320AIC23_LCHNVOL,
179                          TLV320AIC23_RCHNVOL, 0, 127, 0, out_gain_tlv),
180         SOC_SINGLE("Digital Playback Switch", TLV320AIC23_DIGT, 3, 1, 1),
181         SOC_DOUBLE_R("Line Input Switch", TLV320AIC23_LINVOL,
182                      TLV320AIC23_RINVOL, 7, 1, 0),
183         SOC_DOUBLE_R_TLV("Line Input Volume", TLV320AIC23_LINVOL,
184                          TLV320AIC23_RINVOL, 0, 31, 0, input_gain_tlv),
185         SOC_SINGLE("Mic Input Switch", TLV320AIC23_ANLG, 1, 1, 1),
186         SOC_SINGLE("Mic Booster Switch", TLV320AIC23_ANLG, 0, 1, 0),
187         SOC_TLV320AIC23_SINGLE_TLV("Sidetone Volume", TLV320AIC23_ANLG,
188                                   6, 4, 0, sidetone_vol_tlv),
189         SOC_ENUM("Playback De-emphasis", tlv320aic23_deemph),
190 };
191
192 /* add non dapm controls */
193 static int tlv320aic23_add_controls(struct snd_soc_codec *codec)
194 {
195
196         int err, i;
197
198         for (i = 0; i < ARRAY_SIZE(tlv320aic23_snd_controls); i++) {
199                 err = snd_ctl_add(codec->card,
200                                   snd_soc_cnew(&tlv320aic23_snd_controls[i],
201                                                codec, NULL));
202                 if (err < 0)
203                         return err;
204         }
205
206         return 0;
207
208 }
209
210 /* PGA Mixer controls for Line and Mic switch */
211 static const struct snd_kcontrol_new tlv320aic23_output_mixer_controls[] = {
212         SOC_DAPM_SINGLE("Line Bypass Switch", TLV320AIC23_ANLG, 3, 1, 0),
213         SOC_DAPM_SINGLE("Mic Sidetone Switch", TLV320AIC23_ANLG, 5, 1, 0),
214         SOC_DAPM_SINGLE("Playback Switch", TLV320AIC23_ANLG, 4, 1, 0),
215 };
216
217 static const struct snd_soc_dapm_widget tlv320aic23_dapm_widgets[] = {
218         SND_SOC_DAPM_DAC("DAC", "Playback", TLV320AIC23_PWR, 3, 1),
219         SND_SOC_DAPM_ADC("ADC", "Capture", TLV320AIC23_PWR, 2, 1),
220         SND_SOC_DAPM_MUX("Capture Source", SND_SOC_NOPM, 0, 0,
221                          &tlv320aic23_rec_src_mux_controls),
222         SND_SOC_DAPM_MIXER("Output Mixer", TLV320AIC23_PWR, 4, 1,
223                            &tlv320aic23_output_mixer_controls[0],
224                            ARRAY_SIZE(tlv320aic23_output_mixer_controls)),
225         SND_SOC_DAPM_PGA("Line Input", TLV320AIC23_PWR, 0, 1, NULL, 0),
226         SND_SOC_DAPM_PGA("Mic Input", TLV320AIC23_PWR, 1, 1, NULL, 0),
227
228         SND_SOC_DAPM_OUTPUT("LHPOUT"),
229         SND_SOC_DAPM_OUTPUT("RHPOUT"),
230         SND_SOC_DAPM_OUTPUT("LOUT"),
231         SND_SOC_DAPM_OUTPUT("ROUT"),
232
233         SND_SOC_DAPM_INPUT("LLINEIN"),
234         SND_SOC_DAPM_INPUT("RLINEIN"),
235
236         SND_SOC_DAPM_INPUT("MICIN"),
237 };
238
239 static const struct snd_soc_dapm_route intercon[] = {
240         /* Output Mixer */
241         {"Output Mixer", "Line Bypass Switch", "Line Input"},
242         {"Output Mixer", "Playback Switch", "DAC"},
243         {"Output Mixer", "Mic Sidetone Switch", "Mic Input"},
244
245         /* Outputs */
246         {"RHPOUT", NULL, "Output Mixer"},
247         {"LHPOUT", NULL, "Output Mixer"},
248         {"LOUT", NULL, "Output Mixer"},
249         {"ROUT", NULL, "Output Mixer"},
250
251         /* Inputs */
252         {"Line Input", "NULL", "LLINEIN"},
253         {"Line Input", "NULL", "RLINEIN"},
254
255         {"Mic Input", "NULL", "MICIN"},
256
257         /* input mux */
258         {"Capture Source", "Line", "Line Input"},
259         {"Capture Source", "Mic", "Mic Input"},
260         {"ADC", NULL, "Capture Source"},
261
262 };
263
264 /* tlv320aic23 related */
265 static const struct tlv320aic23_srate_reg_info srate_reg_info[] = {
266         {4000, 0x06, 1},        /*  4000 */
267         {8000, 0x06, 0},        /*  8000 */
268         {16000, 0x0C, 1},       /* 16000 */
269         {22050, 0x11, 1},       /* 22050 */
270         {24000, 0x00, 1},       /* 24000 */
271         {32000, 0x0C, 0},       /* 32000 */
272         {44100, 0x11, 0},       /* 44100 */
273         {48000, 0x00, 0},       /* 48000 */
274         {88200, 0x1F, 0},       /* 88200 */
275         {96000, 0x0E, 0},       /* 96000 */
276 };
277
278 static int tlv320aic23_add_widgets(struct snd_soc_codec *codec)
279 {
280         snd_soc_dapm_new_controls(codec, tlv320aic23_dapm_widgets,
281                                   ARRAY_SIZE(tlv320aic23_dapm_widgets));
282
283         /* set up audio path interconnects */
284         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
285
286         snd_soc_dapm_new_widgets(codec);
287         return 0;
288 }
289
290 static int tlv320aic23_hw_params(struct snd_pcm_substream *substream,
291                                  struct snd_pcm_hw_params *params)
292 {
293         struct snd_soc_pcm_runtime *rtd = substream->private_data;
294         struct snd_soc_device *socdev = rtd->socdev;
295         struct snd_soc_codec *codec = socdev->codec;
296         u16 iface_reg, data;
297         u8 count = 0;
298
299         iface_reg =
300             tlv320aic23_read_reg_cache(codec,
301                                        TLV320AIC23_DIGT_FMT) & ~(0x03 << 2);
302
303         /* Search for the right sample rate */
304         /* Verify what happens if the rate is not supported
305          * now it goes to 96Khz */
306         while ((srate_reg_info[count].sample_rate != params_rate(params)) &&
307                (count < ARRAY_SIZE(srate_reg_info))) {
308                 count++;
309         }
310
311         data =  (srate_reg_info[count].divider << TLV320AIC23_CLKIN_SHIFT) |
312                 (srate_reg_info[count]. control << TLV320AIC23_BOSR_SHIFT) |
313                 TLV320AIC23_USB_CLK_ON;
314
315         tlv320aic23_write(codec, TLV320AIC23_SRATE, data);
316
317         switch (params_format(params)) {
318         case SNDRV_PCM_FORMAT_S16_LE:
319                 break;
320         case SNDRV_PCM_FORMAT_S20_3LE:
321                 iface_reg |= (0x01 << 2);
322                 break;
323         case SNDRV_PCM_FORMAT_S24_LE:
324                 iface_reg |= (0x02 << 2);
325                 break;
326         case SNDRV_PCM_FORMAT_S32_LE:
327                 iface_reg |= (0x03 << 2);
328                 break;
329         }
330         tlv320aic23_write(codec, TLV320AIC23_DIGT_FMT, iface_reg);
331
332         return 0;
333 }
334
335 static int tlv320aic23_pcm_prepare(struct snd_pcm_substream *substream)
336 {
337         struct snd_soc_pcm_runtime *rtd = substream->private_data;
338         struct snd_soc_device *socdev = rtd->socdev;
339         struct snd_soc_codec *codec = socdev->codec;
340
341         /* set active */
342         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0001);
343
344         return 0;
345 }
346
347 static void tlv320aic23_shutdown(struct snd_pcm_substream *substream)
348 {
349         struct snd_soc_pcm_runtime *rtd = substream->private_data;
350         struct snd_soc_device *socdev = rtd->socdev;
351         struct snd_soc_codec *codec = socdev->codec;
352
353         /* deactivate */
354         if (!codec->active) {
355                 udelay(50);
356                 tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
357         }
358 }
359
360 static int tlv320aic23_mute(struct snd_soc_dai *dai, int mute)
361 {
362         struct snd_soc_codec *codec = dai->codec;
363         u16 reg;
364
365         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_DIGT);
366         if (mute)
367                 reg |= TLV320AIC23_DACM_MUTE;
368
369         else
370                 reg &= ~TLV320AIC23_DACM_MUTE;
371
372         tlv320aic23_write(codec, TLV320AIC23_DIGT, reg);
373
374         return 0;
375 }
376
377 static int tlv320aic23_set_dai_fmt(struct snd_soc_dai *codec_dai,
378                                    unsigned int fmt)
379 {
380         struct snd_soc_codec *codec = codec_dai->codec;
381         u16 iface_reg;
382
383         iface_reg =
384             tlv320aic23_read_reg_cache(codec, TLV320AIC23_DIGT_FMT) & (~0x03);
385
386         /* set master/slave audio interface */
387         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
388         case SND_SOC_DAIFMT_CBM_CFM:
389                 iface_reg |= TLV320AIC23_MS_MASTER;
390                 break;
391         case SND_SOC_DAIFMT_CBS_CFS:
392                 break;
393         default:
394                 return -EINVAL;
395
396         }
397
398         /* interface format */
399         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
400         case SND_SOC_DAIFMT_I2S:
401                 iface_reg |= TLV320AIC23_FOR_I2S;
402                 break;
403         case SND_SOC_DAIFMT_DSP_A:
404                 iface_reg |= TLV320AIC23_FOR_DSP;
405                 break;
406         case SND_SOC_DAIFMT_RIGHT_J:
407                 break;
408         case SND_SOC_DAIFMT_LEFT_J:
409                 iface_reg |= TLV320AIC23_FOR_LJUST;
410                 break;
411         default:
412                 return -EINVAL;
413
414         }
415
416         tlv320aic23_write(codec, TLV320AIC23_DIGT_FMT, iface_reg);
417
418         return 0;
419 }
420
421 static int tlv320aic23_set_dai_sysclk(struct snd_soc_dai *codec_dai,
422                                       int clk_id, unsigned int freq, int dir)
423 {
424         struct snd_soc_codec *codec = codec_dai->codec;
425
426         switch (freq) {
427         case 12000000:
428                 return 0;
429         }
430         return -EINVAL;
431 }
432
433 static int tlv320aic23_set_bias_level(struct snd_soc_codec *codec,
434                                       enum snd_soc_bias_level level)
435 {
436         u16 reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_PWR) & 0xff7f;
437
438         switch (level) {
439         case SND_SOC_BIAS_ON:
440                 /* vref/mid, osc on, dac unmute */
441                 tlv320aic23_write(codec, TLV320AIC23_PWR, reg);
442                 break;
443         case SND_SOC_BIAS_PREPARE:
444                 break;
445         case SND_SOC_BIAS_STANDBY:
446                 /* everything off except vref/vmid, */
447                 tlv320aic23_write(codec, TLV320AIC23_PWR, reg | 0x0040);
448                 break;
449         case SND_SOC_BIAS_OFF:
450                 /* everything off, dac mute, inactive */
451                 tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
452                 tlv320aic23_write(codec, TLV320AIC23_PWR, 0xffff);
453                 break;
454         }
455         codec->bias_level = level;
456         return 0;
457 }
458
459 #define AIC23_RATES     SNDRV_PCM_RATE_8000_96000
460 #define AIC23_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
461                          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S32_LE)
462
463 struct snd_soc_dai tlv320aic23_dai = {
464         .name = "tlv320aic23",
465         .playback = {
466                      .stream_name = "Playback",
467                      .channels_min = 2,
468                      .channels_max = 2,
469                      .rates = AIC23_RATES,
470                      .formats = AIC23_FORMATS,},
471         .capture = {
472                     .stream_name = "Capture",
473                     .channels_min = 2,
474                     .channels_max = 2,
475                     .rates = AIC23_RATES,
476                     .formats = AIC23_FORMATS,},
477         .ops = {
478                 .prepare = tlv320aic23_pcm_prepare,
479                 .hw_params = tlv320aic23_hw_params,
480                 .shutdown = tlv320aic23_shutdown,
481                 },
482         .dai_ops = {
483                     .digital_mute = tlv320aic23_mute,
484                     .set_fmt = tlv320aic23_set_dai_fmt,
485                     .set_sysclk = tlv320aic23_set_dai_sysclk,
486                     }
487 };
488 EXPORT_SYMBOL_GPL(tlv320aic23_dai);
489
490 static int tlv320aic23_suspend(struct platform_device *pdev,
491                                pm_message_t state)
492 {
493         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
494         struct snd_soc_codec *codec = socdev->codec;
495
496         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
497         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_OFF);
498
499         return 0;
500 }
501
502 static int tlv320aic23_resume(struct platform_device *pdev)
503 {
504         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
505         struct snd_soc_codec *codec = socdev->codec;
506         int i;
507         u16 reg;
508
509         /* Sync reg_cache with the hardware */
510         for (reg = 0; reg < ARRAY_SIZE(tlv320aic23_reg); i++) {
511                 u16 val = tlv320aic23_read_reg_cache(codec, reg);
512                 tlv320aic23_write(codec, reg, val);
513         }
514
515         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
516         tlv320aic23_set_bias_level(codec, codec->suspend_bias_level);
517
518         return 0;
519 }
520
521 /*
522  * initialise the AIC23 driver
523  * register the mixer and dsp interfaces with the kernel
524  */
525 static int tlv320aic23_init(struct snd_soc_device *socdev)
526 {
527         struct snd_soc_codec *codec = socdev->codec;
528         int ret = 0;
529         u16 reg;
530
531         codec->name = "tlv320aic23";
532         codec->owner = THIS_MODULE;
533         codec->read = tlv320aic23_read_reg_cache;
534         codec->write = tlv320aic23_write;
535         codec->set_bias_level = tlv320aic23_set_bias_level;
536         codec->dai = &tlv320aic23_dai;
537         codec->num_dai = 1;
538         codec->reg_cache_size = ARRAY_SIZE(tlv320aic23_reg);
539         codec->reg_cache =
540             kmemdup(tlv320aic23_reg, sizeof(tlv320aic23_reg), GFP_KERNEL);
541         if (codec->reg_cache == NULL)
542                 return -ENOMEM;
543
544         /* Reset codec */
545         tlv320aic23_write(codec, TLV320AIC23_RESET, 0);
546
547         /* register pcms */
548         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
549         if (ret < 0) {
550                 printk(KERN_ERR "tlv320aic23: failed to create pcms\n");
551                 goto pcm_err;
552         }
553
554         /* power on device */
555         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
556
557         tlv320aic23_write(codec, TLV320AIC23_DIGT, TLV320AIC23_DEEMP_44K);
558
559         /* Unmute input */
560         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_LINVOL);
561         tlv320aic23_write(codec, TLV320AIC23_LINVOL,
562                           (reg & (~TLV320AIC23_LIM_MUTED)) |
563                           (TLV320AIC23_LRS_ENABLED));
564
565         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_RINVOL);
566         tlv320aic23_write(codec, TLV320AIC23_RINVOL,
567                           (reg & (~TLV320AIC23_LIM_MUTED)) |
568                           TLV320AIC23_LRS_ENABLED);
569
570         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG);
571         tlv320aic23_write(codec, TLV320AIC23_ANLG,
572                          (reg) & (~TLV320AIC23_BYPASS_ON) &
573                          (~TLV320AIC23_MICM_MUTED));
574
575         /* Default output volume */
576         tlv320aic23_write(codec, TLV320AIC23_LCHNVOL,
577                           TLV320AIC23_DEFAULT_OUT_VOL &
578                           TLV320AIC23_OUT_VOL_MASK);
579         tlv320aic23_write(codec, TLV320AIC23_RCHNVOL,
580                           TLV320AIC23_DEFAULT_OUT_VOL &
581                           TLV320AIC23_OUT_VOL_MASK);
582
583         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x1);
584
585         tlv320aic23_add_controls(codec);
586         tlv320aic23_add_widgets(codec);
587         ret = snd_soc_register_card(socdev);
588         if (ret < 0) {
589                 printk(KERN_ERR "tlv320aic23: failed to register card\n");
590                 goto card_err;
591         }
592
593         return ret;
594
595 card_err:
596         snd_soc_free_pcms(socdev);
597         snd_soc_dapm_free(socdev);
598 pcm_err:
599         kfree(codec->reg_cache);
600         return ret;
601 }
602 static struct snd_soc_device *tlv320aic23_socdev;
603
604 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
605 /*
606  * If the i2c layer weren't so broken, we could pass this kind of data
607  * around
608  */
609 static int tlv320aic23_codec_probe(struct i2c_client *i2c,
610                                    const struct i2c_device_id *i2c_id)
611 {
612         struct snd_soc_device *socdev = tlv320aic23_socdev;
613         struct snd_soc_codec *codec = socdev->codec;
614         int ret;
615
616         if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
617                 return -EINVAL;
618
619         i2c_set_clientdata(i2c, codec);
620         codec->control_data = i2c;
621
622         ret = tlv320aic23_init(socdev);
623         if (ret < 0) {
624                 printk(KERN_ERR "tlv320aic23: failed to initialise AIC23\n");
625                 goto err;
626         }
627         return ret;
628
629 err:
630         kfree(codec);
631         kfree(i2c);
632         return ret;
633 }
634 static int __exit tlv320aic23_i2c_remove(struct i2c_client *i2c)
635 {
636         put_device(&i2c->dev);
637         return 0;
638 }
639
640 static const struct i2c_device_id tlv320aic23_id[] = {
641         {"tlv320aic23", 0},
642         {}
643 };
644
645 MODULE_DEVICE_TABLE(i2c, tlv320aic23_id);
646
647 static struct i2c_driver tlv320aic23_i2c_driver = {
648         .driver = {
649                    .name = "tlv320aic23",
650                    },
651         .probe = tlv320aic23_codec_probe,
652         .remove = __exit_p(tlv320aic23_i2c_remove),
653         .id_table = tlv320aic23_id,
654 };
655
656 #endif
657
658 static int tlv320aic23_probe(struct platform_device *pdev)
659 {
660         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
661         struct snd_soc_codec *codec;
662         int ret = 0;
663
664         printk(KERN_INFO "AIC23 Audio Codec %s\n", AIC23_VERSION);
665
666         codec = kzalloc(sizeof(struct snd_soc_codec), GFP_KERNEL);
667         if (codec == NULL)
668                 return -ENOMEM;
669
670         socdev->codec = codec;
671         mutex_init(&codec->mutex);
672         INIT_LIST_HEAD(&codec->dapm_widgets);
673         INIT_LIST_HEAD(&codec->dapm_paths);
674
675         tlv320aic23_socdev = socdev;
676 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
677         codec->hw_write = (hw_write_t) i2c_master_send;
678         codec->hw_read = NULL;
679         ret = i2c_add_driver(&tlv320aic23_i2c_driver);
680         if (ret != 0)
681                 printk(KERN_ERR "can't add i2c driver");
682 #endif
683         return ret;
684 }
685
686 static int tlv320aic23_remove(struct platform_device *pdev)
687 {
688         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
689         struct snd_soc_codec *codec = socdev->codec;
690
691         if (codec->control_data)
692                 tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_OFF);
693
694         snd_soc_free_pcms(socdev);
695         snd_soc_dapm_free(socdev);
696 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
697         i2c_del_driver(&tlv320aic23_i2c_driver);
698 #endif
699         kfree(codec->reg_cache);
700         kfree(codec);
701
702         return 0;
703 }
704 struct snd_soc_codec_device soc_codec_dev_tlv320aic23 = {
705         .probe = tlv320aic23_probe,
706         .remove = tlv320aic23_remove,
707         .suspend = tlv320aic23_suspend,
708         .resume = tlv320aic23_resume,
709 };
710 EXPORT_SYMBOL_GPL(soc_codec_dev_tlv320aic23);
711
712 MODULE_DESCRIPTION("ASoC TLV320AIC23 codec driver");
713 MODULE_AUTHOR("Arun KS <arunks@mistralsolutions.com>");
714 MODULE_LICENSE("GPL");