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