4b7b51fd1c8be0276fe8b0308a09f77c24288e8d
[linux-3.10.git] / sound / soc / codecs / rt5639.c
1 /*
2  * rt5639.c  --  RT5639 ALSA SoC audio codec driver
3  *
4  * Copyright 2011 Realtek Semiconductor Corp.
5  * Author: Johnny Hsu <johnnyhsu@realtek.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/init.h>
15 #include <linux/delay.h>
16 #include <linux/pm.h>
17 #include <linux/i2c.h>
18 #include <linux/platform_device.h>
19 #include <linux/spi/spi.h>
20 #include <sound/core.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <sound/soc-dapm.h>
25 #include <sound/initval.h>
26 #include <sound/tlv.h>
27
28 #include "rt5639.h"
29
30 #define RT5639_DEMO 1
31 #define RT5639_REG_RW 1
32 #define RT5639_DET_EXT_MIC 0
33
34 #ifdef RT5639_DEMO
35 struct rt5639_init_reg {
36         u8 reg;
37         u16 val;
38 };
39
40 static struct rt5639_init_reg init_list[] = {
41         {RT5639_DUMMY1          , 0x3701},//fa[12:13] = 1'b;fa[8~10]=1;fa[0]=1
42         {RT5639_DEPOP_M1        , 0x0019},//8e[4:3] = 11'b; 8e[0] = 1'b
43         {RT5639_DEPOP_M2        , 0x3100},//8f[13] = 1'b
44         {RT5639_ADDA_CLK1       , 0x1114},//73[2] = 1'b
45         {RT5639_MICBIAS         , 0x3030},//93[5:4] = 11'b
46         {RT5639_PRIV_INDEX      , 0x003d},//PR3d[12] = 1'b
47         {RT5639_PRIV_DATA       , 0x3600},
48         {RT5639_CLS_D_OUT       , 0xa000},//8d[11] = 0'b
49         {RT5639_PRIV_INDEX      , 0x001c},//PR1c = 0D21'h
50         {RT5639_PRIV_DATA       , 0x0D21},
51
52         {RT5639_PRIV_INDEX      , 0x001b},//PR1B = 0D21'h
53         {RT5639_PRIV_DATA       , 0x0000},
54         {RT5639_PRIV_INDEX      , 0x0012},//PR12 = 0aa8'h
55         {RT5639_PRIV_DATA       , 0x0aa8},
56         {RT5639_PRIV_INDEX      , 0x0014},//PR14 = 0aaa'h
57         {RT5639_PRIV_DATA       , 0x0aaa},
58         {RT5639_PRIV_INDEX      , 0x0020},//PR20 = 6110'h
59         {RT5639_PRIV_DATA       , 0x6110},
60         {RT5639_PRIV_INDEX      , 0x0021},//PR21 = e0e0'h
61         {RT5639_PRIV_DATA       , 0xe0e0},
62         {RT5639_PRIV_INDEX      , 0x0023},//PR23 = 1804'h
63         {RT5639_PRIV_DATA       , 0x1804},
64         /*playback*/
65         {RT5639_STO_DAC_MIXER   , 0x1414},//Dig inf 1 -> Sto DAC mixer -> DACL
66         {RT5639_OUT_L3_MIXER    , 0x01fe},//DACL1 -> OUTMIXL
67         {RT5639_OUT_R3_MIXER    , 0x01fe},//DACR1 -> OUTMIXR
68         {RT5639_HP_VOL          , 0x8888},//OUTMIX -> HPVOL
69         {RT5639_HPO_MIXER       , 0xc000},//HPVOL -> HPOLMIX
70 //      {RT5639_HPO_MIXER       , 0xa000},//DAC1 -> HPOLMIX
71         {RT5639_SPK_L_MIXER     , 0x0036},//DACL1 -> SPKMIXL
72         {RT5639_SPK_R_MIXER     , 0x0036},//DACR1 -> SPKMIXR
73         {RT5639_SPK_VOL         , 0x8888},//SPKMIX -> SPKVOL
74         {RT5639_SPO_L_MIXER     , 0xe800},//SPKVOLL -> SPOLMIX
75         {RT5639_SPO_R_MIXER     , 0x2800},//SPKVOLR -> SPORMIX
76 //      {RT5639_SPO_L_MIXER     , 0xb800},//DAC -> SPOLMIX
77 //      {RT5639_SPO_R_MIXER     , 0x1800},//DAC -> SPORMIX
78 //      {RT5639_I2S1_SDP        , 0xD000},//change IIS1 and IIS2
79         /*record*/
80         {RT5639_IN1_IN2         , 0x5080},//IN1 boost 40db and differential mode
81         {RT5639_IN3_IN4         , 0x0500},//IN2 boost 40db and signal ended mode
82         {RT5639_REC_L2_MIXER    , 0x007d},//Mic1 -> RECMIXL
83         {RT5639_REC_R2_MIXER    , 0x007d},//Mic1 -> RECMIXR
84 //      {RT5639_REC_L2_MIXER    , 0x006f},//Mic2 -> RECMIXL
85 //      {RT5639_REC_R2_MIXER    , 0x006f},//Mic2 -> RECMIXR
86         {RT5639_STO_ADC_MIXER   , 0x3020},//ADC -> Sto ADC mixer
87
88 #if RT5639_DET_EXT_MIC
89         {RT5639_MICBIAS         ,0x3800},//enable MICBIAS short current
90         {RT5639_GPIO_CTRL1      ,0x8400},//set GPIO1 to IRQ
91         {RT5639_GPIO_CTRL3      ,0x0004},//set GPIO1 output
92         {RT5639_IRQ_CTRL2       ,0x8000},//set MICBIAS short current to IRQ   ( if sticky set regBE : 8800 )
93 #endif
94 };
95 #define RT5639_INIT_REG_LEN ARRAY_SIZE(init_list)
96
97 static int rt5639_reg_init(struct snd_soc_codec *codec)
98 {
99         int i;
100
101         for (i = 0; i < RT5639_INIT_REG_LEN; i++)
102                 snd_soc_write(codec, init_list[i].reg, init_list[i].val);
103
104         return 0;
105 }
106 #endif
107
108 static int rt5639_index_sync(struct snd_soc_codec *codec)
109 {
110         int i;
111
112         for (i = 0; i < RT5639_INIT_REG_LEN; i++)
113                 if (RT5639_PRIV_INDEX == init_list[i].reg ||
114                         RT5639_PRIV_DATA == init_list[i].reg)
115                         snd_soc_write(codec, init_list[i].reg,
116                                         init_list[i].val);
117         return 0;
118 }
119
120 static const u16 rt5639_reg[RT5639_VENDOR_ID2 + 1] = {
121         [RT5639_RESET] = 0x0008,
122         [RT5639_SPK_VOL] = 0xc8c8,
123         [RT5639_HP_VOL] = 0xc8c8,
124         [RT5639_OUTPUT] = 0xc8c8,
125         [RT5639_MONO_OUT] = 0x8000,
126         [RT5639_INL_INR_VOL] = 0x0808,
127         [RT5639_DAC1_DIG_VOL] = 0xafaf,
128         [RT5639_DAC2_DIG_VOL] = 0xafaf,
129         [RT5639_ADC_DIG_VOL] = 0x2f2f,
130         [RT5639_ADC_DATA] = 0x2f2f,
131         [RT5639_STO_ADC_MIXER] = 0x7060,
132         [RT5639_MONO_ADC_MIXER] = 0x7070,
133         [RT5639_AD_DA_MIXER] = 0x8080,
134         [RT5639_STO_DAC_MIXER] = 0x5454,
135         [RT5639_MONO_DAC_MIXER] = 0x5454,
136         [RT5639_DIG_MIXER] = 0xaa00,
137         [RT5639_DSP_PATH2] = 0xa000,
138         [RT5639_REC_L2_MIXER] = 0x007f,
139         [RT5639_REC_R2_MIXER] = 0x007f,
140         [RT5639_HPO_MIXER] = 0xe000,
141         [RT5639_SPK_L_MIXER] = 0x003e,
142         [RT5639_SPK_R_MIXER] = 0x003e,
143         [RT5639_SPO_L_MIXER] = 0xf800,
144         [RT5639_SPO_R_MIXER] = 0x3800,
145         [RT5639_SPO_CLSD_RATIO] = 0x0004,
146         [RT5639_MONO_MIXER] = 0xfc00,
147         [RT5639_OUT_L3_MIXER] = 0x01ff,
148         [RT5639_OUT_R3_MIXER] = 0x01ff,
149         [RT5639_LOUT_MIXER] = 0xf000,
150         [RT5639_PWR_ANLG1] = 0x00c0,
151         [RT5639_I2S1_SDP] = 0x8000,
152         [RT5639_I2S2_SDP] = 0x8000,
153         [RT5639_I2S3_SDP] = 0x8000,
154         [RT5639_ADDA_CLK1] = 0x1110,
155         [RT5639_ADDA_CLK2] = 0x0c00,
156         [RT5639_DMIC] = 0x1d00,
157         [RT5639_ASRC_3] = 0x0008,
158         [RT5639_HP_OVCD] = 0x0600,
159         [RT5639_CLS_D_OVCD] = 0x0228,
160         [RT5639_CLS_D_OUT] = 0xa800,
161         [RT5639_DEPOP_M1] = 0x0004,
162         [RT5639_DEPOP_M2] = 0x1100,
163         [RT5639_DEPOP_M3] = 0x0646,
164         [RT5639_CHARGE_PUMP] = 0x0c00,
165         [RT5639_MICBIAS] = 0x3000,
166         [RT5639_EQ_CTRL1] = 0x2080,
167         [RT5639_DRC_AGC_1] = 0x2206,
168         [RT5639_DRC_AGC_2] = 0x1f00,
169         [RT5639_ANC_CTRL1] = 0x034b,
170         [RT5639_ANC_CTRL2] = 0x0066,
171         [RT5639_ANC_CTRL3] = 0x000b,
172         [RT5639_GPIO_CTRL1] = 0x0400,
173         [RT5639_DSP_CTRL3] = 0x2000,
174         [RT5639_BASE_BACK] = 0x0013,
175         [RT5639_MP3_PLUS1] = 0x0680,
176         [RT5639_MP3_PLUS2] = 0x1c17,
177         [RT5639_3D_HP] = 0x8c00,
178         [RT5639_ADJ_HPF] = 0x2a20,
179         [RT5639_HP_CALIB_AMP_DET] = 0x0400,
180         [RT5639_SV_ZCD1] = 0x0809,
181         [RT5639_VENDOR_ID1] = 0x10ec,
182         [RT5639_VENDOR_ID2] = 0x6231,
183 };
184
185 static int rt5639_reset(struct snd_soc_codec *codec)
186 {
187         return snd_soc_write(codec, RT5639_RESET, 0);
188 }
189
190 /**
191  * rt5639_index_write - Write private register.
192  * @codec: SoC audio codec device.
193  * @reg: Private register index.
194  * @value: Private register Data.
195  *
196  * Modify private register for advanced setting. It can be written through
197  * private index (0x6a) and data (0x6c) register.
198  *
199  * Returns 0 for success or negative error code.
200  */
201 static int rt5639_index_write(struct snd_soc_codec *codec,
202                 unsigned int reg, unsigned int value)
203 {
204         int ret;
205
206         ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
207         if (ret < 0) {
208                 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
209                 goto err;
210         }
211         ret = snd_soc_write(codec, RT5639_PRIV_DATA, value);
212         if (ret < 0) {
213                 dev_err(codec->dev, "Failed to set private value: %d\n", ret);
214                 goto err;
215         }
216         return 0;
217
218 err:
219         return ret;
220 }
221
222 /**
223  * rt5639_index_read - Read private register.
224  * @codec: SoC audio codec device.
225  * @reg: Private register index.
226  *
227  * Read advanced setting from private register. It can be read through
228  * private index (0x6a) and data (0x6c) register.
229  *
230  * Returns private register value or negative error code.
231  */
232 static unsigned int rt5639_index_read(
233         struct snd_soc_codec *codec, unsigned int reg)
234 {
235         int ret;
236
237         ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
238         if (ret < 0) {
239                 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
240                 return ret;
241         }
242         return snd_soc_read(codec, RT5639_PRIV_DATA);
243 }
244
245 /**
246  * rt5639_index_update_bits - update private register bits
247  * @codec: audio codec
248  * @reg: Private register index.
249  * @mask: register mask
250  * @value: new value
251  *
252  * Writes new register value.
253  *
254  * Returns 1 for change, 0 for no change, or negative error code.
255  */
256 static int rt5639_index_update_bits(struct snd_soc_codec *codec,
257         unsigned int reg, unsigned int mask, unsigned int value)
258 {
259         unsigned int old, new;
260         int change, ret;
261
262         ret = rt5639_index_read(codec, reg);
263         if (ret < 0) {
264                 dev_err(codec->dev, "Failed to read private reg: %d\n", ret);
265                 goto err;
266         }
267
268         old = ret;
269         new = (old & ~mask) | (value & mask);
270         change = old != new;
271         if (change) {
272                 ret = rt5639_index_write(codec, reg, new);
273                 if (ret < 0) {
274                         dev_err(codec->dev,
275                                 "Failed to write private reg: %d\n", ret);
276                         goto err;
277                 }
278         }
279         return change;
280
281 err:
282         return ret;
283 }
284
285 static int rt5639_volatile_register(
286         struct snd_soc_codec *codec, unsigned int reg)
287 {
288         switch (reg) {
289         case RT5639_RESET:
290         case RT5639_PRIV_DATA:
291         case RT5639_ASRC_5:
292         case RT5639_EQ_CTRL1:
293         case RT5639_DRC_AGC_1:
294         case RT5639_ANC_CTRL1:
295         case RT5639_IRQ_CTRL2:
296         case RT5639_INT_IRQ_ST:
297         case RT5639_DSP_CTRL2:
298         case RT5639_DSP_CTRL3:
299         case RT5639_PGM_REG_ARR1:
300         case RT5639_PGM_REG_ARR3:
301                 return 1;
302         default:
303                 return 0;
304         }
305 }
306
307 static int rt5639_readable_register(
308         struct snd_soc_codec *codec, unsigned int reg)
309 {
310         switch (reg) {
311         case RT5639_RESET:
312         case RT5639_SPK_VOL:
313         case RT5639_HP_VOL:
314         case RT5639_OUTPUT:
315         case RT5639_MONO_OUT:
316         case RT5639_IN1_IN2:
317         case RT5639_IN3_IN4:
318         case RT5639_INL_INR_VOL:
319         case RT5639_DAC1_DIG_VOL:
320         case RT5639_DAC2_DIG_VOL:
321         case RT5639_DAC2_CTRL:
322         case RT5639_ADC_DIG_VOL:
323         case RT5639_ADC_DATA:
324         case RT5639_ADC_BST_VOL:
325         case RT5639_STO_ADC_MIXER:
326         case RT5639_MONO_ADC_MIXER:
327         case RT5639_AD_DA_MIXER:
328         case RT5639_STO_DAC_MIXER:
329         case RT5639_MONO_DAC_MIXER:
330         case RT5639_DIG_MIXER:
331         case RT5639_DSP_PATH1:
332         case RT5639_DSP_PATH2:
333         case RT5639_DIG_INF_DATA:
334         case RT5639_REC_L1_MIXER:
335         case RT5639_REC_L2_MIXER:
336         case RT5639_REC_R1_MIXER:
337         case RT5639_REC_R2_MIXER:
338         case RT5639_HPO_MIXER:
339         case RT5639_SPK_L_MIXER:
340         case RT5639_SPK_R_MIXER:
341         case RT5639_SPO_L_MIXER:
342         case RT5639_SPO_R_MIXER:
343         case RT5639_SPO_CLSD_RATIO:
344         case RT5639_MONO_MIXER:
345         case RT5639_OUT_L1_MIXER:
346         case RT5639_OUT_L2_MIXER:
347         case RT5639_OUT_L3_MIXER:
348         case RT5639_OUT_R1_MIXER:
349         case RT5639_OUT_R2_MIXER:
350         case RT5639_OUT_R3_MIXER:
351         case RT5639_LOUT_MIXER:
352         case RT5639_PWR_DIG1:
353         case RT5639_PWR_DIG2:
354         case RT5639_PWR_ANLG1:
355         case RT5639_PWR_ANLG2:
356         case RT5639_PWR_MIXER:
357         case RT5639_PWR_VOL:
358         case RT5639_PRIV_INDEX:
359         case RT5639_PRIV_DATA:
360         case RT5639_I2S1_SDP:
361         case RT5639_I2S2_SDP:
362         case RT5639_I2S3_SDP:
363         case RT5639_ADDA_CLK1:
364         case RT5639_ADDA_CLK2:
365         case RT5639_DMIC:
366         case RT5639_GLB_CLK:
367         case RT5639_PLL_CTRL1:
368         case RT5639_PLL_CTRL2:
369         case RT5639_ASRC_1:
370         case RT5639_ASRC_2:
371         case RT5639_ASRC_3:
372         case RT5639_ASRC_4:
373         case RT5639_ASRC_5:
374         case RT5639_HP_OVCD:
375         case RT5639_CLS_D_OVCD:
376         case RT5639_CLS_D_OUT:
377         case RT5639_DEPOP_M1:
378         case RT5639_DEPOP_M2:
379         case RT5639_DEPOP_M3:
380         case RT5639_CHARGE_PUMP:
381         case RT5639_PV_DET_SPK_G:
382         case RT5639_MICBIAS:
383         case RT5639_EQ_CTRL1:
384         case RT5639_EQ_CTRL2:
385         case RT5639_WIND_FILTER:
386         case RT5639_DRC_AGC_1:
387         case RT5639_DRC_AGC_2:
388         case RT5639_DRC_AGC_3:
389         case RT5639_SVOL_ZC:
390         case RT5639_ANC_CTRL1:
391         case RT5639_ANC_CTRL2:
392         case RT5639_ANC_CTRL3:
393         case RT5639_JD_CTRL:
394         case RT5639_ANC_JD:
395         case RT5639_IRQ_CTRL1:
396         case RT5639_IRQ_CTRL2:
397         case RT5639_INT_IRQ_ST:
398         case RT5639_GPIO_CTRL1:
399         case RT5639_GPIO_CTRL2:
400         case RT5639_GPIO_CTRL3:
401         case RT5639_DSP_CTRL1:
402         case RT5639_DSP_CTRL2:
403         case RT5639_DSP_CTRL3:
404         case RT5639_DSP_CTRL4:
405         case RT5639_PGM_REG_ARR1:
406         case RT5639_PGM_REG_ARR2:
407         case RT5639_PGM_REG_ARR3:
408         case RT5639_PGM_REG_ARR4:
409         case RT5639_PGM_REG_ARR5:
410         case RT5639_SCB_FUNC:
411         case RT5639_SCB_CTRL:
412         case RT5639_BASE_BACK:
413         case RT5639_MP3_PLUS1:
414         case RT5639_MP3_PLUS2:
415         case RT5639_3D_HP:
416         case RT5639_ADJ_HPF:
417         case RT5639_HP_CALIB_AMP_DET:
418         case RT5639_HP_CALIB2:
419         case RT5639_SV_ZCD1:
420         case RT5639_SV_ZCD2:
421         case RT5639_DUMMY1:
422         case RT5639_DUMMY2:
423         case RT5639_DUMMY3:
424         case RT5639_VENDOR_ID:
425         case RT5639_VENDOR_ID1:
426         case RT5639_VENDOR_ID2:
427                 return 1;
428         default:
429                 return 0;
430         }
431 }
432
433 int rt5639_headset_detect(struct snd_soc_codec *codec, int jack_insert)
434 {
435         int jack_type;
436         int sclk_src;
437
438         if (jack_insert) {
439                 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
440                         snd_soc_write(codec, RT5639_PWR_ANLG1, 0x2004);
441                         snd_soc_write(codec, RT5639_MICBIAS, 0x3830);
442                         snd_soc_write(codec, RT5639_DUMMY1 , 0x3701);
443                 }
444                 sclk_src = snd_soc_read(codec, RT5639_GLB_CLK) &
445                         RT5639_SCLK_SRC_MASK;
446                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
447                         RT5639_SCLK_SRC_MASK, 0x3 << RT5639_SCLK_SRC_SFT);
448                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
449                         RT5639_PWR_LDO2, RT5639_PWR_LDO2);
450                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
451                         RT5639_PWR_MB1, RT5639_PWR_MB1);
452                 snd_soc_update_bits(codec, RT5639_MICBIAS,
453                         RT5639_MIC1_OVCD_MASK | RT5639_MIC1_OVTH_MASK |
454                         RT5639_PWR_CLK25M_MASK | RT5639_PWR_MB_MASK,
455                         RT5639_MIC1_OVCD_EN | RT5639_MIC1_OVTH_1500UA |
456                         RT5639_PWR_MB_PU | RT5639_PWR_CLK25M_PU);
457                 snd_soc_update_bits(codec, RT5639_DUMMY1,
458                         0x1, 0x1);
459                 msleep(100);
460                 if (snd_soc_read(codec, RT5639_IRQ_CTRL2) & 0x8)
461                         jack_type = RT5639_HEADPHO_DET;
462                 else
463                         jack_type = RT5639_HEADSET_DET;
464                 snd_soc_update_bits(codec, RT5639_IRQ_CTRL2,
465                         RT5639_MB1_OC_CLR, 0);
466                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
467                         RT5639_SCLK_SRC_MASK, sclk_src);
468         } else {
469                 snd_soc_update_bits(codec, RT5639_MICBIAS,
470                         RT5639_MIC1_OVCD_MASK,
471                         RT5639_MIC1_OVCD_DIS);
472
473                 jack_type = RT5639_NO_JACK;
474         }
475
476         return jack_type;
477 }
478 EXPORT_SYMBOL(rt5639_headset_detect);
479
480 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
481 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
482 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
483 static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
484 static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
485
486 /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
487 static unsigned int bst_tlv[] = {
488         TLV_DB_RANGE_HEAD(7),
489         0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
490         1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
491         2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
492         3, 5, TLV_DB_SCALE_ITEM(3000, 500, 0),
493         6, 6, TLV_DB_SCALE_ITEM(4400, 0, 0),
494         7, 7, TLV_DB_SCALE_ITEM(5000, 0, 0),
495         8, 8, TLV_DB_SCALE_ITEM(5200, 0, 0),
496 };
497
498 static int rt5639_dmic_get(struct snd_kcontrol *kcontrol,
499                 struct snd_ctl_elem_value *ucontrol)
500 {
501         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
502         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
503
504         ucontrol->value.integer.value[0] = rt5639->dmic_en;
505
506         return 0;
507 }
508
509 static int rt5639_dmic_put(struct snd_kcontrol *kcontrol,
510                 struct snd_ctl_elem_value *ucontrol)
511 {
512         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
513         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
514
515         if (rt5639->dmic_en == ucontrol->value.integer.value[0])
516                 return 0;
517
518         rt5639->dmic_en = ucontrol->value.integer.value[0];
519         switch (rt5639->dmic_en) {
520         case RT5639_DMIC_DIS:
521                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
522                         RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK |
523                         RT5639_GP4_PIN_MASK,
524                         RT5639_GP2_PIN_GPIO2 | RT5639_GP3_PIN_GPIO3 |
525                         RT5639_GP4_PIN_GPIO4);
526                 snd_soc_update_bits(codec, RT5639_DMIC,
527                         RT5639_DMIC_1_DP_MASK | RT5639_DMIC_2_DP_MASK,
528                         RT5639_DMIC_1_DP_GPIO3 | RT5639_DMIC_2_DP_GPIO4);
529                 snd_soc_update_bits(codec, RT5639_DMIC,
530                         RT5639_DMIC_1_EN_MASK | RT5639_DMIC_2_EN_MASK,
531                         RT5639_DMIC_1_DIS | RT5639_DMIC_2_DIS);
532                 break;
533
534         case RT5639_DMIC1:
535                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
536                         RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK,
537                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP3_PIN_DMIC1_SDA);
538                 snd_soc_update_bits(codec, RT5639_DMIC,
539                         RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK |
540                         RT5639_DMIC_1_DP_MASK,
541                         RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING |
542                         RT5639_DMIC_1_DP_IN1P);
543                 snd_soc_update_bits(codec, RT5639_DMIC,
544                         RT5639_DMIC_1_EN_MASK, RT5639_DMIC_1_EN);
545                 break;
546
547         case RT5639_DMIC2:
548                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
549                         RT5639_GP2_PIN_MASK | RT5639_GP4_PIN_MASK,
550                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP4_PIN_DMIC2_SDA);
551                 snd_soc_update_bits(codec, RT5639_DMIC,
552                         RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK |
553                         RT5639_DMIC_2_DP_MASK,
554                         RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING |
555                         RT5639_DMIC_2_DP_IN1N);
556                 snd_soc_update_bits(codec, RT5639_DMIC,
557                         RT5639_DMIC_2_EN_MASK, RT5639_DMIC_2_EN);
558                 break;
559
560         default:
561                 return -EINVAL;
562         }
563
564         return 0;
565 }
566
567
568 /* IN1/IN2 Input Type */
569 static const char *rt5639_input_mode[] = {
570         "Single ended", "Differential"};
571
572 static const SOC_ENUM_SINGLE_DECL(
573         rt5639_in1_mode_enum, RT5639_IN1_IN2,
574         RT5639_IN_SFT1, rt5639_input_mode);
575
576 static const SOC_ENUM_SINGLE_DECL(
577         rt5639_in2_mode_enum, RT5639_IN3_IN4,
578         RT5639_IN_SFT2, rt5639_input_mode);
579
580 /* Interface data select */
581 static const char *rt5639_data_select[] = {
582         "Normal", "left copy to right", "right copy to left", "Swap"};
583
584 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_dac_enum, RT5639_DIG_INF_DATA,
585                                 RT5639_IF1_DAC_SEL_SFT, rt5639_data_select);
586
587 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_adc_enum, RT5639_DIG_INF_DATA,
588                                 RT5639_IF1_ADC_SEL_SFT, rt5639_data_select);
589
590 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_dac_enum, RT5639_DIG_INF_DATA,
591                                 RT5639_IF2_DAC_SEL_SFT, rt5639_data_select);
592
593 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_enum, RT5639_DIG_INF_DATA,
594                                 RT5639_IF2_ADC_SEL_SFT, rt5639_data_select);
595
596 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_dac_enum, RT5639_DIG_INF_DATA,
597                                 RT5639_IF3_DAC_SEL_SFT, rt5639_data_select);
598
599 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_adc_enum, RT5639_DIG_INF_DATA,
600                                 RT5639_IF3_ADC_SEL_SFT, rt5639_data_select);
601
602 /* Class D speaker gain ratio */
603 static const char *rt5639_clsd_spk_ratio[] = {"1.66x", "1.83x", "1.94x", "2x",
604         "2.11x", "2.22x", "2.33x", "2.44x", "2.55x", "2.66x", "2.77x"};
605
606 static const SOC_ENUM_SINGLE_DECL(
607         rt5639_clsd_spk_ratio_enum, RT5639_CLS_D_OUT,
608         RT5639_CLSD_RATIO_SFT, rt5639_clsd_spk_ratio);
609
610 /* DMIC */
611 static const char *rt5639_dmic_mode[] = {"Disable", "DMIC1", "DMIC2"};
612
613 static const SOC_ENUM_SINGLE_DECL(rt5639_dmic_enum, 0, 0, rt5639_dmic_mode);
614
615
616
617 #ifdef RT5639_REG_RW
618 #define REGVAL_MAX 0xffff
619 static unsigned int regctl_addr;
620 static int rt5639_regctl_info(struct snd_kcontrol *kcontrol,
621                         struct snd_ctl_elem_info *uinfo)
622 {
623         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
624         uinfo->count = 2;
625         uinfo->value.integer.min = 0;
626         uinfo->value.integer.max = REGVAL_MAX;
627         return 0;
628 }
629
630 static int rt5639_regctl_get(struct snd_kcontrol *kcontrol,
631                         struct snd_ctl_elem_value *ucontrol)
632 {
633         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
634         ucontrol->value.integer.value[0] = regctl_addr;
635         ucontrol->value.integer.value[1] = snd_soc_read(codec, regctl_addr);
636         return 0;
637 }
638
639 static int rt5639_regctl_put(struct snd_kcontrol *kcontrol,
640                         struct snd_ctl_elem_value *ucontrol)
641 {
642         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
643         regctl_addr = ucontrol->value.integer.value[0];
644         if(ucontrol->value.integer.value[1] <= REGVAL_MAX)
645                 snd_soc_write(codec, regctl_addr, ucontrol->value.integer.value[1]);
646         return 0;
647 }
648 #endif
649
650
651 static int rt5639_vol_rescale_get(struct snd_kcontrol *kcontrol,
652                 struct snd_ctl_elem_value *ucontrol)
653 {
654         struct soc_mixer_control *mc =
655                 (struct soc_mixer_control *)kcontrol->private_value;
656         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
657         unsigned int val = snd_soc_read(codec, mc->reg);
658
659         ucontrol->value.integer.value[0] = RT5639_VOL_RSCL_MAX -
660                 ((val & RT5639_L_VOL_MASK) >> mc->shift);
661         ucontrol->value.integer.value[1] = RT5639_VOL_RSCL_MAX -
662                 (val & RT5639_R_VOL_MASK);
663
664         return 0;
665 }
666
667 static int rt5639_vol_rescale_put(struct snd_kcontrol *kcontrol,
668                 struct snd_ctl_elem_value *ucontrol)
669 {
670         struct soc_mixer_control *mc =
671                 (struct soc_mixer_control *)kcontrol->private_value;
672         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
673         unsigned int val, val2;
674
675         val = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[0];
676         val2 = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[1];
677         return snd_soc_update_bits_locked(codec, mc->reg, RT5639_L_VOL_MASK |
678                         RT5639_R_VOL_MASK, val << mc->shift | val2);
679 }
680
681
682 static const struct snd_kcontrol_new rt5639_snd_controls[] = {
683         /* Speaker Output Volume */
684         SOC_DOUBLE_EXT_TLV("Speaker Playback Volume", RT5639_SPK_VOL,
685                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
686                 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
687         /* Headphone Output Volume */
688         SOC_DOUBLE("HP Playback Switch", RT5639_HP_VOL,
689                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
690         SOC_DOUBLE_EXT_TLV("HP Playback Volume", RT5639_HP_VOL,
691                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
692                 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
693         /* OUTPUT Control */
694         SOC_DOUBLE("OUT Playback Switch", RT5639_OUTPUT,
695                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
696         SOC_DOUBLE("OUT Channel Switch", RT5639_OUTPUT,
697                 RT5639_VOL_L_SFT, RT5639_VOL_R_SFT, 1, 1),
698         SOC_DOUBLE_TLV("OUT Playback Volume", RT5639_OUTPUT,
699                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, 39, 1, out_vol_tlv),
700         /* MONO Output Control */
701         SOC_SINGLE("Mono Playback Switch", RT5639_MONO_OUT,
702                                 RT5639_L_MUTE_SFT, 1, 1),
703         /* DAC Digital Volume */
704         SOC_DOUBLE("DAC2 Playback Switch", RT5639_DAC2_CTRL,
705                 RT5639_M_DAC_L2_VOL_SFT, RT5639_M_DAC_R2_VOL_SFT, 1, 1),
706         SOC_DOUBLE_TLV("DAC1 Playback Volume", RT5639_DAC1_DIG_VOL,
707                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
708                         175, 0, dac_vol_tlv),
709         SOC_DOUBLE_TLV("Mono DAC Playback Volume", RT5639_DAC2_DIG_VOL,
710                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
711                         175, 0, dac_vol_tlv),
712         /* IN1/IN2 Control */
713         SOC_ENUM("IN1 Mode Control",  rt5639_in1_mode_enum),
714         SOC_SINGLE_TLV("IN1 Boost", RT5639_IN1_IN2,
715                 RT5639_BST_SFT1, 8, 0, bst_tlv),
716         SOC_ENUM("IN2 Mode Control", rt5639_in2_mode_enum),
717         SOC_SINGLE_TLV("IN2 Boost", RT5639_IN3_IN4,
718                 RT5639_BST_SFT2, 8, 0, bst_tlv),
719         /* INL/INR Volume Control */
720         SOC_DOUBLE_TLV("IN Capture Volume", RT5639_INL_INR_VOL,
721                         RT5639_INL_VOL_SFT, RT5639_INR_VOL_SFT,
722                         31, 1, in_vol_tlv),
723         /* ADC Digital Volume Control */
724         SOC_DOUBLE("ADC Capture Switch", RT5639_ADC_DIG_VOL,
725                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
726         SOC_DOUBLE_TLV("ADC Capture Volume", RT5639_ADC_DIG_VOL,
727                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
728                         127, 0, adc_vol_tlv),
729         SOC_DOUBLE_TLV("Mono ADC Capture Volume", RT5639_ADC_DATA,
730                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
731                         127, 0, adc_vol_tlv),
732         /* ADC Boost Volume Control */
733         SOC_DOUBLE_TLV("ADC Boost Gain", RT5639_ADC_BST_VOL,
734                         RT5639_ADC_L_BST_SFT, RT5639_ADC_R_BST_SFT,
735                         3, 0, adc_bst_tlv),
736         /* Class D speaker gain ratio */
737         SOC_ENUM("Class D SPK Ratio Control", rt5639_clsd_spk_ratio_enum),
738         /* DMIC */
739         SOC_ENUM_EXT("DMIC Switch", rt5639_dmic_enum,
740                 rt5639_dmic_get, rt5639_dmic_put),
741
742 #ifdef RT5639_REG_RW
743         {
744                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
745                 .name = "Register Control",
746                 .info = rt5639_regctl_info,
747                 .get = rt5639_regctl_get,
748                 .put = rt5639_regctl_put,
749         },
750 #endif
751 };
752
753 /**
754  * set_dmic_clk - Set parameter of dmic.
755  *
756  * @w: DAPM widget.
757  * @kcontrol: The kcontrol of this widget.
758  * @event: Event id.
759  *
760  * Choose dmic clock between 1MHz and 3MHz.
761  * It is better for clock to approximate 3MHz.
762  */
763 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
764         struct snd_kcontrol *kcontrol, int event)
765 {
766         struct snd_soc_codec *codec = w->codec;
767         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
768         int div[] = {2, 3, 4, 6, 12}, idx = -EINVAL, i, rate, red, bound, temp;
769
770         rate = rt5639->lrck[rt5639->aif_pu] << 8;
771         red = 3000000 * 12;
772         for (i = 0; i < ARRAY_SIZE(div); i++) {
773                 bound = div[i] * 3000000;
774                 if (rate > bound)
775                         continue;
776                 temp = bound - rate;
777                 if (temp < red) {
778                         red = temp;
779                         idx = i;
780                 }
781         }
782         if (idx < 0)
783                 dev_err(codec->dev, "Failed to set DMIC clock\n");
784         else
785                 snd_soc_update_bits(codec, RT5639_DMIC, RT5639_DMIC_CLK_MASK,
786                                         idx << RT5639_DMIC_CLK_SFT);
787         return idx;
788 }
789
790 static int check_sysclk1_source(struct snd_soc_dapm_widget *source,
791                          struct snd_soc_dapm_widget *sink)
792 {
793         unsigned int val;
794
795         val = snd_soc_read(source->codec, RT5639_GLB_CLK);
796         val &= RT5639_SCLK_SRC_MASK;
797         if (val == RT5639_SCLK_SRC_PLL1)
798                 return 1;
799         else
800                 return 0;
801 }
802
803 /* Digital Mixer */
804 static const struct snd_kcontrol_new rt5639_sto_adc_l_mix[] = {
805         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
806                         RT5639_M_ADC_L1_SFT, 1, 1),
807         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
808                         RT5639_M_ADC_L2_SFT, 1, 1),
809 };
810
811 static const struct snd_kcontrol_new rt5639_sto_adc_r_mix[] = {
812         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
813                         RT5639_M_ADC_R1_SFT, 1, 1),
814         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
815                         RT5639_M_ADC_R2_SFT, 1, 1),
816 };
817
818 static const struct snd_kcontrol_new rt5639_mono_adc_l_mix[] = {
819         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
820                         RT5639_M_MONO_ADC_L1_SFT, 1, 1),
821         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
822                         RT5639_M_MONO_ADC_L2_SFT, 1, 1),
823 };
824
825 static const struct snd_kcontrol_new rt5639_mono_adc_r_mix[] = {
826         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
827                         RT5639_M_MONO_ADC_R1_SFT, 1, 1),
828         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
829                         RT5639_M_MONO_ADC_R2_SFT, 1, 1),
830 };
831
832 static const struct snd_kcontrol_new rt5639_dac_l_mix[] = {
833         SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
834                         RT5639_M_ADCMIX_L_SFT, 1, 1),
835         SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
836                         RT5639_M_IF1_DAC_L_SFT, 1, 1),
837 };
838
839 static const struct snd_kcontrol_new rt5639_dac_r_mix[] = {
840         SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
841                         RT5639_M_ADCMIX_R_SFT, 1, 1),
842         SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
843                         RT5639_M_IF1_DAC_R_SFT, 1, 1),
844 };
845
846 static const struct snd_kcontrol_new rt5639_sto_dac_l_mix[] = {
847         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_STO_DAC_MIXER,
848                         RT5639_M_DAC_L1_SFT, 1, 1),
849         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_STO_DAC_MIXER,
850                         RT5639_M_DAC_L2_SFT, 1, 1),
851         SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
852                         RT5639_M_ANC_DAC_L_SFT, 1, 1),
853 };
854
855 static const struct snd_kcontrol_new rt5639_sto_dac_r_mix[] = {
856         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_STO_DAC_MIXER,
857                         RT5639_M_DAC_R1_SFT, 1, 1),
858         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_STO_DAC_MIXER,
859                         RT5639_M_DAC_R2_SFT, 1, 1),
860         SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
861                         RT5639_M_ANC_DAC_R_SFT, 1, 1),
862 };
863
864 static const struct snd_kcontrol_new rt5639_mono_dac_l_mix[] = {
865         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_MONO_DAC_MIXER,
866                         RT5639_M_DAC_L1_MONO_L_SFT, 1, 1),
867         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
868                         RT5639_M_DAC_L2_MONO_L_SFT, 1, 1),
869         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
870                         RT5639_M_DAC_R2_MONO_L_SFT, 1, 1),
871 };
872
873 static const struct snd_kcontrol_new rt5639_mono_dac_r_mix[] = {
874         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_MONO_DAC_MIXER,
875                         RT5639_M_DAC_R1_MONO_R_SFT, 1, 1),
876         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
877                         RT5639_M_DAC_R2_MONO_R_SFT, 1, 1),
878         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
879                         RT5639_M_DAC_L2_MONO_R_SFT, 1, 1),
880 };
881
882 static const struct snd_kcontrol_new rt5639_dig_l_mix[] = {
883         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_DIG_MIXER,
884                         RT5639_M_STO_L_DAC_L_SFT, 1, 1),
885         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_DIG_MIXER,
886                         RT5639_M_DAC_L2_DAC_L_SFT, 1, 1),
887 };
888
889 static const struct snd_kcontrol_new rt5639_dig_r_mix[] = {
890         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_DIG_MIXER,
891                         RT5639_M_STO_R_DAC_R_SFT, 1, 1),
892         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_DIG_MIXER,
893                         RT5639_M_DAC_R2_DAC_R_SFT, 1, 1),
894 };
895
896 /* Analog Input Mixer */
897 static const struct snd_kcontrol_new rt5639_rec_l_mix[] = {
898         SOC_DAPM_SINGLE("HPOL Switch", RT5639_REC_L2_MIXER,
899                         RT5639_M_HP_L_RM_L_SFT, 1, 1),
900         SOC_DAPM_SINGLE("INL Switch", RT5639_REC_L2_MIXER,
901                         RT5639_M_IN_L_RM_L_SFT, 1, 1),
902         SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_L2_MIXER,
903                         RT5639_M_BST4_RM_L_SFT, 1, 1),
904         SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_L2_MIXER,
905                         RT5639_M_BST1_RM_L_SFT, 1, 1),
906         SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_REC_L2_MIXER,
907                         RT5639_M_OM_L_RM_L_SFT, 1, 1),
908 };
909
910 static const struct snd_kcontrol_new rt5639_rec_r_mix[] = {
911         SOC_DAPM_SINGLE("HPOR Switch", RT5639_REC_R2_MIXER,
912                         RT5639_M_HP_R_RM_R_SFT, 1, 1),
913         SOC_DAPM_SINGLE("INR Switch", RT5639_REC_R2_MIXER,
914                         RT5639_M_IN_R_RM_R_SFT, 1, 1),
915         SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_R2_MIXER,
916                         RT5639_M_BST4_RM_R_SFT, 1, 1),
917         SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_R2_MIXER,
918                         RT5639_M_BST1_RM_R_SFT, 1, 1),
919         SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_REC_R2_MIXER,
920                         RT5639_M_OM_R_RM_R_SFT, 1, 1),
921 };
922
923 /* Analog Output Mixer */
924 static const struct snd_kcontrol_new rt5639_spk_l_mix[] = {
925         SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_SPK_L_MIXER,
926                         RT5639_M_RM_L_SM_L_SFT, 1, 1),
927         SOC_DAPM_SINGLE("INL Switch", RT5639_SPK_L_MIXER,
928                         RT5639_M_IN_L_SM_L_SFT, 1, 1),
929         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPK_L_MIXER,
930                         RT5639_M_DAC_L1_SM_L_SFT, 1, 1),
931         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_SPK_L_MIXER,
932                         RT5639_M_DAC_L2_SM_L_SFT, 1, 1),
933         SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_SPK_L_MIXER,
934                         RT5639_M_OM_L_SM_L_SFT, 1, 1),
935 };
936
937 static const struct snd_kcontrol_new rt5639_spk_r_mix[] = {
938         SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_SPK_R_MIXER,
939                         RT5639_M_RM_R_SM_R_SFT, 1, 1),
940         SOC_DAPM_SINGLE("INR Switch", RT5639_SPK_R_MIXER,
941                         RT5639_M_IN_R_SM_R_SFT, 1, 1),
942         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPK_R_MIXER,
943                         RT5639_M_DAC_R1_SM_R_SFT, 1, 1),
944         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_SPK_R_MIXER,
945                         RT5639_M_DAC_R2_SM_R_SFT, 1, 1),
946         SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_SPK_R_MIXER,
947                         RT5639_M_OM_R_SM_R_SFT, 1, 1),
948 };
949
950 static const struct snd_kcontrol_new rt5639_out_l_mix[] = {
951         SOC_DAPM_SINGLE("SPK MIXL Switch", RT5639_OUT_L3_MIXER,
952                         RT5639_M_SM_L_OM_L_SFT, 1, 1),
953         SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_L3_MIXER,
954                         RT5639_M_BST1_OM_L_SFT, 1, 1),
955         SOC_DAPM_SINGLE("INL Switch", RT5639_OUT_L3_MIXER,
956                         RT5639_M_IN_L_OM_L_SFT, 1, 1),
957         SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_OUT_L3_MIXER,
958                         RT5639_M_RM_L_OM_L_SFT, 1, 1),
959         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_OUT_L3_MIXER,
960                         RT5639_M_DAC_R2_OM_L_SFT, 1, 1),
961         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_OUT_L3_MIXER,
962                         RT5639_M_DAC_L2_OM_L_SFT, 1, 1),
963         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_OUT_L3_MIXER,
964                         RT5639_M_DAC_L1_OM_L_SFT, 1, 1),
965 };
966
967 static const struct snd_kcontrol_new rt5639_out_r_mix[] = {
968         SOC_DAPM_SINGLE("SPK MIXR Switch", RT5639_OUT_R3_MIXER,
969                         RT5639_M_SM_L_OM_R_SFT, 1, 1),
970         SOC_DAPM_SINGLE("BST2 Switch", RT5639_OUT_R3_MIXER,
971                         RT5639_M_BST4_OM_R_SFT, 1, 1),
972         SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_R3_MIXER,
973                         RT5639_M_BST1_OM_R_SFT, 1, 1),
974         SOC_DAPM_SINGLE("INR Switch", RT5639_OUT_R3_MIXER,
975                         RT5639_M_IN_R_OM_R_SFT, 1, 1),
976         SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_OUT_R3_MIXER,
977                         RT5639_M_RM_R_OM_R_SFT, 1, 1),
978         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_OUT_R3_MIXER,
979                         RT5639_M_DAC_L2_OM_R_SFT, 1, 1),
980         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_OUT_R3_MIXER,
981                         RT5639_M_DAC_R2_OM_R_SFT, 1, 1),
982         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_OUT_R3_MIXER,
983                         RT5639_M_DAC_R1_OM_R_SFT, 1, 1),
984 };
985
986 static const struct snd_kcontrol_new rt5639_spo_l_mix[] = {
987         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_L_MIXER,
988                         RT5639_M_DAC_R1_SPM_L_SFT, 1, 1),
989         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPO_L_MIXER,
990                         RT5639_M_DAC_L1_SPM_L_SFT, 1, 1),
991         SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_L_MIXER,
992                         RT5639_M_SV_R_SPM_L_SFT, 1, 1),
993         SOC_DAPM_SINGLE("SPKVOL L Switch", RT5639_SPO_L_MIXER,
994                         RT5639_M_SV_L_SPM_L_SFT, 1, 1),
995         SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_L_MIXER,
996                         RT5639_M_BST1_SPM_L_SFT, 1, 1),
997 };
998
999 static const struct snd_kcontrol_new rt5639_spo_r_mix[] = {
1000         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_R_MIXER,
1001                         RT5639_M_DAC_R1_SPM_R_SFT, 1, 1),
1002         SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_R_MIXER,
1003                         RT5639_M_SV_R_SPM_R_SFT, 1, 1),
1004         SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_R_MIXER,
1005                         RT5639_M_BST1_SPM_R_SFT, 1, 1),
1006 };
1007
1008 static const struct snd_kcontrol_new rt5639_hpo_mix[] = {
1009         SOC_DAPM_SINGLE("DAC2 Switch", RT5639_HPO_MIXER,
1010                         RT5639_M_DAC2_HM_SFT, 1, 1),
1011         SOC_DAPM_SINGLE("DAC1 Switch", RT5639_HPO_MIXER,
1012                         RT5639_M_DAC1_HM_SFT, 1, 1),
1013         SOC_DAPM_SINGLE("HPVOL Switch", RT5639_HPO_MIXER,
1014                         RT5639_M_HPVOL_HM_SFT, 1, 1),
1015 };
1016
1017 static const struct snd_kcontrol_new rt5639_lout_mix[] = {
1018         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_LOUT_MIXER,
1019                         RT5639_M_DAC_L1_LM_SFT, 1, 1),
1020         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_LOUT_MIXER,
1021                         RT5639_M_DAC_R1_LM_SFT, 1, 1),
1022         SOC_DAPM_SINGLE("OUTVOL L Switch", RT5639_LOUT_MIXER,
1023                         RT5639_M_OV_L_LM_SFT, 1, 1),
1024         SOC_DAPM_SINGLE("OUTVOL R Switch", RT5639_LOUT_MIXER,
1025                         RT5639_M_OV_R_LM_SFT, 1, 1),
1026 };
1027
1028 static const struct snd_kcontrol_new rt5639_mono_mix[] = {
1029         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_MIXER,
1030                         RT5639_M_DAC_R2_MM_SFT, 1, 1),
1031         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_MIXER,
1032                         RT5639_M_DAC_L2_MM_SFT, 1, 1),
1033         SOC_DAPM_SINGLE("OUTVOL R Switch", RT5639_MONO_MIXER,
1034                         RT5639_M_OV_R_MM_SFT, 1, 1),
1035         SOC_DAPM_SINGLE("OUTVOL L Switch", RT5639_MONO_MIXER,
1036                         RT5639_M_OV_L_MM_SFT, 1, 1),
1037         SOC_DAPM_SINGLE("BST1 Switch", RT5639_MONO_MIXER,
1038                         RT5639_M_BST1_MM_SFT, 1, 1),
1039 };
1040
1041 /* INL/R source */
1042 static const char *rt5639_inl_src[] = {"IN2P", "MonoP"};
1043
1044 static const SOC_ENUM_SINGLE_DECL(
1045         rt5639_inl_enum, RT5639_INL_INR_VOL,
1046         RT5639_INL_SEL_SFT, rt5639_inl_src);
1047
1048 static const struct snd_kcontrol_new rt5639_inl_mux =
1049         SOC_DAPM_ENUM("INL source", rt5639_inl_enum);
1050
1051 static const char *rt5639_inr_src[] = {"IN2N", "MonoN"};
1052
1053 static const SOC_ENUM_SINGLE_DECL(
1054         rt5639_inr_enum, RT5639_INL_INR_VOL,
1055         RT5639_INR_SEL_SFT, rt5639_inr_src);
1056
1057 static const struct snd_kcontrol_new rt5639_inr_mux =
1058         SOC_DAPM_ENUM("INR source", rt5639_inr_enum);
1059
1060 /* Stereo ADC source */
1061 static const char *rt5639_stereo_adc1_src[] = {"DIG MIX", "ADC"};
1062
1063 static const SOC_ENUM_SINGLE_DECL(
1064         rt5639_stereo_adc1_enum, RT5639_STO_ADC_MIXER,
1065         RT5639_ADC_1_SRC_SFT, rt5639_stereo_adc1_src);
1066
1067 static const struct snd_kcontrol_new rt5639_sto_adc_l1_mux =
1068         SOC_DAPM_ENUM("Stereo ADC L1 source", rt5639_stereo_adc1_enum);
1069
1070 static const struct snd_kcontrol_new rt5639_sto_adc_r1_mux =
1071         SOC_DAPM_ENUM("Stereo ADC R1 source", rt5639_stereo_adc1_enum);
1072
1073 static const char *rt5639_stereo_adc2_src[] = {"DMIC1", "DMIC2", "DIG MIX"};
1074
1075 static const SOC_ENUM_SINGLE_DECL(
1076         rt5639_stereo_adc2_enum, RT5639_STO_ADC_MIXER,
1077         RT5639_ADC_2_SRC_SFT, rt5639_stereo_adc2_src);
1078
1079 static const struct snd_kcontrol_new rt5639_sto_adc_l2_mux =
1080         SOC_DAPM_ENUM("Stereo ADC L2 source", rt5639_stereo_adc2_enum);
1081
1082 static const struct snd_kcontrol_new rt5639_sto_adc_r2_mux =
1083         SOC_DAPM_ENUM("Stereo ADC R2 source", rt5639_stereo_adc2_enum);
1084
1085 /* Mono ADC source */
1086 static const char *rt5639_mono_adc_l1_src[] = {"Mono DAC MIXL", "ADCL"};
1087
1088 static const SOC_ENUM_SINGLE_DECL(
1089         rt5639_mono_adc_l1_enum, RT5639_MONO_ADC_MIXER,
1090         RT5639_MONO_ADC_L1_SRC_SFT, rt5639_mono_adc_l1_src);
1091
1092 static const struct snd_kcontrol_new rt5639_mono_adc_l1_mux =
1093         SOC_DAPM_ENUM("Mono ADC1 left source", rt5639_mono_adc_l1_enum);
1094
1095 static const char *rt5639_mono_adc_l2_src[] =
1096         {"DMIC L1", "DMIC L2", "Mono DAC MIXL"};
1097
1098 static const SOC_ENUM_SINGLE_DECL(
1099         rt5639_mono_adc_l2_enum, RT5639_MONO_ADC_MIXER,
1100         RT5639_MONO_ADC_L2_SRC_SFT, rt5639_mono_adc_l2_src);
1101
1102 static const struct snd_kcontrol_new rt5639_mono_adc_l2_mux =
1103         SOC_DAPM_ENUM("Mono ADC2 left source", rt5639_mono_adc_l2_enum);
1104
1105 static const char *rt5639_mono_adc_r1_src[] = {"Mono DAC MIXR", "ADCR"};
1106
1107 static const SOC_ENUM_SINGLE_DECL(
1108         rt5639_mono_adc_r1_enum, RT5639_MONO_ADC_MIXER,
1109         RT5639_MONO_ADC_R1_SRC_SFT, rt5639_mono_adc_r1_src);
1110
1111 static const struct snd_kcontrol_new rt5639_mono_adc_r1_mux =
1112         SOC_DAPM_ENUM("Mono ADC1 right source", rt5639_mono_adc_r1_enum);
1113
1114 static const char *rt5639_mono_adc_r2_src[] =
1115         {"DMIC R1", "DMIC R2", "Mono DAC MIXR"};
1116
1117 static const SOC_ENUM_SINGLE_DECL(
1118         rt5639_mono_adc_r2_enum, RT5639_MONO_ADC_MIXER,
1119         RT5639_MONO_ADC_R2_SRC_SFT, rt5639_mono_adc_r2_src);
1120
1121 static const struct snd_kcontrol_new rt5639_mono_adc_r2_mux =
1122         SOC_DAPM_ENUM("Mono ADC2 right source", rt5639_mono_adc_r2_enum);
1123
1124 /* DAC2 channel source */
1125 static const char *rt5639_dac_l2_src[] = {"IF2", "IF3", "TxDC", "Base L/R"};
1126
1127 static const SOC_ENUM_SINGLE_DECL(rt5639_dac_l2_enum, RT5639_DSP_PATH2,
1128                                 RT5639_DAC_L2_SEL_SFT, rt5639_dac_l2_src);
1129
1130 static const struct snd_kcontrol_new rt5639_dac_l2_mux =
1131         SOC_DAPM_ENUM("DAC2 left channel source", rt5639_dac_l2_enum);
1132
1133 static const char *rt5639_dac_r2_src[] = {"IF2", "IF3", "TxDC"};
1134
1135 static const SOC_ENUM_SINGLE_DECL(
1136         rt5639_dac_r2_enum, RT5639_DSP_PATH2,
1137         RT5639_DAC_R2_SEL_SFT, rt5639_dac_r2_src);
1138
1139 static const struct snd_kcontrol_new rt5639_dac_r2_mux =
1140         SOC_DAPM_ENUM("DAC2 right channel source", rt5639_dac_r2_enum);
1141
1142 /* Interface 2  ADC channel source */
1143 static const char *rt5639_if2_adc_l_src[] = {"TxDP", "Mono ADC MIXL"};
1144
1145 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_l_enum, RT5639_DSP_PATH2,
1146                         RT5639_IF2_ADC_L_SEL_SFT, rt5639_if2_adc_l_src);
1147
1148 static const struct snd_kcontrol_new rt5639_if2_adc_l_mux =
1149         SOC_DAPM_ENUM("IF2 ADC left channel source", rt5639_if2_adc_l_enum);
1150
1151 static const char *rt5639_if2_adc_r_src[] = {"TxDP", "Mono ADC MIXR"};
1152
1153 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_r_enum, RT5639_DSP_PATH2,
1154                         RT5639_IF2_ADC_R_SEL_SFT, rt5639_if2_adc_r_src);
1155
1156 static const struct snd_kcontrol_new rt5639_if2_adc_r_mux =
1157         SOC_DAPM_ENUM("IF2 ADC right channel source", rt5639_if2_adc_r_enum);
1158
1159 /* digital interface and iis interface map */
1160 static const char *rt5639_dai_iis_map[] = {"1:1|2:2|3:3", "1:1|2:3|3:2",
1161         "1:3|2:1|3:2", "1:3|2:2|3:1", "1:2|2:3|3:1",
1162         "1:2|2:1|3:3", "1:1|2:1|3:3", "1:2|2:2|3:3"};
1163
1164 static const SOC_ENUM_SINGLE_DECL(
1165         rt5639_dai_iis_map_enum, RT5639_I2S1_SDP,
1166         RT5639_I2S_IF_SFT, rt5639_dai_iis_map);
1167
1168 static const struct snd_kcontrol_new rt5639_dai_mux =
1169         SOC_DAPM_ENUM("DAI select", rt5639_dai_iis_map_enum);
1170
1171 /* SDI select */
1172 static const char *rt5639_sdi_sel[] = {"IF1", "IF2"};
1173
1174 static const SOC_ENUM_SINGLE_DECL(
1175         rt5639_sdi_sel_enum, RT5639_I2S2_SDP,
1176         RT5639_I2S2_SDI_SFT, rt5639_sdi_sel);
1177
1178 static const struct snd_kcontrol_new rt5639_sdi_mux =
1179         SOC_DAPM_ENUM("SDI select", rt5639_sdi_sel_enum);
1180
1181 static int spk_event(struct snd_soc_dapm_widget *w,
1182         struct snd_kcontrol *kcontrol, int event)
1183 {
1184         struct snd_soc_codec *codec = w->codec;
1185
1186         switch (event) {
1187         case SND_SOC_DAPM_POST_PMU:
1188                 printk("spk_event --SND_SOC_DAPM_POST_PMU\n");
1189                 snd_soc_update_bits(codec, RT5639_PWR_DIG1,
1190                         RT5639_PWR_CLS_D, RT5639_PWR_CLS_D);
1191                 rt5639_index_update_bits(codec, 0x1c, 0xf000, 0xf000);
1192                 //rt5639_index_write(codec,0x1c,0xfd21);
1193                 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1194                         RT5639_L_MUTE | RT5639_R_MUTE, 0);
1195                 break;
1196
1197         case SND_SOC_DAPM_PRE_PMD:
1198                 printk("spk_event --SND_SOC_DAPM_POST_PMD\n");
1199                 //rt5639_index_write(codec,0x1c,0xfd00);
1200                 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1201                         RT5639_L_MUTE | RT5639_R_MUTE,
1202                         RT5639_L_MUTE | RT5639_R_MUTE);
1203                 rt5639_index_update_bits(codec, 0x1c, 0xf000, 0x0000);
1204                 snd_soc_update_bits(codec,RT5639_PWR_DIG1,
1205                         RT5639_PWR_CLS_D, 0);
1206                 break;
1207
1208         default:
1209                 return 0;
1210         }
1211
1212         return 0;
1213 }
1214
1215 static int hp_event(struct snd_soc_dapm_widget *w,
1216         struct snd_kcontrol *kcontrol, int event)
1217 {
1218         struct snd_soc_codec *codec = w->codec;
1219
1220         switch (event) {
1221         case SND_SOC_DAPM_POST_PMU:
1222                 printk("hp_event --SND_SOC_DAPM_POST_PMU\n");
1223                 snd_soc_update_bits(codec, RT5639_HP_VOL,
1224                         RT5639_L_MUTE | RT5639_R_MUTE, 0);
1225                 break;
1226
1227         case SND_SOC_DAPM_PRE_PMD:
1228                 printk("hp_event --SND_SOC_DAPM_POST_PMD\n");
1229                 snd_soc_update_bits(codec, RT5639_HP_VOL,
1230                         RT5639_L_MUTE | RT5639_R_MUTE,
1231                         RT5639_L_MUTE | RT5639_R_MUTE);
1232                 break;
1233
1234         default:
1235                 return 0;
1236         }
1237
1238         return 0;
1239 }
1240
1241 static const struct snd_soc_dapm_widget rt5639_dapm_widgets[] = {
1242         SND_SOC_DAPM_SUPPLY("PLL1", RT5639_PWR_ANLG2,
1243                         RT5639_PWR_PLL_BIT, 0, NULL, 0),
1244         /* Input Side */
1245         /* micbias */
1246         SND_SOC_DAPM_SUPPLY("LDO2", RT5639_PWR_ANLG1,
1247                         RT5639_PWR_LDO2_BIT, 0, NULL, 0),
1248         SND_SOC_DAPM_MICBIAS("micbias1", RT5639_PWR_ANLG2,
1249                         RT5639_PWR_MB1_BIT, 0),
1250         SND_SOC_DAPM_MICBIAS("micbias2", RT5639_PWR_ANLG2,
1251                         RT5639_PWR_MB2_BIT, 0),
1252         /* Input Lines */
1253
1254         SND_SOC_DAPM_INPUT("MIC1"),
1255         SND_SOC_DAPM_INPUT("MIC2"),
1256         SND_SOC_DAPM_INPUT("DMIC1"),
1257         SND_SOC_DAPM_INPUT("DMIC2"),
1258
1259         SND_SOC_DAPM_INPUT("IN1P"),
1260         SND_SOC_DAPM_INPUT("IN1N"),
1261         SND_SOC_DAPM_INPUT("IN2P"),
1262         SND_SOC_DAPM_INPUT("IN2N"),
1263         SND_SOC_DAPM_INPUT("DMIC L1"),
1264         SND_SOC_DAPM_INPUT("DMIC R1"),
1265         SND_SOC_DAPM_INPUT("DMIC L2"),
1266         SND_SOC_DAPM_INPUT("DMIC R2"),
1267         SND_SOC_DAPM_SUPPLY("DMIC CLK", SND_SOC_NOPM, 0, 0,
1268                 set_dmic_clk, SND_SOC_DAPM_PRE_PMU),
1269         /* Boost */
1270         SND_SOC_DAPM_PGA("BST1", RT5639_PWR_ANLG2,
1271                 RT5639_PWR_BST1_BIT, 0, NULL, 0),
1272         SND_SOC_DAPM_PGA("BST2", RT5639_PWR_ANLG2,
1273                 RT5639_PWR_BST4_BIT, 0, NULL, 0),
1274         /* Input Volume */
1275         SND_SOC_DAPM_PGA("INL VOL", RT5639_PWR_VOL,
1276                 RT5639_PWR_IN_L_BIT, 0, NULL, 0),
1277         SND_SOC_DAPM_PGA("INR VOL", RT5639_PWR_VOL,
1278                 RT5639_PWR_IN_R_BIT, 0, NULL, 0),
1279         /* IN Mux */
1280         SND_SOC_DAPM_MUX("INL Mux", SND_SOC_NOPM, 0, 0, &rt5639_inl_mux),
1281         SND_SOC_DAPM_MUX("INR Mux", SND_SOC_NOPM, 0, 0, &rt5639_inr_mux),
1282         /* REC Mixer */
1283         SND_SOC_DAPM_MIXER("RECMIXL", RT5639_PWR_MIXER, RT5639_PWR_RM_L_BIT, 0,
1284                         rt5639_rec_l_mix, ARRAY_SIZE(rt5639_rec_l_mix)),
1285         SND_SOC_DAPM_MIXER("RECMIXR", RT5639_PWR_MIXER, RT5639_PWR_RM_R_BIT, 0,
1286                         rt5639_rec_r_mix, ARRAY_SIZE(rt5639_rec_r_mix)),
1287         /* ADCs */
1288         SND_SOC_DAPM_ADC("ADC L", NULL, RT5639_PWR_DIG1,
1289                         RT5639_PWR_ADC_L_BIT, 0),
1290         SND_SOC_DAPM_ADC("ADC R", NULL, RT5639_PWR_DIG1,
1291                         RT5639_PWR_ADC_R_BIT, 0),
1292         /* ADC Mux */
1293         SND_SOC_DAPM_MUX("Stereo ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1294                                 &rt5639_sto_adc_l2_mux),
1295         SND_SOC_DAPM_MUX("Stereo ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1296                                 &rt5639_sto_adc_r2_mux),
1297         SND_SOC_DAPM_MUX("Stereo ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1298                                 &rt5639_sto_adc_l1_mux),
1299         SND_SOC_DAPM_MUX("Stereo ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1300                                 &rt5639_sto_adc_r1_mux),
1301         SND_SOC_DAPM_MUX("Mono ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1302                                 &rt5639_mono_adc_l2_mux),
1303         SND_SOC_DAPM_MUX("Mono ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1304                                 &rt5639_mono_adc_l1_mux),
1305         SND_SOC_DAPM_MUX("Mono ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1306                                 &rt5639_mono_adc_r1_mux),
1307         SND_SOC_DAPM_MUX("Mono ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1308                                 &rt5639_mono_adc_r2_mux),
1309         /* ADC Mixer */
1310         SND_SOC_DAPM_SUPPLY("stereo filter", RT5639_PWR_DIG2,
1311                 RT5639_PWR_ADC_SF_BIT, 0, NULL, 0),
1312         SND_SOC_DAPM_MIXER("Stereo ADC MIXL", SND_SOC_NOPM, 0, 0,
1313                 rt5639_sto_adc_l_mix, ARRAY_SIZE(rt5639_sto_adc_l_mix)),
1314         SND_SOC_DAPM_MIXER("Stereo ADC MIXR", SND_SOC_NOPM, 0, 0,
1315                 rt5639_sto_adc_r_mix, ARRAY_SIZE(rt5639_sto_adc_r_mix)),
1316         SND_SOC_DAPM_SUPPLY("mono left filter", RT5639_PWR_DIG2,
1317                 RT5639_PWR_ADC_MF_L_BIT, 0, NULL, 0),
1318         SND_SOC_DAPM_MIXER("Mono ADC MIXL", SND_SOC_NOPM, 0, 0,
1319                 rt5639_mono_adc_l_mix, ARRAY_SIZE(rt5639_mono_adc_l_mix)),
1320         SND_SOC_DAPM_SUPPLY("mono right filter", RT5639_PWR_DIG2,
1321                 RT5639_PWR_ADC_MF_R_BIT, 0, NULL, 0),
1322         SND_SOC_DAPM_MIXER("Mono ADC MIXR", SND_SOC_NOPM, 0, 0,
1323                 rt5639_mono_adc_r_mix, ARRAY_SIZE(rt5639_mono_adc_r_mix)),
1324
1325         /* IF2 Mux */
1326         SND_SOC_DAPM_MUX("IF2 ADC L Mux", SND_SOC_NOPM, 0, 0,
1327                                 &rt5639_if2_adc_l_mux),
1328         SND_SOC_DAPM_MUX("IF2 ADC R Mux", SND_SOC_NOPM, 0, 0,
1329                                 &rt5639_if2_adc_r_mux),
1330
1331         /* Digital Interface */
1332         SND_SOC_DAPM_SUPPLY("I2S1", RT5639_PWR_DIG1,
1333                 RT5639_PWR_I2S1_BIT, 0, NULL, 0),
1334         SND_SOC_DAPM_PGA("IF1 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1335         SND_SOC_DAPM_PGA("IF1 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1336         SND_SOC_DAPM_PGA("IF1 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1337         SND_SOC_DAPM_PGA("IF1 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1338         SND_SOC_DAPM_PGA("IF1 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1339         SND_SOC_DAPM_PGA("IF1 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1340         SND_SOC_DAPM_SUPPLY("I2S2", RT5639_PWR_DIG1,
1341                 RT5639_PWR_I2S2_BIT, 0, NULL, 0),
1342         SND_SOC_DAPM_PGA("IF2 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1343         SND_SOC_DAPM_PGA("IF2 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1344         SND_SOC_DAPM_PGA("IF2 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1345         SND_SOC_DAPM_PGA("IF2 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1346         SND_SOC_DAPM_PGA("IF2 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1347         SND_SOC_DAPM_PGA("IF2 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1348         SND_SOC_DAPM_SUPPLY("I2S3", RT5639_PWR_DIG1,
1349                 RT5639_PWR_I2S3_BIT, 0, NULL, 0),
1350         SND_SOC_DAPM_PGA("IF3 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1351         SND_SOC_DAPM_PGA("IF3 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1352         SND_SOC_DAPM_PGA("IF3 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1353         SND_SOC_DAPM_PGA("IF3 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1354         SND_SOC_DAPM_PGA("IF3 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1355         SND_SOC_DAPM_PGA("IF3 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1356
1357         /* Digital Interface Select */
1358         SND_SOC_DAPM_MUX("DAI1 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1359         SND_SOC_DAPM_MUX("DAI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1360         SND_SOC_DAPM_MUX("DAI1 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1361         SND_SOC_DAPM_MUX("DAI1 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1362         SND_SOC_DAPM_MUX("SDI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
1363
1364         SND_SOC_DAPM_MUX("DAI2 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1365         SND_SOC_DAPM_MUX("DAI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1366         SND_SOC_DAPM_MUX("DAI2 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1367         SND_SOC_DAPM_MUX("DAI2 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1368         SND_SOC_DAPM_MUX("SDI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
1369
1370         SND_SOC_DAPM_MUX("DAI3 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1371         SND_SOC_DAPM_MUX("DAI3 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1372
1373         /* Audio Interface */
1374         SND_SOC_DAPM_AIF_IN("AIF1RX", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1375         SND_SOC_DAPM_AIF_OUT("AIF1TX", "AIF1 Capture", 0, SND_SOC_NOPM, 0, 0),
1376         SND_SOC_DAPM_AIF_IN("AIF2RX", "AIF2 Playback", 0, SND_SOC_NOPM, 0, 0),
1377         SND_SOC_DAPM_AIF_OUT("AIF2TX", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
1378         SND_SOC_DAPM_AIF_IN("AIF3RX", "AIF3 Playback", 0, SND_SOC_NOPM, 0, 0),
1379         SND_SOC_DAPM_AIF_OUT("AIF3TX", "AIF3 Capture", 0, SND_SOC_NOPM, 0, 0),
1380
1381         /* Audio DSP */
1382         SND_SOC_DAPM_PGA("Audio DSP", SND_SOC_NOPM, 0, 0, NULL, 0),
1383
1384         /* ANC */
1385         SND_SOC_DAPM_PGA("ANC", SND_SOC_NOPM, 0, 0, NULL, 0),
1386
1387         /* Output Side */
1388         /* DAC mixer before sound effect  */
1389         SND_SOC_DAPM_MIXER("DAC MIXL", SND_SOC_NOPM, 0, 0,
1390                 rt5639_dac_l_mix, ARRAY_SIZE(rt5639_dac_l_mix)),
1391         SND_SOC_DAPM_MIXER("DAC MIXR", SND_SOC_NOPM, 0, 0,
1392                 rt5639_dac_r_mix, ARRAY_SIZE(rt5639_dac_r_mix)),
1393
1394         /* DAC2 channel Mux */
1395         SND_SOC_DAPM_MUX("DAC L2 Mux", SND_SOC_NOPM, 0, 0,
1396                                 &rt5639_dac_l2_mux),
1397         SND_SOC_DAPM_MUX("DAC R2 Mux", SND_SOC_NOPM, 0, 0,
1398                                 &rt5639_dac_r2_mux),
1399
1400         /* DAC Mixer */
1401         SND_SOC_DAPM_MIXER("Stereo DAC MIXL", SND_SOC_NOPM, 0, 0,
1402                 rt5639_sto_dac_l_mix, ARRAY_SIZE(rt5639_sto_dac_l_mix)),
1403         SND_SOC_DAPM_MIXER("Stereo DAC MIXR", SND_SOC_NOPM, 0, 0,
1404                 rt5639_sto_dac_r_mix, ARRAY_SIZE(rt5639_sto_dac_r_mix)),
1405         SND_SOC_DAPM_MIXER("Mono DAC MIXL", SND_SOC_NOPM, 0, 0,
1406                 rt5639_mono_dac_l_mix, ARRAY_SIZE(rt5639_mono_dac_l_mix)),
1407         SND_SOC_DAPM_MIXER("Mono DAC MIXR", SND_SOC_NOPM, 0, 0,
1408                 rt5639_mono_dac_r_mix, ARRAY_SIZE(rt5639_mono_dac_r_mix)),
1409         SND_SOC_DAPM_MIXER("DIG MIXL", SND_SOC_NOPM, 0, 0,
1410                 rt5639_dig_l_mix, ARRAY_SIZE(rt5639_dig_l_mix)),
1411         SND_SOC_DAPM_MIXER("DIG MIXR", SND_SOC_NOPM, 0, 0,
1412                 rt5639_dig_r_mix, ARRAY_SIZE(rt5639_dig_r_mix)),
1413         /* DACs */
1414         SND_SOC_DAPM_DAC("DAC L1", NULL, RT5639_PWR_DIG1,
1415                         RT5639_PWR_DAC_L1_BIT, 0),
1416         SND_SOC_DAPM_DAC("DAC L2", NULL, RT5639_PWR_DIG1,
1417                         RT5639_PWR_DAC_L2_BIT, 0),
1418         SND_SOC_DAPM_DAC("DAC R1", NULL, RT5639_PWR_DIG1,
1419                         RT5639_PWR_DAC_R1_BIT, 0),
1420         SND_SOC_DAPM_DAC("DAC R2", NULL, RT5639_PWR_DIG1,
1421                         RT5639_PWR_DAC_R2_BIT, 0),
1422         /* SPK/OUT Mixer */
1423         SND_SOC_DAPM_MIXER("SPK MIXL", RT5639_PWR_MIXER, RT5639_PWR_SM_L_BIT,
1424                 0, rt5639_spk_l_mix, ARRAY_SIZE(rt5639_spk_l_mix)),
1425         SND_SOC_DAPM_MIXER("SPK MIXR", RT5639_PWR_MIXER, RT5639_PWR_SM_R_BIT,
1426                 0, rt5639_spk_r_mix, ARRAY_SIZE(rt5639_spk_r_mix)),
1427         SND_SOC_DAPM_MIXER("OUT MIXL", RT5639_PWR_MIXER, RT5639_PWR_OM_L_BIT,
1428                 0, rt5639_out_l_mix, ARRAY_SIZE(rt5639_out_l_mix)),
1429         SND_SOC_DAPM_MIXER("OUT MIXR", RT5639_PWR_MIXER, RT5639_PWR_OM_R_BIT,
1430                 0, rt5639_out_r_mix, ARRAY_SIZE(rt5639_out_r_mix)),
1431         /* Ouput Volume */
1432         SND_SOC_DAPM_PGA("SPKVOL L", RT5639_PWR_VOL,
1433                 RT5639_PWR_SV_L_BIT, 0, NULL, 0),
1434         SND_SOC_DAPM_PGA("SPKVOL R", RT5639_PWR_VOL,
1435                 RT5639_PWR_SV_R_BIT, 0, NULL, 0),
1436         SND_SOC_DAPM_PGA("OUTVOL L", RT5639_PWR_VOL,
1437                 RT5639_PWR_OV_L_BIT, 0, NULL, 0),
1438         SND_SOC_DAPM_PGA("OUTVOL R", RT5639_PWR_VOL,
1439                 RT5639_PWR_OV_R_BIT, 0, NULL, 0),
1440         SND_SOC_DAPM_PGA("HPOVOL L", RT5639_PWR_VOL,
1441                 RT5639_PWR_HV_L_BIT, 0, NULL, 0),
1442         SND_SOC_DAPM_PGA("HPOVOL R", RT5639_PWR_VOL,
1443                 RT5639_PWR_HV_R_BIT, 0, NULL, 0),
1444         /* SPO/HPO/LOUT/Mono Mixer */
1445         SND_SOC_DAPM_MIXER("SPOL MIX",SND_SOC_NOPM, 0,
1446                 0, rt5639_spo_l_mix, ARRAY_SIZE(rt5639_spo_l_mix)),
1447         SND_SOC_DAPM_MIXER("SPOR MIX", SND_SOC_NOPM, 0,
1448                 0, rt5639_spo_r_mix, ARRAY_SIZE(rt5639_spo_r_mix)),
1449         SND_SOC_DAPM_MIXER("HPOL MIX", SND_SOC_NOPM, 0, 0,
1450                 rt5639_hpo_mix, ARRAY_SIZE(rt5639_hpo_mix)),
1451         SND_SOC_DAPM_MIXER("HPOR MIX", SND_SOC_NOPM, 0, 0,
1452                 rt5639_hpo_mix, ARRAY_SIZE(rt5639_hpo_mix)),
1453         SND_SOC_DAPM_MIXER("LOUT MIX", RT5639_PWR_ANLG1, RT5639_PWR_LM_BIT, 0,
1454                 rt5639_lout_mix, ARRAY_SIZE(rt5639_lout_mix)),
1455         SND_SOC_DAPM_MIXER("Mono MIX", RT5639_PWR_ANLG1, RT5639_PWR_MM_BIT, 0,
1456                 rt5639_mono_mix, ARRAY_SIZE(rt5639_mono_mix)),
1457
1458         SND_SOC_DAPM_SUPPLY("Improve mono amp drv", RT5639_PWR_ANLG1,
1459                 RT5639_PWR_MA_BIT, 0, NULL, 0),
1460
1461         SND_SOC_DAPM_SUPPLY("Improve HP amp drv", RT5639_PWR_ANLG1,
1462                 SND_SOC_NOPM, 0, hp_event,SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1463
1464         SND_SOC_DAPM_PGA("HP L amp", RT5639_PWR_ANLG1,
1465                 RT5639_PWR_HP_L_BIT, 0, NULL, 0),
1466
1467         SND_SOC_DAPM_PGA("HP R amp", RT5639_PWR_ANLG1,
1468                 RT5639_PWR_HP_R_BIT, 0, NULL, 0),
1469
1470         SND_SOC_DAPM_SUPPLY("Improve SPK amp drv", SND_SOC_NOPM, 0, 0,
1471                 spk_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1472
1473         /* Output Lines */
1474         SND_SOC_DAPM_OUTPUT("SPOLP"),
1475         SND_SOC_DAPM_OUTPUT("SPOLN"),
1476         SND_SOC_DAPM_OUTPUT("SPORP"),
1477         SND_SOC_DAPM_OUTPUT("SPORN"),
1478         SND_SOC_DAPM_OUTPUT("HPOL"),
1479         SND_SOC_DAPM_OUTPUT("HPOR"),
1480         SND_SOC_DAPM_OUTPUT("LOUTL"),
1481         SND_SOC_DAPM_OUTPUT("LOUTR"),
1482 };
1483
1484 static const struct snd_soc_dapm_route rt5639_dapm_routes[] = {
1485         {"IN1P", NULL, "LDO2"},
1486         {"IN2P", NULL, "LDO2"},
1487
1488         {"IN1P", NULL, "MIC1"},
1489         {"IN1N", NULL, "MIC1"},
1490         {"IN2P", NULL, "MIC2"},
1491         {"IN2N", NULL, "MIC2"},
1492
1493         {"DMIC L1", NULL, "DMIC1"},
1494         {"DMIC R1", NULL, "DMIC1"},
1495         {"DMIC L2", NULL, "DMIC2"},
1496         {"DMIC R2", NULL, "DMIC2"},
1497
1498         {"BST1", NULL, "IN1P"},
1499         {"BST1", NULL, "IN1N"},
1500         {"BST2", NULL, "IN2P"},
1501         {"BST2", NULL, "IN2N"},
1502
1503         {"INL VOL", NULL, "IN2P"},
1504         {"INR VOL", NULL, "IN2N"},
1505
1506         {"RECMIXL", "HPOL Switch", "HPOL"},
1507         {"RECMIXL", "INL Switch", "INL VOL"},
1508         {"RECMIXL", "BST2 Switch", "BST2"},
1509         {"RECMIXL", "BST1 Switch", "BST1"},
1510         {"RECMIXL", "OUT MIXL Switch", "OUT MIXL"},
1511
1512         {"RECMIXR", "HPOR Switch", "HPOR"},
1513         {"RECMIXR", "INR Switch", "INR VOL"},
1514         {"RECMIXR", "BST2 Switch", "BST2"},
1515         {"RECMIXR", "BST1 Switch", "BST1"},
1516         {"RECMIXR", "OUT MIXR Switch", "OUT MIXR"},
1517
1518         {"ADC L", NULL, "RECMIXL"},
1519         {"ADC R", NULL, "RECMIXR"},
1520
1521         {"DMIC L1", NULL, "DMIC CLK"},
1522         {"DMIC L2", NULL, "DMIC CLK"},
1523
1524         {"Stereo ADC L2 Mux", "DMIC1", "DMIC L1"},
1525         {"Stereo ADC L2 Mux", "DMIC2", "DMIC L2"},
1526         {"Stereo ADC L2 Mux", "DIG MIX", "DIG MIXL"},
1527         {"Stereo ADC L1 Mux", "ADC", "ADC L"},
1528         {"Stereo ADC L1 Mux", "DIG MIX", "DIG MIXL"},
1529
1530         {"Stereo ADC R1 Mux", "ADC", "ADC R"},
1531         {"Stereo ADC R1 Mux", "DIG MIX", "DIG MIXR"},
1532         {"Stereo ADC R2 Mux", "DMIC1", "DMIC R1"},
1533         {"Stereo ADC R2 Mux", "DMIC2", "DMIC R2"},
1534         {"Stereo ADC R2 Mux", "DIG MIX", "DIG MIXR"},
1535
1536         {"Mono ADC L2 Mux", "DMIC L1", "DMIC L1"},
1537         {"Mono ADC L2 Mux", "DMIC L2", "DMIC L2"},
1538         {"Mono ADC L2 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
1539         {"Mono ADC L1 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
1540         {"Mono ADC L1 Mux", "ADCL", "ADC L"},
1541
1542         {"Mono ADC R1 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
1543         {"Mono ADC R1 Mux", "ADCR", "ADC R"},
1544         {"Mono ADC R2 Mux", "DMIC R1", "DMIC R1"},
1545         {"Mono ADC R2 Mux", "DMIC R2", "DMIC R2"},
1546         {"Mono ADC R2 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
1547
1548         {"Stereo ADC MIXL", "ADC1 Switch", "Stereo ADC L1 Mux"},
1549         {"Stereo ADC MIXL", "ADC2 Switch", "Stereo ADC L2 Mux"},
1550         {"Stereo ADC MIXL", NULL, "stereo filter"},
1551         {"stereo filter", NULL, "PLL1", check_sysclk1_source},
1552
1553         {"Stereo ADC MIXR", "ADC1 Switch", "Stereo ADC R1 Mux"},
1554         {"Stereo ADC MIXR", "ADC2 Switch", "Stereo ADC R2 Mux"},
1555         {"Stereo ADC MIXR", NULL, "stereo filter"},
1556         {"stereo filter", NULL, "PLL1", check_sysclk1_source},
1557
1558         {"Mono ADC MIXL", "ADC1 Switch", "Mono ADC L1 Mux"},
1559         {"Mono ADC MIXL", "ADC2 Switch", "Mono ADC L2 Mux"},
1560         {"Mono ADC MIXL", NULL, "mono left filter"},
1561         {"mono left filter", NULL, "PLL1", check_sysclk1_source},
1562
1563         {"Mono ADC MIXR", "ADC1 Switch", "Mono ADC R1 Mux"},
1564         {"Mono ADC MIXR", "ADC2 Switch", "Mono ADC R2 Mux"},
1565         {"Mono ADC MIXR", NULL, "mono right filter"},
1566         {"mono right filter", NULL, "PLL1", check_sysclk1_source},
1567
1568         {"IF2 ADC L Mux", "Mono ADC MIXL", "Mono ADC MIXL"},
1569         {"IF2 ADC R Mux", "Mono ADC MIXR", "Mono ADC MIXR"},
1570
1571         {"IF2 ADC L", NULL, "IF2 ADC L Mux"},
1572         {"IF2 ADC R", NULL, "IF2 ADC R Mux"},
1573         {"IF3 ADC L", NULL, "Mono ADC MIXL"},
1574         {"IF3 ADC R", NULL, "Mono ADC MIXR"},
1575         {"IF1 ADC L", NULL, "Stereo ADC MIXL"},
1576         {"IF1 ADC R", NULL, "Stereo ADC MIXR"},
1577
1578         {"IF1 ADC", NULL, "I2S1"},
1579         {"IF1 ADC", NULL, "IF1 ADC L"},
1580         {"IF1 ADC", NULL, "IF1 ADC R"},
1581         {"IF2 ADC", NULL, "I2S2"},
1582         {"IF2 ADC", NULL, "IF2 ADC L"},
1583         {"IF2 ADC", NULL, "IF2 ADC R"},
1584         {"IF3 ADC", NULL, "I2S3"},
1585         {"IF3 ADC", NULL, "IF3 ADC L"},
1586         {"IF3 ADC", NULL, "IF3 ADC R"},
1587
1588         {"DAI1 TX Mux", "1:1|2:2|3:3", "IF1 ADC"},
1589         {"DAI1 TX Mux", "1:1|2:3|3:2", "IF1 ADC"},
1590         {"DAI1 TX Mux", "1:3|2:1|3:2", "IF2 ADC"},
1591         {"DAI1 TX Mux", "1:2|2:1|3:3", "IF2 ADC"},
1592         {"DAI1 TX Mux", "1:3|2:2|3:1", "IF3 ADC"},
1593         {"DAI1 TX Mux", "1:2|2:3|3:1", "IF3 ADC"},
1594         {"DAI1 IF1 Mux", "1:1|2:1|3:3", "IF1 ADC"},
1595         {"DAI1 IF2 Mux", "1:1|2:1|3:3", "IF2 ADC"},
1596         {"SDI1 TX Mux", "IF1", "DAI1 IF1 Mux"},
1597         {"SDI1 TX Mux", "IF2", "DAI1 IF2 Mux"},
1598
1599         {"DAI2 TX Mux", "1:2|2:3|3:1", "IF1 ADC"},
1600         {"DAI2 TX Mux", "1:2|2:1|3:3", "IF1 ADC"},
1601         {"DAI2 TX Mux", "1:1|2:2|3:3", "IF2 ADC"},
1602         {"DAI2 TX Mux", "1:3|2:2|3:1", "IF2 ADC"},
1603         {"DAI2 TX Mux", "1:1|2:3|3:2", "IF3 ADC"},
1604         {"DAI2 TX Mux", "1:3|2:1|3:2", "IF3 ADC"},
1605         {"DAI2 IF1 Mux", "1:2|2:2|3:3", "IF1 ADC"},
1606         {"DAI2 IF2 Mux", "1:2|2:2|3:3", "IF2 ADC"},
1607         {"SDI2 TX Mux", "IF1", "DAI2 IF1 Mux"},
1608         {"SDI2 TX Mux", "IF2", "DAI2 IF2 Mux"},
1609
1610         {"DAI3 TX Mux", "1:3|2:1|3:2", "IF1 ADC"},
1611         {"DAI3 TX Mux", "1:3|2:2|3:1", "IF1 ADC"},
1612         {"DAI3 TX Mux", "1:1|2:3|3:2", "IF2 ADC"},
1613         {"DAI3 TX Mux", "1:2|2:3|3:1", "IF2 ADC"},
1614         {"DAI3 TX Mux", "1:1|2:2|3:3", "IF3 ADC"},
1615         {"DAI3 TX Mux", "1:2|2:1|3:3", "IF3 ADC"},
1616         {"DAI3 TX Mux", "1:1|2:1|3:3", "IF3 ADC"},
1617         {"DAI3 TX Mux", "1:2|2:2|3:3", "IF3 ADC"},
1618
1619         {"AIF1TX", NULL, "DAI1 TX Mux"},
1620         {"AIF1TX", NULL, "SDI1 TX Mux"},
1621         {"AIF2TX", NULL, "DAI2 TX Mux"},
1622         {"AIF2TX", NULL, "SDI2 TX Mux"},
1623         {"AIF3TX", NULL, "DAI3 TX Mux"},
1624
1625         {"DAI1 RX Mux", "1:1|2:2|3:3", "AIF1RX"},
1626         {"DAI1 RX Mux", "1:1|2:3|3:2", "AIF1RX"},
1627         {"DAI1 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
1628         {"DAI1 RX Mux", "1:2|2:3|3:1", "AIF2RX"},
1629         {"DAI1 RX Mux", "1:2|2:1|3:3", "AIF2RX"},
1630         {"DAI1 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
1631         {"DAI1 RX Mux", "1:3|2:1|3:2", "AIF3RX"},
1632         {"DAI1 RX Mux", "1:3|2:2|3:1", "AIF3RX"},
1633
1634         {"DAI2 RX Mux", "1:3|2:1|3:2", "AIF1RX"},
1635         {"DAI2 RX Mux", "1:2|2:1|3:3", "AIF1RX"},
1636         {"DAI2 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
1637         {"DAI2 RX Mux", "1:1|2:2|3:3", "AIF2RX"},
1638         {"DAI2 RX Mux", "1:3|2:2|3:1", "AIF2RX"},
1639         {"DAI2 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
1640         {"DAI2 RX Mux", "1:1|2:3|3:2", "AIF3RX"},
1641         {"DAI2 RX Mux", "1:2|2:3|3:1", "AIF3RX"},
1642
1643         {"DAI3 RX Mux", "1:3|2:2|3:1", "AIF1RX"},
1644         {"DAI3 RX Mux", "1:2|2:3|3:1", "AIF1RX"},
1645         {"DAI3 RX Mux", "1:1|2:3|3:2", "AIF2RX"},
1646         {"DAI3 RX Mux", "1:3|2:1|3:2", "AIF2RX"},
1647         {"DAI3 RX Mux", "1:1|2:2|3:3", "AIF3RX"},
1648         {"DAI3 RX Mux", "1:2|2:1|3:3", "AIF3RX"},
1649         {"DAI3 RX Mux", "1:1|2:1|3:3", "AIF3RX"},
1650         {"DAI3 RX Mux", "1:2|2:2|3:3", "AIF3RX"},
1651
1652         {"IF1 DAC", NULL, "I2S1"},
1653         {"IF1 DAC", NULL, "DAI1 RX Mux"},
1654         {"IF2 DAC", NULL, "I2S2"},
1655         {"IF2 DAC", NULL, "DAI2 RX Mux"},
1656         {"IF3 DAC", NULL, "I2S3"},
1657         {"IF3 DAC", NULL, "DAI3 RX Mux"},
1658
1659         {"IF1 DAC L", NULL, "IF1 DAC"},
1660         {"IF1 DAC R", NULL, "IF1 DAC"},
1661         {"IF2 DAC L", NULL, "IF2 DAC"},
1662         {"IF2 DAC R", NULL, "IF2 DAC"},
1663         {"IF3 DAC L", NULL, "IF3 DAC"},
1664         {"IF3 DAC R", NULL, "IF3 DAC"},
1665
1666         {"DAC MIXL", "Stereo ADC Switch", "Stereo ADC MIXL"},
1667         {"DAC MIXL", "INF1 Switch", "IF1 DAC L"},
1668         {"DAC MIXR", "Stereo ADC Switch", "Stereo ADC MIXR"},
1669         {"DAC MIXR", "INF1 Switch", "IF1 DAC R"},
1670
1671         {"ANC", NULL, "Stereo ADC MIXL"},
1672         {"ANC", NULL, "Stereo ADC MIXR"},
1673
1674         {"Audio DSP", NULL, "DAC MIXL"},
1675         {"Audio DSP", NULL, "DAC MIXR"},
1676
1677         {"DAC L2 Mux", "IF2", "IF2 DAC L"},
1678         {"DAC L2 Mux", "IF3", "IF3 DAC L"},
1679         {"DAC L2 Mux", "Base L/R", "Audio DSP"},
1680
1681         {"DAC R2 Mux", "IF2", "IF2 DAC R"},
1682         {"DAC R2 Mux", "IF3", "IF3 DAC R"},
1683
1684         {"Stereo DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
1685         {"Stereo DAC MIXL", "DAC L2 Switch", "DAC L2 Mux"},
1686         {"Stereo DAC MIXL", "ANC Switch", "ANC"},
1687         {"Stereo DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
1688         {"Stereo DAC MIXR", "DAC R2 Switch", "DAC R2 Mux"},
1689         {"Stereo DAC MIXR", "ANC Switch", "ANC"},
1690
1691         {"Mono DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
1692         {"Mono DAC MIXL", "DAC L2 Switch", "DAC L2 Mux"},
1693         {"Mono DAC MIXL", "DAC R2 Switch", "DAC R2 Mux"},
1694         {"Mono DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
1695         {"Mono DAC MIXR", "DAC R2 Switch", "DAC R2 Mux"},
1696         {"Mono DAC MIXR", "DAC L2 Switch", "DAC L2 Mux"},
1697
1698         {"DIG MIXL", "DAC L1 Switch", "DAC MIXL"},
1699         {"DIG MIXL", "DAC L2 Switch", "DAC L2 Mux"},
1700         {"DIG MIXR", "DAC R1 Switch", "DAC MIXR"},
1701         {"DIG MIXR", "DAC R2 Switch", "DAC R2 Mux"},
1702
1703         {"DAC L1", NULL, "Stereo DAC MIXL"},
1704         {"DAC L1", NULL, "PLL1", check_sysclk1_source},
1705         {"DAC R1", NULL, "Stereo DAC MIXR"},
1706         {"DAC R1", NULL, "PLL1", check_sysclk1_source},
1707
1708         {"SPK MIXL", "REC MIXL Switch", "RECMIXL"},
1709         {"SPK MIXL", "INL Switch", "INL VOL"},
1710         {"SPK MIXL", "DAC L1 Switch", "DAC L1"},
1711         {"SPK MIXL", "DAC L2 Switch", "DAC L2"},
1712         {"SPK MIXL", "OUT MIXL Switch", "OUT MIXL"},
1713         {"SPK MIXR", "REC MIXR Switch", "RECMIXR"},
1714         {"SPK MIXR", "INR Switch", "INR VOL"},
1715         {"SPK MIXR", "DAC R1 Switch", "DAC R1"},
1716         {"SPK MIXR", "DAC R2 Switch", "DAC R2"},
1717         {"SPK MIXR", "OUT MIXR Switch", "OUT MIXR"},
1718
1719         {"OUT MIXL", "SPK MIXL Switch", "SPK MIXL"},
1720         {"OUT MIXL", "BST1 Switch", "BST1"},
1721         {"OUT MIXL", "INL Switch", "INL VOL"},
1722         {"OUT MIXL", "REC MIXL Switch", "RECMIXL"},
1723         {"OUT MIXL", "DAC R2 Switch", "DAC R2"},
1724         {"OUT MIXL", "DAC L2 Switch", "DAC L2"},
1725         {"OUT MIXL", "DAC L1 Switch", "DAC L1"},
1726
1727         {"OUT MIXR", "SPK MIXR Switch", "SPK MIXR"},
1728         {"OUT MIXR", "BST2 Switch", "BST2"},
1729         {"OUT MIXR", "BST1 Switch", "BST1"},
1730         {"OUT MIXR", "INR Switch", "INR VOL"},
1731         {"OUT MIXR", "REC MIXR Switch", "RECMIXR"},
1732         {"OUT MIXR", "DAC L2 Switch", "DAC L2"},
1733         {"OUT MIXR", "DAC R2 Switch", "DAC R2"},
1734         {"OUT MIXR", "DAC R1 Switch", "DAC R1"},
1735
1736         {"SPKVOL L", NULL, "SPK MIXL"},
1737         {"SPKVOL R", NULL, "SPK MIXR"},
1738         {"HPOVOL L", NULL, "OUT MIXL"},
1739         {"HPOVOL R", NULL, "OUT MIXR"},
1740         {"OUTVOL L", NULL, "OUT MIXL"},
1741         {"OUTVOL R", NULL, "OUT MIXR"},
1742
1743         {"SPOL MIX", "DAC R1 Switch", "DAC R1"},
1744         {"SPOL MIX", "DAC L1 Switch", "DAC L1"},
1745         {"SPOL MIX", "SPKVOL R Switch", "SPKVOL R"},
1746         {"SPOL MIX", "SPKVOL L Switch", "SPKVOL L"},
1747         {"SPOL MIX", "BST1 Switch", "BST1"},
1748         {"SPOR MIX", "DAC R1 Switch", "DAC R1"},
1749         {"SPOR MIX", "SPKVOL R Switch", "SPKVOL R"},
1750         {"SPOR MIX", "BST1 Switch", "BST1"},
1751
1752         {"HPOL MIX", "DAC2 Switch", "DAC L2"},
1753         {"HPOL MIX", "DAC1 Switch", "DAC L1"},
1754         {"HPOL MIX", "HPVOL Switch", "HPOVOL L"},
1755         {"HPOR MIX", "DAC2 Switch", "DAC R2"},
1756         {"HPOR MIX", "DAC1 Switch", "DAC R1"},
1757         {"HPOR MIX", "HPVOL Switch", "HPOVOL R"},
1758
1759         {"LOUT MIX", "DAC L1 Switch", "DAC L1"},
1760         {"LOUT MIX", "DAC R1 Switch", "DAC R1"},
1761         {"LOUT MIX", "OUTVOL L Switch", "OUTVOL L"},
1762         {"LOUT MIX", "OUTVOL R Switch", "OUTVOL R"},
1763
1764         {"Mono MIX", "DAC R2 Switch", "DAC R2"},
1765         {"Mono MIX", "DAC L2 Switch", "DAC L2"},
1766         {"Mono MIX", "OUTVOL R Switch", "OUTVOL R"},
1767         {"Mono MIX", "OUTVOL L Switch", "OUTVOL L"},
1768         {"Mono MIX", "BST1 Switch", "BST1"},
1769
1770         {"SPOLP", NULL, "Improve SPK amp drv"},
1771         {"SPOLN", NULL, "Improve SPK amp drv"},
1772         {"SPORP", NULL, "Improve SPK amp drv"},
1773         {"SPORN", NULL, "Improve SPK amp drv"},
1774         {"SPOLP", NULL, "SPOL MIX"},
1775         {"SPOLN", NULL, "SPOL MIX"},
1776         {"SPORP", NULL, "SPOR MIX"},
1777         {"SPORN", NULL, "SPOR MIX"},
1778
1779         {"HP L amp", NULL, "HPOL MIX"},
1780         {"HP R amp", NULL, "HPOR MIX"},
1781         {"HPOL", NULL, "Improve HP amp drv"},
1782         {"HPOR", NULL, "Improve HP amp drv"},
1783         {"HPOL", NULL, "HP L amp"},
1784         {"HPOR", NULL, "HP R amp"},
1785
1786         {"LOUTL", NULL, "LOUT MIX"},
1787         {"LOUTR", NULL, "LOUT MIX"},
1788 };
1789
1790 static int get_sdp_info(struct snd_soc_codec *codec, int dai_id)
1791 {
1792         int ret = 0, val = snd_soc_read(codec, RT5639_I2S1_SDP);
1793
1794         if(codec == NULL)
1795                 return -EINVAL;
1796
1797         val = (val & RT5639_I2S_IF_MASK) >> RT5639_I2S_IF_SFT;
1798         switch (dai_id) {
1799         case RT5639_AIF1:
1800                 if (val == RT5639_IF_123 || val == RT5639_IF_132 ||
1801                         val == RT5639_IF_113)
1802                         ret |= RT5639_U_IF1;
1803                 if (val == RT5639_IF_312 || val == RT5639_IF_213 ||
1804                         val == RT5639_IF_113)
1805                         ret |= RT5639_U_IF2;
1806                 if (val == RT5639_IF_321 || val == RT5639_IF_231)
1807                         ret |= RT5639_U_IF3;
1808                 break;
1809
1810         case RT5639_AIF2:
1811                 if (val == RT5639_IF_231 || val == RT5639_IF_213 ||
1812                         val == RT5639_IF_223)
1813                         ret |= RT5639_U_IF1;
1814                 if (val == RT5639_IF_123 || val == RT5639_IF_321 ||
1815                         val == RT5639_IF_223)
1816                         ret |= RT5639_U_IF2;
1817                 if (val == RT5639_IF_132 || val == RT5639_IF_312)
1818                         ret |= RT5639_U_IF3;
1819                 break;
1820
1821         default:
1822                 ret = -EINVAL;
1823                 break;
1824         }
1825
1826         return ret;
1827 }
1828
1829 static int get_clk_info(int sclk, int rate)
1830 {
1831         int i, pd[] = {1, 2, 3, 4, 6, 8, 12, 16};
1832
1833         if(sclk <= 0 || rate <= 0)
1834                 return -EINVAL;
1835
1836         rate = rate << 8;
1837         for (i = 0; i < ARRAY_SIZE(pd); i++)
1838                 if (sclk == rate * pd[i])
1839                         return i;
1840
1841         return -EINVAL;
1842 }
1843
1844 static int rt5639_hw_params(struct snd_pcm_substream *substream,
1845         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
1846 {
1847         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1848         struct snd_soc_codec *codec = rtd->codec;
1849         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
1850         unsigned int val_len = 0, val_clk, mask_clk, dai_sel;
1851         int pre_div, bclk_ms, frame_size;
1852
1853         rt5639->lrck[dai->id] = params_rate(params);
1854         pre_div = get_clk_info(rt5639->sysclk, rt5639->lrck[dai->id]);
1855         if (pre_div < 0) {
1856                 dev_err(codec->dev, "Unsupported clock setting\n");
1857                 return -EINVAL;
1858         }
1859         frame_size = snd_soc_params_to_frame_size(params);
1860         if (frame_size < 0) {
1861                 dev_err(codec->dev, "Unsupported frame size: %d\n", frame_size);
1862                 return -EINVAL;
1863         }
1864         bclk_ms = frame_size > 32 ? 1 : 0;
1865         /*Tegra requires 64*fs as bitclk in slave mode*/
1866         bclk_ms = 1;
1867         rt5639->bclk[dai->id] = rt5639->lrck[dai->id] * (32 << bclk_ms);
1868
1869         dev_dbg(dai->dev, "bclk is %dHz and lrck is %dHz\n",
1870                 rt5639->bclk[dai->id], rt5639->lrck[dai->id]);
1871         dev_dbg(dai->dev, "bclk_ms is %d and pre_div is %d for iis %d\n",
1872                                 bclk_ms, pre_div, dai->id);
1873
1874         switch (params_format(params)) {
1875         case SNDRV_PCM_FORMAT_S16_LE:
1876                 break;
1877         case SNDRV_PCM_FORMAT_S20_3LE:
1878                 val_len |= RT5639_I2S_DL_20;
1879                 break;
1880         case SNDRV_PCM_FORMAT_S24_LE:
1881                 val_len |= RT5639_I2S_DL_24;
1882                 break;
1883         case SNDRV_PCM_FORMAT_S8:
1884                 val_len |= RT5639_I2S_DL_8;
1885                 break;
1886         default:
1887                 return -EINVAL;
1888         }
1889
1890         dai_sel = get_sdp_info(codec, dai->id);
1891         if (dai_sel < 0) {
1892                 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
1893                 return -EINVAL;
1894         }
1895         if (dai_sel & RT5639_U_IF1) {
1896                 mask_clk = RT5639_I2S_BCLK_MS1_MASK | RT5639_I2S_PD1_MASK;
1897                 val_clk = bclk_ms << RT5639_I2S_BCLK_MS1_SFT |
1898                         pre_div << RT5639_I2S_PD1_SFT;
1899                 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
1900                         RT5639_I2S_DL_MASK, val_len);
1901                 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
1902         }
1903         if (dai_sel & RT5639_U_IF2) {
1904                 mask_clk = RT5639_I2S_BCLK_MS2_MASK | RT5639_I2S_PD2_MASK;
1905                 val_clk = bclk_ms << RT5639_I2S_BCLK_MS2_SFT |
1906                         pre_div << RT5639_I2S_PD2_SFT;
1907                 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
1908                         RT5639_I2S_DL_MASK, val_len);
1909                 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
1910         }
1911
1912         return 0;
1913 }
1914
1915 static int rt5639_prepare(struct snd_pcm_substream *substream,
1916                                 struct snd_soc_dai *dai)
1917 {
1918         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1919         struct snd_soc_codec *codec = rtd->codec;
1920         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
1921
1922         rt5639->aif_pu = dai->id;
1923         return 0;
1924 }
1925
1926 static int rt5639_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
1927 {
1928         struct snd_soc_codec *codec = dai->codec;
1929         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
1930         unsigned int reg_val = 0, dai_sel;
1931
1932         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1933         case SND_SOC_DAIFMT_CBM_CFM:
1934                 rt5639->master[dai->id] = 1;
1935                 break;
1936         case SND_SOC_DAIFMT_CBS_CFS:
1937                 reg_val |= RT5639_I2S_MS_S;
1938                 rt5639->master[dai->id] = 0;
1939                 break;
1940         default:
1941                 return -EINVAL;
1942         }
1943
1944         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1945         case SND_SOC_DAIFMT_NB_NF:
1946                 break;
1947         case SND_SOC_DAIFMT_IB_NF:
1948                 reg_val |= RT5639_I2S_BP_INV;
1949                 break;
1950         default:
1951                 return -EINVAL;
1952         }
1953
1954         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1955         case SND_SOC_DAIFMT_I2S:
1956                 break;
1957         case SND_SOC_DAIFMT_LEFT_J:
1958                 reg_val |= RT5639_I2S_DF_LEFT;
1959                 break;
1960         case SND_SOC_DAIFMT_DSP_A:
1961                 reg_val |= RT5639_I2S_DF_PCM_A;
1962                 break;
1963         case SND_SOC_DAIFMT_DSP_B:
1964                 reg_val |= RT5639_I2S_DF_PCM_B;
1965                 break;
1966         default:
1967                 return -EINVAL;
1968         }
1969
1970         dai_sel = get_sdp_info(codec, dai->id);
1971         if (dai_sel < 0) {
1972                 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
1973                 return -EINVAL;
1974         }
1975         if (dai_sel & RT5639_U_IF1) {
1976                 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
1977                         RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
1978                         RT5639_I2S_DF_MASK, reg_val);
1979         }
1980         if (dai_sel & RT5639_U_IF2) {
1981                 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
1982                         RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
1983                         RT5639_I2S_DF_MASK, reg_val);
1984         }
1985
1986         return 0;
1987 }
1988
1989 static int rt5639_set_dai_sysclk(struct snd_soc_dai *dai,
1990                 int clk_id, unsigned int freq, int dir)
1991 {
1992         struct snd_soc_codec *codec = dai->codec;
1993         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
1994         unsigned int reg_val = 0;
1995
1996         if (freq == rt5639->sysclk && clk_id == rt5639->sysclk_src)
1997                 return 0;
1998
1999         switch (clk_id) {
2000         case RT5639_SCLK_S_MCLK:
2001                 reg_val |= RT5639_SCLK_SRC_MCLK;
2002                 break;
2003         case RT5639_SCLK_S_PLL1:
2004                 reg_val |= RT5639_SCLK_SRC_PLL1;
2005                 break;
2006         case RT5639_SCLK_S_RCCLK:
2007                 reg_val |= RT5639_SCLK_SRC_RCCLK;
2008                 break;
2009         default:
2010                 dev_err(codec->dev, "Invalid clock id (%d)\n", clk_id);
2011                 return -EINVAL;
2012         }
2013         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2014                 RT5639_SCLK_SRC_MASK, reg_val);
2015         rt5639->sysclk = freq;
2016         rt5639->sysclk_src = clk_id;
2017
2018         dev_dbg(dai->dev, "Sysclk is %dHz and clock id is %d\n", freq, clk_id);
2019
2020         return 0;
2021 }
2022
2023 /**
2024  * rt5639_pll_calc - Calcualte PLL M/N/K code.
2025  * @freq_in: external clock provided to codec.
2026  * @freq_out: target clock which codec works on.
2027  * @pll_code: Pointer to structure with M, N, K and bypass flag.
2028  *
2029  * Calcualte M/N/K code to configure PLL for codec. And K is assigned to 2
2030  * which make calculation more efficiently.
2031  *
2032  * Returns 0 for success or negative error code.
2033  */
2034 static int rt5639_pll_calc(const unsigned int freq_in,
2035         const unsigned int freq_out, struct rt5639_pll_code *pll_code)
2036 {
2037         int max_n = RT5639_PLL_N_MAX, max_m = RT5639_PLL_M_MAX;
2038         int k, n = 0, m = 0, red, n_t, m_t, pll_out, in_t, out_t;
2039         int red_t = abs(freq_out - freq_in);
2040         bool bypass = false;
2041
2042         if (RT5639_PLL_INP_MAX < freq_in || RT5639_PLL_INP_MIN > freq_in)
2043                 return -EINVAL;
2044
2045         k = 100000000 / freq_out - 2;
2046         if (k > RT5639_PLL_K_MAX)
2047                 k = RT5639_PLL_K_MAX;
2048         for (n_t = 0; n_t <= max_n; n_t++) {
2049                 in_t = freq_in / (k + 2);
2050                 pll_out = freq_out / (n_t + 2);
2051                 if (in_t < 0)
2052                         continue;
2053                 if (in_t == pll_out) {
2054                         bypass = true;
2055                         n = n_t;
2056                         goto code_find;
2057                 }
2058                 red = abs(in_t - pll_out);
2059                 if (red < red_t) {
2060                         bypass = true;
2061                         n = n_t;
2062                         m = m_t;
2063                         if (red == 0)
2064                                 goto code_find;
2065                         red_t = red;
2066                 }
2067                 for (m_t = 0; m_t <= max_m; m_t++) {
2068                         out_t = in_t / (m_t + 2);
2069                         red = abs(out_t - pll_out);
2070                         if (red < red_t) {
2071                                 bypass = false;
2072                                 n = n_t;
2073                                 m = m_t;
2074                                 if (red == 0)
2075                                         goto code_find;
2076                                 red_t = red;
2077                         }
2078                 }
2079         }
2080         pr_debug("Only get approximation about PLL\n");
2081
2082 code_find:
2083
2084         pll_code->m_bp = bypass;
2085         pll_code->m_code = m;
2086         pll_code->n_code = n;
2087         pll_code->k_code = k;
2088         return 0;
2089 }
2090
2091 static int rt5639_set_dai_pll(struct snd_soc_dai *dai, int pll_id, int source,
2092                         unsigned int freq_in, unsigned int freq_out)
2093 {
2094         struct snd_soc_codec *codec = dai->codec;
2095         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2096         struct rt5639_pll_code pll_code;
2097         int ret, dai_sel;
2098
2099         if (source == rt5639->pll_src && freq_in == rt5639->pll_in &&
2100             freq_out == rt5639->pll_out)
2101                 return 0;
2102
2103         if (!freq_in || !freq_out) {
2104                 dev_dbg(codec->dev, "PLL disabled\n");
2105
2106                 rt5639->pll_in = 0;
2107                 rt5639->pll_out = 0;
2108                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2109                         RT5639_SCLK_SRC_MASK, RT5639_SCLK_SRC_MCLK);
2110                 return 0;
2111         }
2112
2113         switch (source) {
2114         case RT5639_PLL1_S_MCLK:
2115                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2116                         RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_MCLK);
2117                 break;
2118         case RT5639_PLL1_S_BCLK1:
2119         case RT5639_PLL1_S_BCLK2:
2120                 dai_sel = get_sdp_info(codec, dai->id);
2121                 if (dai_sel < 0) {
2122                         dev_err(codec->dev,
2123                                 "Failed to get sdp info: %d\n", dai_sel);
2124                         return -EINVAL;
2125                 }
2126                 if (dai_sel & RT5639_U_IF1) {
2127                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2128                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK1);
2129                 }
2130                 if (dai_sel & RT5639_U_IF2) {
2131                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2132                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK2);
2133                 }
2134                 if (dai_sel & RT5639_U_IF3) {
2135                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2136                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK3);
2137                 }
2138                 break;
2139         default:
2140                 dev_err(codec->dev, "Unknown PLL source %d\n", source);
2141                 return -EINVAL;
2142         }
2143
2144         ret = rt5639_pll_calc(freq_in, freq_out, &pll_code);
2145         if (ret < 0) {
2146                 dev_err(codec->dev, "Unsupport input clock %d\n", freq_in);
2147                 return ret;
2148         }
2149
2150         dev_dbg(codec->dev, "bypass=%d m=%d n=%d k=%d\n", pll_code.m_bp,
2151                 (pll_code.m_bp ? 0 : pll_code.m_code),
2152                 pll_code.n_code, pll_code.k_code);
2153
2154         snd_soc_write(codec, RT5639_PLL_CTRL1,
2155                 pll_code.n_code << RT5639_PLL_N_SFT | pll_code.k_code);
2156         snd_soc_write(codec, RT5639_PLL_CTRL2,
2157                 (pll_code.m_bp ? 0 : pll_code.m_code) << RT5639_PLL_M_SFT |
2158                 pll_code.m_bp << RT5639_PLL_M_BP_SFT);
2159
2160         rt5639->pll_in = freq_in;
2161         rt5639->pll_out = freq_out;
2162         rt5639->pll_src = source;
2163
2164         return 0;
2165 }
2166
2167 /**
2168  * rt5639_index_show - Dump private registers.
2169  * @dev: codec device.
2170  * @attr: device attribute.
2171  * @buf: buffer for display.
2172  *
2173  * To show non-zero values of all private registers.
2174  *
2175  * Returns buffer length.
2176  */
2177 static ssize_t rt5639_index_show(struct device *dev,
2178         struct device_attribute *attr, char *buf)
2179 {
2180         struct i2c_client *client = to_i2c_client(dev);
2181         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2182         struct snd_soc_codec *codec = rt5639->codec;
2183         unsigned int val;
2184         int cnt = 0, i;
2185
2186         cnt += sprintf(buf, "RT5639 index register\n");
2187         for (i = 0; i < 0xb4; i++) {
2188                 if (cnt + RT5639_REG_DISP_LEN >= PAGE_SIZE)
2189                         break;
2190                 val = rt5639_index_read(codec, i);
2191                 if (!val)
2192                         continue;
2193                 cnt += snprintf(buf + cnt, RT5639_REG_DISP_LEN,
2194                                 "%02x: %04x\n", i, val);
2195         }
2196
2197         if (cnt >= PAGE_SIZE)
2198                 cnt = PAGE_SIZE - 1;
2199
2200         return cnt;
2201 }
2202 static DEVICE_ATTR(index_reg, 0444, rt5639_index_show, NULL);
2203
2204 static int rt5639_set_bias_level(struct snd_soc_codec *codec,
2205                         enum snd_soc_bias_level level)
2206 {
2207         switch (level) {
2208         case SND_SOC_BIAS_ON:
2209                 break;
2210
2211         case SND_SOC_BIAS_PREPARE:
2212 #ifdef RT5639_DEMO
2213                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2214                         RT5639_PWR_VREF1 | RT5639_PWR_MB |
2215                         RT5639_PWR_BG | RT5639_PWR_VREF2,
2216                         RT5639_PWR_VREF1 | RT5639_PWR_MB |
2217                         RT5639_PWR_BG | RT5639_PWR_VREF2);
2218                 msleep(100);
2219
2220                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2221                         RT5639_PWR_FV1 | RT5639_PWR_FV2,
2222                         RT5639_PWR_FV1 | RT5639_PWR_FV2);
2223
2224                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
2225                         RT5639_PWR_MB1 | RT5639_PWR_MB2,
2226                         RT5639_PWR_MB1 | RT5639_PWR_MB2);
2227 #endif
2228                 break;
2229
2230         case SND_SOC_BIAS_STANDBY:
2231 #ifdef RT5639_DEMO
2232                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
2233                         RT5639_PWR_MB1 | RT5639_PWR_MB2,
2234                         0);
2235 #endif
2236                 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
2237                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2238                                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2239                                 RT5639_PWR_BG | RT5639_PWR_VREF2,
2240                                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2241                                 RT5639_PWR_BG | RT5639_PWR_VREF2);
2242                         msleep(10);
2243                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2244                                 RT5639_PWR_FV1 | RT5639_PWR_FV2,
2245                                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
2246                         codec->cache_only = false;
2247                         codec->cache_sync = 1;
2248                         snd_soc_cache_sync(codec);
2249                         rt5639_index_sync(codec);
2250                 }
2251                 break;
2252
2253         case SND_SOC_BIAS_OFF:
2254 #ifdef RT5639_DEMO
2255                 snd_soc_update_bits(codec, RT5639_OUTPUT,
2256                         RT5639_L_MUTE | RT5639_R_MUTE, RT5639_L_MUTE | RT5639_R_MUTE);
2257                 snd_soc_update_bits(codec, RT5639_MONO_OUT,
2258                         RT5639_L_MUTE, RT5639_L_MUTE);
2259 #endif
2260                 snd_soc_write(codec, RT5639_PWR_DIG1, 0x0000);
2261                 snd_soc_write(codec, RT5639_PWR_DIG2, 0x0000);
2262                 snd_soc_write(codec, RT5639_PWR_VOL, 0x0000);
2263                 snd_soc_write(codec, RT5639_PWR_MIXER, 0x0000);
2264                 snd_soc_write(codec, RT5639_PWR_ANLG1, 0x0000);
2265                 snd_soc_write(codec, RT5639_PWR_ANLG2, 0x0000);
2266                 break;
2267
2268         default:
2269                 break;
2270         }
2271         codec->dapm.bias_level = level;
2272
2273         return 0;
2274 }
2275
2276 static int rt5639_probe(struct snd_soc_codec *codec)
2277 {
2278         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2279         int ret;
2280
2281         codec->dapm.idle_bias_off = 1;
2282
2283         ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
2284         if (ret != 0) {
2285                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
2286                 return ret;
2287         }
2288
2289         ret = rt5639_reset(codec);
2290         if (ret < 0)
2291                 return -ENODEV;
2292
2293         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2294                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2295                 RT5639_PWR_BG | RT5639_PWR_VREF2,
2296                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2297                 RT5639_PWR_BG | RT5639_PWR_VREF2);
2298         msleep(100);
2299         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2300                 RT5639_PWR_FV1 | RT5639_PWR_FV2,
2301                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
2302         /* DMIC */
2303         if (rt5639->dmic_en == RT5639_DMIC1) {
2304                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
2305                         RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
2306                 snd_soc_update_bits(codec, RT5639_DMIC,
2307                         RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK,
2308                         RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING);
2309         } else if (rt5639->dmic_en == RT5639_DMIC2) {
2310                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
2311                         RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
2312                 snd_soc_update_bits(codec, RT5639_DMIC,
2313                         RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK,
2314                         RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING);
2315         }
2316
2317 #ifdef RT5639_DEMO
2318         rt5639_reg_init(codec);
2319 #endif
2320
2321         codec->dapm.bias_level = SND_SOC_BIAS_STANDBY;
2322
2323         snd_soc_add_codec_controls(codec, rt5639_snd_controls,
2324                 ARRAY_SIZE(rt5639_snd_controls));
2325
2326         rt5639->codec = codec;
2327         ret = device_create_file(codec->dev, &dev_attr_index_reg);
2328         if (ret != 0) {
2329                 dev_err(codec->dev,
2330                         "Failed to create index_reg sysfs files: %d\n", ret);
2331                 return ret;
2332         }
2333
2334         return 0;
2335 }
2336
2337 static int rt5639_remove(struct snd_soc_codec *codec)
2338 {
2339         rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
2340         return 0;
2341 }
2342
2343 #ifdef CONFIG_PM
2344 static int rt5639_suspend(struct snd_soc_codec *codec)
2345 {
2346         rt5639_reset(codec);
2347         rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
2348         return 0;
2349 }
2350
2351 static int rt5639_resume(struct snd_soc_codec *codec)
2352 {
2353         int ret = 0 ;
2354
2355         codec->cache_sync = 1;
2356         ret = snd_soc_cache_sync(codec);
2357         if (ret) {
2358                 dev_err(codec->dev,"Failed to sync cache: %d\n", ret);
2359                 return ret;
2360         }
2361         rt5639_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2362
2363         return 0;
2364 }
2365 #else
2366 #define rt5639_suspend NULL
2367 #define rt5639_resume NULL
2368 #endif
2369
2370 #define RT5639_STEREO_RATES SNDRV_PCM_RATE_8000_96000
2371 #define RT5639_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
2372                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
2373
2374 struct snd_soc_dai_ops rt5639_aif_dai_ops = {
2375         .hw_params = rt5639_hw_params,
2376         .prepare = rt5639_prepare,
2377         .set_fmt = rt5639_set_dai_fmt,
2378         .set_sysclk = rt5639_set_dai_sysclk,
2379         .set_pll = rt5639_set_dai_pll,
2380 };
2381
2382 struct snd_soc_dai_driver rt5639_dai[] = {
2383         {
2384                 .name = "rt5639-aif1",
2385                 .id = RT5639_AIF1,
2386                 .playback = {
2387                         .stream_name = "AIF1 Playback",
2388                         .channels_min = 1,
2389                         .channels_max = 2,
2390                         .rates = RT5639_STEREO_RATES,
2391                         .formats = RT5639_FORMATS,
2392                 },
2393                 .capture = {
2394                         .stream_name = "AIF1 Capture",
2395                         .channels_min = 1,
2396                         .channels_max = 2,
2397                         .rates = RT5639_STEREO_RATES,
2398                         .formats = RT5639_FORMATS,
2399                 },
2400                 .ops = &rt5639_aif_dai_ops,
2401         },
2402         {
2403                 .name = "rt5639-aif2",
2404                 .id = RT5639_AIF2,
2405                 .playback = {
2406                         .stream_name = "AIF2 Playback",
2407                         .channels_min = 1,
2408                         .channels_max = 2,
2409                         .rates = RT5639_STEREO_RATES,
2410                         .formats = RT5639_FORMATS,
2411                 },
2412                 .capture = {
2413                         .stream_name = "AIF2 Capture",
2414                         .channels_min = 1,
2415                         .channels_max = 2,
2416                         .rates = RT5639_STEREO_RATES,
2417                         .formats = RT5639_FORMATS,
2418                 },
2419                 .ops = &rt5639_aif_dai_ops,
2420         },
2421 };
2422
2423 static struct snd_soc_codec_driver soc_codec_dev_rt5639 = {
2424         .probe = rt5639_probe,
2425         .remove = rt5639_remove,
2426         .suspend = rt5639_suspend,
2427         .resume = rt5639_resume,
2428         .set_bias_level = rt5639_set_bias_level,
2429         .reg_cache_size = RT5639_VENDOR_ID2 + 1,
2430         .reg_word_size = sizeof(u16),
2431         .reg_cache_default = rt5639_reg,
2432         .volatile_register = rt5639_volatile_register,
2433         .readable_register = rt5639_readable_register,
2434         .reg_cache_step = 1,
2435         .dapm_widgets = rt5639_dapm_widgets,
2436         .num_dapm_widgets = ARRAY_SIZE(rt5639_dapm_widgets),
2437         .dapm_routes = rt5639_dapm_routes,
2438         .num_dapm_routes = ARRAY_SIZE(rt5639_dapm_routes),
2439 };
2440
2441 static const struct i2c_device_id rt5639_i2c_id[] = {
2442         { "rt5639", 0 },
2443         { }
2444 };
2445 MODULE_DEVICE_TABLE(i2c, rt5639_i2c_id);
2446
2447 static int rt5639_i2c_probe(struct i2c_client *i2c,
2448                     const struct i2c_device_id *id)
2449 {
2450         struct rt5639_priv *rt5639;
2451         int ret;
2452
2453         rt5639 = kzalloc(sizeof(struct rt5639_priv), GFP_KERNEL);
2454         if (NULL == rt5639)
2455                 return -ENOMEM;
2456
2457         i2c_set_clientdata(i2c, rt5639);
2458
2459         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_rt5639,
2460                         rt5639_dai, ARRAY_SIZE(rt5639_dai));
2461         if (ret < 0)
2462                 kfree(rt5639);
2463
2464         return ret;
2465 }
2466
2467 static int rt5639_i2c_remove(struct i2c_client *i2c)
2468 {
2469         snd_soc_unregister_codec(&i2c->dev);
2470         kfree(i2c_get_clientdata(i2c));
2471         return 0;
2472 }
2473
2474 static const struct of_device_id rt5639_of_match[] = {
2475         { .compatible = "realtek,rt5639", },
2476         {},
2477 };
2478
2479 struct i2c_driver rt5639_i2c_driver = {
2480         .driver = {
2481                 .name = "rt5639",
2482                 .owner = THIS_MODULE,
2483                 .of_match_table = rt5639_of_match,
2484         },
2485         .probe = rt5639_i2c_probe,
2486         .remove   = rt5639_i2c_remove,
2487         .id_table = rt5639_i2c_id,
2488 };
2489
2490 static int __init rt5639_modinit(void)
2491 {
2492         return i2c_add_driver(&rt5639_i2c_driver);
2493 }
2494 module_init(rt5639_modinit);
2495
2496 static void __exit rt5639_modexit(void)
2497 {
2498         i2c_del_driver(&rt5639_i2c_driver);
2499 }
2500 module_exit(rt5639_modexit);
2501
2502 MODULE_DESCRIPTION("ASoC RT5639 driver");
2503 MODULE_AUTHOR("Johnny Hsu <johnnyhsu@realtek.com>");
2504 MODULE_LICENSE("GPL");