asoc: codecs: aic326x: enable the headset interrupts after jack registration
[linux-2.6.git] / sound / soc / codecs / tlv320aic326x.c
1 /*
2 * linux/sound/soc/codecs/tlv320aic3262.c
3 *
4 * Copyright (C) 2012 Texas Instruments, Inc.
5 *
6 * Based on sound/soc/codecs/tlv320aic3262.c
7 *
8 * This package is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 *
12 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
13 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
14 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
15 *
16 * The TLV320AIC3262 is a flexible, low-power, low-voltage stereo audio
17 * codec with digital microphone inputs and programmable outputs.
18 *
19 * History:
20 *
21 * Rev 0.1   ASoC driver support       20-01-2011
22 *
23 *               The AIC325x ASoC driver is ported for the codec AIC3262.
24 * Rev 0.2   ASoC driver support      21-03-2011
25 *               The AIC326x ASoC driver is updated abe changes.
26 *
27 * Rev 0.3   ASoC driver support      12.09.2011
28 *               fixed the compilation issues for Whistler support
29 *
30 * Rev 0.4   ASoC driver support     27.09.2011
31 *              The AIC326x driver ported for Nvidia cardhu.
32 *
33 * Rev 0.5   Modified to support Multiple ASI Ports  08-Nov-2011
34 *               Driver updated to support ASI Ports of AIC3262
35 *
36 * Modified by Nvidia 23-Nov-2011 for K39 ASoC changes.
37 */
38
39 /*
40  *****************************************************************************
41  * INCLUDES
42  *****************************************************************************
43  */
44 #include <linux/module.h>
45 #include <linux/moduleparam.h>
46 #include <linux/kernel.h>
47 #include <linux/init.h>
48 #include <linux/delay.h>
49 #include <linux/pm.h>
50 #include <linux/i2c.h>
51 #include <linux/platform_device.h>
52 #include <linux/slab.h>
53 #include <sound/core.h>
54 #include <sound/pcm.h>
55 #include <sound/pcm_params.h>
56 #include <sound/soc.h>
57 #include <sound/initval.h>
58 #include <sound/tlv.h>
59 #include <asm/div64.h>
60 #include <sound/tlv320aic326x.h>
61 #include <sound/jack.h>
62 #include <linux/spi/spi.h>
63
64 #include "tlv320aic326x.h"
65
66 /*
67  *****************************************************************************
68  * Global Variable
69  *****************************************************************************
70  */
71 static u8 aic3262_reg_ctl;
72
73 #ifdef AIC3262_TiLoad
74         extern int aic3262_driver_init(struct snd_soc_codec *codec);
75 #endif
76
77
78
79 /* whenever aplay/arecord is run, aic3262_hw_params() function gets called.
80  * This function reprograms the clock dividers etc. this flag can be used to
81  * disable this when the clock dividers are programmed by pps config file
82  */
83 static int soc_static_freq_config = 1;
84 static struct aic3262_priv *aic3262_priv_data;
85 static struct i2c_client *i2c_pdev;
86 static struct snd_soc_codec *aic3262_codec;
87
88 /*
89  *****************************************************************************
90  * Macros
91  *****************************************************************************
92  */
93
94 /* ASoC Widget Control definition for a single Register based Control */
95 #define SOC_SINGLE_AIC3262(xname) \
96 {\
97         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
98         .info = __new_control_info, .get = __new_control_get,\
99         .put = __new_control_put, \
100         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
101 }
102 #define SOC_SINGLE_N(xname, xreg, xshift, xmax, xinvert) \
103 {\
104         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
105         .info = n_control_info, .get = n_control_get,\
106         .put = n_control_put, \
107         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
108         .private_value =  ((unsigned long)&(struct soc_mixer_control)) \
109         {.reg = xreg, .shift = xshift, .rshift = xshift, .max = xmax, \
110         .invert = xinvert} }
111
112 /* ASoC Widget Control definition for a Double Register based Control */
113
114 #define SOC_DOUBLE_R_N(xname, reg_left, reg_right, xshift, xmax, xinvert) \
115 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
116         .info = snd_soc_info_volsw_2r_n, \
117         .get = snd_soc_get_volsw_2r_n, .put = snd_soc_put_volsw_2r_n, \
118         .private_value = (unsigned long)&(struct soc_mixer_control) \
119                 {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
120                 .max = xmax, .invert = xinvert} }
121
122 #define SND_SOC_DAPM_SWITCH_N(wname, wreg, wshift, winvert) \
123 {       .id = snd_soc_dapm_switch, .name = wname, .reg = wreg, .shift = wshift,\
124         .invert = winvert, .kcontrols = NULL, .num_kcontrols = 0}
125 /*
126  *****************************************************************************
127  * Function Prototype
128  *****************************************************************************
129  */
130 static int aic3262_set_bias_level(struct snd_soc_codec *codec,
131                                                 enum snd_soc_bias_level level);
132
133 static int __new_control_info(struct snd_kcontrol *kcontrol,
134                               struct snd_ctl_elem_info *uinfo);
135
136 static int __new_control_get(struct snd_kcontrol *kcontrol,
137                              struct snd_ctl_elem_value *ucontrol);
138
139 static int __new_control_put(struct snd_kcontrol *kcontrol,
140                              struct snd_ctl_elem_value *ucontrol);
141
142 static inline int aic3262_get_divs(int mclk, int rate);
143
144 static int aic3262_multi_i2s_hw_params(struct snd_pcm_substream *substream,
145                                 struct snd_pcm_hw_params *params,
146                                 struct snd_soc_dai *dai);
147
148 static int aic3262_multi_i2s_set_dai_sysclk(struct snd_soc_dai *codec_dai,
149                 int clk_id, unsigned int freq, int dir);
150 static int aic3262_multi_i2s_set_dai_pll(struct snd_soc_dai *codec_dai,
151                 int pll_id, int source, unsigned int freq_in,
152                 unsigned int freq_out);
153
154 static int aic3262_multi_i2s_asi1_set_dai_fmt(struct snd_soc_dai *codec_dai,
155                 unsigned int fmt);
156
157 static int aic3262_multi_i2s_asi2_set_dai_fmt(struct snd_soc_dai *codec_dai,
158                 unsigned int fmt);
159
160 static int aic3262_multi_i2s_asi3_set_dai_fmt(struct snd_soc_dai *codec_dai,
161                 unsigned int fmt);
162
163 static int aic3262_multi_i2s_asi1_mute(struct snd_soc_dai *dai, int mute);
164
165 static int aic3262_multi_i2s_asi2_mute(struct snd_soc_dai *dai, int mute);
166
167 static int aic3262_multi_i2s_asi3_mute(struct snd_soc_dai *dai, int mute);
168 #if 0
169 static const char *wclk1_pincontrol[] = {
170         "ASI1 Word Clock Input/Output", "CLKOUT output"};
171 static const char *dout1_pincontrol[] = {
172         "disabled", "ASI1 data output", "gpio", "clock out",
173         "INT1", "INT2", "SAR ADC interrupt"};
174
175 static const char *din1_pincontrol[] = {"disabled", "enabled"};
176
177 static const char *wclk2_pincontrol[] = {
178         "diabled", "ASI1 secondary wclk", "general purpose input",
179         "general purpose output", "clkout", "INT1 interrupt",
180         "IN2 interrupt", "output digital microphone",
181         "SAR ADC interrupt", "data output for ASI1"};
182
183 static const char *bclk2_pincontrol[] = {
184         "diabled", "ASI1 secondary wclk", "general purpose input",
185         "general purpose output", "clkout", "INT1 interrupt",
186         "IN2 interrupt", "output digital microphone",
187         "SAR ADC interrupt", "data output for ASI1"};
188
189 static const char *dout2_pincontrol[] = {
190         "disabled", "ASI2 Data Output", "General Purpose Output",
191         "INT1 Interrupt", "INT2 Interrupt", "SAR ADC interrupt",
192         "Output for digital microphone", "Data Output for ASI1"};
193
194 static const char *din2_pincontrol[] = {"disabled", "enabled"};
195
196 static const char *wclk3_pincontrol[] = {
197         "Disabled", "ASI3 WCLK", "General Purpose Input",
198         "General Purpose output", "Data Output for ASI1"};
199
200 static const char *bclk3_pincontrol[] = {
201         "Disabled", "ASI3 BCLK", "General Purpose Input",
202         "General Purpose output", "Data Output for ASI1"};
203
204 static const char *dout3_pincontrol[] = {
205         "disabled", "ASI3 data ooutput", "General Purpose Output",
206         "ASI1 Word Clock Output", "Data Output for ASI1"};
207
208 static const char *din3_pincontrol[] = {"disabled", "enabled"};
209
210 static const char *clkin[] = {
211         "mclk1", "bclk1", "gpio1", "pll_clk", "bclk2", "gpi1",
212         "hf_ref_clk", "hf_osc_clk", "mclk2", "gpio2", "gpi2"};
213
214 #endif
215 #ifdef DAC_INDEPENDENT_VOL
216 /*
217  *----------------------------------------------------------------------------
218  * Function : n_control_info
219  * Purpose  : This function is to initialize data for new control required to
220  *            program the AIC3262 registers.
221  *
222  *----------------------------------------------------------------------------
223  */
224 static int n_control_info(struct snd_kcontrol *kcontrol,
225                               struct snd_ctl_elem_info *uinfo)
226 {
227         struct soc_mixer_control *mc =
228                 (struct soc_mixer_control *)kcontrol->private_value;
229         int max = mc->max;
230         unsigned int shift = mc->shift;
231         unsigned int rshift = mc->rshift;
232
233         if (max == 1)
234                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
235         else
236                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
237
238         uinfo->count = shift == rshift ? 1 : 2;
239         uinfo->value.integer.min = 0;
240         uinfo->value.integer.max = max;
241         return 0;
242 }
243
244 /*
245  *----------------------------------------------------------------------------
246  * Function : n_control_get
247  * Purpose  : This function is to read data of new control for
248  *            program the AIC3262 registers.
249  *
250  *----------------------------------------------------------------------------
251  */
252 static int n_control_get(struct snd_kcontrol *kcontrol,
253                              struct snd_ctl_elem_value *ucontrol)
254 {
255         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
256         u32 val;
257         unsigned short mask, shift;
258         struct soc_mixer_control *mc =
259                 (struct soc_mixer_control *)kcontrol->private_value;
260         if (!strcmp(kcontrol->id.name, "Left DAC Volume")) {
261                 mask = AIC3262_8BITS_MASK;
262                 shift = 0;
263                 val = snd_soc_read(codec, mc->reg);
264                 ucontrol->value.integer.value[0] =
265                     (val <= 48) ? (val + 127) : (val - 129);
266         }
267         if (!strcmp(kcontrol->id.name, "Right DAC Volume")) {
268                 mask = AIC3262_8BITS_MASK;
269                 shift = 0;
270                 val = snd_soc_read(codec, mc->reg);
271                 ucontrol->value.integer.value[0] =
272                     (val <= 48) ? (val + 127) : (val - 129);
273         }
274
275         return 0;
276 }
277
278 /*
279  *----------------------------------------------------------------------------
280  * Function : __new_control_put
281  * Purpose  : new_control_put is called to pass data from user/application to
282  *            the driver.
283  *
284  *----------------------------------------------------------------------------
285  */
286 static int n_control_put(struct snd_kcontrol *kcontrol,
287                              struct snd_ctl_elem_value *ucontrol)
288 {
289         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
290         struct soc_mixer_control *mc =
291                 (struct soc_mixer_control *)kcontrol->private_value;
292         u8 val, val_mask;
293         int reg, err;
294         unsigned int invert = mc->invert;
295         int max = mc->max;
296         DBG("n_control_put\n");
297         reg = mc->reg;
298         val = ucontrol->value.integer.value[0];
299         if (invert)
300                 val = max - val;
301         if (!strcmp(kcontrol->id.name, "Left DAC Volume")) {
302                 DBG("LDAC\n");
303                 val = (val >= 127) ? (val - 127) : (val + 129);
304                 val_mask = AIC3262_8BITS_MASK;
305         }
306         if (!strcmp(kcontrol->id.name, "Right DAC Volume")) {
307                 DBG("RDAC\n");
308                 val = (val >= 127) ? (val - 127) : (val + 129);
309                 val_mask = AIC3262_8BITS_MASK;
310         }
311
312         err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
313         if (err < 0) {
314                 printk(KERN_ERR "Error while updating bits\n");
315                 return err;
316         }
317
318         return 0;
319 }
320 #endif /*#ifdef DAC_INDEPENDENT_VOL*/
321 /*
322  *------------------------------------------------------------------------------
323  * snd_soc_info_volsw_2r_n - double mixer info callback
324  * @kcontrol: mixer control
325  * @uinfo: control element information
326  *
327  * Callback to provide information about a double mixer control that
328  * spans 2 codec registers.
329  *
330  * Returns 0 for success.
331  *------------------------------------------------------------------------------
332  */
333 int snd_soc_info_volsw_2r_n(struct snd_kcontrol *kcontrol,
334         struct snd_ctl_elem_info *uinfo)
335 {
336         struct soc_mixer_control *mc =
337                 (struct soc_mixer_control *)kcontrol->private_value;
338         int max = mc->max;
339
340         if (max == 1)
341                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
342         else
343                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
344
345         uinfo->count = 2;
346         uinfo->value.integer.min = 0;
347         uinfo->value.integer.max = max;
348         return 0;
349 }
350
351 /*
352  *------------------------------------------------------------------------------
353  * snd_soc_get_volsw_2r_n - double mixer get callback
354  * @kcontrol: mixer control
355  * @ucontrol: control element information
356  *
357  * Callback to get the value of a double mixer control that spans 2 registers.
358  *
359  * Returns 0 for success.
360  *------------------------------------------------------------------------------
361  */
362 int snd_soc_get_volsw_2r_n(struct snd_kcontrol *kcontrol,
363         struct snd_ctl_elem_value *ucontrol)
364 {
365         struct soc_mixer_control *mc =
366                 (struct soc_mixer_control *)kcontrol->private_value;
367         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
368         unsigned int reg = mc->reg;
369         unsigned int reg2 = mc->rreg;
370         unsigned int shift = mc->shift;
371         int max = mc->max;
372         unsigned int mask;
373         unsigned int invert = mc->invert;
374         unsigned short val, val2;
375
376         if (!strcmp(kcontrol->id.name, "PCM Playback Volume")) {
377                 mask = AIC3262_8BITS_MASK;
378                 shift = 0;
379         } else if (!strcmp(kcontrol->id.name, "HP Driver Gain")) {
380                 mask = 0x3F;
381                 shift = 0;
382         } else if (!strcmp(kcontrol->id.name, "PGA Capture Volume")) {
383                 mask = 0x7F;
384                 shift = 0;
385         } else if (!strcmp(kcontrol->id.name, "REC Driver Volume")) {
386                 mask = 0x3F;
387                 shift = 0;
388         } else if (!strcmp(kcontrol->id.name, "LO to HP Volume")) {
389                 mask = 0x7F;
390                 shift = 0;
391         } else if (!strcmp(kcontrol->id.name, "MA Volume")) {
392                 mask = 0x7F;
393                 shift = 0;
394         } else {
395                 printk(KERN_ERR "Invalid kcontrol name\n");
396                 return -1;
397         }
398
399         /* Read, update the corresponding Registers */
400         val = (snd_soc_read(codec, reg) >> shift) & mask;
401         val2 = (snd_soc_read(codec, reg2) >> shift) & mask;
402
403         if (!strcmp(kcontrol->id.name, "PCM Playback Volume")) {
404                 ucontrol->value.integer.value[0] =
405                     (val <= 48) ? (val + 127) : (val - 129);
406                 ucontrol->value.integer.value[1] =
407                     (val2 <= 48) ? (val2 + 127) : (val2 - 129);
408         } else if (!strcmp(kcontrol->id.name, "HP Driver Gain")) {
409                 ucontrol->value.integer.value[0] =
410                     (val >= 57) ? (val - 57) : (val + 7);
411                 ucontrol->value.integer.value[1] =
412                     (val2 >= 57) ? (val2 - 57) : (val2 + 7);
413         } else if (!strcmp(kcontrol->id.name, "PGA Capture Volume")) {
414                 ucontrol->value.integer.value[0] =
415                     (val <= 40) ? (val + 24) : (val - 104);
416                 ucontrol->value.integer.value[1] =
417                     (val2 <= 40) ? (val2 + 24) : (val2 - 104);
418         } else if (!strcmp(kcontrol->id.name, "REC Driver Volume")) {
419                 ucontrol->value.integer.value[0] = ((val >= 0) & (val <= 29)) ?
420                                                  (val + 7) : (val - 57);
421                 ucontrol->value.integer.value[1] = ((val2 >= 0) &
422                     (val2 <= 29)) ? (val2 + 7) : (val2 - 57);
423
424         } else if (!strcmp(kcontrol->id.name, "LO to HP Volume")) {
425                 ucontrol->value.integer.value[0] = ((val >= 0) & (val <= 116)) ?
426                                  (val + 1) : ((val == 127) ? (0) : (117));
427                 ucontrol->value.integer.value[1] = ((val2 >= 0) & (val2 <= 116))
428                                  ? (val2 + 1) : ((val2 == 127) ? (0) : (117));
429
430         } else if (!strcmp(kcontrol->id.name, "MA Volume")) {
431                 ucontrol->value.integer.value[0] = (val <= 40) ?
432                                          (41 - val) : (val = 0);
433                 ucontrol->value.integer.value[1] = (val2 <= 40) ?
434                                          (41 - val2) : (val2 = 0);
435         }
436
437         if (invert) {
438                 ucontrol->value.integer.value[0] =
439                         max - ucontrol->value.integer.value[0];
440                 ucontrol->value.integer.value[1] =
441                         max - ucontrol->value.integer.value[1];
442         }
443
444         return 0;
445 }
446 /*
447 *-------------------------------------------------------------------------------
448 * snd_soc_put_volsw_2r_n - double mixer set callback
449 * @kcontrol: mixer control
450 * @ucontrol: control element information
451 *
452 * Callback to set the value of a double mixer control that spans 2 registers.
453 *
454 * Returns 0 for success.
455 *-------------------------------------------------------------------------------
456 */
457 int snd_soc_put_volsw_2r_n(struct snd_kcontrol *kcontrol,
458         struct snd_ctl_elem_value *ucontrol)
459 {
460         struct soc_mixer_control *mc =
461                 (struct soc_mixer_control *)kcontrol->private_value;
462         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
463         unsigned int reg = mc->reg;
464         unsigned int reg2 = mc->rreg;
465         unsigned int shift = mc->shift;
466         int max = mc->max;
467         unsigned int mask;
468         unsigned int invert = mc->invert;
469         int err;
470         unsigned short val, val2, val_mask;
471
472         mask = 0x00FF;
473
474         val = (ucontrol->value.integer.value[0] & mask);
475         val2 = (ucontrol->value.integer.value[1] & mask);
476         if (invert) {
477                 val = max - val;
478                 val2 = max - val2;
479         }
480
481         /* Check for the string name of the kcontrol */
482         if (!strcmp(kcontrol->id.name, "PCM Playback Volume")) {
483                 val = (val >= 127) ? (val - 127) : (val + 129);
484                 val2 = (val2 >= 127) ? (val2 - 127) : (val2 + 129);
485                 val_mask = AIC3262_8BITS_MASK;  /* 8 bits */
486         } else if ((!strcmp(kcontrol->id.name, "HP Driver Gain")) ||
487                    (!strcmp(kcontrol->id.name, "LO Driver Gain"))) {
488                 val = (val <= 6) ? (val + 57) : (val - 7);
489                 val2 = (val2 <= 6) ? (val2 + 57) : (val2 - 7);
490                 val_mask = 0x3F;        /* 6 bits */
491                 DBG("val=%d, val2=%d", val, val2);
492         } else if (!strcmp(kcontrol->id.name, "PGA Capture Volume")) {
493                 val = (val >= 24) ? ((val <= 64) ?
494                         (val-24) : (40)) : (val + 104);
495                 val2 = (val2 >= 24) ?
496                         ((val2 <= 64) ? (val2 - 24) : (40)) : (val2 + 104);
497                 val_mask = 0x7F;        /* 7 bits */
498         } else if (!strcmp(kcontrol->id.name, "LO to REC Volume")) {
499
500                 val = (val <= 116) ?
501                          (val % 116) : ((val == 117) ? (127) : (117));
502                 val2 = (val2 <= 116) ?
503                         (val2 % 116) : ((val2 == 117) ? (127) : (117));
504                 val_mask = 0x7F;
505         } else if (!strcmp(kcontrol->id.name, "REC Driver Volume")) {
506
507                 val = (val <= 7) ? (val + 57) : ((val < 36) ? (val - 7) : (29));
508                 val2 = (val2 <= 7) ?
509                                 (val2 + 57) : ((val2 < 36) ? (val2 - 7) : (29));
510                 val_mask = 0x3F;
511         } else if (!strcmp(kcontrol->id.name, "LO to HP Volume")) {
512
513                 val = ((val > 0) & (val <= 117)) ?
514                          (val - 1) : ((val == 0) ? (127) : (116));
515                 val2 = ((val2 > 0) & (val2 <= 117)) ?
516                          (val2 - 1) : ((val2 == 0) ? (127) : (116));
517                 val_mask = 0x7F;
518         } else if (!strcmp(kcontrol->id.name, "MA Volume")) {
519
520                 val = ((val <= 41) & (val > 0)) ?
521                          (41 - val) : ((val > 41) ? (val = 41) : (63));
522                 val2 = ((val2 <= 41) & (val2 > 0)) ?
523                          (41 - val2) : ((val2 > 41) ? (val2 = 41) : (63));
524                 val_mask = 0x7F;
525         } else {
526                 printk(KERN_ERR "Invalid control name\n");
527                 return -1;
528         }
529
530         val = val << shift;
531         val2 = val2 << shift;
532
533         err = snd_soc_update_bits_locked(codec, reg, val_mask, val);
534         if (err < 0)
535                 return err;
536
537         err = snd_soc_update_bits_locked(codec, reg2, val_mask, val2);
538         return err;
539 }
540
541 static int __new_control_info(struct snd_kcontrol *kcontrol,
542                               struct snd_ctl_elem_info *uinfo)
543 {
544         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
545         uinfo->count = 1;
546         uinfo->value.integer.min = 0;
547         uinfo->value.integer.max = 65535;
548
549         return 0;
550 }
551
552 /*
553  *----------------------------------------------------------------------------
554  * Function : __new_control_get
555  * Purpose  : This function is to read data of new control for
556  *            program the AIC3262 registers.
557  *
558  *----------------------------------------------------------------------------
559  */
560 static int __new_control_get(struct snd_kcontrol *kcontrol,
561                              struct snd_ctl_elem_value *ucontrol)
562 {
563         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
564         u32 val;
565         val = snd_soc_read(codec, aic3262_reg_ctl);
566         ucontrol->value.integer.value[0] = val;
567         return 0;
568 }
569
570 /*
571  *----------------------------------------------------------------------------
572  * Function : __new_control_put
573  * Purpose  : new_control_put is called to pass data from user/application to
574  *            the driver.
575  *
576  *----------------------------------------------------------------------------
577  */
578 static int __new_control_put(struct snd_kcontrol *kcontrol,
579                              struct snd_ctl_elem_value *ucontrol)
580 {
581         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
582         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
583         u8 data[2];
584         int ret = 0;
585
586         u32 data_from_user = ucontrol->value.integer.value[0];
587
588         aic3262_change_book(codec, 0);
589         aic3262_reg_ctl = data[0] = (u8) ((data_from_user & 0xFF00) >> 8);
590         data[1] = (u8) ((data_from_user & 0x00FF));
591
592         if (!data[0])
593                 aic3262->page_no = data[1];
594
595         DBG("reg = %d val = %x\n", data[0], data[1]);
596 #if defined(LOCAL_REG_ACCESS)
597         if (codec->hw_write(codec->control_data, data, 2) != 2)
598                 ret = -EIO;
599 #else
600         ret = snd_soc_write(codec, data[0], data[1]);
601 #endif
602         if (ret)
603                 printk(KERN_ERR "Error in i2c write\n");
604
605         return ret;
606 }
607
608
609 /*
610  *****************************************************************************
611  * Structure Initialization
612  *****************************************************************************
613  */
614 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -6350, 50, 0);
615 static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -1200, 50, 0);
616 static const DECLARE_TLV_DB_SCALE(spk_gain_tlv, 600, 600, 0);
617 static const DECLARE_TLV_DB_SCALE(output_gain_tlv, -600, 100, 0);
618 static const DECLARE_TLV_DB_SCALE(micpga_gain_tlv, 0, 50, 0);
619 static const DECLARE_TLV_DB_SCALE(adc_fine_gain_tlv, -40, 10, 0);
620 static const DECLARE_TLV_DB_SCALE(beep_gen_volume_tlv, -6300, 100, 0);
621
622 /* Chip-level Input and Output CM Mode Controls */
623 static const char *input_common_mode_text[] = {
624     "0.9v", "0.75v" };
625
626 static const char *output_common_mode_text[] = {
627     "Input CM", "1.25v", "1.5v", "1.65v" };
628
629 static const struct soc_enum input_cm_mode =
630     SOC_ENUM_SINGLE(CM_REG, 2, 2, input_common_mode_text);
631
632 static const struct soc_enum output_cm_mode =
633     SOC_ENUM_SINGLE(CM_REG, 0, 4, output_common_mode_text);
634
635
636 /*
637  *****************************************************************************
638  * Structure Initialization
639  *****************************************************************************
640  */
641 static const struct snd_kcontrol_new aic3262_snd_controls[] = {
642         /* Output */
643 #ifndef DAC_INDEPENDENT_VOL
644         /* sound new kcontrol for PCM Playback volume control */
645
646         SOC_DOUBLE_R_SX_TLV("PCM Playback Volume",
647                         DAC_LVOL, DAC_RVOL, 8,0xffffff81, 0x30, dac_vol_tlv),
648 #endif
649         /*HP Driver Gain Control*/
650         SOC_DOUBLE_R_SX_TLV("HeadPhone Driver Amplifier Volume",
651                         HPL_VOL, HPR_VOL, 6, 0xfffffffa, 0xe, output_gain_tlv),
652
653         /*LO Driver Gain Control*/
654         SOC_DOUBLE_TLV("Speaker Amplifier Volume",
655                                 SPK_AMP_CNTL_R4, 4, 0, 5, 0, spk_gain_tlv),
656
657         SOC_DOUBLE_R_SX_TLV("Receiver Amplifier Volume",
658         REC_AMP_CNTL_R5, RAMPR_VOL, 6, 0xfffffffa, 0x1d, output_gain_tlv),
659
660         SOC_DOUBLE_R_SX_TLV("PCM Capture Volume",
661                 LADC_VOL, RADC_VOL, 7,0xffffff68, 0x24, adc_vol_tlv),
662
663
664         SOC_DOUBLE_R_TLV ("MicPGA Volume Control",
665                 MICL_PGA, MICR_PGA, 0, 0x5F, 0, micpga_gain_tlv),
666         SOC_DOUBLE_TLV("PCM Capture Fine Gain Volume",
667                 ADC_FINE_GAIN, 4, 0, 5, 1, adc_fine_gain_tlv),
668
669         SOC_DOUBLE("ADC channel mute", ADC_FINE_GAIN, 7, 3, 1, 0),
670
671         SOC_DOUBLE("DAC MUTE", DAC_MVOL_CONF, 2, 3, 1, 1),
672
673         /* sound new kcontrol for Programming the registers from user space */
674         SOC_SINGLE_AIC3262("Program Registers"),
675
676         SOC_SINGLE("RESET", RESET_REG, 0,1,0),
677
678         SOC_SINGLE("DAC VOL SOFT STEPPING", DAC_MVOL_CONF, 0, 2, 0),
679
680 #ifdef DAC_INDEPENDENT_VOL
681         /*SOC_SINGLE_N("Left DAC Volume", DAC_LVOL, 0, 0xAF, 0),
682         SOC_SINGLE_N("Right DAC Volume", DAC_RVOL, 0, 0xAF, 0),*/
683 #endif
684
685         SOC_SINGLE("DAC AUTO MUTE CONTROL", DAC_MVOL_CONF, 4, 7, 0),
686         SOC_SINGLE("RIGHT MODULATOR SETUP", DAC_MVOL_CONF, 7, 1, 0),
687
688         SOC_SINGLE("ADC Volume soft stepping", ADC_CHANNEL_POW, 0, 3, 0),
689
690         SOC_DOUBLE_R("MICPGA enable/disable",MICL_PGA,MICR_PGA,7, 1, 0),
691
692         SOC_SINGLE("Mic Bias ext independent enable", MIC_BIAS_CNTL, 7, 1, 0),
693         SOC_SINGLE("MICBIAS_EXT ON", MIC_BIAS_CNTL, 6, 1, 0),
694         SOC_SINGLE("MICBIAS EXT Power Level", MIC_BIAS_CNTL, 4, 3, 0),
695
696         SOC_SINGLE("MICBIAS_INT ON", MIC_BIAS_CNTL, 2, 1, 0),
697         SOC_SINGLE("MICBIAS INT Power Level", MIC_BIAS_CNTL, 0, 3, 0),
698
699         SOC_DOUBLE("DRC_EN_CTL", DRC_CNTL_R1, 6, 5, 1, 0),
700         SOC_SINGLE("DRC_THRESHOLD_LEVEL", DRC_CNTL_R1, 2, 7, 1),
701         SOC_SINGLE("DRC_HYSTERISIS_LEVEL", DRC_CNTL_R1, 0, 7, 0),
702
703         SOC_SINGLE("DRC_HOLD_LEVEL", DRC_CNTL_R2, 3, 0x0F, 0),
704         SOC_SINGLE("DRC_GAIN_RATE", DRC_CNTL_R2, 0, 4, 0),
705         SOC_SINGLE("DRC_ATTACK_RATE", DRC_CNTL_R3, 4, 0x0F, 1),
706         SOC_SINGLE("DRC_DECAY_RATE", DRC_CNTL_R3, 0, 0x0F, 1),
707
708         SOC_SINGLE("BEEP_GEN_EN", BEEP_CNTL_R1, 7, 1, 0),
709         SOC_DOUBLE_R("BEEP_VOL_CNTL", BEEP_CNTL_R1, BEEP_CNTL_R2, 0, 0x0F, 1),
710         SOC_SINGLE("BEEP_MAS_VOL", BEEP_CNTL_R2, 6, 3, 0),
711
712         SOC_DOUBLE_R("AGC_EN", LAGC_CNTL, RAGC_CNTL, 7, 1, 0),
713         SOC_DOUBLE_R("AGC_TARGET_LEVEL", LAGC_CNTL, RAGC_CNTL, 4, 7, 1),
714
715         SOC_DOUBLE_R("AGC_GAIN_HYSTERESIS", LAGC_CNTL, RAGC_CNTL, 0, 3, 0),
716         SOC_DOUBLE_R("AGC_HYSTERESIS", LAGC_CNTL_R2, RAGC_CNTL_R2, 6, 3, 0),
717         SOC_DOUBLE_R("AGC_NOISE_THRESHOLD", LAGC_CNTL_R2,
718                                                 RAGC_CNTL_R2, 1, 31, 1),
719
720         SOC_DOUBLE_R("AGC_MAX_GAIN", LAGC_CNTL_R3, RAGC_CNTL_R3, 0, 116, 0),
721         SOC_DOUBLE_R("AGC_ATCK_TIME", LAGC_CNTL_R4, RAGC_CNTL_R4, 3, 31, 0),
722         SOC_DOUBLE_R("AGC_ATCK_SCALE_FACTOR",
723                                 LAGC_CNTL_R4, RAGC_CNTL_R4, 0, 7, 0),
724
725         SOC_DOUBLE_R("AGC_DECAY_TIME", LAGC_CNTL_R5, RAGC_CNTL_R5, 3, 31, 0),
726         SOC_DOUBLE_R("AGC_DECAY_SCALE_FACTOR",
727                                 LAGC_CNTL_R5, RAGC_CNTL_R5, 0, 7, 0),
728         SOC_DOUBLE_R("AGC_NOISE_DEB_TIME", LAGC_CNTL_R6,
729                                                 RAGC_CNTL_R6, 0, 31, 0),
730
731         SOC_DOUBLE_R("AGC_SGL_DEB_TIME", LAGC_CNTL_R7,
732                                         RAGC_CNTL_R7, 0, 0x0F, 0),
733
734         SOC_SINGLE("DAC PRB Selection",DAC_PRB, 0, 25, 0),
735
736         SOC_SINGLE("INTERRUPT FLAG - Read only", 46, 0, 255,0),
737         SOC_SINGLE("INTERRUPT STICKY FLAG - Read only", 44, 0, 255,0),
738         SOC_SINGLE("INT1 CONTROL", 48, 0, 255,0),
739         SOC_SINGLE("GPIO1 CONTROL", GPIO1_IO_CNTL, 0, 255,0),
740         SOC_SINGLE("HP_DEPOP", HP_DEPOP, 0, 255,0),
741         SOC_DOUBLE("IN1 LO BYPASS VOLUME" , LINE_AMP_CNTL_R2, 3, 0, 3, 1),
742
743         SOC_ENUM("Input CM mode", input_cm_mode),
744         SOC_ENUM("Output CM mode", output_cm_mode),
745 };
746
747
748 /* the sturcture contains the different values for mclk */
749 static const struct aic3262_rate_divs aic3262_divs[] = {
750 /*
751  * mclk, rate, p_val, pll_j, pll_d, dosr, ndac, mdac, aosr, nadc, madc, blck_N,
752  * codec_speficic_initializations
753  */
754         /* 8k rate */
755 #ifdef CONFIG_MINI_DSP
756         {12000000, 8000, 1, 8, 1920, 768, 8, 2, 128, 8, 12, 4,
757                 {{0, 60, 0}, {0, 61, 0} } },
758 #else
759         {12000000, 8000, 1, 8, 1920, 128, 12, 8, 128, 8, 6, 4,
760                 {{0, 60, 1}, {0, 61, 1} } },
761         {12288000, 8000, 1, 1, 3333, 128, 12, 8, 128, 8, 6, 4,
762                 {{0, 60, 1}, {0, 61, 1} } },
763         {24000000, 8000, 1, 4, 96, 128, 12, 8, 128, 12, 8, 4,
764                 {{0, 60, 1}, {0, 61, 1} } },
765 #endif
766         /* 11.025k rate */
767         {12000000, 11025, 1, 1, 8816, 1024, 8, 2, 128, 8, 2, 48,
768                 {{0, 60, 1}, {0, 61, 1} } },
769         {12288000, 11025, 1, 1, 8375, 1024, 8, 2, 128, 8, 2, 48,
770                 {{0, 60, 1}, {0, 61, 1} } },
771         {24000000, 11025, 1, 3, 7632, 128, 8, 8, 128, 8, 8, 4,
772                 {{0, 60, 1}, {0, 61, 1} } },
773
774         /* 16k rate */
775 #ifdef CONFIG_MINI_DSP
776         {12000000, 16000, 1, 8, 1920, 384, 4, 4, 128, 4, 12, 12,
777                 {{0, 60, 0}, {0, 61, 0} } },
778 #else
779         {12000000, 16000, 1, 8, 1920, 128, 8, 6, 128, 8, 6, 4,
780                 {{0, 60, 1}, {0, 61, 1} } },
781         {12288000, 16000, 1, 2, 6667, 128, 8, 6, 128, 8, 6, 4,
782                 {{0, 60, 1}, {0, 61, 1} } },
783         {24000000, 16000, 1, 4, 96, 128, 8, 6, 128, 8, 6, 4,
784                 {{0, 60, 1}, {0, 61, 1} } },
785 #endif
786         /* 22.05k rate */
787         {12000000, 22050, 1, 3, 7632, 128, 8, 2, 128, 8, 2, 4,
788                 {{0, 60, 1}, {0, 61, 1} } },
789         {12288000, 22050, 1, 3, 675, 128, 8, 2, 128, 8, 2, 4,
790                 {{0, 60, 1}, {0, 61, 1} } },
791         {24000000, 22050, 1, 3, 7632, 128, 8, 3, 128, 8, 3, 4,
792                 {{0, 60, 1}, {0, 61, 1} } },
793         /* 32k rate */
794         {12000000, 32000, 1, 5, 4613, 128, 8, 2, 128, 8, 2, 4,
795                 {{0, 60, 1}, {0, 61, 1} } },
796         {12288000, 32000, 1, 5, 3333, 128, 8, 2, 128, 8, 2, 4,
797                 {{0, 60, 1}, {0, 61, 1} } },
798         {24000000, 32000, 1, 4, 96, 128, 6, 4, 128, 6, 4, 4,
799                 {{0, 60, 1}, {0, 61, 1} } },
800
801 #ifdef CONFIG_MINI_DSP
802         {12000000, 44100, 1, 7, 5264, 128, 2, 8, 128, 2, 8, 4,
803                 {{0, 60, 0}, {0, 61, 0} } },
804         {12288000, 44100, 1, 7, 3548, 128, 2, 8, 128, 8, 2, 4,
805                 {{0, 60, 0}, {0, 61, 0} } },
806 #else
807         /* 44.1k rate */
808         {12000000, 44100, 1, 7, 5264, 128, 8, 2, 128, 8, 2, 4,
809                 {{0, 60, 1}, {0, 61, 1} } },
810         {12288000, 44100, 1, 7, 3548, 128, 8, 2, 128, 8, 2, 4,
811                 {{0, 60, 1}, {0, 61, 1} } },
812         {24000000, 44100, 1, 3, 7632, 128, 4, 4, 64, 4, 4, 4,
813                 {{0, 60, 1}, {0, 61, 1} } },
814 #endif
815
816 #ifdef CONFIG_MINI_DSP
817         {12288000, 48000, 1, 8, 52, 128, 2, 8, 128, 2, 8, 4,
818                 {{0, 60, 0}, {0, 61, 0} } },
819 #else
820         /* 48k rate */
821         {12000000, 48000, 1, 8, 1920, 128, 8, 2, 128, 8, 2, 4,
822                 {{0, 60, 1}, {0, 61, 1} } },
823         {12288000, 48000, 1, 8, 52, 128, 8, 2, 128, 8, 2, 4,
824                 {{0, 60, 1}, {0, 61, 1} } },
825         {24000000, 48000, 1, 4, 960, 128, 4, 4, 128, 4, 4, 4,
826                 {{0, 60, 1}, {0, 61, 1} } },
827 #endif
828
829         /*96k rate */
830         {12000000, 96000, 1, 16, 3840, 128, 8, 2, 128, 8, 2 , 4,
831                 {{0, 60, 7}, {0, 61, 7} } },
832         {24000000, 96000, 1, 4, 960, 128, 4, 2, 128, 4, 2, 2,
833                 {{0, 60, 7}, {0, 61, 7} } },
834         /*192k */
835         {12000000, 192000, 1, 32, 7680, 128, 8, 2, 128, 8, 2, 4,
836                 {{0, 60, 17}, {0, 61, 13} } },
837         {24000000, 192000, 1, 4, 960, 128, 2, 2, 128, 2, 2, 4,
838                 {{0, 60, 17}, {0, 61, 13} } },
839 };
840
841
842
843 /*
844 *----------------------------------------------------------------------------
845 * Function : aic3262_multi_i2s_dump_regs
846 * Purpose  : This function is to mute or unmute the left and right DAC
847 *
848 *----------------------------------------------------------------------------
849 */
850 static void aic3262_multi_i2s_dump_regs(struct snd_soc_dai *dai)
851 {
852         struct snd_soc_codec *codec = dai->codec;
853         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
854         unsigned int counter;
855
856         DBG(KERN_INFO "#%s: Dai Active %d ASI%d REGS DUMP\n",
857                 __func__, aic3262->active_count, dai->id);
858
859         aic3262_change_page(codec, 0);
860         aic3262_change_book(codec, 0);
861
862         DBG(KERN_INFO "#Page0 REGS..\n");
863         for (counter = 0; counter < 85; counter++) {
864                 DBG(KERN_INFO "#%2d -> 0x%x\n", counter,
865                         snd_soc_read(codec, counter));
866         }
867
868         DBG(KERN_INFO "#Page1 REGS..\n");
869         for (counter = 128; counter < 176; counter++) {
870                 DBG(KERN_INFO "#%2d -> 0x%x\n", (counter % 128),
871                         snd_soc_read(codec, counter));
872         }
873
874         DBG(KERN_INFO "#Page4 REGS..\n");
875         for (counter = 512; counter < 631; counter++) {
876                 DBG(KERN_INFO "#%2d -> 0x%x\n",
877                         (counter % 128), snd_soc_read(codec, counter));
878         }
879
880         for (counter = 0; counter < MAX_ASI_COUNT; counter++) {
881                 DBG(KERN_INFO "#ASI%d Frame %s @ %dHz Playback %d Record %d\n",
882                 (counter + 1),
883                 (aic3262->asiCtxt[counter].master == 1) ? "Master" : "Slave",
884                 aic3262->asiCtxt[counter].sampling_rate,
885                 aic3262->asiCtxt[counter].playback_mode,
886                 aic3262->asiCtxt[counter].capture_mode);
887                 DBG(KERN_INFO "#DAC Option [%d,%d] ADC Option %d WLEN %d\n\n",
888                 aic3262->asiCtxt[counter].left_dac_output,
889                 aic3262->asiCtxt[counter].right_dac_output,
890                 aic3262->asiCtxt[counter].adc_input,
891                 aic3262->asiCtxt[counter].word_len);
892         }
893         return;
894 }
895
896 /*
897  *----------------------------------------------------------------------------
898  * Function : aic3262_multi_i2s_mute
899  * Purpose  : This function is to mute or unmute the left and right DAC
900  *
901  *----------------------------------------------------------------------------
902  */
903 static int aic3262_multi_i2s_mute(struct snd_soc_dai *dai, int mute)
904 {
905         struct snd_soc_codec *codec = dai->codec;
906         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
907
908         DBG(KERN_INFO "#%s : mute entered with %d\n", __func__, mute);
909
910         /* If we are doing both Recording and Playback on this DAI interface,
911         * do not MUTE the Codec.
912         */
913         if (mute && (aic3262->asiCtxt[dai->id - 1].asi_active > 1)) {
914                 DBG("#%s Cannot Mute the ASI%d Now..\n",
915                         __func__, dai->id);
916         } else {
917                 switch (dai->id) {
918                 case 1:
919                         aic3262_multi_i2s_asi1_mute(dai, mute);
920                 break;
921                 case 2:
922                         aic3262_multi_i2s_asi2_mute(dai, mute);
923                 break;
924                 case 3:
925                         aic3262_multi_i2s_asi3_mute(dai, mute);
926                 break;
927                 default:
928                         printk(KERN_ERR "#%s: Invalid DAI id\n", __func__);
929                         return -EINVAL;
930                 }
931         }
932         DBG(KERN_INFO "#%s : mute ended\n", __func__);
933         return 0;
934 }
935
936
937 /*
938 *----------------------------------------------------------------------------
939 * Function : aic3262_multi_i2s_asi1_mute
940 * Purpose  : This function is to mute or unmute the left and right DAC
941 *
942 *----------------------------------------------------------------------------
943 */
944 static int aic3262_multi_i2s_asi1_mute(struct snd_soc_dai *dai, int mute)
945 {
946         struct snd_soc_codec *codec = dai->codec;
947         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
948
949         DBG(KERN_INFO "#%s : mute %d started\n", __func__, mute);
950
951         if (mute && !aic3262->asiCtxt[0].port_muted ) {
952                 DBG(KERN_INFO "Mute if part\n");
953
954
955         snd_soc_update_bits(codec, DAC_MVOL_CONF, DAC_LR_MUTE_MASK,DAC_LR_MUTE);
956
957                 /* First check if both Playback and Recording is going on
958                 * this interface.
959                 */
960                 if (aic3262->asiCtxt[0].asi_active > 1) {
961                         DBG("#%s Cannot Mute the ASI Now..\n", __func__);
962                 } else if (!(aic3262->asiCtxt[1].playback_mode) &&
963                         !(aic3262->asiCtxt[2].playback_mode)) {
964                         /* Before Muting, please check if any other
965                         * ASI is active. if so, we cannot simply mute the
966                         * DAC and ADC Registers.
967                         */
968                 DBG("#%s None of the ASI's are active now..\n", __func__);
969                         snd_soc_write(codec, DAC_MVOL_CONF,
970                                 ((aic3262->dac_reg & 0xF3) | 0x0C));
971                         snd_soc_write(codec, ADC_FINE_GAIN,
972                                 ((aic3262->adc_gain & 0x77) | 0x88));
973                         snd_soc_write(codec, HPL_VOL, 0xB9);
974                         snd_soc_write(codec, HPR_VOL, 0xB9);
975                         snd_soc_write(codec, REC_AMP_CNTL_R5, 0x39);
976                         snd_soc_write(codec, RAMPR_VOL, 0x39);
977                         snd_soc_write(codec, SPK_AMP_CNTL_R4, 0x00);
978                         aic3262->asiCtxt[0].port_muted = 1;
979                 }
980         } else {
981                 DBG(KERN_INFO "Mute else part\n");
982                 snd_soc_update_bits(codec, DAC_MVOL_CONF,
983                                                 DAC_LR_MUTE_MASK, 0x0);
984                 snd_soc_write(codec, ADC_FINE_GAIN,(0X00 & 0x77) | 0x0);
985                 aic3262_multi_i2s_dump_regs(dai);
986         }
987
988         DBG(KERN_INFO "#%s : mute %d ended\n", __func__, mute);
989
990         return 0;
991 }
992
993 /*
994 *----------------------------------------------------------------------------
995 * Function : aic3262_multi_i2s_asi2_maic3262_asi3_clk_configute
996 * Purpose : This function is to mute or unmute the left and right DAC
997 *
998 *----------------------------------------------------------------------------
999 */
1000 static int aic3262_multi_i2s_asi2_mute(struct snd_soc_dai *dai, int mute)
1001 {
1002         struct snd_soc_codec *codec = dai->codec;
1003         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1004
1005         DBG(KERN_INFO "#%s : mute %d started\n", __func__, mute);
1006
1007         if (mute && !aic3262->asiCtxt[1].port_muted ) {
1008                 DBG(KERN_INFO "Mute if part\n");
1009         snd_soc_update_bits(codec, DAC_MVOL_CONF, DAC_LR_MUTE_MASK,DAC_LR_MUTE);
1010
1011                 /* First check if both Playback and Recording is going on
1012                 * this interface.
1013                 */
1014                 if (aic3262->asiCtxt[1].asi_active > 1) {
1015                         DBG("#%s Cannot Mute the ASI Now..\n", __func__);
1016                 } else if (!(aic3262->asiCtxt[0].playback_mode) &&
1017                         !(aic3262->asiCtxt[2].playback_mode)) {
1018                         /* Before Muting, please check if any other
1019                         * ASI is active. if so, we cannot simply mute the
1020                         * DAC and ADC Registers.
1021                         */
1022                         snd_soc_write(codec, DAC_MVOL_CONF,
1023                                 ((aic3262->dac_reg & 0xF3) | 0x0C));
1024                         snd_soc_write(codec, ADC_FINE_GAIN,
1025                                 ((aic3262->adc_gain & 0x77) | 0x88));
1026                         snd_soc_write(codec, HPL_VOL, 0xB9);
1027                         snd_soc_write(codec, HPR_VOL, 0xB9);
1028                         snd_soc_write(codec, REC_AMP_CNTL_R5, 0x39);
1029                         snd_soc_write(codec, RAMPR_VOL, 0x39);
1030                         snd_soc_write(codec, SPK_AMP_CNTL_R4, 0x00);
1031                         aic3262->asiCtxt[1].port_muted = 1;
1032                 }
1033         } else {
1034                 DBG(KERN_INFO "Mute else part\n");
1035                 snd_soc_update_bits(codec, DAC_MVOL_CONF,
1036                                                 DAC_LR_MUTE_MASK, 0x0);
1037
1038                 /*aic3262_multi_i2s_dump_regs(dai);*/
1039         }
1040
1041         DBG(KERN_INFO "#%s : mute %d ended\n", __func__, mute);
1042
1043         return 0;
1044 }
1045
1046 /*
1047 *----------------------------------------------------------------------------
1048 * Function : aic3262_multi_i2s_asi3_mute
1049 * Purpose : This function is to mute or unmute the left and right DAC
1050 *
1051 *----------------------------------------------------------------------------
1052 */
1053 static int aic3262_multi_i2s_asi3_mute(struct snd_soc_dai *dai, int mute)
1054 {
1055         struct snd_soc_codec *codec = dai->codec;
1056         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1057
1058         DBG(KERN_INFO "#%s : mute %d started\n", __func__, mute);
1059
1060         if (mute && !aic3262->asiCtxt[2].port_muted) {
1061                 DBG("Mute if part\n");
1062         snd_soc_update_bits(codec, DAC_MVOL_CONF, DAC_LR_MUTE_MASK,DAC_LR_MUTE);
1063
1064                 /* First check if both Playback and Recording is going on
1065                 * this interface.
1066                 */
1067                 if (aic3262->asiCtxt[2].asi_active > 1) {
1068                         DBG("#%s Cannot Mute the ASI Now..\n", __func__);
1069                 } else if (!(aic3262->asiCtxt[0].playback_mode) &&
1070                         !(aic3262->asiCtxt[1].playback_mode)) {
1071                         /* Before Muting, please check if any other
1072                         * ASI is active. if so, we cannot simply mute the
1073                         * DAC and ADC Registers.
1074                         */
1075                         snd_soc_write(codec, DAC_MVOL_CONF,
1076                                 ((aic3262->dac_reg & 0xF3) | 0x0C));
1077                         snd_soc_write(codec, ADC_FINE_GAIN,
1078                                 ((aic3262->adc_gain & 0x77) | 0x88));
1079                         snd_soc_write(codec, HPL_VOL, 0xB9);
1080                         snd_soc_write(codec, HPR_VOL, 0xB9);
1081                         snd_soc_write(codec, REC_AMP_CNTL_R5, 0x39);
1082                         snd_soc_write(codec, RAMPR_VOL, 0x39);
1083                         snd_soc_write(codec, SPK_AMP_CNTL_R4, 0x00);
1084                         aic3262->asiCtxt[2].port_muted = 1;
1085                 }
1086         } else {
1087                 DBG("Mute else part\n");
1088                 snd_soc_update_bits(codec, DAC_MVOL_CONF,
1089                                                 DAC_LR_MUTE_MASK, 0x0);
1090
1091                 /*aic3262_multi_i2s_dump_regs(dai);*/
1092
1093         }
1094
1095         DBG(KERN_INFO "#%s : mute %d ended\n", __func__, mute);
1096
1097         return 0;
1098 }
1099
1100 /*
1101  *----------------------------------------------------------------------------
1102  * Function : aic3262_multi_i2s_set_dai_fmt
1103  * Purpose  : This function is to set the DAI format
1104  *
1105  *----------------------------------------------------------------------------
1106  */
1107 static int aic3262_multi_i2s_set_dai_fmt(struct snd_soc_dai *codec_dai,
1108                 unsigned int fmt)
1109 {
1110         /* Check the DAI Id and based on that switch the configuration for
1111         * the Individual ASI Port.
1112         */
1113         switch (codec_dai->id) {
1114         case 1:
1115                 aic3262_multi_i2s_asi1_set_dai_fmt(codec_dai, fmt);
1116         break;
1117         case 2:
1118                 aic3262_multi_i2s_asi2_set_dai_fmt(codec_dai, fmt);
1119         break;
1120         case 3:
1121                 aic3262_multi_i2s_asi3_set_dai_fmt(codec_dai, fmt);
1122         break;
1123         default:
1124                 printk(KERN_ERR
1125                         "#%s: Invalid DAI interface format\n", __func__);
1126                 return -EINVAL;
1127         }
1128         return 0;
1129 }
1130
1131
1132
1133 /*
1134 *----------------------------------------------------------------------------
1135 * Function : aic3262_multi_i2s_asi1_set_dai_fmt
1136 * Purpose  : This function is to set the DAI format for ASI1 Port
1137 *
1138 *----------------------------------------------------------------------------
1139 */
1140 static int aic3262_multi_i2s_asi1_set_dai_fmt(struct snd_soc_dai *codec_dai,
1141                 unsigned int fmt)
1142 {
1143         struct snd_soc_codec *codec = codec_dai->codec;
1144         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1145         u8 iface_reg, clk_reg;
1146         u8 regvalue;
1147
1148         DBG(KERN_INFO "%s: DAI_ID %d fmt %d\n",
1149                 __func__, codec_dai->id, fmt);
1150
1151         /* Read the B0_P4_R4 and B0_P4_R10 Registers to configure the
1152         * ASI1 Bus and Clock Formats depending on the PCM Format.
1153         */
1154         iface_reg = snd_soc_read(codec, ASI1_BUS_FMT);
1155         clk_reg   = snd_soc_read(codec, ASI1_BWCLK_CNTL_REG);
1156
1157         /* set master/slave audio interface */
1158         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1159         case SND_SOC_DAIFMT_CBM_CFM:
1160                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Master..\n",
1161                         __func__, codec_dai->id);
1162                 aic3262->asiCtxt[0].master = 1;
1163                 clk_reg |= (BIT5 | BIT2);       /* Codec Interface as Master */
1164         break;
1165         case SND_SOC_DAIFMT_CBS_CFS:
1166                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Slave..\n",
1167                         __func__, codec_dai->id);
1168                 clk_reg &= ~0xFC; /* Reset bits D[7:5] and D[4:2] to zero */
1169                 aic3262->asiCtxt[0].master = 0;
1170         break;
1171         case SND_SOC_DAIFMT_CBS_CFM:
1172                 /* new case..just for debugging */
1173                 DBG(KERN_INFO "%s: SND_SOC_DAIFMT_CBS_CFM\n", __func__);
1174                 aic3262->asiCtxt[0].master = 0;
1175                 clk_reg |= BIT5;        /* Only WCLK1 Output from Codec */
1176                 clk_reg &= ~0x1C;       /* BCLK1 Input to Codec */
1177         break;
1178         default:
1179                 printk(KERN_ERR "#%s: Invalid DAI master/slave interface\n",
1180                         __func__);
1181                 return -EINVAL;
1182         }
1183         aic3262->asiCtxt[0].pcm_format = (fmt & SND_SOC_DAIFMT_FORMAT_MASK);
1184         /* interface format */
1185         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1186         case SND_SOC_DAIFMT_I2S:
1187                 DBG(KERN_INFO "#%s: Configuring ASI%d for I2s Mode..\n",
1188                         __func__, codec_dai->id);
1189                 iface_reg = (iface_reg & 0x1f);
1190         break;
1191         case SND_SOC_DAIFMT_DSP_A:
1192                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP_A Mode..\n",
1193                         __func__, codec_dai->id);
1194                 iface_reg = (iface_reg & 0x1f) | 0x20;
1195         break;
1196         case SND_SOC_DAIFMT_RIGHT_J:
1197                 iface_reg = (iface_reg & 0x1f) | 0x40;
1198         break;
1199         case SND_SOC_DAIFMT_LEFT_J:
1200                 iface_reg = (iface_reg & 0x1f) | 0x60;
1201         break;
1202         case SND_SOC_DAIFMT_DSP_B:
1203                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP_B Mode..\n",
1204                         __func__, codec_dai->id);
1205                 iface_reg = (iface_reg & 0x1f) | 0x80;
1206                 /* voice call need data offset in 1 bitclock */
1207                 snd_soc_write(codec, ASI1_LCH_OFFSET, 1);
1208         break;
1209         default:
1210                 printk(KERN_ERR
1211                         "#%s: Invalid DAI interface format\n", __func__);
1212                 return -EINVAL;
1213         }
1214         /* Also Configure the Pin Control Registers before writing into
1215         * the ASI specific Clock Control and Format Registers
1216         */
1217
1218         /* Configure B0_P4_R65_D[5:2] to 001 This configures the
1219         * WCLK1 Pin to ASI1
1220         */
1221         regvalue = snd_soc_read(codec, WCLK1_PIN_CNTL_REG);
1222         snd_soc_write(codec, WCLK1_PIN_CNTL_REG, (regvalue | BIT2));
1223
1224         /* Configure B0_P4_R68_d[6:5] = 01 and B0_P4_R67_D[4:1] to 0001
1225         * to ensure that the DIN1 and DOUT1 Pins are configured
1226         * correctly
1227         */
1228         regvalue = snd_soc_read(codec, DIN1_PIN_CNTL_REG);
1229         snd_soc_write(codec, DIN1_PIN_CNTL_REG, (regvalue | BIT5));
1230         regvalue = snd_soc_read(codec, DOUT1_PIN_CNTL_REG);
1231         snd_soc_write(codec, DOUT1_PIN_CNTL_REG, (regvalue | BIT1));
1232
1233         snd_soc_write(codec, ASI1_BWCLK_CNTL_REG, clk_reg);
1234
1235         snd_soc_write(codec, ASI1_BUS_FMT, iface_reg);
1236
1237         return 0;
1238 }
1239
1240
1241 /*
1242 *----------------------------------------------------------------------------
1243 * Function : aic3262_multi_i2s_asi2_set_dai_fmt
1244 * Purpose  : This function is to set the DAI format for ASI2 Port
1245 *
1246 *----------------------------------------------------------------------------
1247 */
1248 static int aic3262_multi_i2s_asi2_set_dai_fmt(struct snd_soc_dai *codec_dai,
1249                         unsigned int fmt)
1250 {
1251         struct snd_soc_codec *codec = codec_dai->codec;
1252         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1253         u8 iface_reg, clk_reg;
1254         u8 regvalue;
1255
1256         DBG(KERN_INFO "%s: DAI_ID %d fmt %d\n",
1257                 __func__, codec_dai->id, fmt);
1258
1259         /* Read the B0_P4_R17 and B0_P4_R26 Registers to configure the
1260         * ASI1 Bus and Clock Formats depending on the PCM Format.
1261         */
1262         iface_reg = snd_soc_read(codec, ASI2_BUS_FMT);
1263         clk_reg   = snd_soc_read(codec, ASI2_BWCLK_CNTL_REG);
1264
1265         /* set master/slave audio interface */
1266         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1267         case SND_SOC_DAIFMT_CBM_CFM:
1268                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Master..\n",
1269                         __func__, codec_dai->id);
1270                 aic3262->asiCtxt[1].master = 1;
1271                 clk_reg |= (BIT5 | BIT2);
1272         break;
1273         case SND_SOC_DAIFMT_CBS_CFS:
1274                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Slave..\n",
1275                         __func__, codec_dai->id);
1276
1277                 clk_reg &= ~0xFC;
1278                 aic3262->asiCtxt[1].master = 0;
1279         break;
1280         case SND_SOC_DAIFMT_CBS_CFM:
1281                 /*new case..just for debugging */
1282                 DBG(KERN_INFO "%s: SND_SOC_DAIFMT_CBS_CFM\n", __func__);
1283                 aic3262->asiCtxt[1].master = 0;
1284                 clk_reg |= BIT5;
1285                 clk_reg &= ~0x1C;
1286         break;
1287         default:
1288                 printk(KERN_ERR "#%s:Invalid DAI master/slave interface\n",
1289                         __func__);
1290                 return -EINVAL;
1291         }
1292         aic3262->asiCtxt[1].pcm_format = (fmt & SND_SOC_DAIFMT_FORMAT_MASK);
1293         /* interface format */
1294         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1295         case SND_SOC_DAIFMT_I2S:
1296                 DBG(KERN_INFO "#%s: Configuring ASI%d for I2S Mode..\n",
1297                                 __func__, codec_dai->id);
1298                 iface_reg = (iface_reg & 0x1f);
1299         break;
1300         case SND_SOC_DAIFMT_DSP_A:
1301                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP_A Mode..\n",
1302                         __func__, codec_dai->id);
1303                 iface_reg = (iface_reg & 0x1f) | 0x20;
1304         break;
1305         case SND_SOC_DAIFMT_RIGHT_J:
1306                 iface_reg = (iface_reg & 0x1f) | 0x40;
1307         break;
1308         case SND_SOC_DAIFMT_LEFT_J:
1309                 iface_reg = (iface_reg & 0x1f) | 0x60;
1310         break;
1311         case SND_SOC_DAIFMT_DSP_B:
1312                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP Mode..\n",
1313                         __func__, codec_dai->id);
1314                 iface_reg = (iface_reg & 0x1f) | 0x80;
1315                 /* voice call need data offset in 1 bitclock */
1316                 snd_soc_write(codec, ASI2_LCH_OFFSET, 1);
1317         break;
1318         default:
1319                 printk(KERN_ERR "#%s:Invalid DAI interface format\n", __func__);
1320                 return -EINVAL;
1321         }
1322
1323         /* Also Configure the Pin Control Registers before writing into
1324         * the ASI2 specific Clock Control and Format Registers
1325         */
1326
1327         /* Configure B0_P4_R69_D[5:2] to 001 This configures the
1328         * WCLK2 Pin to ASI2
1329         */
1330
1331         regvalue = snd_soc_read(codec, WCLK2_PIN_CNTL_REG);
1332         snd_soc_write(codec, WCLK2_PIN_CNTL_REG, (regvalue | BIT2));
1333
1334         regvalue = snd_soc_read(codec, BCLK2_PIN_CNTL_REG);
1335         snd_soc_write(codec, BCLK2_PIN_CNTL_REG, (regvalue | BIT2));
1336
1337         /* Configure B0_P4_R72_d[6:5] = 01 and B0_P4_R71_D[4:1] to 0001
1338          * to ensure that the DIN2 and DOUT2 Pins are configured
1339          * correctly
1340          */
1341         regvalue = snd_soc_read(codec, DIN2_PIN_CNTL_REG);
1342         snd_soc_write(codec, DIN2_PIN_CNTL_REG, (regvalue | BIT5));
1343
1344         regvalue = snd_soc_read(codec, DOUT2_PIN_CNTL_REG);
1345         snd_soc_write(codec, DOUT2_PIN_CNTL_REG, (regvalue | BIT5 | BIT1));
1346
1347         snd_soc_write(codec, ASI2_BWCLK_CNTL_REG, clk_reg);
1348
1349         snd_soc_write(codec, ASI2_BUS_FMT, iface_reg);
1350
1351         return 0;
1352 }
1353
1354 /*
1355 *----------------------------------------------------------------------------
1356 * Function : aic3262_multi_i2s_asi3_set_dai_fmt
1357 * Purpose  : This function is to set the DAI format for ASI3 Port
1358 *
1359 *----------------------------------------------------------------------------
1360 */
1361 static int aic3262_multi_i2s_asi3_set_dai_fmt(struct snd_soc_dai *codec_dai,
1362                         unsigned int fmt)
1363 {
1364         struct snd_soc_codec *codec = codec_dai->codec;
1365         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1366         u8 iface_reg, clk_reg;
1367         u8 regvalue;
1368
1369         DBG(KERN_INFO "%s: DAI_ID %d fmt %d\n",
1370                 __func__, codec_dai->id, fmt);
1371
1372         /* Read the B0_P4_R33 and B0_P4_R42 Registers to configure the
1373         * ASI1 Bus and Clock Formats depending on the PCM Format.
1374         */
1375         iface_reg = snd_soc_read(codec, ASI3_BUS_FMT);
1376         clk_reg   = snd_soc_read(codec, ASI3_BWCLK_CNTL_REG);
1377
1378         /* set master/slave audio interface */
1379         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1380         case SND_SOC_DAIFMT_CBM_CFM:
1381                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Master..\n",
1382                         __func__, codec_dai->id);
1383                 aic3262->asiCtxt[2].master = 1;
1384                 clk_reg |= (BIT5 | BIT2);
1385         break;
1386         case SND_SOC_DAIFMT_CBS_CFS:
1387                 DBG(KERN_INFO "#%s: Configuring ASI%d as Frame Slave..\n",
1388                         __func__, codec_dai->id);
1389                 clk_reg &= ~0xFC;
1390                 aic3262->asiCtxt[2].master = 0;
1391         break;
1392         case SND_SOC_DAIFMT_CBS_CFM:
1393                 /* new case..just for debugging */
1394                 DBG(KERN_INFO "%s: SND_SOC_DAIFMT_CBS_CFM\n", __func__);
1395                 aic3262->asiCtxt[2].master = 0;
1396                 clk_reg |= BIT5;
1397                 clk_reg &= ~0x1C;
1398         break;
1399         default:
1400                 printk(KERN_ERR "Invalid DAI master/slave interface\n");
1401                 return -EINVAL;
1402         }
1403         aic3262->asiCtxt[2].pcm_format = (fmt & SND_SOC_DAIFMT_FORMAT_MASK);
1404         /* interface format */
1405         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1406         case SND_SOC_DAIFMT_I2S:
1407                 DBG(KERN_INFO "#%s: Configuring ASI%d for I2S Mode..\n",
1408                         __func__, codec_dai->id);
1409                 iface_reg = (iface_reg & 0x1f);
1410         break;
1411         case SND_SOC_DAIFMT_DSP_A:
1412                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP_A Mode..\n",
1413                         __func__, codec_dai->id);
1414                 iface_reg = (iface_reg & 0x1f) | 0x20;
1415         break;
1416         case SND_SOC_DAIFMT_RIGHT_J:
1417                 iface_reg = (iface_reg & 0x1f) | 0x40;
1418         break;
1419         case SND_SOC_DAIFMT_LEFT_J:
1420                 iface_reg = (iface_reg & 0x1f) | 0x60;
1421         break;
1422         case SND_SOC_DAIFMT_DSP_B:
1423                 DBG(KERN_INFO "#%s: Configuring ASI%d for DSP Mode..\n",
1424                         __func__, codec_dai->id);
1425                 iface_reg = (iface_reg & 0x1f) | 0x80;
1426                 /* voice call need data offset in 1 bitclock */
1427                 snd_soc_write(codec, ASI3_LCH_OFFSET, 1);
1428         break;
1429         default:
1430                 printk(KERN_ERR
1431                         "#%s: Invalid DAI interface format\n", __func__);
1432                 return -EINVAL;
1433         }
1434
1435         /* Also Configure the Pin Control Registers before writing into
1436         * the ASI specific Clock Control and Format Registers
1437         */
1438         /* Configure B0_P4_R73_D[5:2] to 0001 This configures the
1439         * WCLK1 Pin to ASI1
1440         */
1441         regvalue = snd_soc_read(codec, WCLK3_PIN_CNTL_REG);
1442         snd_soc_write(codec, WCLK3_PIN_CNTL_REG, (regvalue | BIT2));
1443
1444         regvalue = snd_soc_read(codec, BCLK3_PIN_CNTL_REG);
1445         snd_soc_write(codec, BCLK3_PIN_CNTL_REG, (regvalue | BIT2));
1446
1447         /* Configure B0_P4_R76_d[6:5] = 01 and B0_P4_R75_D[4:1] to 0001
1448         * to ensure that the DIN1 and DOUT1 Pins are configured
1449         * correctly
1450         */
1451         regvalue = snd_soc_read(codec, DIN3_PIN_CNTL_REG);
1452         snd_soc_write(codec, DIN3_PIN_CNTL_REG, (regvalue | BIT5));
1453         regvalue = snd_soc_read(codec, DOUT3_PIN_CNTL_REG);
1454         snd_soc_write(codec, DOUT3_PIN_CNTL_REG, (regvalue | BIT1));
1455
1456         snd_soc_write(codec, ASI3_BWCLK_CNTL_REG, clk_reg);
1457
1458         snd_soc_write(codec, ASI3_BUS_FMT, iface_reg);
1459
1460         return 0;
1461 }
1462
1463 /*
1464  * Clock after PLL and dividers
1465  */
1466 static int aic3262_multi_i2s_set_dai_sysclk(struct snd_soc_dai *codec_dai,
1467                 int clk_id, unsigned int freq, int dir)
1468 {
1469         struct snd_soc_codec *codec = codec_dai->codec;
1470         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1471
1472         DBG(KERN_INFO "#%s: DAI ID %d Freq %d Direction %d\n",
1473                         __func__, codec_dai->id, freq, dir);
1474         switch (freq) {
1475         case AIC3262_FREQ_12000000:
1476         case AIC3262_FREQ_12288000:
1477         case AIC3262_FREQ_24000000:
1478                 aic3262->sysclk = freq;
1479                 return 0;
1480                 break;
1481         }
1482         printk(KERN_ERR "Invalid frequency to set DAI system clock\n");
1483         return -EINVAL;
1484 }
1485
1486 /*
1487 * aic3262_multi_i2s_set_pll
1488 *
1489 * This function is invoked as part of the PLL call-back
1490 * handler from the ALSA layer.
1491 */
1492 static int aic3262_multi_i2s_set_dai_pll(struct snd_soc_dai *codec_dai,
1493                 int pll_id, int source, unsigned int freq_in,
1494                 unsigned int freq_out)
1495 {
1496
1497         printk(KERN_INFO "%s: DAI ID %d PLL_ID %d InFreq %d OutFreq %d\n",
1498                 __func__, pll_id, codec_dai->id, freq_in, freq_out);
1499
1500         return 0;
1501 }
1502
1503 /*
1504 * aic3262_asi1_clk_config
1505 *
1506 * This function is used to configure the BCLK1, WCLK1 pins which
1507 * are specific to ASI1 Interface. This function just enables the
1508 * BCLk and WCLK  along with the miniDSP Port Control Registers.
1509 * However, depending on the user requirement, this function can also be
1510 * extended to configure the sourc for the BCLK and WCLK on a ASI basis.
1511 */
1512 static int aic3262_asi1_clk_config(struct snd_soc_codec *codec,
1513                 struct snd_pcm_hw_params *params)
1514 {
1515         u8 bclk_N_value, wclk_N_value;
1516         u8 minidspD_data, minidspA_data;
1517         u8 regval;
1518
1519         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1520
1521         DBG(KERN_INFO "%s: Invoked\n",  __func__);
1522
1523         /* Configure the BCLK and WCLK Output Mux Options */
1524         regval = snd_soc_read(codec, ASI1_BWCLK_OUT_CNTL);
1525         regval &= ~(AIC3262_ASI_BCLK_MUX_MASK | AIC3262_ASI_WCLK_MUX_MASK);
1526
1527         regval |= (aic3262->asiCtxt[0].bclk_output <<
1528                         AIC3262_ASI_BCLK_MUX_SHIFT);
1529         regval |= aic3262->asiCtxt[0].wclk_output;
1530         snd_soc_write(codec, ASI1_BWCLK_OUT_CNTL, regval);
1531
1532         /* Configure the corresponding miniDSP Data Ports */
1533         minidspD_data = snd_soc_read(codec, MINIDSP_PORT_CNTL_REG);
1534         minidspD_data &= ~(BIT5 | BIT4);
1535         snd_soc_write(codec, MINIDSP_PORT_CNTL_REG, minidspD_data);
1536
1537         minidspA_data = snd_soc_read(codec, ASI1_ADC_INPUT_CNTL);
1538         minidspA_data &= ~(BIT2 | BIT1 | BIT0);
1539         minidspA_data |= aic3262->asiCtxt[0].adc_input;
1540         snd_soc_write(codec, ASI1_ADC_INPUT_CNTL, minidspA_data);
1541
1542
1543         if (aic3262->asiCtxt[0].master == 1) {
1544                 DBG(KERN_INFO
1545                 "#%s: Codec Master on ASI1 Port. Enabling BCLK WCLK Divider.\n",
1546                         __func__);
1547                 bclk_N_value = aic3262->asiCtxt[0].bclk_div;
1548                 snd_soc_write(codec, ASI1_BCLK_N, (bclk_N_value | 0x80));
1549
1550                 wclk_N_value = snd_soc_read(codec, ASI1_WCLK_N);
1551                 snd_soc_write(codec, ASI1_WCLK_N, (wclk_N_value | 0xA0));
1552         }
1553         return 0;
1554
1555 }
1556
1557 /*
1558 * aic3262_asi2_clk_config
1559 *
1560 * This function is used to configure the BCLK2, WCLK2 pins which
1561 * are specific to ASI2 Interface. This function just enables the
1562 * BCLk and WCLK  along with the miniDSP Port Control Registers.
1563 * However, depending on the user requirement, this function can also be
1564 * extended to configure the sourc for the BCLK and WCLK on a ASI basis.
1565 */
1566 static int aic3262_asi2_clk_config(struct snd_soc_codec *codec,
1567                 struct snd_pcm_hw_params *params)
1568 {
1569         u8 bclk_N_value, wclk_N_value, minidspD_data, minidspA_data;
1570         u8 regval;
1571
1572         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1573
1574         DBG(KERN_INFO "%s: Invoked\n",  __func__);
1575
1576
1577         /* Configure the BCLK and WCLK Output Mux Options */
1578         regval = snd_soc_read(codec, ASI2_BWCLK_OUT_CNTL);
1579         regval &= ~(AIC3262_ASI_BCLK_MUX_MASK | AIC3262_ASI_WCLK_MUX_MASK);
1580         regval |= (aic3262->asiCtxt[1].bclk_output <<
1581                         AIC3262_ASI_BCLK_MUX_SHIFT);
1582         regval |= aic3262->asiCtxt[1].wclk_output;
1583
1584         snd_soc_write(codec, ASI2_BWCLK_OUT_CNTL, regval);
1585         /* Configure the corresponding miniDSP Data Ports */
1586         minidspD_data = snd_soc_read(codec, MINIDSP_PORT_CNTL_REG);
1587         minidspD_data |= (BIT2);
1588         snd_soc_write(codec, MINIDSP_PORT_CNTL_REG, minidspD_data);
1589
1590         minidspA_data = snd_soc_read(codec, ASI2_ADC_INPUT_CNTL);
1591         minidspA_data &= ~(BIT2 | BIT1 | BIT0);
1592         minidspA_data |= aic3262->asiCtxt[1].adc_input;
1593         snd_soc_write(codec, ASI2_ADC_INPUT_CNTL, minidspA_data);
1594
1595         if (aic3262->asiCtxt[1].master == 1) {
1596                 DBG(KERN_INFO
1597                 "#%s: Codec Master on ASI2 Port. Enabling BCLK WCLK Divider.\n",
1598                         __func__);
1599                 bclk_N_value = aic3262->asiCtxt[1].bclk_div;
1600                 snd_soc_write(codec, ASI2_BCLK_N, (bclk_N_value | 0x80));
1601
1602                 wclk_N_value = snd_soc_read(codec, ASI2_WCLK_N);
1603                 snd_soc_write(codec, ASI2_WCLK_N, (wclk_N_value | 0xA0));
1604         }
1605         return 0;
1606
1607 }
1608
1609 /*
1610 * aic3262_asi3_clk_config
1611 *
1612 * This function is used to configure the BCLK3, WCLK3 pins which
1613 * are specific to ASI3 Interface. This function just enables the
1614 * BCLk and WCLK  along with the miniDSP Port Control Registers.
1615 * However, depending on the user requirement, this function can also be
1616 * extended to configure the sourc for the BCLK and WCLK on a ASI basis.
1617 */
1618 static int aic3262_asi3_clk_config(struct snd_soc_codec *codec,
1619                 struct snd_pcm_hw_params *params)
1620 {
1621         u8 bclk_N_value, wclk_N_value, minidspD_data, minidspA_data;
1622         u8 regval;
1623
1624         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1625
1626         DBG(KERN_INFO "%s:\n",  __func__);
1627
1628
1629         /* Configure the BCLK and WCLK Output Mux Options */
1630         regval = snd_soc_read(codec, ASI3_BWCLK_OUT_CNTL);
1631         regval &= ~(AIC3262_ASI_BCLK_MUX_MASK | AIC3262_ASI_WCLK_MUX_MASK);
1632         regval |= (aic3262->asiCtxt[2].bclk_output <<
1633                         AIC3262_ASI_BCLK_MUX_SHIFT);
1634         regval |= aic3262->asiCtxt[2].wclk_output;
1635         snd_soc_write(codec, ASI3_BWCLK_OUT_CNTL, regval);
1636
1637         minidspD_data = snd_soc_read(codec, MINIDSP_PORT_CNTL_REG);
1638         minidspD_data |= (BIT1);
1639         snd_soc_write(codec, MINIDSP_PORT_CNTL_REG, minidspD_data);
1640
1641         minidspA_data = snd_soc_read(codec, ASI3_ADC_INPUT_CNTL);
1642         minidspA_data &= ~(BIT2 | BIT1 | BIT0);
1643         minidspA_data |= aic3262->asiCtxt[2].adc_input;
1644         snd_soc_write(codec, ASI3_ADC_INPUT_CNTL, minidspA_data);
1645
1646                 if (aic3262->asiCtxt[2].master == 1) {
1647                 DBG(KERN_INFO
1648                 "#%s: Codec Master on ASI3 Port. Enabling BCLK WCLK Divider.\n",
1649                         __func__);
1650                 bclk_N_value = aic3262->asiCtxt[2].bclk_div;
1651                 snd_soc_write(codec, ASI2_BCLK_N, (bclk_N_value | 0x80));
1652
1653                 wclk_N_value = snd_soc_read(codec, ASI3_WCLK_N);
1654                 snd_soc_write(codec, ASI3_WCLK_N, (wclk_N_value | 0xA0));
1655         }
1656         return 0;
1657
1658 }
1659
1660 /*
1661 * aic3262_multi_i2s_hw_params
1662 *
1663 * This function is used to configure the individual ASI port registers
1664 * depending on the configuration passed on by the snd_pcm_hw_params
1665 * structure.
1666 * This function internally configures the ASI specific pins and clock
1667 * Control Registers.
1668 */
1669 static int aic3262_multi_i2s_hw_params(struct snd_pcm_substream *substream,
1670                         struct snd_pcm_hw_params *params,
1671                         struct snd_soc_dai *dai)
1672 {
1673         int i, j;
1674         u8 data;
1675         u16 regoffset = 0;
1676         u8 dacpath = 0;
1677         u8 adcpath = 0;
1678         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1679         struct snd_soc_codec *codec = rtd->codec;
1680         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1681
1682         DBG(KERN_INFO "#%s: Invoked for ASI%d Port for %s Mode\n",
1683                 __func__, dai->id,
1684                 (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
1685                 ? "Playback" : "Record");
1686
1687         i = aic3262_get_divs(aic3262->sysclk, params_rate(params));
1688
1689         i2c_verify_book0(codec);
1690
1691         if (i < 0) {
1692                 printk(KERN_ERR "#%s: Sampling rate %d not supported\n",
1693                         __func__, params_rate(params));
1694                 return i;
1695         }
1696
1697         aic3262_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
1698
1699         /* Configure the PLL J, R D values only if none of the ASI
1700         * Interfaces are Active.
1701         */
1702
1703         if (1) {
1704                 DBG(KERN_INFO "#%s: None of the ASIs active yet...\n",
1705                         __func__);
1706                 /*We will fix R value to 1 and make P & J=K.D as variable */
1707                 /* Setting P & R values are set to 1 and 1 at init*/
1708
1709                 /* J value */
1710                 snd_soc_write(codec, PLL_J_REG, aic3262_divs[i].pll_j);
1711
1712                 /* MSB & LSB for D value */
1713
1714                 snd_soc_write(codec, PLL_D_MSB, (aic3262_divs[i].pll_d >> 8));
1715                 snd_soc_write(codec, PLL_D_LSB,
1716                               (aic3262_divs[i].pll_d & AIC3262_8BITS_MASK));
1717
1718                 /* NDAC divider value */
1719                 data = snd_soc_read(codec, NDAC_DIV_POW_REG);
1720                 DBG(KERN_INFO "# reading NDAC = %d , NDAC_DIV_POW_REG = %x\n",
1721                         aic3262_divs[i].ndac, data);
1722                 snd_soc_write(codec, NDAC_DIV_POW_REG,
1723                          ((data & 0x80)|(aic3262_divs[i].ndac)));
1724                 DBG(KERN_INFO "# writing NDAC = %d , NDAC_DIV_POW_REG = %x\n",
1725                         aic3262_divs[i].ndac,
1726                         ((data & 0x80)|(aic3262_divs[i].ndac)));
1727
1728                 /* MDAC divider value */
1729                 data = snd_soc_read(codec, MDAC_DIV_POW_REG);
1730                 DBG(KERN_INFO "# reading MDAC = %d , MDAC_DIV_POW_REG = %x\n",
1731                         aic3262_divs[i].mdac, data);
1732                 snd_soc_write(codec, MDAC_DIV_POW_REG,
1733                         ((data & 0x80)|(aic3262_divs[i].mdac)));
1734                 DBG(KERN_INFO "# writing MDAC = %d , MDAC_DIV_POW_REG = %x\n",
1735                 aic3262_divs[i].mdac, ((data & 0x80)|(aic3262_divs[i].mdac)));
1736
1737                 /* DOSR MSB & LSB values */
1738                 snd_soc_write(codec, DOSR_MSB_REG, aic3262_divs[i].dosr >> 8);
1739                 DBG(KERN_INFO "# writing DOSR_MSB_REG = %d\n",
1740                         (aic3262_divs[i].dosr >> 8));
1741                 snd_soc_write(codec, DOSR_LSB_REG,
1742                         aic3262_divs[i].dosr & AIC3262_8BITS_MASK);
1743                 DBG(KERN_INFO "# writing DOSR_LSB_REG = %d\n",
1744                         (aic3262_divs[i].dosr & AIC3262_8BITS_MASK));
1745
1746                 /* NADC divider value */
1747                 data = snd_soc_read(codec, NADC_DIV_POW_REG);
1748                 snd_soc_write(codec, NADC_DIV_POW_REG,
1749                         ((data & 0x80)|(aic3262_divs[i].nadc)));
1750                 DBG(KERN_INFO "# writing NADC_DIV_POW_REG = %d\n",
1751                         aic3262_divs[i].nadc);
1752
1753                 /* MADC divider value */
1754                 data = snd_soc_read(codec, MADC_DIV_POW_REG);
1755                 snd_soc_write(codec, MADC_DIV_POW_REG,
1756                         ((data & 0x80)|(aic3262_divs[i].madc)));
1757                 DBG(KERN_INFO "# writing MADC_DIV_POW_REG = %d\n",
1758                         aic3262_divs[i].madc);
1759
1760                 /* AOSR value */
1761                 snd_soc_write(codec, AOSR_REG, aic3262_divs[i].aosr);
1762                 DBG(KERN_INFO "# writing AOSR = %d\n", aic3262_divs[i].aosr);
1763         } else {
1764                 DBG(KERN_INFO "#Atleast 1 ASI Active. Cannot Program PLL..\n");
1765         }
1766         /* Check for the DAI ID to know which ASI needs
1767         * Configuration.
1768         */
1769         switch (dai->id) {
1770         case 1:
1771                 regoffset = ASI1_BUS_FMT;
1772
1773                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1774                         DBG(KERN_INFO "#%s: ASI1 DAC Inputs enabled..\n",
1775                                         __func__);
1776                         /* Read the DAC Control Register and configure it
1777                         * as per the ASIContext Structure Settings.
1778                         */
1779                         dacpath = snd_soc_read(codec, ASI1_DAC_OUT_CNTL);
1780                         dacpath &= ~(AIC3262_ASI_LDAC_PATH_MASK |
1781                                 AIC3262_ASI_RDAC_PATH_MASK);
1782                         dacpath |= (aic3262->asiCtxt[0].left_dac_output
1783                                 << AIC3262_ASI_LDAC_PATH_SHIFT);
1784
1785                         dacpath |= (aic3262->asiCtxt[0].right_dac_output
1786                                 << AIC3262_ASI_RDAC_PATH_SHIFT);
1787                         snd_soc_write(codec, ASI1_DAC_OUT_CNTL, dacpath);
1788
1789                         aic3262->asiCtxt[0].playback_mode = 1;
1790                         aic3262->asiCtxt[0].bclk_div =
1791                                 aic3262_divs[i].blck_N;
1792                 } else {
1793                         /* For Recording, Configure the DOUT Pin as per
1794                          * ASIContext Structure Settings.
1795                          */
1796                         adcpath = snd_soc_read(codec, ASI1_DATA_OUT);
1797                         adcpath &= ~(AIC3262_ASI_DOUT_MASK);
1798
1799                         adcpath |= aic3262->asiCtxt[0].dout_option;
1800                         snd_soc_write(codec, ASI1_DATA_OUT, adcpath);
1801
1802                         aic3262->asiCtxt[0].capture_mode = 1;
1803                 }
1804         break;
1805         case 2:
1806                 regoffset = ASI2_BUS_FMT;
1807
1808                 /* Since we are configuring ASI2, please check if Playback
1809                  * is expected. If so, enable ASI2 Inputs to Left and
1810                  * Right DACs
1811                  */
1812                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1813                         DBG(KERN_INFO "#%s: ASI2 DAC Inputs enabled..\n",
1814                                         __func__);
1815                         /* Read the DAC Control Register and configure it
1816                          * as per theASIContext Structure Settings.
1817                          */
1818                         dacpath = snd_soc_read(codec, ASI2_DAC_OUT_CNTL);
1819                         dacpath &= ~(AIC3262_ASI_LDAC_PATH_MASK |
1820                                 AIC3262_ASI_RDAC_PATH_MASK);
1821                         dacpath |= (aic3262->asiCtxt[1].left_dac_output
1822                                 << AIC3262_ASI_LDAC_PATH_SHIFT);
1823
1824                         dacpath |= (aic3262->asiCtxt[1].right_dac_output
1825                                 << AIC3262_ASI_RDAC_PATH_SHIFT);
1826                         snd_soc_write(codec, ASI2_DAC_OUT_CNTL, dacpath);
1827                         aic3262->asiCtxt[1].playback_mode = 1;
1828
1829                         aic3262->asiCtxt[1].bclk_div =
1830                                 aic3262_divs[i].blck_N;
1831                 } else {
1832                         /* For Recording, Configure the DOUT Pin as per
1833                          * ASIContext Structure Settings.
1834                          */
1835                         adcpath = snd_soc_read(codec, ASI2_DATA_OUT);
1836                         adcpath &= ~(AIC3262_ASI_DOUT_MASK);
1837                         adcpath |= aic3262->asiCtxt[1].dout_option;
1838                         snd_soc_write(codec, ASI2_DATA_OUT, adcpath);
1839
1840                         aic3262->asiCtxt[1].capture_mode = 1;
1841                 }
1842         break;
1843         case 3:
1844                 regoffset = ASI3_BUS_FMT;
1845                 /* Since we are configuring ASI3, please check if Playback
1846                 * is expected. If so, enable ASI3 Inputs to Left and
1847                 * Right DACs
1848                 */
1849                 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1850                         DBG(KERN_INFO "#%s:ASI3 DAC Inputs enabled.\n",
1851                                 __func__);
1852                         /* Read the DAC Control Register and configure
1853                         * it as per the ASIContext Structure Settings.
1854                         */
1855                         dacpath = snd_soc_read(codec, ASI3_DAC_OUT_CNTL);
1856                         dacpath &= ~(AIC3262_ASI_LDAC_PATH_MASK |
1857                                         AIC3262_ASI_RDAC_PATH_MASK);
1858                         dacpath |= (aic3262->asiCtxt[2].left_dac_output
1859                                         << AIC3262_ASI_LDAC_PATH_SHIFT);
1860                         dacpath |= (aic3262->asiCtxt[2].right_dac_output
1861                                 << AIC3262_ASI_RDAC_PATH_SHIFT);
1862                         snd_soc_write(codec,
1863                                 ASI3_DAC_OUT_CNTL, dacpath);
1864
1865                         aic3262->asiCtxt[2].playback_mode = 1;
1866
1867                         aic3262->asiCtxt[2].bclk_div =
1868                                 aic3262_divs[i].blck_N;
1869                 } else {
1870                         /* For Recording, Configure the DOUT Pin as per
1871                          * ASIContext Structure Settings.
1872                          */
1873                         adcpath &= ~(AIC3262_ASI_DOUT_MASK);
1874                         adcpath |= aic3262->asiCtxt[2].dout_option;
1875                         snd_soc_write(codec, ASI3_DATA_OUT, adcpath);
1876
1877                         aic3262->asiCtxt[2].capture_mode = 1;
1878                 }
1879         break;
1880         default:
1881                 printk(KERN_ERR "Invalid Dai ID %d in %s",
1882                         dai->id, __func__);
1883         break;
1884         }
1885         DBG(KERN_INFO "#%s: Reading Pg %d Reg %d for Bus Format Control.\n",
1886                 __func__, (regoffset/128),  (regoffset % 128));
1887
1888         /* Read the correspondig ASI DAI Interface Register */
1889         data = snd_soc_read(codec, regoffset);
1890
1891         data = data & 0xe7;
1892
1893         switch (params_format(params)) {
1894         case SNDRV_PCM_FORMAT_S16_LE:
1895                 DBG(KERN_INFO "#%s: Configuring ASI%d S16_LE Fmt..\n",
1896                         __func__, dai->id);
1897                 data = data | 0x00;
1898                 aic3262->asiCtxt[dai->id - 1].word_len = 16;
1899         break;
1900         case SNDRV_PCM_FORMAT_S20_3LE:
1901                 data |= (0x08);
1902                 aic3262->asiCtxt[dai->id - 1].word_len = 20;
1903         break;
1904         case SNDRV_PCM_FORMAT_S24_LE:
1905                 DBG(KERN_INFO "#%s: Configuring ASI%d S24_LE Fmt..\n",
1906                         __func__, dai->id);
1907                 data |= (0x10);
1908                 aic3262->asiCtxt[dai->id - 1].word_len = 24;
1909         break;
1910         case SNDRV_PCM_FORMAT_S32_LE:
1911                 DBG(KERN_INFO "#%s: Configuring ASI%d S32_LE Fmt..\n",
1912                         __func__, dai->id);
1913                 data |= (0x18);
1914                 aic3262->asiCtxt[dai->id - 1].word_len = 32;
1915         break;
1916         }
1917
1918         /* configure the respective Registers for the above configuration */
1919         snd_soc_write(codec, regoffset, data);
1920
1921         for (j = 0; j < NO_FEATURE_REGS; j++) {
1922                 snd_soc_write(codec,
1923                         aic3262_divs[i].codec_specific_regs[j].reg_offset,
1924                         aic3262_divs[i].codec_specific_regs[j].reg_val);
1925         }
1926
1927         /* Enable the PLL, MDAC, NDAC, NADC, MADC and BCLK Dividers */
1928         aic3262_set_bias_level(codec, SND_SOC_BIAS_ON);
1929
1930         /* Based on the DAI ID we enable the corresponding pins related to the
1931         * ASI Port.
1932         */
1933         switch (dai->id) {
1934         case 1:
1935                 aic3262_asi1_clk_config(codec, params);
1936         break;
1937         case 2:
1938                 aic3262_asi2_clk_config(codec, params);
1939         break;
1940         case 3:
1941                 aic3262_asi3_clk_config(codec, params);
1942         break;
1943         default:
1944                 printk(KERN_ERR "Invalid Dai ID %d in %s",
1945                         dai->id, __func__);
1946         break;
1947         }
1948         /* Depending on the DAI->ID update the local Flags */
1949         aic3262->asiCtxt[dai->id - 1].asi_active++;
1950         aic3262->asiCtxt[dai->id - 1].sampling_rate = params_rate(params);
1951         /* Update the active_count flag */
1952         aic3262->active_count++;
1953
1954         return 0;
1955 }
1956
1957 /*
1958 *
1959 * aic3262_multi_i2s_hw_free
1960 *
1961 * This function is used to configure the Codec after the usage is completed.
1962 * We can use this function to disable the DAC and ADC specific inputs from the
1963 * individual ASI Ports of the Audio Codec.
1964 */
1965 static int aic3262_multi_i2s_shutdown(struct snd_pcm_substream *substream,
1966                         struct snd_soc_dai *dai)
1967 {
1968         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1969         struct snd_soc_codec *codec = rtd->codec;
1970         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
1971
1972         u8 value;
1973         u8 dacpath;
1974         u8 adcpath;
1975         u16 dacregoffset = 0;
1976         u16 adcregoffset = 0;
1977
1978         DBG(KERN_INFO "#%s: ASI%d Port for %s Mode\n",
1979                 __func__, dai->id,
1980                 (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) ?
1981                 "Playback" : "Record");
1982
1983         /* Check if this function was already executed earlier for the same
1984         * ASI Port
1985         */
1986         if ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) &&
1987                 (aic3262->asiCtxt[dai->id - 1].playback_mode == 0)) {
1988                 DBG(KERN_INFO "#%s: Function Already Executed. Exiting..\n",
1989                         __func__);
1990                 goto err;
1991         } else if ((substream->stream != SNDRV_PCM_STREAM_PLAYBACK) &&
1992                 (aic3262->asiCtxt[dai->id - 1].capture_mode == 0)) {
1993                 DBG(KERN_INFO "#%s: Function Already Executed. Exiting..\n",
1994                         __func__);
1995                 goto err;
1996         }
1997
1998         switch (dai->id) {
1999         case 1:
2000                 /* In case we are Frame Master on this Interface, Switch off
2001                 * the Bit Clock Divider and Word Clock Dividers
2002                 */
2003                 if (aic3262->asiCtxt[0].master == 1) {
2004                         /* Also check if either Playback or Recording is still
2005                         * going on this ASI Interface
2006                         */
2007
2008                         value = snd_soc_read(codec, ASI1_BCLK_N);
2009                         snd_soc_write(codec, ASI1_BCLK_N, (value & 0x7f));
2010
2011                         value = snd_soc_read(codec, ASI1_WCLK_N);
2012                         snd_soc_write(codec, ASI1_WCLK_N, (value & 0x7f));
2013                 }
2014
2015                 dacregoffset = ASI1_DAC_OUT_CNTL;
2016                 adcregoffset = ASI1_ADC_INPUT_CNTL;
2017         break;
2018         case 2:
2019                 /* In case we are Frame Master on this Interface, Switch off
2020                 * the Bit Clock Divider and Word Clock Dividers
2021                 */
2022                 if (aic3262->asiCtxt[1].master == 1) {
2023                         value = snd_soc_read(codec, ASI2_BCLK_N);
2024                         snd_soc_write(codec, ASI2_BCLK_N, (value & 0x7f));
2025
2026                         value = snd_soc_read(codec, ASI2_WCLK_N);
2027                         snd_soc_write(codec, ASI2_WCLK_N, (value & 0x7f));
2028                 }
2029                 dacregoffset = ASI2_DAC_OUT_CNTL;
2030                 adcregoffset = ASI2_ADC_INPUT_CNTL;
2031         break;
2032         case 3:
2033                 /* In case we are Frame Master on this Interface, Switch off
2034                 * the Bit Clock Divider and Word Clock Dividers
2035                 */
2036                 if (aic3262->asiCtxt[2].master == 1) {
2037                         value = snd_soc_read(codec, ASI3_BCLK_N);
2038                         snd_soc_write(codec, ASI3_BCLK_N, (value & 0x7f));
2039
2040                         value = snd_soc_read(codec, ASI3_WCLK_N);
2041                         snd_soc_write(codec, ASI3_WCLK_N, (value & 0x7f));
2042                 }
2043                 dacregoffset = ASI3_DAC_OUT_CNTL;
2044                 adcregoffset = ASI3_ADC_INPUT_CNTL;
2045         break;
2046         default:
2047                 printk(KERN_ERR "#%s: Invalid dai id\n", __func__);
2048         }
2049         /* If this was a Playback Stream Stop, then only
2050         * switch off the DAC Inputs
2051         */
2052         if ((substream->stream == SNDRV_PCM_STREAM_PLAYBACK) &&
2053                 (dacregoffset != 0)) {
2054                 DBG(KERN_INFO "#%s: Disabling Pg %d Reg %d DAC Inputs ..\n",
2055                         __func__, (dacregoffset/128), (dacregoffset % 128));
2056
2057                 dacpath = snd_soc_read(codec, dacregoffset);
2058                 snd_soc_write(codec, dacregoffset, (dacpath & ~(BIT6 | BIT4)));
2059
2060                 aic3262->asiCtxt[dai->id - 1].playback_mode = 0;
2061         } else {
2062                 /* Switch off the ADC Input Control Registers here */
2063                 DBG(KERN_INFO "#%s: Disabling Pg %d Reg %d for ADC Inputs..\n",
2064                         __func__, (adcregoffset/128), (adcregoffset % 128));
2065
2066                 adcpath =  snd_soc_read(codec, adcregoffset);
2067                 snd_soc_write(codec, adcregoffset,
2068                         (adcpath & ~(BIT2 | BIT1 | BIT0)));
2069
2070                 aic3262->asiCtxt[dai->id - 1].capture_mode = 0;
2071         }
2072
2073         /* If we were configured in mono PCM Mode earlier, then reset the
2074         * Left Channel and Right Channel offset Registers here.
2075         */
2076         switch (dai->id) {
2077         case 1:
2078                 if (aic3262->asiCtxt[0].pcm_format == SND_SOC_DAIFMT_DSP_B) {
2079                         snd_soc_write(codec, ASI1_LCH_OFFSET, 0x00);
2080                         snd_soc_write(codec, ASI1_RCH_OFFSET, 0x00);
2081                 }
2082         break;
2083         case 2:
2084                 if (aic3262->asiCtxt[1].pcm_format == SND_SOC_DAIFMT_DSP_B) {
2085                         snd_soc_write(codec, ASI2_LCH_OFFSET, 0x00);
2086                         snd_soc_write(codec, ASI2_RCH_OFFSET, 0x00);
2087                 }
2088
2089         break;
2090         case 3:
2091                 if (aic3262->asiCtxt[2].pcm_format == SND_SOC_DAIFMT_DSP_B) {
2092                         snd_soc_write(codec, ASI3_LCH_OFFSET, 0x00);
2093                         snd_soc_write(codec, ASI3_RCH_OFFSET, 0x00);
2094                 }
2095         break;
2096         }
2097         /* Depending on the DAI->ID update the asi_active Flags */
2098         if (aic3262->asiCtxt[dai->id - 1].asi_active) {
2099                 aic3262->asiCtxt[dai->id - 1].asi_active--;
2100
2101                 /* Update the active_count flag */
2102                 if (aic3262->active_count)
2103                         aic3262->active_count--;
2104         }
2105 err:
2106         return 0;
2107 }
2108
2109 /*
2110  *----------------------------------------------------------------------------
2111  * @struct  snd_soc_codec_dai |
2112  *          It is SoC Codec DAI structure which has DAI capabilities viz.,
2113  *          playback and capture, DAI runtime information viz. state of DAI
2114  *                      and pop wait state, and DAI private data.
2115  *          The AIC3262 rates ranges from 8k to 192k
2116  *          The PCM bit format supported are 16, 20, 24 and 32 bits
2117  *----------------------------------------------------------------------------
2118  */
2119 struct snd_soc_dai_ops aic3262_multi_i2s_dai_ops = {
2120         .hw_params      = aic3262_multi_i2s_hw_params,
2121         .digital_mute   = aic3262_multi_i2s_mute,
2122         .set_fmt        = aic3262_multi_i2s_set_dai_fmt,
2123         .set_pll        = aic3262_multi_i2s_set_dai_pll,
2124         .set_sysclk     = aic3262_multi_i2s_set_dai_sysclk,
2125         .shutdown        = aic3262_multi_i2s_shutdown,
2126 };
2127
2128
2129 static struct snd_soc_dai_driver tlv320aic3262_dai[] = {
2130 /* AIC3262 ASI1 DAI */
2131 {
2132         .name = "aic3262-asi1",
2133         .id = 1,
2134         .playback = {
2135                 .stream_name = "Playback",
2136                 .channels_min = 1,
2137                 .channels_max = 2,
2138                 .rates = AIC3262_RATES,
2139                 .formats = AIC3262_FORMATS},
2140         .capture = { /* dummy for fast DAI switching */
2141                 .stream_name = "Capture",
2142                 .channels_min = 1,
2143                 .channels_max = 2,
2144                 .rates = AIC3262_RATES,
2145                 .formats = AIC3262_FORMATS},
2146         .ops = &aic3262_multi_i2s_dai_ops,
2147 },
2148 /* AIC3262 ASI2 DAI */
2149 {
2150         .name = "aic3262-asi2",
2151         .id = 2,
2152         .playback = {
2153                 .stream_name = "Playback",
2154                 .channels_min = 1,
2155                 .channels_max = 2,
2156                 .rates = AIC3262_RATES,
2157                 .formats = AIC3262_FORMATS,},
2158         .capture = {
2159                 .stream_name = "Capture",
2160                 .channels_min = 1,
2161                 .channels_max = 2,
2162                 .rates = AIC3262_RATES,
2163                 .formats = AIC3262_FORMATS,},
2164         .ops = &aic3262_multi_i2s_dai_ops,
2165
2166 },
2167 /* AIC3262 ASI3 DAI  */
2168 {
2169         .name = "aic3262-asi3",
2170         .id = 3,
2171         .playback = {
2172                 .stream_name = "Playback",
2173                 .channels_min = 1,
2174                 .channels_max = 2,
2175                 .rates = AIC3262_RATES,
2176                 .formats = AIC3262_FORMATS, },
2177         .capture = {
2178                 .stream_name = "Capture",
2179                 .channels_min = 1,
2180                 .channels_max = 2,
2181                 .rates = AIC3262_RATES,
2182                 .formats = AIC3262_FORMATS, },
2183         .ops = &aic3262_multi_i2s_dai_ops,
2184
2185 },
2186 };
2187
2188 /*
2189  *****************************************************************************
2190  * Initializations
2191  *****************************************************************************
2192  */
2193 /*
2194  * AIC3262 register cache
2195  * We are caching the registers here.
2196  * There is no point in caching the reset register.
2197  *
2198  * NOTE: In AIC3262, there are 127 registers supported in both page0 and page1
2199  *       The following table contains the page0 and page 1 and page 3
2200  *       registers values.
2201  */
2202 static const u8 aic3262_reg[AIC3262_CACHEREGNUM] = {
2203         0x00, 0x00, 0x10, 0x00, /* 0 */
2204         0x03, 0x40, 0x11, 0x08, /* 4 */
2205         0x00, 0x00, 0x00, 0x82, /* 8 */
2206         0x88, 0x00, 0x80, 0x02, /* 12 */
2207         0x00, 0x08, 0x01, 0x01, /* 16 */
2208         0x80, 0x01, 0x00, 0x04, /* 20 */
2209         0x00, 0x00, 0x01, 0x00, /* 24 */
2210         0x00, 0x00, 0x01, 0x00, /* 28 */
2211         0x00, 0x00, 0x00, 0x00, /* 32 */
2212         0x00, 0x00, 0x00, 0x00, /* 36 */
2213         0x00, 0x00, 0x00, 0x00, /* 40 */
2214         0x00, 0x00, 0x00, 0x00, /* 44 */
2215         0x00, 0x00, 0x00, 0x00, /* 48 */
2216         0x00, 0x42, 0x02, 0x02, /* 52 */
2217         0x42, 0x02, 0x02, 0x02, /* 56 */
2218         0x00, 0x00, 0x00, 0x01, /* 60 */
2219         0x01, 0x00, 0x14, 0x00, /* 64 */
2220         0x0C, 0x00, 0x00, 0x00, /* 68 */
2221         0x00, 0x00, 0x00, 0xEE, /* 72 */
2222         0x10, 0xD8, 0x10, 0xD8, /* 76 */
2223         0x00, 0x00, 0x88, 0x00, /* 80 */
2224         0x00, 0x00, 0x00, 0x00, /* 84 */
2225         0x7F, 0x00, 0x00, 0x00, /* 88 */
2226         0x00, 0x00, 0x00, 0x00, /* 92 */
2227         0x7F, 0x00, 0x00, 0x00, /* 96 */
2228         0x00, 0x00, 0x00, 0x00, /* 100 */
2229         0x00, 0x00, 0x00, 0x00, /* 104 */
2230         0x00, 0x00, 0x00, 0x00, /* 108 */
2231         0x00, 0x00, 0x00, 0x00, /* 112 */
2232         0x00, 0x00, 0x00, 0x00, /* 116 */
2233         0x00, 0x00, 0x00, 0x00, /* 120 */
2234         0x00, 0x00, 0x00, 0x00, /* 124 - PAGE0 Registers(127) ends here */
2235         0x01, 0x00, 0x08, 0x00, /* 128, PAGE1-0 */
2236         0x00, 0x00, 0x00, 0x00, /* 132, PAGE1-4 */
2237         0x00, 0x00, 0x00, 0x10, /* 136, PAGE1-8 */
2238         0x00, 0x00, 0x00, 0x00, /* 140, PAGE1-12 */
2239         0x40, 0x40, 0x40, 0x40, /* 144, PAGE1-16 */
2240         0x00, 0x00, 0x00, 0x00, /* 148, PAGE1-20 */
2241         0x00, 0x00, 0x00, 0x00, /* 152, PAGE1-24 */
2242         0x00, 0x00, 0x00, 0x00, /* 156, PAGE1-28 */
2243         0x00, 0x00, 0x00, 0x00, /* 160, PAGE1-32 */
2244         0x00, 0x00, 0x00, 0x00, /* 164, PAGE1-36 */
2245         0x00, 0x00, 0x00, 0x00, /* 168, PAGE1-40 */
2246         0x00, 0x00, 0x00, 0x00, /* 172, PAGE1-44 */
2247         0x00, 0x00, 0x00, 0x00, /* 176, PAGE1-48 */
2248         0x00, 0x00, 0x00, 0x00, /* 180, PAGE1-52 */
2249         0x00, 0x00, 0x00, 0x80, /* 184, PAGE1-56 */
2250         0x80, 0x00, 0x00, 0x00, /* 188, PAGE1-60 */
2251         0x00, 0x00, 0x00, 0x00, /* 192, PAGE1-64 */
2252         0x00, 0x00, 0x00, 0x00, /* 196, PAGE1-68 */
2253         0x00, 0x00, 0x00, 0x00, /* 200, PAGE1-72 */
2254         0x00, 0x00, 0x00, 0x00, /* 204, PAGE1-76 */
2255         0x00, 0x00, 0x00, 0x00, /* 208, PAGE1-80 */
2256         0x00, 0x00, 0x00, 0x00, /* 212, PAGE1-84 */
2257         0x00, 0x00, 0x00, 0x00, /* 216, PAGE1-88 */
2258         0x00, 0x00, 0x00, 0x00, /* 220, PAGE1-92 */
2259         0x00, 0x00, 0x00, 0x00, /* 224, PAGE1-96 */
2260         0x00, 0x00, 0x00, 0x00, /* 228, PAGE1-100 */
2261         0x00, 0x00, 0x00, 0x00, /* 232, PAGE1-104 */
2262         0x00, 0x00, 0x00, 0x00, /* 236, PAGE1-108 */
2263         0x00, 0x00, 0x00, 0x00, /* 240, PAGE1-112 */
2264         0x00, 0x00, 0x00, 0x00, /* 244, PAGE1-116 */
2265         0x00, 0x00, 0x00, 0x00, /* 248, PAGE1-120 */
2266         0x00, 0x00, 0x00, 0x00, /* 252, PAGE1-124 Page 1 Registers Ends Here */
2267         0x00, 0x00, 0x00, 0x00, /* 256, PAGE2-0  */
2268         0x00, 0x00, 0x00, 0x00, /* 260, PAGE2-4  */
2269         0x00, 0x00, 0x00, 0x00, /* 264, PAGE2-8  */
2270         0x00, 0x00, 0x00, 0x00, /* 268, PAGE2-12 */
2271         0x00, 0x00, 0x00, 0x00, /* 272, PAGE2-16 */
2272         0x00, 0x00, 0x00, 0x00, /* 276, PAGE2-20 */
2273         0x00, 0x00, 0x00, 0x00, /* 280, PAGE2-24 */
2274         0x00, 0x00, 0x00, 0x00, /* 284, PAGE2-28 */
2275         0x00, 0x00, 0x00, 0x00, /* 288, PAGE2-32 */
2276         0x00, 0x00, 0x00, 0x00, /* 292, PAGE2-36 */
2277         0x00, 0x00, 0x00, 0x00, /* 296, PAGE2-40 */
2278         0x00, 0x00, 0x00, 0x00, /* 300, PAGE2-44 */
2279         0x00, 0x00, 0x00, 0x00, /* 304, PAGE2-48 */
2280         0x00, 0x00, 0x00, 0x00, /* 308, PAGE2-52 */
2281         0x00, 0x00, 0x00, 0x00, /* 312, PAGE2-56 */
2282         0x00, 0x00, 0x00, 0x00, /* 316, PAGE2-60 */
2283         0x00, 0x00, 0x00, 0x00, /* 320, PAGE2-64 */
2284         0x00, 0x00, 0x00, 0x00, /* 324, PAGE2-68 */
2285         0x00, 0x00, 0x00, 0x00, /* 328, PAGE2-72 */
2286         0x00, 0x00, 0x00, 0x00, /* 332, PAGE2-76 */
2287         0x00, 0x00, 0x00, 0x00, /* 336, PAGE2-80 */
2288         0x00, 0x00, 0x00, 0x00, /* 340, PAGE2-84 */
2289         0x00, 0x00, 0x00, 0x00, /* 344, PAGE2-88 */
2290         0x00, 0x00, 0x00, 0x00, /* 348, PAGE2-92 */
2291         0x00, 0x00, 0x00, 0x00, /* 352, PAGE2-96 */
2292         0x00, 0x00, 0x00, 0x00, /* 356, PAGE2-100 */
2293         0x00, 0x00, 0x00, 0x00, /* 360, PAGE2-104 */
2294         0x00, 0x00, 0x00, 0x00, /* 364, PAGE2-108 */
2295         0x00, 0x00, 0x00, 0x00, /* 368, PAGE2-112*/
2296         0x00, 0x00, 0x00, 0x00, /* 372, PAGE2-116*/
2297         0x00, 0x00, 0x00, 0x00, /* 376, PAGE2-120*/
2298         0x00, 0x00, 0x00, 0x00, /* 380, PAGE2-124 Page 2 Registers Ends Here */
2299         0x00, 0x00, 0x00, 0x00, /* 384, PAGE3-0  */
2300         0x00, 0x00, 0x00, 0x00, /* 388, PAGE3-4  */
2301         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-8  */
2302         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-12  */
2303         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-16  */
2304         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-20  */
2305         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-24  */
2306         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-28  */
2307         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-32  */
2308         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-36  */
2309         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-40  */
2310         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-44  */
2311         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-48  */
2312         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-52  */
2313         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-56  */
2314         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-60  */
2315         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-64  */
2316         0x00, 0x00, 0x00, 0x00, /* 392, PAGE3-68  */
2317         0x00, 0x00, 0x00, 0x00, /* 328, PAGE3-72 */
2318         0x00, 0x00, 0x00, 0x00, /* 332, PAGE3-76 */
2319         0x00, 0x00, 0x00, 0x00, /* 336, PAGE3-80 */
2320         0x00, 0x00, 0x00, 0x00, /* 340, PAGE3-84 */
2321         0x00, 0x00, 0x00, 0x00, /* 344, PAGE3-88 */
2322         0x00, 0x00, 0x00, 0x00, /* 348, PAGE3-92 */
2323         0x00, 0x00, 0x00, 0x00, /* 352, PAGE3-96 */
2324         0x00, 0x00, 0x00, 0x00, /* 356, PAGE3-100 */
2325         0x00, 0x00, 0x00, 0x00, /* 360, PAGE3-104 */
2326         0x00, 0x00, 0x00, 0x00, /* 364, PAGE3-108 */
2327         0x00, 0x00, 0x00, 0x00, /* 368, PAGE3-112*/
2328         0x00, 0x00, 0x00, 0x00, /* 372, PAGE3-116*/
2329         0x00, 0x00, 0x00, 0x00, /* 376, PAGE3-120*/
2330         0x00, 0x00, 0x00, 0x00, /* 380, PAGE3-124 Page 3 Registers Ends Here */
2331         0x00, 0x00, 0x00, 0x00, /* 384, PAGE4-0  */
2332         0x00, 0x00, 0x00, 0x00, /* 388, PAGE4-4  */
2333         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-8  */
2334         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-12  */
2335         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-16  */
2336         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-20  */
2337         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-24  */
2338         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-28  */
2339         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-32  */
2340         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-36  */
2341         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-40  */
2342         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-44  */
2343         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-48  */
2344         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-52  */
2345         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-56  */
2346         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-60  */
2347         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-64  */
2348         0x00, 0x00, 0x00, 0x00, /* 392, PAGE4-68  */
2349         0x00, 0x00, 0x00, 0x00, /* 328, PAGE4-72 */
2350         0x00, 0x00, 0x00, 0x00, /* 332, PAGE4-76 */
2351         0x00, 0x00, 0x00, 0x00, /* 336, PAGE4-80 */
2352         0x00, 0x00, 0x00, 0x00, /* 340, PAGE4-84 */
2353         0x00, 0x00, 0x00, 0x00, /* 344, PAGE4-88 */
2354         0x00, 0x00, 0x00, 0x00, /* 348, PAGE4-92 */
2355         0x00, 0x00, 0x00, 0x00, /* 352, PAGE4-96 */
2356         0x00, 0x00, 0x00, 0x00, /* 356, PAGE4-100 */
2357         0x00, 0x00, 0x00, 0x00, /* 360, PAGE4-104 */
2358         0x00, 0x00, 0x00, 0x00, /* 364, PAGE4-108 */
2359         0x00, 0x00, 0x00, 0x00, /* 368, PAGE4-112*/
2360         0x00, 0x00, 0x00, 0x00, /* 372, PAGE4-116*/
2361         0x00, 0x00, 0x00, 0x00, /* 376, PAGE4-120*/
2362         0x00, 0x00, 0x00, 0x00, /* 380, PAGE4-124 Page 2 Registers Ends Here */
2363
2364 };
2365
2366 /*
2367  *------------------------------------------------------------------------------
2368  * aic3262 initialization data
2369  * This structure initialization contains the initialization required for
2370  * AIC326x.
2371  * These registers values (reg_val) are written into the respective AIC3262
2372  * register offset (reg_offset) to  initialize AIC326x.
2373  * These values are used in aic3262_init() function only.
2374  *------------------------------------------------------------------------------
2375  */
2376 static const struct aic3262_configs aic3262_reg_init[] = {
2377         /* CLOCKING */
2378
2379         {0, RESET_REG, 1},
2380         {0, RESET_REG, 0},
2381
2382         {0, PASI_DAC_DP_SETUP,  0xc0},  /*DAC */
2383         {0, DAC_MVOL_CONF,  0x00},      /*DAC un-muted*/
2384         /* set default volumes */
2385         {0, DAC_LVOL, 0x01},
2386         {0, DAC_RVOL, 0x01},
2387         {0, HPL_VOL,  0x3a},
2388         {0, HPR_VOL,  0x3a},
2389         {0, SPK_AMP_CNTL_R2, 0x14},
2390         {0, SPK_AMP_CNTL_R3, 0x14},
2391         {0, SPK_AMP_CNTL_R4, 0x33},
2392         {0, REC_AMP_CNTL_R5, 0x82},
2393         {0, RAMPR_VOL, 20},
2394         {0, RAMP_CNTL_R1, 70},
2395         {0, RAMP_CNTL_R2, 70},
2396
2397         /* DRC Defaults */
2398         {0, DRC_CNTL_R1, 0x6c},
2399         {0, DRC_CNTL_R2, 16},
2400
2401         /* DEPOP SETTINGS */
2402         {0, HP_DEPOP, 0x14},
2403         {0, RECV_DEPOP, 0x14},
2404
2405         {0, POWER_CONF, 0x00},   /* Disconnecting AVDD-DVD weak link*/
2406         {0, REF_PWR_DLY, 0x01},
2407         {0, CM_REG, 0x00},      /*CM - default*/
2408         {0, LDAC_PTM, 0},       /*LDAC_PTM - default*/
2409         {0, RDAC_PTM, 0},       /*RDAC_PTM - default*/
2410         {0, HP_CTL, 0x30},      /*HP output percentage - at 75%*/
2411         {0, LADC_VOL, 0x01},    /*LADC volume*/
2412         {0, RADC_VOL, 0x01},    /*RADC volume*/
2413
2414         {0, DAC_ADC_CLKIN_REG, 0x33},   /*DAC ADC CLKIN*/
2415         {0, PLL_CLKIN_REG, 0x00},       /*PLL CLKIN*/
2416         {0, PLL_PR_POW_REG, 0x11},      /*PLL Power=0-down, P=1, R=1 vals*/
2417         {0, 0x3d, 1},
2418
2419         {0, LMIC_PGA_PIN, 0x0}, /*IN1_L select - - 10k -LMICPGA_P*/
2420         {0, LMIC_PGA_MIN, 0x40},        /*CM to LMICPGA-M*/
2421         {0, RMIC_PGA_PIN, 0x0}, /*IN1_R select - - 10k -RMIC_PGA_P*/
2422         {0, RMIC_PGA_MIN, 0x0}, /*CM to RMICPGA_M*/
2423         {0, MIC_PWR_DLY , 33},  /*LMIC-PGA-POWERUP-DELAY - default*/
2424         {0, REF_PWR_DLY, 1},    /*FIXMELATER*/
2425
2426
2427         {0, ADC_CHANNEL_POW, 0x0}, /*ladc, radc ON , SOFT STEP disabled*/
2428         {0, ADC_FINE_GAIN, 0x00},   /*ladc - unmute, radc - unmute*/
2429         {0, MICL_PGA, 0x4f},
2430         {0, MICR_PGA, 0x4f},
2431         /*controls MicBias ext power based on B0_P1_R51_D6*/
2432         {0, MIC_BIAS_CNTL, 0x80},
2433         /*   ASI1 Configuration */
2434         {0, ASI1_BUS_FMT, 0},
2435         {0, ASI1_BWCLK_CNTL_REG, 0x00},         /* originaly 0x24*/
2436         {0, ASI1_BCLK_N_CNTL, 1},
2437         {0, ASI1_BCLK_N, 0x84},
2438
2439         {0, MA_CNTL, 0},                        /* Mixer Amp disabled */
2440         {0, LINE_AMP_CNTL_R2, 0x00},            /* Line Amp Cntl disabled */
2441
2442         /* ASI2 Configuration */
2443         {0, ASI2_BUS_FMT, 0},
2444         {0, ASI2_BCLK_N_CNTL, 1},
2445         {0, ASI2_BCLK_N, 0x84},
2446         {0, ASI2_BWCLK_OUT_CNTL, 0x20},
2447
2448         {0, BEEP_CNTL_R1, 0x05},
2449         {0, BEEP_CNTL_R2, 0x04},
2450
2451         /* Interrupt config for headset detection */
2452         //{0, INT1_CNTL, 0x80}, /*Enable INT after Jack Registration*/
2453         {0, INT_FMT, 0x40},
2454         {0, GPIO1_IO_CNTL, 0x14},
2455         /* enables debounce with 512ms*/
2456         {0, HP_DETECT, 0x96},
2457
2458 #if defined(CONFIG_MINI_DSP)
2459         {0, 60, 0},
2460         {0, 61, 0},
2461         /* Added the below set of values after consulting the miniDSP
2462          * Program Section Array
2463          */
2464         {0, MINIDSP_ACCESS_CTRL, 0x00},
2465 #endif
2466
2467
2468 };
2469
2470 static int reg_init_size =
2471         sizeof(aic3262_reg_init) / sizeof(struct aic3262_configs);
2472
2473 static const unsigned int adc_ma_tlv[] = {
2474 TLV_DB_RANGE_HEAD(4),
2475         0, 29, TLV_DB_SCALE_ITEM(-1450, 500, 0),
2476         30, 35, TLV_DB_SCALE_ITEM(-2060, 1000, 0),
2477         36, 38, TLV_DB_SCALE_ITEM(-2660, 2000, 0),
2478         39, 40, TLV_DB_SCALE_ITEM(-3610, 5000, 0),
2479 };
2480 static const DECLARE_TLV_DB_SCALE(lo_hp_tlv, -7830, 50, 0);
2481
2482 static const struct snd_kcontrol_new mal_pga_mixer_controls[] = {
2483         SOC_DAPM_SINGLE("IN1L Switch", MA_CNTL, 5, 1, 0),
2484         SOC_DAPM_SINGLE_TLV("Left MicPGA Volume", LADC_PGA_MAL_VOL, 0,
2485                                                         0x3f, 1, adc_ma_tlv),
2486
2487 };
2488
2489 static const struct snd_kcontrol_new mar_pga_mixer_controls[] = {
2490         SOC_DAPM_SINGLE("IN1R Switch", MA_CNTL, 4, 1, 0),
2491         SOC_DAPM_SINGLE_TLV("Right MicPGA Volume", RADC_PGA_MAR_VOL, 0,
2492                                                         0x3f, 1, adc_ma_tlv),
2493 };
2494
2495 /* Left HPL Mixer */
2496 static const struct snd_kcontrol_new hpl_output_mixer_controls[] = {
2497         SOC_DAPM_SINGLE("MAL Switch", HP_AMP_CNTL_R1, 7, 1, 0),
2498         SOC_DAPM_SINGLE("LDAC Switch", HP_AMP_CNTL_R1, 5, 1, 0),
2499         SOC_DAPM_SINGLE_TLV("LOL-B1 Volume", HP_AMP_CNTL_R2, 0,
2500                                                         0x7f, 1, lo_hp_tlv),
2501 };
2502
2503 /* Right HPR Mixer */
2504 static const struct snd_kcontrol_new hpr_output_mixer_controls[] = {
2505         SOC_DAPM_SINGLE_TLV("LOR-B1 Volume", HP_AMP_CNTL_R3, 0,
2506                                                         0x7f, 1, lo_hp_tlv),
2507         SOC_DAPM_SINGLE("LDAC Switch", HP_AMP_CNTL_R1,   2, 1, 0),
2508         SOC_DAPM_SINGLE("RDAC Switch", HP_AMP_CNTL_R1, 4, 1, 0),
2509         SOC_DAPM_SINGLE("MAR Switch", HP_AMP_CNTL_R1, 6, 1, 0),
2510 };
2511
2512 /* Left LOL Mixer */
2513 static const struct snd_kcontrol_new lol_output_mixer_controls[] = {
2514         SOC_DAPM_SINGLE("MAL Switch", LINE_AMP_CNTL_R2, 7, 1, 0),
2515         SOC_DAPM_SINGLE("IN1L-B Switch", LINE_AMP_CNTL_R2, 3, 1,0),
2516         SOC_DAPM_SINGLE("LDAC Switch", LINE_AMP_CNTL_R1, 7, 1, 0),
2517         SOC_DAPM_SINGLE("RDAC Switch", LINE_AMP_CNTL_R1, 5, 1, 0),
2518 };
2519
2520 /* Right LOR Mixer */
2521 static const struct snd_kcontrol_new lor_output_mixer_controls[] = {
2522         SOC_DAPM_SINGLE("LOL Switch", LINE_AMP_CNTL_R1, 2, 1, 0),
2523         SOC_DAPM_SINGLE("RDAC Switch", LINE_AMP_CNTL_R1, 6, 1, 0),
2524         SOC_DAPM_SINGLE("MAR Switch", LINE_AMP_CNTL_R2, 6, 1, 0),
2525         SOC_DAPM_SINGLE("IN1R-B Switch", LINE_AMP_CNTL_R2, 0, 1,0),
2526 };
2527
2528 /* Left SPKL Mixer */
2529 static const struct snd_kcontrol_new spkl_output_mixer_controls[] = {
2530         SOC_DAPM_SINGLE("MAL Switch", SPK_AMP_CNTL_R1, 7, 1, 0),
2531         SOC_DAPM_SINGLE_TLV("LOL Volume", SPK_AMP_CNTL_R2, 0, 0x7f,0,
2532                                                                 lo_hp_tlv),
2533         SOC_DAPM_SINGLE("SPR_IN Switch", SPK_AMP_CNTL_R1, 2, 1, 0),
2534 };
2535
2536 /* Right SPKR Mixer */
2537 static const struct snd_kcontrol_new spkr_output_mixer_controls[] = {
2538         SOC_DAPM_SINGLE_TLV("LOR Volume", SPK_AMP_CNTL_R3, 0, 0x7f, 0,
2539                                                                 lo_hp_tlv),
2540         SOC_DAPM_SINGLE("MAR Switch", SPK_AMP_CNTL_R1, 6, 1, 0),
2541 };
2542
2543 /* REC Mixer */
2544 static const struct snd_kcontrol_new rec_output_mixer_controls[] = {
2545         SOC_DAPM_SINGLE_TLV("LOL-B2 Volume", RAMP_CNTL_R1, 0, 0x7f,0,
2546                                                         lo_hp_tlv),
2547         SOC_DAPM_SINGLE_TLV("IN1L Volume", IN1L_SEL_RM, 0, 0x7f, 1, lo_hp_tlv),
2548         SOC_DAPM_SINGLE_TLV("IN1R Volume", IN1R_SEL_RM, 0, 0x7f, 1, lo_hp_tlv),
2549         SOC_DAPM_SINGLE_TLV("LOR-B2 Volume", RAMP_CNTL_R2, 0,0x7f, 0,lo_hp_tlv),
2550 };
2551
2552 /* Left Input Mixer */
2553 static const struct snd_kcontrol_new left_input_mixer_controls[] = {
2554         SOC_DAPM_SINGLE("IN1L Switch", LMIC_PGA_PIN, 6, 1, 0),
2555         SOC_DAPM_SINGLE("IN2L Switch", LMIC_PGA_PIN, 4, 1, 0),
2556         SOC_DAPM_SINGLE("IN3L Switch", LMIC_PGA_PIN, 2, 1, 0),
2557         SOC_DAPM_SINGLE("IN4L Switch", LMIC_PGA_PM_IN4, 5, 1, 0),
2558         SOC_DAPM_SINGLE("IN1R Switch", LMIC_PGA_PIN, 0, 1, 0),
2559         SOC_DAPM_SINGLE("IN2R Switch", LMIC_PGA_MIN, 4, 1, 0),
2560         SOC_DAPM_SINGLE("IN3R Switch", LMIC_PGA_MIN, 2, 1, 0),
2561         SOC_DAPM_SINGLE("IN4R Switch", LMIC_PGA_PM_IN4, 4, 1, 0),
2562         SOC_DAPM_SINGLE("CM2L Switch", LMIC_PGA_MIN, 0, 1, 0),
2563         SOC_DAPM_SINGLE("CM1L Switch", LMIC_PGA_MIN, 6, 1, 0),
2564 };
2565
2566 /* Right Input Mixer */
2567 static const struct snd_kcontrol_new right_input_mixer_controls[] = {
2568         SOC_DAPM_SINGLE("IN1R Switch", RMIC_PGA_PIN, 6, 1, 0),
2569         SOC_DAPM_SINGLE("IN2R Switch", RMIC_PGA_PIN, 4, 1, 0),
2570         SOC_DAPM_SINGLE("IN3R Switch", RMIC_PGA_PIN, 2, 1, 0),
2571         SOC_DAPM_SINGLE("IN4R Switch", RMIC_PGA_PM_IN4, 5, 1, 0),
2572         SOC_DAPM_SINGLE("IN2L Switch", RMIC_PGA_PIN, 0, 1, 0),
2573         SOC_DAPM_SINGLE("IN1L Switch", RMIC_PGA_MIN, 4, 1, 0),
2574         SOC_DAPM_SINGLE("IN3L Switch", RMIC_PGA_MIN, 2, 1, 0),
2575         SOC_DAPM_SINGLE("IN4L Switch", RMIC_PGA_PM_IN4, 4, 1, 0),
2576         SOC_DAPM_SINGLE("CM1R Switch", RMIC_PGA_MIN, 6, 1, 0),
2577         SOC_DAPM_SINGLE("CM2R Switch", RMIC_PGA_MIN, 0, 1, 0),
2578 };
2579
2580
2581 static const char *asi1lin_text[] = {
2582         "Off", "ASI1 Left In","ASI1 Right In","ASI1 MonoMix In"
2583 };
2584
2585 SOC_ENUM_SINGLE_DECL(asi1lin_enum, ASI1_DAC_OUT_CNTL, 6, asi1lin_text);
2586
2587 static const struct snd_kcontrol_new asi1lin_control =
2588         SOC_DAPM_ENUM("ASI1LIN Route", asi1lin_enum);
2589
2590
2591 static const char *asi1rin_text[] = {
2592         "Off", "ASI1 Right In","ASI1 Left In","ASI1 MonoMix In"
2593 };
2594
2595 SOC_ENUM_SINGLE_DECL(asi1rin_enum, ASI1_DAC_OUT_CNTL, 4, asi1rin_text);
2596
2597 static const struct snd_kcontrol_new asi1rin_control =
2598         SOC_DAPM_ENUM("ASI1RIN Route", asi1rin_enum);
2599
2600 static const char *asi2lin_text[] = {
2601         "Off", "ASI2 Left In","ASI2 Right In","ASI2 MonoMix In"
2602 };
2603
2604 SOC_ENUM_SINGLE_DECL(asi2lin_enum, ASI2_DAC_OUT_CNTL, 6, asi2lin_text);
2605 static const struct snd_kcontrol_new asi2lin_control =
2606         SOC_DAPM_ENUM("ASI2LIN Route", asi2lin_enum);
2607
2608 static const char *asi2rin_text[] = {
2609         "Off", "ASI2 Right In","ASI2 Left In","ASI2 MonoMix In"
2610 };
2611
2612
2613 SOC_ENUM_SINGLE_DECL(asi2rin_enum, ASI2_DAC_OUT_CNTL, 4, asi2rin_text);
2614
2615 static const struct snd_kcontrol_new asi2rin_control =
2616         SOC_DAPM_ENUM("ASI2RIN Route", asi2rin_enum);
2617
2618 static const char *asi3lin_text[] = {
2619         "Off", "ASI3 Left In","ASI3 Right In","ASI3 MonoMix In"
2620 };
2621
2622
2623 SOC_ENUM_SINGLE_DECL(asi3lin_enum, ASI3_DAC_OUT_CNTL, 6, asi3lin_text);
2624 static const struct snd_kcontrol_new asi3lin_control =
2625                         SOC_DAPM_ENUM("ASI3LIN Route", asi3lin_enum);
2626
2627
2628 static const char *asi3rin_text[] = {
2629         "Off", "ASI3 Right In","ASI3 Left In","ASI3 MonoMix In"
2630 };
2631
2632
2633 SOC_ENUM_SINGLE_DECL(asi3rin_enum, ASI3_DAC_OUT_CNTL, 4, asi3rin_text);
2634 static const struct snd_kcontrol_new asi3rin_control =
2635         SOC_DAPM_ENUM("ASI3RIN Route", asi3rin_enum);
2636
2637
2638 static const char *dacminidspin1_text[] = {
2639         "ASI1 In", "ASI2 In","ASI3 In","ADC MiniDSP Out"
2640 };
2641
2642 SOC_ENUM_SINGLE_DECL(dacminidspin1_enum, MINIDSP_PORT_CNTL_REG, 4, dacminidspin1_text);
2643 static const struct snd_kcontrol_new dacminidspin1_control =
2644         SOC_DAPM_ENUM("DAC MiniDSP IN1 Route", dacminidspin1_enum);
2645
2646 static const char *asi1out_text[] = {
2647         "Off",
2648         "ASI1 Out",
2649         "ASI1In Bypass",
2650         "ASI2In Bypass",
2651         "ASI3In Bypass",
2652 };
2653 SOC_ENUM_SINGLE_DECL(asi1out_enum, ASI1_ADC_INPUT_CNTL, 0, asi1out_text);
2654 static const struct snd_kcontrol_new asi1out_control =
2655         SOC_DAPM_ENUM("ASI1OUT Route", asi1out_enum);
2656
2657 static const char *asi2out_text[] = {
2658         "Off",
2659         "ASI1 Out",
2660         "ASI1In Bypass",
2661         "ASI2In Bypass",
2662         "ASI3In Bypass",
2663         "ASI2 Out",
2664 };
2665 SOC_ENUM_SINGLE_DECL(asi2out_enum, ASI2_ADC_INPUT_CNTL, 0, asi2out_text);
2666 static const struct snd_kcontrol_new asi2out_control =
2667         SOC_DAPM_ENUM("ASI2OUT Route", asi2out_enum);
2668 static const char *asi3out_text[] = {
2669         "Off",
2670         "ASI1 Out",
2671         "ASI1In Bypass",
2672         "ASI2In Bypass",
2673         "ASI3In Bypass",
2674         "ASI3 Out",
2675 };
2676 SOC_ENUM_SINGLE_DECL(asi3out_enum, ASI3_ADC_INPUT_CNTL, 0, asi3out_text);
2677 static const struct snd_kcontrol_new asi3out_control =
2678         SOC_DAPM_ENUM("ASI3OUT Route", asi3out_enum);
2679
2680 static const char *asi1bclk_text[] = {
2681         "DAC_CLK",
2682         "DAC_MOD_CLK",
2683         "ADC_CLK",
2684         "ADC_MOD_CLK",
2685 };
2686
2687 static int aic326x_hp_event(struct snd_soc_dapm_widget *w,
2688                 struct snd_kcontrol *kcontrol, int event)
2689 {
2690         return 0;
2691 }
2692 static int pll_power_on_event(struct snd_soc_dapm_widget *w,
2693         struct snd_kcontrol *kcontrol, int event)
2694 {
2695         if (event == SND_SOC_DAPM_POST_PMU)
2696         {
2697                 mdelay(10);
2698         }
2699         return 0;
2700 }
2701 static const struct snd_soc_dapm_widget aic3262_dapm_widgets[] = {
2702         /* TODO: Can we switch these off ? */
2703         SND_SOC_DAPM_AIF_IN("ASI1IN", "ASI1 Playback", 0, SND_SOC_NOPM, 0, 0),
2704         SND_SOC_DAPM_AIF_IN("ASI2IN", "ASI2 Playback", 0, SND_SOC_NOPM, 0, 0),
2705         SND_SOC_DAPM_AIF_IN("ASI3IN", "ASI3 Playback", 0, SND_SOC_NOPM, 0, 0),
2706
2707         SND_SOC_DAPM_DAC("Left DAC", NULL, PASI_DAC_DP_SETUP, 7, 0),
2708         SND_SOC_DAPM_DAC("Right DAC", NULL, PASI_DAC_DP_SETUP, 6, 0),
2709
2710
2711         /* dapm widget (path domain) for HPL Output Mixer */
2712         SND_SOC_DAPM_MIXER("HPL Output Mixer", SND_SOC_NOPM, 0, 0,
2713                  &hpl_output_mixer_controls[0],
2714                 ARRAY_SIZE(hpl_output_mixer_controls)),
2715
2716         /* dapm widget (path domain) for HPR Output Mixer */
2717         SND_SOC_DAPM_MIXER("HPR Output Mixer", SND_SOC_NOPM, 0, 0,
2718                         &hpr_output_mixer_controls[0],
2719                         ARRAY_SIZE(hpr_output_mixer_controls)),
2720
2721
2722         SND_SOC_DAPM_PGA_E("HPL Driver", HP_AMP_CNTL_R1, 1, 0, NULL, 0,
2723                                 aic326x_hp_event, SND_SOC_DAPM_POST_PMU),
2724         SND_SOC_DAPM_PGA_E("HPR Driver", HP_AMP_CNTL_R1, 0, 0, NULL, 0,
2725                                 aic326x_hp_event, SND_SOC_DAPM_POST_PMU),
2726
2727
2728         /* dapm widget (path domain) for LOL Output Mixer */
2729         SND_SOC_DAPM_MIXER("LOL Output Mixer", SND_SOC_NOPM, 0, 0,
2730                         &lol_output_mixer_controls[0],
2731                         ARRAY_SIZE(lol_output_mixer_controls)),
2732
2733         /* dapm widget (path domain) for LOR Output Mixer mixer */
2734         SND_SOC_DAPM_MIXER("LOR Output Mixer", SND_SOC_NOPM, 0, 0,
2735                         &lor_output_mixer_controls[0],
2736                         ARRAY_SIZE(lor_output_mixer_controls)),
2737
2738         SND_SOC_DAPM_PGA("LOL Driver", LINE_AMP_CNTL_R1, 1, 0, NULL, 0),
2739         SND_SOC_DAPM_PGA("LOR Driver", LINE_AMP_CNTL_R1, 0, 0, NULL, 0),
2740
2741
2742         /* dapm widget (path domain) for SPKL Output Mixer */
2743         SND_SOC_DAPM_MIXER("SPKL Output Mixer", SND_SOC_NOPM, 0, 0,
2744                         &spkl_output_mixer_controls[0],
2745                         ARRAY_SIZE(spkl_output_mixer_controls)),
2746
2747         /* dapm widget (path domain) for SPKR Output Mixer */
2748         SND_SOC_DAPM_MIXER("SPKR Output Mixer", SND_SOC_NOPM, 0, 0,
2749                         &spkr_output_mixer_controls[0],
2750                         ARRAY_SIZE(spkr_output_mixer_controls)),
2751
2752         SND_SOC_DAPM_PGA("SPKL Driver", SPK_AMP_CNTL_R1, 1, 0, NULL, 0),
2753         SND_SOC_DAPM_PGA("SPKR Driver", SPK_AMP_CNTL_R1, 0, 0, NULL, 0),
2754
2755
2756         /* dapm widget (path domain) for SPKR Output Mixer */
2757         SND_SOC_DAPM_MIXER("REC Output Mixer", SND_SOC_NOPM, 0, 0,
2758                         &rec_output_mixer_controls[0],
2759                         ARRAY_SIZE(rec_output_mixer_controls)),
2760
2761         SND_SOC_DAPM_PGA("RECP Driver", REC_AMP_CNTL_R5, 7, 0, NULL, 0),
2762         SND_SOC_DAPM_PGA("RECM Driver", REC_AMP_CNTL_R5, 6, 0, NULL, 0),
2763
2764
2765         SND_SOC_DAPM_MUX("ASI1LIN Route",
2766                 SND_SOC_NOPM, 0, 0, &asi1lin_control),
2767         SND_SOC_DAPM_MUX("ASI1RIN Route",
2768                 SND_SOC_NOPM, 0, 0, &asi1rin_control),
2769         SND_SOC_DAPM_MUX("ASI2LIN Route",
2770                 SND_SOC_NOPM, 0, 0, &asi2lin_control),
2771         SND_SOC_DAPM_MUX("ASI2RIN Route",
2772                 SND_SOC_NOPM, 0, 0, &asi2rin_control),
2773         SND_SOC_DAPM_MUX("ASI3LIN Route",
2774                 SND_SOC_NOPM, 0, 0, &asi3lin_control),
2775         SND_SOC_DAPM_MUX("ASI3RIN Route",
2776                 SND_SOC_NOPM, 0, 0, &asi3rin_control),
2777
2778         SND_SOC_DAPM_PGA("ASI1LIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2779         SND_SOC_DAPM_PGA("ASI1RIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2780         SND_SOC_DAPM_PGA("ASI2LIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2781         SND_SOC_DAPM_PGA("ASI2RIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2782         SND_SOC_DAPM_PGA("ASI3LIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2783         SND_SOC_DAPM_PGA("ASI3RIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2784
2785         SND_SOC_DAPM_PGA("ASI1LOUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2786         SND_SOC_DAPM_PGA("ASI1ROUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2787         SND_SOC_DAPM_PGA("ASI2LOUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2788         SND_SOC_DAPM_PGA("ASI2ROUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2789         SND_SOC_DAPM_PGA("ASI3LOUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2790         SND_SOC_DAPM_PGA("ASI3ROUT", SND_SOC_NOPM, 0, 0, NULL, 0),
2791
2792         SND_SOC_DAPM_PGA("ASI1MonoMixIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2793         SND_SOC_DAPM_PGA("ASI2MonoMixIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2794         SND_SOC_DAPM_PGA("ASI3MonoMixIN", SND_SOC_NOPM, 0, 0, NULL, 0),
2795         /* TODO: Can we switch the ASIxIN off? */
2796         SND_SOC_DAPM_PGA("ASI1IN Port", SND_SOC_NOPM, 0, 0, NULL, 0),
2797         SND_SOC_DAPM_PGA("ASI2IN Port", SND_SOC_NOPM, 0, 0, NULL, 0),
2798         SND_SOC_DAPM_PGA("ASI3IN Port", SND_SOC_NOPM, 0, 0, NULL, 0),
2799
2800
2801         SND_SOC_DAPM_MUX("DAC MiniDSP IN1 Route",
2802                         SND_SOC_NOPM, 0, 0, &dacminidspin1_control),
2803
2804
2805         SND_SOC_DAPM_PGA("CM", SND_SOC_NOPM, 0, 0, NULL, 0),
2806         SND_SOC_DAPM_PGA("CM1L", SND_SOC_NOPM, 0, 0, NULL, 0),
2807         SND_SOC_DAPM_PGA("CM2L", SND_SOC_NOPM, 0, 0, NULL, 0),
2808         SND_SOC_DAPM_PGA("CM1R", SND_SOC_NOPM, 0, 0, NULL, 0),
2809         SND_SOC_DAPM_PGA("CM2R", SND_SOC_NOPM, 0, 0, NULL, 0),
2810
2811         /* TODO: Can we switch these off ? */
2812         SND_SOC_DAPM_AIF_OUT("ASI1OUT","ASI1 Capture", 0, SND_SOC_NOPM, 0, 0),
2813         SND_SOC_DAPM_AIF_OUT("ASI2OUT", "ASI2 Capture",0, SND_SOC_NOPM, 0, 0),
2814         SND_SOC_DAPM_AIF_OUT("ASI3OUT", "ASI3 Capture",0, SND_SOC_NOPM, 0, 0),
2815
2816         SND_SOC_DAPM_MUX("ASI1OUT Route",
2817                 SND_SOC_NOPM, 0, 0, &asi1out_control),
2818         SND_SOC_DAPM_MUX("ASI2OUT Route",
2819                 SND_SOC_NOPM, 0, 0, &asi2out_control),
2820         SND_SOC_DAPM_MUX("ASI3OUT Route",
2821                 SND_SOC_NOPM, 0, 0, &asi3out_control),
2822
2823         /* TODO: Will be used during MINIDSP programming */
2824         /* TODO: Can we switch them off? */
2825         SND_SOC_DAPM_PGA("ADC MiniDSP OUT1", SND_SOC_NOPM, 0, 0, NULL, 0),
2826         SND_SOC_DAPM_PGA("ADC MiniDSP OUT2", SND_SOC_NOPM, 0, 0, NULL, 0),
2827         SND_SOC_DAPM_PGA("ADC MiniDSP OUT3", SND_SOC_NOPM, 0, 0, NULL, 0),
2828
2829
2830         SND_SOC_DAPM_ADC("Left ADC", NULL, ADC_CHANNEL_POW, 7, 0),
2831         SND_SOC_DAPM_ADC("Right ADC", NULL, ADC_CHANNEL_POW, 6, 0),
2832
2833
2834         SND_SOC_DAPM_PGA("Left MicPGA",MICL_PGA, 7, 1, NULL, 0),
2835         SND_SOC_DAPM_PGA("Right MicPGA",MICR_PGA, 7, 1, NULL, 0),
2836
2837         SND_SOC_DAPM_PGA("MAL PGA", MA_CNTL, 3, 0, NULL, 0),
2838         SND_SOC_DAPM_PGA("MAR PGA", MA_CNTL, 2, 0, NULL, 0),
2839
2840
2841         /* dapm widget for MAL PGA Mixer*/
2842         SND_SOC_DAPM_MIXER("MAL PGA Mixer", SND_SOC_NOPM, 0, 0,
2843                          &mal_pga_mixer_controls[0],
2844                          ARRAY_SIZE(mal_pga_mixer_controls)),
2845
2846         /* dapm widget for MAR PGA Mixer*/
2847         SND_SOC_DAPM_MIXER("MAR PGA Mixer", SND_SOC_NOPM, 0, 0,
2848                         &mar_pga_mixer_controls[0],
2849                         ARRAY_SIZE(mar_pga_mixer_controls)),
2850
2851         /* dapm widget for Left Input Mixer*/
2852         SND_SOC_DAPM_MIXER("Left Input Mixer", SND_SOC_NOPM, 0, 0,
2853                         &left_input_mixer_controls[0],
2854                         ARRAY_SIZE(left_input_mixer_controls)),
2855
2856         /* dapm widget for Right Input Mixer*/
2857         SND_SOC_DAPM_MIXER("Right Input Mixer", SND_SOC_NOPM, 0, 0,
2858                         &right_input_mixer_controls[0],
2859                         ARRAY_SIZE(right_input_mixer_controls)),
2860
2861
2862         SND_SOC_DAPM_OUTPUT("HPL"),
2863         SND_SOC_DAPM_OUTPUT("HPR"),
2864         SND_SOC_DAPM_OUTPUT("LOL"),
2865         SND_SOC_DAPM_OUTPUT("LOR"),
2866         SND_SOC_DAPM_OUTPUT("SPKL"),
2867         SND_SOC_DAPM_OUTPUT("SPKR"),
2868         SND_SOC_DAPM_OUTPUT("RECP"),
2869         SND_SOC_DAPM_OUTPUT("RECM"),
2870
2871         SND_SOC_DAPM_INPUT("IN1L"),
2872         SND_SOC_DAPM_INPUT("IN2L"),
2873         SND_SOC_DAPM_INPUT("IN3L"),
2874         SND_SOC_DAPM_INPUT("IN4L"),
2875         SND_SOC_DAPM_INPUT("IN1R"),
2876         SND_SOC_DAPM_INPUT("IN2R"),
2877         SND_SOC_DAPM_INPUT("IN3R"),
2878         SND_SOC_DAPM_INPUT("IN4R"),
2879
2880
2881         SND_SOC_DAPM_MICBIAS("Mic Bias Ext", MIC_BIAS_CNTL, 6, 0),
2882         SND_SOC_DAPM_MICBIAS("Mic Bias Int", MIC_BIAS_CNTL, 2, 0),
2883
2884         SND_SOC_DAPM_SUPPLY("PLLCLK",PLL_PR_POW_REG,7,0,pll_power_on_event,
2885                                                 SND_SOC_DAPM_POST_PMU),
2886         SND_SOC_DAPM_SUPPLY("NDAC",NDAC_DIV_POW_REG,7,0, NULL, 0),
2887         SND_SOC_DAPM_SUPPLY("MDAC",MDAC_DIV_POW_REG,7,0, NULL, 0),
2888         SND_SOC_DAPM_SUPPLY("NADC",NADC_DIV_POW_REG,7,0, NULL, 0),
2889         SND_SOC_DAPM_SUPPLY("MADC",MADC_DIV_POW_REG,7,0, NULL, 0),
2890
2891
2892 };
2893
2894 static const struct snd_soc_dapm_route aic3262_dapm_routes[] ={
2895 /* TODO: Do we need only DACCLK for ASIIN's and ADCCLK for ASIOUT??? */
2896 /* Clock portion */
2897         {"NDAC", NULL, "PLLCLK"},
2898         {"MDAC", NULL, "NDAC"},
2899         {"ASI1IN", NULL , "NDAC"},
2900         {"ASI1IN", NULL , "NADC"},
2901         {"ASI1IN", NULL , "MDAC"},
2902         {"ASI1IN", NULL , "MADC"},
2903
2904         {"ASI1OUT", NULL , "NDAC"},
2905         {"ASI1OUT", NULL , "NADC"},
2906         {"ASI1OUT", NULL , "MDAC"},
2907         {"ASI1OUT", NULL , "MADC"},
2908
2909 #ifdef AIC3262_ASI1_MASTER
2910         {"ASI1IN", NULL , "ASI1_BCLK"},
2911         {"ASI1OUT", NULL , "ASI1_BCLK"},
2912         {"ASI1IN", NULL , "ASI1_WCLK"},
2913         {"ASI1OUT", NULL , "ASI1_WCLK"},
2914 #else
2915
2916 #endif
2917         {"ASI2IN", NULL , "NDAC"},
2918         {"ASI2IN", NULL , "NADC"},
2919         {"ASI2IN", NULL , "MDAC"},
2920         {"ASI2IN", NULL , "MADC"},
2921
2922         {"ASI2OUT", NULL , "NDAC"},
2923         {"ASI2OUT", NULL , "NADC"},
2924         {"ASI2OUT", NULL , "MDAC"},
2925         {"ASI2OUT", NULL , "MADC"},
2926
2927 #ifdef AIC3262_ASI2_MASTER
2928         {"ASI2IN", NULL , "ASI2_BCLK"},
2929         {"ASI2OUT", NULL , "ASI2_BCLK"},
2930         {"ASI2IN", NULL , "ASI2_WCLK"},
2931         {"ASI2OUT", NULL , "ASI2_WCLK"},
2932 #else
2933
2934 #endif
2935         {"ASI3IN", NULL , "NDAC"},
2936         {"ASI3IN", NULL , "NADC"},
2937         {"ASI3IN", NULL , "MDAC"},
2938         {"ASI3IN", NULL , "MADC"},
2939
2940         {"ASI3OUT", NULL , "NDAC"},
2941         {"ASI3OUT", NULL , "NADC"},
2942         {"ASI3OUT", NULL , "MDAC"},
2943         {"ASI3OUT", NULL , "MADC"},
2944
2945 #ifdef AIC3262_ASI3_MASTER
2946         {"ASI3IN", NULL , "ASI3_BCLK"},
2947         {"ASI3OUT", NULL , "ASI3_BCLK"},
2948         {"ASI3IN", NULL , "ASI3_WCLK"},
2949         {"ASI3OUT", NULL , "ASI3_WCLK"},
2950 #else
2951 #endif
2952 /* Playback (DAC) Portion */
2953         {"HPL Output Mixer","LDAC Switch","Left DAC"},
2954         {"HPL Output Mixer","MAL Switch","MAL PGA"},
2955         {"HPL Output Mixer","LOL-B1 Volume","LOL"},
2956
2957         {"HPR Output Mixer","LOR-B1 Volume","LOR"},
2958         {"HPR Output Mixer","LDAC Switch","Left DAC"},
2959         {"HPR Output Mixer","RDAC Switch","Right DAC"},
2960         {"HPR Output Mixer","MAR Switch","MAR PGA"},
2961
2962         {"HPL Driver",NULL,"HPL Output Mixer"},
2963         {"HPR Driver",NULL,"HPR Output Mixer"},
2964
2965         {"HPL",NULL,"HPL Driver"},
2966         {"HPR",NULL,"HPR Driver"},
2967
2968         {"LOL Output Mixer","MAL Switch","MAL PGA"},
2969         {"LOL Output Mixer","IN1L-B Switch","IN1L"},
2970         {"LOL Output Mixer","LDAC Switch","Left DAC"},
2971         {"LOL Output Mixer","RDAC Switch","Right DAC"},
2972
2973         {"LOR Output Mixer","LOL Switch","LOL"},
2974         {"LOR Output Mixer","RDAC Switch","Right DAC"},
2975         {"LOR Output Mixer","MAR Switch","MAR PGA"},
2976         {"LOR Output Mixer","IN1R-B Switch","IN1R"},
2977
2978         {"LOL Driver",NULL,"LOL Output Mixer"},
2979         {"LOR Driver",NULL,"LOR Output Mixer"},
2980
2981         {"LOL",NULL,"LOL Driver"},
2982         {"LOR",NULL,"LOR Driver"},
2983
2984         {"REC Output Mixer","LOL-B2 Volume","LOL"},
2985         {"REC Output Mixer","IN1L Volume","IN1L"},
2986         {"REC Output Mixer","IN1R Volume","IN1R"},
2987         {"REC Output Mixer","LOR-B2 Volume","LOR"},
2988
2989         {"RECP Driver",NULL,"REC Output Mixer"},
2990         {"RECM Driver",NULL,"REC Output Mixer"},
2991
2992         {"RECP",NULL,"RECP Driver"},
2993         {"RECM",NULL,"RECM Driver"},
2994
2995         {"SPKL Output Mixer","MAL Switch","MAL PGA"},
2996         {"SPKL Output Mixer","LOL Volume","LOL"},
2997         {"SPKL Output Mixer","SPR_IN Switch","SPKR Output Mixer"},
2998
2999         {"SPKR Output Mixer", "LOR Volume","LOR"},
3000         {"SPKR Output Mixer", "MAR Switch","MAR PGA"},
3001
3002
3003         {"SPKL Driver",NULL,"SPKL Output Mixer"},
3004         {"SPKR Driver",NULL,"SPKR Output Mixer"},
3005
3006         {"SPKL",NULL,"SPKL Driver"},
3007         {"SPKR",NULL,"SPKR Driver"},
3008 /* ASI Input routing */
3009         {"ASI1LIN", NULL, "ASI1IN"},
3010         {"ASI1RIN", NULL, "ASI1IN"},
3011         {"ASI2LIN", NULL, "ASI2IN"},
3012         {"ASI2RIN", NULL, "ASI2IN"},
3013         {"ASI3LIN", NULL, "ASI3IN"},
3014         {"ASI3RIN", NULL, "ASI3IN"},
3015
3016         {"ASI1MonoMixIN", NULL, "ASI1IN"},
3017         {"ASI2MonoMixIN", NULL, "ASI2IN"},
3018         {"ASI3MonoMixIN", NULL, "ASI3IN"},
3019
3020         {"ASI1LIN Route","ASI1 Left In","ASI1LIN"},
3021         {"ASI1LIN Route","ASI1 Right In","ASI1RIN"},
3022         {"ASI1LIN Route","ASI1 MonoMix In","ASI1MonoMixIN"},
3023
3024         {"ASI1RIN Route", "ASI1 Right In","ASI1RIN"},
3025         {"ASI1RIN Route","ASI1 Left In","ASI1LIN"},
3026         {"ASI1RIN Route","ASI1 MonoMix In","ASI1MonoMixIN"},
3027
3028
3029         {"ASI2LIN Route","ASI2 Left In","ASI2LIN"},
3030         {"ASI2LIN Route","ASI2 Right In","ASI2RIN"},
3031         {"ASI2LIN Route","ASI2 MonoMix In","ASI2MonoMixIN"},
3032
3033         {"ASI2RIN Route","ASI2 Right In","ASI2RIN"},
3034         {"ASI2RIN Route","ASI2 Left In","ASI2LIN"},
3035         {"ASI2RIN Route","ASI2 MonoMix In","ASI2MonoMixIN"},
3036
3037
3038         {"ASI3LIN Route","ASI3 Left In","ASI3LIN"},
3039         {"ASI3LIN Route","ASI3 Right In","ASI3RIN"},
3040         {"ASI3LIN Route","ASI3 MonoMix In","ASI3MonoMixIN"},
3041
3042         {"ASI3RIN Route","ASI3 Right In","ASI3RIN"},
3043         {"ASI3RIN Route","ASI3 Left In","ASI3LIN"},
3044         {"ASI3RIN Route","ASI3 MonoMix In","ASI3MonoMixIN"},
3045
3046         {"ASI1IN Port", NULL, "ASI1LIN Route"},
3047         {"ASI1IN Port", NULL, "ASI1RIN Route"},
3048         {"ASI2IN Port", NULL, "ASI2LIN Route"},
3049         {"ASI2IN Port", NULL, "ASI2RIN Route"},
3050         {"ASI3IN Port", NULL, "ASI3LIN Route"},
3051         {"ASI3IN Port", NULL, "ASI3RIN Route"},
3052
3053         {"DAC MiniDSP IN1 Route", "ASI1 In","ASI1IN Port"},
3054         {"DAC MiniDSP IN1 Route","ASI2 In","ASI2IN Port"},
3055         {"DAC MiniDSP IN1 Route","ASI3 In","ASI3IN Port"},
3056         {"DAC MiniDSP IN1 Route","ADC MiniDSP Out","ADC MiniDSP OUT1"},
3057
3058         {"Left DAC", "NULL", "DAC MiniDSP IN1 Route"},
3059         {"Right DAC", "NULL", "DAC MiniDSP IN1 Route"},
3060
3061
3062 /* Mixer Amplifier */
3063
3064         {"MAL PGA Mixer", "IN1L Switch","IN1L"},
3065         {"MAL PGA Mixer", "Left MicPGA Volume","Left MicPGA"},
3066
3067         {"MAL PGA", NULL, "MAL PGA Mixer"},
3068
3069
3070         {"MAR PGA Mixer", "IN1R Switch","IN1R"},
3071         {"MAR PGA Mixer", "Right MicPGA Volume","Right MicPGA"},
3072
3073         {"MAR PGA", NULL, "MAR PGA Mixer"},
3074
3075
3076 /* Capture (ADC) portions */
3077         /* Left Positive PGA input */
3078         {"Left Input Mixer","IN1L Switch","IN1L"},
3079         {"Left Input Mixer","IN2L Switch","IN2L"},
3080         {"Left Input Mixer","IN3L Switch","IN3L"},
3081         {"Left Input Mixer","IN4L Switch","IN4L"},
3082         {"Left Input Mixer","IN1R Switch","IN1R"},
3083         /* Left Negative PGA input */
3084         {"Left Input Mixer","IN2R Switch","IN2R"},
3085         {"Left Input Mixer","IN3R Switch","IN3R"},
3086         {"Left Input Mixer","IN4R Switch","IN4R"},
3087         {"Left Input Mixer","CM2L Switch","CM2L"},
3088         {"Left Input Mixer","CM1L Switch","CM1L"},
3089
3090         /* Right Positive PGA Input */
3091         {"Right Input Mixer","IN1R Switch","IN1R"},
3092         {"Right Input Mixer","IN2R Switch","IN2R"},
3093         {"Right Input Mixer","IN3R Switch","IN3R"},
3094         {"Right Input Mixer","IN4R Switch","IN4R"},
3095         {"Right Input Mixer","IN2L Switch","IN2L"},
3096
3097         /* Right Negative PGA Input */
3098         {"Right Input Mixer","IN1L Switch","IN1L"},
3099         {"Right Input Mixer","IN3L Switch","IN3L"},
3100         {"Right Input Mixer","IN4L Switch","IN4L"},
3101         {"Right Input Mixer","CM1R Switch","CM1R"},
3102         {"Right Input Mixer","CM2R Switch","CM2R"},
3103
3104         {"CM1L", NULL, "CM"},
3105         {"CM2L", NULL, "CM"},
3106         {"CM1R", NULL, "CM"},
3107         {"CM2R", NULL, "CM"},
3108
3109         {"Left MicPGA",NULL,"Left Input Mixer"},
3110         {"Right MicPGA",NULL,"Right Input Mixer"},
3111
3112         {"Left ADC", NULL, "Left MicPGA"},
3113         {"Right ADC", NULL, "Right MicPGA"},
3114
3115 /* ASI Output Routing */
3116         {"ADC MiniDSP OUT1", NULL, "Left ADC"},
3117         {"ADC MiniDSP OUT1", NULL, "Right ADC"},
3118
3119         {"ASI1OUT Route", "ASI1 Out","ADC MiniDSP OUT1"},// Port 1
3120         {"ASI1OUT Route", "ASI1In Bypass","ASI1IN Port"},
3121         {"ASI1OUT Route", "ASI2In Bypass","ASI2IN Port"},
3122         {"ASI1OUT Route", "ASI3In Bypass","ASI3IN Port"},
3123
3124         {"ASI2OUT Route", "ASI1 Out","ADC MiniDSP OUT1"},// Port 1
3125         {"ASI2OUT Route", "ASI1In Bypass","ASI1IN Port"},
3126         {"ASI2OUT Route", "ASI2In Bypass","ASI2IN Port"},
3127         {"ASI2OUT Route", "ASI3In Bypass","ASI3IN Port"},
3128         {"ASI2OUT Route", "ASI2 Out","ADC MiniDSP OUT2"},// Port 2
3129
3130         {"ASI3OUT Route", "ASI1 Out","ADC MiniDSP OUT1"},// Port 1
3131         {"ASI3OUT Route", "ASI1In Bypass","ASI1IN Port"},
3132         {"ASI3OUT Route", "ASI2In Bypass","ASI2IN Port"},
3133         {"ASI3OUT Route", "ASI3In Bypass","ASI3IN Port"},
3134         {"ASI3OUT Route", "ASI3 Out","ADC MiniDSP OUT3"},// Port 3
3135
3136         {"ASI1OUT",NULL,"ASI1OUT Route"},
3137         {"ASI2OUT",NULL,"ASI2OUT Route"},
3138         {"ASI3OUT",NULL,"ASI3OUT Route"},
3139
3140 };
3141
3142
3143 #define AIC3262_DAPM_ROUTE_NUM (sizeof(aic3262_dapm_routes)/sizeof(struct snd_soc_dapm_route))
3144
3145 /*
3146  *****************************************************************************
3147  * Function Definitions
3148  *****************************************************************************
3149  */
3150
3151
3152 /*
3153  *----------------------------------------------------------------------------
3154  * Function : aic3262_change_page
3155  * Purpose  : This function is to switch between page 0 and page 1.
3156  *
3157  *----------------------------------------------------------------------------
3158  */
3159 int aic3262_change_page(struct snd_soc_codec *codec, u8 new_page)
3160 {
3161         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3162         u8 data[2];
3163         int ret = 0;
3164
3165         data[0] = 0;
3166         data[1] = new_page;
3167         aic3262->page_no = new_page;
3168
3169 #if defined(LOCAL_REG_ACCESS)
3170         if (codec->hw_write(codec->control_data, data, 2) != 2)
3171                 ret = -EIO;
3172 #else
3173         ret = snd_soc_write(codec, data[0], data[1]);
3174 #endif
3175         if (ret)
3176                 printk(KERN_ERR "Error in changing page to %d\n", new_page);
3177
3178         /*DBG("# Changing page to %d\r\n", new_page);*/
3179
3180         return ret;
3181 }
3182 /*
3183  *----------------------------------------------------------------------------
3184  * Function : aic3262_change_book
3185  * Purpose  : This function is to switch between books
3186  *
3187  *----------------------------------------------------------------------------
3188  */
3189 int aic3262_change_book(struct snd_soc_codec *codec, u8 new_book)
3190 {
3191         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3192         u8 data[2];
3193         int ret = 0;
3194
3195         data[0] = 0x7F;
3196         data[1] = new_book;
3197         aic3262->book_no = new_book;
3198
3199         ret = aic3262_change_page(codec, 0);
3200         if (ret)
3201                 return ret;
3202
3203 #if defined(LOCAL_REG_ACCESS)
3204         if (codec->hw_write(codec->control_data, data, 2) != 2)
3205                 ret = -EIO;
3206 #else
3207         ret = snd_soc_write(codec, data[0], data[1]);
3208 #endif
3209         if (ret)
3210                 printk(KERN_ERR "Error in changing Book\n");
3211
3212         /*DBG("# Changing book to %d\r\n", new_book);*/
3213
3214         return ret;
3215 }
3216 /*
3217  *----------------------------------------------------------------------------
3218  * Function : aic3262_write_reg_cache
3219  * Purpose  : This function is to write aic3262 register cache
3220  *
3221  *----------------------------------------------------------------------------
3222  */
3223 void aic3262_write_reg_cache(struct snd_soc_codec *codec,
3224                                            u16 reg, u8 value)
3225 {
3226 #if defined(EN_REG_CACHE)
3227         u8 *cache = codec->reg_cache;
3228
3229         if (reg >= AIC3262_CACHEREGNUM)
3230                 return;
3231
3232         if (cache)
3233                 cache[reg] = value;
3234 #endif
3235 }
3236
3237 /*
3238  *----------------------------------------------------------------------------
3239  * Function : aic3262_read
3240  * Purpose  : This function is to read the aic3262 register space.
3241  *
3242  *----------------------------------------------------------------------------
3243  */
3244
3245 u8 aic3262_read(struct snd_soc_codec *codec, u16 reg)
3246 {
3247         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3248         u8 value;
3249         u8 page = reg / 128;
3250         u16 *cache = codec->reg_cache;
3251         u16 cmd;
3252         u8 buffer[2];
3253         int rc;
3254         reg = reg % 128;
3255
3256         if (reg >= AIC3262_CACHEREGNUM) {
3257                 return 0;
3258         }
3259
3260         if (aic3262->control_type == SND_SOC_I2C) {
3261                 if (aic3262->page_no != page) {
3262                 aic3262_change_page(codec, page);
3263                 }
3264                 i2c_master_send(codec->control_data, (char *)&reg, 1);
3265                 i2c_master_recv(codec->control_data, &value, 1);
3266                 /*DBG("r %2x %02x\r\n", reg, value); */
3267         } else if (aic3262->control_type == SND_SOC_SPI) {
3268                 u16 value;
3269
3270                 /* Do SPI transfer; first 16bits are command; remaining is
3271                  * register contents */
3272                 cmd = AIC3262_READ_COMMAND_WORD(reg);
3273                 buffer[0] = (cmd >> 8) & 0xff;
3274                 buffer[1] = cmd & 0xff;
3275                 //rc = spi_write_then_read(aic3262->spi, buffer, 2, buffer, 2);
3276
3277                 if (rc) {
3278                         dev_err(&aic3262->spi->dev, "AIC26 reg read error\n");
3279                         return -EIO;
3280                 }
3281                 value = (buffer[0] << 8) | buffer[1];
3282         } else {
3283                 printk(KERN_ERR "Unknown Interface Type in aic3262_read\n");
3284         }
3285
3286         /* Update the cache before returning with the value */
3287         cache[reg] = value;
3288         return value;
3289
3290 }
3291
3292 /*
3293  *----------------------------------------------------------------------------
3294  * Function : aic3262_write
3295  * Purpose  : This function is to write to the aic3262 register space.
3296  *
3297  *----------------------------------------------------------------------------
3298  */
3299 int aic3262_write(struct snd_soc_codec *codec, u16 reg, u8 value)
3300 {
3301         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3302         u8 data[2];
3303         u8 page;
3304         int ret = 0;
3305
3306         page = reg / 128;
3307         data[AIC3262_REG_OFFSET_INDEX] = reg % 128;
3308         if (aic3262->page_no != page)
3309                 aic3262_change_page(codec, page);
3310
3311         /* data is
3312          *   D15..D8 aic3262 register offset
3313          *   D7...D0 register data
3314          */
3315         data[AIC3262_REG_DATA_INDEX] = value & AIC3262_8BITS_MASK;
3316 #if defined(EN_REG_CACHE)
3317         if ((page >= 0) & (page <= 4))
3318                 aic3262_write_reg_cache(codec, reg, value);
3319
3320 #endif
3321         if (!data[AIC3262_REG_OFFSET_INDEX]) {
3322                 /* if the write is to reg0 update aic3262->page_no */
3323                 aic3262->page_no = value;
3324         }
3325
3326         /*DBG("w %2x %02x\r\n",
3327                 data[AIC3262_REG_OFFSET_INDEX], data[AIC3262_REG_DATA_INDEX]);*/
3328
3329 #if defined(LOCAL_REG_ACCESS)
3330         if (codec->hw_write(codec->control_data, data, 2) != 2)
3331                 ret = -EIO;
3332 #else
3333         ret = snd_soc_write(codec, data[AIC3262_REG_OFFSET_INDEX],
3334                         data[AIC3262_REG_DATA_INDEX]);
3335 #endif
3336         if (ret)
3337                 printk(KERN_ERR "Error in i2c write\n");
3338
3339         return ret;
3340 }
3341
3342 /*
3343  *------------------------------------------------------------------------------
3344  * Function : aic3262_write__
3345  * Purpose  : This function is to write to the aic3262 register space.
3346  *            (low level).
3347  *------------------------------------------------------------------------------
3348  */
3349
3350 int aic3262_write__(struct i2c_client *client, const char *buf, int count)
3351 {
3352         u8 data[3];
3353         int ret;
3354         data[0] = *buf;
3355         data[1] = *(buf+1);
3356         data[2] = *(buf+2);
3357         /*DBG("w %2x %02x\r\n",
3358                 data[AIC3262_REG_OFFSET_INDEX], data[AIC3262_REG_DATA_INDEX]);*/
3359         ret = i2c_master_send(client, data, 2);
3360         if (ret < 2) {
3361                 printk(
3362                 KERN_ERR "I2C write Error : bytes written = %d\n\n", ret);
3363                 return -EIO;
3364         }
3365
3366         return ret;
3367 }
3368 /*
3369  *----------------------------------------------------------------------------
3370  * Function : aic3262_reset_cache
3371  * Purpose  : This function is to reset the cache.
3372  *----------------------------------------------------------------------------
3373  */
3374 int aic3262_reset_cache(struct snd_soc_codec *codec)
3375 {
3376 #if defined(EN_REG_CACHE)
3377         if (codec->reg_cache) {
3378                 memcpy(codec->reg_cache, aic3262_reg, sizeof(aic3262_reg));
3379                 return 0;
3380         }
3381
3382         codec->reg_cache = kmemdup(aic3262_reg,
3383                         sizeof(aic3262_reg), GFP_KERNEL);
3384         if (!codec->reg_cache) {
3385                 printk(KERN_ERR "aic32x4: kmemdup failed\n");
3386                 return -ENOMEM;
3387         }
3388 #endif
3389         return 0;
3390 }
3391
3392 /*
3393  *----------------------------------------------------------------------------
3394  * Function : aic3262_get_divs
3395  * Purpose  : This function is to get required divisor from the "aic3262_divs"
3396  *            table.
3397  *
3398  *----------------------------------------------------------------------------
3399  */
3400 static inline int aic3262_get_divs(int mclk, int rate)
3401 {
3402         int i;
3403
3404         for (i = 0; i < ARRAY_SIZE(aic3262_divs); i++) {
3405                 if ((aic3262_divs[i].rate == rate)
3406                     && (aic3262_divs[i].mclk == mclk)) {
3407                         DBG(KERN_INFO "#%s: Found Entry %d in Clock_Array\n",
3408                                 __func__, i);
3409                         return i;
3410                 }
3411         }
3412         printk(KERN_ERR "Master clock and sample rate is not supported\n");
3413         return -EINVAL;
3414 }
3415
3416 /*
3417  *----------------------------------------------------------------------------
3418  * Function : aic3262_add_widgets
3419  * Purpose  : This function is to add the dapm widgets
3420  *            The following are the main widgets supported
3421  *                # Left DAC to Left Outputs
3422  *                # Right DAC to Right Outputs
3423  *                # Left Inputs to Left ADC
3424  *                # Right Inputs to Right ADC
3425  *
3426  *----------------------------------------------------------------------------
3427  */
3428 static int aic3262_add_widgets(struct snd_soc_codec *codec)
3429 {
3430         int ret;
3431         struct snd_soc_dapm_context *dapm = &codec->dapm;
3432 #ifndef AIC3262_MULTI_I2S
3433         int i;
3434         for (i = 0; i < ARRAY_SIZE(aic3262_dapm_widgets); i++)
3435                 ret = snd_soc_dapm_new_control(dapm, &aic3262_dapm_widgets[i]);
3436 #else
3437         ret = snd_soc_dapm_new_controls(dapm, aic3262_dapm_widgets,
3438                         ARRAY_SIZE(aic3262_dapm_widgets));
3439         if (ret != 0) {
3440                 printk(KERN_ERR "#%s: Unable to add DAPM Controls. Err %d\n",
3441                                  __func__, ret);
3442         }
3443 #endif
3444         /* set up audio path interconnects */
3445         DBG("#Completed adding new dapm widget controls size=%d\n",
3446                 ARRAY_SIZE(aic3262_dapm_widgets));
3447         snd_soc_dapm_add_routes(dapm, aic3262_dapm_routes,
3448                                 ARRAY_SIZE(aic3262_dapm_routes));
3449         DBG("#Completed adding DAPM routes\n");
3450         snd_soc_dapm_new_widgets(dapm);
3451         DBG("#Completed updating dapm\n");
3452         return 0;
3453 }
3454 /*
3455  *----------------------------------------------------------------------------
3456  * Function : reg_def_conf
3457  * Purpose  : This function is to reset the codec book 0 registers
3458  *
3459  *----------------------------------------------------------------------------
3460  */
3461 int reg_def_conf(struct snd_soc_codec *codec)
3462 {
3463         int i = 0, ret;
3464         DBG(KERN_INFO "#%s: Invoked..\n", __func__);
3465
3466         ret = aic3262_change_page(codec, 0);
3467         if (ret != 0)
3468                 return ret;
3469
3470         ret = aic3262_change_book(codec, 0);
3471         if (ret != 0)
3472                 return ret;
3473
3474         /* Configure the Codec with the default Initialization Values */
3475         for (i = 0; i < reg_init_size; i++) {
3476                 ret = snd_soc_write(codec, aic3262_reg_init[i].reg_offset,
3477                         aic3262_reg_init[i].reg_val);
3478                 if (ret)
3479                         break;
3480         }
3481         DBG(KERN_INFO "#%s: Done..\n", __func__);
3482         return ret;
3483 }
3484
3485 /*
3486  * i2c_verify_book0
3487  *
3488  * This function is used to dump the values of the Book 0 Pages.
3489  */
3490 int i2c_verify_book0(struct snd_soc_codec *codec)
3491 {
3492         int i, j, k = 0;
3493         u8 val1;
3494
3495         DBG("starting i2c_verify\n");
3496         DBG("Resetting page to 0\n");
3497         aic3262_change_book(codec, 0);
3498         for (j = 0; j < 3; j++) {
3499                 if (j == 0) {
3500                         aic3262_change_page(codec, 0);
3501                         k = 0;
3502                 }
3503                 if (j == 1) {
3504                         aic3262_change_page(codec, 1);
3505                         k = 1;
3506                 }
3507                 /*
3508                 if (j == 2) {
3509                         aic3262_change_page(codec, 4);
3510                         k = 4;
3511                 }*/
3512                 for (i = 0; i <= 127; i++) {
3513 #if defined(LOCAL_REG_ACCESS)
3514                         val1 = i2c_smbus_read_byte_data(codec->control_data, i);
3515 #else
3516                         val1 = snd_soc_read(codec, i);
3517 #endif
3518                         /* printk("[%d][%d]=[0x%2x]\n",k,i,val1); */
3519                 }
3520         }
3521         return 0;
3522 }
3523
3524 /*
3525  *----------------------------------------------------------------------------
3526  * Function : aic3262_set_bias_level
3527  * Purpose  : This function is to get triggered when dapm events occurs.
3528  *
3529  *----------------------------------------------------------------------------
3530  */
3531
3532 static int aic3262_set_bias_level(struct snd_soc_codec *codec,
3533                         enum snd_soc_bias_level level)
3534 {
3535         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3536         u8 value;
3537         switch (level) {
3538                 /* full On */
3539         case SND_SOC_BIAS_ON:
3540
3541                 /* all power is driven by DAPM system */
3542                 dev_dbg(codec->dev, "set_bias_on\n");
3543                 break;
3544
3545                 /* partial On */
3546         case SND_SOC_BIAS_PREPARE:
3547
3548                 dev_dbg(codec->dev, "set_bias_prepare\n");
3549
3550                 break;
3551
3552         /* Off, with power */
3553         case SND_SOC_BIAS_STANDBY:
3554                 /*
3555                  * all power is driven by DAPM system,
3556                  * so output power is safe if bypass was set
3557                  */
3558                  dev_dbg(codec->dev, "set_bias_stby\n");
3559
3560                 break;
3561         /* Off, without power */
3562         case SND_SOC_BIAS_OFF:
3563                  dev_dbg(codec->dev, "set_bias_off\n");
3564
3565                 break;
3566         }
3567         codec->dapm.bias_level=level;
3568
3569         return 0;
3570 }
3571
3572
3573 /*
3574  *----------------------------------------------------------------------------
3575  * Function : aic3262_suspend
3576  * Purpose  : This function is to suspend the AIC3262 driver.
3577  *
3578  *----------------------------------------------------------------------------
3579  */
3580 static int aic3262_suspend(struct snd_soc_codec *codec, pm_message_t state)
3581 {
3582         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3583         DBG(KERN_INFO "#%s: Invoked..\n", __func__);
3584         if (aic3262)
3585                 disable_irq(aic3262->irq);
3586
3587         aic3262_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
3588
3589         return 0;
3590 }
3591
3592 /*
3593  *----------------------------------------------------------------------------
3594  * Function : aic3262_resume
3595  * Purpose  : This function is to resume the AIC3262 driver
3596  *
3597  *----------------------------------------------------------------------------
3598  */
3599 static int aic3262_resume(struct snd_soc_codec *codec)
3600 {
3601         int i;
3602         u8 data[2];
3603         int ret = 0;
3604         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3605         u8 *cache = codec->reg_cache;
3606         DBG(KERN_INFO "#%s: Invoked..\n", __func__);
3607
3608         ret = aic3262_change_page(codec, 0);
3609         if (ret)
3610                 return ret;
3611 #if defined(EN_REG_CACHE)
3612         /* Sync reg_cache with the hardware */
3613         for (i = 0; i < ARRAY_SIZE(aic3262_reg); i++) {
3614                 data[0] = i % 128;
3615                 data[1] = cache[i];
3616 #if defined(LOCAL_REG_ACCESS)
3617                 codec->hw_write(codec->control_data, data, 2);
3618 #else
3619                 ret = snd_soc_write(codec, data[0], data[1]);
3620                 if (ret)
3621                         break;
3622 #endif
3623         }
3624 #endif
3625         if (!ret) {
3626                 aic3262_change_page(codec, 0);
3627                 aic3262_set_bias_level(codec, SND_SOC_BIAS_ON);
3628
3629                 if (aic3262)
3630                         enable_irq(aic3262->irq);
3631         }
3632         return ret;
3633 }
3634 /*
3635  *----------------------------------------------------------------------------
3636  * Function : aic3262_hw_read
3637  * Purpose  : This is a low level harware read function.
3638  *
3639  *----------------------------------------------------------------------------
3640  */
3641 unsigned int aic3262_hw_read(struct snd_soc_codec *codec, unsigned int count)
3642 {
3643         struct i2c_client *client = codec->control_data;
3644         unsigned int buf;
3645
3646         if (count > (sizeof(unsigned int)))
3647                 return 0;
3648
3649         i2c_master_recv(client, (char *)&buf, count);
3650         return buf;
3651 }
3652
3653 /*
3654 * aic3262_jack_handler
3655 *
3656 * This function is called from the Interrupt Handler
3657 * to check the status of the AIC3262 Registers related to Headset Detection
3658 */
3659 static irqreturn_t aic3262_jack_handler(int irq, void *data)
3660 {
3661         struct snd_soc_codec *codec = data;
3662         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3663         unsigned int value;
3664         unsigned int micbits, hsbits = 0;
3665
3666         DBG(KERN_INFO "%s++\n", __func__);
3667
3668
3669         aic3262_change_page(codec, 0);
3670
3671         /* Read the Jack Status Register*/
3672         value = snd_soc_read(codec, STICKY_FLAG2);
3673         DBG(KERN_INFO "reg44 0x%x\n", value);
3674
3675
3676         value = snd_soc_read(codec, INT_FLAG2);
3677         DBG(KERN_INFO "reg46 0x%x\n", value);
3678
3679         value = snd_soc_read(codec, DAC_FLAG_R1);
3680         DBG(KERN_INFO "reg37 0x%x\n", value);
3681
3682         micbits = value & DAC_FLAG_MIC_MASKBITS;
3683         DBG(KERN_INFO "micbits 0x%x\n", micbits);
3684
3685         hsbits = value & DAC_FLAG_HS_MASKBITS;
3686         DBG(KERN_INFO "hsbits 0x%x\n", hsbits);
3687
3688
3689         /* No Headphone or Headset*/
3690         if (!micbits && !hsbits) {
3691                 DBG(KERN_INFO "no headset/headphone\n");
3692                 snd_soc_jack_report(aic3262->headset_jack,
3693                                 0, SND_JACK_HEADSET);
3694         }
3695
3696         /* Headphone Detected */
3697         if ((micbits == DAC_FLAG_R1_NOMIC) || (hsbits)) {
3698                 DBG(KERN_INFO "headphone\n");
3699                 snd_soc_jack_report(aic3262->headset_jack,
3700                                 SND_JACK_HEADPHONE, SND_JACK_HEADSET);
3701         }
3702
3703         /* Headset Detected - only with capless */
3704         if (micbits == DAC_FLAG_R1_MIC) {
3705                 DBG(KERN_INFO "headset\n");
3706                 snd_soc_jack_report(aic3262->headset_jack,
3707                                 SND_JACK_HEADSET, SND_JACK_HEADSET);
3708         }
3709
3710         DBG(KERN_INFO "%s--\n", __func__);
3711         return IRQ_HANDLED;
3712 }
3713
3714 /*
3715 * aic326x_headset_detect
3716 *
3717 * Call-back function called to check the status of Headset Pin.
3718 */
3719 int aic326x_headset_detect(struct snd_soc_codec *codec,
3720         struct snd_soc_jack *jack, int jack_type)
3721 {
3722         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3723
3724         aic3262->headset_jack = jack;
3725         /*Enable the Headset Interrupts*/
3726         snd_soc_write(codec, INT1_CNTL, 0x80);
3727
3728         return 0;
3729 }
3730 EXPORT_SYMBOL_GPL(aic326x_headset_detect);
3731
3732
3733 #ifdef AIC3262_MULTI_I2S
3734 /*
3735 * aic3262_asi_default_config
3736 *
3737 * This function is used to perform the default pin configurations for
3738 * the functionalities which are specific to each ASI Port of the AIC3262
3739 * Audio Codec Chipset. The user is encouraged to change these values
3740 * if required on their platforms.
3741 */
3742 static void aic3262_asi_default_config(struct snd_soc_codec *codec)
3743 {
3744         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3745         u16 counter;
3746
3747         DBG(KERN_INFO
3748                 "#%s: Invoked. Will Config ASI Registers to Defaults..\n",
3749                         __func__);
3750         for (counter = 0; counter < MAX_ASI_COUNT; counter++) {
3751                 aic3262->asiCtxt[counter].asi_active = 0;
3752                 aic3262->asiCtxt[counter].bclk_div = 1;
3753                 aic3262->asiCtxt[counter].wclk_div = 1;
3754                 aic3262->asiCtxt[counter].port_muted = 1;
3755                 aic3262->asiCtxt[counter].bclk_div_option =
3756                         BDIV_CLKIN_DAC_MOD_CLK;
3757                 aic3262->asiCtxt[counter].offset1 = 0;
3758                 aic3262->asiCtxt[counter].offset2 = 0;
3759         }
3760         /* ASI1 Defaults */
3761         aic3262->asiCtxt[0].bclk_output = ASI1_BCLK_DIVIDER_OUTPUT;
3762         aic3262->asiCtxt[0].wclk_output = GENERATED_DAC_FS;
3763         aic3262->asiCtxt[0].left_dac_output  = DAC_PATH_LEFT;
3764         aic3262->asiCtxt[0].right_dac_output = DAC_PATH_LEFT;
3765         aic3262->asiCtxt[0].adc_input        = ADC_PATH_MINIDSP_1;
3766         aic3262->asiCtxt[0].dout_option      = ASI_OUTPUT;
3767
3768         /* ASI2 Defaults */
3769         aic3262->asiCtxt[1].bclk_output = ASI2_BCLK_DIVIDER_OUTPUT;
3770         aic3262->asiCtxt[1].wclk_output = GENERATED_DAC_FS;
3771         aic3262->asiCtxt[1].left_dac_output  = DAC_PATH_LEFT;
3772         aic3262->asiCtxt[1].right_dac_output = DAC_PATH_LEFT;
3773         aic3262->asiCtxt[1].adc_input        = ADC_PATH_MINIDSP_2;
3774         aic3262->asiCtxt[1].dout_option      = ASI_OUTPUT;
3775
3776         /* ASI3 Defaults */
3777         aic3262->asiCtxt[2].bclk_output = ASI3_BCLK_DIVIDER_OUTPUT;
3778         aic3262->asiCtxt[2].wclk_output = GENERATED_DAC_FS;
3779         aic3262->asiCtxt[2].left_dac_output  = DAC_PATH_LEFT;
3780         aic3262->asiCtxt[2].right_dac_output = DAC_PATH_LEFT;
3781         aic3262->asiCtxt[2].adc_input        = ADC_PATH_MINIDSP_3;
3782         aic3262->asiCtxt[2].dout_option      = ASI2_INPUT;
3783         return;
3784 }
3785
3786 #endif /* #ifdef AIC3262_MULTI_I2S */
3787
3788 /*
3789  *----------------------------------------------------------------------------
3790  * Function : aic3262_probe
3791  * Purpose  : This is first driver function called by the SoC core driver.
3792  *
3793  *----------------------------------------------------------------------------
3794  */
3795
3796 static int aic3262_probe(struct snd_soc_codec *codec)
3797 {
3798         struct aic3262_priv *aic3262 = snd_soc_codec_get_drvdata(codec);
3799         int ret = 0;
3800
3801         DBG(KERN_INFO "#%s: Invoked..\n", __func__);
3802
3803 #if defined(EN_REG_CACHE)
3804         codec->reg_cache =
3805                 kmemdup(aic3262_reg, sizeof(aic3262_reg), GFP_KERNEL);
3806
3807         if (!codec->reg_cache) {
3808                 printk(KERN_ERR "aic3262: kmemdup failed\n");
3809                 return -ENOMEM;
3810         }
3811 #else
3812         /* Setting cache bypass - not to overwrite the cache registers,
3813         Codec registers have 4 pages which is not handled in the common
3814         cache code properly - bypass it in write value and save it
3815         using separate call*/
3816         codec->cache_bypass = 1;
3817 #endif
3818
3819 #if defined(LOCAL_REG_ACCESS)
3820         codec->control_data = aic3262->control_data;
3821         codec->hw_write = (hw_write_t) aic3262_write__;
3822         codec->hw_read = aic3262_hw_read;
3823 #else
3824         ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_I2C);
3825         if (ret != 0) {
3826                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
3827                 return ret;
3828         }
3829 #endif
3830         ret = reg_def_conf(codec);
3831         if (ret != 0) {
3832                 printk(KERN_ERR "Failed to init TI codec: %d\n", ret);
3833                 return ret;
3834         }
3835
3836         if (aic3262->irq) {
3837                 /* audio interrupt */
3838                 ret = request_threaded_irq(aic3262->irq, NULL,
3839                                 aic3262_jack_handler,
3840                                 IRQF_TRIGGER_FALLING,
3841                                 "tlv320aic3262", codec);
3842                 if (ret) {
3843                         printk(KERN_INFO "#%s: IRQ Registration failed..[%d]",
3844                                         __func__, ret);
3845                         dev_err(codec->dev, "Failed to request IRQ: %d\n", ret);
3846                         return ret;
3847                 } else
3848                         DBG(KERN_INFO
3849                                 "#%s: irq Registration for IRQ %d done..\n",
3850                                         __func__, aic3262->irq);
3851         } else {
3852                 DBG(KERN_INFO "#%s: I2C IRQ Configuration is Wrong. \
3853                         Please check it..\n", __func__);
3854         }
3855
3856         aic3262_asi_default_config(codec);
3857
3858         /* off, with power on */
3859         aic3262_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
3860
3861         ret = snd_soc_add_controls(codec, aic3262_snd_controls,
3862                                         ARRAY_SIZE(aic3262_snd_controls));
3863         if(ret)
3864         {
3865                 printk(KERN_INFO "%s failed\n", __func__);
3866         }
3867
3868         aic3262_add_widgets(codec);
3869         /*TODO*/
3870         snd_soc_write(codec, MIC_BIAS_CNTL, 0x66);
3871
3872 #ifdef AIC3262_TiLoad
3873         ret = aic3262_driver_init(codec);
3874         if (ret < 0)
3875                 printk(KERN_ERR
3876         "\nAIC3262 CODEC: aic3262_probe :TiLoad Initialization failed\n");
3877 #endif
3878
3879
3880 #ifdef CONFIG_MINI_DSP
3881         /* Program MINI DSP for ADC and DAC */
3882         aic3262_minidsp_program(codec);
3883         aic3262_add_minidsp_controls(codec);
3884         aic3262_change_book(codec, 0x0);
3885 #endif
3886
3887 #ifdef MULTIBYTE_CONFIG_SUPPORT
3888         aic3262_add_multiconfig_controls(codec);
3889 #endif
3890
3891         DBG(KERN_INFO "#%s: done..\n", __func__);
3892         return ret;
3893 }
3894
3895
3896
3897 /*
3898  *----------------------------------------------------------------------------
3899  * Function : aic3262_remove
3900  * Purpose  : to remove aic3262 soc device
3901  *
3902  *----------------------------------------------------------------------------
3903  */
3904 static int aic3262_remove(struct snd_soc_codec *codec)
3905 {
3906
3907         /* power down chip */
3908         aic3262_set_bias_level(codec, SND_SOC_BIAS_OFF);
3909
3910         return 0;
3911 }
3912
3913
3914 /*
3915  *----------------------------------------------------------------------------
3916  * @struct  snd_soc_codec_device |
3917  *          This structure is soc audio codec device sturecute which pointer
3918  *          to basic functions aic3262_probe(), aic3262_remove(),
3919  *          aic3262_suspend() and aic3262_resume()
3920  *----------------------------------------------------------------------------
3921  */
3922 static struct snd_soc_codec_driver soc_codec_dev_aic3262 = {
3923         .probe = aic3262_probe,
3924         .remove = aic3262_remove,
3925         .suspend = aic3262_suspend,
3926         .resume = aic3262_resume,
3927         .set_bias_level = aic3262_set_bias_level,
3928 #if defined(LOCAL_REG_ACCESS)
3929         .read = aic3262_read,
3930         .write = aic3262_write,
3931 #endif
3932 #if !defined(EN_REG_CACHE)
3933         .reg_cache_size = ARRAY_SIZE(aic3262_reg),
3934         .reg_word_size = sizeof(u8),
3935         .reg_cache_default = aic3262_reg,
3936 #endif
3937 };
3938
3939
3940 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
3941 /*
3942  *----------------------------------------------------------------------------
3943  * Function : aic3262_codec_probe
3944  * Purpose  : This function attaches the i2c client and initializes
3945  *                              AIC3262 CODEC.
3946  *            NOTE:
3947  *            This function is called from i2c core when the I2C address is
3948  *            valid.
3949  *            If the i2c layer weren't so broken, we could pass this kind of
3950  *            data around
3951  *
3952  *----------------------------------------------------------------------------
3953  */
3954 static __devinit int aic3262_codec_probe(struct i2c_client *i2c,
3955                         const struct i2c_device_id *id)
3956 {
3957         int ret;
3958
3959         struct aic3262_priv *aic3262;
3960
3961         DBG(KERN_INFO "#%s: Entered\n", __func__);
3962
3963         aic3262 = kzalloc(sizeof(struct aic3262_priv), GFP_KERNEL);
3964
3965         if (!aic3262) {
3966                 printk(KERN_ERR "#%s: Unable to Allocate Priv struct..\n",
3967                         __func__);
3968                 return -ENOMEM;
3969         }
3970
3971         i2c_set_clientdata(i2c, aic3262);
3972 #if defined(LOCAL_REG_ACCESS)
3973         aic3262->control_data = i2c;
3974 #endif
3975         aic3262->control_type = SND_SOC_I2C;
3976         aic3262->irq = i2c->irq;
3977         aic3262->pdata = i2c->dev.platform_data;
3978
3979         /* The Configuration Support will be by default to 3 which
3980         * holds the MAIN Patch Configuration.
3981         */
3982         aic3262->current_dac_config[0] = -1;
3983         aic3262->current_dac_config[1] = -1;
3984         aic3262->current_adc_config[0] = -1;
3985         aic3262->current_adc_config[1] = -1;
3986
3987         aic3262->mute_codec = 1;
3988
3989         aic3262->page_no = 0;
3990         aic3262->book_no = 0;
3991         aic3262->active_count = 0;
3992         aic3262->dac_clkin_option = 3;
3993         aic3262->adc_clkin_option = 3;
3994
3995         ret = snd_soc_register_codec(&i2c->dev,
3996                 &soc_codec_dev_aic3262,
3997                 tlv320aic3262_dai, ARRAY_SIZE(tlv320aic3262_dai));
3998
3999         if (ret < 0)
4000                 kfree(aic3262);
4001         DBG(KERN_INFO "#%s: Done ret %d\n", __func__, ret);
4002         return ret;
4003 }
4004
4005 /*
4006  *----------------------------------------------------------------------------
4007  * Function : aic3262_i2c_remove
4008  * Purpose  : This function removes the i2c client and uninitializes
4009  *                              AIC3262 CODEC.
4010  *            NOTE:
4011  *            This function is called from i2c core
4012  *            If the i2c layer weren't so broken, we could pass this kind of
4013  *            data around
4014  *
4015  *----------------------------------------------------------------------------
4016  */
4017 static __devexit int aic3262_i2c_remove(struct i2c_client *i2c)
4018 {
4019         snd_soc_unregister_codec(&i2c->dev);
4020         kfree(i2c_get_clientdata(i2c));
4021         return 0;
4022 }
4023
4024 static const struct i2c_device_id tlv320aic3262_id[] = {
4025         {"aic3262-codec", 0},
4026         {}
4027 };
4028 MODULE_DEVICE_TABLE(i2c, tlv320aic3262_id);
4029
4030 static struct i2c_driver tlv320aic3262_i2c_driver = {
4031         .driver = {
4032                 .name = "aic3262-codec",
4033                 .owner = THIS_MODULE,
4034         },
4035         .probe = aic3262_codec_probe,
4036         .remove = __devexit_p(aic3262_i2c_remove),
4037         .id_table = tlv320aic3262_id,
4038 };
4039 #endif /*#if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)*/
4040
4041 #if defined(CONFIG_SPI_MASTER)
4042 static int aic3262_spi_write(struct spi_device *spi, const char *data, int len)
4043 {
4044         struct spi_transfer t;
4045         struct spi_message m;
4046         u8 msg[2];
4047
4048         if (len <= 0)
4049                 return 0;
4050
4051         msg[0] = data[0];
4052         msg[1] = data[1];
4053
4054         spi_message_init(&m);
4055         memset(&t, 0, (sizeof t));
4056         t.tx_buf = &msg[0];
4057         t.len = len;
4058
4059         spi_message_add_tail(&t, &m);
4060         spi_sync(spi, &m);
4061
4062         return len;
4063 }
4064
4065 /*
4066  * This function forces any delayed work to be queued and run.
4067  */
4068 static int run_delayed_work(struct delayed_work *dwork)
4069 {
4070         int ret;
4071
4072         /* cancel any work waiting to be queued. */
4073         ret = cancel_delayed_work(dwork);
4074
4075         /* if there was any work waiting then we run it now and
4076          * wait for it's completion */
4077         if (ret) {
4078                 schedule_delayed_work(dwork, 0);
4079                 flush_scheduled_work();
4080         }
4081         return ret;
4082 }
4083 static int __devinit aic3262_spi_probe(struct spi_device *spi)
4084 {
4085         int ret;
4086         struct snd_soc_codec *codec;
4087         struct aic3262_priv *aic3262;
4088         printk(KERN_INFO "%s entering\n",__func__);
4089         aic3262 = kzalloc(sizeof(struct aic3262_priv), GFP_KERNEL);
4090
4091         if (!aic3262) {
4092                 printk(KERN_ERR "#%s: Unable to Allocate Priv struct..\n",
4093                         __func__);
4094                 return -ENOMEM;
4095         }
4096         codec = &aic3262->codec;
4097         codec->control_data = spi;
4098         aic3262->control_type = SND_SOC_SPI;
4099         codec->hw_write = (hw_write_t)aic3262_spi_write;
4100         codec->dev = &spi->dev;
4101
4102         aic3262->pdata = spi->dev.platform_data;
4103
4104         /* The Configuration Support will be by default to 3 which
4105         * holds the MAIN Patch Configuration.
4106         */
4107         aic3262->current_dac_config[0] = -1;
4108         aic3262->current_dac_config[1] = -1;
4109         aic3262->current_adc_config[0] = -1;
4110         aic3262->current_adc_config[1] = -1;
4111
4112         aic3262->mute_codec = 1;
4113
4114         aic3262->page_no = 0;
4115         aic3262->book_no = 0;
4116         aic3262->active_count = 0;
4117         aic3262->dac_clkin_option = 3;
4118         aic3262->adc_clkin_option = 3;
4119         dev_set_drvdata(&spi->dev, aic3262);
4120         spi_set_drvdata(spi, aic3262);
4121         ret = snd_soc_register_codec(&spi->dev,
4122                 &soc_codec_dev_aic3262,
4123                 tlv320aic3262_dai, ARRAY_SIZE(tlv320aic3262_dai));
4124
4125         if (ret < 0) {
4126                 printk(KERN_INFO "%s codec registeration failed\n",__func__);
4127                 kfree(aic3262);
4128         }
4129         else {
4130                 printk(KERN_INFO "%s registered\n",__func__);
4131         }
4132         printk(KERN_INFO "#%s: Done ret %d\n", __func__, ret);
4133         return ret;
4134 }
4135
4136 static int __devexit aic3262_spi_remove(struct spi_device *spi)
4137 {
4138         struct aic3262_priv *aic3262 = dev_get_drvdata(&spi->dev);
4139         aic3262_set_bias_level(&aic3262->codec, SND_SOC_BIAS_OFF);
4140         snd_soc_unregister_codec(&spi->dev);
4141         kfree(aic3262);
4142         aic3262_codec = NULL;
4143         return 0;
4144
4145 }
4146
4147 static const struct spi_device_id tlv320aic3262_id[] = {
4148         {"aic3262-codec", 0},
4149         {}
4150 };
4151 static struct spi_driver aic3262_spi_driver = {
4152         .driver = {
4153                 .name   = "aic3262-codec",
4154                 .bus    = &spi_bus_type,
4155                 .owner  = THIS_MODULE,
4156         },
4157         .probe          = aic3262_spi_probe,
4158         .remove         = __devexit_p(aic3262_spi_remove),
4159         .id_table = tlv320aic3262_id,
4160 };
4161 #endif
4162 static int __init tlv320aic3262_modinit(void)
4163 {
4164         int ret = 0;
4165         printk(KERN_INFO "In %s\n",__func__);
4166 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
4167         ret = i2c_add_driver(&tlv320aic3262_i2c_driver);
4168         if (ret != 0)
4169                 printk(KERN_ERR "Failed to register aic326x i2c driver %d\n",
4170                         ret);
4171 #endif
4172 #if defined(CONFIG_SPI_MASTER)
4173         printk(KERN_INFO "Inside config_spi_master\n");
4174         ret = spi_register_driver(&aic3262_spi_driver);
4175         if (ret != 0)
4176                 printk(KERN_ERR "Failed to register aic3262 SPI driver: %d\n", ret);
4177 #endif
4178         return ret;
4179
4180 }
4181
4182 module_init(tlv320aic3262_modinit);
4183
4184 static void __exit tlv320aic3262_exit(void)
4185 {
4186 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
4187         i2c_del_driver(&tlv320aic3262_i2c_driver);
4188 #endif
4189 }
4190 module_exit(tlv320aic3262_exit);
4191
4192 MODULE_DESCRIPTION("ASoC TLV320AIC3262 codec driver");
4193 MODULE_AUTHOR("Barani Prashanth<gvbarani@mistralsolutions.com>");
4194 MODULE_AUTHOR("Ravindra<ravindra@mistralsolutions.com>");
4195 MODULE_LICENSE("GPL");