asoc; tegra: Increase Realtek speaker gain.
[linux-2.6.git] / sound / soc / codecs / rt5639.c
1 /*
2  * rt5639.c  --  RT5639 ALSA SoC audio codec driver
3  *
4  * Copyright (c) 2011-2013 REALTEK SEMICONDUCTOR CORP. All rights reserved.
5  * Author: Johnny Hsu <johnnyhsu@realtek.com>
6  *
7  * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/delay.h>
18 #include <linux/pm.h>
19 #include <linux/i2c.h>
20 #include <linux/platform_device.h>
21 #include <linux/spi/spi.h>
22 #include <sound/core.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/soc.h>
26 #include <sound/soc-dapm.h>
27 #include <sound/initval.h>
28 #include <sound/tlv.h>
29
30 #define RTK_IOCTL
31 #ifdef RTK_IOCTL
32 #if defined(CONFIG_SND_HWDEP) || defined(CONFIG_SND_HWDEP_MODULE)
33 #include "rt56xx_ioctl.h"
34 #include "rt5639_ioctl.h"
35 #endif
36 #endif
37
38 #include "rt5639.h"
39
40 #define RT5639_REG_RW 0 /* for debug */
41 #define RT5639_DET_EXT_MIC 0
42 #define USE_ONEBIT_DEPOP 1 /* for one bit depop */
43 /* #define USE_EQ */
44 #define VERSION "0.8.5 alsa 1.0.24"
45
46 struct rt5639_init_reg {
47         u8 reg;
48         u16 val;
49 };
50
51 static struct rt5639_init_reg init_list[] = {
52         {RT5639_GEN_CTRL1       , 0x3f01},/* fa[12:13] = 1'b;
53                                              fa[8~11]=1; fa[0]=1 */
54         {RT5639_ADDA_CLK1       , 0x1114},/* 73[2] = 1'b */
55         {RT5639_MICBIAS         , 0x3030},/* 93[5:4] = 11'b */
56         {RT5639_CLS_D_OUT       , 0xa000},/* 8d[11] = 0'b */
57         {RT5639_CLS_D_OVCD      , 0x0334},/* 8c[8] = 1'b */
58         {RT5639_PRIV_INDEX      , 0x001d},/* PR1d[8] = 1'b; */
59         {RT5639_PRIV_DATA       , 0x0347},
60         {RT5639_PRIV_INDEX      , 0x003d},/* PR3d[12] = 0'b; PR3d[9] = 1'b */
61         {RT5639_PRIV_DATA       , 0x2600},
62         {RT5639_PRIV_INDEX      , 0x0012},/* PR12 = 0aa8'h */
63         {RT5639_PRIV_DATA       , 0x0aa8},
64         {RT5639_PRIV_INDEX      , 0x0014},/* PR14 = 8aaa'h */
65         {RT5639_PRIV_DATA       , 0x8aaa},
66         {RT5639_PRIV_INDEX      , 0x0020},/* PR20 = 6115'h */
67         {RT5639_PRIV_DATA       , 0x6115},
68         {RT5639_PRIV_INDEX      , 0x0023},/* PR23 = 0804'h */
69         {RT5639_PRIV_DATA       , 0x0804},
70         {RT5639_PRIV_INDEX      , 0x0015},/* PR15 = ab00'h */
71         {RT5639_PRIV_DATA       , 0xab00},
72         /*playback*/
73         {RT5639_STO_DAC_MIXER   , 0x1414},/* Dig inf 1 -> Sto
74                                              DAC mixer -> DACL */
75         {RT5639_OUT_L3_MIXER    , 0x01fe},/* DACL1 -> OUTMIXL */
76         {RT5639_OUT_R3_MIXER    , 0x01fe},/* DACR1 -> OUTMIXR */
77         {RT5639_HP_VOL          , 0x8888},/* OUTMIX -> HPVOL */
78         {RT5639_HPO_MIXER       , 0xc000},/* HPVOL -> HPOLMIX */
79         /*{RT5639_HPO_MIXER     , 0xa000},*//* DAC1 -> HPOLMIX */
80         /*{RT5639_CHARGE_PUMP   , 0x0f00},*/
81         {RT5639_PRIV_INDEX      , 0x0090},
82         {RT5639_PRIV_DATA       , 0x2000},
83         {RT5639_PRIV_INDEX      , 0x0091},
84         {RT5639_PRIV_DATA       , 0x1000},
85         /*{RT5639_HP_CALIB_AMP_DET, 0x0420}*/
86         {RT5639_SPK_L_MIXER     , 0x0036},/* DACL1 -> SPKMIXL */
87         {RT5639_SPK_R_MIXER     , 0x0036},/* DACR1 -> SPKMIXR */
88         {RT5639_SPK_VOL         , 0x8b8b},/* SPKMIX -> SPKVOL */
89         {RT5639_SPO_CLSD_RATIO  , 0x0004},
90         {RT5639_SPO_L_MIXER     , 0xe800},/* SPKVOLL -> SPOLMIX */
91         {RT5639_SPO_R_MIXER     , 0x2800},/* SPKVOLR -> SPORMIX */
92         /*{RT5639_SPO_L_MIXER   , 0xb800},*//* DAC -> SPOLMIX */
93         /*{RT5639_SPO_R_MIXER   , 0x1800},*//* DAC -> SPORMIX */
94         /*{RT5639_I2S1_SDP      , 0xD000},*//* change IIS1 and IIS2 */
95         /*record*/
96         {RT5639_IN1_IN2         , 0x5080},/* IN1 boost 40db and
97                                              differential mode */
98         {RT5639_IN3_IN4         , 0x0500},/* IN2 boost 40db and
99                                              signal ended mode */
100         {RT5639_REC_L2_MIXER    , 0x007d},/* Mic1 -> RECMIXL */
101         {RT5639_REC_R2_MIXER    , 0x007d},/* Mic1 -> RECMIXR */
102         /*{RT5639_REC_L2_MIXER  , 0x006f},*//* Mic2 -> RECMIXL */
103         /*{RT5639_REC_R2_MIXER  , 0x006f},*//* Mic2 -> RECMIXR */
104         {RT5639_STO_ADC_MIXER   , 0x3020},/* ADC -> Sto ADC mixer */
105 #if RT5639_DET_EXT_MIC
106         {RT5639_MICBIAS         , 0x3800},/* enable MICBIAS short current */
107         {RT5639_GPIO_CTRL1      , 0x8400},/* set GPIO1 to IRQ */
108         {RT5639_GPIO_CTRL3      , 0x0004},/* set GPIO1 output */
109         {RT5639_IRQ_CTRL2       , 0x8000},/*set MICBIAS short current to IRQ */
110                                         /*( if sticky set regBE : 8800 ) */
111 #endif
112         {RT5639_JD_CTRL         , 0x6000},/* JD2 as jack detection source */
113 };
114 #define RT5639_INIT_REG_LEN ARRAY_SIZE(init_list)
115
116 static int rt5639_reg_init(struct snd_soc_codec *codec)
117 {
118         int i;
119
120         for (i = 0; i < RT5639_INIT_REG_LEN; i++)
121                 snd_soc_write(codec, init_list[i].reg, init_list[i].val);
122
123         return 0;
124 }
125
126 static int rt5639_index_sync(struct snd_soc_codec *codec)
127 {
128         int i;
129
130         for (i = 0; i < RT5639_INIT_REG_LEN; i++)
131                 if (RT5639_PRIV_INDEX == init_list[i].reg ||
132                         RT5639_PRIV_DATA == init_list[i].reg)
133                         snd_soc_write(codec, init_list[i].reg,
134                                         init_list[i].val);
135         return 0;
136 }
137
138 static const u16 rt5639_reg[RT5639_VENDOR_ID2 + 1] = {
139         [RT5639_RESET] = 0x000c,
140         [RT5639_SPK_VOL] = 0xc8c8,
141         [RT5639_HP_VOL] = 0xc8c8,
142         [RT5639_OUTPUT] = 0xc8c8,
143         [RT5639_MONO_OUT] = 0x8000,
144         [RT5639_INL_INR_VOL] = 0x0808,
145         [RT5639_DAC1_DIG_VOL] = 0xafaf,
146         [RT5639_DAC2_DIG_VOL] = 0xafaf,
147         [RT5639_ADC_DIG_VOL] = 0x2f2f,
148         [RT5639_ADC_DATA] = 0x2f2f,
149         [RT5639_STO_ADC_MIXER] = 0x7060,
150         [RT5639_MONO_ADC_MIXER] = 0x7070,
151         [RT5639_AD_DA_MIXER] = 0x8080,
152         [RT5639_STO_DAC_MIXER] = 0x5454,
153         [RT5639_MONO_DAC_MIXER] = 0x5454,
154         [RT5639_DIG_MIXER] = 0xaa00,
155         [RT5639_DSP_PATH2] = 0xa000,
156         [RT5639_REC_L2_MIXER] = 0x007f,
157         [RT5639_REC_R2_MIXER] = 0x007f,
158         [RT5639_HPO_MIXER] = 0xe000,
159         [RT5639_SPK_L_MIXER] = 0x003e,
160         [RT5639_SPK_R_MIXER] = 0x003e,
161         [RT5639_SPO_L_MIXER] = 0xf800,
162         [RT5639_SPO_R_MIXER] = 0x3800,
163         [RT5639_SPO_CLSD_RATIO] = 0x0004,
164         [RT5639_MONO_MIXER] = 0xfc00,
165         [RT5639_OUT_L3_MIXER] = 0x01ff,
166         [RT5639_OUT_R3_MIXER] = 0x01ff,
167         [RT5639_LOUT_MIXER] = 0xf000,
168         [RT5639_PWR_ANLG1] = 0x00c0,
169         [RT5639_I2S1_SDP] = 0x8000,
170         [RT5639_I2S2_SDP] = 0x8000,
171         [RT5639_I2S3_SDP] = 0x8000,
172         [RT5639_ADDA_CLK1] = 0x1110,
173         [RT5639_ADDA_CLK2] = 0x0c00,
174         [RT5639_DMIC] = 0x1d00,
175         [RT5639_ASRC_3] = 0x0008,
176         [RT5639_HP_OVCD] = 0x0600,
177         [RT5639_CLS_D_OVCD] = 0x0228,
178         [RT5639_CLS_D_OUT] = 0xa800,
179         [RT5639_DEPOP_M1] = 0x0004,
180         [RT5639_DEPOP_M2] = 0x1100,
181         [RT5639_DEPOP_M3] = 0x0646,
182         [RT5639_CHARGE_PUMP] = 0x0c00,
183         [RT5639_MICBIAS] = 0x3000,
184         [RT5639_EQ_CTRL1] = 0x2080,
185         [RT5639_DRC_AGC_1] = 0x2206,
186         [RT5639_DRC_AGC_2] = 0x1f00,
187         [RT5639_ANC_CTRL1] = 0x034b,
188         [RT5639_ANC_CTRL2] = 0x0066,
189         [RT5639_ANC_CTRL3] = 0x000b,
190         [RT5639_GPIO_CTRL1] = 0x0400,
191         [RT5639_DSP_CTRL3] = 0x2000,
192         [RT5639_BASE_BACK] = 0x0013,
193         [RT5639_MP3_PLUS1] = 0x0680,
194         [RT5639_MP3_PLUS2] = 0x1c17,
195         [RT5639_3D_HP] = 0x8c00,
196         [RT5639_ADJ_HPF] = 0xaa20,
197         [RT5639_HP_CALIB_AMP_DET] = 0x0400,
198         [RT5639_SV_ZCD1] = 0x0809,
199         [RT5639_VENDOR_ID1] = 0x10ec,
200         [RT5639_VENDOR_ID2] = 0x6231,
201         /* [RT5639_PV_DET_SPK_G] = 0xc000, */
202 };
203
204 static int rt5639_reset(struct snd_soc_codec *codec)
205 {
206         return snd_soc_write(codec, RT5639_RESET, 0);
207 }
208
209 /**
210  * rt5639_index_write - Write private register.
211  * @codec: SoC audio codec device.
212  * @reg: Private register index.
213  * @value: Private register Data.
214  *
215  * Modify private register for advanced setting. It can be written through
216  * private index (0x6a) and data (0x6c) register.
217  *
218  * Returns 0 for success or negative error code.
219  */
220 static int rt5639_index_write(struct snd_soc_codec *codec,
221                 unsigned int reg, unsigned int value)
222 {
223         int ret;
224
225         ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
226         if (ret < 0) {
227                 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
228                 goto err;
229         }
230         ret = snd_soc_write(codec, RT5639_PRIV_DATA, value);
231         if (ret < 0) {
232                 dev_err(codec->dev, "Failed to set private value: %d\n", ret);
233                 goto err;
234         }
235         return 0;
236
237 err:
238         return ret;
239 }
240
241 /**
242  * rt5639_index_read - Read private register.
243  * @codec: SoC audio codec device.
244  * @reg: Private register index.
245  *
246  * Read advanced setting from private register. It can be read through
247  * private index (0x6a) and data (0x6c) register.
248  *
249  * Returns private register value or negative error code.
250  */
251 static unsigned int rt5639_index_read(
252         struct snd_soc_codec *codec, unsigned int reg)
253 {
254         int ret;
255
256         ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
257         if (ret < 0) {
258                 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
259                 return ret;
260         }
261         return snd_soc_read(codec, RT5639_PRIV_DATA);
262 }
263
264 /**
265  * rt5639_index_update_bits - update private register bits
266  * @codec: audio codec
267  * @reg: Private register index.
268  * @mask: register mask
269  * @value: new value
270  *
271  * Writes new register value.
272  *
273  * Returns 1 for change, 0 for no change, or negative error code.
274  */
275 static int rt5639_index_update_bits(struct snd_soc_codec *codec,
276         unsigned int reg, unsigned int mask, unsigned int value)
277 {
278         unsigned int old, new;
279         int change, ret;
280
281         ret = rt5639_index_read(codec, reg);
282         if (ret < 0) {
283                 dev_err(codec->dev, "Failed to read private reg: %d\n", ret);
284                 goto err;
285         }
286
287         old = ret;
288         new = (old & ~mask) | (value & mask);
289         change = old != new;
290         if (change) {
291                 ret = rt5639_index_write(codec, reg, new);
292                 if (ret < 0) {
293                         dev_err(codec->dev,
294                                 "Failed to write private reg: %d\n", ret);
295                         goto err;
296                 }
297         }
298         return change;
299
300 err:
301         return ret;
302 }
303
304 static int rt5639_volatile_register(
305         struct snd_soc_codec *codec, unsigned int reg)
306 {
307         switch (reg) {
308         case RT5639_RESET:
309         case RT5639_PRIV_DATA:
310         case RT5639_ASRC_5:
311         case RT5639_EQ_CTRL1:
312         case RT5639_DRC_AGC_1:
313         case RT5639_ANC_CTRL1:
314         case RT5639_IRQ_CTRL2:
315         case RT5639_INT_IRQ_ST:
316         case RT5639_DSP_CTRL2:
317         case RT5639_DSP_CTRL3:
318         case RT5639_PGM_REG_ARR1:
319         case RT5639_PGM_REG_ARR3:
320         case RT5639_VENDOR_ID:
321         case RT5639_VENDOR_ID1:
322         case RT5639_VENDOR_ID2:
323                 return 1;
324         default:
325                 return 0;
326         }
327 }
328
329 static int rt5639_readable_register(
330         struct snd_soc_codec *codec, unsigned int reg)
331 {
332         switch (reg) {
333         case RT5639_RESET:
334         case RT5639_SPK_VOL:
335         case RT5639_HP_VOL:
336         case RT5639_OUTPUT:
337         case RT5639_MONO_OUT:
338         case RT5639_IN1_IN2:
339         case RT5639_IN3_IN4:
340         case RT5639_INL_INR_VOL:
341         case RT5639_DAC1_DIG_VOL:
342         case RT5639_DAC2_DIG_VOL:
343         case RT5639_DAC2_CTRL:
344         case RT5639_ADC_DIG_VOL:
345         case RT5639_ADC_DATA:
346         case RT5639_ADC_BST_VOL:
347         case RT5639_STO_ADC_MIXER:
348         case RT5639_MONO_ADC_MIXER:
349         case RT5639_AD_DA_MIXER:
350         case RT5639_STO_DAC_MIXER:
351         case RT5639_MONO_DAC_MIXER:
352         case RT5639_DIG_MIXER:
353         case RT5639_DSP_PATH1:
354         case RT5639_DSP_PATH2:
355         case RT5639_DIG_INF_DATA:
356         case RT5639_REC_L1_MIXER:
357         case RT5639_REC_L2_MIXER:
358         case RT5639_REC_R1_MIXER:
359         case RT5639_REC_R2_MIXER:
360         case RT5639_HPO_MIXER:
361         case RT5639_SPK_L_MIXER:
362         case RT5639_SPK_R_MIXER:
363         case RT5639_SPO_L_MIXER:
364         case RT5639_SPO_R_MIXER:
365         case RT5639_SPO_CLSD_RATIO:
366         case RT5639_MONO_MIXER:
367         case RT5639_OUT_L1_MIXER:
368         case RT5639_OUT_L2_MIXER:
369         case RT5639_OUT_L3_MIXER:
370         case RT5639_OUT_R1_MIXER:
371         case RT5639_OUT_R2_MIXER:
372         case RT5639_OUT_R3_MIXER:
373         case RT5639_LOUT_MIXER:
374         case RT5639_PWR_DIG1:
375         case RT5639_PWR_DIG2:
376         case RT5639_PWR_ANLG1:
377         case RT5639_PWR_ANLG2:
378         case RT5639_PWR_MIXER:
379         case RT5639_PWR_VOL:
380         case RT5639_PRIV_INDEX:
381         case RT5639_PRIV_DATA:
382         case RT5639_I2S1_SDP:
383         case RT5639_I2S2_SDP:
384         case RT5639_I2S3_SDP:
385         case RT5639_ADDA_CLK1:
386         case RT5639_ADDA_CLK2:
387         case RT5639_DMIC:
388         case RT5639_GLB_CLK:
389         case RT5639_PLL_CTRL1:
390         case RT5639_PLL_CTRL2:
391         case RT5639_ASRC_1:
392         case RT5639_ASRC_2:
393         case RT5639_ASRC_3:
394         case RT5639_ASRC_4:
395         case RT5639_ASRC_5:
396         case RT5639_HP_OVCD:
397         case RT5639_CLS_D_OVCD:
398         case RT5639_CLS_D_OUT:
399         case RT5639_DEPOP_M1:
400         case RT5639_DEPOP_M2:
401         case RT5639_DEPOP_M3:
402         case RT5639_CHARGE_PUMP:
403         case RT5639_PV_DET_SPK_G:
404         case RT5639_MICBIAS:
405         case RT5639_EQ_CTRL1:
406         case RT5639_EQ_CTRL2:
407         case RT5639_WIND_FILTER:
408         case RT5639_DRC_AGC_1:
409         case RT5639_DRC_AGC_2:
410         case RT5639_DRC_AGC_3:
411         case RT5639_SVOL_ZC:
412         case RT5639_ANC_CTRL1:
413         case RT5639_ANC_CTRL2:
414         case RT5639_ANC_CTRL3:
415         case RT5639_JD_CTRL:
416         case RT5639_ANC_JD:
417         case RT5639_IRQ_CTRL1:
418         case RT5639_IRQ_CTRL2:
419         case RT5639_INT_IRQ_ST:
420         case RT5639_GPIO_CTRL1:
421         case RT5639_GPIO_CTRL2:
422         case RT5639_GPIO_CTRL3:
423         case RT5639_DSP_CTRL1:
424         case RT5639_DSP_CTRL2:
425         case RT5639_DSP_CTRL3:
426         case RT5639_DSP_CTRL4:
427         case RT5639_PGM_REG_ARR1:
428         case RT5639_PGM_REG_ARR2:
429         case RT5639_PGM_REG_ARR3:
430         case RT5639_PGM_REG_ARR4:
431         case RT5639_PGM_REG_ARR5:
432         case RT5639_SCB_FUNC:
433         case RT5639_SCB_CTRL:
434         case RT5639_BASE_BACK:
435         case RT5639_MP3_PLUS1:
436         case RT5639_MP3_PLUS2:
437         case RT5639_3D_HP:
438         case RT5639_ADJ_HPF:
439         case RT5639_HP_CALIB_AMP_DET:
440         case RT5639_HP_CALIB2:
441         case RT5639_SV_ZCD1:
442         case RT5639_SV_ZCD2:
443         case RT5639_GEN_CTRL1:
444         case RT5639_GEN_CTRL2:
445         case RT5639_GEN_CTRL3:
446         case RT5639_VENDOR_ID:
447         case RT5639_VENDOR_ID1:
448         case RT5639_VENDOR_ID2:
449         case RT5639_DUMMY_PR3F:
450                 return 1;
451         default:
452                 return 0;
453         }
454 }
455
456 static void DC_Calibrate(struct snd_soc_codec *codec)
457 {
458         unsigned int sclk_src;
459
460         sclk_src = snd_soc_read(codec, RT5639_GLB_CLK) &
461                 RT5639_SCLK_SRC_MASK;
462
463         snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
464                 RT5639_PWR_MB1, RT5639_PWR_MB1);
465         snd_soc_update_bits(codec, RT5639_DEPOP_M2,
466                 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
467         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
468                 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK | RT5639_HP_CB_MASK,
469                 RT5639_HP_CP_PU | RT5639_HP_SG_DIS | RT5639_HP_CB_PU);
470
471         snd_soc_update_bits(codec, RT5639_GLB_CLK,
472                 RT5639_SCLK_SRC_MASK, 0x2 << RT5639_SCLK_SRC_SFT);
473
474         rt5639_index_write(codec, RT5639_HP_DCC_INT1, 0x9f00);
475         snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
476                 RT5639_PWR_MB1, 0);
477         snd_soc_update_bits(codec, RT5639_GLB_CLK,
478                 RT5639_SCLK_SRC_MASK, sclk_src);
479 }
480
481 /**
482  * rt5639_headset_detect - Detect headset.
483  * @codec: SoC audio codec device.
484  * @jack_insert: Jack insert or not.
485  *
486  * Detect whether is headset or not when jack inserted.
487  *
488  * Returns detect status.
489  */
490 int rt5639_headset_detect(struct snd_soc_codec *codec, int jack_insert)
491 {
492         int jack_type;
493         int sclk_src;
494         int reg63, reg64;
495
496         if (jack_insert) {
497                 reg63 = snd_soc_read(codec, RT5639_PWR_ANLG1);
498                 reg64 = snd_soc_read(codec, RT5639_PWR_ANLG2);
499                 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
500                         snd_soc_write(codec, RT5639_PWR_ANLG1, 0xa814);
501                         snd_soc_write(codec, RT5639_MICBIAS, 0x3a30);
502                         snd_soc_write(codec, RT5639_GEN_CTRL1 , 0x3701);
503                 }
504                 sclk_src = snd_soc_read(codec, RT5639_GLB_CLK) &
505                         RT5639_SCLK_SRC_MASK;
506                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
507                         RT5639_SCLK_SRC_MASK, 0x3 << RT5639_SCLK_SRC_SFT);
508                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
509                         RT5639_PWR_LDO2, RT5639_PWR_LDO2);
510                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
511                         RT5639_PWR_MB1, RT5639_PWR_MB1);
512                 snd_soc_update_bits(codec, RT5639_MICBIAS,
513                         RT5639_MIC1_OVCD_MASK | RT5639_MIC1_OVTH_MASK |
514                         RT5639_PWR_CLK25M_MASK | RT5639_PWR_MB_MASK,
515                         RT5639_MIC1_OVCD_EN | RT5639_MIC1_OVTH_1500UA |
516                         RT5639_PWR_MB_PU | RT5639_PWR_CLK25M_PU);
517                 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
518                         0x1, 0x1);
519                 msleep(100);
520
521                 dev_info(codec->dev, "%s RT5639_PWR_ANLG1(0x%x) = 0x%x\n",
522                         __func__, RT5639_PWR_ANLG1,
523                         snd_soc_read(codec, RT5639_PWR_ANLG1));
524                 dev_info(codec->dev, "%s RT5639_IRQ_CTRL2(0x%x) = 0x%x\n",
525                         __func__, RT5639_IRQ_CTRL2,
526                         snd_soc_read(codec, RT5639_IRQ_CTRL2));
527
528                 if (snd_soc_read(codec, RT5639_IRQ_CTRL2) & 0x8)
529                         jack_type = RT5639_HEADPHO_DET;
530                 else
531                         jack_type = RT5639_HEADSET_DET;
532                 snd_soc_update_bits(codec, RT5639_IRQ_CTRL2,
533                         RT5639_MB1_OC_CLR, 0);
534                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
535                         RT5639_SCLK_SRC_MASK, sclk_src);
536                 snd_soc_write(codec, RT5639_PWR_ANLG1, reg63);
537                 snd_soc_write(codec, RT5639_PWR_ANLG2, reg64);
538         } else {
539                 snd_soc_update_bits(codec, RT5639_MICBIAS,
540                         RT5639_MIC1_OVCD_MASK,
541                         RT5639_MIC1_OVCD_DIS);
542
543                 jack_type = RT5639_NO_JACK;
544         }
545         dev_info(codec->dev, "%s jack_type = %d\n", __func__, jack_type);
546
547         return jack_type;
548 }
549 EXPORT_SYMBOL(rt5639_headset_detect);
550
551 /**
552  * rt5639_conn_mux_path - connect MUX widget path.
553  * @codec: SoC audio codec device.
554  * @widget_name: widget name.
555  * @path_name: path name.
556  *
557  * Make MUX path connected and update register.
558  *
559  * Returns 0 for success or negative error code.
560  */
561 int rt5639_conn_mux_path(struct snd_soc_codec *codec,
562                 char *widget_name, char *path_name)
563 {
564         struct snd_soc_dapm_context *dapm = &codec->dapm;
565         struct snd_soc_dapm_widget *w;
566         struct snd_soc_dapm_path *path;
567         struct snd_kcontrol_new *kcontrol;
568         struct soc_enum *em;
569         unsigned int val, mask, bitmask;
570         int i, update = 0;
571
572         if (codec == NULL || widget_name == NULL || path_name == NULL)
573                 return -EINVAL;
574
575         list_for_each_entry(w, &dapm->card->widgets, list)
576         {
577                 if (!w->name || w->dapm != dapm)
578                         continue;
579                 if (!(strcmp(w->name, widget_name))) {
580                         if (w->id != snd_soc_dapm_mux)
581                                 return -EINVAL;
582                         dev_info(codec->dev, "w->name=%s\n", w->name);
583                         list_for_each_entry(path, &w->sources, list_sink)
584                         {
585                                 if (!(strcmp(path->name, path_name)))
586                                         path->connect = 1;
587                                 else
588                                         path->connect = 0;
589                                 dev_info(codec->dev,
590                                         "path->name=%s path->connect=%d\n",
591                                         path->name, path->connect);
592                         }
593                         update = 1;
594                         break;
595                 }
596         }
597
598         if (update) {
599                 snd_soc_dapm_sync(dapm);
600
601                 kcontrol = &w->kcontrols[0];
602                 em = (struct soc_enum *)kcontrol->private_value;
603                 for (i = 0; i < em->max; i++)
604                         if (!(strcmp(path_name, em->texts[i])))
605                                 break;
606                 for (bitmask = 1; bitmask < em->max; bitmask <<= 1)
607                         ;
608                 val = i << em->shift_l;
609                 mask = (bitmask - 1) << em->shift_l;
610                 snd_soc_update_bits(codec, em->reg, mask, val);
611         }
612
613         return 0;
614 }
615 EXPORT_SYMBOL(rt5639_conn_mux_path);
616
617 static const char * const rt5639_dacr2_src[] = { "TxDC_R", "TxDP_R" };
618
619 static const SOC_ENUM_SINGLE_DECL(rt5639_dacr2_enum, RT5639_DUMMY_PR3F,
620         14, rt5639_dacr2_src);
621 static const struct snd_kcontrol_new rt5639_dacr2_mux =
622         SOC_DAPM_ENUM("Mono dacr source", rt5639_dacr2_enum);
623
624 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
625 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
626 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
627 static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
628 static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
629
630 /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
631 static unsigned int bst_tlv[] = {
632         TLV_DB_RANGE_HEAD(7),
633         0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
634         1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
635         2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
636         3, 5, TLV_DB_SCALE_ITEM(3000, 500, 0),
637         6, 6, TLV_DB_SCALE_ITEM(4400, 0, 0),
638         7, 7, TLV_DB_SCALE_ITEM(5000, 0, 0),
639         8, 8, TLV_DB_SCALE_ITEM(5200, 0, 0),
640 };
641
642 static int rt5639_dmic_get(struct snd_kcontrol *kcontrol,
643                 struct snd_ctl_elem_value *ucontrol)
644 {
645         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
646         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
647
648         ucontrol->value.integer.value[0] = rt5639->dmic_en;
649
650         return 0;
651 }
652
653 static int rt5639_dmic_put(struct snd_kcontrol *kcontrol,
654                 struct snd_ctl_elem_value *ucontrol)
655 {
656         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
657         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
658
659         if (rt5639->dmic_en == ucontrol->value.integer.value[0])
660                 return 0;
661
662         rt5639->dmic_en = ucontrol->value.integer.value[0];
663         switch (rt5639->dmic_en) {
664         case RT5639_DMIC_DIS:
665                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
666                         RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK |
667                         RT5639_GP4_PIN_MASK,
668                         RT5639_GP2_PIN_GPIO2 | RT5639_GP3_PIN_GPIO3 |
669                         RT5639_GP4_PIN_GPIO4);
670                 snd_soc_update_bits(codec, RT5639_DMIC,
671                         RT5639_DMIC_1_DP_MASK | RT5639_DMIC_2_DP_MASK,
672                         RT5639_DMIC_1_DP_GPIO3 | RT5639_DMIC_2_DP_GPIO4);
673                 snd_soc_update_bits(codec, RT5639_DMIC,
674                         RT5639_DMIC_1_EN_MASK | RT5639_DMIC_2_EN_MASK,
675                         RT5639_DMIC_1_DIS | RT5639_DMIC_2_DIS);
676                 break;
677
678         case RT5639_DMIC1:
679                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
680                         RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK,
681                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP3_PIN_DMIC1_SDA);
682                 snd_soc_update_bits(codec, RT5639_DMIC,
683                         RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK |
684                         RT5639_DMIC_1_DP_MASK,
685                         RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING |
686                         RT5639_DMIC_1_DP_IN1P);
687                 snd_soc_update_bits(codec, RT5639_DMIC,
688                         RT5639_DMIC_1_EN_MASK, RT5639_DMIC_1_EN);
689                 break;
690
691         case RT5639_DMIC2:
692                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
693                         RT5639_GP2_PIN_MASK | RT5639_GP4_PIN_MASK,
694                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP4_PIN_DMIC2_SDA);
695                 snd_soc_update_bits(codec, RT5639_DMIC,
696                         RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK |
697                         RT5639_DMIC_2_DP_MASK,
698                         RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING |
699                         RT5639_DMIC_2_DP_IN1N);
700                 snd_soc_update_bits(codec, RT5639_DMIC,
701                         RT5639_DMIC_2_EN_MASK, RT5639_DMIC_2_EN);
702                 break;
703
704         default:
705                 return -EINVAL;
706         }
707
708         return 0;
709 }
710
711
712 /* IN1/IN2 Input Type */
713 static const char *rt5639_input_mode[] = {
714         "Single ended", "Differential"};
715
716 static const SOC_ENUM_SINGLE_DECL(
717         rt5639_in1_mode_enum, RT5639_IN1_IN2,
718         RT5639_IN_SFT1, rt5639_input_mode);
719
720 static const SOC_ENUM_SINGLE_DECL(
721         rt5639_in2_mode_enum, RT5639_IN3_IN4,
722         RT5639_IN_SFT2, rt5639_input_mode);
723
724 /* Interface data select */
725 static const char *rt5639_data_select[] = {
726         "Normal", "Swap", "left copy to right", "right copy to left"};
727
728 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_dac_enum, RT5639_DIG_INF_DATA,
729                                 RT5639_IF1_DAC_SEL_SFT, rt5639_data_select);
730
731 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_adc_enum, RT5639_DIG_INF_DATA,
732                                 RT5639_IF1_ADC_SEL_SFT, rt5639_data_select);
733
734 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_dac_enum, RT5639_DIG_INF_DATA,
735                                 RT5639_IF2_DAC_SEL_SFT, rt5639_data_select);
736
737 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_enum, RT5639_DIG_INF_DATA,
738                                 RT5639_IF2_ADC_SEL_SFT, rt5639_data_select);
739
740 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_dac_enum, RT5639_DIG_INF_DATA,
741                                 RT5639_IF3_DAC_SEL_SFT, rt5639_data_select);
742
743 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_adc_enum, RT5639_DIG_INF_DATA,
744                                 RT5639_IF3_ADC_SEL_SFT, rt5639_data_select);
745
746 /* Class D speaker gain ratio */
747 static const char *rt5639_clsd_spk_ratio[] = {"1.66x", "1.83x", "1.94x", "2x",
748         "2.11x", "2.22x", "2.33x", "2.44x", "2.55x", "2.66x", "2.77x"};
749
750 static const SOC_ENUM_SINGLE_DECL(
751         rt5639_clsd_spk_ratio_enum, RT5639_CLS_D_OUT,
752         RT5639_CLSD_RATIO_SFT, rt5639_clsd_spk_ratio);
753
754 /* DMIC */
755 static const char *rt5639_dmic_mode[] = {"Disable", "DMIC1", "DMIC2"};
756
757 static const SOC_ENUM_SINGLE_DECL(rt5639_dmic_enum, 0, 0, rt5639_dmic_mode);
758
759
760
761 #ifdef RT5639_REG_RW
762 #define REGVAL_MAX 0xffff
763 static unsigned int regctl_addr;
764 static int rt5639_regctl_info(struct snd_kcontrol *kcontrol,
765                         struct snd_ctl_elem_info *uinfo)
766 {
767         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
768         uinfo->count = 2;
769         uinfo->value.integer.min = 0;
770         uinfo->value.integer.max = REGVAL_MAX;
771         return 0;
772 }
773
774 static int rt5639_regctl_get(struct snd_kcontrol *kcontrol,
775                         struct snd_ctl_elem_value *ucontrol)
776 {
777         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
778         ucontrol->value.integer.value[0] = regctl_addr;
779         ucontrol->value.integer.value[1] = snd_soc_read(codec, regctl_addr);
780         return 0;
781 }
782
783 static int rt5639_regctl_put(struct snd_kcontrol *kcontrol,
784                         struct snd_ctl_elem_value *ucontrol)
785 {
786         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
787         regctl_addr = ucontrol->value.integer.value[0];
788         if (ucontrol->value.integer.value[1] <= REGVAL_MAX)
789                 snd_soc_write(codec, regctl_addr, ucontrol->value.integer.value[1]);
790         return 0;
791 }
792 #endif
793
794
795 static int rt5639_vol_rescale_get(struct snd_kcontrol *kcontrol,
796                 struct snd_ctl_elem_value *ucontrol)
797 {
798         struct soc_mixer_control *mc =
799                 (struct soc_mixer_control *)kcontrol->private_value;
800         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
801         unsigned int val = snd_soc_read(codec, mc->reg);
802
803         ucontrol->value.integer.value[0] = RT5639_VOL_RSCL_MAX -
804                 ((val & RT5639_L_VOL_MASK) >> mc->shift);
805         ucontrol->value.integer.value[1] = RT5639_VOL_RSCL_MAX -
806                 (val & RT5639_R_VOL_MASK);
807
808         return 0;
809 }
810
811 static int rt5639_vol_rescale_put(struct snd_kcontrol *kcontrol,
812                 struct snd_ctl_elem_value *ucontrol)
813 {
814         struct soc_mixer_control *mc =
815                 (struct soc_mixer_control *)kcontrol->private_value;
816         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
817         unsigned int val, val2;
818
819         val = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[0];
820         val2 = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[1];
821         return snd_soc_update_bits_locked(codec, mc->reg, RT5639_L_VOL_MASK |
822                         RT5639_R_VOL_MASK, val << mc->shift | val2);
823 }
824
825
826 static const struct snd_kcontrol_new rt5639_snd_controls[] = {
827         /* Speaker Output Volume */
828         SOC_DOUBLE("Speaker Playback Switch", RT5639_SPK_VOL,
829                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
830         SOC_DOUBLE_EXT_TLV("Speaker Playback Volume", RT5639_SPK_VOL,
831                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
832                 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
833         /* Headphone Output Volume */
834         SOC_DOUBLE("HP Playback Switch", RT5639_HP_VOL,
835                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
836         SOC_DOUBLE_EXT_TLV("HP Playback Volume", RT5639_HP_VOL,
837                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
838                 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
839         /* OUTPUT Control */
840         SOC_DOUBLE("OUT Playback Switch", RT5639_OUTPUT,
841                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
842         SOC_DOUBLE("OUT Channel Switch", RT5639_OUTPUT,
843                 RT5639_VOL_L_SFT, RT5639_VOL_R_SFT, 1, 1),
844         SOC_DOUBLE_TLV("OUT Playback Volume", RT5639_OUTPUT,
845                 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, 39, 1, out_vol_tlv),
846         /* MONO Output Control */
847         SOC_SINGLE("Mono Playback Switch", RT5639_MONO_OUT,
848                                 RT5639_L_MUTE_SFT, 1, 1),
849         /* DAC Digital Volume */
850         SOC_DOUBLE("DAC2 Playback Switch", RT5639_DAC2_CTRL,
851                 RT5639_M_DAC_L2_VOL_SFT, RT5639_M_DAC_R2_VOL_SFT, 1, 1),
852         SOC_DOUBLE_TLV("DAC1 Playback Volume", RT5639_DAC1_DIG_VOL,
853                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
854                         175, 0, dac_vol_tlv),
855         SOC_DOUBLE_TLV("Mono DAC Playback Volume", RT5639_DAC2_DIG_VOL,
856                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
857                         175, 0, dac_vol_tlv),
858         /* IN1/IN2 Control */
859         SOC_ENUM("IN1 Mode Control",  rt5639_in1_mode_enum),
860         SOC_SINGLE_TLV("IN1 Boost", RT5639_IN1_IN2,
861                 RT5639_BST_SFT1, 8, 0, bst_tlv),
862         SOC_ENUM("IN2 Mode Control", rt5639_in2_mode_enum),
863         SOC_SINGLE_TLV("IN2 Boost", RT5639_IN3_IN4,
864                 RT5639_BST_SFT2, 8, 0, bst_tlv),
865         /* INL/INR Volume Control */
866         SOC_DOUBLE_TLV("IN Capture Volume", RT5639_INL_INR_VOL,
867                         RT5639_INL_VOL_SFT, RT5639_INR_VOL_SFT,
868                         31, 1, in_vol_tlv),
869         /* ADC Digital Volume Control */
870         SOC_DOUBLE("ADC Capture Switch", RT5639_ADC_DIG_VOL,
871                 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
872         SOC_DOUBLE_TLV("ADC Capture Volume", RT5639_ADC_DIG_VOL,
873                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
874                         127, 0, adc_vol_tlv),
875         SOC_DOUBLE_TLV("Mono ADC Capture Volume", RT5639_ADC_DATA,
876                         RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
877                         127, 0, adc_vol_tlv),
878         /* ADC Boost Volume Control */
879         SOC_DOUBLE_TLV("ADC Boost Gain", RT5639_ADC_BST_VOL,
880                         RT5639_ADC_L_BST_SFT, RT5639_ADC_R_BST_SFT,
881                         3, 0, adc_bst_tlv),
882         /* Class D speaker gain ratio */
883         SOC_ENUM("Class D SPK Ratio Control", rt5639_clsd_spk_ratio_enum),
884         /* DMIC */
885         SOC_ENUM_EXT("DMIC Switch", rt5639_dmic_enum,
886                 rt5639_dmic_get, rt5639_dmic_put),
887
888         SOC_ENUM("ADC IF1 Data Switch", rt5639_if1_adc_enum),
889         SOC_ENUM("DAC IF1 Data Switch", rt5639_if1_dac_enum),
890         SOC_ENUM("ADC IF2 Data Switch", rt5639_if2_adc_enum),
891         SOC_ENUM("DAC IF2 Data Switch", rt5639_if2_dac_enum),
892 #ifdef RT5639_REG_RW
893         {
894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
895                 .name = "Register Control",
896                 .info = rt5639_regctl_info,
897                 .get = rt5639_regctl_get,
898                 .put = rt5639_regctl_put,
899         },
900 #endif
901 };
902
903 /**
904  * set_dmic_clk - Set parameter of dmic.
905  *
906  * @w: DAPM widget.
907  * @kcontrol: The kcontrol of this widget.
908  * @event: Event id.
909  *
910  * Choose dmic clock between 1MHz and 3MHz.
911  * It is better for clock to approximate 3MHz.
912  */
913 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
914         struct snd_kcontrol *kcontrol, int event)
915 {
916         struct snd_soc_codec *codec = w->codec;
917         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
918         int div[] = {2, 3, 4, 6, 12}, idx = -EINVAL, i, rate, red, bound, temp;
919
920         rate = rt5639->lrck[rt5639->aif_pu] << 8;
921         red = 3000000 * 12;
922         for (i = 0; i < ARRAY_SIZE(div); i++) {
923                 bound = div[i] * 3000000;
924                 if (rate > bound)
925                         continue;
926                 temp = bound - rate;
927                 if (temp < red) {
928                         red = temp;
929                         idx = i;
930                 }
931         }
932         if (idx < 0)
933                 dev_err(codec->dev, "Failed to set DMIC clock\n");
934         else
935                 snd_soc_update_bits(codec, RT5639_DMIC, RT5639_DMIC_CLK_MASK,
936                                         idx << RT5639_DMIC_CLK_SFT);
937         return idx;
938 }
939
940 static int check_sysclk1_source(struct snd_soc_dapm_widget *source,
941                          struct snd_soc_dapm_widget *sink)
942 {
943         unsigned int val;
944
945         val = snd_soc_read(source->codec, RT5639_GLB_CLK);
946         val &= RT5639_SCLK_SRC_MASK;
947         if (val == RT5639_SCLK_SRC_PLL1)
948                 return 1;
949         else
950                 return 0;
951 }
952
953 /* Digital Mixer */
954 static const struct snd_kcontrol_new rt5639_sto_adc_l_mix[] = {
955         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
956                         RT5639_M_ADC_L1_SFT, 1, 1),
957         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
958                         RT5639_M_ADC_L2_SFT, 1, 1),
959 };
960
961 static const struct snd_kcontrol_new rt5639_sto_adc_r_mix[] = {
962         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
963                         RT5639_M_ADC_R1_SFT, 1, 1),
964         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
965                         RT5639_M_ADC_R2_SFT, 1, 1),
966 };
967
968 static const struct snd_kcontrol_new rt5639_mono_adc_l_mix[] = {
969         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
970                         RT5639_M_MONO_ADC_L1_SFT, 1, 1),
971         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
972                         RT5639_M_MONO_ADC_L2_SFT, 1, 1),
973 };
974
975 static const struct snd_kcontrol_new rt5639_mono_adc_r_mix[] = {
976         SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
977                         RT5639_M_MONO_ADC_R1_SFT, 1, 1),
978         SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
979                         RT5639_M_MONO_ADC_R2_SFT, 1, 1),
980 };
981
982 static const struct snd_kcontrol_new rt5639_dac_l_mix[] = {
983         SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
984                         RT5639_M_ADCMIX_L_SFT, 1, 1),
985         SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
986                         RT5639_M_IF1_DAC_L_SFT, 1, 1),
987 };
988
989 static const struct snd_kcontrol_new rt5639_dac_r_mix[] = {
990         SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
991                         RT5639_M_ADCMIX_R_SFT, 1, 1),
992         SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
993                         RT5639_M_IF1_DAC_R_SFT, 1, 1),
994 };
995
996 static const struct snd_kcontrol_new rt5639_sto_dac_l_mix[] = {
997         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_STO_DAC_MIXER,
998                         RT5639_M_DAC_L1_SFT, 1, 1),
999         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_STO_DAC_MIXER,
1000                         RT5639_M_DAC_L2_SFT, 1, 1),
1001         SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
1002                         RT5639_M_ANC_DAC_L_SFT, 1, 1),
1003 };
1004
1005 static const struct snd_kcontrol_new rt5639_sto_dac_r_mix[] = {
1006         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_STO_DAC_MIXER,
1007                         RT5639_M_DAC_R1_SFT, 1, 1),
1008         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_STO_DAC_MIXER,
1009                         RT5639_M_DAC_R2_SFT, 1, 1),
1010         SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
1011                         RT5639_M_ANC_DAC_R_SFT, 1, 1),
1012 };
1013
1014 static const struct snd_kcontrol_new rt5639_mono_dac_l_mix[] = {
1015         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_MONO_DAC_MIXER,
1016                         RT5639_M_DAC_L1_MONO_L_SFT, 1, 1),
1017         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
1018                         RT5639_M_DAC_L2_MONO_L_SFT, 1, 1),
1019         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
1020                         RT5639_M_DAC_R2_MONO_L_SFT, 1, 1),
1021 };
1022
1023 static const struct snd_kcontrol_new rt5639_mono_dac_r_mix[] = {
1024         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_MONO_DAC_MIXER,
1025                         RT5639_M_DAC_R1_MONO_R_SFT, 1, 1),
1026         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
1027                         RT5639_M_DAC_R2_MONO_R_SFT, 1, 1),
1028         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
1029                         RT5639_M_DAC_L2_MONO_R_SFT, 1, 1),
1030 };
1031
1032 static const struct snd_kcontrol_new rt5639_dig_l_mix[] = {
1033         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_DIG_MIXER,
1034                         RT5639_M_STO_L_DAC_L_SFT, 1, 1),
1035         SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_DIG_MIXER,
1036                         RT5639_M_DAC_L2_DAC_L_SFT, 1, 1),
1037 };
1038
1039 static const struct snd_kcontrol_new rt5639_dig_r_mix[] = {
1040         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_DIG_MIXER,
1041                         RT5639_M_STO_R_DAC_R_SFT, 1, 1),
1042         SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_DIG_MIXER,
1043                         RT5639_M_DAC_R2_DAC_R_SFT, 1, 1),
1044 };
1045
1046 /* Analog Input Mixer */
1047 static const struct snd_kcontrol_new rt5639_rec_l_mix[] = {
1048         SOC_DAPM_SINGLE("HPOL Switch", RT5639_REC_L2_MIXER,
1049                         RT5639_M_HP_L_RM_L_SFT, 1, 1),
1050         SOC_DAPM_SINGLE("INL Switch", RT5639_REC_L2_MIXER,
1051                         RT5639_M_IN_L_RM_L_SFT, 1, 1),
1052         SOC_DAPM_SINGLE("BST3 Switch", RT5639_REC_L2_MIXER,
1053                         RT5639_M_BST2_RM_L_SFT, 1, 1),
1054         SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_L2_MIXER,
1055                         RT5639_M_BST4_RM_L_SFT, 1, 1),
1056         SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_L2_MIXER,
1057                         RT5639_M_BST1_RM_L_SFT, 1, 1),
1058         SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_REC_L2_MIXER,
1059                         RT5639_M_OM_L_RM_L_SFT, 1, 1),
1060 };
1061
1062 static const struct snd_kcontrol_new rt5639_rec_r_mix[] = {
1063         SOC_DAPM_SINGLE("HPOR Switch", RT5639_REC_R2_MIXER,
1064                         RT5639_M_HP_R_RM_R_SFT, 1, 1),
1065         SOC_DAPM_SINGLE("INR Switch", RT5639_REC_R2_MIXER,
1066                         RT5639_M_IN_R_RM_R_SFT, 1, 1),
1067         SOC_DAPM_SINGLE("BST3 Switch", RT5639_REC_R2_MIXER,
1068                         RT5639_M_BST2_RM_R_SFT, 1, 1),
1069         SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_R2_MIXER,
1070                         RT5639_M_BST4_RM_R_SFT, 1, 1),
1071         SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_R2_MIXER,
1072                         RT5639_M_BST1_RM_R_SFT, 1, 1),
1073         SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_REC_R2_MIXER,
1074                         RT5639_M_OM_R_RM_R_SFT, 1, 1),
1075 };
1076
1077 /* Analog Output Mixer */
1078 static const struct snd_kcontrol_new rt5639_spk_l_mix[] = {
1079         SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_SPK_L_MIXER,
1080                         RT5639_M_RM_L_SM_L_SFT, 1, 1),
1081         SOC_DAPM_SINGLE("INL Switch", RT5639_SPK_L_MIXER,
1082                         RT5639_M_IN_L_SM_L_SFT, 1, 1),
1083         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPK_L_MIXER,
1084                         RT5639_M_DAC_L1_SM_L_SFT, 1, 1),
1085         SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_SPK_L_MIXER,
1086                         RT5639_M_OM_L_SM_L_SFT, 1, 1),
1087 };
1088
1089 static const struct snd_kcontrol_new rt5639_spk_r_mix[] = {
1090         SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_SPK_R_MIXER,
1091                         RT5639_M_RM_R_SM_R_SFT, 1, 1),
1092         SOC_DAPM_SINGLE("INR Switch", RT5639_SPK_R_MIXER,
1093                         RT5639_M_IN_R_SM_R_SFT, 1, 1),
1094         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPK_R_MIXER,
1095                         RT5639_M_DAC_R1_SM_R_SFT, 1, 1),
1096         SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_SPK_R_MIXER,
1097                         RT5639_M_OM_R_SM_R_SFT, 1, 1),
1098 };
1099
1100 static const struct snd_kcontrol_new rt5639_out_l_mix[] = {
1101         SOC_DAPM_SINGLE("SPK MIXL Switch", RT5639_OUT_L3_MIXER,
1102                         RT5639_M_SM_L_OM_L_SFT, 1, 1),
1103         SOC_DAPM_SINGLE("BST3 Switch", RT5639_OUT_L3_MIXER,
1104                         RT5639_M_BST2_OM_L_SFT, 1, 1),
1105         SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_L3_MIXER,
1106                         RT5639_M_BST1_OM_L_SFT, 1, 1),
1107         SOC_DAPM_SINGLE("INL Switch", RT5639_OUT_L3_MIXER,
1108                         RT5639_M_IN_L_OM_L_SFT, 1, 1),
1109         SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_OUT_L3_MIXER,
1110                         RT5639_M_RM_L_OM_L_SFT, 1, 1),
1111         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_OUT_L3_MIXER,
1112                         RT5639_M_DAC_L1_OM_L_SFT, 1, 1),
1113 };
1114
1115 static const struct snd_kcontrol_new rt5639_out_r_mix[] = {
1116         SOC_DAPM_SINGLE("SPK MIXR Switch", RT5639_OUT_R3_MIXER,
1117                         RT5639_M_SM_L_OM_R_SFT, 1, 1),
1118         SOC_DAPM_SINGLE("BST3 Switch", RT5639_OUT_R3_MIXER,
1119                         RT5639_M_BST2_OM_R_SFT, 1, 1),
1120         SOC_DAPM_SINGLE("BST2 Switch", RT5639_OUT_R3_MIXER,
1121                         RT5639_M_BST4_OM_R_SFT, 1, 1),
1122         SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_R3_MIXER,
1123                         RT5639_M_BST1_OM_R_SFT, 1, 1),
1124         SOC_DAPM_SINGLE("INR Switch", RT5639_OUT_R3_MIXER,
1125                         RT5639_M_IN_R_OM_R_SFT, 1, 1),
1126         SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_OUT_R3_MIXER,
1127                         RT5639_M_RM_R_OM_R_SFT, 1, 1),
1128         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_OUT_R3_MIXER,
1129                         RT5639_M_DAC_R1_OM_R_SFT, 1, 1),
1130 };
1131
1132 static const struct snd_kcontrol_new rt5639_spo_l_mix[] = {
1133         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_L_MIXER,
1134                         RT5639_M_DAC_R1_SPM_L_SFT, 1, 1),
1135         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPO_L_MIXER,
1136                         RT5639_M_DAC_L1_SPM_L_SFT, 1, 1),
1137         SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_L_MIXER,
1138                         RT5639_M_SV_R_SPM_L_SFT, 1, 1),
1139         SOC_DAPM_SINGLE("SPKVOL L Switch", RT5639_SPO_L_MIXER,
1140                         RT5639_M_SV_L_SPM_L_SFT, 1, 1),
1141         SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_L_MIXER,
1142                         RT5639_M_BST1_SPM_L_SFT, 1, 1),
1143 };
1144
1145 static const struct snd_kcontrol_new rt5639_spo_r_mix[] = {
1146         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_R_MIXER,
1147                         RT5639_M_DAC_R1_SPM_R_SFT, 1, 1),
1148         SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_R_MIXER,
1149                         RT5639_M_SV_R_SPM_R_SFT, 1, 1),
1150         SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_R_MIXER,
1151                         RT5639_M_BST1_SPM_R_SFT, 1, 1),
1152 };
1153
1154 static const struct snd_kcontrol_new rt5639_hpo_mix[] = {
1155         SOC_DAPM_SINGLE("DAC1 Switch", RT5639_HPO_MIXER,
1156                         RT5639_M_DAC1_HM_SFT, 1, 1),
1157         SOC_DAPM_SINGLE("HPVOL Switch", RT5639_HPO_MIXER,
1158                         RT5639_M_HPVOL_HM_SFT, 1, 1),
1159 };
1160
1161 static const struct snd_kcontrol_new rt5639_lout_mix[] = {
1162         SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_LOUT_MIXER,
1163                         RT5639_M_DAC_L1_LM_SFT, 1, 1),
1164         SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_LOUT_MIXER,
1165                         RT5639_M_DAC_R1_LM_SFT, 1, 1),
1166         SOC_DAPM_SINGLE("OUTVOL L Switch", RT5639_LOUT_MIXER,
1167                         RT5639_M_OV_L_LM_SFT, 1, 1),
1168         SOC_DAPM_SINGLE("OUTVOL R Switch", RT5639_LOUT_MIXER,
1169                         RT5639_M_OV_R_LM_SFT, 1, 1),
1170 };
1171
1172
1173 /* INL/R source */
1174 static const char *rt5639_inl_src[] = {"IN2P", "MonoP"};
1175
1176 static const SOC_ENUM_SINGLE_DECL(
1177         rt5639_inl_enum, RT5639_INL_INR_VOL,
1178         RT5639_INL_SEL_SFT, rt5639_inl_src);
1179
1180 static const struct snd_kcontrol_new rt5639_inl_mux =
1181         SOC_DAPM_ENUM("INL source", rt5639_inl_enum);
1182
1183 static const char *rt5639_inr_src[] = {"IN2N", "MonoN"};
1184
1185 static const SOC_ENUM_SINGLE_DECL(
1186         rt5639_inr_enum, RT5639_INL_INR_VOL,
1187         RT5639_INR_SEL_SFT, rt5639_inr_src);
1188
1189 static const struct snd_kcontrol_new rt5639_inr_mux =
1190         SOC_DAPM_ENUM("INR source", rt5639_inr_enum);
1191
1192 /* Stereo ADC source */
1193 static const char *rt5639_stereo_adc1_src[] = {"DIG MIX", "ADC"};
1194
1195 static const SOC_ENUM_SINGLE_DECL(
1196         rt5639_stereo_adc1_enum, RT5639_STO_ADC_MIXER,
1197         RT5639_ADC_1_SRC_SFT, rt5639_stereo_adc1_src);
1198
1199 static const struct snd_kcontrol_new rt5639_sto_adc_l1_mux =
1200         SOC_DAPM_ENUM("Stereo ADC L1 source", rt5639_stereo_adc1_enum);
1201
1202 static const struct snd_kcontrol_new rt5639_sto_adc_r1_mux =
1203         SOC_DAPM_ENUM("Stereo ADC R1 source", rt5639_stereo_adc1_enum);
1204
1205 static const char *rt5639_stereo_adc2_src[] = {"DMIC1", "DMIC2", "DIG MIX"};
1206
1207 static const SOC_ENUM_SINGLE_DECL(
1208         rt5639_stereo_adc2_enum, RT5639_STO_ADC_MIXER,
1209         RT5639_ADC_2_SRC_SFT, rt5639_stereo_adc2_src);
1210
1211 static const struct snd_kcontrol_new rt5639_sto_adc_l2_mux =
1212         SOC_DAPM_ENUM("Stereo ADC L2 source", rt5639_stereo_adc2_enum);
1213
1214 static const struct snd_kcontrol_new rt5639_sto_adc_r2_mux =
1215         SOC_DAPM_ENUM("Stereo ADC R2 source", rt5639_stereo_adc2_enum);
1216
1217 /* Mono ADC source */
1218 static const char *rt5639_mono_adc_l1_src[] = {"Mono DAC MIXL", "ADCL"};
1219
1220 static const SOC_ENUM_SINGLE_DECL(
1221         rt5639_mono_adc_l1_enum, RT5639_MONO_ADC_MIXER,
1222         RT5639_MONO_ADC_L1_SRC_SFT, rt5639_mono_adc_l1_src);
1223
1224 static const struct snd_kcontrol_new rt5639_mono_adc_l1_mux =
1225         SOC_DAPM_ENUM("Mono ADC1 left source", rt5639_mono_adc_l1_enum);
1226
1227 static const char *rt5639_mono_adc_l2_src[] =
1228         {"DMIC L1", "DMIC L2", "Mono DAC MIXL"};
1229
1230 static const SOC_ENUM_SINGLE_DECL(
1231         rt5639_mono_adc_l2_enum, RT5639_MONO_ADC_MIXER,
1232         RT5639_MONO_ADC_L2_SRC_SFT, rt5639_mono_adc_l2_src);
1233
1234 static const struct snd_kcontrol_new rt5639_mono_adc_l2_mux =
1235         SOC_DAPM_ENUM("Mono ADC2 left source", rt5639_mono_adc_l2_enum);
1236
1237 static const char *rt5639_mono_adc_r1_src[] = {"Mono DAC MIXR", "ADCR"};
1238
1239 static const SOC_ENUM_SINGLE_DECL(
1240         rt5639_mono_adc_r1_enum, RT5639_MONO_ADC_MIXER,
1241         RT5639_MONO_ADC_R1_SRC_SFT, rt5639_mono_adc_r1_src);
1242
1243 static const struct snd_kcontrol_new rt5639_mono_adc_r1_mux =
1244         SOC_DAPM_ENUM("Mono ADC1 right source", rt5639_mono_adc_r1_enum);
1245
1246 static const char *rt5639_mono_adc_r2_src[] =
1247         {"DMIC R1", "DMIC R2", "Mono DAC MIXR"};
1248
1249 static const SOC_ENUM_SINGLE_DECL(
1250         rt5639_mono_adc_r2_enum, RT5639_MONO_ADC_MIXER,
1251         RT5639_MONO_ADC_R2_SRC_SFT, rt5639_mono_adc_r2_src);
1252
1253 static const struct snd_kcontrol_new rt5639_mono_adc_r2_mux =
1254         SOC_DAPM_ENUM("Mono ADC2 right source", rt5639_mono_adc_r2_enum);
1255
1256 /* DAC2 channel source */
1257 static const char *rt5639_dac_l2_src[] = {"IF2", "IF3", "TxDC", "Base L/R"};
1258
1259 static const SOC_ENUM_SINGLE_DECL(rt5639_dac_l2_enum, RT5639_DSP_PATH2,
1260                                 RT5639_DAC_L2_SEL_SFT, rt5639_dac_l2_src);
1261
1262 static const struct snd_kcontrol_new rt5639_dac_l2_mux =
1263         SOC_DAPM_ENUM("DAC2 left channel source", rt5639_dac_l2_enum);
1264
1265 static const char *rt5639_dac_r2_src[] = {"IF2", "IF3", "TxDC"};
1266
1267 static const SOC_ENUM_SINGLE_DECL(
1268         rt5639_dac_r2_enum, RT5639_DSP_PATH2,
1269         RT5639_DAC_R2_SEL_SFT, rt5639_dac_r2_src);
1270
1271 static const struct snd_kcontrol_new rt5639_dac_r2_mux =
1272         SOC_DAPM_ENUM("DAC2 right channel source", rt5639_dac_r2_enum);
1273
1274 /* Interface 2  ADC channel source */
1275 static const char *rt5639_if2_adc_l_src[] = {"TxDP", "Mono ADC MIXL"};
1276
1277 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_l_enum, RT5639_DSP_PATH2,
1278                         RT5639_IF2_ADC_L_SEL_SFT, rt5639_if2_adc_l_src);
1279
1280 static const struct snd_kcontrol_new rt5639_if2_adc_l_mux =
1281         SOC_DAPM_ENUM("IF2 ADC left channel source", rt5639_if2_adc_l_enum);
1282
1283 static const char *rt5639_if2_adc_r_src[] = {"TxDP", "Mono ADC MIXR"};
1284
1285 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_r_enum, RT5639_DSP_PATH2,
1286                         RT5639_IF2_ADC_R_SEL_SFT, rt5639_if2_adc_r_src);
1287
1288 static const struct snd_kcontrol_new rt5639_if2_adc_r_mux =
1289         SOC_DAPM_ENUM("IF2 ADC right channel source", rt5639_if2_adc_r_enum);
1290
1291 /* digital interface and iis interface map */
1292 static const char *rt5639_dai_iis_map[] = {"1:1|2:2|3:3", "1:1|2:3|3:2",
1293         "1:3|2:1|3:2", "1:3|2:2|3:1", "1:2|2:3|3:1",
1294         "1:2|2:1|3:3", "1:1|2:1|3:3", "1:2|2:2|3:3"};
1295
1296 static const SOC_ENUM_SINGLE_DECL(
1297         rt5639_dai_iis_map_enum, RT5639_I2S1_SDP,
1298         RT5639_I2S_IF_SFT, rt5639_dai_iis_map);
1299
1300 static const struct snd_kcontrol_new rt5639_dai_mux =
1301         SOC_DAPM_ENUM("DAI select", rt5639_dai_iis_map_enum);
1302
1303 /* SDI select */
1304 static const char *rt5639_sdi_sel[] = {"IF1", "IF2"};
1305
1306 static const SOC_ENUM_SINGLE_DECL(
1307         rt5639_sdi_sel_enum, RT5639_I2S2_SDP,
1308         RT5639_I2S2_SDI_SFT, rt5639_sdi_sel);
1309
1310 static const struct snd_kcontrol_new rt5639_sdi_mux =
1311         SOC_DAPM_ENUM("SDI select", rt5639_sdi_sel_enum);
1312
1313 static int rt5639_adc_event(struct snd_soc_dapm_widget *w,
1314         struct snd_kcontrol *kcontrol, int event)
1315 {
1316         struct snd_soc_codec *codec = w->codec;
1317
1318         switch (event) {
1319         case SND_SOC_DAPM_POST_PMU:
1320                 rt5639_index_update_bits(codec,
1321                         RT5639_CHOP_DAC_ADC, 0x1000, 0x1000);
1322                 break;
1323
1324         case SND_SOC_DAPM_POST_PMD:
1325                 rt5639_index_update_bits(codec,
1326                         RT5639_CHOP_DAC_ADC, 0x1000, 0x0000);
1327                 break;
1328
1329         default:
1330                 return 0;
1331         }
1332
1333         return 0;
1334 }
1335
1336 static int rt5639_mono_adcl_event(struct snd_soc_dapm_widget *w,
1337         struct snd_kcontrol *kcontrol, int event)
1338 {
1339         struct snd_soc_codec *codec = w->codec;
1340
1341         switch (event) {
1342         case SND_SOC_DAPM_POST_PMU:
1343                 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1344                         RT5639_M_MAMIX_L, 0);
1345                 break;
1346         case SND_SOC_DAPM_PRE_PMD:
1347                 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1348                         RT5639_M_MAMIX_L,
1349                         RT5639_M_MAMIX_L);
1350                 break;
1351
1352         default:
1353                 return 0;
1354         }
1355
1356         return 0;
1357 }
1358
1359 static int rt5639_mono_adcr_event(struct snd_soc_dapm_widget *w,
1360         struct snd_kcontrol *kcontrol, int event)
1361 {
1362         struct snd_soc_codec *codec = w->codec;
1363
1364         switch (event) {
1365         case SND_SOC_DAPM_POST_PMU:
1366                 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1367                         RT5639_M_MAMIX_R, 0);
1368                 break;
1369         case SND_SOC_DAPM_PRE_PMD:
1370                 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1371                         RT5639_M_MAMIX_R,
1372                         RT5639_M_MAMIX_R);
1373                 break;
1374
1375         default:
1376                 return 0;
1377         }
1378
1379         return 0;
1380 }
1381
1382 static int rt5639_spk_event(struct snd_soc_dapm_widget *w,
1383                 struct snd_kcontrol *kcontrol, int event)
1384 {
1385         struct snd_soc_codec *codec = w->codec;
1386
1387         switch (event) {
1388         case SND_SOC_DAPM_POST_PMU:
1389 #ifdef USE_EQ
1390                 rt5639_update_eqmode(codec, SPK);
1391 #endif
1392                 snd_soc_update_bits(codec, RT5639_PWR_DIG1,
1393                         RT5639_PWR_CLS_D, RT5639_PWR_CLS_D);
1394                 rt5639_index_update_bits(codec,
1395                         RT5639_CLSD_INT_REG1, 0xf000, 0xf000);
1396                 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1397                         RT5639_L_MUTE | RT5639_R_MUTE, 0);
1398                 break;
1399
1400         case SND_SOC_DAPM_PRE_PMD:
1401                 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1402                         RT5639_L_MUTE | RT5639_R_MUTE,
1403                         RT5639_L_MUTE | RT5639_R_MUTE);
1404                 rt5639_index_update_bits(codec,
1405                         RT5639_CLSD_INT_REG1, 0xf000, 0x0000);
1406                 snd_soc_update_bits(codec, RT5639_PWR_DIG1,
1407                         RT5639_PWR_CLS_D, 0);
1408                 break;
1409
1410         default:
1411                 return 0;
1412         }
1413
1414         return 0;
1415 }
1416
1417 static int rt5639_set_dmic1_event(struct snd_soc_dapm_widget *w,
1418         struct snd_kcontrol *kcontrol, int event)
1419 {
1420         struct snd_soc_codec *codec = w->codec;
1421
1422         switch (event) {
1423         case SND_SOC_DAPM_PRE_PMU:
1424                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
1425                         RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK,
1426                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP3_PIN_DMIC1_SDA);
1427                 snd_soc_update_bits(codec, RT5639_DMIC,
1428                         RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK |
1429                         RT5639_DMIC_1_DP_MASK,
1430                         RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING |
1431                         RT5639_DMIC_1_DP_IN1P);
1432                 snd_soc_update_bits(codec, RT5639_DMIC,
1433                         RT5639_DMIC_1_EN_MASK, RT5639_DMIC_1_EN);
1434         default:
1435                 return 0;
1436         }
1437
1438         return 0;
1439 }
1440
1441 static int rt5639_set_dmic2_event(struct snd_soc_dapm_widget *w,
1442         struct snd_kcontrol *kcontrol, int event)
1443 {
1444         struct snd_soc_codec *codec = w->codec;
1445
1446         switch (event) {
1447         case SND_SOC_DAPM_PRE_PMU:
1448                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
1449                         RT5639_GP2_PIN_MASK | RT5639_GP4_PIN_MASK,
1450                         RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP4_PIN_DMIC2_SDA);
1451                 snd_soc_update_bits(codec, RT5639_DMIC,
1452                         RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK |
1453                         RT5639_DMIC_2_DP_MASK,
1454                         RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING |
1455                         RT5639_DMIC_2_DP_IN1N);
1456                 snd_soc_update_bits(codec, RT5639_DMIC,
1457                         RT5639_DMIC_2_EN_MASK, RT5639_DMIC_2_EN);
1458         default:
1459                 return 0;
1460         }
1461
1462         return 0;
1463 }
1464
1465 #if USE_ONEBIT_DEPOP
1466 static void hp_amp_power(struct snd_soc_codec *codec, int on)
1467 {
1468         static int hp_amp_power_count;
1469         dev_info(codec->dev,
1470                 "one bit hp_amp_power on=%d hp_amp_power_count=%d\n",
1471                 on, hp_amp_power_count);
1472
1473         if (on) {
1474                 if (hp_amp_power_count <= 0) {
1475                         /* depop parameters */
1476                         rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1477                                 0x0700, 0x0200);
1478                         snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1479                                 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
1480                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1481                                 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK
1482                                 | RT5639_HP_CB_MASK, RT5639_HP_CP_PU
1483                                 | RT5639_HP_SG_DIS | RT5639_HP_CB_PU);
1484                         /* headphone amp power on */
1485                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1486                                 RT5639_PWR_FV1 | RT5639_PWR_FV2, 0);
1487                         msleep(5);
1488
1489                         snd_soc_update_bits(codec, RT5639_PWR_VOL,
1490                                 RT5639_PWR_HV_L | RT5639_PWR_HV_R,
1491                                 RT5639_PWR_HV_L | RT5639_PWR_HV_R);
1492                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1493                                 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1494                                 | RT5639_PWR_HA, RT5639_PWR_HP_L
1495                                 | RT5639_PWR_HP_R | RT5639_PWR_HA);
1496                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1497                                 RT5639_PWR_FV1 | RT5639_PWR_FV2 ,
1498                                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
1499                         snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1500                                 RT5639_DEPOP_MASK | RT5639_DIG_DP_MASK,
1501                                 RT5639_DEPOP_AUTO | RT5639_DIG_DP_EN);
1502                         snd_soc_update_bits(codec, RT5639_CHARGE_PUMP,
1503                                 RT5639_PM_HP_MASK, RT5639_PM_HP_HV);
1504                         snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1505                                 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK
1506                                 | RT5639_CP_FQ3_MASK,
1507                                 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ1_SFT) |
1508                                 (RT5639_CP_FQ_24_KHZ << RT5639_CP_FQ2_SFT) |
1509                                 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ3_SFT));
1510                         rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0x1c00);
1511                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1512                                 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK,
1513                                 RT5639_HP_CP_PD | RT5639_HP_SG_EN);
1514                         rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1515                                                 0x0700, 0x0400);
1516                 }
1517                 hp_amp_power_count++;
1518         } else {
1519                 hp_amp_power_count--;
1520                 if (hp_amp_power_count <= 0) {
1521                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1522                                 RT5639_HP_CB_MASK, RT5639_HP_CB_PD);
1523                         msleep(30);
1524                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1525                                 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1526                                 | RT5639_PWR_HA, 0);
1527                         snd_soc_write(codec, RT5639_DEPOP_M2, 0x3100);
1528                 }
1529         }
1530 }
1531
1532 static void rt5639_pmu_depop(struct snd_soc_codec *codec)
1533 {
1534         hp_amp_power(codec, 1);
1535         /* headphone unmute sequence */
1536         msleep(5);
1537         snd_soc_update_bits(codec, RT5639_HP_VOL,
1538                 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1539         msleep(65);
1540         /*snd_soc_update_bits(codec, RT5639_HP_CALIB_AMP_DET,
1541                 RT5639_HPD_PS_MASK, RT5639_HPD_PS_EN);*/
1542 }
1543
1544 static void rt5639_pmd_depop(struct snd_soc_codec *codec)
1545 {
1546         snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1547                 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1548                 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ1_SFT) |
1549                 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1550                 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ3_SFT));
1551         rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0x7c00);
1552         /*snd_soc_update_bits(codec, RT5639_HP_CALIB_AMP_DET,
1553                 RT5639_HPD_PS_MASK, RT5639_HPD_PS_DIS); */
1554         snd_soc_update_bits(codec, RT5639_HP_VOL,
1555                 RT5639_L_MUTE | RT5639_R_MUTE,
1556                 RT5639_L_MUTE | RT5639_R_MUTE);
1557         msleep(50);
1558         hp_amp_power(codec, 0);
1559 }
1560
1561 #else /*seq*/
1562 static void hp_amp_power(struct snd_soc_codec *codec, int on)
1563 {
1564         static int hp_amp_power_count;
1565         dev_info(codec->dev, "hp_amp_power on=%d hp_amp_power_count=%d\n",
1566                 on, hp_amp_power_count);
1567
1568         if (on) {
1569                 if (hp_amp_power_count <= 0) {
1570                         /* depop parameters */
1571                         rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1572                                 0x0700, 0x0200);
1573                         snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1574                                 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
1575                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1576                                 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK
1577                                 | RT5639_HP_CB_MASK,
1578                                 RT5639_HP_CP_PU | RT5639_HP_SG_DIS
1579                                 | RT5639_HP_CB_PU);
1580                         /* headphone amp power on */
1581                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1582                                 RT5639_PWR_FV1 | RT5639_PWR_FV2 , 0);
1583                         snd_soc_update_bits(codec, RT5639_PWR_VOL,
1584                                 RT5639_PWR_HV_L | RT5639_PWR_HV_R,
1585                                 RT5639_PWR_HV_L | RT5639_PWR_HV_R);
1586                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1587                                 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1588                                 | RT5639_PWR_HA,
1589                                 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1590                                 | RT5639_PWR_HA);
1591                         msleep(5);
1592                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1593                                 RT5639_PWR_FV1 | RT5639_PWR_FV2,
1594                                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
1595
1596                         snd_soc_update_bits(codec, RT5639_CHARGE_PUMP,
1597                                 RT5639_PM_HP_MASK, RT5639_PM_HP_HV);
1598                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1599                                 RT5639_HP_CO_MASK | RT5639_HP_SG_MASK,
1600                                 RT5639_HP_CO_EN | RT5639_HP_SG_EN);
1601                         rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1602                                 0x0700, 0x0400);
1603                 }
1604                 hp_amp_power_count++;
1605         } else {
1606                 hp_amp_power_count--;
1607                 if (hp_amp_power_count <= 0) {
1608                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1609                                 RT5639_HP_SG_MASK | RT5639_HP_L_SMT_MASK |
1610                                 RT5639_HP_R_SMT_MASK, RT5639_HP_SG_DIS |
1611                                 RT5639_HP_L_SMT_DIS | RT5639_HP_R_SMT_DIS);
1612                         /* headphone amp power down */
1613                         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1614                                 RT5639_SMT_TRIG_MASK | RT5639_HP_CD_PD_MASK |
1615                                 RT5639_HP_CO_MASK | RT5639_HP_CP_MASK |
1616                                 RT5639_HP_SG_MASK | RT5639_HP_CB_MASK,
1617                                 RT5639_SMT_TRIG_DIS | RT5639_HP_CD_PD_EN |
1618                                 RT5639_HP_CO_DIS | RT5639_HP_CP_PD |
1619                                 RT5639_HP_SG_EN | RT5639_HP_CB_PD);
1620                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1621                                 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1622                                 | RT5639_PWR_HA,
1623                                 0);
1624                 }
1625         }
1626 }
1627
1628 static void rt5639_pmu_depop(struct snd_soc_codec *codec)
1629 {
1630         hp_amp_power(codec, 1);
1631         /* headphone unmute sequence */
1632         snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1633                 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1634                 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ1_SFT) |
1635                 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1636                 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ3_SFT));
1637         rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0xfc00);
1638         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1639                 RT5639_SMT_TRIG_MASK, RT5639_SMT_TRIG_EN);
1640         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1641                 RT5639_RSTN_MASK, RT5639_RSTN_EN);
1642         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1643                 RT5639_RSTN_MASK | RT5639_HP_L_SMT_MASK | RT5639_HP_R_SMT_MASK,
1644                 RT5639_RSTN_DIS | RT5639_HP_L_SMT_EN | RT5639_HP_R_SMT_EN);
1645         snd_soc_update_bits(codec, RT5639_HP_VOL,
1646                 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1647         msleep(40);
1648         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1649                 RT5639_HP_SG_MASK | RT5639_HP_L_SMT_MASK |
1650                 RT5639_HP_R_SMT_MASK, RT5639_HP_SG_DIS |
1651                 RT5639_HP_L_SMT_DIS | RT5639_HP_R_SMT_DIS);
1652
1653 }
1654
1655 static void rt5639_pmd_depop(struct snd_soc_codec *codec)
1656 {
1657         /* headphone mute sequence */
1658         snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1659                 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1660                 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ1_SFT) |
1661                 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1662                 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ3_SFT));
1663         rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0xfc00);
1664         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1665                 RT5639_HP_SG_MASK, RT5639_HP_SG_EN);
1666         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1667                 RT5639_RSTP_MASK, RT5639_RSTP_EN);
1668         snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1669                 RT5639_RSTP_MASK | RT5639_HP_L_SMT_MASK |
1670                 RT5639_HP_R_SMT_MASK, RT5639_RSTP_DIS |
1671                 RT5639_HP_L_SMT_EN | RT5639_HP_R_SMT_EN);
1672
1673         snd_soc_update_bits(codec, RT5639_HP_VOL,
1674                 RT5639_L_MUTE | RT5639_R_MUTE, RT5639_L_MUTE | RT5639_R_MUTE);
1675         msleep(30);
1676
1677         hp_amp_power(codec, 0);
1678 }
1679 #endif
1680
1681 static int rt5639_hp_event(struct snd_soc_dapm_widget *w,
1682         struct snd_kcontrol *kcontrol, int event)
1683 {
1684         struct snd_soc_codec *codec = w->codec;
1685
1686         switch (event) {
1687         case SND_SOC_DAPM_POST_PMU:
1688 #ifdef USE_EQ
1689                 rt5639_update_eqmode(codec, HP);
1690 #endif
1691                 rt5639_pmu_depop(codec);
1692                 break;
1693
1694         case SND_SOC_DAPM_PRE_PMD:
1695                 rt5639_pmd_depop(codec);
1696                 break;
1697
1698         default:
1699                 return 0;
1700         }
1701
1702         return 0;
1703 }
1704
1705 static int rt5639_mono_event(struct snd_soc_dapm_widget *w,
1706         struct snd_kcontrol *kcontrol, int event)
1707 {
1708         struct snd_soc_codec *codec = w->codec;
1709
1710         switch (event) {
1711         case SND_SOC_DAPM_POST_PMU:
1712                 snd_soc_update_bits(codec, RT5639_MONO_OUT,
1713                                 RT5639_L_MUTE, 0);
1714                 break;
1715
1716         case SND_SOC_DAPM_PRE_PMD:
1717                 snd_soc_update_bits(codec, RT5639_MONO_OUT,
1718                         RT5639_L_MUTE, RT5639_L_MUTE);
1719                 break;
1720
1721         default:
1722                 return 0;
1723         }
1724
1725         return 0;
1726 }
1727
1728 static int rt5639_lout_event(struct snd_soc_dapm_widget *w,
1729         struct snd_kcontrol *kcontrol, int event)
1730 {
1731         struct snd_soc_codec *codec = w->codec;
1732
1733         switch (event) {
1734         case SND_SOC_DAPM_POST_PMU:
1735                 hp_amp_power(codec, 1);
1736                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1737                         RT5639_PWR_LM, RT5639_PWR_LM);
1738                 snd_soc_update_bits(codec, RT5639_OUTPUT,
1739                         RT5639_L_MUTE | RT5639_R_MUTE, 0);
1740                 break;
1741
1742         case SND_SOC_DAPM_PRE_PMD:
1743                 snd_soc_update_bits(codec, RT5639_OUTPUT,
1744                         RT5639_L_MUTE | RT5639_R_MUTE,
1745                         RT5639_L_MUTE | RT5639_R_MUTE);
1746                 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1747                         RT5639_PWR_LM, 0);
1748                 hp_amp_power(codec, 0);
1749                 break;
1750
1751         default:
1752                 return 0;
1753         }
1754
1755         return 0;
1756 }
1757
1758 static int rt5639_index_sync_event(struct snd_soc_dapm_widget *w,
1759         struct snd_kcontrol *kcontrol, int event)
1760 {
1761         struct snd_soc_codec *codec = w->codec;
1762
1763         switch (event) {
1764         case SND_SOC_DAPM_PRE_PMU:
1765                 rt5639_index_write(codec, RT5639_MIXER_INT_REG,
1766                         snd_soc_read(codec, RT5639_DUMMY_PR3F));
1767
1768                 break;
1769         default:
1770                 return 0;
1771         }
1772
1773         return 0;
1774 }
1775
1776 static int rt5639_dac1_event(struct snd_soc_dapm_widget *w,
1777         struct snd_kcontrol *kcontrol, int event)
1778 {
1779 #ifdef USE_EQ
1780         struct snd_soc_codec *codec = w->codec;
1781 #endif
1782
1783         switch (event) {
1784         case SND_SOC_DAPM_PRE_PMD:
1785 #ifdef USE_EQ
1786                 rt5639_update_eqmode(codec, NORMAL);
1787 #endif
1788                 break;
1789         default:
1790                 return 0;
1791         }
1792
1793         return 0;
1794 }
1795
1796 static const struct snd_soc_dapm_widget rt5639_dapm_widgets[] = {
1797         SND_SOC_DAPM_SUPPLY("PLL1", RT5639_PWR_ANLG2,
1798                         RT5639_PWR_PLL_BIT, 0, NULL, 0),
1799         /* Input Side */
1800         /* micbias */
1801         SND_SOC_DAPM_SUPPLY("LDO2", RT5639_PWR_ANLG1,
1802                         RT5639_PWR_LDO2_BIT, 0, NULL, 0),
1803         SND_SOC_DAPM_MICBIAS("micbias1", RT5639_PWR_ANLG2,
1804                         RT5639_PWR_MB1_BIT, 0),
1805         SND_SOC_DAPM_MICBIAS("micbias2", RT5639_PWR_ANLG2,
1806                         RT5639_PWR_MB2_BIT, 0),
1807         /* Input Lines */
1808         SND_SOC_DAPM_INPUT("DMIC1"),
1809         SND_SOC_DAPM_INPUT("DMIC2"),
1810
1811         SND_SOC_DAPM_INPUT("IN1P"),
1812         SND_SOC_DAPM_INPUT("IN1N"),
1813         SND_SOC_DAPM_INPUT("IN2P"),
1814         SND_SOC_DAPM_INPUT("IN2N"),
1815         SND_SOC_DAPM_INPUT("IN3P"),
1816         SND_SOC_DAPM_INPUT("IN3N"),
1817         SND_SOC_DAPM_PGA_E("DMIC L1", SND_SOC_NOPM, 0, 0, NULL, 0,
1818                 rt5639_set_dmic1_event, SND_SOC_DAPM_PRE_PMU),
1819         SND_SOC_DAPM_PGA_E("DMIC R1", SND_SOC_NOPM, 0, 0, NULL, 0,
1820                 rt5639_set_dmic1_event, SND_SOC_DAPM_PRE_PMU),
1821         SND_SOC_DAPM_PGA_E("DMIC L2", SND_SOC_NOPM, 0, 0, NULL, 0,
1822                 rt5639_set_dmic2_event, SND_SOC_DAPM_PRE_PMU),
1823         SND_SOC_DAPM_PGA_E("DMIC R2", SND_SOC_NOPM, 0, 0, NULL, 0,
1824                 rt5639_set_dmic2_event, SND_SOC_DAPM_PRE_PMU),
1825         SND_SOC_DAPM_SUPPLY("DMIC CLK", SND_SOC_NOPM, 0, 0,
1826                 set_dmic_clk, SND_SOC_DAPM_PRE_PMU),
1827         /* Boost */
1828         SND_SOC_DAPM_PGA("BST1", RT5639_PWR_ANLG2,
1829                 RT5639_PWR_BST1_BIT, 0, NULL, 0),
1830         SND_SOC_DAPM_PGA("BST2", RT5639_PWR_ANLG2,
1831                 RT5639_PWR_BST4_BIT, 0, NULL, 0),
1832         SND_SOC_DAPM_PGA("BST3", RT5639_PWR_ANLG2,
1833                 RT5639_PWR_BST2_BIT, 0, NULL, 0),
1834
1835         /* Input Volume */
1836         SND_SOC_DAPM_PGA("INL VOL", RT5639_PWR_VOL,
1837                 RT5639_PWR_IN_L_BIT, 0, NULL, 0),
1838         SND_SOC_DAPM_PGA("INR VOL", RT5639_PWR_VOL,
1839                 RT5639_PWR_IN_R_BIT, 0, NULL, 0),
1840         /* IN Mux */
1841         SND_SOC_DAPM_MUX("INL Mux", SND_SOC_NOPM, 0, 0, &rt5639_inl_mux),
1842         SND_SOC_DAPM_MUX("INR Mux", SND_SOC_NOPM, 0, 0, &rt5639_inr_mux),
1843         /* REC Mixer */
1844         SND_SOC_DAPM_MIXER("RECMIXL", RT5639_PWR_MIXER, RT5639_PWR_RM_L_BIT, 0,
1845                         rt5639_rec_l_mix, ARRAY_SIZE(rt5639_rec_l_mix)),
1846         SND_SOC_DAPM_MIXER("RECMIXR", RT5639_PWR_MIXER, RT5639_PWR_RM_R_BIT, 0,
1847                         rt5639_rec_r_mix, ARRAY_SIZE(rt5639_rec_r_mix)),
1848         /* ADCs */
1849         SND_SOC_DAPM_ADC("ADC L", NULL, SND_SOC_NOPM,
1850                 0, 0),
1851         SND_SOC_DAPM_ADC("ADC R", NULL, SND_SOC_NOPM,
1852                 0, 0),
1853
1854         SND_SOC_DAPM_SUPPLY("ADC L power", RT5639_PWR_DIG1,
1855                         RT5639_PWR_ADC_L_BIT, 0, NULL, 0),
1856         SND_SOC_DAPM_SUPPLY("ADC R power", RT5639_PWR_DIG1,
1857                         RT5639_PWR_ADC_R_BIT, 0, NULL, 0),
1858         SND_SOC_DAPM_SUPPLY("ADC clock", SND_SOC_NOPM, 0, 0, rt5639_adc_event,
1859                         SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
1860         /* ADC Mux */
1861         SND_SOC_DAPM_MUX("Stereo ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1862                                 &rt5639_sto_adc_l2_mux),
1863         SND_SOC_DAPM_MUX("Stereo ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1864                                 &rt5639_sto_adc_r2_mux),
1865         SND_SOC_DAPM_MUX("Stereo ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1866                                 &rt5639_sto_adc_l1_mux),
1867         SND_SOC_DAPM_MUX("Stereo ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1868                                 &rt5639_sto_adc_r1_mux),
1869         SND_SOC_DAPM_MUX("Mono ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1870                                 &rt5639_mono_adc_l2_mux),
1871         SND_SOC_DAPM_MUX("Mono ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1872                                 &rt5639_mono_adc_l1_mux),
1873         SND_SOC_DAPM_MUX("Mono ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1874                                 &rt5639_mono_adc_r1_mux),
1875         SND_SOC_DAPM_MUX("Mono ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1876                                 &rt5639_mono_adc_r2_mux),
1877         /* ADC Mixer */
1878         SND_SOC_DAPM_SUPPLY("stereo filter", RT5639_PWR_DIG2,
1879                 RT5639_PWR_ADC_SF_BIT, 0, NULL, 0),
1880         SND_SOC_DAPM_MIXER("Stereo ADC MIXL", SND_SOC_NOPM, 0, 0,
1881                 rt5639_sto_adc_l_mix, ARRAY_SIZE(rt5639_sto_adc_l_mix)),
1882         SND_SOC_DAPM_MIXER("Stereo ADC MIXR", SND_SOC_NOPM, 0, 0,
1883                 rt5639_sto_adc_r_mix, ARRAY_SIZE(rt5639_sto_adc_r_mix)),
1884         SND_SOC_DAPM_SUPPLY("mono left filter", RT5639_PWR_DIG2,
1885                 RT5639_PWR_ADC_MF_L_BIT, 0, NULL, 0),
1886         SND_SOC_DAPM_MIXER_E("Mono ADC MIXL", SND_SOC_NOPM, 0, 0,
1887                 rt5639_mono_adc_l_mix, ARRAY_SIZE(rt5639_mono_adc_l_mix),
1888                 rt5639_mono_adcl_event,
1889                 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1890         SND_SOC_DAPM_SUPPLY("mono right filter", RT5639_PWR_DIG2,
1891                 RT5639_PWR_ADC_MF_R_BIT, 0, NULL, 0),
1892         SND_SOC_DAPM_MIXER_E("Mono ADC MIXR", SND_SOC_NOPM, 0, 0,
1893                 rt5639_mono_adc_r_mix, ARRAY_SIZE(rt5639_mono_adc_r_mix),
1894                 rt5639_mono_adcr_event,
1895                 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1896
1897         /* IF2 Mux */
1898         SND_SOC_DAPM_MUX("IF2 ADC L Mux", SND_SOC_NOPM, 0, 0,
1899                                 &rt5639_if2_adc_l_mux),
1900         SND_SOC_DAPM_MUX("IF2 ADC R Mux", SND_SOC_NOPM, 0, 0,
1901                                 &rt5639_if2_adc_r_mux),
1902
1903         /* Digital Interface */
1904         SND_SOC_DAPM_SUPPLY("I2S1", RT5639_PWR_DIG1,
1905                 RT5639_PWR_I2S1_BIT, 0, NULL, 0),
1906         SND_SOC_DAPM_PGA("IF1 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1907         SND_SOC_DAPM_PGA("IF1 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1908         SND_SOC_DAPM_PGA("IF1 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1909         SND_SOC_DAPM_PGA("IF1 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1910         SND_SOC_DAPM_PGA("IF1 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1911         SND_SOC_DAPM_PGA("IF1 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1912         SND_SOC_DAPM_SUPPLY("I2S2", RT5639_PWR_DIG1,
1913                 RT5639_PWR_I2S2_BIT, 0, NULL, 0),
1914         SND_SOC_DAPM_PGA("IF2 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1915         SND_SOC_DAPM_PGA("IF2 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1916         SND_SOC_DAPM_PGA("IF2 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1917         SND_SOC_DAPM_PGA("IF2 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1918         SND_SOC_DAPM_PGA("IF2 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1919         SND_SOC_DAPM_PGA("IF2 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1920         SND_SOC_DAPM_SUPPLY("I2S3", RT5639_PWR_DIG1,
1921                 RT5639_PWR_I2S3_BIT, 0, NULL, 0),
1922         SND_SOC_DAPM_PGA("IF3 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
1923         SND_SOC_DAPM_PGA("IF3 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1924         SND_SOC_DAPM_PGA("IF3 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1925         SND_SOC_DAPM_PGA("IF3 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
1926         SND_SOC_DAPM_PGA("IF3 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
1927         SND_SOC_DAPM_PGA("IF3 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
1928
1929         /* Digital Interface Select */
1930         SND_SOC_DAPM_MUX("DAI1 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1931         SND_SOC_DAPM_MUX("DAI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1932         SND_SOC_DAPM_MUX("DAI1 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1933         SND_SOC_DAPM_MUX("DAI1 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1934         SND_SOC_DAPM_MUX("SDI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
1935
1936         SND_SOC_DAPM_MUX("DAI2 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1937         SND_SOC_DAPM_MUX("DAI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1938         SND_SOC_DAPM_MUX("DAI2 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1939         SND_SOC_DAPM_MUX("DAI2 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1940         SND_SOC_DAPM_MUX("SDI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
1941
1942         SND_SOC_DAPM_MUX("DAI3 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1943         SND_SOC_DAPM_MUX("DAI3 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
1944
1945         /* Audio Interface */
1946         SND_SOC_DAPM_AIF_IN("AIF1RX", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1947         SND_SOC_DAPM_AIF_OUT("AIF1TX", "AIF1 Capture", 0, SND_SOC_NOPM, 0, 0),
1948         SND_SOC_DAPM_AIF_IN("AIF2RX", "AIF2 Playback", 0, SND_SOC_NOPM, 0, 0),
1949         SND_SOC_DAPM_AIF_OUT("AIF2TX", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
1950         SND_SOC_DAPM_AIF_IN("AIF3RX", "AIF3 Playback", 0, SND_SOC_NOPM, 0, 0),
1951         SND_SOC_DAPM_AIF_OUT("AIF3TX", "AIF3 Capture", 0, SND_SOC_NOPM, 0, 0),
1952
1953         /* Audio DSP */
1954         SND_SOC_DAPM_PGA("Audio DSP", SND_SOC_NOPM, 0, 0, NULL, 0),
1955
1956         /* ANC */
1957         SND_SOC_DAPM_PGA("ANC", SND_SOC_NOPM, 0, 0, NULL, 0),
1958
1959         /* Output Side */
1960         /* DAC mixer before sound effect  */
1961         SND_SOC_DAPM_MIXER("DAC MIXL", SND_SOC_NOPM, 0, 0,
1962                 rt5639_dac_l_mix, ARRAY_SIZE(rt5639_dac_l_mix)),
1963         SND_SOC_DAPM_MIXER("DAC MIXR", SND_SOC_NOPM, 0, 0,
1964                 rt5639_dac_r_mix, ARRAY_SIZE(rt5639_dac_r_mix)),
1965
1966         /* DAC2 channel Mux */
1967         SND_SOC_DAPM_MUX("DAC L2 Mux", SND_SOC_NOPM, 0, 0,
1968                                 &rt5639_dac_l2_mux),
1969         SND_SOC_DAPM_MUX("DAC R2 Mux", SND_SOC_NOPM, 0, 0,
1970                                 &rt5639_dac_r2_mux),
1971         SND_SOC_DAPM_PGA("DAC L2 Volume", RT5639_PWR_DIG1,
1972                         RT5639_PWR_DAC_L2_BIT, 0, NULL, 0),
1973         SND_SOC_DAPM_PGA("DAC R2 Volume", RT5639_PWR_DIG1,
1974                         RT5639_PWR_DAC_R2_BIT, 0, NULL, 0),
1975
1976         /* DAC Mixer */
1977         SND_SOC_DAPM_MIXER("Stereo DAC MIXL", SND_SOC_NOPM, 0, 0,
1978                 rt5639_sto_dac_l_mix, ARRAY_SIZE(rt5639_sto_dac_l_mix)),
1979         SND_SOC_DAPM_MIXER("Stereo DAC MIXR", SND_SOC_NOPM, 0, 0,
1980                 rt5639_sto_dac_r_mix, ARRAY_SIZE(rt5639_sto_dac_r_mix)),
1981         SND_SOC_DAPM_MIXER("Mono DAC MIXL", SND_SOC_NOPM, 0, 0,
1982                 rt5639_mono_dac_l_mix, ARRAY_SIZE(rt5639_mono_dac_l_mix)),
1983         SND_SOC_DAPM_MIXER("Mono DAC MIXR", SND_SOC_NOPM, 0, 0,
1984                 rt5639_mono_dac_r_mix, ARRAY_SIZE(rt5639_mono_dac_r_mix)),
1985         SND_SOC_DAPM_MIXER("DIG MIXL", SND_SOC_NOPM, 0, 0,
1986                 rt5639_dig_l_mix, ARRAY_SIZE(rt5639_dig_l_mix)),
1987         SND_SOC_DAPM_MIXER("DIG MIXR", SND_SOC_NOPM, 0, 0,
1988                 rt5639_dig_r_mix, ARRAY_SIZE(rt5639_dig_r_mix)),
1989         SND_SOC_DAPM_MUX_E("Mono dacr Mux", SND_SOC_NOPM, 0, 0,
1990                 &rt5639_dacr2_mux, rt5639_index_sync_event,
1991                 SND_SOC_DAPM_PRE_PMU),
1992
1993         /* DACs */
1994         SND_SOC_DAPM_DAC_E("DAC L1", NULL, RT5639_PWR_DIG1,
1995                         RT5639_PWR_DAC_L1_BIT, 0, rt5639_dac1_event,
1996                         SND_SOC_DAPM_PRE_PMD),
1997         SND_SOC_DAPM_DAC_E("DAC R1", NULL, RT5639_PWR_DIG1,
1998                         RT5639_PWR_DAC_R1_BIT, 0, rt5639_dac1_event,
1999                         SND_SOC_DAPM_PRE_PMD),
2000
2001         /* SPK/OUT Mixer */
2002         SND_SOC_DAPM_MIXER("SPK MIXL", RT5639_PWR_MIXER, RT5639_PWR_SM_L_BIT,
2003                 0, rt5639_spk_l_mix, ARRAY_SIZE(rt5639_spk_l_mix)),
2004         SND_SOC_DAPM_MIXER("SPK MIXR", RT5639_PWR_MIXER, RT5639_PWR_SM_R_BIT,
2005                 0, rt5639_spk_r_mix, ARRAY_SIZE(rt5639_spk_r_mix)),
2006         SND_SOC_DAPM_MIXER("OUT MIXL", RT5639_PWR_MIXER, RT5639_PWR_OM_L_BIT,
2007                 0, rt5639_out_l_mix, ARRAY_SIZE(rt5639_out_l_mix)),
2008         SND_SOC_DAPM_MIXER("OUT MIXR", RT5639_PWR_MIXER, RT5639_PWR_OM_R_BIT,
2009                 0, rt5639_out_r_mix, ARRAY_SIZE(rt5639_out_r_mix)),
2010         /* Ouput Volume */
2011         SND_SOC_DAPM_PGA("SPKVOL L", RT5639_PWR_VOL,
2012                 RT5639_PWR_SV_L_BIT, 0, NULL, 0),
2013         SND_SOC_DAPM_PGA("SPKVOL R", RT5639_PWR_VOL,
2014                 RT5639_PWR_SV_R_BIT, 0, NULL, 0),
2015         SND_SOC_DAPM_PGA("OUTVOL L", RT5639_PWR_VOL,
2016                 RT5639_PWR_OV_L_BIT, 0, NULL, 0),
2017         SND_SOC_DAPM_PGA("OUTVOL R", RT5639_PWR_VOL,
2018                 RT5639_PWR_OV_R_BIT, 0, NULL, 0),
2019         SND_SOC_DAPM_PGA("HPOVOL L", RT5639_PWR_VOL,
2020                 RT5639_PWR_HV_L_BIT, 0, NULL, 0),
2021         SND_SOC_DAPM_PGA("HPOVOL R", RT5639_PWR_VOL,
2022                 RT5639_PWR_HV_R_BIT, 0, NULL, 0),
2023         SND_SOC_DAPM_PGA("DAC 1", SND_SOC_NOPM,
2024                 0, 0, NULL, 0),
2025         SND_SOC_DAPM_PGA("HPOVOL", SND_SOC_NOPM,
2026                 0, 0, NULL, 0),
2027         /* SPO/HPO/LOUT/Mono Mixer */
2028         SND_SOC_DAPM_MIXER("SPOL MIX", SND_SOC_NOPM, 0,
2029                 0, rt5639_spo_l_mix, ARRAY_SIZE(rt5639_spo_l_mix)),
2030         SND_SOC_DAPM_MIXER("SPOR MIX", SND_SOC_NOPM, 0,
2031                 0, rt5639_spo_r_mix, ARRAY_SIZE(rt5639_spo_r_mix)),
2032         SND_SOC_DAPM_MIXER("HPO MIX", SND_SOC_NOPM, 0, 0,
2033                 rt5639_hpo_mix, ARRAY_SIZE(rt5639_hpo_mix)),
2034         SND_SOC_DAPM_MIXER("LOUT MIX", SND_SOC_NOPM, 0, 0,
2035                 rt5639_lout_mix, ARRAY_SIZE(rt5639_lout_mix)),
2036
2037         SND_SOC_DAPM_PGA_S("HP amp", 1, SND_SOC_NOPM, 0, 0,
2038                 rt5639_hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2039         SND_SOC_DAPM_PGA_S("SPK amp", 1, SND_SOC_NOPM, 0, 0,
2040                 rt5639_spk_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2041         SND_SOC_DAPM_PGA_S("LOUT amp", 1, SND_SOC_NOPM, 0, 0,
2042                 rt5639_lout_event,
2043                 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2044
2045         /* Output Lines */
2046         SND_SOC_DAPM_OUTPUT("SPOLP"),
2047         SND_SOC_DAPM_OUTPUT("SPOLN"),
2048         SND_SOC_DAPM_OUTPUT("SPORP"),
2049         SND_SOC_DAPM_OUTPUT("SPORN"),
2050         SND_SOC_DAPM_OUTPUT("HPOL"),
2051         SND_SOC_DAPM_OUTPUT("HPOR"),
2052         SND_SOC_DAPM_OUTPUT("LOUTL"),
2053         SND_SOC_DAPM_OUTPUT("LOUTR"),
2054 };
2055
2056 static const struct snd_soc_dapm_route rt5639_dapm_routes[] = {
2057         {"IN1P", NULL, "LDO2"},
2058         {"IN2P", NULL, "LDO2"},
2059         {"IN3P", NULL, "LDO2"},
2060
2061         {"DMIC L1", NULL, "DMIC1"},
2062         {"DMIC R1", NULL, "DMIC1"},
2063         {"DMIC L2", NULL, "DMIC2"},
2064         {"DMIC R2", NULL, "DMIC2"},
2065
2066         {"BST1", NULL, "IN1P"},
2067         {"BST1", NULL, "IN1N"},
2068         {"BST2", NULL, "IN2P"},
2069         {"BST2", NULL, "IN2N"},
2070         {"BST3", NULL, "IN3P"},
2071         {"BST3", NULL, "IN3N"},
2072
2073         {"INL VOL", NULL, "IN2P"},
2074         {"INR VOL", NULL, "IN2N"},
2075
2076         {"RECMIXL", "HPOL Switch", "HPOL"},
2077         {"RECMIXL", "INL Switch", "INL VOL"},
2078         {"RECMIXL", "BST3 Switch", "BST3"},
2079         {"RECMIXL", "BST2 Switch", "BST2"},
2080         {"RECMIXL", "BST1 Switch", "BST1"},
2081         {"RECMIXL", "OUT MIXL Switch", "OUT MIXL"},
2082
2083         {"RECMIXR", "HPOR Switch", "HPOR"},
2084         {"RECMIXR", "INR Switch", "INR VOL"},
2085         {"RECMIXR", "BST3 Switch", "BST3"},
2086         {"RECMIXR", "BST2 Switch", "BST2"},
2087         {"RECMIXR", "BST1 Switch", "BST1"},
2088         {"RECMIXR", "OUT MIXR Switch", "OUT MIXR"},
2089
2090         {"ADC L", NULL, "RECMIXL"},
2091         {"ADC L", NULL, "ADC L power"},
2092         {"ADC L", NULL, "ADC clock"},
2093         {"ADC R", NULL, "RECMIXR"},
2094         {"ADC R", NULL, "ADC R power"},
2095         {"ADC R", NULL, "ADC clock"},
2096
2097         {"DMIC L1", NULL, "DMIC CLK"},
2098         {"DMIC R1", NULL, "DMIC CLK"},
2099         {"DMIC L2", NULL, "DMIC CLK"},
2100         {"DMIC R2", NULL, "DMIC CLK"},
2101
2102         {"Stereo ADC L2 Mux", "DMIC1", "DMIC L1"},
2103         {"Stereo ADC L2 Mux", "DMIC2", "DMIC L2"},
2104         {"Stereo ADC L2 Mux", "DIG MIX", "DIG MIXL"},
2105         {"Stereo ADC L1 Mux", "ADC", "ADC L"},
2106         {"Stereo ADC L1 Mux", "DIG MIX", "DIG MIXL"},
2107
2108         {"Stereo ADC R1 Mux", "ADC", "ADC R"},
2109         {"Stereo ADC R1 Mux", "DIG MIX", "DIG MIXR"},
2110         {"Stereo ADC R2 Mux", "DMIC1", "DMIC R1"},
2111         {"Stereo ADC R2 Mux", "DMIC2", "DMIC R2"},
2112         {"Stereo ADC R2 Mux", "DIG MIX", "DIG MIXR"},
2113
2114         {"Mono ADC L2 Mux", "DMIC L1", "DMIC L1"},
2115         {"Mono ADC L2 Mux", "DMIC L2", "DMIC L2"},
2116         {"Mono ADC L2 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
2117         {"Mono ADC L1 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
2118         {"Mono ADC L1 Mux", "ADCL", "ADC L"},
2119
2120         {"Mono ADC R1 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
2121         {"Mono ADC R1 Mux", "ADCR", "ADC R"},
2122         {"Mono ADC R2 Mux", "DMIC R1", "DMIC R1"},
2123         {"Mono ADC R2 Mux", "DMIC R2", "DMIC R2"},
2124         {"Mono ADC R2 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
2125
2126         {"Stereo ADC MIXL", "ADC1 Switch", "Stereo ADC L1 Mux"},
2127         {"Stereo ADC MIXL", "ADC2 Switch", "Stereo ADC L2 Mux"},
2128         {"Stereo ADC MIXL", NULL, "stereo filter"},
2129         {"stereo filter", NULL, "PLL1", check_sysclk1_source},
2130
2131         {"Stereo ADC MIXR", "ADC1 Switch", "Stereo ADC R1 Mux"},
2132         {"Stereo ADC MIXR", "ADC2 Switch", "Stereo ADC R2 Mux"},
2133         {"Stereo ADC MIXR", NULL, "stereo filter"},
2134         {"stereo filter", NULL, "PLL1", check_sysclk1_source},
2135
2136         {"Mono ADC MIXL", "ADC1 Switch", "Mono ADC L1 Mux"},
2137         {"Mono ADC MIXL", "ADC2 Switch", "Mono ADC L2 Mux"},
2138         {"Mono ADC MIXL", NULL, "mono left filter"},
2139         {"mono left filter", NULL, "PLL1", check_sysclk1_source},
2140
2141         {"Mono ADC MIXR", "ADC1 Switch", "Mono ADC R1 Mux"},
2142         {"Mono ADC MIXR", "ADC2 Switch", "Mono ADC R2 Mux"},
2143         {"Mono ADC MIXR", NULL, "mono right filter"},
2144         {"mono right filter", NULL, "PLL1", check_sysclk1_source},
2145
2146         {"IF2 ADC L Mux", "Mono ADC MIXL", "Mono ADC MIXL"},
2147         {"IF2 ADC R Mux", "Mono ADC MIXR", "Mono ADC MIXR"},
2148
2149         {"IF2 ADC L", NULL, "IF2 ADC L Mux"},
2150         {"IF2 ADC R", NULL, "IF2 ADC R Mux"},
2151         {"IF3 ADC L", NULL, "Mono ADC MIXL"},
2152         {"IF3 ADC R", NULL, "Mono ADC MIXR"},
2153         {"IF1 ADC L", NULL, "Stereo ADC MIXL"},
2154         {"IF1 ADC R", NULL, "Stereo ADC MIXR"},
2155
2156         {"IF1 ADC", NULL, "I2S1"},
2157         {"IF1 ADC", NULL, "IF1 ADC L"},
2158         {"IF1 ADC", NULL, "IF1 ADC R"},
2159         {"IF2 ADC", NULL, "I2S2"},
2160         {"IF2 ADC", NULL, "IF2 ADC L"},
2161         {"IF2 ADC", NULL, "IF2 ADC R"},
2162         {"IF3 ADC", NULL, "I2S3"},
2163         {"IF3 ADC", NULL, "IF3 ADC L"},
2164         {"IF3 ADC", NULL, "IF3 ADC R"},
2165
2166         {"DAI1 TX Mux", "1:1|2:2|3:3", "IF1 ADC"},
2167         {"DAI1 TX Mux", "1:1|2:3|3:2", "IF1 ADC"},
2168         {"DAI1 TX Mux", "1:3|2:1|3:2", "IF2 ADC"},
2169         {"DAI1 TX Mux", "1:2|2:1|3:3", "IF2 ADC"},
2170         {"DAI1 TX Mux", "1:3|2:2|3:1", "IF3 ADC"},
2171         {"DAI1 TX Mux", "1:2|2:3|3:1", "IF3 ADC"},
2172         {"DAI1 IF1 Mux", "1:1|2:1|3:3", "IF1 ADC"},
2173         {"DAI1 IF2 Mux", "1:1|2:1|3:3", "IF2 ADC"},
2174         {"SDI1 TX Mux", "IF1", "DAI1 IF1 Mux"},
2175         {"SDI1 TX Mux", "IF2", "DAI1 IF2 Mux"},
2176
2177         {"DAI2 TX Mux", "1:2|2:3|3:1", "IF1 ADC"},
2178         {"DAI2 TX Mux", "1:2|2:1|3:3", "IF1 ADC"},
2179         {"DAI2 TX Mux", "1:1|2:2|3:3", "IF2 ADC"},
2180         {"DAI2 TX Mux", "1:3|2:2|3:1", "IF2 ADC"},
2181         {"DAI2 TX Mux", "1:1|2:3|3:2", "IF3 ADC"},
2182         {"DAI2 TX Mux", "1:3|2:1|3:2", "IF3 ADC"},
2183         {"DAI2 IF1 Mux", "1:2|2:2|3:3", "IF1 ADC"},
2184         {"DAI2 IF2 Mux", "1:2|2:2|3:3", "IF2 ADC"},
2185         {"SDI2 TX Mux", "IF1", "DAI2 IF1 Mux"},
2186         {"SDI2 TX Mux", "IF2", "DAI2 IF2 Mux"},
2187
2188         {"DAI3 TX Mux", "1:3|2:1|3:2", "IF1 ADC"},
2189         {"DAI3 TX Mux", "1:3|2:2|3:1", "IF1 ADC"},
2190         {"DAI3 TX Mux", "1:1|2:3|3:2", "IF2 ADC"},
2191         {"DAI3 TX Mux", "1:2|2:3|3:1", "IF2 ADC"},
2192         {"DAI3 TX Mux", "1:1|2:2|3:3", "IF3 ADC"},
2193         {"DAI3 TX Mux", "1:2|2:1|3:3", "IF3 ADC"},
2194         {"DAI3 TX Mux", "1:1|2:1|3:3", "IF3 ADC"},
2195         {"DAI3 TX Mux", "1:2|2:2|3:3", "IF3 ADC"},
2196
2197         {"AIF1TX", NULL, "DAI1 TX Mux"},
2198         {"AIF1TX", NULL, "SDI1 TX Mux"},
2199         {"AIF2TX", NULL, "DAI2 TX Mux"},
2200         {"AIF2TX", NULL, "SDI2 TX Mux"},
2201         {"AIF3TX", NULL, "DAI3 TX Mux"},
2202
2203         {"DAI1 RX Mux", "1:1|2:2|3:3", "AIF1RX"},
2204         {"DAI1 RX Mux", "1:1|2:3|3:2", "AIF1RX"},
2205         {"DAI1 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
2206         {"DAI1 RX Mux", "1:2|2:3|3:1", "AIF2RX"},
2207         {"DAI1 RX Mux", "1:2|2:1|3:3", "AIF2RX"},
2208         {"DAI1 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
2209         {"DAI1 RX Mux", "1:3|2:1|3:2", "AIF3RX"},
2210         {"DAI1 RX Mux", "1:3|2:2|3:1", "AIF3RX"},
2211
2212         {"DAI2 RX Mux", "1:3|2:1|3:2", "AIF1RX"},
2213         {"DAI2 RX Mux", "1:2|2:1|3:3", "AIF1RX"},
2214         {"DAI2 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
2215         {"DAI2 RX Mux", "1:1|2:2|3:3", "AIF2RX"},
2216         {"DAI2 RX Mux", "1:3|2:2|3:1", "AIF2RX"},
2217         {"DAI2 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
2218         {"DAI2 RX Mux", "1:1|2:3|3:2", "AIF3RX"},
2219         {"DAI2 RX Mux", "1:2|2:3|3:1", "AIF3RX"},
2220
2221         {"DAI3 RX Mux", "1:3|2:2|3:1", "AIF1RX"},
2222         {"DAI3 RX Mux", "1:2|2:3|3:1", "AIF1RX"},
2223         {"DAI3 RX Mux", "1:1|2:3|3:2", "AIF2RX"},
2224         {"DAI3 RX Mux", "1:3|2:1|3:2", "AIF2RX"},
2225         {"DAI3 RX Mux", "1:1|2:2|3:3", "AIF3RX"},
2226         {"DAI3 RX Mux", "1:2|2:1|3:3", "AIF3RX"},
2227         {"DAI3 RX Mux", "1:1|2:1|3:3", "AIF3RX"},
2228         {"DAI3 RX Mux", "1:2|2:2|3:3", "AIF3RX"},
2229
2230         {"IF1 DAC", NULL, "I2S1"},
2231         {"IF1 DAC", NULL, "DAI1 RX Mux"},
2232         {"IF2 DAC", NULL, "I2S2"},
2233         {"IF2 DAC", NULL, "DAI2 RX Mux"},
2234         {"IF3 DAC", NULL, "I2S3"},
2235         {"IF3 DAC", NULL, "DAI3 RX Mux"},
2236
2237         {"IF1 DAC L", NULL, "IF1 DAC"},
2238         {"IF1 DAC R", NULL, "IF1 DAC"},
2239         {"IF2 DAC L", NULL, "IF2 DAC"},
2240         {"IF2 DAC R", NULL, "IF2 DAC"},
2241         {"IF3 DAC L", NULL, "IF3 DAC"},
2242         {"IF3 DAC R", NULL, "IF3 DAC"},
2243
2244         {"DAC MIXL", "Stereo ADC Switch", "Stereo ADC MIXL"},
2245         {"DAC MIXL", "INF1 Switch", "IF1 DAC L"},
2246         {"DAC MIXR", "Stereo ADC Switch", "Stereo ADC MIXR"},
2247         {"DAC MIXR", "INF1 Switch", "IF1 DAC R"},
2248
2249         {"ANC", NULL, "Stereo ADC MIXL"},
2250         {"ANC", NULL, "Stereo ADC MIXR"},
2251
2252         {"Audio DSP", NULL, "DAC MIXL"},
2253         {"Audio DSP", NULL, "DAC MIXR"},
2254
2255         {"DAC L2 Mux", "IF2", "IF2 DAC L"},
2256         {"DAC L2 Mux", "IF3", "IF3 DAC L"},
2257         {"DAC L2 Mux", "Base L/R", "Audio DSP"},
2258         {"DAC L2 Volume", NULL, "DAC L2 Mux"},
2259
2260         {"DAC R2 Mux", "IF2", "IF2 DAC R"},
2261         {"DAC R2 Mux", "IF3", "IF3 DAC R"},
2262         {"DAC R2 Volume", NULL, "Mono dacr Mux"},
2263         {"Mono dacr Mux", "TxDC_R", "DAC R2 Mux"},
2264         {"Mono dacr Mux", "TxDP_R", "IF2 ADC R Mux"},
2265
2266         {"Stereo DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
2267         {"Stereo DAC MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2268         {"Stereo DAC MIXL", "ANC Switch", "ANC"},
2269         {"Stereo DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
2270         {"Stereo DAC MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2271         {"Stereo DAC MIXR", "ANC Switch", "ANC"},
2272
2273         {"Mono DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
2274         {"Mono DAC MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2275         {"Mono DAC MIXL", "DAC R2 Switch", "DAC R2 Volume"},
2276         {"Mono DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
2277         {"Mono DAC MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2278         {"Mono DAC MIXR", "DAC L2 Switch", "DAC L2 Volume"},
2279
2280         {"DIG MIXL", "DAC L1 Switch", "DAC MIXL"},
2281         {"DIG MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2282         {"DIG MIXR", "DAC R1 Switch", "DAC MIXR"},
2283         {"DIG MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2284
2285         {"DAC L1", NULL, "Stereo DAC MIXL"},
2286         {"DAC L1", NULL, "PLL1", check_sysclk1_source},
2287         {"DAC R1", NULL, "Stereo DAC MIXR"},
2288         {"DAC R1", NULL, "PLL1", check_sysclk1_source},
2289
2290         {"SPK MIXL", "REC MIXL Switch", "RECMIXL"},
2291         {"SPK MIXL", "INL Switch", "INL VOL"},
2292         {"SPK MIXL", "DAC L1 Switch", "DAC L1"},
2293         {"SPK MIXL", "OUT MIXL Switch", "OUT MIXL"},
2294         {"SPK MIXR", "REC MIXR Switch", "RECMIXR"},
2295         {"SPK MIXR", "INR Switch", "INR VOL"},
2296         {"SPK MIXR", "DAC R1 Switch", "DAC R1"},
2297         {"SPK MIXR", "OUT MIXR Switch", "OUT MIXR"},
2298
2299         {"OUT MIXL", "BST3 Switch", "BST3"},
2300         {"OUT MIXL", "BST1 Switch", "BST1"},
2301         {"OUT MIXL", "INL Switch", "INL VOL"},
2302         {"OUT MIXL", "REC MIXL Switch", "RECMIXL"},
2303         {"OUT MIXL", "DAC L1 Switch", "DAC L1"},
2304
2305         {"OUT MIXR", "BST3 Switch", "BST3"},
2306         {"OUT MIXR", "BST2 Switch", "BST2"},
2307         {"OUT MIXR", "BST1 Switch", "BST1"},
2308         {"OUT MIXR", "INR Switch", "INR VOL"},
2309         {"OUT MIXR", "REC MIXR Switch", "RECMIXR"},
2310         {"OUT MIXR", "DAC R1 Switch", "DAC R1"},
2311
2312         {"SPKVOL L", NULL, "SPK MIXL"},
2313         {"SPKVOL R", NULL, "SPK MIXR"},
2314         {"HPOVOL L", NULL, "OUT MIXL"},
2315         {"HPOVOL R", NULL, "OUT MIXR"},
2316         {"OUTVOL L", NULL, "OUT MIXL"},
2317         {"OUTVOL R", NULL, "OUT MIXR"},
2318
2319         {"SPOL MIX", "DAC R1 Switch", "DAC R1"},
2320         {"SPOL MIX", "DAC L1 Switch", "DAC L1"},
2321         {"SPOL MIX", "SPKVOL R Switch", "SPKVOL R"},
2322         {"SPOL MIX", "SPKVOL L Switch", "SPKVOL L"},
2323         {"SPOL MIX", "BST1 Switch", "BST1"},
2324         {"SPOR MIX", "DAC R1 Switch", "DAC R1"},
2325         {"SPOR MIX", "SPKVOL R Switch", "SPKVOL R"},
2326         {"SPOR MIX", "BST1 Switch", "BST1"},
2327
2328         {"DAC 1", NULL, "DAC L1"},
2329         {"DAC 1", NULL, "DAC R1"},
2330         {"HPOVOL", NULL, "HPOVOL L"},
2331         {"HPOVOL", NULL, "HPOVOL R"},
2332         {"HPO MIX", "DAC1 Switch", "DAC 1"},
2333         {"HPO MIX", "HPVOL Switch", "HPOVOL"},
2334
2335         {"LOUT MIX", "DAC L1 Switch", "DAC L1"},
2336         {"LOUT MIX", "DAC R1 Switch", "DAC R1"},
2337         {"LOUT MIX", "OUTVOL L Switch", "OUTVOL L"},
2338         {"LOUT MIX", "OUTVOL R Switch", "OUTVOL R"},
2339
2340         {"SPK amp", NULL, "SPOL MIX"},
2341         {"SPK amp", NULL, "SPOR MIX"},
2342         {"SPOLP", NULL, "SPK amp"},
2343         {"SPOLN", NULL, "SPK amp"},
2344         {"SPORP", NULL, "SPK amp"},
2345         {"SPORN", NULL, "SPK amp"},
2346
2347         {"HP amp", NULL, "HPO MIX"},
2348         {"HPOL", NULL, "HP amp"},
2349         {"HPOR", NULL, "HP amp"},
2350
2351         {"LOUT amp", NULL, "LOUT MIX"},
2352         {"LOUTL", NULL, "LOUT amp"},
2353         {"LOUTR", NULL, "LOUT amp"},
2354 };
2355
2356 static int get_sdp_info(struct snd_soc_codec *codec, int dai_id)
2357 {
2358         int ret = 0, val;
2359
2360         if (codec == NULL)
2361                 return -EINVAL;
2362
2363         val = snd_soc_read(codec, RT5639_I2S1_SDP);
2364         val = (val & RT5639_I2S_IF_MASK) >> RT5639_I2S_IF_SFT;
2365         switch (dai_id) {
2366         case RT5639_AIF1:
2367                 if (val == RT5639_IF_123 || val == RT5639_IF_132 ||
2368                         val == RT5639_IF_113)
2369                         ret |= RT5639_U_IF1;
2370                 if (val == RT5639_IF_312 || val == RT5639_IF_213 ||
2371                         val == RT5639_IF_113)
2372                         ret |= RT5639_U_IF2;
2373                 if (val == RT5639_IF_321 || val == RT5639_IF_231)
2374                         ret |= RT5639_U_IF3;
2375                 break;
2376
2377         case RT5639_AIF2:
2378                 if (val == RT5639_IF_231 || val == RT5639_IF_213 ||
2379                         val == RT5639_IF_223)
2380                         ret |= RT5639_U_IF1;
2381                 if (val == RT5639_IF_123 || val == RT5639_IF_321 ||
2382                         val == RT5639_IF_223)
2383                         ret |= RT5639_U_IF2;
2384                 if (val == RT5639_IF_132 || val == RT5639_IF_312)
2385                         ret |= RT5639_U_IF3;
2386                 break;
2387
2388         default:
2389                 ret = -EINVAL;
2390                 break;
2391         }
2392
2393         return ret;
2394 }
2395
2396 static int get_clk_info(int sclk, int rate)
2397 {
2398         int i, pd[] = {1, 2, 3, 4, 6, 8, 12, 16};
2399
2400         if (sclk <= 0 || rate <= 0)
2401                 return -EINVAL;
2402
2403         rate = rate << 8;
2404         for (i = 0; i < ARRAY_SIZE(pd); i++)
2405                 if (sclk == rate * pd[i])
2406                         return i;
2407
2408         return -EINVAL;
2409 }
2410
2411 static int rt5639_hw_params(struct snd_pcm_substream *substream,
2412         struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
2413 {
2414         struct snd_soc_pcm_runtime *rtd = substream->private_data;
2415         struct snd_soc_codec *codec = rtd->codec;
2416         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2417         unsigned int val_len = 0, val_clk, mask_clk, dai_sel;
2418         int pre_div, bclk_ms, frame_size;
2419
2420         rt5639->lrck[dai->id] = params_rate(params);
2421         pre_div = get_clk_info(rt5639->sysclk, rt5639->lrck[dai->id]);
2422         if (pre_div < 0) {
2423                 dev_err(codec->dev, "Unsupported clock setting\n");
2424                 return -EINVAL;
2425         }
2426         frame_size = snd_soc_params_to_frame_size(params);
2427         if (frame_size < 0) {
2428                 dev_err(codec->dev, "Unsupported frame size: %d\n", frame_size);
2429                 return -EINVAL;
2430         }
2431         bclk_ms = frame_size > 32 ? 1 : 0;
2432         rt5639->bclk[dai->id] = rt5639->lrck[dai->id] * (32 << bclk_ms);
2433
2434         dev_dbg(dai->dev, "bclk is %dHz and lrck is %dHz\n",
2435                 rt5639->bclk[dai->id], rt5639->lrck[dai->id]);
2436         dev_dbg(dai->dev, "bclk_ms is %d and pre_div is %d for iis %d\n",
2437                                 bclk_ms, pre_div, dai->id);
2438
2439         switch (params_format(params)) {
2440         case SNDRV_PCM_FORMAT_S16_LE:
2441                 break;
2442         case SNDRV_PCM_FORMAT_S20_3LE:
2443                 val_len |= RT5639_I2S_DL_20;
2444                 break;
2445         case SNDRV_PCM_FORMAT_S24_LE:
2446                 val_len |= RT5639_I2S_DL_24;
2447                 break;
2448         case SNDRV_PCM_FORMAT_S8:
2449                 val_len |= RT5639_I2S_DL_8;
2450                 break;
2451         default:
2452                 return -EINVAL;
2453         }
2454
2455         dai_sel = get_sdp_info(codec, dai->id);
2456         dai_sel |= (RT5639_U_IF1 | RT5639_U_IF2);
2457         if (dai_sel < 0) {
2458                 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
2459                 return -EINVAL;
2460         }
2461         if (dai_sel & RT5639_U_IF1) {
2462                 mask_clk = RT5639_I2S_BCLK_MS1_MASK | RT5639_I2S_PD1_MASK;
2463                 val_clk = bclk_ms << RT5639_I2S_BCLK_MS1_SFT |
2464                         pre_div << RT5639_I2S_PD1_SFT;
2465                 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
2466                         RT5639_I2S_DL_MASK, val_len);
2467                 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
2468         }
2469         if (dai_sel & RT5639_U_IF2) {
2470                 mask_clk = RT5639_I2S_BCLK_MS2_MASK | RT5639_I2S_PD2_MASK;
2471                 val_clk = bclk_ms << RT5639_I2S_BCLK_MS2_SFT |
2472                         pre_div << RT5639_I2S_PD2_SFT;
2473                 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
2474                         RT5639_I2S_DL_MASK, val_len);
2475                 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
2476         }
2477
2478         return 0;
2479 }
2480
2481 static int rt5639_prepare(struct snd_pcm_substream *substream,
2482                                 struct snd_soc_dai *dai)
2483 {
2484         struct snd_soc_pcm_runtime *rtd = substream->private_data;
2485         struct snd_soc_codec *codec = rtd->codec;
2486         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2487
2488         rt5639->aif_pu = dai->id;
2489         return 0;
2490 }
2491
2492 static int rt5639_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2493 {
2494         struct snd_soc_codec *codec = dai->codec;
2495         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2496         unsigned int reg_val = 0, dai_sel;
2497
2498         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2499         case SND_SOC_DAIFMT_CBM_CFM:
2500                 rt5639->master[dai->id] = 1;
2501                 break;
2502         case SND_SOC_DAIFMT_CBS_CFS:
2503                 reg_val |= RT5639_I2S_MS_S;
2504                 rt5639->master[dai->id] = 0;
2505                 break;
2506         default:
2507                 return -EINVAL;
2508         }
2509
2510         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
2511         case SND_SOC_DAIFMT_NB_NF:
2512                 break;
2513         case SND_SOC_DAIFMT_IB_NF:
2514                 reg_val |= RT5639_I2S_BP_INV;
2515                 break;
2516         default:
2517                 return -EINVAL;
2518         }
2519
2520         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
2521         case SND_SOC_DAIFMT_I2S:
2522                 break;
2523         case SND_SOC_DAIFMT_LEFT_J:
2524                 reg_val |= RT5639_I2S_DF_LEFT;
2525                 break;
2526         case SND_SOC_DAIFMT_DSP_A:
2527                 reg_val |= RT5639_I2S_DF_PCM_A;
2528                 break;
2529         case SND_SOC_DAIFMT_DSP_B:
2530                 reg_val |= RT5639_I2S_DF_PCM_B;
2531                 break;
2532         default:
2533                 return -EINVAL;
2534         }
2535
2536         dai_sel = get_sdp_info(codec, dai->id);
2537         if (dai_sel < 0) {
2538                 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
2539                 return -EINVAL;
2540         }
2541         if (dai_sel & RT5639_U_IF1) {
2542                 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
2543                         RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
2544                         RT5639_I2S_DF_MASK, reg_val);
2545         }
2546         if (dai_sel & RT5639_U_IF2) {
2547                 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
2548                         RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
2549                         RT5639_I2S_DF_MASK, reg_val);
2550         }
2551
2552         return 0;
2553 }
2554
2555 static int rt5639_set_dai_sysclk(struct snd_soc_dai *dai,
2556                 int clk_id, unsigned int freq, int dir)
2557 {
2558         struct snd_soc_codec *codec = dai->codec;
2559         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2560         unsigned int reg_val = 0;
2561
2562         if (freq == rt5639->sysclk && clk_id == rt5639->sysclk_src)
2563                 return 0;
2564
2565         switch (clk_id) {
2566         case RT5639_SCLK_S_MCLK:
2567                 reg_val |= RT5639_SCLK_SRC_MCLK;
2568                 break;
2569         case RT5639_SCLK_S_PLL1:
2570                 reg_val |= RT5639_SCLK_SRC_PLL1;
2571                 break;
2572         case RT5639_SCLK_S_RCCLK:
2573                 reg_val |= RT5639_SCLK_SRC_RCCLK;
2574                 break;
2575         default:
2576                 dev_err(codec->dev, "Invalid clock id (%d)\n", clk_id);
2577                 return -EINVAL;
2578         }
2579         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2580                 RT5639_SCLK_SRC_MASK, reg_val);
2581         rt5639->sysclk = freq;
2582         rt5639->sysclk_src = clk_id;
2583
2584         dev_dbg(dai->dev, "Sysclk is %dHz and clock id is %d\n", freq, clk_id);
2585
2586         return 0;
2587 }
2588
2589 /**
2590  * rt5639_pll_calc - Calcualte PLL M/N/K code.
2591  * @freq_in: external clock provided to codec.
2592  * @freq_out: target clock which codec works on.
2593  * @pll_code: Pointer to structure with M, N, K and bypass flag.
2594  *
2595  * Calcualte M/N/K code to configure PLL for codec. And K is assigned to 2
2596  * which make calculation more efficiently.
2597  *
2598  * Returns 0 for success or negative error code.
2599  */
2600 static int rt5639_pll_calc(const unsigned int freq_in,
2601         const unsigned int freq_out, struct rt5639_pll_code *pll_code)
2602 {
2603         int max_n = RT5639_PLL_N_MAX, max_m = RT5639_PLL_M_MAX;
2604         int k, n = 0, m = 0, red, n_t, m_t, pll_out, in_t, out_t;
2605         int red_t = abs(freq_out - freq_in);
2606         bool bypass = false;
2607
2608         if (RT5639_PLL_INP_MAX < freq_in || RT5639_PLL_INP_MIN > freq_in)
2609                 return -EINVAL;
2610
2611         k = 100000000 / freq_out - 2;
2612         if (k > RT5639_PLL_K_MAX)
2613                 k = RT5639_PLL_K_MAX;
2614         for (n_t = 0; n_t <= max_n; n_t++) {
2615                 in_t = freq_in / (k + 2);
2616                 pll_out = freq_out / (n_t + 2);
2617                 if (in_t < 0)
2618                         continue;
2619                 if (in_t == pll_out) {
2620                         bypass = true;
2621                         n = n_t;
2622                         goto code_find;
2623                 }
2624
2625                 red = abs(in_t - pll_out);
2626
2627                 if (red < red_t) {
2628                         bypass = true;
2629                         n = n_t;
2630                         m = m_t;
2631                         if (red == 0)
2632                                 goto code_find;
2633                         red_t = red;
2634                 }
2635                 for (m_t = 0; m_t <= max_m; m_t++) {
2636                         out_t = in_t / (m_t + 2);
2637                         red = abs(out_t - pll_out);
2638                         if (red < red_t) {
2639                                 bypass = false;
2640                                 n = n_t;
2641                                 m = m_t;
2642                                 if (red == 0)
2643                                         goto code_find;
2644                                 red_t = red;
2645                         }
2646                 }
2647         }
2648         pr_debug("Only get approximation about PLL\n");
2649
2650 code_find:
2651
2652         pll_code->m_bp = bypass;
2653         pll_code->m_code = m;
2654         pll_code->n_code = n;
2655         pll_code->k_code = k;
2656         return 0;
2657 }
2658
2659 static int rt5639_set_dai_pll(struct snd_soc_dai *dai, int pll_id, int source,
2660                         unsigned int freq_in, unsigned int freq_out)
2661 {
2662         struct snd_soc_codec *codec = dai->codec;
2663         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2664         struct rt5639_pll_code pll_code;
2665         int ret, dai_sel;
2666
2667         if (source == rt5639->pll_src && freq_in == rt5639->pll_in &&
2668             freq_out == rt5639->pll_out)
2669                 return 0;
2670
2671         if (!freq_in || !freq_out) {
2672                 dev_dbg(codec->dev, "PLL disabled\n");
2673
2674                 rt5639->pll_in = 0;
2675                 rt5639->pll_out = 0;
2676                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2677                         RT5639_SCLK_SRC_MASK, RT5639_SCLK_SRC_MCLK);
2678                 return 0;
2679         }
2680
2681         switch (source) {
2682         case RT5639_PLL1_S_MCLK:
2683                 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2684                         RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_MCLK);
2685                 break;
2686         case RT5639_PLL1_S_BCLK1:
2687         case RT5639_PLL1_S_BCLK2:
2688                 dai_sel = get_sdp_info(codec, dai->id);
2689                 if (dai_sel < 0) {
2690                         dev_err(codec->dev,
2691                                 "Failed to get sdp info: %d\n", dai_sel);
2692                         return -EINVAL;
2693                 }
2694                 if (dai_sel & RT5639_U_IF1) {
2695                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2696                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK1);
2697                 }
2698                 if (dai_sel & RT5639_U_IF2) {
2699                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2700                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK2);
2701                 }
2702                 if (dai_sel & RT5639_U_IF3) {
2703                         snd_soc_update_bits(codec, RT5639_GLB_CLK,
2704                                 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK3);
2705                 }
2706                 break;
2707         default:
2708                 dev_err(codec->dev, "Unknown PLL source %d\n", source);
2709                 return -EINVAL;
2710         }
2711
2712         ret = rt5639_pll_calc(freq_in, freq_out, &pll_code);
2713         if (ret < 0) {
2714                 dev_err(codec->dev, "Unsupport input clock %d\n", freq_in);
2715                 return ret;
2716         }
2717
2718         dev_dbg(codec->dev, "bypass=%d m=%d n=%d k=%d\n", pll_code.m_bp,
2719                 (pll_code.m_bp ? 0 : pll_code.m_code),
2720                 pll_code.n_code, pll_code.k_code);
2721
2722         snd_soc_write(codec, RT5639_PLL_CTRL1,
2723                 pll_code.n_code << RT5639_PLL_N_SFT | pll_code.k_code);
2724         snd_soc_write(codec, RT5639_PLL_CTRL2,
2725                 (pll_code.m_bp ? 0 : pll_code.m_code) << RT5639_PLL_M_SFT |
2726                 pll_code.m_bp << RT5639_PLL_M_BP_SFT);
2727
2728         rt5639->pll_in = freq_in;
2729         rt5639->pll_out = freq_out;
2730         rt5639->pll_src = source;
2731
2732         return 0;
2733 }
2734
2735 /**
2736  * rt5639_index_show - Dump private registers.
2737  * @dev: codec device.
2738  * @attr: device attribute.
2739  * @buf: buffer for display.
2740  *
2741  * To show non-zero values of all private registers.
2742  *
2743  * Returns buffer length.
2744  */
2745 static ssize_t rt5639_index_show(struct device *dev,
2746         struct device_attribute *attr, char *buf)
2747 {
2748         struct i2c_client *client = to_i2c_client(dev);
2749         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2750         struct snd_soc_codec *codec = rt5639->codec;
2751         unsigned int val;
2752         int cnt = 0, i;
2753
2754         cnt += sprintf(buf, "RT5639 index register\n");
2755         for (i = 0; i < 0xb4; i++) {
2756                 if (cnt + RT5639_REG_DISP_LEN >= PAGE_SIZE)
2757                         break;
2758                 val = rt5639_index_read(codec, i);
2759                 if (!val)
2760                         continue;
2761                 cnt += snprintf(buf + cnt, RT5639_REG_DISP_LEN,
2762                                 "%02x: %04x\n", i, val);
2763         }
2764
2765         if (cnt >= PAGE_SIZE)
2766                 cnt = PAGE_SIZE - 1;
2767
2768         return cnt;
2769 }
2770
2771 static ssize_t rt5639_index_store(struct device *dev,
2772                 struct device_attribute *attr, const char *buf, size_t count)
2773 {
2774         struct i2c_client *client = to_i2c_client(dev);
2775         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2776         struct snd_soc_codec *codec = rt5639->codec;
2777         unsigned int val = 0, addr = 0;
2778         int i;
2779
2780         dev_info(codec->dev, "register \"%s\" count=%d\n", buf, count);
2781         for (i = 0; i < count; i++) { /*address*/
2782                 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2783                         addr = (addr << 4) | (*(buf+i)-'0');
2784                 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2785                         addr = (addr << 4) | ((*(buf+i) - 'a')+0xa);
2786                 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2787                         addr = (addr << 4) | ((*(buf+i) - 'A')+0xa);
2788                 else
2789                         break;
2790         }
2791
2792         for (i = i+1; i < count; i++) { /*val*/
2793                 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2794                         val = (val << 4) | (*(buf+i) - '0');
2795                 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2796                         val = (val << 4) | ((*(buf+i) - 'a') + 0xa);
2797                 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2798                         val = (val << 4) | ((*(buf+i) - 'A') + 0xa);
2799                 else
2800                         break;
2801         }
2802         dev_info(codec->dev, "addr=0x%x val=0x%x\n", addr, val);
2803         if (addr > RT5639_VENDOR_ID2 || val > 0xffff || val < 0)
2804                 return count;
2805
2806         if (i == count)
2807                 dev_info(codec->dev, "0x%02x = 0x%04x\n", addr,
2808                         rt5639_index_read(codec, addr));
2809         else
2810                 rt5639_index_write(codec, addr, val);
2811
2812         return count;
2813 }
2814 static DEVICE_ATTR(index_reg, 0444, rt5639_index_show, rt5639_index_store);
2815
2816 static ssize_t rt5639_codec_show(struct device *dev,
2817         struct device_attribute *attr, char *buf)
2818 {
2819         struct i2c_client *client = to_i2c_client(dev);
2820         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2821         struct snd_soc_codec *codec = rt5639->codec;
2822         unsigned int val;
2823         int cnt = 0, i;
2824
2825         cnt += sprintf(buf, "RT5639 codec register\n");
2826         for (i = 0; i <= RT5639_VENDOR_ID2; i++) {
2827                 if (cnt + RT5639_REG_DISP_LEN >= PAGE_SIZE)
2828                         break;
2829                 val = codec->hw_read(codec, i);
2830                 if (!val)
2831                         continue;
2832                 cnt += snprintf(buf + cnt, RT5639_REG_DISP_LEN,
2833                                 "#rng%02x  #rv%04x  #rd0\n", i, val);
2834         }
2835
2836         if (cnt >= PAGE_SIZE)
2837                 cnt = PAGE_SIZE - 1;
2838
2839         return cnt;
2840 }
2841
2842 static ssize_t rt5639_codec_store(struct device *dev,
2843                 struct device_attribute *attr, const char *buf, size_t count)
2844 {
2845         struct i2c_client *client = to_i2c_client(dev);
2846         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2847         struct snd_soc_codec *codec = rt5639->codec;
2848         unsigned int val = 0, addr = 0;
2849         int i;
2850
2851         dev_info(codec->dev, "register \"%s\" count=%d\n", buf, count);
2852         for (i = 0; i < count; i++) {/*address*/
2853                 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2854                         addr = (addr << 4) | (*(buf+i)-'0');
2855                 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2856                         addr = (addr << 4) | ((*(buf+i) - 'a') + 0xa);
2857                 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2858                         addr = (addr << 4) | ((*(buf+i) - 'A') + 0xa);
2859                 else
2860                         break;
2861         }
2862
2863         for (i = i+1; i < count; i++) {/*val*/
2864                 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2865                         val = (val << 4) | (*(buf+i) - '0');
2866                 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2867                         val = (val << 4) | ((*(buf+i) - 'a') + 0xa);
2868                 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2869                         val = (val << 4) | ((*(buf+i) - 'A') + 0xa);
2870                 else
2871                         break;
2872         }
2873         dev_info(codec->dev, "addr=0x%x val=0x%x\n", addr, val);
2874         if (addr > RT5639_VENDOR_ID2 || val > 0xffff || val < 0)
2875                 return count;
2876
2877         if (i == count)
2878                 dev_info(codec->dev, "0x%02x = 0x%04x\n", addr,
2879                         codec->hw_read(codec, addr));
2880         else
2881                 snd_soc_write(codec, addr, val);
2882
2883         return count;
2884 }
2885
2886 static DEVICE_ATTR(codec_reg, 0644, rt5639_codec_show, rt5639_codec_store);
2887
2888 static int rt5639_set_bias_level(struct snd_soc_codec *codec,
2889                         enum snd_soc_bias_level level)
2890 {
2891         switch (level) {
2892         case SND_SOC_BIAS_ON:
2893                 break;
2894
2895         case SND_SOC_BIAS_PREPARE:
2896                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
2897                         RT5639_PWR_MB1 | RT5639_PWR_MB2,
2898                         RT5639_PWR_MB1 | RT5639_PWR_MB2);
2899                 break;
2900
2901         case SND_SOC_BIAS_STANDBY:
2902                 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
2903                         RT5639_PWR_MB1 | RT5639_PWR_MB2, 0);
2904                 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
2905                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2906                                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2907                                 RT5639_PWR_BG | RT5639_PWR_VREF2,
2908                                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2909                                 RT5639_PWR_BG | RT5639_PWR_VREF2);
2910                         msleep(5);
2911                         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2912                                 RT5639_PWR_FV1 | RT5639_PWR_FV2,
2913                                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
2914                         snd_soc_write(codec, RT5639_GEN_CTRL1, 0x3701);
2915                         codec->cache_only = false;
2916                         codec->cache_sync = 1;
2917                         snd_soc_cache_sync(codec);
2918                         rt5639_index_sync(codec);
2919                 }
2920                 break;
2921
2922         case SND_SOC_BIAS_OFF:
2923                 snd_soc_write(codec, RT5639_DEPOP_M1, 0x0004);
2924                 snd_soc_write(codec, RT5639_DEPOP_M2, 0x1100);
2925                 snd_soc_write(codec, RT5639_GEN_CTRL1, 0x3700);
2926                 snd_soc_write(codec, RT5639_PWR_DIG1, 0x0000);
2927                 snd_soc_write(codec, RT5639_PWR_DIG2, 0x0000);
2928                 snd_soc_write(codec, RT5639_PWR_VOL, 0x0000);
2929                 snd_soc_write(codec, RT5639_PWR_MIXER, 0x0000);
2930                 snd_soc_write(codec, RT5639_PWR_ANLG1, 0x0000);
2931                 snd_soc_write(codec, RT5639_PWR_ANLG2, 0x0000);
2932                 break;
2933
2934         default:
2935                 break;
2936         }
2937         codec->dapm.bias_level = level;
2938
2939         return 0;
2940 }
2941
2942 static int rt5639_probe(struct snd_soc_codec *codec)
2943 {
2944         struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2945         int ret;
2946
2947         pr_info("Codec driver version %s\n", VERSION);
2948
2949         ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
2950         if (ret != 0) {
2951                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
2952                 return ret;
2953         }
2954
2955         rt5639_reset(codec);
2956         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2957                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2958                 RT5639_PWR_BG | RT5639_PWR_VREF2,
2959                 RT5639_PWR_VREF1 | RT5639_PWR_MB |
2960                 RT5639_PWR_BG | RT5639_PWR_VREF2);
2961         msleep(10);
2962         snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
2963                 RT5639_PWR_FV1 | RT5639_PWR_FV2,
2964                 RT5639_PWR_FV1 | RT5639_PWR_FV2);
2965         /* DMIC */
2966         if (rt5639->dmic_en == RT5639_DMIC1) {
2967                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
2968                         RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
2969                 snd_soc_update_bits(codec, RT5639_DMIC,
2970                         RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK,
2971                         RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING);
2972         } else if (rt5639->dmic_en == RT5639_DMIC2) {
2973                 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
2974                         RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
2975                 snd_soc_update_bits(codec, RT5639_DMIC,
2976                         RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK,
2977                         RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING);
2978         }
2979         /*snd_soc_write(codec, RT5639_GEN_CTRL2, 0x4040);*/
2980         /* Enable JD2 Function for Extra JD Status */
2981         snd_soc_write(codec, RT5639_GEN_CTRL2, 0x4140);
2982         ret = snd_soc_read(codec, RT5639_VENDOR_ID);
2983         dev_info(codec->dev, "read 0x%x=0x%x\n", RT5639_VENDOR_ID, ret);
2984         if (0x5 == ret) {
2985                 snd_soc_update_bits(codec, RT5639_JD_CTRL,
2986                         RT5639_JD1_IN4P_MASK | RT5639_JD2_IN4N_MASK,
2987                         RT5639_JD1_IN4P_EN | RT5639_JD2_IN4N_EN);
2988         }
2989         rt5639_reg_init(codec);
2990         DC_Calibrate(codec);
2991         codec->dapm.bias_level = SND_SOC_BIAS_STANDBY;
2992         rt5639->codec = codec;
2993
2994         snd_soc_add_codec_controls(codec, rt5639_snd_controls,
2995                         ARRAY_SIZE(rt5639_snd_controls));
2996         snd_soc_dapm_new_controls(&codec->dapm, rt5639_dapm_widgets,
2997                         ARRAY_SIZE(rt5639_dapm_widgets));
2998         snd_soc_dapm_add_routes(&codec->dapm, rt5639_dapm_routes,
2999                         ARRAY_SIZE(rt5639_dapm_routes));
3000
3001
3002 #ifdef RTK_IOCTL
3003 #if defined(CONFIG_SND_HWDEP) || defined(CONFIG_SND_HWDEP_MODULE)
3004         struct rt56xx_ops *ioctl_ops = rt56xx_get_ioctl_ops();
3005         ioctl_ops->index_write = rt5639_index_write;
3006         ioctl_ops->index_read = rt5639_index_read;
3007         ioctl_ops->index_update_bits = rt5639_index_update_bits;
3008         ioctl_ops->ioctl_common = rt5639_ioctl_common;
3009         realtek_ce_init_hwdep(codec);
3010 #endif
3011 #endif
3012
3013         ret = device_create_file(codec->dev, &dev_attr_index_reg);
3014         if (ret != 0) {
3015                 dev_err(codec->dev,
3016                         "Failed to create index_reg sysfs files: %d\n", ret);
3017                 return ret;
3018         }
3019
3020         ret = device_create_file(codec->dev, &dev_attr_codec_reg);
3021         if (ret != 0) {
3022                 dev_err(codec->dev,
3023                         "Failed to create codex_reg sysfs files: %d\n", ret);
3024                 return ret;
3025         }
3026
3027         return 0;
3028 }
3029
3030 static int rt5639_remove(struct snd_soc_codec *codec)
3031 {
3032         rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
3033         return 0;
3034 }
3035
3036 #ifdef CONFIG_PM
3037 static int rt5639_suspend(struct snd_soc_codec *codec, pm_message_t state)
3038 {
3039         rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
3040         return 0;
3041 }
3042
3043 static int rt5639_resume(struct snd_soc_codec *codec)
3044 {
3045         rt5639_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
3046         return 0;
3047 }
3048 #else
3049 #define rt5639_suspend NULL
3050 #define rt5639_resume NULL
3051 #endif
3052
3053 #define RT5639_STEREO_RATES SNDRV_PCM_RATE_8000_96000
3054 #define RT5639_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
3055                         SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
3056
3057 struct snd_soc_dai_ops rt5639_aif_dai_ops = {
3058         .hw_params = rt5639_hw_params,
3059         .prepare = rt5639_prepare,
3060         .set_fmt = rt5639_set_dai_fmt,
3061         .set_sysclk = rt5639_set_dai_sysclk,
3062         .set_pll = rt5639_set_dai_pll,
3063 };
3064
3065 struct snd_soc_dai_driver rt5639_dai[] = {
3066         {
3067                 .name = "rt5639-aif1",
3068                 .id = RT5639_AIF1,
3069                 .playback = {
3070                         .stream_name = "AIF1 Playback",
3071                         .channels_min = 1,
3072                         .channels_max = 2,
3073                         .rates = RT5639_STEREO_RATES,
3074                         .formats = RT5639_FORMATS,
3075                 },
3076                 .capture = {
3077                         .stream_name = "AIF1 Capture",
3078                         .channels_min = 1,
3079                         .channels_max = 2,
3080                         .rates = RT5639_STEREO_RATES,
3081                         .formats = RT5639_FORMATS,
3082                 },
3083                 .ops = &rt5639_aif_dai_ops,
3084         },
3085         {
3086                 .name = "rt5639-aif2",
3087                 .id = RT5639_AIF2,
3088                 .playback = {
3089                         .stream_name = "AIF2 Playback",
3090                         .channels_min = 1,
3091                         .channels_max = 2,
3092                         .rates = RT5639_STEREO_RATES,
3093                         .formats = RT5639_FORMATS,
3094                 },
3095                 .capture = {
3096                         .stream_name = "AIF2 Capture",
3097                         .channels_min = 1,
3098                         .channels_max = 2,
3099                         .rates = RT5639_STEREO_RATES,
3100                         .formats = RT5639_FORMATS,
3101                 },
3102                 .ops = &rt5639_aif_dai_ops,
3103         },
3104 };
3105
3106 static struct snd_soc_codec_driver soc_codec_dev_rt5639 = {
3107         .probe = rt5639_probe,
3108         .remove = rt5639_remove,
3109         .suspend = rt5639_suspend,
3110         .resume = rt5639_resume,
3111         .set_bias_level = rt5639_set_bias_level,
3112         .reg_cache_size = RT5639_VENDOR_ID2 + 1,
3113         .reg_word_size = sizeof(u16),
3114         .reg_cache_default = rt5639_reg,
3115         .volatile_register = rt5639_volatile_register,
3116         .readable_register = rt5639_readable_register,
3117         .reg_cache_step = 1,
3118 };
3119
3120 static const struct i2c_device_id rt5639_i2c_id[] = {
3121         { "rt5639", 0 },
3122         { }
3123 };
3124 MODULE_DEVICE_TABLE(i2c, rt5639_i2c_id);
3125
3126 static int __devinit rt5639_i2c_probe(struct i2c_client *i2c,
3127                     const struct i2c_device_id *id)
3128 {
3129         struct rt5639_priv *rt5639;
3130         int ret;
3131
3132         rt5639 = kzalloc(sizeof(struct rt5639_priv), GFP_KERNEL);
3133         if (NULL == rt5639)
3134                 return -ENOMEM;
3135
3136         i2c_set_clientdata(i2c, rt5639);
3137
3138         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_rt5639,
3139                         rt5639_dai, ARRAY_SIZE(rt5639_dai));
3140         if (ret < 0)
3141                 kfree(rt5639);
3142
3143         return ret;
3144 }
3145
3146 static int __devexit rt5639_i2c_remove(struct i2c_client *i2c)
3147 {
3148         snd_soc_unregister_codec(&i2c->dev);
3149         kfree(i2c_get_clientdata(i2c));
3150         return 0;
3151 }
3152
3153 static int rt5639_i2c_shutdown(struct i2c_client *client)
3154 {
3155         struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
3156         struct snd_soc_codec *codec = rt5639->codec;
3157
3158         if (codec != NULL)
3159                 rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
3160
3161         return 0;
3162 }
3163
3164 struct i2c_driver rt5639_i2c_driver = {
3165         .driver = {
3166                 .name = "rt5639",
3167                 .owner = THIS_MODULE,
3168         },
3169         .probe = rt5639_i2c_probe,
3170         .remove   = __devexit_p(rt5639_i2c_remove),
3171         .shutdown = rt5639_i2c_shutdown,
3172         .id_table = rt5639_i2c_id,
3173 };
3174
3175 static int __init rt5639_modinit(void)
3176 {
3177         return i2c_add_driver(&rt5639_i2c_driver);
3178 }
3179 module_init(rt5639_modinit);
3180
3181 static void __exit rt5639_modexit(void)
3182 {
3183         i2c_del_driver(&rt5639_i2c_driver);
3184 }
3185 module_exit(rt5639_modexit);
3186
3187 MODULE_DESCRIPTION("ASoC RT5639 driver");
3188 MODULE_AUTHOR("Johnny Hsu <johnnyhsu@realtek.com>");
3189 MODULE_LICENSE("GPL");