Merge branch 'topic/core-change' into for-linus
[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 /*
41  * AIC23 register cache
42  */
43 static const u16 tlv320aic23_reg[] = {
44         0x0097, 0x0097, 0x00F9, 0x00F9, /* 0 */
45         0x001A, 0x0004, 0x0007, 0x0001, /* 4 */
46         0x0020, 0x0000, 0x0000, 0x0000, /* 8 */
47         0x0000, 0x0000, 0x0000, 0x0000, /* 12 */
48 };
49
50 /*
51  * read tlv320aic23 register cache
52  */
53 static inline unsigned int tlv320aic23_read_reg_cache(struct snd_soc_codec
54                                                       *codec, unsigned int reg)
55 {
56         u16 *cache = codec->reg_cache;
57         if (reg >= ARRAY_SIZE(tlv320aic23_reg))
58                 return -1;
59         return cache[reg];
60 }
61
62 /*
63  * write tlv320aic23 register cache
64  */
65 static inline void tlv320aic23_write_reg_cache(struct snd_soc_codec *codec,
66                                                u8 reg, u16 value)
67 {
68         u16 *cache = codec->reg_cache;
69         if (reg >= ARRAY_SIZE(tlv320aic23_reg))
70                 return;
71         cache[reg] = value;
72 }
73
74 /*
75  * write to the tlv320aic23 register space
76  */
77 static int tlv320aic23_write(struct snd_soc_codec *codec, unsigned int reg,
78                              unsigned int value)
79 {
80
81         u8 data[2];
82
83         /* TLV320AIC23 has 7 bit address and 9 bits of data
84          * so we need to switch one data bit into reg and rest
85          * of data into val
86          */
87
88         if (reg > 9 && reg != 15) {
89                 printk(KERN_WARNING "%s Invalid register R%u\n", __func__, reg);
90                 return -1;
91         }
92
93         data[0] = (reg << 1) | (value >> 8 & 0x01);
94         data[1] = value & 0xff;
95
96         tlv320aic23_write_reg_cache(codec, reg, value);
97
98         if (codec->hw_write(codec->control_data, data, 2) == 2)
99                 return 0;
100
101         printk(KERN_ERR "%s cannot write %03x to register R%u\n", __func__,
102                value, reg);
103
104         return -EIO;
105 }
106
107 static const char *rec_src_text[] = { "Line", "Mic" };
108 static const char *deemph_text[] = {"None", "32Khz", "44.1Khz", "48Khz"};
109
110 static const struct soc_enum rec_src_enum =
111         SOC_ENUM_SINGLE(TLV320AIC23_ANLG, 2, 2, rec_src_text);
112
113 static const struct snd_kcontrol_new tlv320aic23_rec_src_mux_controls =
114 SOC_DAPM_ENUM("Input Select", rec_src_enum);
115
116 static const struct soc_enum tlv320aic23_rec_src =
117         SOC_ENUM_SINGLE(TLV320AIC23_ANLG, 2, 2, rec_src_text);
118 static const struct soc_enum tlv320aic23_deemph =
119         SOC_ENUM_SINGLE(TLV320AIC23_DIGT, 1, 4, deemph_text);
120
121 static const DECLARE_TLV_DB_SCALE(out_gain_tlv, -12100, 100, 0);
122 static const DECLARE_TLV_DB_SCALE(input_gain_tlv, -1725, 75, 0);
123 static const DECLARE_TLV_DB_SCALE(sidetone_vol_tlv, -1800, 300, 0);
124
125 static int snd_soc_tlv320aic23_put_volsw(struct snd_kcontrol *kcontrol,
126         struct snd_ctl_elem_value *ucontrol)
127 {
128         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
129         u16 val, reg;
130
131         val = (ucontrol->value.integer.value[0] & 0x07);
132
133         /* linear conversion to userspace
134         * 000   =       -6db
135         * 001   =       -9db
136         * 010   =       -12db
137         * 011   =       -18db (Min)
138         * 100   =       0db (Max)
139         */
140         val = (val >= 4) ? 4  : (3 - val);
141
142         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG) & (~0x1C0);
143         tlv320aic23_write(codec, TLV320AIC23_ANLG, reg | (val << 6));
144
145         return 0;
146 }
147
148 static int snd_soc_tlv320aic23_get_volsw(struct snd_kcontrol *kcontrol,
149         struct snd_ctl_elem_value *ucontrol)
150 {
151         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
152         u16 val;
153
154         val = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG) & (0x1C0);
155         val = val >> 6;
156         val = (val >= 4) ? 4  : (3 -  val);
157         ucontrol->value.integer.value[0] = val;
158         return 0;
159
160 }
161
162 #define SOC_TLV320AIC23_SINGLE_TLV(xname, reg, shift, max, invert, tlv_array) \
163 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
164         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
165                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
166         .tlv.p = (tlv_array), \
167         .info = snd_soc_info_volsw, .get = snd_soc_tlv320aic23_get_volsw,\
168         .put = snd_soc_tlv320aic23_put_volsw, \
169         .private_value =  SOC_SINGLE_VALUE(reg, shift, max, invert) }
170
171 static const struct snd_kcontrol_new tlv320aic23_snd_controls[] = {
172         SOC_DOUBLE_R_TLV("Digital Playback Volume", TLV320AIC23_LCHNVOL,
173                          TLV320AIC23_RCHNVOL, 0, 127, 0, out_gain_tlv),
174         SOC_SINGLE("Digital Playback Switch", TLV320AIC23_DIGT, 3, 1, 1),
175         SOC_DOUBLE_R("Line Input Switch", TLV320AIC23_LINVOL,
176                      TLV320AIC23_RINVOL, 7, 1, 0),
177         SOC_DOUBLE_R_TLV("Line Input Volume", TLV320AIC23_LINVOL,
178                          TLV320AIC23_RINVOL, 0, 31, 0, input_gain_tlv),
179         SOC_SINGLE("Mic Input Switch", TLV320AIC23_ANLG, 1, 1, 1),
180         SOC_SINGLE("Mic Booster Switch", TLV320AIC23_ANLG, 0, 1, 0),
181         SOC_TLV320AIC23_SINGLE_TLV("Sidetone Volume", TLV320AIC23_ANLG,
182                                   6, 4, 0, sidetone_vol_tlv),
183         SOC_ENUM("Playback De-emphasis", tlv320aic23_deemph),
184 };
185
186 /* PGA Mixer controls for Line and Mic switch */
187 static const struct snd_kcontrol_new tlv320aic23_output_mixer_controls[] = {
188         SOC_DAPM_SINGLE("Line Bypass Switch", TLV320AIC23_ANLG, 3, 1, 0),
189         SOC_DAPM_SINGLE("Mic Sidetone Switch", TLV320AIC23_ANLG, 5, 1, 0),
190         SOC_DAPM_SINGLE("Playback Switch", TLV320AIC23_ANLG, 4, 1, 0),
191 };
192
193 static const struct snd_soc_dapm_widget tlv320aic23_dapm_widgets[] = {
194         SND_SOC_DAPM_DAC("DAC", "Playback", TLV320AIC23_PWR, 3, 1),
195         SND_SOC_DAPM_ADC("ADC", "Capture", TLV320AIC23_PWR, 2, 1),
196         SND_SOC_DAPM_MUX("Capture Source", SND_SOC_NOPM, 0, 0,
197                          &tlv320aic23_rec_src_mux_controls),
198         SND_SOC_DAPM_MIXER("Output Mixer", TLV320AIC23_PWR, 4, 1,
199                            &tlv320aic23_output_mixer_controls[0],
200                            ARRAY_SIZE(tlv320aic23_output_mixer_controls)),
201         SND_SOC_DAPM_PGA("Line Input", TLV320AIC23_PWR, 0, 1, NULL, 0),
202         SND_SOC_DAPM_PGA("Mic Input", TLV320AIC23_PWR, 1, 1, NULL, 0),
203
204         SND_SOC_DAPM_OUTPUT("LHPOUT"),
205         SND_SOC_DAPM_OUTPUT("RHPOUT"),
206         SND_SOC_DAPM_OUTPUT("LOUT"),
207         SND_SOC_DAPM_OUTPUT("ROUT"),
208
209         SND_SOC_DAPM_INPUT("LLINEIN"),
210         SND_SOC_DAPM_INPUT("RLINEIN"),
211
212         SND_SOC_DAPM_INPUT("MICIN"),
213 };
214
215 static const struct snd_soc_dapm_route intercon[] = {
216         /* Output Mixer */
217         {"Output Mixer", "Line Bypass Switch", "Line Input"},
218         {"Output Mixer", "Playback Switch", "DAC"},
219         {"Output Mixer", "Mic Sidetone Switch", "Mic Input"},
220
221         /* Outputs */
222         {"RHPOUT", NULL, "Output Mixer"},
223         {"LHPOUT", NULL, "Output Mixer"},
224         {"LOUT", NULL, "Output Mixer"},
225         {"ROUT", NULL, "Output Mixer"},
226
227         /* Inputs */
228         {"Line Input", "NULL", "LLINEIN"},
229         {"Line Input", "NULL", "RLINEIN"},
230
231         {"Mic Input", "NULL", "MICIN"},
232
233         /* input mux */
234         {"Capture Source", "Line", "Line Input"},
235         {"Capture Source", "Mic", "Mic Input"},
236         {"ADC", NULL, "Capture Source"},
237
238 };
239
240 /* AIC23 driver data */
241 struct aic23 {
242         struct snd_soc_codec codec;
243         int mclk;
244         int requested_adc;
245         int requested_dac;
246 };
247
248 /*
249  * Common Crystals used
250  * 11.2896 Mhz /128 = *88.2k  /192 = 58.8k
251  * 12.0000 Mhz /125 = *96k    /136 = 88.235K
252  * 12.2880 Mhz /128 = *96k    /192 = 64k
253  * 16.9344 Mhz /128 = 132.3k /192 = *88.2k
254  * 18.4320 Mhz /128 = 144k   /192 = *96k
255  */
256
257 /*
258  * Normal BOSR 0-256/2 = 128, 1-384/2 = 192
259  * USB BOSR 0-250/2 = 125, 1-272/2 = 136
260  */
261 static const int bosr_usb_divisor_table[] = {
262         128, 125, 192, 136
263 };
264 #define LOWER_GROUP ((1<<0) | (1<<1) | (1<<2) | (1<<3) | (1<<6) | (1<<7))
265 #define UPPER_GROUP ((1<<8) | (1<<9) | (1<<10) | (1<<11)        | (1<<15))
266 static const unsigned short sr_valid_mask[] = {
267         LOWER_GROUP|UPPER_GROUP,        /* Normal, bosr - 0*/
268         LOWER_GROUP,                    /* Usb, bosr - 0*/
269         LOWER_GROUP|UPPER_GROUP,        /* Normal, bosr - 1*/
270         UPPER_GROUP,                    /* Usb, bosr - 1*/
271 };
272 /*
273  * Every divisor is a factor of 11*12
274  */
275 #define SR_MULT (11*12)
276 #define A(x) (SR_MULT/x)
277 static const unsigned char sr_adc_mult_table[] = {
278         A(2), A(2), A(12), A(12),  0, 0, A(3), A(1),
279         A(2), A(2), A(11), A(11),  0, 0, 0, A(1)
280 };
281 static const unsigned char sr_dac_mult_table[] = {
282         A(2), A(12), A(2), A(12),  0, 0, A(3), A(1),
283         A(2), A(11), A(2), A(11),  0, 0, 0, A(1)
284 };
285
286 static unsigned get_score(int adc, int adc_l, int adc_h, int need_adc,
287                 int dac, int dac_l, int dac_h, int need_dac)
288 {
289         if ((adc >= adc_l) && (adc <= adc_h) &&
290                         (dac >= dac_l) && (dac <= dac_h)) {
291                 int diff_adc = need_adc - adc;
292                 int diff_dac = need_dac - dac;
293                 return abs(diff_adc) + abs(diff_dac);
294         }
295         return UINT_MAX;
296 }
297
298 static int find_rate(int mclk, u32 need_adc, u32 need_dac)
299 {
300         int i, j;
301         int best_i = -1;
302         int best_j = -1;
303         int best_div = 0;
304         unsigned best_score = UINT_MAX;
305         int adc_l, adc_h, dac_l, dac_h;
306
307         need_adc *= SR_MULT;
308         need_dac *= SR_MULT;
309         /*
310          * rates given are +/- 1/32
311          */
312         adc_l = need_adc - (need_adc >> 5);
313         adc_h = need_adc + (need_adc >> 5);
314         dac_l = need_dac - (need_dac >> 5);
315         dac_h = need_dac + (need_dac >> 5);
316         for (i = 0; i < ARRAY_SIZE(bosr_usb_divisor_table); i++) {
317                 int base = mclk / bosr_usb_divisor_table[i];
318                 int mask = sr_valid_mask[i];
319                 for (j = 0; j < ARRAY_SIZE(sr_adc_mult_table);
320                                 j++, mask >>= 1) {
321                         int adc;
322                         int dac;
323                         int score;
324                         if ((mask & 1) == 0)
325                                 continue;
326                         adc = base * sr_adc_mult_table[j];
327                         dac = base * sr_dac_mult_table[j];
328                         score = get_score(adc, adc_l, adc_h, need_adc,
329                                         dac, dac_l, dac_h, need_dac);
330                         if (best_score > score) {
331                                 best_score = score;
332                                 best_i = i;
333                                 best_j = j;
334                                 best_div = 0;
335                         }
336                         score = get_score((adc >> 1), adc_l, adc_h, need_adc,
337                                         (dac >> 1), dac_l, dac_h, need_dac);
338                         /* prefer to have a /2 */
339                         if ((score != UINT_MAX) && (best_score >= score)) {
340                                 best_score = score;
341                                 best_i = i;
342                                 best_j = j;
343                                 best_div = 1;
344                         }
345                 }
346         }
347         return (best_j << 2) | best_i | (best_div << TLV320AIC23_CLKIN_SHIFT);
348 }
349
350 #ifdef DEBUG
351 static void get_current_sample_rates(struct snd_soc_codec *codec, int mclk,
352                 u32 *sample_rate_adc, u32 *sample_rate_dac)
353 {
354         int src = tlv320aic23_read_reg_cache(codec, TLV320AIC23_SRATE);
355         int sr = (src >> 2) & 0x0f;
356         int val = (mclk / bosr_usb_divisor_table[src & 3]);
357         int adc = (val * sr_adc_mult_table[sr]) / SR_MULT;
358         int dac = (val * sr_dac_mult_table[sr]) / SR_MULT;
359         if (src & TLV320AIC23_CLKIN_HALF) {
360                 adc >>= 1;
361                 dac >>= 1;
362         }
363         *sample_rate_adc = adc;
364         *sample_rate_dac = dac;
365 }
366 #endif
367
368 static int set_sample_rate_control(struct snd_soc_codec *codec, int mclk,
369                 u32 sample_rate_adc, u32 sample_rate_dac)
370 {
371         /* Search for the right sample rate */
372         int data = find_rate(mclk, sample_rate_adc, sample_rate_dac);
373         if (data < 0) {
374                 printk(KERN_ERR "%s:Invalid rate %u,%u requested\n",
375                                 __func__, sample_rate_adc, sample_rate_dac);
376                 return -EINVAL;
377         }
378         tlv320aic23_write(codec, TLV320AIC23_SRATE, data);
379 #ifdef DEBUG
380         {
381                 u32 adc, dac;
382                 get_current_sample_rates(codec, mclk, &adc, &dac);
383                 printk(KERN_DEBUG "actual samplerate = %u,%u reg=%x\n",
384                         adc, dac, data);
385         }
386 #endif
387         return 0;
388 }
389
390 static int tlv320aic23_add_widgets(struct snd_soc_codec *codec)
391 {
392         snd_soc_dapm_new_controls(codec, tlv320aic23_dapm_widgets,
393                                   ARRAY_SIZE(tlv320aic23_dapm_widgets));
394
395         /* set up audio path interconnects */
396         snd_soc_dapm_add_routes(codec, intercon, ARRAY_SIZE(intercon));
397
398         snd_soc_dapm_new_widgets(codec);
399         return 0;
400 }
401
402 static int tlv320aic23_hw_params(struct snd_pcm_substream *substream,
403                                  struct snd_pcm_hw_params *params,
404                                  struct snd_soc_dai *dai)
405 {
406         struct snd_soc_pcm_runtime *rtd = substream->private_data;
407         struct snd_soc_device *socdev = rtd->socdev;
408         struct snd_soc_codec *codec = socdev->card->codec;
409         u16 iface_reg;
410         int ret;
411         struct aic23 *aic23 = container_of(codec, struct aic23, codec);
412         u32 sample_rate_adc = aic23->requested_adc;
413         u32 sample_rate_dac = aic23->requested_dac;
414         u32 sample_rate = params_rate(params);
415
416         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
417                 aic23->requested_dac = sample_rate_dac = sample_rate;
418                 if (!sample_rate_adc)
419                         sample_rate_adc = sample_rate;
420         } else {
421                 aic23->requested_adc = sample_rate_adc = sample_rate;
422                 if (!sample_rate_dac)
423                         sample_rate_dac = sample_rate;
424         }
425         ret = set_sample_rate_control(codec, aic23->mclk, sample_rate_adc,
426                         sample_rate_dac);
427         if (ret < 0)
428                 return ret;
429
430         iface_reg =
431             tlv320aic23_read_reg_cache(codec,
432                                        TLV320AIC23_DIGT_FMT) & ~(0x03 << 2);
433         switch (params_format(params)) {
434         case SNDRV_PCM_FORMAT_S16_LE:
435                 break;
436         case SNDRV_PCM_FORMAT_S20_3LE:
437                 iface_reg |= (0x01 << 2);
438                 break;
439         case SNDRV_PCM_FORMAT_S24_LE:
440                 iface_reg |= (0x02 << 2);
441                 break;
442         case SNDRV_PCM_FORMAT_S32_LE:
443                 iface_reg |= (0x03 << 2);
444                 break;
445         }
446         tlv320aic23_write(codec, TLV320AIC23_DIGT_FMT, iface_reg);
447
448         return 0;
449 }
450
451 static int tlv320aic23_pcm_prepare(struct snd_pcm_substream *substream,
452                                    struct snd_soc_dai *dai)
453 {
454         struct snd_soc_pcm_runtime *rtd = substream->private_data;
455         struct snd_soc_device *socdev = rtd->socdev;
456         struct snd_soc_codec *codec = socdev->card->codec;
457
458         /* set active */
459         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0001);
460
461         return 0;
462 }
463
464 static void tlv320aic23_shutdown(struct snd_pcm_substream *substream,
465                                  struct snd_soc_dai *dai)
466 {
467         struct snd_soc_pcm_runtime *rtd = substream->private_data;
468         struct snd_soc_device *socdev = rtd->socdev;
469         struct snd_soc_codec *codec = socdev->card->codec;
470         struct aic23 *aic23 = container_of(codec, struct aic23, codec);
471
472         /* deactivate */
473         if (!codec->active) {
474                 udelay(50);
475                 tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
476         }
477         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
478                 aic23->requested_dac = 0;
479         else
480                 aic23->requested_adc = 0;
481 }
482
483 static int tlv320aic23_mute(struct snd_soc_dai *dai, int mute)
484 {
485         struct snd_soc_codec *codec = dai->codec;
486         u16 reg;
487
488         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_DIGT);
489         if (mute)
490                 reg |= TLV320AIC23_DACM_MUTE;
491
492         else
493                 reg &= ~TLV320AIC23_DACM_MUTE;
494
495         tlv320aic23_write(codec, TLV320AIC23_DIGT, reg);
496
497         return 0;
498 }
499
500 static int tlv320aic23_set_dai_fmt(struct snd_soc_dai *codec_dai,
501                                    unsigned int fmt)
502 {
503         struct snd_soc_codec *codec = codec_dai->codec;
504         u16 iface_reg;
505
506         iface_reg =
507             tlv320aic23_read_reg_cache(codec, TLV320AIC23_DIGT_FMT) & (~0x03);
508
509         /* set master/slave audio interface */
510         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
511         case SND_SOC_DAIFMT_CBM_CFM:
512                 iface_reg |= TLV320AIC23_MS_MASTER;
513                 break;
514         case SND_SOC_DAIFMT_CBS_CFS:
515                 break;
516         default:
517                 return -EINVAL;
518
519         }
520
521         /* interface format */
522         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
523         case SND_SOC_DAIFMT_I2S:
524                 iface_reg |= TLV320AIC23_FOR_I2S;
525                 break;
526         case SND_SOC_DAIFMT_DSP_A:
527                 iface_reg |= TLV320AIC23_LRP_ON;
528         case SND_SOC_DAIFMT_DSP_B:
529                 iface_reg |= TLV320AIC23_FOR_DSP;
530                 break;
531         case SND_SOC_DAIFMT_RIGHT_J:
532                 break;
533         case SND_SOC_DAIFMT_LEFT_J:
534                 iface_reg |= TLV320AIC23_FOR_LJUST;
535                 break;
536         default:
537                 return -EINVAL;
538
539         }
540
541         tlv320aic23_write(codec, TLV320AIC23_DIGT_FMT, iface_reg);
542
543         return 0;
544 }
545
546 static int tlv320aic23_set_dai_sysclk(struct snd_soc_dai *codec_dai,
547                                       int clk_id, unsigned int freq, int dir)
548 {
549         struct snd_soc_codec *codec = codec_dai->codec;
550         struct aic23 *aic23 = container_of(codec, struct aic23, codec);
551         aic23->mclk = freq;
552         return 0;
553 }
554
555 static int tlv320aic23_set_bias_level(struct snd_soc_codec *codec,
556                                       enum snd_soc_bias_level level)
557 {
558         u16 reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_PWR) & 0xff7f;
559
560         switch (level) {
561         case SND_SOC_BIAS_ON:
562                 /* vref/mid, osc on, dac unmute */
563                 tlv320aic23_write(codec, TLV320AIC23_PWR, reg);
564                 break;
565         case SND_SOC_BIAS_PREPARE:
566                 break;
567         case SND_SOC_BIAS_STANDBY:
568                 /* everything off except vref/vmid, */
569                 tlv320aic23_write(codec, TLV320AIC23_PWR, reg | 0x0040);
570                 break;
571         case SND_SOC_BIAS_OFF:
572                 /* everything off, dac mute, inactive */
573                 tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
574                 tlv320aic23_write(codec, TLV320AIC23_PWR, 0xffff);
575                 break;
576         }
577         codec->bias_level = level;
578         return 0;
579 }
580
581 #define AIC23_RATES     SNDRV_PCM_RATE_8000_96000
582 #define AIC23_FORMATS   (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
583                          SNDRV_PCM_FMTBIT_S24_3LE | SNDRV_PCM_FMTBIT_S32_LE)
584
585 static struct snd_soc_dai_ops tlv320aic23_dai_ops = {
586         .prepare        = tlv320aic23_pcm_prepare,
587         .hw_params      = tlv320aic23_hw_params,
588         .shutdown       = tlv320aic23_shutdown,
589         .digital_mute   = tlv320aic23_mute,
590         .set_fmt        = tlv320aic23_set_dai_fmt,
591         .set_sysclk     = tlv320aic23_set_dai_sysclk,
592 };
593
594 struct snd_soc_dai tlv320aic23_dai = {
595         .name = "tlv320aic23",
596         .playback = {
597                      .stream_name = "Playback",
598                      .channels_min = 2,
599                      .channels_max = 2,
600                      .rates = AIC23_RATES,
601                      .formats = AIC23_FORMATS,},
602         .capture = {
603                     .stream_name = "Capture",
604                     .channels_min = 2,
605                     .channels_max = 2,
606                     .rates = AIC23_RATES,
607                     .formats = AIC23_FORMATS,},
608         .ops = &tlv320aic23_dai_ops,
609 };
610 EXPORT_SYMBOL_GPL(tlv320aic23_dai);
611
612 static int tlv320aic23_suspend(struct platform_device *pdev,
613                                pm_message_t state)
614 {
615         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
616         struct snd_soc_codec *codec = socdev->card->codec;
617
618         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x0);
619         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_OFF);
620
621         return 0;
622 }
623
624 static int tlv320aic23_resume(struct platform_device *pdev)
625 {
626         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
627         struct snd_soc_codec *codec = socdev->card->codec;
628         u16 reg;
629
630         /* Sync reg_cache with the hardware */
631         for (reg = 0; reg < TLV320AIC23_RESET; reg++) {
632                 u16 val = tlv320aic23_read_reg_cache(codec, reg);
633                 tlv320aic23_write(codec, reg, val);
634         }
635
636         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
637         tlv320aic23_set_bias_level(codec, codec->suspend_bias_level);
638
639         return 0;
640 }
641
642 /*
643  * initialise the AIC23 driver
644  * register the mixer and dsp interfaces with the kernel
645  */
646 static int tlv320aic23_init(struct snd_soc_device *socdev)
647 {
648         struct snd_soc_codec *codec = socdev->card->codec;
649         int ret = 0;
650         u16 reg;
651
652         codec->name = "tlv320aic23";
653         codec->owner = THIS_MODULE;
654         codec->read = tlv320aic23_read_reg_cache;
655         codec->write = tlv320aic23_write;
656         codec->set_bias_level = tlv320aic23_set_bias_level;
657         codec->dai = &tlv320aic23_dai;
658         codec->num_dai = 1;
659         codec->reg_cache_size = ARRAY_SIZE(tlv320aic23_reg);
660         codec->reg_cache =
661             kmemdup(tlv320aic23_reg, sizeof(tlv320aic23_reg), GFP_KERNEL);
662         if (codec->reg_cache == NULL)
663                 return -ENOMEM;
664
665         /* Reset codec */
666         tlv320aic23_write(codec, TLV320AIC23_RESET, 0);
667
668         /* register pcms */
669         ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1);
670         if (ret < 0) {
671                 printk(KERN_ERR "tlv320aic23: failed to create pcms\n");
672                 goto pcm_err;
673         }
674
675         /* power on device */
676         tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
677
678         tlv320aic23_write(codec, TLV320AIC23_DIGT, TLV320AIC23_DEEMP_44K);
679
680         /* Unmute input */
681         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_LINVOL);
682         tlv320aic23_write(codec, TLV320AIC23_LINVOL,
683                           (reg & (~TLV320AIC23_LIM_MUTED)) |
684                           (TLV320AIC23_LRS_ENABLED));
685
686         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_RINVOL);
687         tlv320aic23_write(codec, TLV320AIC23_RINVOL,
688                           (reg & (~TLV320AIC23_LIM_MUTED)) |
689                           TLV320AIC23_LRS_ENABLED);
690
691         reg = tlv320aic23_read_reg_cache(codec, TLV320AIC23_ANLG);
692         tlv320aic23_write(codec, TLV320AIC23_ANLG,
693                          (reg) & (~TLV320AIC23_BYPASS_ON) &
694                          (~TLV320AIC23_MICM_MUTED));
695
696         /* Default output volume */
697         tlv320aic23_write(codec, TLV320AIC23_LCHNVOL,
698                           TLV320AIC23_DEFAULT_OUT_VOL &
699                           TLV320AIC23_OUT_VOL_MASK);
700         tlv320aic23_write(codec, TLV320AIC23_RCHNVOL,
701                           TLV320AIC23_DEFAULT_OUT_VOL &
702                           TLV320AIC23_OUT_VOL_MASK);
703
704         tlv320aic23_write(codec, TLV320AIC23_ACTIVE, 0x1);
705
706         snd_soc_add_controls(codec, tlv320aic23_snd_controls,
707                                 ARRAY_SIZE(tlv320aic23_snd_controls));
708         tlv320aic23_add_widgets(codec);
709         ret = snd_soc_init_card(socdev);
710         if (ret < 0) {
711                 printk(KERN_ERR "tlv320aic23: failed to register card\n");
712                 goto card_err;
713         }
714
715         return ret;
716
717 card_err:
718         snd_soc_free_pcms(socdev);
719         snd_soc_dapm_free(socdev);
720 pcm_err:
721         kfree(codec->reg_cache);
722         return ret;
723 }
724 static struct snd_soc_device *tlv320aic23_socdev;
725
726 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
727 /*
728  * If the i2c layer weren't so broken, we could pass this kind of data
729  * around
730  */
731 static int tlv320aic23_codec_probe(struct i2c_client *i2c,
732                                    const struct i2c_device_id *i2c_id)
733 {
734         struct snd_soc_device *socdev = tlv320aic23_socdev;
735         struct snd_soc_codec *codec = socdev->card->codec;
736         int ret;
737
738         if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
739                 return -EINVAL;
740
741         i2c_set_clientdata(i2c, codec);
742         codec->control_data = i2c;
743
744         ret = tlv320aic23_init(socdev);
745         if (ret < 0) {
746                 printk(KERN_ERR "tlv320aic23: failed to initialise AIC23\n");
747                 goto err;
748         }
749         return ret;
750
751 err:
752         kfree(codec);
753         kfree(i2c);
754         return ret;
755 }
756 static int __exit tlv320aic23_i2c_remove(struct i2c_client *i2c)
757 {
758         put_device(&i2c->dev);
759         return 0;
760 }
761
762 static const struct i2c_device_id tlv320aic23_id[] = {
763         {"tlv320aic23", 0},
764         {}
765 };
766
767 MODULE_DEVICE_TABLE(i2c, tlv320aic23_id);
768
769 static struct i2c_driver tlv320aic23_i2c_driver = {
770         .driver = {
771                    .name = "tlv320aic23",
772                    },
773         .probe = tlv320aic23_codec_probe,
774         .remove = __exit_p(tlv320aic23_i2c_remove),
775         .id_table = tlv320aic23_id,
776 };
777
778 #endif
779
780 static int tlv320aic23_probe(struct platform_device *pdev)
781 {
782         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
783         struct snd_soc_codec *codec;
784         struct aic23 *aic23;
785         int ret = 0;
786
787         printk(KERN_INFO "AIC23 Audio Codec %s\n", AIC23_VERSION);
788
789         aic23 = kzalloc(sizeof(struct aic23), GFP_KERNEL);
790         if (aic23 == NULL)
791                 return -ENOMEM;
792         codec = &aic23->codec;
793         socdev->card->codec = codec;
794         mutex_init(&codec->mutex);
795         INIT_LIST_HEAD(&codec->dapm_widgets);
796         INIT_LIST_HEAD(&codec->dapm_paths);
797
798         tlv320aic23_socdev = socdev;
799 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
800         codec->hw_write = (hw_write_t) i2c_master_send;
801         codec->hw_read = NULL;
802         ret = i2c_add_driver(&tlv320aic23_i2c_driver);
803         if (ret != 0)
804                 printk(KERN_ERR "can't add i2c driver");
805 #endif
806         return ret;
807 }
808
809 static int tlv320aic23_remove(struct platform_device *pdev)
810 {
811         struct snd_soc_device *socdev = platform_get_drvdata(pdev);
812         struct snd_soc_codec *codec = socdev->card->codec;
813         struct aic23 *aic23 = container_of(codec, struct aic23, codec);
814
815         if (codec->control_data)
816                 tlv320aic23_set_bias_level(codec, SND_SOC_BIAS_OFF);
817
818         snd_soc_free_pcms(socdev);
819         snd_soc_dapm_free(socdev);
820 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
821         i2c_del_driver(&tlv320aic23_i2c_driver);
822 #endif
823         kfree(codec->reg_cache);
824         kfree(aic23);
825
826         return 0;
827 }
828 struct snd_soc_codec_device soc_codec_dev_tlv320aic23 = {
829         .probe = tlv320aic23_probe,
830         .remove = tlv320aic23_remove,
831         .suspend = tlv320aic23_suspend,
832         .resume = tlv320aic23_resume,
833 };
834 EXPORT_SYMBOL_GPL(soc_codec_dev_tlv320aic23);
835
836 static int __init tlv320aic23_modinit(void)
837 {
838         return snd_soc_register_dai(&tlv320aic23_dai);
839 }
840 module_init(tlv320aic23_modinit);
841
842 static void __exit tlv320aic23_exit(void)
843 {
844         snd_soc_unregister_dai(&tlv320aic23_dai);
845 }
846 module_exit(tlv320aic23_exit);
847
848 MODULE_DESCRIPTION("ASoC TLV320AIC23 codec driver");
849 MODULE_AUTHOR("Arun KS <arunks@mistralsolutions.com>");
850 MODULE_LICENSE("GPL");