2 * rt5639.c -- RT5639 ALSA SoC audio codec driver
4 * Copyright (c) 2011-2013 REALTEK SEMICONDUCTOR CORP. All rights reserved.
5 * Author: Johnny Hsu <johnnyhsu@realtek.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/module.h>
13 #include <linux/moduleparam.h>
14 #include <linux/init.h>
15 #include <linux/delay.h>
17 #include <linux/i2c.h>
18 #include <linux/platform_device.h>
19 #include <linux/spi/spi.h>
20 #include <sound/core.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/soc.h>
24 #include <sound/soc-dapm.h>
25 #include <sound/initval.h>
26 #include <sound/tlv.h>
30 #if defined(CONFIG_SND_HWDEP) || defined(CONFIG_SND_HWDEP_MODULE)
31 #include "rt56xx_ioctl.h"
32 #include "rt5639_ioctl.h"
38 #define RT5639_REG_RW 0 /* for debug */
39 #define RT5639_DET_EXT_MIC 0
40 #define USE_ONEBIT_DEPOP 1 /* for one bit depop */
42 #define VERSION "0.8.5 alsa 1.0.24"
44 struct rt5639_init_reg {
49 static struct rt5639_init_reg init_list[] = {
50 //Make sure we are not in test mode
51 {RT5639_PRIV_INDEX ,0x001B}, //MX6A
52 {RT5639_PRIV_DATA ,0x0200}, //MX6C
54 {RT5639_GEN_CTRL1 , 0x3b01},/* fa[12:13] = 1'b;
55 fa[8~11]=1; fa[0]=1 */
56 {RT5639_ADDA_CLK1 , 0x1114},/* 73[2] = 1'b */
57 {RT5639_MICBIAS , 0x3030},/* 93[5:4] = 11'b */
58 {RT5639_CLS_D_OUT , 0xa000},/* 8d[11] = 0'b */
59 {RT5639_CLS_D_OVCD , 0x0301},/* 8c[8] = 1'b */
60 {RT5639_PRIV_INDEX , 0x001d},/* PR1d[8] = 1'b; */
61 {RT5639_PRIV_DATA , 0x0347},
62 {RT5639_PRIV_INDEX , 0x003d},/* PR3d[12] = 0'b; PR3d[9] = 1'b */
63 {RT5639_PRIV_DATA , 0x2600},
64 {RT5639_PRIV_INDEX , 0x0012},/* PR12 = 0aa8'h */
65 {RT5639_PRIV_DATA , 0x0aa8},
66 {RT5639_PRIV_INDEX , 0x0014},/* PR14 = 8aaa'h */
67 {RT5639_PRIV_DATA , 0x8aaa},
68 {RT5639_PRIV_INDEX , 0x0020},/* PR20 = 6115'h */
69 {RT5639_PRIV_DATA , 0x6115},
70 {RT5639_PRIV_INDEX , 0x0023},/* PR23 = 0804'h */
71 {RT5639_PRIV_DATA , 0x0804},
72 /*{RT5639_PRIV_INDEX , 0x0015},*//* PR15 = ab00'h */
73 /*{RT5639_PRIV_DATA , 0xab00},*/
75 {RT5639_STO_DAC_MIXER , 0x1414},/* Dig inf 1 -> Sto
77 {RT5639_OUT_L3_MIXER , 0x01fe},/* DACL1 -> OUTMIXL */
78 {RT5639_OUT_R3_MIXER , 0x01fe},/* DACR1 -> OUTMIXR */
79 {RT5639_HP_VOL , 0x8888},/* OUTMIX -> HPVOL */
80 {RT5639_HPO_MIXER , 0xc000},/* HPVOL -> HPOLMIX */
81 /*{RT5639_HPO_MIXER , 0xa000},*//* DAC1 -> HPOLMIX */
82 /*{RT5639_CHARGE_PUMP , 0x0f00},*/
83 {RT5639_PRIV_INDEX , 0x0090},
84 {RT5639_PRIV_DATA , 0x2000},
85 {RT5639_PRIV_INDEX , 0x0091},
86 {RT5639_PRIV_DATA , 0x1000},
87 /*{RT5639_HP_CALIB_AMP_DET, 0x0420}*/
88 {RT5639_SPK_L_MIXER , 0x0036},/* DACL1 -> SPKMIXL */
89 {RT5639_SPK_R_MIXER , 0x0036},/* DACR1 -> SPKMIXR */
90 {RT5639_SPK_VOL , 0x8b8b},/* SPKMIX -> SPKVOL */
91 {RT5639_SPO_CLSD_RATIO , 0x0004},
92 {RT5639_SPO_L_MIXER , 0xe800},/* SPKVOLL -> SPOLMIX */
93 {RT5639_SPO_R_MIXER , 0x2800},/* SPKVOLR -> SPORMIX */
94 /*{RT5639_SPO_L_MIXER , 0xb800},*//* DAC -> SPOLMIX */
95 /*{RT5639_SPO_R_MIXER , 0x1800},*//* DAC -> SPORMIX */
96 /*{RT5639_I2S1_SDP , 0xD000},*//* change IIS1 and IIS2 */
98 {RT5639_IN1_IN2 , 0x5080},/* IN1 boost 40db and
100 {RT5639_IN3_IN4 , 0x0500},/* IN2 boost 40db and
102 {RT5639_REC_L2_MIXER , 0x007d},/* Mic1 -> RECMIXL */
103 {RT5639_REC_R2_MIXER , 0x007d},/* Mic1 -> RECMIXR */
104 /*{RT5639_REC_L2_MIXER , 0x006f},*//* Mic2 -> RECMIXL */
105 /*{RT5639_REC_R2_MIXER , 0x006f},*//* Mic2 -> RECMIXR */
106 {RT5639_STO_ADC_MIXER , 0x3020},/* ADC -> Sto ADC mixer */
107 #if RT5639_DET_EXT_MIC
108 {RT5639_MICBIAS , 0x3800},/* enable MICBIAS short current */
109 {RT5639_GPIO_CTRL1 , 0x8400},/* set GPIO1 to IRQ */
110 {RT5639_GPIO_CTRL3 , 0x0004},/* set GPIO1 output */
111 {RT5639_IRQ_CTRL2 , 0x8000},/*set MICBIAS short current to IRQ */
112 /*( if sticky set regBE : 8800 ) */
114 {RT5639_JD_CTRL , 0x6000},/* JD2 as jack detection source */
117 #define RT5639_INIT_REG_LEN ARRAY_SIZE(init_list)
119 static struct rt5639_init_reg irq_jd_init_list[] = {
120 {RT5639_GPIO_CTRL1 , 0x8400},/* set GPIO1 to IRQ */
121 {RT5639_GPIO_CTRL3 , 0x0004},/* set GPIO1 output */
122 {RT5639_IRQ_CTRL1 , 0x8000},/* enable JD IRQ and set active low */
124 #define RT5639_IRQ_JD_INIT_REG_LEN ARRAY_SIZE(irq_jd_init_list)
126 int rt5639_irq_jd_reg_init(struct snd_soc_codec *codec)
130 for (i = 0; i < RT5639_IRQ_JD_INIT_REG_LEN; i++)
131 snd_soc_write(codec, irq_jd_init_list[i].reg, irq_jd_init_list[i].val);
135 EXPORT_SYMBOL(rt5639_irq_jd_reg_init);
137 static int rt5639_reg_init(struct snd_soc_codec *codec)
141 for (i = 0; i < RT5639_INIT_REG_LEN; i++)
142 snd_soc_write(codec, init_list[i].reg, init_list[i].val);
147 static int rt5639_index_sync(struct snd_soc_codec *codec)
151 for (i = 0; i < RT5639_INIT_REG_LEN; i++)
152 if (RT5639_PRIV_INDEX == init_list[i].reg ||
153 RT5639_PRIV_DATA == init_list[i].reg)
154 snd_soc_write(codec, init_list[i].reg,
159 static const u16 rt5639_reg[RT5639_VENDOR_ID2 + 1] = {
160 [RT5639_RESET] = 0x000c,
161 [RT5639_SPK_VOL] = 0xc8c8,
162 [RT5639_HP_VOL] = 0xc8c8,
163 [RT5639_OUTPUT] = 0xc8c8,
164 [RT5639_MONO_OUT] = 0x8000,
165 [RT5639_INL_INR_VOL] = 0x0808,
166 [RT5639_DAC1_DIG_VOL] = 0xafaf,
167 [RT5639_DAC2_DIG_VOL] = 0xafaf,
168 [RT5639_ADC_DIG_VOL] = 0x2f2f,
169 [RT5639_ADC_DATA] = 0x2f2f,
170 [RT5639_STO_ADC_MIXER] = 0x7060,
171 [RT5639_MONO_ADC_MIXER] = 0x7070,
172 [RT5639_AD_DA_MIXER] = 0x8080,
173 [RT5639_STO_DAC_MIXER] = 0x5454,
174 [RT5639_MONO_DAC_MIXER] = 0x5454,
175 [RT5639_DIG_MIXER] = 0xaa00,
176 [RT5639_DSP_PATH2] = 0xa000,
177 [RT5639_REC_L2_MIXER] = 0x007f,
178 [RT5639_REC_R2_MIXER] = 0x007f,
179 [RT5639_HPO_MIXER] = 0xe000,
180 [RT5639_SPK_L_MIXER] = 0x003e,
181 [RT5639_SPK_R_MIXER] = 0x003e,
182 [RT5639_SPO_L_MIXER] = 0xf800,
183 [RT5639_SPO_R_MIXER] = 0x3800,
184 [RT5639_SPO_CLSD_RATIO] = 0x0004,
185 [RT5639_MONO_MIXER] = 0xfc00,
186 [RT5639_OUT_L3_MIXER] = 0x01ff,
187 [RT5639_OUT_R3_MIXER] = 0x01ff,
188 [RT5639_LOUT_MIXER] = 0xf000,
189 [RT5639_PWR_ANLG1] = 0x00c0,
190 [RT5639_I2S1_SDP] = 0x8000,
191 [RT5639_I2S2_SDP] = 0x8000,
192 [RT5639_I2S3_SDP] = 0x8000,
193 [RT5639_ADDA_CLK1] = 0x1110,
194 [RT5639_ADDA_CLK2] = 0x0c00,
195 [RT5639_DMIC] = 0x1d00,
196 [RT5639_ASRC_3] = 0x0008,
197 [RT5639_HP_OVCD] = 0x0600,
198 [RT5639_CLS_D_OVCD] = 0x0201, /*Init to 0.15A OVCD */
199 [RT5639_CLS_D_OUT] = 0xa800,
200 [RT5639_DEPOP_M1] = 0x0004,
201 [RT5639_DEPOP_M2] = 0x1100,
202 [RT5639_DEPOP_M3] = 0x0646,
203 [RT5639_CHARGE_PUMP] = 0x0c00,
204 [RT5639_MICBIAS] = 0x3000,
205 [RT5639_EQ_CTRL1] = 0x2080,
206 [RT5639_DRC_AGC_1] = 0xe206,
207 [RT5639_DRC_AGC_2] = 0x1f00,
208 [RT5639_DRC_AGC_3] = 0x6040,
209 [RT5639_ANC_CTRL1] = 0x034b,
210 [RT5639_ANC_CTRL2] = 0x0066,
211 [RT5639_ANC_CTRL3] = 0x000b,
212 [RT5639_GPIO_CTRL1] = 0x0400,
213 [RT5639_DSP_CTRL3] = 0x2000,
214 [RT5639_BASE_BACK] = 0x0013,
215 [RT5639_MP3_PLUS1] = 0x0680,
216 [RT5639_MP3_PLUS2] = 0x1c17,
217 [RT5639_3D_HP] = 0x8c00,
218 [RT5639_ADJ_HPF] = 0xaa20,
219 [RT5639_HP_CALIB_AMP_DET] = 0x0400,
220 [RT5639_SV_ZCD1] = 0x0809,
221 [RT5639_VENDOR_ID1] = 0x10ec,
222 [RT5639_VENDOR_ID2] = 0x6231,
225 static int rt5639_reset(struct snd_soc_codec *codec)
227 return snd_soc_write(codec, RT5639_RESET, 0);
231 * rt5639_index_write - Write private register.
232 * @codec: SoC audio codec device.
233 * @reg: Private register index.
234 * @value: Private register Data.
236 * Modify private register for advanced setting. It can be written through
237 * private index (0x6a) and data (0x6c) register.
239 * Returns 0 for success or negative error code.
241 static int rt5639_index_write(struct snd_soc_codec *codec,
242 unsigned int reg, unsigned int value)
246 ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
248 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
251 ret = snd_soc_write(codec, RT5639_PRIV_DATA, value);
253 dev_err(codec->dev, "Failed to set private value: %d\n", ret);
263 * rt5639_index_read - Read private register.
264 * @codec: SoC audio codec device.
265 * @reg: Private register index.
267 * Read advanced setting from private register. It can be read through
268 * private index (0x6a) and data (0x6c) register.
270 * Returns private register value or negative error code.
272 static unsigned int rt5639_index_read(
273 struct snd_soc_codec *codec, unsigned int reg)
277 ret = snd_soc_write(codec, RT5639_PRIV_INDEX, reg);
279 dev_err(codec->dev, "Failed to set private addr: %d\n", ret);
282 return snd_soc_read(codec, RT5639_PRIV_DATA);
286 * rt5639_index_update_bits - update private register bits
287 * @codec: audio codec
288 * @reg: Private register index.
289 * @mask: register mask
292 * Writes new register value.
294 * Returns 1 for change, 0 for no change, or negative error code.
296 static int rt5639_index_update_bits(struct snd_soc_codec *codec,
297 unsigned int reg, unsigned int mask, unsigned int value)
299 unsigned int old, new;
302 ret = rt5639_index_read(codec, reg);
304 dev_err(codec->dev, "Failed to read private reg: %d\n", ret);
309 new = (old & ~mask) | (value & mask);
312 ret = rt5639_index_write(codec, reg, new);
315 "Failed to write private reg: %d\n", ret);
325 static int rt5639_volatile_register(
326 struct snd_soc_codec *codec, unsigned int reg)
330 case RT5639_PRIV_DATA:
332 case RT5639_EQ_CTRL1:
333 case RT5639_DRC_AGC_1:
334 case RT5639_ANC_CTRL1:
335 case RT5639_IRQ_CTRL2:
336 case RT5639_INT_IRQ_ST:
337 case RT5639_DSP_CTRL2:
338 case RT5639_DSP_CTRL3:
339 case RT5639_PGM_REG_ARR1:
340 case RT5639_PGM_REG_ARR3:
341 case RT5639_VENDOR_ID:
342 case RT5639_VENDOR_ID1:
343 case RT5639_VENDOR_ID2:
350 static int rt5639_readable_register(
351 struct snd_soc_codec *codec, unsigned int reg)
358 case RT5639_MONO_OUT:
361 case RT5639_INL_INR_VOL:
362 case RT5639_DAC1_DIG_VOL:
363 case RT5639_DAC2_DIG_VOL:
364 case RT5639_DAC2_CTRL:
365 case RT5639_ADC_DIG_VOL:
366 case RT5639_ADC_DATA:
367 case RT5639_ADC_BST_VOL:
368 case RT5639_STO_ADC_MIXER:
369 case RT5639_MONO_ADC_MIXER:
370 case RT5639_AD_DA_MIXER:
371 case RT5639_STO_DAC_MIXER:
372 case RT5639_MONO_DAC_MIXER:
373 case RT5639_DIG_MIXER:
374 case RT5639_DSP_PATH1:
375 case RT5639_DSP_PATH2:
376 case RT5639_DIG_INF_DATA:
377 case RT5639_REC_L1_MIXER:
378 case RT5639_REC_L2_MIXER:
379 case RT5639_REC_R1_MIXER:
380 case RT5639_REC_R2_MIXER:
381 case RT5639_HPO_MIXER:
382 case RT5639_SPK_L_MIXER:
383 case RT5639_SPK_R_MIXER:
384 case RT5639_SPO_L_MIXER:
385 case RT5639_SPO_R_MIXER:
386 case RT5639_SPO_CLSD_RATIO:
387 case RT5639_MONO_MIXER:
388 case RT5639_OUT_L1_MIXER:
389 case RT5639_OUT_L2_MIXER:
390 case RT5639_OUT_L3_MIXER:
391 case RT5639_OUT_R1_MIXER:
392 case RT5639_OUT_R2_MIXER:
393 case RT5639_OUT_R3_MIXER:
394 case RT5639_LOUT_MIXER:
395 case RT5639_PWR_DIG1:
396 case RT5639_PWR_DIG2:
397 case RT5639_PWR_ANLG1:
398 case RT5639_PWR_ANLG2:
399 case RT5639_PWR_MIXER:
401 case RT5639_PRIV_INDEX:
402 case RT5639_PRIV_DATA:
403 case RT5639_I2S1_SDP:
404 case RT5639_I2S2_SDP:
405 case RT5639_I2S3_SDP:
406 case RT5639_ADDA_CLK1:
407 case RT5639_ADDA_CLK2:
410 case RT5639_PLL_CTRL1:
411 case RT5639_PLL_CTRL2:
418 case RT5639_CLS_D_OVCD:
419 case RT5639_CLS_D_OUT:
420 case RT5639_DEPOP_M1:
421 case RT5639_DEPOP_M2:
422 case RT5639_DEPOP_M3:
423 case RT5639_CHARGE_PUMP:
424 case RT5639_PV_DET_SPK_G:
426 case RT5639_EQ_CTRL1:
427 case RT5639_EQ_CTRL2:
428 case RT5639_WIND_FILTER:
429 case RT5639_DRC_AGC_1:
430 case RT5639_DRC_AGC_2:
431 case RT5639_DRC_AGC_3:
433 case RT5639_ANC_CTRL1:
434 case RT5639_ANC_CTRL2:
435 case RT5639_ANC_CTRL3:
438 case RT5639_IRQ_CTRL1:
439 case RT5639_IRQ_CTRL2:
440 case RT5639_INT_IRQ_ST:
441 case RT5639_GPIO_CTRL1:
442 case RT5639_GPIO_CTRL2:
443 case RT5639_GPIO_CTRL3:
444 case RT5639_DSP_CTRL1:
445 case RT5639_DSP_CTRL2:
446 case RT5639_DSP_CTRL3:
447 case RT5639_DSP_CTRL4:
448 case RT5639_PGM_REG_ARR1:
449 case RT5639_PGM_REG_ARR2:
450 case RT5639_PGM_REG_ARR3:
451 case RT5639_PGM_REG_ARR4:
452 case RT5639_PGM_REG_ARR5:
453 case RT5639_SCB_FUNC:
454 case RT5639_SCB_CTRL:
455 case RT5639_BASE_BACK:
456 case RT5639_MP3_PLUS1:
457 case RT5639_MP3_PLUS2:
460 case RT5639_HP_CALIB_AMP_DET:
461 case RT5639_HP_CALIB2:
464 case RT5639_GEN_CTRL1:
465 case RT5639_GEN_CTRL2:
466 case RT5639_GEN_CTRL3:
467 case RT5639_VENDOR_ID:
468 case RT5639_VENDOR_ID1:
469 case RT5639_VENDOR_ID2:
470 case RT5639_DUMMY_PR3F:
477 static void DC_Calibrate(struct snd_soc_codec *codec)
479 unsigned int sclk_src;
481 sclk_src = snd_soc_read(codec, RT5639_GLB_CLK) &
482 RT5639_SCLK_SRC_MASK;
484 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
485 RT5639_PWR_MB1, RT5639_PWR_MB1);
486 snd_soc_update_bits(codec, RT5639_DEPOP_M2,
487 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
488 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
489 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK | RT5639_HP_CB_MASK,
490 RT5639_HP_CP_PU | RT5639_HP_SG_DIS | RT5639_HP_CB_PU);
492 snd_soc_update_bits(codec, RT5639_GLB_CLK,
493 RT5639_SCLK_SRC_MASK, 0x2 << RT5639_SCLK_SRC_SFT);
495 rt5639_index_write(codec, RT5639_HP_DCC_INT1, 0x9f00);
496 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
498 snd_soc_update_bits(codec, RT5639_GLB_CLK,
499 RT5639_SCLK_SRC_MASK, sclk_src);
503 * rt5639_headset_detect - Detect headset.
504 * @codec: SoC audio codec device.
505 * @jack_insert: Jack insert or not.
507 * Detect whether is headset or not when jack inserted.
509 * Returns detect status.
511 int rt5639_headset_detect(struct snd_soc_codec *codec, int jack_insert)
514 int sclk_src = RT5639_SCLK_S_MCLK;
516 int i, headphone = 0, headset = 0, previous_state = RT5639_NO_JACK;
517 bool hp_detected = false;
518 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
521 reg63 = snd_soc_read(codec, RT5639_PWR_ANLG1);
522 reg64 = snd_soc_read(codec, RT5639_PWR_ANLG2);
523 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
524 snd_soc_write(codec, RT5639_PWR_ANLG1, 0xa814);
525 snd_soc_write(codec, RT5639_MICBIAS, 0x3810);
526 snd_soc_write(codec, RT5639_GEN_CTRL1 , 0x3b01);
527 snd_soc_update_bits(codec, RT5639_GLB_CLK,
528 RT5639_SCLK_SRC_MASK,
529 0x3 << RT5639_SCLK_SRC_SFT);
531 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
532 RT5639_PWR_LDO2, RT5639_PWR_LDO2);
533 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
534 RT5639_PWR_MB1, RT5639_PWR_MB1);
535 snd_soc_update_bits(codec, RT5639_MICBIAS,
536 RT5639_MIC1_OVCD_MASK | RT5639_MIC1_OVTH_MASK |
537 RT5639_PWR_CLK25M_MASK | RT5639_PWR_MB_MASK,
538 RT5639_MIC1_OVCD_EN | RT5639_MIC1_OVTH_600UA |
539 RT5639_PWR_MB_PD | RT5639_PWR_CLK25M_PU);
540 rt5639_index_update_bits(codec, 0x15, 0x0300, 0x0300);
541 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
545 dev_info(codec->dev, "%s RT5639_PWR_ANLG1(0x%x) = 0x%x\n",
546 __func__, RT5639_PWR_ANLG1,
547 snd_soc_read(codec, RT5639_PWR_ANLG1));
548 dev_info(codec->dev, "%s RT5639_IRQ_CTRL2(0x%x) = 0x%x\n",
549 __func__, RT5639_IRQ_CTRL2,
550 snd_soc_read(codec, RT5639_IRQ_CTRL2));
552 for (i = 0; i < 450; i++) {
553 if (snd_soc_read(codec, RT5639_IRQ_CTRL2) & 0x8) {
554 if (previous_state == RT5639_HEADPHO_DET) {
558 previous_state = RT5639_HEADPHO_DET;
561 if (previous_state == RT5639_HEADSET_DET) {
565 previous_state = RT5639_HEADSET_DET;
569 if (headphone == 50) {
570 jack_type = RT5639_HEADPHO_DET;
576 jack_type = RT5639_HEADSET_DET;
588 for (i = 0; i < 50; i++) {
589 if (snd_soc_read(codec, RT5639_IRQ_CTRL2) & 0x8)
597 if (headset >= headphone)
598 jack_type = RT5639_HEADSET_DET;
600 jack_type = RT5639_HEADPHO_DET;
603 snd_soc_update_bits(codec, RT5639_IRQ_CTRL2,
604 RT5639_MB1_OC_CLR, 0);
606 switch (rt5639->sysclk_src) {
607 case RT5639_SCLK_S_MCLK:
608 sclk_src = RT5639_SCLK_SRC_MCLK;
610 case RT5639_SCLK_S_PLL1:
611 sclk_src = RT5639_SCLK_SRC_PLL1;
613 case RT5639_SCLK_S_RCCLK:
614 sclk_src = RT5639_SCLK_SRC_RCCLK;
617 dev_err(codec->dev, "Invalid clock id (%d)\n",
621 snd_soc_update_bits(codec, RT5639_GLB_CLK,
622 RT5639_SCLK_SRC_MASK, sclk_src);
623 snd_soc_write(codec, RT5639_PWR_ANLG1, reg63);
624 snd_soc_write(codec, RT5639_PWR_ANLG2, reg64);
626 snd_soc_update_bits(codec, RT5639_MICBIAS,
627 RT5639_MIC1_OVCD_MASK,
628 RT5639_MIC1_OVCD_DIS);
630 jack_type = RT5639_NO_JACK;
632 dev_info(codec->dev, "%s jack_type = %d\n", __func__, jack_type);
636 EXPORT_SYMBOL(rt5639_headset_detect);
640 * rt5639_conn_mux_path - connect MUX widget path.
641 * @codec: SoC audio codec device.
642 * @widget_name: widget name.
643 * @path_name: path name.
645 * Make MUX path connected and update register.
647 * Returns 0 for success or negative error code.
649 int rt5639_conn_mux_path(struct snd_soc_codec *codec,
650 char *widget_name, char *path_name)
652 struct snd_soc_dapm_context *dapm = &codec->dapm;
653 struct snd_soc_dapm_widget *w;
654 struct snd_soc_dapm_path *path;
655 struct snd_kcontrol_new *kcontrol;
657 unsigned int val, mask, bitmask;
660 if (codec == NULL || widget_name == NULL || path_name == NULL)
663 list_for_each_entry(w, &dapm->card->widgets, list)
665 if (!w->name || w->dapm != dapm)
667 if (!(strcmp(w->name, widget_name))) {
668 if (w->id != snd_soc_dapm_mux)
670 dev_info(codec->dev, "w->name=%s\n", w->name);
671 list_for_each_entry(path, &w->sources, list_sink)
673 if (!(strcmp(path->name, path_name)))
678 "path->name=%s path->connect=%d\n",
679 path->name, path->connect);
687 snd_soc_dapm_sync(dapm);
689 kcontrol = &w->kcontrols[0];
690 em = (struct soc_enum *)kcontrol->private_value;
691 for (i = 0; i < em->max; i++)
692 if (!(strcmp(path_name, em->texts[i])))
694 for (bitmask = 1; bitmask < em->max; bitmask <<= 1)
696 val = i << em->shift_l;
697 mask = (bitmask - 1) << em->shift_l;
698 snd_soc_update_bits(codec, em->reg, mask, val);
703 EXPORT_SYMBOL(rt5639_conn_mux_path);
705 static const char * const rt5639_dacr2_src[] = { "TxDC_R", "TxDP_R" };
707 static const SOC_ENUM_SINGLE_DECL(rt5639_dacr2_enum, RT5639_DUMMY_PR3F,
708 14, rt5639_dacr2_src);
709 static const struct snd_kcontrol_new rt5639_dacr2_mux =
710 SOC_DAPM_ENUM("Mono dacr source", rt5639_dacr2_enum);
712 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
713 static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
714 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
715 static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
716 static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
718 /* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
719 static unsigned int bst_tlv[] = {
720 TLV_DB_RANGE_HEAD(7),
721 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
722 1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
723 2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
724 3, 5, TLV_DB_SCALE_ITEM(3000, 500, 0),
725 6, 6, TLV_DB_SCALE_ITEM(4400, 0, 0),
726 7, 7, TLV_DB_SCALE_ITEM(5000, 0, 0),
727 8, 8, TLV_DB_SCALE_ITEM(5200, 0, 0),
730 static int rt5639_dmic_get(struct snd_kcontrol *kcontrol,
731 struct snd_ctl_elem_value *ucontrol)
733 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
734 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
736 ucontrol->value.integer.value[0] = rt5639->dmic_en;
741 static int rt5639_dmic_put(struct snd_kcontrol *kcontrol,
742 struct snd_ctl_elem_value *ucontrol)
744 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
745 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
747 if (rt5639->dmic_en == ucontrol->value.integer.value[0])
750 rt5639->dmic_en = ucontrol->value.integer.value[0];
751 switch (rt5639->dmic_en) {
752 case RT5639_DMIC_DIS:
753 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
754 RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK |
756 RT5639_GP2_PIN_GPIO2 | RT5639_GP3_PIN_GPIO3 |
757 RT5639_GP4_PIN_GPIO4);
758 snd_soc_update_bits(codec, RT5639_DMIC,
759 RT5639_DMIC_1_DP_MASK | RT5639_DMIC_2_DP_MASK,
760 RT5639_DMIC_1_DP_GPIO3 | RT5639_DMIC_2_DP_GPIO4);
761 snd_soc_update_bits(codec, RT5639_DMIC,
762 RT5639_DMIC_1_EN_MASK | RT5639_DMIC_2_EN_MASK,
763 RT5639_DMIC_1_DIS | RT5639_DMIC_2_DIS);
767 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
768 RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK,
769 RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP3_PIN_DMIC1_SDA);
770 snd_soc_update_bits(codec, RT5639_DMIC,
771 RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK |
772 RT5639_DMIC_1_DP_MASK,
773 RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING |
774 RT5639_DMIC_1_DP_IN1P);
775 snd_soc_update_bits(codec, RT5639_DMIC,
776 RT5639_DMIC_1_EN_MASK, RT5639_DMIC_1_EN);
780 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
781 RT5639_GP2_PIN_MASK | RT5639_GP4_PIN_MASK,
782 RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP4_PIN_DMIC2_SDA);
783 snd_soc_update_bits(codec, RT5639_DMIC,
784 RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK |
785 RT5639_DMIC_2_DP_MASK,
786 RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING |
787 RT5639_DMIC_2_DP_IN1N);
788 snd_soc_update_bits(codec, RT5639_DMIC,
789 RT5639_DMIC_2_EN_MASK, RT5639_DMIC_2_EN);
800 /* IN1/IN2 Input Type */
801 static const char *rt5639_input_mode[] = {
802 "Single ended", "Differential"};
804 static const SOC_ENUM_SINGLE_DECL(
805 rt5639_in1_mode_enum, RT5639_IN1_IN2,
806 RT5639_IN_SFT1, rt5639_input_mode);
808 static const SOC_ENUM_SINGLE_DECL(
809 rt5639_in2_mode_enum, RT5639_IN3_IN4,
810 RT5639_IN_SFT2, rt5639_input_mode);
812 /* Interface data select */
813 static const char *rt5639_data_select[] = {
814 "Normal", "Swap", "left copy to right", "right copy to left"};
816 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_dac_enum, RT5639_DIG_INF_DATA,
817 RT5639_IF1_DAC_SEL_SFT, rt5639_data_select);
819 static const SOC_ENUM_SINGLE_DECL(rt5639_if1_adc_enum, RT5639_DIG_INF_DATA,
820 RT5639_IF1_ADC_SEL_SFT, rt5639_data_select);
822 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_dac_enum, RT5639_DIG_INF_DATA,
823 RT5639_IF2_DAC_SEL_SFT, rt5639_data_select);
825 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_enum, RT5639_DIG_INF_DATA,
826 RT5639_IF2_ADC_SEL_SFT, rt5639_data_select);
828 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_dac_enum, RT5639_DIG_INF_DATA,
829 RT5639_IF3_DAC_SEL_SFT, rt5639_data_select);
831 static const SOC_ENUM_SINGLE_DECL(rt5639_if3_adc_enum, RT5639_DIG_INF_DATA,
832 RT5639_IF3_ADC_SEL_SFT, rt5639_data_select);
834 /* Class D speaker gain ratio */
835 static const char *rt5639_clsd_spk_ratio[] = {"1.66x", "1.83x", "1.94x", "2x",
836 "2.11x", "2.22x", "2.33x", "2.44x", "2.55x", "2.66x", "2.77x"};
838 static const SOC_ENUM_SINGLE_DECL(
839 rt5639_clsd_spk_ratio_enum, RT5639_CLS_D_OUT,
840 RT5639_CLSD_RATIO_SFT, rt5639_clsd_spk_ratio);
843 static const char *rt5639_dmic_mode[] = {"Disable", "DMIC1", "DMIC2"};
845 static const SOC_ENUM_SINGLE_DECL(rt5639_dmic_enum, 0, 0, rt5639_dmic_mode);
850 #define REGVAL_MAX 0xffff
851 static unsigned int regctl_addr;
852 static int rt5639_regctl_info(struct snd_kcontrol *kcontrol,
853 struct snd_ctl_elem_info *uinfo)
855 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
857 uinfo->value.integer.min = 0;
858 uinfo->value.integer.max = REGVAL_MAX;
862 static int rt5639_regctl_get(struct snd_kcontrol *kcontrol,
863 struct snd_ctl_elem_value *ucontrol)
865 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
866 ucontrol->value.integer.value[0] = regctl_addr;
867 ucontrol->value.integer.value[1] = snd_soc_read(codec, regctl_addr);
871 static int rt5639_regctl_put(struct snd_kcontrol *kcontrol,
872 struct snd_ctl_elem_value *ucontrol)
874 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
875 regctl_addr = ucontrol->value.integer.value[0];
876 if(ucontrol->value.integer.value[1] <= REGVAL_MAX)
877 snd_soc_write(codec, regctl_addr, ucontrol->value.integer.value[1]);
883 static int rt5639_vol_rescale_get(struct snd_kcontrol *kcontrol,
884 struct snd_ctl_elem_value *ucontrol)
886 struct soc_mixer_control *mc =
887 (struct soc_mixer_control *)kcontrol->private_value;
888 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
889 unsigned int val = snd_soc_read(codec, mc->reg);
891 ucontrol->value.integer.value[0] = RT5639_VOL_RSCL_MAX -
892 ((val & RT5639_L_VOL_MASK) >> mc->shift);
893 ucontrol->value.integer.value[1] = RT5639_VOL_RSCL_MAX -
894 (val & RT5639_R_VOL_MASK);
899 static int rt5639_vol_rescale_put(struct snd_kcontrol *kcontrol,
900 struct snd_ctl_elem_value *ucontrol)
902 struct soc_mixer_control *mc =
903 (struct soc_mixer_control *)kcontrol->private_value;
904 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
905 unsigned int val, val2;
907 val = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[0];
908 val2 = RT5639_VOL_RSCL_MAX - ucontrol->value.integer.value[1];
909 return snd_soc_update_bits_locked(codec, mc->reg, RT5639_L_VOL_MASK |
910 RT5639_R_VOL_MASK, val << mc->shift | val2);
914 static const struct snd_kcontrol_new rt5639_snd_controls[] = {
915 /* Speaker Output Volume */
916 SOC_DOUBLE("Speaker Playback Switch", RT5639_SPK_VOL,
917 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
918 SOC_DOUBLE_EXT_TLV("Speaker Playback Volume", RT5639_SPK_VOL,
919 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
920 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
921 /* Headphone Output Volume */
922 SOC_DOUBLE("HP Playback Switch", RT5639_HP_VOL,
923 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
924 SOC_DOUBLE_EXT_TLV("HP Playback Volume", RT5639_HP_VOL,
925 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, RT5639_VOL_RSCL_RANGE, 0,
926 rt5639_vol_rescale_get, rt5639_vol_rescale_put, out_vol_tlv),
928 SOC_DOUBLE("OUT Playback Switch", RT5639_OUTPUT,
929 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
930 SOC_DOUBLE("OUT Channel Switch", RT5639_OUTPUT,
931 RT5639_VOL_L_SFT, RT5639_VOL_R_SFT, 1, 1),
932 SOC_DOUBLE_TLV("OUT Playback Volume", RT5639_OUTPUT,
933 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT, 39, 1, out_vol_tlv),
934 /* MONO Output Control */
935 SOC_SINGLE("Mono Playback Switch", RT5639_MONO_OUT,
936 RT5639_L_MUTE_SFT, 1, 1),
937 /* DAC Digital Volume */
938 SOC_DOUBLE("DAC2 Playback Switch", RT5639_DAC2_CTRL,
939 RT5639_M_DAC_L2_VOL_SFT, RT5639_M_DAC_R2_VOL_SFT, 1, 1),
940 SOC_DOUBLE_TLV("DAC1 Playback Volume", RT5639_DAC1_DIG_VOL,
941 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
942 175, 0, dac_vol_tlv),
943 SOC_DOUBLE_TLV("Mono DAC Playback Volume", RT5639_DAC2_DIG_VOL,
944 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
945 175, 0, dac_vol_tlv),
946 /* IN1/IN2 Control */
947 SOC_ENUM("IN1 Mode Control", rt5639_in1_mode_enum),
948 SOC_SINGLE_TLV("IN1 Boost", RT5639_IN1_IN2,
949 RT5639_BST_SFT1, 8, 0, bst_tlv),
950 SOC_ENUM("IN2 Mode Control", rt5639_in2_mode_enum),
951 SOC_SINGLE_TLV("IN2 Boost", RT5639_IN3_IN4,
952 RT5639_BST_SFT2, 8, 0, bst_tlv),
953 /* INL/INR Volume Control */
954 SOC_DOUBLE_TLV("IN Capture Volume", RT5639_INL_INR_VOL,
955 RT5639_INL_VOL_SFT, RT5639_INR_VOL_SFT,
957 /* ADC Digital Volume Control */
958 SOC_DOUBLE("ADC Capture Switch", RT5639_ADC_DIG_VOL,
959 RT5639_L_MUTE_SFT, RT5639_R_MUTE_SFT, 1, 1),
960 SOC_DOUBLE_TLV("ADC Capture Volume", RT5639_ADC_DIG_VOL,
961 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
962 127, 0, adc_vol_tlv),
963 SOC_DOUBLE_TLV("Mono ADC Capture Volume", RT5639_ADC_DATA,
964 RT5639_L_VOL_SFT, RT5639_R_VOL_SFT,
965 127, 0, adc_vol_tlv),
966 /* ADC Boost Volume Control */
967 SOC_DOUBLE_TLV("ADC Boost Gain", RT5639_ADC_BST_VOL,
968 RT5639_ADC_L_BST_SFT, RT5639_ADC_R_BST_SFT,
970 /* Class D speaker gain ratio */
971 SOC_ENUM("Class D SPK Ratio Control", rt5639_clsd_spk_ratio_enum),
973 SOC_ENUM_EXT("DMIC Switch", rt5639_dmic_enum,
974 rt5639_dmic_get, rt5639_dmic_put),
976 SOC_ENUM("ADC IF1 Data Switch", rt5639_if1_adc_enum),
977 SOC_ENUM("DAC IF1 Data Switch", rt5639_if1_dac_enum),
978 SOC_ENUM("ADC IF2 Data Switch", rt5639_if2_adc_enum),
979 SOC_ENUM("DAC IF2 Data Switch", rt5639_if2_dac_enum),
982 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
983 .name = "Register Control",
984 .info = rt5639_regctl_info,
985 .get = rt5639_regctl_get,
986 .put = rt5639_regctl_put,
992 * set_dmic_clk - Set parameter of dmic.
995 * @kcontrol: The kcontrol of this widget.
998 * Choose dmic clock between 1MHz and 3MHz.
999 * It is better for clock to approximate 3MHz.
1001 static int set_dmic_clk(struct snd_soc_dapm_widget *w,
1002 struct snd_kcontrol *kcontrol, int event)
1004 struct snd_soc_codec *codec = w->codec;
1005 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
1006 int div[] = {2, 3, 4, 6, 12}, idx = -EINVAL, i, rate, red, bound, temp;
1008 rate = rt5639->lrck[rt5639->aif_pu] << 8;
1010 for (i = 0; i < ARRAY_SIZE(div); i++) {
1011 bound = div[i] * 3000000;
1014 temp = bound - rate;
1021 dev_err(codec->dev, "Failed to set DMIC clock\n");
1023 snd_soc_update_bits(codec, RT5639_DMIC, RT5639_DMIC_CLK_MASK,
1024 idx << RT5639_DMIC_CLK_SFT);
1028 static int check_sysclk1_source(struct snd_soc_dapm_widget *source,
1029 struct snd_soc_dapm_widget *sink)
1033 val = snd_soc_read(source->codec, RT5639_GLB_CLK);
1034 val &= RT5639_SCLK_SRC_MASK;
1035 if (val == RT5639_SCLK_SRC_PLL1)
1042 static const struct snd_kcontrol_new rt5639_sto_adc_l_mix[] = {
1043 SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
1044 RT5639_M_ADC_L1_SFT, 1, 1),
1045 SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
1046 RT5639_M_ADC_L2_SFT, 1, 1),
1049 static const struct snd_kcontrol_new rt5639_sto_adc_r_mix[] = {
1050 SOC_DAPM_SINGLE("ADC1 Switch", RT5639_STO_ADC_MIXER,
1051 RT5639_M_ADC_R1_SFT, 1, 1),
1052 SOC_DAPM_SINGLE("ADC2 Switch", RT5639_STO_ADC_MIXER,
1053 RT5639_M_ADC_R2_SFT, 1, 1),
1056 static const struct snd_kcontrol_new rt5639_mono_adc_l_mix[] = {
1057 SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
1058 RT5639_M_MONO_ADC_L1_SFT, 1, 1),
1059 SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
1060 RT5639_M_MONO_ADC_L2_SFT, 1, 1),
1063 static const struct snd_kcontrol_new rt5639_mono_adc_r_mix[] = {
1064 SOC_DAPM_SINGLE("ADC1 Switch", RT5639_MONO_ADC_MIXER,
1065 RT5639_M_MONO_ADC_R1_SFT, 1, 1),
1066 SOC_DAPM_SINGLE("ADC2 Switch", RT5639_MONO_ADC_MIXER,
1067 RT5639_M_MONO_ADC_R2_SFT, 1, 1),
1070 static const struct snd_kcontrol_new rt5639_dac_l_mix[] = {
1071 SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
1072 RT5639_M_ADCMIX_L_SFT, 1, 1),
1073 SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
1074 RT5639_M_IF1_DAC_L_SFT, 1, 1),
1077 static const struct snd_kcontrol_new rt5639_dac_r_mix[] = {
1078 SOC_DAPM_SINGLE("Stereo ADC Switch", RT5639_AD_DA_MIXER,
1079 RT5639_M_ADCMIX_R_SFT, 1, 1),
1080 SOC_DAPM_SINGLE("INF1 Switch", RT5639_AD_DA_MIXER,
1081 RT5639_M_IF1_DAC_R_SFT, 1, 1),
1084 static const struct snd_kcontrol_new rt5639_sto_dac_l_mix[] = {
1085 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_STO_DAC_MIXER,
1086 RT5639_M_DAC_L1_SFT, 1, 1),
1087 SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_STO_DAC_MIXER,
1088 RT5639_M_DAC_L2_SFT, 1, 1),
1089 SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
1090 RT5639_M_ANC_DAC_L_SFT, 1, 1),
1093 static const struct snd_kcontrol_new rt5639_sto_dac_r_mix[] = {
1094 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_STO_DAC_MIXER,
1095 RT5639_M_DAC_R1_SFT, 1, 1),
1096 SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_STO_DAC_MIXER,
1097 RT5639_M_DAC_R2_SFT, 1, 1),
1098 SOC_DAPM_SINGLE("ANC Switch", RT5639_STO_DAC_MIXER,
1099 RT5639_M_ANC_DAC_R_SFT, 1, 1),
1102 static const struct snd_kcontrol_new rt5639_mono_dac_l_mix[] = {
1103 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_MONO_DAC_MIXER,
1104 RT5639_M_DAC_L1_MONO_L_SFT, 1, 1),
1105 SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
1106 RT5639_M_DAC_L2_MONO_L_SFT, 1, 1),
1107 SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
1108 RT5639_M_DAC_R2_MONO_L_SFT, 1, 1),
1111 static const struct snd_kcontrol_new rt5639_mono_dac_r_mix[] = {
1112 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_MONO_DAC_MIXER,
1113 RT5639_M_DAC_R1_MONO_R_SFT, 1, 1),
1114 SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_DAC_MIXER,
1115 RT5639_M_DAC_R2_MONO_R_SFT, 1, 1),
1116 SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_DAC_MIXER,
1117 RT5639_M_DAC_L2_MONO_R_SFT, 1, 1),
1120 static const struct snd_kcontrol_new rt5639_dig_l_mix[] = {
1121 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_DIG_MIXER,
1122 RT5639_M_STO_L_DAC_L_SFT, 1, 1),
1123 SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_DIG_MIXER,
1124 RT5639_M_DAC_L2_DAC_L_SFT, 1, 1),
1127 static const struct snd_kcontrol_new rt5639_dig_r_mix[] = {
1128 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_DIG_MIXER,
1129 RT5639_M_STO_R_DAC_R_SFT, 1, 1),
1130 SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_DIG_MIXER,
1131 RT5639_M_DAC_R2_DAC_R_SFT, 1, 1),
1134 /* Analog Input Mixer */
1135 static const struct snd_kcontrol_new rt5639_rec_l_mix[] = {
1136 SOC_DAPM_SINGLE("HPOL Switch", RT5639_REC_L2_MIXER,
1137 RT5639_M_HP_L_RM_L_SFT, 1, 1),
1138 SOC_DAPM_SINGLE("INL Switch", RT5639_REC_L2_MIXER,
1139 RT5639_M_IN_L_RM_L_SFT, 1, 1),
1140 SOC_DAPM_SINGLE("BST3 Switch", RT5639_REC_L2_MIXER,
1141 RT5639_M_BST2_RM_L_SFT, 1, 1),
1142 SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_L2_MIXER,
1143 RT5639_M_BST4_RM_L_SFT, 1, 1),
1144 SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_L2_MIXER,
1145 RT5639_M_BST1_RM_L_SFT, 1, 1),
1146 SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_REC_L2_MIXER,
1147 RT5639_M_OM_L_RM_L_SFT, 1, 1),
1150 static const struct snd_kcontrol_new rt5639_rec_r_mix[] = {
1151 SOC_DAPM_SINGLE("HPOR Switch", RT5639_REC_R2_MIXER,
1152 RT5639_M_HP_R_RM_R_SFT, 1, 1),
1153 SOC_DAPM_SINGLE("INR Switch", RT5639_REC_R2_MIXER,
1154 RT5639_M_IN_R_RM_R_SFT, 1, 1),
1155 SOC_DAPM_SINGLE("BST3 Switch", RT5639_REC_R2_MIXER,
1156 RT5639_M_BST2_RM_R_SFT, 1, 1),
1157 SOC_DAPM_SINGLE("BST2 Switch", RT5639_REC_R2_MIXER,
1158 RT5639_M_BST4_RM_R_SFT, 1, 1),
1159 SOC_DAPM_SINGLE("BST1 Switch", RT5639_REC_R2_MIXER,
1160 RT5639_M_BST1_RM_R_SFT, 1, 1),
1161 SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_REC_R2_MIXER,
1162 RT5639_M_OM_R_RM_R_SFT, 1, 1),
1165 /* Analog Output Mixer */
1166 static const struct snd_kcontrol_new rt5639_spk_l_mix[] = {
1167 SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_SPK_L_MIXER,
1168 RT5639_M_RM_L_SM_L_SFT, 1, 1),
1169 SOC_DAPM_SINGLE("INL Switch", RT5639_SPK_L_MIXER,
1170 RT5639_M_IN_L_SM_L_SFT, 1, 1),
1171 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPK_L_MIXER,
1172 RT5639_M_DAC_L1_SM_L_SFT, 1, 1),
1173 SOC_DAPM_SINGLE("OUT MIXL Switch", RT5639_SPK_L_MIXER,
1174 RT5639_M_OM_L_SM_L_SFT, 1, 1),
1177 static const struct snd_kcontrol_new rt5639_spk_r_mix[] = {
1178 SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_SPK_R_MIXER,
1179 RT5639_M_RM_R_SM_R_SFT, 1, 1),
1180 SOC_DAPM_SINGLE("INR Switch", RT5639_SPK_R_MIXER,
1181 RT5639_M_IN_R_SM_R_SFT, 1, 1),
1182 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPK_R_MIXER,
1183 RT5639_M_DAC_R1_SM_R_SFT, 1, 1),
1184 SOC_DAPM_SINGLE("OUT MIXR Switch", RT5639_SPK_R_MIXER,
1185 RT5639_M_OM_R_SM_R_SFT, 1, 1),
1188 static const struct snd_kcontrol_new rt5639_out_l_mix[] = {
1189 SOC_DAPM_SINGLE("SPK MIXL Switch", RT5639_OUT_L3_MIXER,
1190 RT5639_M_SM_L_OM_L_SFT, 1, 1),
1191 SOC_DAPM_SINGLE("BST3 Switch", RT5639_OUT_L3_MIXER,
1192 RT5639_M_BST2_OM_L_SFT, 1, 1),
1193 SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_L3_MIXER,
1194 RT5639_M_BST1_OM_L_SFT, 1, 1),
1195 SOC_DAPM_SINGLE("INL Switch", RT5639_OUT_L3_MIXER,
1196 RT5639_M_IN_L_OM_L_SFT, 1, 1),
1197 SOC_DAPM_SINGLE("REC MIXL Switch", RT5639_OUT_L3_MIXER,
1198 RT5639_M_RM_L_OM_L_SFT, 1, 1),
1199 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_OUT_L3_MIXER,
1200 RT5639_M_DAC_L1_OM_L_SFT, 1, 1),
1203 static const struct snd_kcontrol_new rt5639_out_r_mix[] = {
1204 SOC_DAPM_SINGLE("SPK MIXR Switch", RT5639_OUT_R3_MIXER,
1205 RT5639_M_SM_L_OM_R_SFT, 1, 1),
1206 SOC_DAPM_SINGLE("BST3 Switch", RT5639_OUT_R3_MIXER,
1207 RT5639_M_BST2_OM_R_SFT, 1, 1),
1208 SOC_DAPM_SINGLE("BST2 Switch", RT5639_OUT_R3_MIXER,
1209 RT5639_M_BST4_OM_R_SFT, 1, 1),
1210 SOC_DAPM_SINGLE("BST1 Switch", RT5639_OUT_R3_MIXER,
1211 RT5639_M_BST1_OM_R_SFT, 1, 1),
1212 SOC_DAPM_SINGLE("INR Switch", RT5639_OUT_R3_MIXER,
1213 RT5639_M_IN_R_OM_R_SFT, 1, 1),
1214 SOC_DAPM_SINGLE("REC MIXR Switch", RT5639_OUT_R3_MIXER,
1215 RT5639_M_RM_R_OM_R_SFT, 1, 1),
1216 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_OUT_R3_MIXER,
1217 RT5639_M_DAC_R1_OM_R_SFT, 1, 1),
1220 static const struct snd_kcontrol_new rt5639_spo_l_mix[] = {
1221 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_L_MIXER,
1222 RT5639_M_DAC_R1_SPM_L_SFT, 1, 1),
1223 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_SPO_L_MIXER,
1224 RT5639_M_DAC_L1_SPM_L_SFT, 1, 1),
1225 SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_L_MIXER,
1226 RT5639_M_SV_R_SPM_L_SFT, 1, 1),
1227 SOC_DAPM_SINGLE("SPKVOL L Switch", RT5639_SPO_L_MIXER,
1228 RT5639_M_SV_L_SPM_L_SFT, 1, 1),
1229 SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_L_MIXER,
1230 RT5639_M_BST1_SPM_L_SFT, 1, 1),
1233 static const struct snd_kcontrol_new rt5639_spo_r_mix[] = {
1234 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_SPO_R_MIXER,
1235 RT5639_M_DAC_R1_SPM_R_SFT, 1, 1),
1236 SOC_DAPM_SINGLE("SPKVOL R Switch", RT5639_SPO_R_MIXER,
1237 RT5639_M_SV_R_SPM_R_SFT, 1, 1),
1238 SOC_DAPM_SINGLE("BST1 Switch", RT5639_SPO_R_MIXER,
1239 RT5639_M_BST1_SPM_R_SFT, 1, 1),
1242 static const struct snd_kcontrol_new rt5639_hpo_mix[] = {
1243 SOC_DAPM_SINGLE("DAC1 Switch", RT5639_HPO_MIXER,
1244 RT5639_M_DAC1_HM_SFT, 1, 1),
1245 SOC_DAPM_SINGLE("HPVOL Switch", RT5639_HPO_MIXER,
1246 RT5639_M_HPVOL_HM_SFT, 1, 1),
1249 static const struct snd_kcontrol_new rt5639_lout_mix[] = {
1250 SOC_DAPM_SINGLE("DAC L1 Switch", RT5639_LOUT_MIXER,
1251 RT5639_M_DAC_L1_LM_SFT, 1, 1),
1252 SOC_DAPM_SINGLE("DAC R1 Switch", RT5639_LOUT_MIXER,
1253 RT5639_M_DAC_R1_LM_SFT, 1, 1),
1254 SOC_DAPM_SINGLE("OUTVOL L Switch", RT5639_LOUT_MIXER,
1255 RT5639_M_OV_L_LM_SFT, 1, 1),
1256 SOC_DAPM_SINGLE("OUTVOL R Switch", RT5639_LOUT_MIXER,
1257 RT5639_M_OV_R_LM_SFT, 1, 1),
1260 static const struct snd_kcontrol_new rt5639_mono_mix[] = {
1261 SOC_DAPM_SINGLE("DAC R2 Switch", RT5639_MONO_MIXER,
1262 RT5639_M_DAC_R2_MM_SFT, 1, 1),
1263 SOC_DAPM_SINGLE("DAC L2 Switch", RT5639_MONO_MIXER,
1264 RT5639_M_DAC_L2_MM_SFT, 1, 1),
1265 SOC_DAPM_SINGLE("OUTVOL R Switch", RT5639_MONO_MIXER,
1266 RT5639_M_OV_R_MM_SFT, 1, 1),
1267 SOC_DAPM_SINGLE("OUTVOL L Switch", RT5639_MONO_MIXER,
1268 RT5639_M_OV_L_MM_SFT, 1, 1),
1269 SOC_DAPM_SINGLE("BST1 Switch", RT5639_MONO_MIXER,
1270 RT5639_M_BST1_MM_SFT, 1, 1),
1274 static const char *rt5639_inl_src[] = {"IN2P", "MonoP"};
1276 static const SOC_ENUM_SINGLE_DECL(
1277 rt5639_inl_enum, RT5639_INL_INR_VOL,
1278 RT5639_INL_SEL_SFT, rt5639_inl_src);
1280 static const struct snd_kcontrol_new rt5639_inl_mux =
1281 SOC_DAPM_ENUM("INL source", rt5639_inl_enum);
1283 static const char *rt5639_inr_src[] = {"IN2N", "MonoN"};
1285 static const SOC_ENUM_SINGLE_DECL(
1286 rt5639_inr_enum, RT5639_INL_INR_VOL,
1287 RT5639_INR_SEL_SFT, rt5639_inr_src);
1289 static const struct snd_kcontrol_new rt5639_inr_mux =
1290 SOC_DAPM_ENUM("INR source", rt5639_inr_enum);
1292 /* Stereo ADC source */
1293 static const char *rt5639_stereo_adc1_src[] = {"DIG MIX", "ADC"};
1295 static const SOC_ENUM_SINGLE_DECL(
1296 rt5639_stereo_adc1_enum, RT5639_STO_ADC_MIXER,
1297 RT5639_ADC_1_SRC_SFT, rt5639_stereo_adc1_src);
1299 static const struct snd_kcontrol_new rt5639_sto_adc_l1_mux =
1300 SOC_DAPM_ENUM("Stereo ADC L1 source", rt5639_stereo_adc1_enum);
1302 static const struct snd_kcontrol_new rt5639_sto_adc_r1_mux =
1303 SOC_DAPM_ENUM("Stereo ADC R1 source", rt5639_stereo_adc1_enum);
1305 static const char *rt5639_stereo_adc2_src[] = {"DMIC1", "DMIC2", "DIG MIX"};
1307 static const SOC_ENUM_SINGLE_DECL(
1308 rt5639_stereo_adc2_enum, RT5639_STO_ADC_MIXER,
1309 RT5639_ADC_2_SRC_SFT, rt5639_stereo_adc2_src);
1311 static const struct snd_kcontrol_new rt5639_sto_adc_l2_mux =
1312 SOC_DAPM_ENUM("Stereo ADC L2 source", rt5639_stereo_adc2_enum);
1314 static const struct snd_kcontrol_new rt5639_sto_adc_r2_mux =
1315 SOC_DAPM_ENUM("Stereo ADC R2 source", rt5639_stereo_adc2_enum);
1317 /* Mono ADC source */
1318 static const char *rt5639_mono_adc_l1_src[] = {"Mono DAC MIXL", "ADCL"};
1320 static const SOC_ENUM_SINGLE_DECL(
1321 rt5639_mono_adc_l1_enum, RT5639_MONO_ADC_MIXER,
1322 RT5639_MONO_ADC_L1_SRC_SFT, rt5639_mono_adc_l1_src);
1324 static const struct snd_kcontrol_new rt5639_mono_adc_l1_mux =
1325 SOC_DAPM_ENUM("Mono ADC1 left source", rt5639_mono_adc_l1_enum);
1327 static const char *rt5639_mono_adc_l2_src[] =
1328 {"DMIC L1", "DMIC L2", "Mono DAC MIXL"};
1330 static const SOC_ENUM_SINGLE_DECL(
1331 rt5639_mono_adc_l2_enum, RT5639_MONO_ADC_MIXER,
1332 RT5639_MONO_ADC_L2_SRC_SFT, rt5639_mono_adc_l2_src);
1334 static const struct snd_kcontrol_new rt5639_mono_adc_l2_mux =
1335 SOC_DAPM_ENUM("Mono ADC2 left source", rt5639_mono_adc_l2_enum);
1337 static const char *rt5639_mono_adc_r1_src[] = {"Mono DAC MIXR", "ADCR"};
1339 static const SOC_ENUM_SINGLE_DECL(
1340 rt5639_mono_adc_r1_enum, RT5639_MONO_ADC_MIXER,
1341 RT5639_MONO_ADC_R1_SRC_SFT, rt5639_mono_adc_r1_src);
1343 static const struct snd_kcontrol_new rt5639_mono_adc_r1_mux =
1344 SOC_DAPM_ENUM("Mono ADC1 right source", rt5639_mono_adc_r1_enum);
1346 static const char *rt5639_mono_adc_r2_src[] =
1347 {"DMIC R1", "DMIC R2", "Mono DAC MIXR"};
1349 static const SOC_ENUM_SINGLE_DECL(
1350 rt5639_mono_adc_r2_enum, RT5639_MONO_ADC_MIXER,
1351 RT5639_MONO_ADC_R2_SRC_SFT, rt5639_mono_adc_r2_src);
1353 static const struct snd_kcontrol_new rt5639_mono_adc_r2_mux =
1354 SOC_DAPM_ENUM("Mono ADC2 right source", rt5639_mono_adc_r2_enum);
1356 /* DAC2 channel source */
1357 static const char *rt5639_dac_l2_src[] = {"IF2", "IF3", "TxDC", "Base L/R"};
1359 static const SOC_ENUM_SINGLE_DECL(rt5639_dac_l2_enum, RT5639_DSP_PATH2,
1360 RT5639_DAC_L2_SEL_SFT, rt5639_dac_l2_src);
1362 static const struct snd_kcontrol_new rt5639_dac_l2_mux =
1363 SOC_DAPM_ENUM("DAC2 left channel source", rt5639_dac_l2_enum);
1365 static const char *rt5639_dac_r2_src[] = {"IF2", "IF3", "TxDC"};
1367 static const SOC_ENUM_SINGLE_DECL(
1368 rt5639_dac_r2_enum, RT5639_DSP_PATH2,
1369 RT5639_DAC_R2_SEL_SFT, rt5639_dac_r2_src);
1371 static const struct snd_kcontrol_new rt5639_dac_r2_mux =
1372 SOC_DAPM_ENUM("DAC2 right channel source", rt5639_dac_r2_enum);
1374 /* Interface 2 ADC channel source */
1375 static const char *rt5639_if2_adc_l_src[] = {"TxDP", "Mono ADC MIXL"};
1377 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_l_enum, RT5639_DSP_PATH2,
1378 RT5639_IF2_ADC_L_SEL_SFT, rt5639_if2_adc_l_src);
1380 static const struct snd_kcontrol_new rt5639_if2_adc_l_mux =
1381 SOC_DAPM_ENUM("IF2 ADC left channel source", rt5639_if2_adc_l_enum);
1383 static const char *rt5639_if2_adc_r_src[] = {"TxDP", "Mono ADC MIXR"};
1385 static const SOC_ENUM_SINGLE_DECL(rt5639_if2_adc_r_enum, RT5639_DSP_PATH2,
1386 RT5639_IF2_ADC_R_SEL_SFT, rt5639_if2_adc_r_src);
1388 static const struct snd_kcontrol_new rt5639_if2_adc_r_mux =
1389 SOC_DAPM_ENUM("IF2 ADC right channel source", rt5639_if2_adc_r_enum);
1391 /* digital interface and iis interface map */
1392 static const char *rt5639_dai_iis_map[] = {"1:1|2:2|3:3", "1:1|2:3|3:2",
1393 "1:3|2:1|3:2", "1:3|2:2|3:1", "1:2|2:3|3:1",
1394 "1:2|2:1|3:3", "1:1|2:1|3:3", "1:2|2:2|3:3"};
1396 static const SOC_ENUM_SINGLE_DECL(
1397 rt5639_dai_iis_map_enum, RT5639_I2S1_SDP,
1398 RT5639_I2S_IF_SFT, rt5639_dai_iis_map);
1400 static const struct snd_kcontrol_new rt5639_dai_mux =
1401 SOC_DAPM_ENUM("DAI select", rt5639_dai_iis_map_enum);
1404 static const char *rt5639_sdi_sel[] = {"IF1", "IF2"};
1406 static const SOC_ENUM_SINGLE_DECL(
1407 rt5639_sdi_sel_enum, RT5639_I2S2_SDP,
1408 RT5639_I2S2_SDI_SFT, rt5639_sdi_sel);
1410 static const struct snd_kcontrol_new rt5639_sdi_mux =
1411 SOC_DAPM_ENUM("SDI select", rt5639_sdi_sel_enum);
1413 static int rt5639_adc_event(struct snd_soc_dapm_widget *w,
1414 struct snd_kcontrol *kcontrol, int event)
1416 struct snd_soc_codec *codec = w->codec;
1419 case SND_SOC_DAPM_POST_PMU:
1420 rt5639_index_update_bits(codec,
1421 RT5639_CHOP_DAC_ADC, 0x1000, 0x1000);
1424 case SND_SOC_DAPM_POST_PMD:
1425 rt5639_index_update_bits(codec,
1426 RT5639_CHOP_DAC_ADC, 0x1000, 0x0000);
1436 static int rt5639_mono_adcl_event(struct snd_soc_dapm_widget *w,
1437 struct snd_kcontrol *kcontrol, int event)
1439 struct snd_soc_codec *codec = w->codec;
1442 case SND_SOC_DAPM_POST_PMU:
1443 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1444 RT5639_M_MAMIX_L, 0);
1446 case SND_SOC_DAPM_PRE_PMD:
1447 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1459 static int rt5639_mono_adcr_event(struct snd_soc_dapm_widget *w,
1460 struct snd_kcontrol *kcontrol, int event)
1462 struct snd_soc_codec *codec = w->codec;
1465 case SND_SOC_DAPM_POST_PMU:
1466 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1467 RT5639_M_MAMIX_R, 0);
1469 case SND_SOC_DAPM_PRE_PMD:
1470 snd_soc_update_bits(codec, RT5639_GEN_CTRL1,
1482 static int rt5639_spk_event(struct snd_soc_dapm_widget *w,
1483 struct snd_kcontrol *kcontrol, int event)
1486 struct snd_soc_codec *codec = w->codec;
1489 case SND_SOC_DAPM_POST_PMU:
1491 rt5639_update_eqmode(codec, SPK);
1493 snd_soc_update_bits(codec, RT5639_PWR_DIG1,
1494 RT5639_PWR_CLS_D, RT5639_PWR_CLS_D);
1495 rt5639_index_update_bits(codec,
1496 RT5639_CLSD_INT_REG1, 0xf000, 0xf000);
1497 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1498 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1500 /* Make sure test mode is not enabled */
1501 val = rt5639_index_read(codec, 0x001B);
1503 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0301);
1505 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0328);
1508 case SND_SOC_DAPM_PRE_PMD:
1509 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0301);
1510 snd_soc_update_bits(codec, RT5639_SPK_VOL,
1511 RT5639_L_MUTE | RT5639_R_MUTE,
1512 RT5639_L_MUTE | RT5639_R_MUTE);
1513 rt5639_index_update_bits(codec,
1514 RT5639_CLSD_INT_REG1, 0xf000, 0x0000);
1515 snd_soc_update_bits(codec,RT5639_PWR_DIG1,
1516 RT5639_PWR_CLS_D, 0);
1526 static int rt5639_set_dmic1_event(struct snd_soc_dapm_widget *w,
1527 struct snd_kcontrol *kcontrol, int event)
1529 struct snd_soc_codec *codec = w->codec;
1532 case SND_SOC_DAPM_PRE_PMU:
1533 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
1534 RT5639_GP2_PIN_MASK | RT5639_GP3_PIN_MASK,
1535 RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP3_PIN_DMIC1_SDA);
1536 snd_soc_update_bits(codec, RT5639_DMIC,
1537 RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK |
1538 RT5639_DMIC_1_DP_MASK,
1539 RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING |
1540 RT5639_DMIC_1_DP_IN1P);
1541 snd_soc_update_bits(codec, RT5639_DMIC,
1542 RT5639_DMIC_1_EN_MASK, RT5639_DMIC_1_EN);
1550 static int rt5639_set_dmic2_event(struct snd_soc_dapm_widget *w,
1551 struct snd_kcontrol *kcontrol, int event)
1553 struct snd_soc_codec *codec = w->codec;
1556 case SND_SOC_DAPM_PRE_PMU:
1557 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
1558 RT5639_GP2_PIN_MASK | RT5639_GP4_PIN_MASK,
1559 RT5639_GP2_PIN_DMIC1_SCL | RT5639_GP4_PIN_DMIC2_SDA);
1560 snd_soc_update_bits(codec, RT5639_DMIC,
1561 RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK |
1562 RT5639_DMIC_2_DP_MASK,
1563 RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING |
1564 RT5639_DMIC_2_DP_IN1N);
1565 snd_soc_update_bits(codec, RT5639_DMIC,
1566 RT5639_DMIC_2_EN_MASK, RT5639_DMIC_2_EN);
1574 #if USE_ONEBIT_DEPOP
1575 static void hp_amp_power(struct snd_soc_codec *codec, int on)
1577 static int hp_amp_power_count;
1579 "one bit hp_amp_power on=%d hp_amp_power_count=%d\n",
1580 on, hp_amp_power_count);
1583 if (hp_amp_power_count <= 0) {
1584 /* depop parameters */
1585 rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1587 snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1588 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
1589 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1590 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK
1591 | RT5639_HP_CB_MASK, RT5639_HP_CP_PU
1592 | RT5639_HP_SG_DIS | RT5639_HP_CB_PU);
1593 /* headphone amp power on */
1594 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1595 RT5639_PWR_FV1 | RT5639_PWR_FV2, 0);
1598 snd_soc_update_bits(codec, RT5639_PWR_VOL,
1599 RT5639_PWR_HV_L | RT5639_PWR_HV_R,
1600 RT5639_PWR_HV_L | RT5639_PWR_HV_R);
1601 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1602 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1603 | RT5639_PWR_HA, RT5639_PWR_HP_L
1604 | RT5639_PWR_HP_R | RT5639_PWR_HA);
1605 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1606 RT5639_PWR_FV1 | RT5639_PWR_FV2 ,
1607 RT5639_PWR_FV1 | RT5639_PWR_FV2);
1608 snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1609 RT5639_DEPOP_MASK | RT5639_DIG_DP_MASK,
1610 RT5639_DEPOP_AUTO | RT5639_DIG_DP_EN);
1611 snd_soc_update_bits(codec, RT5639_CHARGE_PUMP,
1612 RT5639_PM_HP_MASK, RT5639_PM_HP_HV);
1613 snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1614 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK
1615 | RT5639_CP_FQ3_MASK,
1616 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ1_SFT) |
1617 (RT5639_CP_FQ_24_KHZ << RT5639_CP_FQ2_SFT) |
1618 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ3_SFT));
1619 rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0x1c00);
1620 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1621 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK,
1622 RT5639_HP_CP_PD | RT5639_HP_SG_EN);
1623 rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1626 hp_amp_power_count++;
1628 hp_amp_power_count--;
1629 if (hp_amp_power_count <= 0) {
1630 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1631 RT5639_HP_CB_MASK, RT5639_HP_CB_PD);
1633 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1634 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1635 | RT5639_PWR_HA, 0);
1636 snd_soc_write(codec, RT5639_DEPOP_M2, 0x3100);
1641 static void rt5639_pmu_depop(struct snd_soc_codec *codec)
1643 hp_amp_power(codec, 1);
1644 /* headphone unmute sequence */
1646 snd_soc_update_bits(codec, RT5639_HP_VOL,
1647 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1649 /*snd_soc_update_bits(codec, RT5639_HP_CALIB_AMP_DET,
1650 RT5639_HPD_PS_MASK, RT5639_HPD_PS_EN);*/
1653 static void rt5639_pmd_depop(struct snd_soc_codec *codec)
1655 snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1656 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1657 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ1_SFT) |
1658 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1659 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ3_SFT));
1660 rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0x7c00);
1661 /*snd_soc_update_bits(codec, RT5639_HP_CALIB_AMP_DET,
1662 RT5639_HPD_PS_MASK, RT5639_HPD_PS_DIS); */
1663 snd_soc_update_bits(codec, RT5639_HP_VOL,
1664 RT5639_L_MUTE | RT5639_R_MUTE,
1665 RT5639_L_MUTE | RT5639_R_MUTE);
1667 hp_amp_power(codec, 0);
1671 static void hp_amp_power(struct snd_soc_codec *codec, int on)
1673 static int hp_amp_power_count;
1674 dev_info(codec->dev, "hp_amp_power on=%d hp_amp_power_count=%d\n",
1675 on, hp_amp_power_count);
1678 if (hp_amp_power_count <= 0) {
1679 /* depop parameters */
1680 rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1682 snd_soc_update_bits(codec, RT5639_DEPOP_M2,
1683 RT5639_DEPOP_MASK, RT5639_DEPOP_MAN);
1684 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1685 RT5639_HP_CP_MASK | RT5639_HP_SG_MASK
1686 | RT5639_HP_CB_MASK,
1687 RT5639_HP_CP_PU | RT5639_HP_SG_DIS
1689 /* headphone amp power on */
1690 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1691 RT5639_PWR_FV1 | RT5639_PWR_FV2 , 0);
1692 snd_soc_update_bits(codec, RT5639_PWR_VOL,
1693 RT5639_PWR_HV_L | RT5639_PWR_HV_R,
1694 RT5639_PWR_HV_L | RT5639_PWR_HV_R);
1695 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1696 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1698 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1701 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1702 RT5639_PWR_FV1 | RT5639_PWR_FV2,
1703 RT5639_PWR_FV1 | RT5639_PWR_FV2);
1705 snd_soc_update_bits(codec, RT5639_CHARGE_PUMP,
1706 RT5639_PM_HP_MASK, RT5639_PM_HP_HV);
1707 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1708 RT5639_HP_CO_MASK | RT5639_HP_SG_MASK,
1709 RT5639_HP_CO_EN | RT5639_HP_SG_EN);
1710 rt5639_index_update_bits(codec, RT5639_CHPUMP_INT_REG1,
1713 hp_amp_power_count++;
1715 hp_amp_power_count--;
1716 if (hp_amp_power_count <= 0) {
1717 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1718 RT5639_HP_SG_MASK | RT5639_HP_L_SMT_MASK |
1719 RT5639_HP_R_SMT_MASK, RT5639_HP_SG_DIS |
1720 RT5639_HP_L_SMT_DIS | RT5639_HP_R_SMT_DIS);
1721 /* headphone amp power down */
1722 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1723 RT5639_SMT_TRIG_MASK | RT5639_HP_CD_PD_MASK |
1724 RT5639_HP_CO_MASK | RT5639_HP_CP_MASK |
1725 RT5639_HP_SG_MASK | RT5639_HP_CB_MASK,
1726 RT5639_SMT_TRIG_DIS | RT5639_HP_CD_PD_EN |
1727 RT5639_HP_CO_DIS | RT5639_HP_CP_PD |
1728 RT5639_HP_SG_EN | RT5639_HP_CB_PD);
1729 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1730 RT5639_PWR_HP_L | RT5639_PWR_HP_R
1737 static void rt5639_pmu_depop(struct snd_soc_codec *codec)
1739 hp_amp_power(codec, 1);
1740 /* headphone unmute sequence */
1741 snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1742 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1743 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ1_SFT) |
1744 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1745 (RT5639_CP_FQ_192_KHZ << RT5639_CP_FQ3_SFT));
1746 rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0xfc00);
1747 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1748 RT5639_SMT_TRIG_MASK, RT5639_SMT_TRIG_EN);
1749 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1750 RT5639_RSTN_MASK, RT5639_RSTN_EN);
1751 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1752 RT5639_RSTN_MASK | RT5639_HP_L_SMT_MASK | RT5639_HP_R_SMT_MASK,
1753 RT5639_RSTN_DIS | RT5639_HP_L_SMT_EN | RT5639_HP_R_SMT_EN);
1754 snd_soc_update_bits(codec, RT5639_HP_VOL,
1755 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1757 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1758 RT5639_HP_SG_MASK | RT5639_HP_L_SMT_MASK |
1759 RT5639_HP_R_SMT_MASK, RT5639_HP_SG_DIS |
1760 RT5639_HP_L_SMT_DIS | RT5639_HP_R_SMT_DIS);
1764 static void rt5639_pmd_depop(struct snd_soc_codec *codec)
1766 /* headphone mute sequence */
1767 snd_soc_update_bits(codec, RT5639_DEPOP_M3,
1768 RT5639_CP_FQ1_MASK | RT5639_CP_FQ2_MASK | RT5639_CP_FQ3_MASK,
1769 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ1_SFT) |
1770 (RT5639_CP_FQ_12_KHZ << RT5639_CP_FQ2_SFT) |
1771 (RT5639_CP_FQ_96_KHZ << RT5639_CP_FQ3_SFT));
1772 rt5639_index_write(codec, RT5639_MAMP_INT_REG2, 0xfc00);
1773 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1774 RT5639_HP_SG_MASK, RT5639_HP_SG_EN);
1775 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1776 RT5639_RSTP_MASK, RT5639_RSTP_EN);
1777 snd_soc_update_bits(codec, RT5639_DEPOP_M1,
1778 RT5639_RSTP_MASK | RT5639_HP_L_SMT_MASK |
1779 RT5639_HP_R_SMT_MASK, RT5639_RSTP_DIS |
1780 RT5639_HP_L_SMT_EN | RT5639_HP_R_SMT_EN);
1782 snd_soc_update_bits(codec, RT5639_HP_VOL,
1783 RT5639_L_MUTE | RT5639_R_MUTE, RT5639_L_MUTE | RT5639_R_MUTE);
1786 hp_amp_power(codec, 0);
1790 static int rt5639_hp_event(struct snd_soc_dapm_widget *w,
1791 struct snd_kcontrol *kcontrol, int event)
1793 struct snd_soc_codec *codec = w->codec;
1796 case SND_SOC_DAPM_POST_PMU:
1798 rt5639_update_eqmode(codec, HP);
1800 rt5639_pmu_depop(codec);
1803 case SND_SOC_DAPM_PRE_PMD:
1804 rt5639_pmd_depop(codec);
1814 static int rt5639_mono_event(struct snd_soc_dapm_widget *w,
1815 struct snd_kcontrol *kcontrol, int event)
1817 struct snd_soc_codec *codec = w->codec;
1820 case SND_SOC_DAPM_POST_PMU:
1821 snd_soc_update_bits(codec, RT5639_MONO_OUT,
1825 case SND_SOC_DAPM_PRE_PMD:
1826 snd_soc_update_bits(codec, RT5639_MONO_OUT,
1827 RT5639_L_MUTE, RT5639_L_MUTE);
1837 static int rt5639_lout_event(struct snd_soc_dapm_widget *w,
1838 struct snd_kcontrol *kcontrol, int event)
1840 struct snd_soc_codec *codec = w->codec;
1843 case SND_SOC_DAPM_POST_PMU:
1844 hp_amp_power(codec, 1);
1845 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1846 RT5639_PWR_LM, RT5639_PWR_LM);
1847 snd_soc_update_bits(codec, RT5639_OUTPUT,
1848 RT5639_L_MUTE | RT5639_R_MUTE, 0);
1851 case SND_SOC_DAPM_PRE_PMD:
1852 snd_soc_update_bits(codec, RT5639_OUTPUT,
1853 RT5639_L_MUTE | RT5639_R_MUTE,
1854 RT5639_L_MUTE | RT5639_R_MUTE);
1855 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
1857 hp_amp_power(codec, 0);
1867 static int rt5639_index_sync_event(struct snd_soc_dapm_widget *w,
1868 struct snd_kcontrol *kcontrol, int event)
1870 struct snd_soc_codec *codec = w->codec;
1873 case SND_SOC_DAPM_PRE_PMU:
1874 rt5639_index_write(codec, RT5639_MIXER_INT_REG,
1875 snd_soc_read(codec, RT5639_DUMMY_PR3F));
1885 static int rt5639_dac1_event(struct snd_soc_dapm_widget *w,
1886 struct snd_kcontrol *kcontrol, int event)
1889 struct snd_soc_codec *codec = w->codec;
1893 case SND_SOC_DAPM_PRE_PMD:
1895 rt5639_update_eqmode(codec, NORMAL);
1905 static const struct snd_soc_dapm_widget rt5639_dapm_widgets[] = {
1906 SND_SOC_DAPM_SUPPLY("PLL1", RT5639_PWR_ANLG2,
1907 RT5639_PWR_PLL_BIT, 0, NULL, 0),
1910 SND_SOC_DAPM_SUPPLY("LDO2", RT5639_PWR_ANLG1,
1911 RT5639_PWR_LDO2_BIT, 0, NULL, 0),
1912 SND_SOC_DAPM_MICBIAS("micbias1", RT5639_PWR_ANLG2,
1913 RT5639_PWR_MB1_BIT, 0),
1914 SND_SOC_DAPM_MICBIAS("micbias2", RT5639_PWR_ANLG2,
1915 RT5639_PWR_MB2_BIT, 0),
1917 SND_SOC_DAPM_INPUT("DMIC1"),
1918 SND_SOC_DAPM_INPUT("DMIC2"),
1920 SND_SOC_DAPM_INPUT("IN1P"),
1921 SND_SOC_DAPM_INPUT("IN1N"),
1922 SND_SOC_DAPM_INPUT("IN2P"),
1923 SND_SOC_DAPM_INPUT("IN2N"),
1924 SND_SOC_DAPM_INPUT("IN3P"),
1925 SND_SOC_DAPM_INPUT("IN3N"),
1926 SND_SOC_DAPM_PGA_E("DMIC L1", SND_SOC_NOPM, 0, 0, NULL, 0,
1927 rt5639_set_dmic1_event, SND_SOC_DAPM_PRE_PMU),
1928 SND_SOC_DAPM_PGA_E("DMIC R1", SND_SOC_NOPM, 0, 0, NULL, 0,
1929 rt5639_set_dmic1_event, SND_SOC_DAPM_PRE_PMU),
1930 SND_SOC_DAPM_PGA_E("DMIC L2", SND_SOC_NOPM, 0, 0, NULL, 0,
1931 rt5639_set_dmic2_event, SND_SOC_DAPM_PRE_PMU),
1932 SND_SOC_DAPM_PGA_E("DMIC R2", SND_SOC_NOPM, 0, 0, NULL, 0,
1933 rt5639_set_dmic2_event, SND_SOC_DAPM_PRE_PMU),
1934 SND_SOC_DAPM_SUPPLY("DMIC CLK", SND_SOC_NOPM, 0, 0,
1935 set_dmic_clk, SND_SOC_DAPM_PRE_PMU),
1937 SND_SOC_DAPM_PGA("BST1", RT5639_PWR_ANLG2,
1938 RT5639_PWR_BST1_BIT, 0, NULL, 0),
1939 SND_SOC_DAPM_PGA("BST2", RT5639_PWR_ANLG2,
1940 RT5639_PWR_BST4_BIT, 0, NULL, 0),
1941 SND_SOC_DAPM_PGA("BST3", RT5639_PWR_ANLG2,
1942 RT5639_PWR_BST2_BIT, 0, NULL, 0),
1945 SND_SOC_DAPM_PGA("INL VOL", RT5639_PWR_VOL,
1946 RT5639_PWR_IN_L_BIT, 0, NULL, 0),
1947 SND_SOC_DAPM_PGA("INR VOL", RT5639_PWR_VOL,
1948 RT5639_PWR_IN_R_BIT, 0, NULL, 0),
1950 SND_SOC_DAPM_MUX("INL Mux", SND_SOC_NOPM, 0, 0, &rt5639_inl_mux),
1951 SND_SOC_DAPM_MUX("INR Mux", SND_SOC_NOPM, 0, 0, &rt5639_inr_mux),
1953 SND_SOC_DAPM_MIXER("RECMIXL", RT5639_PWR_MIXER, RT5639_PWR_RM_L_BIT, 0,
1954 rt5639_rec_l_mix, ARRAY_SIZE(rt5639_rec_l_mix)),
1955 SND_SOC_DAPM_MIXER("RECMIXR", RT5639_PWR_MIXER, RT5639_PWR_RM_R_BIT, 0,
1956 rt5639_rec_r_mix, ARRAY_SIZE(rt5639_rec_r_mix)),
1958 SND_SOC_DAPM_ADC("ADC L", NULL, SND_SOC_NOPM,
1960 SND_SOC_DAPM_ADC("ADC R", NULL, SND_SOC_NOPM,
1963 SND_SOC_DAPM_SUPPLY("ADC L power", RT5639_PWR_DIG1,
1964 RT5639_PWR_ADC_L_BIT, 0, NULL, 0),
1965 SND_SOC_DAPM_SUPPLY("ADC R power", RT5639_PWR_DIG1,
1966 RT5639_PWR_ADC_R_BIT, 0, NULL, 0),
1967 SND_SOC_DAPM_SUPPLY("ADC clock", SND_SOC_NOPM, 0, 0, rt5639_adc_event,
1968 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
1970 SND_SOC_DAPM_MUX("Stereo ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1971 &rt5639_sto_adc_l2_mux),
1972 SND_SOC_DAPM_MUX("Stereo ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1973 &rt5639_sto_adc_r2_mux),
1974 SND_SOC_DAPM_MUX("Stereo ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1975 &rt5639_sto_adc_l1_mux),
1976 SND_SOC_DAPM_MUX("Stereo ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1977 &rt5639_sto_adc_r1_mux),
1978 SND_SOC_DAPM_MUX("Mono ADC L2 Mux", SND_SOC_NOPM, 0, 0,
1979 &rt5639_mono_adc_l2_mux),
1980 SND_SOC_DAPM_MUX("Mono ADC L1 Mux", SND_SOC_NOPM, 0, 0,
1981 &rt5639_mono_adc_l1_mux),
1982 SND_SOC_DAPM_MUX("Mono ADC R1 Mux", SND_SOC_NOPM, 0, 0,
1983 &rt5639_mono_adc_r1_mux),
1984 SND_SOC_DAPM_MUX("Mono ADC R2 Mux", SND_SOC_NOPM, 0, 0,
1985 &rt5639_mono_adc_r2_mux),
1987 SND_SOC_DAPM_SUPPLY("stereo filter", RT5639_PWR_DIG2,
1988 RT5639_PWR_ADC_SF_BIT, 0, NULL, 0),
1989 SND_SOC_DAPM_MIXER("Stereo ADC MIXL", SND_SOC_NOPM, 0, 0,
1990 rt5639_sto_adc_l_mix, ARRAY_SIZE(rt5639_sto_adc_l_mix)),
1991 SND_SOC_DAPM_MIXER("Stereo ADC MIXR", SND_SOC_NOPM, 0, 0,
1992 rt5639_sto_adc_r_mix, ARRAY_SIZE(rt5639_sto_adc_r_mix)),
1993 SND_SOC_DAPM_SUPPLY("mono left filter", RT5639_PWR_DIG2,
1994 RT5639_PWR_ADC_MF_L_BIT, 0, NULL, 0),
1995 SND_SOC_DAPM_MIXER_E("Mono ADC MIXL", SND_SOC_NOPM, 0, 0,
1996 rt5639_mono_adc_l_mix, ARRAY_SIZE(rt5639_mono_adc_l_mix),
1997 rt5639_mono_adcl_event,
1998 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1999 SND_SOC_DAPM_SUPPLY("mono right filter", RT5639_PWR_DIG2,
2000 RT5639_PWR_ADC_MF_R_BIT, 0, NULL, 0),
2001 SND_SOC_DAPM_MIXER_E("Mono ADC MIXR", SND_SOC_NOPM, 0, 0,
2002 rt5639_mono_adc_r_mix, ARRAY_SIZE(rt5639_mono_adc_r_mix),
2003 rt5639_mono_adcr_event,
2004 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2007 SND_SOC_DAPM_MUX("IF2 ADC L Mux", SND_SOC_NOPM, 0, 0,
2008 &rt5639_if2_adc_l_mux),
2009 SND_SOC_DAPM_MUX("IF2 ADC R Mux", SND_SOC_NOPM, 0, 0,
2010 &rt5639_if2_adc_r_mux),
2012 /* Digital Interface */
2013 SND_SOC_DAPM_SUPPLY("I2S1", RT5639_PWR_DIG1,
2014 RT5639_PWR_I2S1_BIT, 0, NULL, 0),
2015 SND_SOC_DAPM_PGA("IF1 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
2016 SND_SOC_DAPM_PGA("IF1 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2017 SND_SOC_DAPM_PGA("IF1 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2018 SND_SOC_DAPM_PGA("IF1 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
2019 SND_SOC_DAPM_PGA("IF1 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2020 SND_SOC_DAPM_PGA("IF1 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2021 SND_SOC_DAPM_SUPPLY("I2S2", RT5639_PWR_DIG1,
2022 RT5639_PWR_I2S2_BIT, 0, NULL, 0),
2023 SND_SOC_DAPM_PGA("IF2 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
2024 SND_SOC_DAPM_PGA("IF2 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2025 SND_SOC_DAPM_PGA("IF2 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2026 SND_SOC_DAPM_PGA("IF2 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
2027 SND_SOC_DAPM_PGA("IF2 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2028 SND_SOC_DAPM_PGA("IF2 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2029 SND_SOC_DAPM_SUPPLY("I2S3", RT5639_PWR_DIG1,
2030 RT5639_PWR_I2S3_BIT, 0, NULL, 0),
2031 SND_SOC_DAPM_PGA("IF3 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
2032 SND_SOC_DAPM_PGA("IF3 DAC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2033 SND_SOC_DAPM_PGA("IF3 DAC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2034 SND_SOC_DAPM_PGA("IF3 ADC", SND_SOC_NOPM, 0, 0, NULL, 0),
2035 SND_SOC_DAPM_PGA("IF3 ADC L", SND_SOC_NOPM, 0, 0, NULL, 0),
2036 SND_SOC_DAPM_PGA("IF3 ADC R", SND_SOC_NOPM, 0, 0, NULL, 0),
2038 /* Digital Interface Select */
2039 SND_SOC_DAPM_MUX("DAI1 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2040 SND_SOC_DAPM_MUX("DAI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2041 SND_SOC_DAPM_MUX("DAI1 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2042 SND_SOC_DAPM_MUX("DAI1 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2043 SND_SOC_DAPM_MUX("SDI1 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
2045 SND_SOC_DAPM_MUX("DAI2 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2046 SND_SOC_DAPM_MUX("DAI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2047 SND_SOC_DAPM_MUX("DAI2 IF1 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2048 SND_SOC_DAPM_MUX("DAI2 IF2 Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2049 SND_SOC_DAPM_MUX("SDI2 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_sdi_mux),
2051 SND_SOC_DAPM_MUX("DAI3 RX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2052 SND_SOC_DAPM_MUX("DAI3 TX Mux", SND_SOC_NOPM, 0, 0, &rt5639_dai_mux),
2054 /* Audio Interface */
2055 SND_SOC_DAPM_AIF_IN("AIF1RX", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
2056 SND_SOC_DAPM_AIF_OUT("AIF1TX", "AIF1 Capture", 0, SND_SOC_NOPM, 0, 0),
2057 SND_SOC_DAPM_AIF_IN("AIF2RX", "AIF2 Playback", 0, SND_SOC_NOPM, 0, 0),
2058 SND_SOC_DAPM_AIF_OUT("AIF2TX", "AIF2 Capture", 0, SND_SOC_NOPM, 0, 0),
2059 SND_SOC_DAPM_AIF_IN("AIF3RX", "AIF3 Playback", 0, SND_SOC_NOPM, 0, 0),
2060 SND_SOC_DAPM_AIF_OUT("AIF3TX", "AIF3 Capture", 0, SND_SOC_NOPM, 0, 0),
2063 SND_SOC_DAPM_PGA("Audio DSP", SND_SOC_NOPM, 0, 0, NULL, 0),
2066 SND_SOC_DAPM_PGA("ANC", SND_SOC_NOPM, 0, 0, NULL, 0),
2069 /* DAC mixer before sound effect */
2070 SND_SOC_DAPM_MIXER("DAC MIXL", SND_SOC_NOPM, 0, 0,
2071 rt5639_dac_l_mix, ARRAY_SIZE(rt5639_dac_l_mix)),
2072 SND_SOC_DAPM_MIXER("DAC MIXR", SND_SOC_NOPM, 0, 0,
2073 rt5639_dac_r_mix, ARRAY_SIZE(rt5639_dac_r_mix)),
2075 /* DAC2 channel Mux */
2076 SND_SOC_DAPM_MUX("DAC L2 Mux", SND_SOC_NOPM, 0, 0,
2077 &rt5639_dac_l2_mux),
2078 SND_SOC_DAPM_MUX("DAC R2 Mux", SND_SOC_NOPM, 0, 0,
2079 &rt5639_dac_r2_mux),
2080 SND_SOC_DAPM_PGA("DAC L2 Volume", RT5639_PWR_DIG1,
2081 RT5639_PWR_DAC_L2_BIT, 0, NULL, 0),
2082 SND_SOC_DAPM_PGA("DAC R2 Volume", RT5639_PWR_DIG1,
2083 RT5639_PWR_DAC_R2_BIT, 0, NULL, 0),
2086 SND_SOC_DAPM_MIXER("Stereo DAC MIXL", SND_SOC_NOPM, 0, 0,
2087 rt5639_sto_dac_l_mix, ARRAY_SIZE(rt5639_sto_dac_l_mix)),
2088 SND_SOC_DAPM_MIXER("Stereo DAC MIXR", SND_SOC_NOPM, 0, 0,
2089 rt5639_sto_dac_r_mix, ARRAY_SIZE(rt5639_sto_dac_r_mix)),
2090 SND_SOC_DAPM_MIXER("Mono DAC MIXL", SND_SOC_NOPM, 0, 0,
2091 rt5639_mono_dac_l_mix, ARRAY_SIZE(rt5639_mono_dac_l_mix)),
2092 SND_SOC_DAPM_MIXER("Mono DAC MIXR", SND_SOC_NOPM, 0, 0,
2093 rt5639_mono_dac_r_mix, ARRAY_SIZE(rt5639_mono_dac_r_mix)),
2094 SND_SOC_DAPM_MIXER("DIG MIXL", SND_SOC_NOPM, 0, 0,
2095 rt5639_dig_l_mix, ARRAY_SIZE(rt5639_dig_l_mix)),
2096 SND_SOC_DAPM_MIXER("DIG MIXR", SND_SOC_NOPM, 0, 0,
2097 rt5639_dig_r_mix, ARRAY_SIZE(rt5639_dig_r_mix)),
2098 SND_SOC_DAPM_MUX_E("Mono dacr Mux", SND_SOC_NOPM, 0, 0,
2099 &rt5639_dacr2_mux, rt5639_index_sync_event,
2100 SND_SOC_DAPM_PRE_PMU),
2103 SND_SOC_DAPM_DAC_E("DAC L1", NULL, RT5639_PWR_DIG1,
2104 RT5639_PWR_DAC_L1_BIT, 0, rt5639_dac1_event,
2105 SND_SOC_DAPM_PRE_PMD),
2106 SND_SOC_DAPM_DAC_E("DAC R1", NULL, RT5639_PWR_DIG1,
2107 RT5639_PWR_DAC_R1_BIT, 0, rt5639_dac1_event,
2108 SND_SOC_DAPM_PRE_PMD),
2111 SND_SOC_DAPM_MIXER("SPK MIXL", RT5639_PWR_MIXER, RT5639_PWR_SM_L_BIT,
2112 0, rt5639_spk_l_mix, ARRAY_SIZE(rt5639_spk_l_mix)),
2113 SND_SOC_DAPM_MIXER("SPK MIXR", RT5639_PWR_MIXER, RT5639_PWR_SM_R_BIT,
2114 0, rt5639_spk_r_mix, ARRAY_SIZE(rt5639_spk_r_mix)),
2115 SND_SOC_DAPM_MIXER("OUT MIXL", RT5639_PWR_MIXER, RT5639_PWR_OM_L_BIT,
2116 0, rt5639_out_l_mix, ARRAY_SIZE(rt5639_out_l_mix)),
2117 SND_SOC_DAPM_MIXER("OUT MIXR", RT5639_PWR_MIXER, RT5639_PWR_OM_R_BIT,
2118 0, rt5639_out_r_mix, ARRAY_SIZE(rt5639_out_r_mix)),
2120 SND_SOC_DAPM_PGA("SPKVOL L", RT5639_PWR_VOL,
2121 RT5639_PWR_SV_L_BIT, 0, NULL, 0),
2122 SND_SOC_DAPM_PGA("SPKVOL R", RT5639_PWR_VOL,
2123 RT5639_PWR_SV_R_BIT, 0, NULL, 0),
2124 SND_SOC_DAPM_PGA("OUTVOL L", RT5639_PWR_VOL,
2125 RT5639_PWR_OV_L_BIT, 0, NULL, 0),
2126 SND_SOC_DAPM_PGA("OUTVOL R", RT5639_PWR_VOL,
2127 RT5639_PWR_OV_R_BIT, 0, NULL, 0),
2128 SND_SOC_DAPM_PGA("HPOVOL L", RT5639_PWR_VOL,
2129 RT5639_PWR_HV_L_BIT, 0, NULL, 0),
2130 SND_SOC_DAPM_PGA("HPOVOL R", RT5639_PWR_VOL,
2131 RT5639_PWR_HV_R_BIT, 0, NULL, 0),
2132 SND_SOC_DAPM_PGA("DAC 1", SND_SOC_NOPM,
2134 SND_SOC_DAPM_PGA("HPOVOL", SND_SOC_NOPM,
2136 /* SPO/HPO/LOUT/Mono Mixer */
2137 SND_SOC_DAPM_MIXER("SPOL MIX",SND_SOC_NOPM, 0,
2138 0, rt5639_spo_l_mix, ARRAY_SIZE(rt5639_spo_l_mix)),
2139 SND_SOC_DAPM_MIXER("SPOR MIX", SND_SOC_NOPM, 0,
2140 0, rt5639_spo_r_mix, ARRAY_SIZE(rt5639_spo_r_mix)),
2141 SND_SOC_DAPM_MIXER("HPO MIX", SND_SOC_NOPM, 0, 0,
2142 rt5639_hpo_mix, ARRAY_SIZE(rt5639_hpo_mix)),
2143 SND_SOC_DAPM_MIXER("LOUT MIX", SND_SOC_NOPM, 0, 0,
2144 rt5639_lout_mix, ARRAY_SIZE(rt5639_lout_mix)),
2146 SND_SOC_DAPM_PGA_S("HP amp", 1, SND_SOC_NOPM, 0, 0,
2147 rt5639_hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2148 SND_SOC_DAPM_PGA_S("SPK amp", 1, SND_SOC_NOPM, 0, 0,
2149 rt5639_spk_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2150 SND_SOC_DAPM_PGA_S("LOUT amp", 1, SND_SOC_NOPM, 0, 0,
2152 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
2155 SND_SOC_DAPM_OUTPUT("SPOLP"),
2156 SND_SOC_DAPM_OUTPUT("SPOLN"),
2157 SND_SOC_DAPM_OUTPUT("SPORP"),
2158 SND_SOC_DAPM_OUTPUT("SPORN"),
2159 SND_SOC_DAPM_OUTPUT("HPOL"),
2160 SND_SOC_DAPM_OUTPUT("HPOR"),
2161 SND_SOC_DAPM_OUTPUT("LOUTL"),
2162 SND_SOC_DAPM_OUTPUT("LOUTR"),
2165 static const struct snd_soc_dapm_route rt5639_dapm_routes[] = {
2166 {"IN1P", NULL, "LDO2"},
2167 {"IN2P", NULL, "LDO2"},
2168 {"IN3P", NULL, "LDO2"},
2170 {"DMIC L1", NULL, "DMIC1"},
2171 {"DMIC R1", NULL, "DMIC1"},
2172 {"DMIC L2", NULL, "DMIC2"},
2173 {"DMIC R2", NULL, "DMIC2"},
2175 {"BST1", NULL, "IN1P"},
2176 {"BST1", NULL, "IN1N"},
2177 {"BST2", NULL, "IN2P"},
2178 {"BST2", NULL, "IN2N"},
2179 {"BST3", NULL, "IN3P"},
2180 {"BST3", NULL, "IN3N"},
2182 {"INL VOL", NULL, "IN2P"},
2183 {"INR VOL", NULL, "IN2N"},
2185 {"RECMIXL", "HPOL Switch", "HPOL"},
2186 {"RECMIXL", "INL Switch", "INL VOL"},
2187 {"RECMIXL", "BST3 Switch", "BST3"},
2188 {"RECMIXL", "BST2 Switch", "BST2"},
2189 {"RECMIXL", "BST1 Switch", "BST1"},
2190 {"RECMIXL", "OUT MIXL Switch", "OUT MIXL"},
2192 {"RECMIXR", "HPOR Switch", "HPOR"},
2193 {"RECMIXR", "INR Switch", "INR VOL"},
2194 {"RECMIXR", "BST3 Switch", "BST3"},
2195 {"RECMIXR", "BST2 Switch", "BST2"},
2196 {"RECMIXR", "BST1 Switch", "BST1"},
2197 {"RECMIXR", "OUT MIXR Switch", "OUT MIXR"},
2199 {"ADC L", NULL, "RECMIXL"},
2200 {"ADC L", NULL, "ADC L power"},
2201 {"ADC L", NULL, "ADC clock"},
2202 {"ADC R", NULL, "RECMIXR"},
2203 {"ADC R", NULL, "ADC R power"},
2204 {"ADC R", NULL, "ADC clock"},
2206 {"DMIC L1", NULL, "DMIC CLK"},
2207 {"DMIC R1", NULL, "DMIC CLK"},
2208 {"DMIC L2", NULL, "DMIC CLK"},
2209 {"DMIC R2", NULL, "DMIC CLK"},
2211 {"Stereo ADC L2 Mux", "DMIC1", "DMIC L1"},
2212 {"Stereo ADC L2 Mux", "DMIC2", "DMIC L2"},
2213 {"Stereo ADC L2 Mux", "DIG MIX", "DIG MIXL"},
2214 {"Stereo ADC L1 Mux", "ADC", "ADC L"},
2215 {"Stereo ADC L1 Mux", "DIG MIX", "DIG MIXL"},
2217 {"Stereo ADC R1 Mux", "ADC", "ADC R"},
2218 {"Stereo ADC R1 Mux", "DIG MIX", "DIG MIXR"},
2219 {"Stereo ADC R2 Mux", "DMIC1", "DMIC R1"},
2220 {"Stereo ADC R2 Mux", "DMIC2", "DMIC R2"},
2221 {"Stereo ADC R2 Mux", "DIG MIX", "DIG MIXR"},
2223 {"Mono ADC L2 Mux", "DMIC L1", "DMIC L1"},
2224 {"Mono ADC L2 Mux", "DMIC L2", "DMIC L2"},
2225 {"Mono ADC L2 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
2226 {"Mono ADC L1 Mux", "Mono DAC MIXL", "Mono DAC MIXL"},
2227 {"Mono ADC L1 Mux", "ADCL", "ADC L"},
2229 {"Mono ADC R1 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
2230 {"Mono ADC R1 Mux", "ADCR", "ADC R"},
2231 {"Mono ADC R2 Mux", "DMIC R1", "DMIC R1"},
2232 {"Mono ADC R2 Mux", "DMIC R2", "DMIC R2"},
2233 {"Mono ADC R2 Mux", "Mono DAC MIXR", "Mono DAC MIXR"},
2235 {"Stereo ADC MIXL", "ADC1 Switch", "Stereo ADC L1 Mux"},
2236 {"Stereo ADC MIXL", "ADC2 Switch", "Stereo ADC L2 Mux"},
2237 {"Stereo ADC MIXL", NULL, "stereo filter"},
2238 {"stereo filter", NULL, "PLL1", check_sysclk1_source},
2240 {"Stereo ADC MIXR", "ADC1 Switch", "Stereo ADC R1 Mux"},
2241 {"Stereo ADC MIXR", "ADC2 Switch", "Stereo ADC R2 Mux"},
2242 {"Stereo ADC MIXR", NULL, "stereo filter"},
2243 {"stereo filter", NULL, "PLL1", check_sysclk1_source},
2245 {"Mono ADC MIXL", "ADC1 Switch", "Mono ADC L1 Mux"},
2246 {"Mono ADC MIXL", "ADC2 Switch", "Mono ADC L2 Mux"},
2247 {"Mono ADC MIXL", NULL, "mono left filter"},
2248 {"mono left filter", NULL, "PLL1", check_sysclk1_source},
2250 {"Mono ADC MIXR", "ADC1 Switch", "Mono ADC R1 Mux"},
2251 {"Mono ADC MIXR", "ADC2 Switch", "Mono ADC R2 Mux"},
2252 {"Mono ADC MIXR", NULL, "mono right filter"},
2253 {"mono right filter", NULL, "PLL1", check_sysclk1_source},
2255 {"IF2 ADC L Mux", "Mono ADC MIXL", "Mono ADC MIXL"},
2256 {"IF2 ADC R Mux", "Mono ADC MIXR", "Mono ADC MIXR"},
2258 {"IF2 ADC L", NULL, "IF2 ADC L Mux"},
2259 {"IF2 ADC R", NULL, "IF2 ADC R Mux"},
2260 {"IF3 ADC L", NULL, "Mono ADC MIXL"},
2261 {"IF3 ADC R", NULL, "Mono ADC MIXR"},
2262 {"IF1 ADC L", NULL, "Stereo ADC MIXL"},
2263 {"IF1 ADC R", NULL, "Stereo ADC MIXR"},
2265 {"IF1 ADC", NULL, "I2S1"},
2266 {"IF1 ADC", NULL, "IF1 ADC L"},
2267 {"IF1 ADC", NULL, "IF1 ADC R"},
2268 {"IF2 ADC", NULL, "I2S2"},
2269 {"IF2 ADC", NULL, "IF2 ADC L"},
2270 {"IF2 ADC", NULL, "IF2 ADC R"},
2271 {"IF3 ADC", NULL, "I2S3"},
2272 {"IF3 ADC", NULL, "IF3 ADC L"},
2273 {"IF3 ADC", NULL, "IF3 ADC R"},
2275 {"DAI1 TX Mux", "1:1|2:2|3:3", "IF1 ADC"},
2276 {"DAI1 TX Mux", "1:1|2:3|3:2", "IF1 ADC"},
2277 {"DAI1 TX Mux", "1:3|2:1|3:2", "IF2 ADC"},
2278 {"DAI1 TX Mux", "1:2|2:1|3:3", "IF2 ADC"},
2279 {"DAI1 TX Mux", "1:3|2:2|3:1", "IF3 ADC"},
2280 {"DAI1 TX Mux", "1:2|2:3|3:1", "IF3 ADC"},
2281 {"DAI1 IF1 Mux", "1:1|2:1|3:3", "IF1 ADC"},
2282 {"DAI1 IF2 Mux", "1:1|2:1|3:3", "IF2 ADC"},
2283 {"SDI1 TX Mux", "IF1", "DAI1 IF1 Mux"},
2284 {"SDI1 TX Mux", "IF2", "DAI1 IF2 Mux"},
2286 {"DAI2 TX Mux", "1:2|2:3|3:1", "IF1 ADC"},
2287 {"DAI2 TX Mux", "1:2|2:1|3:3", "IF1 ADC"},
2288 {"DAI2 TX Mux", "1:1|2:2|3:3", "IF2 ADC"},
2289 {"DAI2 TX Mux", "1:3|2:2|3:1", "IF2 ADC"},
2290 {"DAI2 TX Mux", "1:1|2:3|3:2", "IF3 ADC"},
2291 {"DAI2 TX Mux", "1:3|2:1|3:2", "IF3 ADC"},
2292 {"DAI2 IF1 Mux", "1:2|2:2|3:3", "IF1 ADC"},
2293 {"DAI2 IF2 Mux", "1:2|2:2|3:3", "IF2 ADC"},
2294 {"SDI2 TX Mux", "IF1", "DAI2 IF1 Mux"},
2295 {"SDI2 TX Mux", "IF2", "DAI2 IF2 Mux"},
2297 {"DAI3 TX Mux", "1:3|2:1|3:2", "IF1 ADC"},
2298 {"DAI3 TX Mux", "1:3|2:2|3:1", "IF1 ADC"},
2299 {"DAI3 TX Mux", "1:1|2:3|3:2", "IF2 ADC"},
2300 {"DAI3 TX Mux", "1:2|2:3|3:1", "IF2 ADC"},
2301 {"DAI3 TX Mux", "1:1|2:2|3:3", "IF3 ADC"},
2302 {"DAI3 TX Mux", "1:2|2:1|3:3", "IF3 ADC"},
2303 {"DAI3 TX Mux", "1:1|2:1|3:3", "IF3 ADC"},
2304 {"DAI3 TX Mux", "1:2|2:2|3:3", "IF3 ADC"},
2306 {"AIF1TX", NULL, "DAI1 TX Mux"},
2307 {"AIF1TX", NULL, "SDI1 TX Mux"},
2308 {"AIF2TX", NULL, "DAI2 TX Mux"},
2309 {"AIF2TX", NULL, "SDI2 TX Mux"},
2310 {"AIF3TX", NULL, "DAI3 TX Mux"},
2312 {"DAI1 RX Mux", "1:1|2:2|3:3", "AIF1RX"},
2313 {"DAI1 RX Mux", "1:1|2:3|3:2", "AIF1RX"},
2314 {"DAI1 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
2315 {"DAI1 RX Mux", "1:2|2:3|3:1", "AIF2RX"},
2316 {"DAI1 RX Mux", "1:2|2:1|3:3", "AIF2RX"},
2317 {"DAI1 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
2318 {"DAI1 RX Mux", "1:3|2:1|3:2", "AIF3RX"},
2319 {"DAI1 RX Mux", "1:3|2:2|3:1", "AIF3RX"},
2321 {"DAI2 RX Mux", "1:3|2:1|3:2", "AIF1RX"},
2322 {"DAI2 RX Mux", "1:2|2:1|3:3", "AIF1RX"},
2323 {"DAI2 RX Mux", "1:1|2:1|3:3", "AIF1RX"},
2324 {"DAI2 RX Mux", "1:1|2:2|3:3", "AIF2RX"},
2325 {"DAI2 RX Mux", "1:3|2:2|3:1", "AIF2RX"},
2326 {"DAI2 RX Mux", "1:2|2:2|3:3", "AIF2RX"},
2327 {"DAI2 RX Mux", "1:1|2:3|3:2", "AIF3RX"},
2328 {"DAI2 RX Mux", "1:2|2:3|3:1", "AIF3RX"},
2330 {"DAI3 RX Mux", "1:3|2:2|3:1", "AIF1RX"},
2331 {"DAI3 RX Mux", "1:2|2:3|3:1", "AIF1RX"},
2332 {"DAI3 RX Mux", "1:1|2:3|3:2", "AIF2RX"},
2333 {"DAI3 RX Mux", "1:3|2:1|3:2", "AIF2RX"},
2334 {"DAI3 RX Mux", "1:1|2:2|3:3", "AIF3RX"},
2335 {"DAI3 RX Mux", "1:2|2:1|3:3", "AIF3RX"},
2336 {"DAI3 RX Mux", "1:1|2:1|3:3", "AIF3RX"},
2337 {"DAI3 RX Mux", "1:2|2:2|3:3", "AIF3RX"},
2339 {"IF1 DAC", NULL, "I2S1"},
2340 {"IF1 DAC", NULL, "DAI1 RX Mux"},
2341 {"IF2 DAC", NULL, "I2S2"},
2342 {"IF2 DAC", NULL, "DAI2 RX Mux"},
2343 {"IF3 DAC", NULL, "I2S3"},
2344 {"IF3 DAC", NULL, "DAI3 RX Mux"},
2346 {"IF1 DAC L", NULL, "IF1 DAC"},
2347 {"IF1 DAC R", NULL, "IF1 DAC"},
2348 {"IF2 DAC L", NULL, "IF2 DAC"},
2349 {"IF2 DAC R", NULL, "IF2 DAC"},
2350 {"IF3 DAC L", NULL, "IF3 DAC"},
2351 {"IF3 DAC R", NULL, "IF3 DAC"},
2353 {"DAC MIXL", "Stereo ADC Switch", "Stereo ADC MIXL"},
2354 {"DAC MIXL", "INF1 Switch", "IF1 DAC L"},
2355 {"DAC MIXR", "Stereo ADC Switch", "Stereo ADC MIXR"},
2356 {"DAC MIXR", "INF1 Switch", "IF1 DAC R"},
2358 {"ANC", NULL, "Stereo ADC MIXL"},
2359 {"ANC", NULL, "Stereo ADC MIXR"},
2361 {"Audio DSP", NULL, "DAC MIXL"},
2362 {"Audio DSP", NULL, "DAC MIXR"},
2364 {"DAC L2 Mux", "IF2", "IF2 DAC L"},
2365 {"DAC L2 Mux", "IF3", "IF3 DAC L"},
2366 {"DAC L2 Mux", "Base L/R", "Audio DSP"},
2367 {"DAC L2 Volume", NULL, "DAC L2 Mux"},
2369 {"DAC R2 Mux", "IF2", "IF2 DAC R"},
2370 {"DAC R2 Mux", "IF3", "IF3 DAC R"},
2371 {"DAC R2 Volume", NULL, "Mono dacr Mux"},
2372 {"Mono dacr Mux", "TxDC_R", "DAC R2 Mux"},
2373 {"Mono dacr Mux", "TxDP_R", "IF2 ADC R Mux"},
2375 {"Stereo DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
2376 {"Stereo DAC MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2377 {"Stereo DAC MIXL", "ANC Switch", "ANC"},
2378 {"Stereo DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
2379 {"Stereo DAC MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2380 {"Stereo DAC MIXR", "ANC Switch", "ANC"},
2382 {"Mono DAC MIXL", "DAC L1 Switch", "DAC MIXL"},
2383 {"Mono DAC MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2384 {"Mono DAC MIXL", "DAC R2 Switch", "DAC R2 Volume"},
2385 {"Mono DAC MIXR", "DAC R1 Switch", "DAC MIXR"},
2386 {"Mono DAC MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2387 {"Mono DAC MIXR", "DAC L2 Switch", "DAC L2 Volume"},
2389 {"DIG MIXL", "DAC L1 Switch", "DAC MIXL"},
2390 {"DIG MIXL", "DAC L2 Switch", "DAC L2 Volume"},
2391 {"DIG MIXR", "DAC R1 Switch", "DAC MIXR"},
2392 {"DIG MIXR", "DAC R2 Switch", "DAC R2 Volume"},
2394 {"DAC L1", NULL, "Stereo DAC MIXL"},
2395 {"DAC L1", NULL, "PLL1", check_sysclk1_source},
2396 {"DAC R1", NULL, "Stereo DAC MIXR"},
2397 {"DAC R1", NULL, "PLL1", check_sysclk1_source},
2399 {"SPK MIXL", "REC MIXL Switch", "RECMIXL"},
2400 {"SPK MIXL", "INL Switch", "INL VOL"},
2401 {"SPK MIXL", "DAC L1 Switch", "DAC L1"},
2402 {"SPK MIXL", "OUT MIXL Switch", "OUT MIXL"},
2403 {"SPK MIXR", "REC MIXR Switch", "RECMIXR"},
2404 {"SPK MIXR", "INR Switch", "INR VOL"},
2405 {"SPK MIXR", "DAC R1 Switch", "DAC R1"},
2406 {"SPK MIXR", "OUT MIXR Switch", "OUT MIXR"},
2408 {"OUT MIXL", "SPK MIXL Switch", "SPK MIXL"},
2409 {"OUT MIXL", "BST1 Switch", "BST1"},
2410 {"OUT MIXL", "INL Switch", "INL VOL"},
2411 {"OUT MIXL", "REC MIXL Switch", "RECMIXL"},
2412 {"OUT MIXL", "DAC L1 Switch", "DAC L1"},
2414 {"OUT MIXR", "SPK MIXR Switch", "SPK MIXR"},
2415 {"OUT MIXR", "BST2 Switch", "BST2"},
2416 {"OUT MIXR", "BST1 Switch", "BST1"},
2417 {"OUT MIXR", "INR Switch", "INR VOL"},
2418 {"OUT MIXR", "REC MIXR Switch", "RECMIXR"},
2419 {"OUT MIXR", "DAC R1 Switch", "DAC R1"},
2421 {"SPKVOL L", NULL, "SPK MIXL"},
2422 {"SPKVOL R", NULL, "SPK MIXR"},
2423 {"HPOVOL L", NULL, "OUT MIXL"},
2424 {"HPOVOL R", NULL, "OUT MIXR"},
2425 {"OUTVOL L", NULL, "OUT MIXL"},
2426 {"OUTVOL R", NULL, "OUT MIXR"},
2428 {"SPOL MIX", "DAC R1 Switch", "DAC R1"},
2429 {"SPOL MIX", "DAC L1 Switch", "DAC L1"},
2430 {"SPOL MIX", "SPKVOL R Switch", "SPKVOL R"},
2431 {"SPOL MIX", "SPKVOL L Switch", "SPKVOL L"},
2432 {"SPOL MIX", "BST1 Switch", "BST1"},
2433 {"SPOR MIX", "DAC R1 Switch", "DAC R1"},
2434 {"SPOR MIX", "SPKVOL R Switch", "SPKVOL R"},
2435 {"SPOR MIX", "BST1 Switch", "BST1"},
2437 {"DAC 1", NULL, "DAC L1"},
2438 {"DAC 1", NULL, "DAC R1"},
2439 {"HPOVOL", NULL, "HPOVOL L"},
2440 {"HPOVOL", NULL, "HPOVOL R"},
2441 {"HPO MIX", "DAC1 Switch", "DAC 1"},
2442 {"HPO MIX", "HPVOL Switch", "HPOVOL"},
2444 {"LOUT MIX", "DAC L1 Switch", "DAC L1"},
2445 {"LOUT MIX", "DAC R1 Switch", "DAC R1"},
2446 {"LOUT MIX", "OUTVOL L Switch", "OUTVOL L"},
2447 {"LOUT MIX", "OUTVOL R Switch", "OUTVOL R"},
2449 {"SPK amp", NULL, "SPOL MIX"},
2450 {"SPK amp", NULL, "SPOR MIX"},
2451 {"SPOLP", NULL, "SPK amp"},
2452 {"SPOLN", NULL, "SPK amp"},
2453 {"SPORP", NULL, "SPK amp"},
2454 {"SPORN", NULL, "SPK amp"},
2456 {"HP amp", NULL, "HPO MIX"},
2457 {"HPOL", NULL, "HP amp"},
2458 {"HPOR", NULL, "HP amp"},
2460 {"LOUT amp", NULL, "LOUT MIX"},
2461 {"LOUTL", NULL, "LOUT amp"},
2462 {"LOUTR", NULL, "LOUT amp"},
2465 static int get_sdp_info(struct snd_soc_codec *codec, int dai_id)
2472 val = snd_soc_read(codec, RT5639_I2S1_SDP);
2473 val = (val & RT5639_I2S_IF_MASK) >> RT5639_I2S_IF_SFT;
2476 if (val == RT5639_IF_123 || val == RT5639_IF_132 ||
2477 val == RT5639_IF_113)
2478 ret |= RT5639_U_IF1;
2479 if (val == RT5639_IF_312 || val == RT5639_IF_213 ||
2480 val == RT5639_IF_113)
2481 ret |= RT5639_U_IF2;
2482 if (val == RT5639_IF_321 || val == RT5639_IF_231)
2483 ret |= RT5639_U_IF3;
2487 if (val == RT5639_IF_231 || val == RT5639_IF_213 ||
2488 val == RT5639_IF_223)
2489 ret |= RT5639_U_IF1;
2490 if (val == RT5639_IF_123 || val == RT5639_IF_321 ||
2491 val == RT5639_IF_223)
2492 ret |= RT5639_U_IF2;
2493 if (val == RT5639_IF_132 || val == RT5639_IF_312)
2494 ret |= RT5639_U_IF3;
2505 static int get_clk_info(int sclk, int rate)
2507 int i, pd[] = {1, 2, 3, 4, 6, 8, 12, 16};
2509 if(sclk <= 0 || rate <= 0)
2513 for (i = 0; i < ARRAY_SIZE(pd); i++)
2514 if (sclk == rate * pd[i])
2520 static int rt5639_hw_params(struct snd_pcm_substream *substream,
2521 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
2523 struct snd_soc_pcm_runtime *rtd = substream->private_data;
2524 struct snd_soc_codec *codec = rtd->codec;
2525 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2526 unsigned int val_len = 0, val_clk, mask_clk, dai_sel;
2527 int pre_div, bclk_ms, frame_size;
2529 rt5639->lrck[dai->id] = params_rate(params);
2530 pre_div = get_clk_info(rt5639->sysclk, rt5639->lrck[dai->id]);
2532 dev_err(codec->dev, "Unsupported clock setting\n");
2535 frame_size = snd_soc_params_to_frame_size(params);
2536 if (frame_size < 0) {
2537 dev_err(codec->dev, "Unsupported frame size: %d\n", frame_size);
2540 bclk_ms = frame_size > 32 ? 1 : 0;
2541 /*Tegra requires 64*fs as bitclk in slave mode*/
2543 rt5639->bclk[dai->id] = rt5639->lrck[dai->id] * (32 << bclk_ms);
2545 dev_dbg(dai->dev, "bclk is %dHz and lrck is %dHz\n",
2546 rt5639->bclk[dai->id], rt5639->lrck[dai->id]);
2547 dev_dbg(dai->dev, "bclk_ms is %d and pre_div is %d for iis %d\n",
2548 bclk_ms, pre_div, dai->id);
2550 switch (params_format(params)) {
2551 case SNDRV_PCM_FORMAT_S16_LE:
2553 case SNDRV_PCM_FORMAT_S20_3LE:
2554 val_len |= RT5639_I2S_DL_20;
2556 case SNDRV_PCM_FORMAT_S24_LE:
2557 val_len |= RT5639_I2S_DL_24;
2559 case SNDRV_PCM_FORMAT_S8:
2560 val_len |= RT5639_I2S_DL_8;
2566 dai_sel = get_sdp_info(codec, dai->id);
2567 dai_sel |= (RT5639_U_IF1 | RT5639_U_IF2);
2569 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
2572 if (dai_sel & RT5639_U_IF1) {
2573 mask_clk = RT5639_I2S_BCLK_MS1_MASK | RT5639_I2S_PD1_MASK;
2574 val_clk = bclk_ms << RT5639_I2S_BCLK_MS1_SFT |
2575 pre_div << RT5639_I2S_PD1_SFT;
2576 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
2577 RT5639_I2S_DL_MASK, val_len);
2578 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
2580 if (dai_sel & RT5639_U_IF2) {
2581 mask_clk = RT5639_I2S_BCLK_MS2_MASK | RT5639_I2S_PD2_MASK;
2582 val_clk = bclk_ms << RT5639_I2S_BCLK_MS2_SFT |
2583 pre_div << RT5639_I2S_PD2_SFT;
2584 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
2585 RT5639_I2S_DL_MASK, val_len);
2586 snd_soc_update_bits(codec, RT5639_ADDA_CLK1, mask_clk, val_clk);
2592 static int rt5639_prepare(struct snd_pcm_substream *substream,
2593 struct snd_soc_dai *dai)
2595 struct snd_soc_pcm_runtime *rtd = substream->private_data;
2596 struct snd_soc_codec *codec = rtd->codec;
2597 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2599 rt5639->aif_pu = dai->id;
2603 static int rt5639_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
2605 struct snd_soc_codec *codec = dai->codec;
2606 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2607 unsigned int reg_val = 0, dai_sel;
2609 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2610 case SND_SOC_DAIFMT_CBM_CFM:
2611 rt5639->master[dai->id] = 1;
2613 case SND_SOC_DAIFMT_CBS_CFS:
2614 reg_val |= RT5639_I2S_MS_S;
2615 rt5639->master[dai->id] = 0;
2621 switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
2622 case SND_SOC_DAIFMT_NB_NF:
2624 case SND_SOC_DAIFMT_IB_NF:
2625 reg_val |= RT5639_I2S_BP_INV;
2631 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
2632 case SND_SOC_DAIFMT_I2S:
2634 case SND_SOC_DAIFMT_LEFT_J:
2635 reg_val |= RT5639_I2S_DF_LEFT;
2637 case SND_SOC_DAIFMT_DSP_A:
2638 reg_val |= RT5639_I2S_DF_PCM_A;
2640 case SND_SOC_DAIFMT_DSP_B:
2641 reg_val |= RT5639_I2S_DF_PCM_B;
2647 dai_sel = get_sdp_info(codec, dai->id);
2649 dev_err(codec->dev, "Failed to get sdp info: %d\n", dai_sel);
2652 if (dai_sel & RT5639_U_IF1) {
2653 snd_soc_update_bits(codec, RT5639_I2S1_SDP,
2654 RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
2655 RT5639_I2S_DF_MASK, reg_val);
2657 if (dai_sel & RT5639_U_IF2) {
2658 snd_soc_update_bits(codec, RT5639_I2S2_SDP,
2659 RT5639_I2S_MS_MASK | RT5639_I2S_BP_MASK |
2660 RT5639_I2S_DF_MASK, reg_val);
2666 static int rt5639_set_dai_sysclk(struct snd_soc_dai *dai,
2667 int clk_id, unsigned int freq, int dir)
2669 struct snd_soc_codec *codec = dai->codec;
2670 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2671 unsigned int reg_val = 0;
2673 if (freq == rt5639->sysclk && clk_id == rt5639->sysclk_src)
2677 case RT5639_SCLK_S_MCLK:
2678 reg_val |= RT5639_SCLK_SRC_MCLK;
2680 case RT5639_SCLK_S_PLL1:
2681 reg_val |= RT5639_SCLK_SRC_PLL1;
2683 case RT5639_SCLK_S_RCCLK:
2684 reg_val |= RT5639_SCLK_SRC_RCCLK;
2687 dev_err(codec->dev, "Invalid clock id (%d)\n", clk_id);
2690 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2691 RT5639_SCLK_SRC_MASK, reg_val);
2692 rt5639->sysclk = freq;
2693 rt5639->sysclk_src = clk_id;
2695 dev_dbg(dai->dev, "Sysclk is %dHz and clock id is %d\n", freq, clk_id);
2701 * rt5639_pll_calc - Calcualte PLL M/N/K code.
2702 * @freq_in: external clock provided to codec.
2703 * @freq_out: target clock which codec works on.
2704 * @pll_code: Pointer to structure with M, N, K and bypass flag.
2706 * Calcualte M/N/K code to configure PLL for codec. And K is assigned to 2
2707 * which make calculation more efficiently.
2709 * Returns 0 for success or negative error code.
2711 static int rt5639_pll_calc(const unsigned int freq_in,
2712 const unsigned int freq_out, struct rt5639_pll_code *pll_code)
2714 int max_n = RT5639_PLL_N_MAX, max_m = RT5639_PLL_M_MAX;
2715 int k, n = 0, m = 0, red, n_t, m_t, pll_out, in_t, out_t;
2716 int red_t = abs(freq_out - freq_in);
2717 bool bypass = false;
2719 if (RT5639_PLL_INP_MAX < freq_in || RT5639_PLL_INP_MIN > freq_in)
2722 k = 100000000 / freq_out - 2;
2723 if (k > RT5639_PLL_K_MAX)
2724 k = RT5639_PLL_K_MAX;
2725 for (n_t = 0; n_t <= max_n; n_t++) {
2726 in_t = freq_in / (k + 2);
2727 pll_out = freq_out / (n_t + 2);
2730 if (in_t == pll_out) {
2735 red = abs(in_t - pll_out);
2744 for (m_t = 0; m_t <= max_m; m_t++) {
2745 out_t = in_t / (m_t + 2);
2746 red = abs(out_t - pll_out);
2757 pr_debug("Only get approximation about PLL\n");
2761 pll_code->m_bp = bypass;
2762 pll_code->m_code = m;
2763 pll_code->n_code = n;
2764 pll_code->k_code = k;
2768 static int rt5639_set_dai_pll(struct snd_soc_dai *dai, int pll_id, int source,
2769 unsigned int freq_in, unsigned int freq_out)
2771 struct snd_soc_codec *codec = dai->codec;
2772 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
2773 struct rt5639_pll_code pll_code;
2776 if (source == rt5639->pll_src && freq_in == rt5639->pll_in &&
2777 freq_out == rt5639->pll_out)
2780 if (!freq_in || !freq_out) {
2781 dev_dbg(codec->dev, "PLL disabled\n");
2784 rt5639->pll_out = 0;
2785 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2786 RT5639_SCLK_SRC_MASK, RT5639_SCLK_SRC_MCLK);
2791 case RT5639_PLL1_S_MCLK:
2792 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2793 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_MCLK);
2795 case RT5639_PLL1_S_BCLK1:
2796 case RT5639_PLL1_S_BCLK2:
2797 dai_sel = get_sdp_info(codec, dai->id);
2800 "Failed to get sdp info: %d\n", dai_sel);
2803 if (dai_sel & RT5639_U_IF1) {
2804 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2805 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK1);
2807 if (dai_sel & RT5639_U_IF2) {
2808 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2809 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK2);
2811 if (dai_sel & RT5639_U_IF3) {
2812 snd_soc_update_bits(codec, RT5639_GLB_CLK,
2813 RT5639_PLL1_SRC_MASK, RT5639_PLL1_SRC_BCLK3);
2817 dev_err(codec->dev, "Unknown PLL source %d\n", source);
2821 ret = rt5639_pll_calc(freq_in, freq_out, &pll_code);
2823 dev_err(codec->dev, "Unsupport input clock %d\n", freq_in);
2827 dev_dbg(codec->dev, "bypass=%d m=%d n=%d k=%d\n", pll_code.m_bp,
2828 (pll_code.m_bp ? 0 : pll_code.m_code),
2829 pll_code.n_code, pll_code.k_code);
2831 snd_soc_write(codec, RT5639_PLL_CTRL1,
2832 pll_code.n_code << RT5639_PLL_N_SFT | pll_code.k_code);
2833 snd_soc_write(codec, RT5639_PLL_CTRL2,
2834 (pll_code.m_bp ? 0 : pll_code.m_code) << RT5639_PLL_M_SFT |
2835 pll_code.m_bp << RT5639_PLL_M_BP_SFT);
2837 rt5639->pll_in = freq_in;
2838 rt5639->pll_out = freq_out;
2839 rt5639->pll_src = source;
2845 * rt5639_index_show - Dump private registers.
2846 * @dev: codec device.
2847 * @attr: device attribute.
2848 * @buf: buffer for display.
2850 * To show non-zero values of all private registers.
2852 * Returns buffer length.
2854 static ssize_t rt5639_index_show(struct device *dev,
2855 struct device_attribute *attr, char *buf)
2857 struct i2c_client *client = to_i2c_client(dev);
2858 struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2859 struct snd_soc_codec *codec = rt5639->codec;
2863 cnt += sprintf(buf, "RT5639 index register\n");
2864 for (i = 0; i < 0xb4; i++) {
2865 if (cnt + RT5639_REG_DISP_LEN >= PAGE_SIZE)
2867 val = rt5639_index_read(codec, i);
2870 cnt += snprintf(buf + cnt, RT5639_REG_DISP_LEN,
2871 "%02x: %04x\n", i, val);
2874 if (cnt >= PAGE_SIZE)
2875 cnt = PAGE_SIZE - 1;
2880 static ssize_t rt5639_index_store(struct device *dev,
2881 struct device_attribute *attr, const char *buf, size_t count)
2883 struct i2c_client *client = to_i2c_client(dev);
2884 struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2885 struct snd_soc_codec *codec = rt5639->codec;
2886 unsigned int val = 0, addr = 0;
2889 dev_info(codec->dev, "register \"%s\" count=%d\n", buf, count);
2890 for (i = 0; i < count; i++) { /*address*/
2891 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2892 addr = (addr << 4) | (*(buf+i)-'0');
2893 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2894 addr = (addr << 4) | ((*(buf+i) - 'a')+0xa);
2895 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2896 addr = (addr << 4) | ((*(buf+i) - 'A')+0xa);
2901 for (i = i+1; i < count; i++) { /*val*/
2902 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2903 val = (val << 4) | (*(buf+i) - '0');
2904 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2905 val = (val << 4) | ((*(buf+i) - 'a') + 0xa);
2906 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2907 val = (val << 4) | ((*(buf+i) - 'A') + 0xa);
2911 dev_info(codec->dev, "addr=0x%x val=0x%x\n", addr, val);
2912 if (addr > RT5639_VENDOR_ID2 || val > 0xffff || val < 0)
2916 dev_info(codec->dev, "0x%02x = 0x%04x\n", addr,
2917 rt5639_index_read(codec, addr));
2919 rt5639_index_write(codec, addr, val);
2923 static DEVICE_ATTR(index_reg, 0444, rt5639_index_show, rt5639_index_store);
2925 static ssize_t rt5639_codec_show(struct device *dev,
2926 struct device_attribute *attr, char *buf)
2928 struct i2c_client *client = to_i2c_client(dev);
2929 struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2930 struct snd_soc_codec *codec = rt5639->codec;
2934 cnt += sprintf(buf, "RT5639 codec register\n");
2935 for (i = 0; i <= RT5639_VENDOR_ID2; i++) {
2936 if (cnt + RT5639_REG_DISP_LEN >= PAGE_SIZE)
2938 val = codec->hw_read(codec, i);
2941 cnt += snprintf(buf + cnt, RT5639_REG_DISP_LEN,
2942 "#rng%02x #rv%04x #rd0\n", i, val);
2945 if (cnt >= PAGE_SIZE)
2946 cnt = PAGE_SIZE - 1;
2951 static ssize_t rt5639_codec_store(struct device *dev,
2952 struct device_attribute *attr, const char *buf, size_t count)
2954 struct i2c_client *client = to_i2c_client(dev);
2955 struct rt5639_priv *rt5639 = i2c_get_clientdata(client);
2956 struct snd_soc_codec *codec = rt5639->codec;
2957 unsigned int val = 0, addr = 0;
2960 dev_info(codec->dev, "register \"%s\" count=%d\n", buf, count);
2961 for (i = 0; i < count; i++) {/*address*/
2962 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2963 addr = (addr << 4) | (*(buf+i)-'0');
2964 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2965 addr = (addr << 4) | ((*(buf+i) - 'a') + 0xa);
2966 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2967 addr = (addr << 4) | ((*(buf+i) - 'A') + 0xa);
2972 for (i = i+1; i < count; i++) {/*val*/
2973 if (*(buf+i) <= '9' && *(buf+i) >= '0')
2974 val = (val << 4) | (*(buf+i) - '0');
2975 else if (*(buf+i) <= 'f' && *(buf+i) >= 'a')
2976 val = (val << 4) | ((*(buf+i) - 'a') + 0xa);
2977 else if (*(buf+i) <= 'F' && *(buf+i) >= 'A')
2978 val = (val << 4) | ((*(buf+i) - 'A') + 0xa);
2982 dev_info(codec->dev, "addr=0x%x val=0x%x\n", addr, val);
2983 if (addr > RT5639_VENDOR_ID2 || val > 0xffff || val < 0)
2987 dev_info(codec->dev, "0x%02x = 0x%04x\n", addr,
2988 codec->hw_read(codec, addr));
2990 snd_soc_write(codec, addr, val);
2995 static DEVICE_ATTR(codec_reg, 0644, rt5639_codec_show, rt5639_codec_store);
2997 static int rt5639_set_bias_level(struct snd_soc_codec *codec,
2998 enum snd_soc_bias_level level)
3002 /* Make sure test mode is not enabled */
3003 val = rt5639_index_read(codec, 0x001B);
3005 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0301);
3007 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0328);
3010 case SND_SOC_BIAS_ON:
3013 case SND_SOC_BIAS_PREPARE:
3014 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
3015 RT5639_PWR_MB1 | RT5639_PWR_MB2,
3016 RT5639_PWR_MB1 | RT5639_PWR_MB2);
3019 case SND_SOC_BIAS_STANDBY:
3020 snd_soc_update_bits(codec, RT5639_PWR_ANLG2,
3021 RT5639_PWR_MB1 | RT5639_PWR_MB2, 0);
3022 if (SND_SOC_BIAS_OFF == codec->dapm.bias_level) {
3023 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
3024 RT5639_PWR_VREF1 | RT5639_PWR_MB |
3025 RT5639_PWR_BG | RT5639_PWR_VREF2,
3026 RT5639_PWR_VREF1 | RT5639_PWR_MB |
3027 RT5639_PWR_BG | RT5639_PWR_VREF2);
3029 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
3030 RT5639_PWR_FV1 | RT5639_PWR_FV2,
3031 RT5639_PWR_FV1 | RT5639_PWR_FV2);
3032 snd_soc_write(codec, RT5639_GEN_CTRL1, 0x3b01);
3033 codec->cache_only = false;
3034 codec->cache_sync = 1;
3035 snd_soc_cache_sync(codec);
3036 rt5639_index_sync(codec);
3040 case SND_SOC_BIAS_OFF:
3041 snd_soc_write(codec, RT5639_DEPOP_M1, 0x0004);
3042 snd_soc_write(codec, RT5639_DEPOP_M2, 0x1100);
3043 snd_soc_write(codec, RT5639_GEN_CTRL1, 0x3b01);
3044 snd_soc_write(codec, RT5639_PWR_DIG1, 0x0000);
3045 snd_soc_write(codec, RT5639_PWR_DIG2, 0x0000);
3046 snd_soc_write(codec, RT5639_PWR_VOL, 0x0000);
3047 snd_soc_write(codec, RT5639_PWR_MIXER, 0x0000);
3048 snd_soc_write(codec, RT5639_PWR_ANLG1, 0x0000);
3049 snd_soc_write(codec, RT5639_PWR_ANLG2, 0x0000);
3050 snd_soc_write(codec, RT5639_CLS_D_OVCD, 0x0301);
3056 codec->dapm.bias_level = level;
3061 static int rt5639_probe(struct snd_soc_codec *codec)
3063 struct rt5639_priv *rt5639 = snd_soc_codec_get_drvdata(codec);
3066 #if defined(CONFIG_SND_HWDEP) || defined(CONFIG_SND_HWDEP_MODULE)
3067 struct rt56xx_ops *ioctl_ops;
3071 codec->dapm.idle_bias_off = 1;
3073 ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
3075 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
3079 rt5639_reset(codec);
3080 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
3081 RT5639_PWR_VREF1 | RT5639_PWR_MB |
3082 RT5639_PWR_BG | RT5639_PWR_VREF2,
3083 RT5639_PWR_VREF1 | RT5639_PWR_MB |
3084 RT5639_PWR_BG | RT5639_PWR_VREF2);
3086 snd_soc_update_bits(codec, RT5639_PWR_ANLG1,
3087 RT5639_PWR_FV1 | RT5639_PWR_FV2,
3088 RT5639_PWR_FV1 | RT5639_PWR_FV2);
3090 if (rt5639->dmic_en == RT5639_DMIC1) {
3091 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
3092 RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
3093 snd_soc_update_bits(codec, RT5639_DMIC,
3094 RT5639_DMIC_1L_LH_MASK | RT5639_DMIC_1R_LH_MASK,
3095 RT5639_DMIC_1L_LH_FALLING | RT5639_DMIC_1R_LH_RISING);
3096 } else if (rt5639->dmic_en == RT5639_DMIC2) {
3097 snd_soc_update_bits(codec, RT5639_GPIO_CTRL1,
3098 RT5639_GP2_PIN_MASK, RT5639_GP2_PIN_DMIC1_SCL);
3099 snd_soc_update_bits(codec, RT5639_DMIC,
3100 RT5639_DMIC_2L_LH_MASK | RT5639_DMIC_2R_LH_MASK,
3101 RT5639_DMIC_2L_LH_FALLING | RT5639_DMIC_2R_LH_RISING);
3103 /*snd_soc_write(codec, RT5639_GEN_CTRL2, 0x4040);*/
3104 /* Enable JD2 Function for Extra JD Status */
3105 snd_soc_write(codec, RT5639_GEN_CTRL2, 0x4140);
3106 ret = snd_soc_read(codec, RT5639_VENDOR_ID);
3107 dev_info(codec->dev, "read 0x%x=0x%x\n", RT5639_VENDOR_ID, ret);
3109 snd_soc_update_bits(codec, RT5639_JD_CTRL,
3110 RT5639_JD1_IN4P_MASK | RT5639_JD2_IN4N_MASK,
3111 RT5639_JD1_IN4P_EN | RT5639_JD2_IN4N_EN);
3113 rt5639_reg_init(codec);
3114 DC_Calibrate(codec);
3115 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
3116 rt5639->codec = codec;
3118 snd_soc_add_codec_controls(codec, rt5639_snd_controls,
3119 ARRAY_SIZE(rt5639_snd_controls));
3120 snd_soc_dapm_new_controls(&codec->dapm, rt5639_dapm_widgets,
3121 ARRAY_SIZE(rt5639_dapm_widgets));
3122 snd_soc_dapm_add_routes(&codec->dapm, rt5639_dapm_routes,
3123 ARRAY_SIZE(rt5639_dapm_routes));
3125 rt5639->codec = codec;
3128 #if defined(CONFIG_SND_HWDEP) || defined(CONFIG_SND_HWDEP_MODULE)
3129 ioctl_ops = rt56xx_get_ioctl_ops();
3130 ioctl_ops->index_write = rt5639_index_write;
3131 ioctl_ops->index_read = rt5639_index_read;
3132 ioctl_ops->index_update_bits = rt5639_index_update_bits;
3133 ioctl_ops->ioctl_common = rt5639_ioctl_common;
3134 realtek_ce_init_hwdep(codec);
3138 ret = device_create_file(codec->dev, &dev_attr_index_reg);
3141 "Failed to create index_reg sysfs files: %d\n", ret);
3148 static int rt5639_remove(struct snd_soc_codec *codec)
3150 rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
3155 static int rt5639_suspend(struct snd_soc_codec *codec)
3157 rt5639_reset(codec);
3158 rt5639_set_bias_level(codec, SND_SOC_BIAS_OFF);
3162 static int rt5639_resume(struct snd_soc_codec *codec)
3166 codec->cache_sync = 1;
3167 ret = snd_soc_cache_sync(codec);
3169 dev_err(codec->dev,"Failed to sync cache: %d\n", ret);
3172 rt5639_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
3176 #define rt5639_suspend NULL
3177 #define rt5639_resume NULL
3180 #define RT5639_STEREO_RATES SNDRV_PCM_RATE_8000_192000
3181 #define RT5639_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
3182 SNDRV_PCM_FMTBIT_S24_LE | SNDRV_PCM_FMTBIT_S8)
3184 struct snd_soc_dai_ops rt5639_aif_dai_ops = {
3185 .hw_params = rt5639_hw_params,
3186 .prepare = rt5639_prepare,
3187 .set_fmt = rt5639_set_dai_fmt,
3188 .set_sysclk = rt5639_set_dai_sysclk,
3189 .set_pll = rt5639_set_dai_pll,
3192 struct snd_soc_dai_driver rt5639_dai[] = {
3194 .name = "rt5639-aif1",
3197 .stream_name = "AIF1 Playback",
3200 .rates = RT5639_STEREO_RATES,
3201 .formats = RT5639_FORMATS,
3204 .stream_name = "AIF1 Capture",
3207 .rates = RT5639_STEREO_RATES,
3208 .formats = RT5639_FORMATS,
3210 .ops = &rt5639_aif_dai_ops,
3213 .name = "rt5639-aif2",
3216 .stream_name = "AIF2 Playback",
3219 .rates = RT5639_STEREO_RATES,
3220 .formats = RT5639_FORMATS,
3223 .stream_name = "AIF2 Capture",
3226 .rates = RT5639_STEREO_RATES,
3227 .formats = RT5639_FORMATS,
3229 .ops = &rt5639_aif_dai_ops,
3233 static struct snd_soc_codec_driver soc_codec_dev_rt5639 = {
3234 .probe = rt5639_probe,
3235 .remove = rt5639_remove,
3236 .suspend = rt5639_suspend,
3237 .resume = rt5639_resume,
3238 .set_bias_level = rt5639_set_bias_level,
3239 .reg_cache_size = RT5639_VENDOR_ID2 + 1,
3240 .reg_word_size = sizeof(u16),
3241 .reg_cache_default = rt5639_reg,
3242 .volatile_register = rt5639_volatile_register,
3243 .readable_register = rt5639_readable_register,
3244 .reg_cache_step = 1,
3247 static const struct i2c_device_id rt5639_i2c_id[] = {
3251 MODULE_DEVICE_TABLE(i2c, rt5639_i2c_id);
3253 static int rt5639_i2c_probe(struct i2c_client *i2c,
3254 const struct i2c_device_id *id)
3256 struct rt5639_priv *rt5639;
3259 rt5639 = kzalloc(sizeof(struct rt5639_priv), GFP_KERNEL);
3263 i2c_set_clientdata(i2c, rt5639);
3265 ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_rt5639,
3266 rt5639_dai, ARRAY_SIZE(rt5639_dai));
3273 static int rt5639_i2c_remove(struct i2c_client *i2c)
3275 snd_soc_unregister_codec(&i2c->dev);
3276 kfree(i2c_get_clientdata(i2c));
3280 static const struct of_device_id rt5639_of_match[] = {
3281 { .compatible = "realtek,rt5639", },
3285 struct i2c_driver rt5639_i2c_driver = {
3288 .owner = THIS_MODULE,
3289 .of_match_table = rt5639_of_match,
3291 .probe = rt5639_i2c_probe,
3292 .remove = rt5639_i2c_remove,
3293 .id_table = rt5639_i2c_id,
3296 static int __init rt5639_modinit(void)
3298 return i2c_add_driver(&rt5639_i2c_driver);
3300 module_init(rt5639_modinit);
3302 static void __exit rt5639_modexit(void)
3304 i2c_del_driver(&rt5639_i2c_driver);
3306 module_exit(rt5639_modexit);
3308 MODULE_DESCRIPTION("ASoC RT5639 driver");
3309 MODULE_AUTHOR("Johnny Hsu <johnnyhsu@realtek.com>");
3310 MODULE_LICENSE("GPL");