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