sound/soc/codecs/rt5631.c

   1 /*
   2  * rt5631.c  --  RT5631 ALSA Soc Audio driver
   3  *
   4  * Copyright 2011 Realtek Microelectronics
   5  *
   6  * Author: flove <flove@realtek.com>
   7  *
   8  * Based on WM8753.c
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License version 2 as
  12  * published by the Free Software Foundation.
  13  *
  14  */
  15 #include <linux/module.h>
  16 #include <linux/moduleparam.h>
  17 #include <linux/init.h>
  18 #include <linux/delay.h>
  19 #include <linux/pm.h>
  20 #include <linux/i2c.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/spi/spi.h>
  23 #include <sound/core.h>
  24 #include <sound/pcm.h>
  25 #include <sound/pcm_params.h>
  26 #include <sound/soc.h>
  27 #include <sound/soc-dapm.h>
  28 #include <sound/initval.h>
  29
  30 #include "rt5631.h"
  31 #include <linux/timer.h>
  32
  33 #if 0
  34 #define DBG(x...)       printk(x)
  35 #else
  36 #define DBG(x...)
  37 #endif
  38 #define RT5631_VERSION "0.01 alsa 1.0.24"
  39
  40 #define RT5631_ALC_DAC_FUNC_ENA 0       //ALC functio for DAC
  41 #define RT5631_ALC_ADC_FUNC_ENA 1       //ALC function for ADC
  42 #define RT5631_SPK_TIMER        0       //if enable this, MUST enable RT5631_EQ_FUNC_ENA first!
  43
  44 struct rt5631_priv {
  45         int codec_version;
  46         int master;
  47         int sysclk;
  48         int dmic_used_flag;
  49         int eq_mode;
  50         int pll_used_flag;
  51 };
  52 #if (RT5631_SPK_TIMER == 1)
  53 static struct timer_list spk_timer;
  54 struct work_struct  spk_work;
  55 static bool last_is_spk = false;        // need modify.
  56 #endif
  57
  58 static struct snd_soc_codec *rt5631_codec;
  59 struct delayed_work rt5631_delay_cap; //bard 7-16
  60 EXPORT_SYMBOL(rt5631_delay_cap); //bard 7-16
  61 static const u16 rt5631_reg[0x80];
  62 static int timesofbclk = 32;
  63 bool isPlaybackon = false, isCaptureon = false;
  64
  65 module_param(timesofbclk, int, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
  66 MODULE_PARM_DESC(timeofbclk, "relationship between bclk and fs");
  67
  68
  69 static inline int rt5631_write(struct snd_soc_codec *codec,
  70                         unsigned int reg, unsigned int val)
  71 {
  72         return snd_soc_write(codec, reg, val);
  73 }
  74
  75 static inline unsigned int rt5631_read(struct snd_soc_codec *codec,
  76                                 unsigned int reg)
  77 {
  78         return snd_soc_read(codec, reg);
  79 }
  80
  81 static int rt5631_write_mask(struct snd_soc_codec *codec,
  82         unsigned int reg, unsigned int value, unsigned int mask)
  83 {
  84         unsigned int reg_val;
  85         int ret = 0;
  86
  87         if (!mask)
  88                 return 0;
  89
  90         if (mask != 0xffff) {
  91                 reg_val = rt5631_read(codec, reg);
  92                 reg_val &= ~mask;
  93                 reg_val |= (value & mask);
  94                 ret = rt5631_write(codec, reg, reg_val);
  95         } else {
  96                 ret = rt5631_write(codec, reg, value);
  97         }
  98
  99         return ret;
 100 }
 101
 102 static void rt5631_write_index(struct snd_soc_codec *codec,
 103                 unsigned int reg, unsigned int value)
 104 {
 105         rt5631_write(codec, RT5631_INDEX_ADD, reg);
 106         rt5631_write(codec, RT5631_INDEX_DATA, value);
 107         return;
 108 }
 109
 110 static unsigned int rt5631_read_index(struct snd_soc_codec *codec,
 111                                 unsigned int reg)
 112 {
 113         unsigned int value;
 114
 115         rt5631_write(codec, RT5631_INDEX_ADD, reg);
 116         value = rt5631_read(codec, RT5631_INDEX_DATA);
 117
 118         return value;
 119 }
 120
 121 static void rt5631_write_index_mask(struct snd_soc_codec *codec,
 122         unsigned int reg, unsigned int value, unsigned int mask)
 123 {
 124         unsigned int reg_val;
 125
 126         if (!mask)
 127                 return;
 128
 129         if (mask != 0xffff) {
 130                 reg_val = rt5631_read_index(codec, reg);
 131                 reg_val &= ~mask;
 132                 reg_val |= (value & mask);
 133                 rt5631_write_index(codec, reg, reg_val);
 134         } else {
 135                 rt5631_write_index(codec, reg, value);
 136         }
 137
 138         return;
 139 }
 140
 141 static inline int rt5631_reset(struct snd_soc_codec *codec)
 142 {
 143         return snd_soc_write(codec, RT5631_RESET, 0);
 144 }
 145
 146 struct rt5631_init_reg {
 147         u8 reg;
 148         u16 val;
 149 };
 150
 151 #ifndef DEF_VOL
 152 #define DEF_VOL                                 0xd4//0xd4 -30dB 0xc0 0dB
 153 #endif
 154 #ifndef DEF_VOL_SPK
 155 #define DEF_VOL_SPK                             0xc4
 156 #endif
 157
 158 /*
 159  * speaker channel volume select SPKMIXER, 0DB by default
 160  * Headphone channel volume select OUTMIXER,0DB by default
 161  * AXO1/AXO2 channel volume select OUTMIXER,0DB by default
 162  * Record Mixer source from Mic1/Mic2 by default
 163  * Mic1/Mic2 boost 40dB by default
 164  * DAC_L-->OutMixer_L by default
 165  * DAC_R-->OutMixer_R by default
 166  * DAC-->SpeakerMixer
 167  * Speaker volume-->SPOMixer(L-->L,R-->R)
 168  * Speaker AMP ratio gain is 1.44X
 169  * HP from OutMixer,speaker out from SpeakerOut Mixer
 170  * enable HP zero cross
 171  * change Mic1 & mic2 to differential mode
 172  */
 173 static struct rt5631_init_reg init_list[] = {
 174
 175         {RT5631_SPK_OUT_VOL             , (DEF_VOL_SPK<<8) | DEF_VOL_SPK},//speaker channel volume select SPKMIXER,0DB by default
 176         {RT5631_HP_OUT_VOL              , (DEF_VOL<<8) | DEF_VOL},//Headphone channel volume select OUTMIXER,0DB by default
 177         {RT5631_MONO_AXO_1_2_VOL        , 0xf0c0},//AXO1/AXO2 channel volume select OUTMIXER,0DB by default
 178         //{RT5631_STEREO_DAC_VOL_1      , 0x004C},
 179         {RT5631_ADC_REC_MIXER           , 0xb0f0},//Record Mixer source from Mic1 by default
 180         {RT5631_ADC_CTRL_1              , 0x0006},//STEREO ADC CONTROL 1
 181         {RT5631_MIC_CTRL_2              , 0x4400},//0x8800},//0x6600}, //Mic1/Mic2 boost 40DB by default
 182         {RT5631_PWR_MANAG_ADD1          , 0x93e0},
 183
 184 #if RT5631_ALC_ADC_FUNC_ENA
 185
 186         {RT5631_ALC_CTRL_1              , 0x0a0f},//ALC CONTROL 1
 187         {RT5631_ALC_CTRL_2              , 0x0005},//ALC CONTROL 2
 188         {RT5631_ALC_CTRL_3              , 0xe080},//ALC CONTROL 3
 189
 190 #endif
 191         {RT5631_OUTMIXER_L_CTRL         , 0xdfC0},//DAC_L-->OutMixer_L by default
 192         {RT5631_OUTMIXER_R_CTRL         , 0xdfC0},//DAC_R-->OutMixer_R by default
 193         {RT5631_AXO1MIXER_CTRL          , 0x8840},//OutMixer_L-->AXO1Mixer by default
 194         {RT5631_AXO2MIXER_CTRL          , 0x8880},//OutMixer_R-->AXO2Mixer by default
 195         {RT5631_SPK_MIXER_CTRL          , 0xd8d8},//DAC-->SpeakerMixer
 196         {RT5631_SPK_MONO_OUT_CTRL       , 0x6c00},//Speaker volume-->SPOMixer(L-->L,R-->R)
 197         {RT5631_GEN_PUR_CTRL_REG        , 0x4e00},//Speaker AMP ratio gain is 1.27x
 198 #if defined(CONFIG_ADJUST_VOL_BY_CODEC)
 199         {RT5631_SPK_MONO_HP_OUT_CTRL    , 0x0000},//HP from outputmixer,speaker out from SpeakerOut Mixer
 200 #else
 201         {RT5631_SPK_MONO_HP_OUT_CTRL    , 0x000c},//HP from DAC,speaker out from SpeakerOut Mixer
 202 #endif
 203         {RT5631_DEPOP_FUN_CTRL_2        , 0x8000},//HP depop by register control
 204         {RT5631_INT_ST_IRQ_CTRL_2       , 0x0f18},//enable HP zero cross
 205         {RT5631_MIC_CTRL_1              , 0x8000},//set mic 1 to differnetial mode
 206         {RT5631_GPIO_CTRL               , 0x0000},//set GPIO to input pin
 207 //      {RT5631_JACK_DET_CTRL           , 0x4e80},//Jack detect for GPIO,high is HP,low is speaker
 208         {RT5631_JACK_DET_CTRL           , 0x4bc0},//Jack detect for GPIO,high is speaker,low is hp
 209 };
 210 #define RT5631_INIT_REG_LEN ARRAY_SIZE(init_list)
 211
 212 /*
 213  * EQ parameter
 214  */
 215 enum {
 216         NORMAL,
 217         CLUB,
 218         DANCE,
 219         LIVE,
 220         POP,
 221         ROCK,
 222         OPPO,
 223         TREBLE,
 224         BASS,
 225         HFREQ,
 226         SPK_FR
 227 };
 228
 229 struct hw_eq_preset {
 230         u16 type;
 231         u16 value[22];
 232         u16 ctrl;
 233 };
 234
 235 /*
 236  * EQ param reg : 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
 237  *              0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf
 238  * EQ control reg : 0x6e
 239  */
 240 struct hw_eq_preset hweq_preset[] = {
 241         {NORMAL , {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 242                 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 243                 0x0000, 0x0000, 0x0000, 0x0000}, 0x0000},
 244         {CLUB   , {0x1C10, 0x0000, 0xC1CC, 0x1E5D, 0x0699, 0xCD48,
 245                 0x188D, 0x0699, 0xC3B6, 0x1CD0, 0x0699, 0x0436,
 246                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000E},
 247         {DANCE  , {0x1F2C, 0x095B, 0xC071, 0x1F95, 0x0616, 0xC96E,
 248                 0x1B11, 0xFC91, 0xDCF2, 0x1194, 0xFAF2, 0x0436,
 249                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000F},
 250         {LIVE   , {0x1EB5, 0xFCB6, 0xC24A, 0x1DF8, 0x0E7C, 0xC883,
 251                 0x1C10, 0x0699, 0xDA41, 0x1561, 0x0295, 0x0436,
 252                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000F},
 253         {POP    , {0x1EB5, 0xFCB6, 0xC1D4, 0x1E5D, 0x0E23, 0xD92E,
 254                 0x16E6, 0xFCB6, 0x0000, 0x0969, 0xF988, 0x0436,
 255                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000F},
 256         {ROCK   , {0x1EB5, 0xFCB6, 0xC071, 0x1F95, 0x0424, 0xC30A,
 257                 0x1D27, 0xF900, 0x0C5D, 0x0FC7, 0x0E23, 0x0436,
 258                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000F},
 259         {OPPO   , {0x0000, 0x0000, 0xCA4A, 0x17F8, 0x0FEC, 0xCA4A,
 260                 0x17F8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 261                 0x0000, 0x0000, 0x0000, 0x0000}, 0x000F},
 262         {TREBLE , {0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 263                 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x188D,
 264                 0x1699, 0x0000, 0x0000, 0x0000}, 0x0010},
 265         {BASS   , {0x1A43, 0x0C00, 0x0000, 0x0000, 0x0000, 0x0000,
 266                 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000,
 267                 0x0000, 0x0000, 0x0000, 0x0000}, 0x0001},
 268 };
 269
 270 static int rt5631_reg_init(struct snd_soc_codec *codec)
 271 {
 272         int i;
 273
 274         for (i = 0; i < RT5631_INIT_REG_LEN; i++)
 275                 rt5631_write(codec, init_list[i].reg, init_list[i].val);
 276
 277         return 0;
 278 }
 279 //bard 7-16 s
 280 void rt5631_adc_on(struct work_struct *work)
 281 {
 282         int val;
 283
 284         val = snd_soc_read(rt5631_codec,RT5631_ADC_REC_MIXER);
 285         snd_soc_write(rt5631_codec,RT5631_ADC_REC_MIXER,0xf0f0);
 286
 287         snd_soc_update_bits(rt5631_codec, RT5631_PWR_MANAG_ADD1,
 288                 PWR_ADC_L_CLK | PWR_ADC_R_CLK, 0);
 289         snd_soc_update_bits(rt5631_codec, RT5631_PWR_MANAG_ADD1,
 290                 PWR_ADC_L_CLK | PWR_ADC_R_CLK,
 291                 PWR_ADC_L_CLK | PWR_ADC_R_CLK);
 292         snd_soc_write(rt5631_codec,RT5631_ADC_REC_MIXER,val);
 293         snd_soc_update_bits(rt5631_codec, RT5631_ADC_CTRL_1,
 294                                 RT_L_MUTE|RT_R_MUTE,0x0);
 295
 296 }
 297 //bard 7-16 e
 298 static const char *rt5631_spol_source_sel[] = {
 299         "SPOLMIX", "MONOIN_RX", "VDAC", "DACL"};
 300 static const char *rt5631_spor_source_sel[] = {
 301         "SPORMIX", "MONOIN_RX", "VDAC", "DACR"};
 302 static const char *rt5631_mono_source_sel[] = {"MONOMIX", "MONOIN_RX", "VDAC"};
 303 static const char *rt5631_input_mode_source_sel[] = {
 304         "Single-end", "Differential"};
 305 static const char *rt5631_mic_boost[] = {"Bypass", "+20db", "+24db", "+30db",
 306                         "+35db", "+40db", "+44db", "+50db", "+52db"};
 307 static const char *rt5631_hpl_source_sel[] = {"LEFT HPVOL", "LEFT DAC"};
 308 static const char *rt5631_hpr_source_sel[] = {"RIGHT HPVOL", "RIGHT DAC"};
 309 static const char *rt5631_eq_sel[] = {"NORMAL", "CLUB", "DANCE", "LIVE", "POP",
 310                                 "ROCK", "OPPO", "TREBLE", "BASS"};
 311
 312
 313 static const struct soc_enum rt5631_enum[] = {
 314 SOC_ENUM_SINGLE(RT5631_SPK_MONO_HP_OUT_CTRL, 14, 4, rt5631_spol_source_sel),
 315 SOC_ENUM_SINGLE(RT5631_SPK_MONO_HP_OUT_CTRL, 10, 4, rt5631_spor_source_sel),
 316 SOC_ENUM_SINGLE(RT5631_SPK_MONO_HP_OUT_CTRL, 6, 3, rt5631_mono_source_sel),
 317 SOC_ENUM_SINGLE(RT5631_MIC_CTRL_1, 15, 2,  rt5631_input_mode_source_sel),
 318 SOC_ENUM_SINGLE(RT5631_MIC_CTRL_1, 7, 2,  rt5631_input_mode_source_sel),
 319 SOC_ENUM_SINGLE(RT5631_MONO_INPUT_VOL, 15, 2, rt5631_input_mode_source_sel),
 320 SOC_ENUM_SINGLE(RT5631_MIC_CTRL_2, 12, 9, rt5631_mic_boost),
 321 SOC_ENUM_SINGLE(RT5631_MIC_CTRL_2, 8, 9, rt5631_mic_boost),
 322 SOC_ENUM_SINGLE(RT5631_SPK_MONO_HP_OUT_CTRL, 3, 2, rt5631_hpl_source_sel),
 323 SOC_ENUM_SINGLE(RT5631_SPK_MONO_HP_OUT_CTRL, 2, 2, rt5631_hpr_source_sel),
 324 SOC_ENUM_SINGLE(0, 4, 9, rt5631_eq_sel),
 325 };
 326
 327 static int rt5631_dmic_get(struct snd_kcontrol *kcontrol,
 328                 struct snd_ctl_elem_value *ucontrol)
 329 {
 330         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 331         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 332
 333         ucontrol->value.integer.value[0] = rt5631->dmic_used_flag;
 334
 335         return 0;
 336 }
 337
 338 static void rt5631_close_dmic(struct snd_soc_codec *codec)
 339 {
 340         rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
 341                 DMIC_L_CH_MUTE | DMIC_R_CH_MUTE,
 342                 DMIC_L_CH_MUTE_MASK | DMIC_R_CH_MUTE_MASK);
 343         rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
 344                 DMIC_DIS, DMIC_ENA_MASK);
 345         return;
 346 }
 347
 348 static int rt5631_dmic_put(struct snd_kcontrol *kcontrol,
 349                 struct snd_ctl_elem_value *ucontrol)
 350 {
 351         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 352         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 353
 354         if (rt5631->dmic_used_flag == ucontrol->value.integer.value[0])
 355                 return 0;
 356
 357         if (ucontrol->value.integer.value[0]) {
 358                 rt5631->dmic_used_flag = 1;
 359         } else {
 360                 rt5631_close_dmic(codec);
 361                 rt5631->dmic_used_flag = 0;
 362         }
 363
 364         return 0;
 365 }
 366
 367 static int rt5631_eq_sel_get(struct snd_kcontrol *kcontrol,
 368                 struct snd_ctl_elem_value *ucontrol)
 369 {
 370         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 371         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 372
 373         ucontrol->value.integer.value[0] = rt5631->eq_mode;
 374
 375         return 0;
 376 }
 377
 378 static void rt5631_update_eqmode(struct snd_soc_codec *codec, int mode)
 379 {
 380         int i;
 381
 382         if (NORMAL == mode) {
 383                 /* In Normal mode, the EQ parameter is cleared,
 384                  * and hardware LP, BP1, BP2, BP3, HP1, HP2
 385                  * block control and EQ block are disabled.
 386                  */
 387                 for (i = RT5631_EQ_BW_LOP; i <= RT5631_EQ_HPF_GAIN; i++)
 388                         rt5631_write_index(codec, i,
 389                                 hweq_preset[mode].value[i]);
 390                 rt5631_write_mask(codec, RT5631_EQ_CTRL, 0x0000, 0x003f);
 391                 rt5631_write_index_mask(codec, RT5631_EQ_PRE_VOL_CTRL
 392                                                 , 0x0000, 0x8000);
 393         } else {
 394                 /* Fill and update EQ parameter,
 395                  * and EQ block are enabled.
 396                  */
 397                 rt5631_write_index_mask(codec, RT5631_EQ_PRE_VOL_CTRL
 398                                                 , 0x8000, 0x8000);
 399                 rt5631_write(codec, RT5631_EQ_CTRL,
 400                         hweq_preset[mode].ctrl);
 401                 for (i = RT5631_EQ_BW_LOP; i <= RT5631_EQ_HPF_GAIN; i++)
 402                         rt5631_write_index(codec, i,
 403                                 hweq_preset[mode].value[i]);
 404                 rt5631_write_mask(codec, RT5631_EQ_CTRL, 0x4000, 0x4000);
 405         }
 406
 407         return;
 408 }
 409
 410 static int rt5631_eq_sel_put(struct snd_kcontrol *kcontrol,
 411                 struct snd_ctl_elem_value *ucontrol)
 412 {
 413         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 414         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 415
 416         if (rt5631->eq_mode == ucontrol->value.integer.value[0])
 417                 return 0;
 418
 419         rt5631_update_eqmode(codec, ucontrol->value.enumerated.item[0]);
 420         rt5631->eq_mode = ucontrol->value.integer.value[0];
 421
 422         return 0;
 423 }
 424
 425 #if (RT5631_SPK_TIMER == 1)
 426 static void spk_work_handler(struct work_struct *work)
 427 {
 428         struct snd_soc_codec *codec = rt5631_codec;
 429         bool is_spk = (rt5631_read(codec, 0x4a)) & 0x04;        //detect rt5631 reg4a[3], 1'b:SPK, 0'b:HP ;
 430         if(last_is_spk != is_spk)
 431                 printk("%s---%s is in use.last is %s in use\n", __FUNCTION__,is_spk?"speaker":"headphone",last_is_spk?"speaker":"headphone");
 432
 433         if(is_spk && !last_is_spk){
 434                 rt5631_write_index_mask(codec,0x11,0x0000,0x0007);      //0db
 435                 rt5631_write_index(codec,0x12,0x0003);                  //0db
 436                 rt5631_update_eqmode(codec, SPK_FR);            // SPK is in use, enable EQ mode of SPK_FR.
 437         }else if(!is_spk && last_is_spk){
 438         //flove071311   rt5631_update_eqmode(codec, NORMAL);            // HP is in use, enable EQ mode of NORMAL.
 439                 rt5631_write_index_mask(codec,0x11,0x0001,0x0003);
 440                 rt5631_write_index(codec,0x12,0x0001);
 441                 rt5631_update_eqmode(codec,HFREQ);
 442         }
 443         last_is_spk = is_spk;
 444 }
 445
 446 /* timer to judge SPK or HP in use, and handle EQ issues accordingly. */
 447 void spk_timer_callback(unsigned long data )
 448 {
 449         int ret = 0;
 450
 451         schedule_work(&spk_work);
 452
 453         //DBG("Starting timer to fire in 1000ms (%ld)\n", jiffies );
 454   ret = mod_timer(&spk_timer, jiffies + msecs_to_jiffies(1000));
 455   if (ret) printk("Error in mod_timer\n");
 456 }
 457 #endif
 458
 459 static const struct snd_kcontrol_new rt5631_snd_controls[] = {
 460 SOC_ENUM("MIC1 Mode Control",  rt5631_enum[3]),
 461 SOC_ENUM("MIC1 Boost", rt5631_enum[6]),
 462 SOC_ENUM("MIC2 Mode Control", rt5631_enum[4]),
 463 SOC_ENUM("MIC2 Boost", rt5631_enum[7]),
 464 SOC_ENUM("MONOIN Mode Control", rt5631_enum[5]),
 465 SOC_DOUBLE("PCM Playback Volume", RT5631_STEREO_DAC_VOL_2, 8, 0, 255, 1),
 466 SOC_DOUBLE("PCM Playback Switch", RT5631_STEREO_DAC_VOL_1, 15, 7, 1, 1),
 467 SOC_DOUBLE("MONOIN_RX Capture Volume", RT5631_MONO_INPUT_VOL, 8, 0, 31, 1),
 468 SOC_DOUBLE("AXI Capture Volume", RT5631_AUX_IN_VOL, 8, 0, 31, 1),
 469 SOC_SINGLE("AXO1 Playback Switch", RT5631_MONO_AXO_1_2_VOL, 15, 1, 1),
 470 SOC_SINGLE("AXO2 Playback Switch", RT5631_MONO_AXO_1_2_VOL, 7, 1, 1),
 471 SOC_DOUBLE("OUTVOL Playback Volume", RT5631_MONO_AXO_1_2_VOL, 8, 0, 31, 1),
 472 SOC_DOUBLE("Speaker Playback Switch", RT5631_SPK_OUT_VOL, 15, 7, 1, 1),
 473 SOC_DOUBLE("Speaker Playback Volume", RT5631_SPK_OUT_VOL, 8, 0, 63, 1),
 474 SOC_SINGLE("MONO Playback Switch", RT5631_MONO_AXO_1_2_VOL, 13, 1, 1),
 475 SOC_DOUBLE("HP Playback Switch", RT5631_HP_OUT_VOL, 15, 7, 1, 1),
 476 SOC_DOUBLE("HP Playback Volume", RT5631_HP_OUT_VOL, 8, 0, 63, 1),
 477 SOC_SINGLE_EXT("DMIC Capture Switch", 0, 2, 1, 0,
 478         rt5631_dmic_get, rt5631_dmic_put),
 479 SOC_ENUM_EXT("EQ Mode", rt5631_enum[10], rt5631_eq_sel_get, rt5631_eq_sel_put),
 480 };
 481
 482 static const struct snd_kcontrol_new rt5631_recmixl_mixer_controls[] = {
 483 SOC_DAPM_SINGLE("OUTMIXL Capture Switch", RT5631_ADC_REC_MIXER, 15, 1, 1),
 484 SOC_DAPM_SINGLE("MIC1_BST1 Capture Switch", RT5631_ADC_REC_MIXER, 14, 1, 1),
 485 SOC_DAPM_SINGLE("AXILVOL Capture Switch", RT5631_ADC_REC_MIXER, 13, 1, 1),
 486 SOC_DAPM_SINGLE("MONOIN_RX Capture Switch", RT5631_ADC_REC_MIXER, 12, 1, 1),
 487 };
 488
 489 static const struct snd_kcontrol_new rt5631_recmixr_mixer_controls[] = {
 490 SOC_DAPM_SINGLE("MONOIN_RX Capture Switch", RT5631_ADC_REC_MIXER, 4, 1, 1),
 491 SOC_DAPM_SINGLE("AXIRVOL Capture Switch", RT5631_ADC_REC_MIXER, 5, 1, 1),
 492 SOC_DAPM_SINGLE("MIC2_BST2 Capture Switch", RT5631_ADC_REC_MIXER, 6, 1, 1),
 493 SOC_DAPM_SINGLE("OUTMIXR Capture Switch", RT5631_ADC_REC_MIXER, 7, 1, 1),
 494 };
 495
 496 static const struct snd_kcontrol_new rt5631_spkmixl_mixer_controls[] = {
 497 SOC_DAPM_SINGLE("RECMIXL Playback Switch", RT5631_SPK_MIXER_CTRL, 15, 1, 1),
 498 SOC_DAPM_SINGLE("MIC1_P Playback Switch", RT5631_SPK_MIXER_CTRL, 14, 1, 1),
 499 SOC_DAPM_SINGLE("DACL Playback Switch", RT5631_SPK_MIXER_CTRL, 13, 1, 1),
 500 SOC_DAPM_SINGLE("OUTMIXL Playback Switch", RT5631_SPK_MIXER_CTRL, 12, 1, 1),
 501 };
 502
 503 static const struct snd_kcontrol_new rt5631_spkmixr_mixer_controls[] = {
 504 SOC_DAPM_SINGLE("OUTMIXR Playback Switch", RT5631_SPK_MIXER_CTRL, 4, 1, 1),
 505 SOC_DAPM_SINGLE("DACR Playback Switch", RT5631_SPK_MIXER_CTRL, 5, 1, 1),
 506 SOC_DAPM_SINGLE("MIC2_P Playback Switch", RT5631_SPK_MIXER_CTRL, 6, 1, 1),
 507 SOC_DAPM_SINGLE("RECMIXR Playback Switch", RT5631_SPK_MIXER_CTRL, 7, 1, 1),
 508 };
 509
 510 static const struct snd_kcontrol_new rt5631_outmixl_mixer_controls[] = {
 511 SOC_DAPM_SINGLE("RECMIXL Playback Switch", RT5631_OUTMIXER_L_CTRL, 15, 1, 1),
 512 SOC_DAPM_SINGLE("RECMIXR Playback Switch", RT5631_OUTMIXER_L_CTRL, 14, 1, 1),
 513 SOC_DAPM_SINGLE("DACL Playback Switch", RT5631_OUTMIXER_L_CTRL, 13, 1, 1),
 514 SOC_DAPM_SINGLE("MIC1_BST1 Playback Switch", RT5631_OUTMIXER_L_CTRL, 12, 1, 1),
 515 SOC_DAPM_SINGLE("MIC2_BST2 Playback Switch", RT5631_OUTMIXER_L_CTRL, 11, 1, 1),
 516 SOC_DAPM_SINGLE("MONOIN_RXP Playback Switch", RT5631_OUTMIXER_L_CTRL, 10, 1, 1),
 517 SOC_DAPM_SINGLE("AXILVOL Playback Switch", RT5631_OUTMIXER_L_CTRL, 9, 1, 1),
 518 SOC_DAPM_SINGLE("AXIRVOL Playback Switch", RT5631_OUTMIXER_L_CTRL, 8, 1, 1),
 519 SOC_DAPM_SINGLE("VDAC Playback Switch", RT5631_OUTMIXER_L_CTRL, 7, 1, 1),
 520 };
 521
 522 static const struct snd_kcontrol_new rt5631_outmixr_mixer_controls[] = {
 523 SOC_DAPM_SINGLE("VDAC Playback Switch", RT5631_OUTMIXER_R_CTRL, 7, 1, 1),
 524 SOC_DAPM_SINGLE("AXIRVOL Playback Switch", RT5631_OUTMIXER_R_CTRL, 8, 1, 1),
 525 SOC_DAPM_SINGLE("AXILVOL Playback Switch", RT5631_OUTMIXER_R_CTRL, 9, 1, 1),
 526 SOC_DAPM_SINGLE("MONOIN_RXN Playback Switch", RT5631_OUTMIXER_R_CTRL, 10, 1, 1),
 527 SOC_DAPM_SINGLE("MIC2_BST2 Playback Switch", RT5631_OUTMIXER_R_CTRL, 11, 1, 1),
 528 SOC_DAPM_SINGLE("MIC1_BST1 Playback Switch", RT5631_OUTMIXER_R_CTRL, 12, 1, 1),
 529 SOC_DAPM_SINGLE("DACR Playback Switch", RT5631_OUTMIXER_R_CTRL, 13, 1, 1),
 530 SOC_DAPM_SINGLE("RECMIXR Playback Switch", RT5631_OUTMIXER_R_CTRL, 14, 1, 1),
 531 SOC_DAPM_SINGLE("RECMIXL Playback Switch", RT5631_OUTMIXER_R_CTRL, 15, 1, 1),
 532 };
 533
 534 static const struct snd_kcontrol_new rt5631_AXO1MIX_mixer_controls[] = {
 535 SOC_DAPM_SINGLE("MIC1_BST1 Playback Switch", RT5631_AXO1MIXER_CTRL, 15 , 1, 1),
 536 SOC_DAPM_SINGLE("MIC2_BST2 Playback Switch", RT5631_AXO1MIXER_CTRL, 11, 1, 1),
 537 SOC_DAPM_SINGLE("OUTVOLL Playback Switch", RT5631_AXO1MIXER_CTRL, 7 , 1 , 1),
 538 SOC_DAPM_SINGLE("OUTVOLR Playback Switch", RT5631_AXO1MIXER_CTRL, 6, 1, 1),
 539 };
 540
 541 static const struct snd_kcontrol_new rt5631_AXO2MIX_mixer_controls[] = {
 542 SOC_DAPM_SINGLE("MIC1_BST1 Playback Switch", RT5631_AXO2MIXER_CTRL, 15, 1, 1),
 543 SOC_DAPM_SINGLE("MIC2_BST2 Playback Switch", RT5631_AXO2MIXER_CTRL, 11, 1, 1),
 544 SOC_DAPM_SINGLE("OUTVOLL Playback Switch", RT5631_AXO2MIXER_CTRL, 7, 1, 1),
 545 SOC_DAPM_SINGLE("OUTVOLR Playback Switch", RT5631_AXO2MIXER_CTRL, 6, 1 , 1),
 546 };
 547
 548 static const struct snd_kcontrol_new rt5631_spolmix_mixer_controls[] = {
 549 SOC_DAPM_SINGLE("SPKVOLL Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 15, 1, 1),
 550 SOC_DAPM_SINGLE("SPKVOLR Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 14, 1, 1),
 551 };
 552
 553 static const struct snd_kcontrol_new rt5631_spormix_mixer_controls[] = {
 554 SOC_DAPM_SINGLE("SPKVOLL Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 13, 1, 1),
 555 SOC_DAPM_SINGLE("SPKVOLR Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 12, 1, 1),
 556 };
 557
 558 static const struct snd_kcontrol_new rt5631_monomix_mixer_controls[] = {
 559 SOC_DAPM_SINGLE("OUTVOLL Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 11, 1, 1),
 560 SOC_DAPM_SINGLE("OUTVOLR Playback Switch", RT5631_SPK_MONO_OUT_CTRL, 10, 1, 1),
 561 };
 562
 563 static const struct snd_kcontrol_new rt5631_spol_mux_control =
 564 SOC_DAPM_ENUM("Route", rt5631_enum[0]);
 565 static const struct snd_kcontrol_new rt5631_spor_mux_control =
 566 SOC_DAPM_ENUM("Route", rt5631_enum[1]);
 567 static const struct snd_kcontrol_new rt5631_mono_mux_control =
 568 SOC_DAPM_ENUM("Route", rt5631_enum[2]);
 569
 570 static const struct snd_kcontrol_new rt5631_hpl_mux_control =
 571 SOC_DAPM_ENUM("Route", rt5631_enum[8]);
 572 static const struct snd_kcontrol_new rt5631_hpr_mux_control =
 573 SOC_DAPM_ENUM("Route", rt5631_enum[9]);
 574
 575 //ALC for DAC function
 576 #if (RT5631_ALC_DAC_FUNC_ENA == 1)
 577 static void rt5631_alc_enable(struct snd_soc_codec *codec,unsigned int EnableALC)
 578 {
 579         if(EnableALC)
 580         {
 581                 rt5631_write(codec, 0x64,0x0206);
 582                 rt5631_write(codec, 0x65,0x0003);
 583                 rt5631_write_index(codec, 0x21,0x5000);
 584                 rt5631_write_index(codec, 0x22,0xa480);
 585                 rt5631_write_index(codec, 0x23,0x0a08);
 586                 rt5631_write(codec, 0x0c,0x0010);
 587                 rt5631_write(codec, 0x66,0x650a);
 588
 589         }
 590         else
 591         {
 592                 rt5631_write(codec, 0x66,0x250A);
 593                 rt5631_write(codec, 0x0c,0x0000);
 594         }
 595
 596 }
 597 #endif
 598
 599 static int spk_event(struct snd_soc_dapm_widget *w,
 600         struct snd_kcontrol *kcontrol, int event)
 601 {
 602         struct snd_soc_codec *codec = w->codec;
 603         static int spkl_out_enable, spkr_out_enable;
 604
 605         switch (event) {
 606         case SND_SOC_DAPM_POST_PMU:
 607
 608 #if (RT5631_ALC_DAC_FUNC_ENA == 1)
 609                rt5631_alc_enable(codec, 1);
 610 #endif
 611
 612                 if (!spkl_out_enable && !strcmp(w->name, "SPKL Amp")) {
 613                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD4,
 614                                         PWR_SPK_L_VOL, PWR_SPK_L_VOL);
 615                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
 616                                         PWR_CLASS_D, PWR_CLASS_D);
 617                         rt5631_write_mask(codec, RT5631_SPK_OUT_VOL,
 618                                         0, RT_L_MUTE);
 619                         spkl_out_enable = 1;
 620                 }
 621                 if (!spkr_out_enable && !strcmp(w->name, "SPKR Amp")) {
 622                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD4,
 623                                         PWR_SPK_R_VOL, PWR_SPK_R_VOL);
 624                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
 625                                         PWR_CLASS_D, PWR_CLASS_D);
 626                         rt5631_write_mask(codec, RT5631_SPK_OUT_VOL,
 627                                         0, RT_R_MUTE);
 628                         spkr_out_enable = 1;
 629                 }
 630                 break;
 631
 632         case SND_SOC_DAPM_POST_PMD:
 633                 if (spkl_out_enable && !strcmp(w->name, "SPKL Amp")) {
 634                         rt5631_write_mask(codec, RT5631_SPK_OUT_VOL,
 635                                         RT_L_MUTE, RT_L_MUTE);
 636                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD4,
 637                                         0, PWR_SPK_L_VOL);
 638                         spkl_out_enable = 0;
 639                 }
 640                 if (spkr_out_enable && !strcmp(w->name, "SPKR Amp")) {
 641                         rt5631_write_mask(codec, RT5631_SPK_OUT_VOL,
 642                                         RT_R_MUTE, RT_R_MUTE);
 643                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD4,
 644                                         0, PWR_SPK_R_VOL);
 645                         spkr_out_enable = 0;
 646                 }
 647                 if (0 == spkl_out_enable && 0 == spkr_out_enable)
 648                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
 649                                         0, PWR_CLASS_D);
 650
 651 #if (RT5631_ALC_DAC_FUNC_ENA == 1)
 652                 rt5631_alc_enable(codec, 0);
 653 #endif
 654
 655                 break;
 656
 657         default:
 658                 return 0;
 659         }
 660
 661         return 0;
 662 }
 663
 664
 665 static void hp_depop_mode2_onebit(struct snd_soc_codec *codec, int enable)
 666 {
 667         unsigned int soft_vol, hp_zc;
 668
 669         rt5631_write_mask(codec, RT5631_DEPOP_FUN_CTRL_2, 0, EN_ONE_BIT_DEPOP);
 670
 671         soft_vol = rt5631_read(codec, RT5631_SOFT_VOL_CTRL);
 672         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, 0);
 673         hp_zc = rt5631_read(codec, RT5631_INT_ST_IRQ_CTRL_2);
 674         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc & 0xf7ff);
 675         if (enable) {
 676                 rt5631_write_index(codec, RT5631_TEST_MODE_CTRL, 0x84c0);
 677                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x309f);
 678                 rt5631_write_index(codec, RT5631_CP_INTL_REG2, 0x6530);
 679                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_2,
 680                                 EN_CAP_FREE_DEPOP);
 681         } else {
 682                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_2, 0);
 683                 schedule_timeout_uninterruptible(msecs_to_jiffies(100));
 684         }
 685
 686         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, soft_vol);
 687         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc);
 688
 689         return;
 690 }
 691
 692 static void hp_mute_unmute_depop_onebit(struct snd_soc_codec *codec, int enable)
 693 {
 694         unsigned int soft_vol, hp_zc;
 695
 696         rt5631_write_mask(codec, RT5631_DEPOP_FUN_CTRL_2, 0, EN_ONE_BIT_DEPOP);
 697         soft_vol = rt5631_read(codec, RT5631_SOFT_VOL_CTRL);
 698         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, 0);
 699         hp_zc = rt5631_read(codec, RT5631_INT_ST_IRQ_CTRL_2);
 700         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc & 0xf7ff);
 701         if (enable) {
 702                 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
 703                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x307f);
 704                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL, 0,
 705                                 RT_L_MUTE | RT_R_MUTE);
 706                 schedule_timeout_uninterruptible(msecs_to_jiffies(300));
 707
 708         } else {
 709                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL,
 710                         RT_L_MUTE | RT_R_MUTE, RT_L_MUTE | RT_R_MUTE);
 711                 schedule_timeout_uninterruptible(msecs_to_jiffies(100));
 712         }
 713         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, soft_vol);
 714         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc);
 715
 716         return;
 717 }
 718
 719 static void hp_depop2(struct snd_soc_codec *codec, int enable)
 720 {
 721         unsigned int soft_vol, hp_zc;
 722
 723         rt5631_write_mask(codec, RT5631_DEPOP_FUN_CTRL_2,
 724                 EN_ONE_BIT_DEPOP, EN_ONE_BIT_DEPOP);
 725         soft_vol = rt5631_read(codec, RT5631_SOFT_VOL_CTRL);
 726         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, 0);
 727         hp_zc = rt5631_read(codec, RT5631_INT_ST_IRQ_CTRL_2);
 728         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc & 0xf7ff);
 729         if (enable) {
 730                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x303e);
 731                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
 732                         PWR_CHARGE_PUMP | PWR_HP_L_AMP | PWR_HP_R_AMP,
 733                         PWR_CHARGE_PUMP | PWR_HP_L_AMP | PWR_HP_R_AMP);
 734                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 735                         POW_ON_SOFT_GEN | EN_DEPOP2_FOR_HP);
 736                 schedule_timeout_uninterruptible(msecs_to_jiffies(100));
 737                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
 738                         PWR_HP_DEPOP_DIS, PWR_HP_DEPOP_DIS);
 739         } else {
 740                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x303F);
 741                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 742                         POW_ON_SOFT_GEN | EN_MUTE_UNMUTE_DEPOP |
 743                         PD_HPAMP_L_ST_UP | PD_HPAMP_R_ST_UP);
 744                 schedule_timeout_uninterruptible(msecs_to_jiffies(75));
 745                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 746                         POW_ON_SOFT_GEN | PD_HPAMP_L_ST_UP | PD_HPAMP_R_ST_UP);
 747                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3, 0,
 748                                         PWR_HP_DEPOP_DIS);
 749                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 750                         POW_ON_SOFT_GEN | EN_DEPOP2_FOR_HP |
 751                         PD_HPAMP_L_ST_UP | PD_HPAMP_R_ST_UP);
 752                 schedule_timeout_uninterruptible(msecs_to_jiffies(80));
 753                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1, POW_ON_SOFT_GEN);
 754                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3, 0,
 755                         PWR_CHARGE_PUMP | PWR_HP_L_AMP | PWR_HP_R_AMP);
 756         }
 757
 758         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, soft_vol);
 759         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc);
 760
 761         return;
 762 }
 763
 764 static void hp_mute_unmute_depop(struct snd_soc_codec *codec, int enable)
 765 {
 766         unsigned int soft_vol, hp_zc;
 767
 768         rt5631_write_mask(codec, RT5631_DEPOP_FUN_CTRL_2,
 769                 EN_ONE_BIT_DEPOP, EN_ONE_BIT_DEPOP);
 770         soft_vol = rt5631_read(codec, RT5631_SOFT_VOL_CTRL);
 771         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, 0);
 772         hp_zc = rt5631_read(codec, RT5631_INT_ST_IRQ_CTRL_2);
 773         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc & 0xf7ff);
 774         if (enable) {
 775                 schedule_timeout_uninterruptible(msecs_to_jiffies(10));
 776                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x302f);
 777                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 778                         POW_ON_SOFT_GEN | EN_MUTE_UNMUTE_DEPOP |
 779                         EN_HP_R_M_UN_MUTE_DEPOP | EN_HP_L_M_UN_MUTE_DEPOP);
 780                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL, 0,
 781                                 RT_L_MUTE | RT_R_MUTE);
 782                 schedule_timeout_uninterruptible(msecs_to_jiffies(160));
 783         } else {
 784                 rt5631_write_index(codec, RT5631_SPK_INTL_CTRL, 0x302f);
 785                 rt5631_write(codec, RT5631_DEPOP_FUN_CTRL_1,
 786                         POW_ON_SOFT_GEN | EN_MUTE_UNMUTE_DEPOP |
 787                         EN_HP_R_M_UN_MUTE_DEPOP | EN_HP_L_M_UN_MUTE_DEPOP);
 788                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL,
 789                         RT_L_MUTE | RT_R_MUTE, RT_L_MUTE | RT_R_MUTE);
 790                 schedule_timeout_uninterruptible(msecs_to_jiffies(150));
 791         }
 792
 793         rt5631_write(codec, RT5631_SOFT_VOL_CTRL, soft_vol);
 794         rt5631_write(codec, RT5631_INT_ST_IRQ_CTRL_2, hp_zc);
 795
 796         return;
 797 }
 798
 799 static int hp_event(struct snd_soc_dapm_widget *w,
 800         struct snd_kcontrol *kcontrol, int event)
 801 {
 802         struct snd_soc_codec *codec = w->codec;
 803         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 804         static bool hp_en;
 805         int pu_l, pu_r;
 806
 807         pu_l = rt5631_read(codec, RT5631_PWR_MANAG_ADD4) & PWR_HP_L_OUT_VOL;
 808         pu_r = rt5631_read(codec, RT5631_PWR_MANAG_ADD4) & PWR_HP_R_OUT_VOL;
 809         switch (event) {
 810         case SND_SOC_DAPM_PRE_PMD:
 811                 if ((pu_l && pu_r) && hp_en) {
 812                         if (rt5631->codec_version) {
 813                                 hp_mute_unmute_depop_onebit(codec, 0);
 814                                 hp_depop_mode2_onebit(codec, 0);
 815                         } else {
 816                                 hp_mute_unmute_depop(codec, 0);
 817                                 hp_depop2(codec, 0);
 818                         }
 819                         hp_en = false;
 820                 }
 821                 break;
 822
 823         case SND_SOC_DAPM_POST_PMU:
 824                 if ((pu_l && pu_r) && !hp_en) {
 825                         if (rt5631->codec_version) {
 826                                 hp_depop_mode2_onebit(codec, 1);
 827                                 hp_mute_unmute_depop_onebit(codec, 1);
 828                         } else {
 829                                 hp_depop2(codec, 1);
 830                                 hp_mute_unmute_depop(codec, 1);
 831                         }
 832                         hp_en = true;
 833                 }
 834                 break;
 835
 836         default:
 837                 break;
 838         }
 839
 840         return 0;
 841 }
 842
 843 static int dac_to_hp_event(struct snd_soc_dapm_widget *w,
 844                 struct snd_kcontrol *kcontrol, int event)
 845 {
 846         struct snd_soc_codec *codec = w->codec;
 847         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
 848         static bool hp_en;
 849
 850         switch (event) {
 851         case SND_SOC_DAPM_PRE_PMD:
 852                 if (hp_en) {
 853                         if (rt5631->codec_version) {
 854                                 hp_mute_unmute_depop_onebit(codec, 0);
 855                                 hp_depop_mode2_onebit(codec, 0);
 856                         } else {
 857                                 hp_mute_unmute_depop(codec, 0);
 858                                 hp_depop2(codec, 0);
 859                         }
 860                         hp_en = false;
 861                 }
 862                 break;
 863
 864         case SND_SOC_DAPM_POST_PMU:
 865                 if (!hp_en) {
 866                         if (rt5631->codec_version) {
 867                                 hp_depop_mode2_onebit(codec, 1);
 868                                 hp_mute_unmute_depop_onebit(codec, 1);
 869                         } else {
 870                                 hp_depop2(codec, 1);
 871                                 hp_mute_unmute_depop(codec, 1);
 872                         }
 873                         hp_en = true;
 874                 }
 875                 break;
 876
 877         default:
 878                 break;
 879         }
 880
 881         return 0;
 882 }
 883
 884 static int mic_event(struct snd_soc_dapm_widget *w,
 885         struct snd_kcontrol *kcontrol, int event)
 886 {
 887         struct snd_soc_codec *codec = w->codec;
 888         int val_mic1, val_mic2;
 889
 890         val_mic1 = rt5631_read(codec, RT5631_PWR_MANAG_ADD2) &
 891                                 PWR_MIC1_BOOT_GAIN;
 892         val_mic2 = rt5631_read(codec, RT5631_PWR_MANAG_ADD2) &
 893                                 PWR_MIC2_BOOT_GAIN;
 894         switch (event) {
 895         case SND_SOC_DAPM_POST_PMU:
 896                 /*
 897                  * If microphone is stereo, need not copy ADC channel
 898                  * If mic1 is used, copy ADC left to right
 899                  * If mic2 is used, copy ADC right to left
 900                  */
 901                 if (val_mic1 && val_mic2)
 902                         rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
 903                                                         0x0000, 0xc000);
 904                 else if (val_mic1)
 905                         rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
 906                                                         0x4000, 0xc000);
 907                 else if (val_mic2)
 908                         rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
 909                                                         0x8000, 0xc000);
 910                 else
 911                         rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
 912                                                         0x0000, 0xc000);
 913                 break;
 914
 915         default:
 916                 break;
 917         }
 918
 919         return 0;
 920 }
 921
 922 static int auxo1_event(struct snd_soc_dapm_widget *w,
 923         struct snd_kcontrol *kcontrol, int event)
 924 {
 925         struct snd_soc_codec *codec = w->codec;
 926         static bool aux1_en;
 927
 928         switch (event) {
 929         case SND_SOC_DAPM_PRE_PMD:
 930                 if (aux1_en) {
 931                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
 932                                                 RT_L_MUTE, RT_L_MUTE);
 933                         aux1_en = false;
 934                 }
 935                 break;
 936
 937         case SND_SOC_DAPM_POST_PMU:
 938                 if (!aux1_en) {
 939                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
 940                                                 0, RT_L_MUTE);
 941                         aux1_en = true;
 942                 }
 943                 break;
 944
 945         default:
 946                 break;
 947         }
 948
 949         return 0;
 950 }
 951
 952 static int auxo2_event(struct snd_soc_dapm_widget *w,
 953         struct snd_kcontrol *kcontrol, int event)
 954 {
 955         struct snd_soc_codec *codec = w->codec;
 956         static bool aux2_en;
 957
 958         switch (event) {
 959         case SND_SOC_DAPM_PRE_PMD:
 960                 if (aux2_en) {
 961                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
 962                                                 RT_R_MUTE, RT_R_MUTE);
 963                         aux2_en = false;
 964                 }
 965                 break;
 966
 967         case SND_SOC_DAPM_POST_PMU:
 968                 if (!aux2_en) {
 969                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
 970                                                 0, RT_R_MUTE);
 971                         aux2_en = true;
 972                 }
 973                 break;
 974
 975         default:
 976                 break;
 977         }
 978
 979         return 0;
 980 }
 981
 982 static int mono_event(struct snd_soc_dapm_widget *w,
 983         struct snd_kcontrol *kcontrol, int event)
 984 {
 985         struct snd_soc_codec *codec = w->codec;
 986         static bool mono_en;
 987
 988         switch (event) {
 989         case SND_SOC_DAPM_PRE_PMD:
 990                 if (mono_en) {
 991                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
 992                                                 MUTE_MONO, MUTE_MONO);
 993                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
 994                                                 0, PWR_MONO_DEPOP_DIS);
 995                         mono_en = false;
 996                 }
 997                 break;
 998
 999         case SND_SOC_DAPM_POST_PMU:
1000                 if (!mono_en) {
1001                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
1002                                 PWR_MONO_DEPOP_DIS, PWR_MONO_DEPOP_DIS);
1003                         rt5631_write_mask(codec, RT5631_MONO_AXO_1_2_VOL,
1004                                                 0, MUTE_MONO);
1005                         mono_en = true;
1006                 }
1007                 break;
1008
1009         default:
1010                 break;
1011         }
1012
1013         return 0;
1014 }
1015
1016 /**
1017  * config_common_power - control all common power of codec system
1018  * @pmu: power up or not
1019  */
1020 static int config_common_power(struct snd_soc_codec *codec, bool pmu)
1021 {
1022         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1023         unsigned int mux_val;
1024
1025         if (pmu) {
1026                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
1027                         PWR_MAIN_I2S_EN | PWR_DAC_REF,
1028                         PWR_MAIN_I2S_EN | PWR_DAC_REF);
1029                 mux_val = rt5631_read(codec, RT5631_SPK_MONO_HP_OUT_CTRL);
1030                 //if (!(mux_val & HP_L_MUX_SEL_DAC_L))
1031                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
1032                                 PWR_DAC_L_TO_MIXER, PWR_DAC_L_TO_MIXER);
1033                 //if (!(mux_val & HP_R_MUX_SEL_DAC_R))
1034                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1,
1035                                 PWR_DAC_R_TO_MIXER, PWR_DAC_R_TO_MIXER);
1036                 if (rt5631->pll_used_flag)
1037                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD2,
1038                                                 PWR_PLL, PWR_PLL);
1039         } else if (isPlaybackon == false && isCaptureon == false){
1040                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD1, 0,
1041                         PWR_MAIN_I2S_EN | PWR_DAC_REF |
1042                         PWR_DAC_L_TO_MIXER | PWR_DAC_R_TO_MIXER);
1043                 if (rt5631->pll_used_flag)
1044                         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD2,
1045                                                 0, PWR_PLL);
1046         }
1047
1048         return 0;
1049 }
1050
1051 static int adc_event(struct snd_soc_dapm_widget *w,
1052         struct snd_kcontrol *kcontrol, int event)
1053 {
1054         struct snd_soc_codec *codec = w->codec;
1055         static bool pmu;
1056
1057         switch (event) {
1058         case SND_SOC_DAPM_POST_PMD:
1059                 if (pmu) {
1060                         isPlaybackon = false;
1061                         config_common_power(codec, false);
1062                         pmu = false;
1063                 }
1064                 break;
1065
1066         case SND_SOC_DAPM_PRE_PMU:
1067                 if (!pmu) {
1068                         isPlaybackon = true;
1069                         config_common_power(codec, true);
1070                         pmu = true;
1071                 }
1072                 break;
1073
1074         default:
1075                 break;
1076         }
1077
1078         return 0;
1079 }
1080
1081 static int dac_event(struct snd_soc_dapm_widget *w,
1082         struct snd_kcontrol *kcontrol, int event)
1083 {
1084         struct snd_soc_codec *codec = w->codec;
1085         static bool pmu;
1086
1087         switch (event) {
1088         case SND_SOC_DAPM_POST_PMD:
1089                 if (pmu) {
1090                         isCaptureon = false;
1091                         config_common_power(codec, false);
1092                         pmu = false;
1093                 }
1094                 break;
1095
1096         case SND_SOC_DAPM_PRE_PMU:
1097                 if (!pmu) {
1098                         isCaptureon = true;
1099                         config_common_power(codec, true);
1100                         pmu = true;
1101                 }
1102                 break;
1103
1104         default:
1105                 break;
1106         }
1107
1108         return 0;
1109 }
1110
1111 static const struct snd_soc_dapm_widget rt5631_dapm_widgets[] = {
1112 SND_SOC_DAPM_INPUT("MIC1"),
1113 SND_SOC_DAPM_INPUT("MIC2"),
1114 SND_SOC_DAPM_INPUT("AXIL"),
1115 SND_SOC_DAPM_INPUT("AXIR"),
1116 SND_SOC_DAPM_INPUT("MONOIN_RXN"),
1117 SND_SOC_DAPM_INPUT("MONOIN_RXP"),
1118
1119 SND_SOC_DAPM_MICBIAS("Mic Bias1", RT5631_PWR_MANAG_ADD2, 3, 0),
1120 SND_SOC_DAPM_MICBIAS("Mic Bias2", RT5631_PWR_MANAG_ADD2, 2, 0),
1121
1122 SND_SOC_DAPM_PGA_E("Mic1 Boost", RT5631_PWR_MANAG_ADD2, 5, 0, NULL, 0,
1123                 mic_event, SND_SOC_DAPM_POST_PMU),
1124 SND_SOC_DAPM_PGA_E("Mic2 Boost", RT5631_PWR_MANAG_ADD2, 4, 0, NULL, 0,
1125                 mic_event, SND_SOC_DAPM_POST_PMU),
1126 SND_SOC_DAPM_PGA("MONOIN_RXP Boost", RT5631_PWR_MANAG_ADD4, 7, 0, NULL, 0),
1127 SND_SOC_DAPM_PGA("MONOIN_RXN Boost", RT5631_PWR_MANAG_ADD4, 6, 0, NULL, 0),
1128 SND_SOC_DAPM_PGA("AXIL Boost", RT5631_PWR_MANAG_ADD4, 9, 0, NULL, 0),
1129 SND_SOC_DAPM_PGA("AXIR Boost", RT5631_PWR_MANAG_ADD4, 8, 0, NULL, 0),
1130 SND_SOC_DAPM_MIXER("MONO_IN", SND_SOC_NOPM, 0, 0, NULL, 0),
1131
1132 SND_SOC_DAPM_MIXER("RECMIXL Mixer", RT5631_PWR_MANAG_ADD2, 11, 0,
1133                 &rt5631_recmixl_mixer_controls[0],
1134                 ARRAY_SIZE(rt5631_recmixl_mixer_controls)),
1135 SND_SOC_DAPM_MIXER("RECMIXR Mixer", RT5631_PWR_MANAG_ADD2, 10, 0,
1136                 &rt5631_recmixr_mixer_controls[0],
1137                 ARRAY_SIZE(rt5631_recmixr_mixer_controls)),
1138 SND_SOC_DAPM_MIXER("ADC Mixer", SND_SOC_NOPM, 0, 0, NULL, 0),
1139
1140 SND_SOC_DAPM_ADC_E("Left ADC", "Left ADC HIFI Capture",
1141                 RT5631_PWR_MANAG_ADD1, 11, 0,
1142                 adc_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_PRE_PMU),
1143 SND_SOC_DAPM_ADC_E("Right ADC", "Right ADC HIFI Capture",
1144                 RT5631_PWR_MANAG_ADD1, 10, 0,
1145                 adc_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_PRE_PMU),
1146 SND_SOC_DAPM_DAC_E("Left DAC", "Left DAC HIFI Playback",
1147                 RT5631_PWR_MANAG_ADD1, 9, 0,
1148                 dac_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_PRE_PMU),
1149 SND_SOC_DAPM_DAC_E("Right DAC", "Right DAC HIFI Playback",
1150                 RT5631_PWR_MANAG_ADD1, 8, 0,
1151                 dac_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_PRE_PMU),
1152 SND_SOC_DAPM_DAC("Voice DAC", "Voice DAC Mono Playback", SND_SOC_NOPM, 0, 0),
1153 SND_SOC_DAPM_PGA("Voice DAC Boost", SND_SOC_NOPM, 0, 0, NULL, 0),
1154
1155 SND_SOC_DAPM_MIXER("SPKMIXL Mixer", RT5631_PWR_MANAG_ADD2, 13, 0,
1156                 &rt5631_spkmixl_mixer_controls[0],
1157                 ARRAY_SIZE(rt5631_spkmixl_mixer_controls)),
1158 SND_SOC_DAPM_MIXER("OUTMIXL Mixer", RT5631_PWR_MANAG_ADD2, 15, 0,
1159                 &rt5631_outmixl_mixer_controls[0],
1160                 ARRAY_SIZE(rt5631_outmixl_mixer_controls)),
1161 SND_SOC_DAPM_MIXER("OUTMIXR Mixer", RT5631_PWR_MANAG_ADD2, 14, 0,
1162                 &rt5631_outmixr_mixer_controls[0],
1163                 ARRAY_SIZE(rt5631_outmixr_mixer_controls)),
1164 SND_SOC_DAPM_MIXER("SPKMIXR Mixer", RT5631_PWR_MANAG_ADD2, 12, 0,
1165                 &rt5631_spkmixr_mixer_controls[0],
1166                 ARRAY_SIZE(rt5631_spkmixr_mixer_controls)),
1167
1168 SND_SOC_DAPM_PGA("Left SPK Vol", RT5631_PWR_MANAG_ADD4, 15, 0, NULL, 0),
1169 SND_SOC_DAPM_PGA("Right SPK Vol", RT5631_PWR_MANAG_ADD4, 14, 0, NULL, 0),
1170 SND_SOC_DAPM_PGA_E("Left HP Vol", RT5631_PWR_MANAG_ADD4, 11, 0, NULL, 0,
1171                 hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1172 SND_SOC_DAPM_PGA_E("Right HP Vol", RT5631_PWR_MANAG_ADD4, 10, 0, NULL, 0,
1173                 hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1174
1175 SND_SOC_DAPM_PGA_E("Left DAC_HP", SND_SOC_NOPM, 0, 0, NULL, 0,
1176         dac_to_hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1177 SND_SOC_DAPM_PGA_E("Right DAC_HP", SND_SOC_NOPM, 0, 0, NULL, 0,
1178         dac_to_hp_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1179
1180 SND_SOC_DAPM_PGA("Left Out Vol", RT5631_PWR_MANAG_ADD4, 13, 0, NULL, 0),
1181 SND_SOC_DAPM_PGA("Right Out Vol", RT5631_PWR_MANAG_ADD4, 12, 0, NULL, 0),
1182
1183 SND_SOC_DAPM_MIXER_E("AXO1MIX Mixer", RT5631_PWR_MANAG_ADD3, 11, 0,
1184                 &rt5631_AXO1MIX_mixer_controls[0],
1185                 ARRAY_SIZE(rt5631_AXO1MIX_mixer_controls),
1186                 auxo1_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1187 SND_SOC_DAPM_MIXER("SPOLMIX Mixer", SND_SOC_NOPM, 0, 0,
1188                 &rt5631_spolmix_mixer_controls[0],
1189                 ARRAY_SIZE(rt5631_spolmix_mixer_controls)),
1190 SND_SOC_DAPM_MIXER("MONOMIX Mixer", RT5631_PWR_MANAG_ADD3, 9, 0,
1191                 &rt5631_monomix_mixer_controls[0],
1192                 ARRAY_SIZE(rt5631_monomix_mixer_controls)),
1193 SND_SOC_DAPM_MIXER("SPORMIX Mixer", SND_SOC_NOPM, 0, 0,
1194                 &rt5631_spormix_mixer_controls[0],
1195                 ARRAY_SIZE(rt5631_spormix_mixer_controls)),
1196 SND_SOC_DAPM_MIXER_E("AXO2MIX Mixer", RT5631_PWR_MANAG_ADD3, 10, 0,
1197                 &rt5631_AXO2MIX_mixer_controls[0],
1198                 ARRAY_SIZE(rt5631_AXO2MIX_mixer_controls),
1199                 auxo2_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1200
1201 SND_SOC_DAPM_MUX("SPOL Mux", SND_SOC_NOPM, 0, 0, &rt5631_spol_mux_control),
1202 SND_SOC_DAPM_MUX("SPOR Mux", SND_SOC_NOPM, 0, 0, &rt5631_spor_mux_control),
1203 SND_SOC_DAPM_MUX("Mono Mux", SND_SOC_NOPM, 0, 0, &rt5631_mono_mux_control),
1204 SND_SOC_DAPM_MUX("HPL Mux", SND_SOC_NOPM, 0, 0, &rt5631_hpl_mux_control),
1205 SND_SOC_DAPM_MUX("HPR Mux", SND_SOC_NOPM, 0, 0, &rt5631_hpr_mux_control),
1206
1207 SND_SOC_DAPM_PGA_E("Mono Amp", RT5631_PWR_MANAG_ADD3, 7, 0, NULL, 0,
1208                 mono_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
1209 SND_SOC_DAPM_PGA_E("SPKL Amp", SND_SOC_NOPM, 0, 0, NULL, 0,
1210                 spk_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
1211 SND_SOC_DAPM_PGA_E("SPKR Amp", SND_SOC_NOPM, 1, 0, NULL, 0,
1212                 spk_event, SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
1213
1214 SND_SOC_DAPM_OUTPUT("AUXO1"),
1215 SND_SOC_DAPM_OUTPUT("AUXO2"),
1216 SND_SOC_DAPM_OUTPUT("SPOL"),
1217 SND_SOC_DAPM_OUTPUT("SPOR"),
1218 SND_SOC_DAPM_OUTPUT("HPOL"),
1219 SND_SOC_DAPM_OUTPUT("HPOR"),
1220 SND_SOC_DAPM_OUTPUT("MONO"),
1221 };
1222
1223
1224 static const struct snd_soc_dapm_route audio_map[] = {
1225         {"Mic1 Boost", NULL, "MIC1"},
1226         {"Mic2 Boost", NULL, "MIC2"},
1227         {"MONOIN_RXP Boost", NULL, "MONOIN_RXP"},
1228         {"MONOIN_RXN Boost", NULL, "MONOIN_RXN"},
1229         {"AXIL Boost", NULL, "AXIL"},
1230         {"AXIR Boost", NULL, "AXIR"},
1231
1232         {"MONO_IN", NULL, "MONOIN_RXP Boost"},
1233         {"MONO_IN", NULL, "MONOIN_RXN Boost"},
1234
1235         {"RECMIXL Mixer", "OUTMIXL Capture Switch", "OUTMIXL Mixer"},
1236         {"RECMIXL Mixer", "MIC1_BST1 Capture Switch", "Mic1 Boost"},
1237         {"RECMIXL Mixer", "AXILVOL Capture Switch", "AXIL Boost"},
1238         {"RECMIXL Mixer", "MONOIN_RX Capture Switch", "MONO_IN"},
1239
1240         {"RECMIXR Mixer", "OUTMIXR Capture Switch", "OUTMIXR Mixer"},
1241         {"RECMIXR Mixer", "MIC2_BST2 Capture Switch", "Mic2 Boost"},
1242         {"RECMIXR Mixer", "AXIRVOL Capture Switch", "AXIR Boost"},
1243         {"RECMIXR Mixer", "MONOIN_RX Capture Switch", "MONO_IN"},
1244
1245         {"ADC Mixer", NULL, "RECMIXL Mixer"},
1246         {"ADC Mixer", NULL, "RECMIXR Mixer"},
1247         {"Left ADC", NULL, "ADC Mixer"},
1248         {"Right ADC", NULL, "ADC Mixer"},
1249
1250         {"Voice DAC Boost", NULL, "Voice DAC"},
1251
1252         {"SPKMIXL Mixer", "RECMIXL Playback Switch", "RECMIXL Mixer"},
1253         {"SPKMIXL Mixer", "MIC1_P Playback Switch", "MIC1"},
1254         {"SPKMIXL Mixer", "DACL Playback Switch", "Left DAC"},
1255         {"SPKMIXL Mixer", "OUTMIXL Playback Switch", "OUTMIXL Mixer"},
1256
1257         {"SPKMIXR Mixer", "OUTMIXR Playback Switch", "OUTMIXR Mixer"},
1258         {"SPKMIXR Mixer", "DACR Playback Switch", "Right DAC"},
1259         {"SPKMIXR Mixer", "MIC2_P Playback Switch", "MIC2"},
1260         {"SPKMIXR Mixer", "RECMIXR Playback Switch", "RECMIXR Mixer"},
1261
1262         {"OUTMIXL Mixer", "RECMIXL Playback Switch", "RECMIXL Mixer"},
1263         {"OUTMIXL Mixer", "RECMIXR Playback Switch", "RECMIXR Mixer"},
1264         {"OUTMIXL Mixer", "DACL Playback Switch", "Left DAC"},
1265         {"OUTMIXL Mixer", "MIC1_BST1 Playback Switch", "Mic1 Boost"},
1266         {"OUTMIXL Mixer", "MIC2_BST2 Playback Switch", "Mic2 Boost"},
1267         {"OUTMIXL Mixer", "MONOIN_RXP Playback Switch", "MONOIN_RXP Boost"},
1268         {"OUTMIXL Mixer", "AXILVOL Playback Switch", "AXIL Boost"},
1269         {"OUTMIXL Mixer", "AXIRVOL Playback Switch", "AXIR Boost"},
1270         {"OUTMIXL Mixer", "VDAC Playback Switch", "Voice DAC Boost"},
1271
1272         {"OUTMIXR Mixer", "RECMIXL Playback Switch", "RECMIXL Mixer"},
1273         {"OUTMIXR Mixer", "RECMIXR Playback Switch", "RECMIXR Mixer"},
1274         {"OUTMIXR Mixer", "DACR Playback Switch", "Right DAC"},
1275         {"OUTMIXR Mixer", "MIC1_BST1 Playback Switch", "Mic1 Boost"},
1276         {"OUTMIXR Mixer", "MIC2_BST2 Playback Switch", "Mic2 Boost"},
1277         {"OUTMIXR Mixer", "MONOIN_RXN Playback Switch", "MONOIN_RXN Boost"},
1278         {"OUTMIXR Mixer", "AXILVOL Playback Switch", "AXIL Boost"},
1279         {"OUTMIXR Mixer", "AXIRVOL Playback Switch", "AXIR Boost"},
1280         {"OUTMIXR Mixer", "VDAC Playback Switch", "Voice DAC Boost"},
1281
1282         {"Left SPK Vol",  NULL, "SPKMIXL Mixer"},
1283         {"Right SPK Vol",  NULL, "SPKMIXR Mixer"},
1284         {"Left HP Vol",  NULL, "OUTMIXL Mixer"},
1285         {"Left Out Vol",  NULL, "OUTMIXL Mixer"},
1286         {"Right Out Vol",  NULL, "OUTMIXR Mixer"},
1287         {"Right HP Vol",  NULL, "OUTMIXR Mixer"},
1288
1289         {"AXO1MIX Mixer", "MIC1_BST1 Playback Switch", "Mic1 Boost"},
1290         {"AXO1MIX Mixer", "OUTVOLL Playback Switch", "Left Out Vol"},
1291         {"AXO1MIX Mixer", "OUTVOLR Playback Switch", "Right Out Vol"},
1292         {"AXO1MIX Mixer", "MIC2_BST2 Playback Switch", "Mic2 Boost"},
1293
1294         {"AXO2MIX Mixer", "MIC1_BST1 Playback Switch", "Mic1 Boost"},
1295         {"AXO2MIX Mixer", "OUTVOLL Playback Switch", "Left Out Vol"},
1296         {"AXO2MIX Mixer", "OUTVOLR Playback Switch", "Right Out Vol"},
1297         {"AXO2MIX Mixer", "MIC2_BST2 Playback Switch", "Mic2 Boost"},
1298
1299         {"SPOLMIX Mixer", "SPKVOLL Playback Switch", "Left SPK Vol"},
1300         {"SPOLMIX Mixer", "SPKVOLR Playback Switch", "Right SPK Vol"},
1301
1302         {"SPORMIX Mixer", "SPKVOLL Playback Switch", "Left SPK Vol"},
1303         {"SPORMIX Mixer", "SPKVOLR Playback Switch", "Right SPK Vol"},
1304
1305         {"MONOMIX Mixer", "OUTVOLL Playback Switch", "Left Out Vol"},
1306         {"MONOMIX Mixer", "OUTVOLR Playback Switch", "Right Out Vol"},
1307
1308         {"SPOL Mux", "SPOLMIX", "SPOLMIX Mixer"},
1309         {"SPOL Mux", "MONOIN_RX", "MONO_IN"},
1310         {"SPOL Mux", "VDAC", "Voice DAC Boost"},
1311         {"SPOL Mux", "DACL", "Left DAC"},
1312
1313         {"SPOR Mux", "SPORMIX", "SPORMIX Mixer"},
1314         {"SPOR Mux", "MONOIN_RX", "MONO_IN"},
1315         {"SPOR Mux", "VDAC", "Voice DAC Boost"},
1316         {"SPOR Mux", "DACR", "Right DAC"},
1317
1318         {"Mono Mux", "MONOMIX", "MONOMIX Mixer"},
1319         {"Mono Mux", "MONOIN_RX", "MONO_IN"},
1320         {"Mono Mux", "VDAC", "Voice DAC Boost"},
1321
1322         {"Right DAC_HP", "NULL", "Right DAC"},
1323         {"Left DAC_HP", "NULL", "Left DAC"},
1324
1325         {"HPL Mux", "LEFT HPVOL", "Left HP Vol"},
1326         {"HPL Mux", "LEFT DAC", "Left DAC_HP"},
1327         {"HPR Mux", "RIGHT HPVOL", "Right HP Vol"},
1328         {"HPR Mux", "RIGHT DAC", "Right DAC_HP"},
1329
1330         {"SPKL Amp", NULL, "SPOL Mux"},
1331         {"SPKR Amp", NULL, "SPOR Mux"},
1332         {"Mono Amp", NULL, "Mono Mux"},
1333
1334         {"AUXO1", NULL, "AXO1MIX Mixer"},
1335         {"AUXO2", NULL, "AXO2MIX Mixer"},
1336         {"SPOL", NULL, "SPKL Amp"},
1337         {"SPOR", NULL, "SPKR Amp"},
1338
1339         {"HPOL", NULL, "HPL Mux"},
1340         {"HPOR", NULL, "HPR Mux"},
1341
1342         {"MONO", NULL, "Mono Amp"}
1343 };
1344
1345 static int rt5631_add_widgets(struct snd_soc_codec *codec)
1346 {
1347         struct snd_soc_dapm_context *dapm = &codec->dapm;
1348
1349         snd_soc_dapm_new_controls(dapm, rt5631_dapm_widgets,
1350                         ARRAY_SIZE(rt5631_dapm_widgets));
1351         snd_soc_dapm_add_routes(dapm, audio_map, ARRAY_SIZE(audio_map));
1352
1353         return 0;
1354 }
1355
1356 static int voltab[2][16] =
1357 {
1358     //spk
1359     {0x27, 0x1b, 0x18, 0x15, 0x13, 0x11, 0x0f, 0x0e, 0x0d, 0x0c, 0x0b, 0x0a, 0x09, 0x08, 0x07, 0x06},
1360     //hp
1361     {0x1f, 0x1c, 0x1a, 0x18, 0x16, 0x14, 0x12, 0x10, 0x0e, 0x0c, 0x0a, 0x08, 0x06, 0x04, 0x02, 0x01},
1362 };
1363 static int gvolume = 0;
1364
1365 #if 1
1366 static int get_vol(int max, int min, int stage_num, int stage)
1367 {
1368         int ret, step=((max-min)<<8)/(stage_num-1);
1369         if(stage==stage_num-1)
1370                 ret=min;
1371         else if(stage==0)
1372                 ret=max;
1373         else {
1374                 ret=(stage_num-stage-1) * step;
1375                 ret >>= 8;
1376                 ret = min+ret;
1377         }
1378         DBG("%s(): ret=%02x, max=0x%02x, min=0x%02x, stage_num=%d, stage=%d\n",
1379                 __FUNCTION__,
1380                 ret,
1381                 max,
1382                 min,
1383                 stage_num,
1384                 stage);
1385         return ret;
1386 }
1387
1388 static void rt5631_set_volume(int vollevel)
1389 {
1390         struct snd_soc_codec *codec = rt5631_codec;
1391         int tmpvol1, tmpvol2;
1392
1393         //DBG("rt5631_set_volume = %d\n", vollevel);
1394
1395         if (vollevel > 15) vollevel = 8;
1396         gvolume = vollevel;
1397
1398 //      tmpvol1 = voltab[0][vollevel];
1399 //      tmpvol2 = voltab[1][vollevel];
1400         tmpvol1=get_vol(0x27, DEF_VOL_SPK&0x3f, 16, vollevel);
1401         tmpvol2=get_vol(0x1f, DEF_VOL&0x1f, 16, vollevel);
1402
1403         if(vollevel == 0){
1404                 rt5631_write_mask(codec, RT5631_SPK_OUT_VOL, 0x8080, 0x8080);
1405                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL, 0x8080, 0x8080);
1406         }
1407 //      else{
1408 //              rt5631_write_mask(codec, RT5631_SPK_OUT_VOL, 0x00, 0x8080);
1409 //              rt5631_write_mask(codec, RT5631_HP_OUT_VOL, 0x00, 0x8080);
1410 //      }
1411
1412         rt5631_write_mask(codec, RT5631_SPK_OUT_VOL, ((tmpvol1<<8)|tmpvol1), 0x3f3f);
1413         rt5631_write_mask(codec, RT5631_HP_OUT_VOL,  ((tmpvol2<<8)|tmpvol2), 0x3f3f);
1414 }
1415
1416 static void rt5631_set_eq(int on)
1417 {
1418         struct snd_soc_codec *codec = rt5631_codec;
1419         unsigned int Reg0C;
1420
1421         Reg0C = rt5631_read(codec, RT5631_STEREO_DAC_VOL_1);
1422         DBG("------- rt5631_set_eq: read Reg0C = 0x%04x\n", Reg0C);
1423
1424         Reg0C &= 0xFF80;
1425         if(on) {
1426                 Reg0C |= 0x10;
1427         } else {
1428                 Reg0C |= 0x00;
1429         }
1430
1431         DBG("------- rt5631_set_eq: write Reg0C = 0x%04x\n", Reg0C);
1432         rt5631_write(codec, RT5631_STEREO_DAC_VOL_1, Reg0C);
1433 }
1434
1435 #else
1436
1437 static void rt5631_set_volume(int vollevel)
1438 {
1439         struct snd_soc_codec *codec = rt5631_codec;
1440         u8 tmpvol1, tmpvol2;
1441         u16 spk_vol, hp_vol;
1442
1443         DBG("rt5631_set_volume = %d\n", vollevel);
1444
1445         if (vollevel > 15) vollevel = 8;
1446         gvolume = vollevel;
1447
1448         tmpvol1 = voltab[0][vollevel];
1449         tmpvol2 = voltab[1][vollevel];
1450
1451         spk_vol = snd_soc_read(codec, RT5631_SPK_OUT_VOL);
1452         hp_vol  = snd_soc_read(codec, RT5631_HP_OUT_VOL);
1453
1454         DBG("\n\nold value: 0x%04x, 0x%04x\n", spk_vol & 0x3F3F, hp_vol & 0x3F3F);
1455         DBG("new value: 0x%04x\n", (tmpvol1<<8)|tmpvol1, (tmpvol2<<8)|tmpvol2);
1456
1457         spk_vol &= 0x3C3C;
1458         spk_vol |= (tmpvol1<<8)|tmpvol1;
1459         hp_vol  &= 0x3C3C;
1460         hp_vol  |= (tmpvol2<<8)|tmpvol2;
1461
1462         snd_soc_write(codec, RT5631_SPK_OUT_VOL, spk_vol);
1463         snd_soc_write(codec, RT5631_HP_OUT_VOL , hp_vol);
1464 }
1465
1466 #endif
1467 struct coeff_clk_div {
1468         u32 mclk;
1469         u32 bclk;
1470         u32 rate;
1471         u16 reg_val;
1472 };
1473
1474 /* PLL divisors yes*/
1475 struct pll_div {
1476         u32 pll_in;
1477         u32 pll_out;
1478         u16 reg_val;
1479 };
1480
1481 static const struct pll_div codec_master_pll_div[] = {
1482         {2048000,  8192000,  0x0ea0},
1483         {3686400,  8192000,  0x4e27},
1484         {12000000,  8192000,  0x456b},
1485         {13000000,  8192000,  0x495f},
1486         {13100000,  8192000,  0x0320},
1487         {2048000,  11289600,  0xf637},
1488         {3686400,  11289600,  0x2f22},
1489         {12000000,  11289600,  0x3e2f},
1490         {13000000,  11289600,  0x4d5b},
1491         {13100000,  11289600,  0x363b},
1492         {2048000,  16384000,  0x1ea0},
1493         {3686400,  16384000,  0x9e27},
1494         {12000000,  16384000,  0x452b},
1495         {13000000,  16384000,  0x542f},
1496         {13100000,  16384000,  0x03a0},
1497         {2048000,  16934400,  0xe625},
1498         {3686400,  16934400,  0x9126},
1499         {12000000,  16934400,  0x4d2c},
1500         {13000000,  16934400,  0x742f},
1501         {13100000,  16934400,  0x3c27},
1502         {2048000,  22579200,  0x2aa0},
1503         {3686400,  22579200,  0x2f20},
1504         {12000000,  22579200,  0x7e2f},
1505         {13000000,  22579200,  0x742f},
1506         {13100000,  22579200,  0x3c27},
1507         {2048000,  24576000,  0x2ea0},
1508         {3686400,  24576000,  0xee27},
1509         {12000000,  24576000,  0x2915},
1510         {13000000,  24576000,  0x772e},
1511         {13100000,  24576000,  0x0d20},
1512         {26000000,  24576000,  0x2027},
1513         {26000000,  22579200,  0x392f},
1514         {24576000,  22579200,  0x0921},
1515         {24576000,  24576000,  0x02a0},
1516 };
1517
1518 static const struct pll_div codec_slave_pll_div[] = {
1519         {256000,  2048000,  0x46f0},
1520         {256000,  4096000,  0x3ea0},
1521         {352800,         5644800,  0x3ea0},
1522         {512000,         8192000,  0x3ea0},
1523         {1024000,  8192000,  0x46f0},
1524         {705600,  11289600,  0x3ea0},
1525         {1024000,  16384000,  0x3ea0},
1526         {1411200,  22579200,  0x3ea0},
1527         {1536000,  24576000,  0x3ea0},
1528         {2048000,  16384000,  0x1ea0},
1529         {2822400,  22579200,  0x1ea0},
1530         {2822400,  45158400,  0x5ec0},
1531         {5644800,  45158400,  0x46f0},
1532         {3072000,  24576000,  0x1ea0},
1533         {3072000,  49152000,  0x5ec0},
1534         {6144000,  49152000,  0x46f0},
1535         {705600,  11289600,  0x3ea0},
1536         {705600,  8467200,  0x3ab0},
1537         {24576000,  24576000,  0x02a0},
1538         {1411200,  11289600,  0x1690},
1539         {2822400,  11289600,  0x0a90},
1540         {1536000,  12288000,  0x1690},
1541         {3072000,  12288000,  0x0a90},
1542 };
1543
1544 struct coeff_clk_div coeff_div[] = {
1545         /* sysclk is 256fs */
1546         {2048000,  8000 * 32,  8000, 0x1000},
1547         {2048000,  8000 * 64,  8000, 0x0000},
1548         {2822400,  11025 * 32,  11025,  0x1000},
1549         {2822400,  11025 * 64,  11025,  0x0000},
1550         {4096000,  16000 * 32,  16000,  0x1000},
1551         {4096000,  16000 * 64,  16000,  0x0000},
1552         {5644800,  22050 * 32,  22050,  0x1000},
1553         {5644800,  22050 * 64,  22050,  0x0000},
1554         {8192000,  32000 * 32,  32000,  0x1000},
1555         {8192000,  32000 * 64,  32000,  0x0000},
1556         {11289600,  44100 * 32,  44100,  0x1000},
1557         {11289600,  44100 * 64,  44100,  0x0000},
1558         {12288000,  48000 * 32,  48000,  0x1000},
1559         {12288000,  48000 * 64,  48000,  0x0000},
1560         {22579200,  88200 * 32,  88200,  0x1000},
1561         {22579200,  88200 * 64,  88200,  0x0000},
1562         {24576000,  96000 * 32,  96000,  0x1000},
1563         {24576000,  96000 * 64,  96000,  0x0000},
1564         /* sysclk is 512fs */
1565         {4096000,  8000 * 32,  8000, 0x3000},
1566         {4096000,  8000 * 64,  8000, 0x2000},
1567         {5644800,  11025 * 32,  11025, 0x3000},
1568         {5644800,  11025 * 64,  11025, 0x2000},
1569         {8192000,  16000 * 32,  16000, 0x3000},
1570         {8192000,  16000 * 64,  16000, 0x2000},
1571         {11289600,  22050 * 32,  22050, 0x3000},
1572         {11289600,  22050 * 64,  22050, 0x2000},
1573         {16384000,  32000 * 32,  32000, 0x3000},
1574         {16384000,  32000 * 64,  32000, 0x2000},
1575         {22579200,  44100 * 32,  44100, 0x3000},
1576         {22579200,  44100 * 64,  44100, 0x2000},
1577         {24576000,  48000 * 32,  48000, 0x3000},
1578         {24576000,  48000 * 64,  48000, 0x2000},
1579         {45158400,  88200 * 32,  88200, 0x3000},
1580         {45158400,  88200 * 64,  88200, 0x2000},
1581         {49152000,  96000 * 32,  96000, 0x3000},
1582         {49152000,  96000 * 64,  96000, 0x2000},
1583         /* sysclk is 24.576Mhz or 22.5792Mhz */
1584         {24576000,  8000 * 32,  8000,  0x7080},
1585         {24576000,  8000 * 64,  8000,  0x6080},
1586         {24576000,  16000 * 32,  16000,  0x5080},
1587         {24576000,  16000 * 64,  16000,  0x4080},
1588         {24576000,  24000 * 32,  24000,  0x5000},
1589         {24576000,  24000 * 64,  24000,  0x4000},
1590         {24576000,  32000 * 32,  32000,  0x3080},
1591         {24576000,  32000 * 64,  32000,  0x2080},
1592         {22579200,  11025 * 32,  11025,  0x7000},
1593         {22579200,  11025 * 64,  11025,  0x6000},
1594         {22579200,  22050 * 32,  22050,  0x5000},
1595         {22579200,  22050 * 64,  22050,  0x4000},
1596 };
1597
1598 static int get_coeff(int mclk, int rate, int timesofbclk)
1599 {
1600         int i;
1601
1602         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
1603                 if (coeff_div[i].mclk == mclk && coeff_div[i].rate == rate &&
1604                         (coeff_div[i].bclk / coeff_div[i].rate) == timesofbclk)
1605                         return i;
1606         }
1607         return -EINVAL;
1608 }
1609
1610 static int get_coeff_in_slave_mode(int mclk, int rate)
1611 {
1612         return get_coeff(mclk, rate, timesofbclk);
1613 }
1614
1615 static int get_coeff_in_master_mode(int mclk, int rate, int bclk)
1616 {
1617         return get_coeff(mclk, rate, (bclk / rate));
1618 }
1619
1620 static void rt5631_set_dmic_params(struct snd_soc_codec *codec,
1621         struct snd_pcm_hw_params *params)
1622 {
1623         int rate;
1624
1625         rt5631_write_mask(codec, RT5631_GPIO_CTRL,
1626                 GPIO_PIN_FUN_SEL_GPIO_DIMC | GPIO_DMIC_FUN_SEL_DIMC,
1627                 GPIO_PIN_FUN_SEL_MASK | GPIO_DMIC_FUN_SEL_MASK);
1628         rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL, DMIC_ENA, DMIC_ENA_MASK);
1629         rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
1630                 DMIC_L_CH_LATCH_FALLING | DMIC_R_CH_LATCH_RISING,
1631                 DMIC_L_CH_LATCH_MASK|DMIC_R_CH_LATCH_MASK);
1632
1633         rate = params_rate(params);
1634         switch (rate) {
1635         case 44100:
1636         case 48000:
1637                 rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
1638                         DMIC_CLK_CTRL_TO_32FS, DMIC_CLK_CTRL_MASK);
1639                 break;
1640
1641         case 32000:
1642         case 22050:
1643                 rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
1644                         DMIC_CLK_CTRL_TO_64FS, DMIC_CLK_CTRL_MASK);
1645                 break;
1646
1647         case 16000:
1648         case 11025:
1649         case 8000:
1650                 rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
1651                         DMIC_CLK_CTRL_TO_128FS, DMIC_CLK_CTRL_MASK);
1652                 break;
1653
1654         default:
1655                 break;
1656         }
1657
1658         rt5631_write_mask(codec, RT5631_DIG_MIC_CTRL,
1659                 DMIC_L_CH_UNMUTE | DMIC_R_CH_UNMUTE,
1660                 DMIC_L_CH_MUTE_MASK | DMIC_R_CH_MUTE_MASK);
1661
1662         return;
1663 }
1664
1665 static int rt5631_hifi_pcm_params(struct snd_pcm_substream *substream,
1666                 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai)
1667 {
1668         struct snd_soc_pcm_runtime *rtd = substream->private_data;
1669         struct snd_soc_codec *codec = rtd->codec;
1670         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1671         int stream = substream->stream, rate = params_rate(params), coeff;
1672         unsigned int iface = 0;
1673
1674         pr_debug("enter %s\n", __func__);
1675
1676         if (!rt5631->master)
1677                 coeff = get_coeff_in_slave_mode(rt5631->sysclk, rate);
1678         else
1679                 coeff = get_coeff_in_master_mode(rt5631->sysclk, rate,
1680                                         rate * timesofbclk);
1681         if (coeff < 0)
1682                 pr_err("%s: get coeff err!\n", __func__);
1683
1684         switch (params_format(params)) {
1685         case SNDRV_PCM_FORMAT_S16_LE:
1686                 break;
1687         case SNDRV_PCM_FORMAT_S20_3LE:
1688                 iface |= SDP_I2S_DL_20;
1689                 break;
1690         case SNDRV_PCM_FORMAT_S24_LE:
1691                 iface |= SDP_I2S_DL_24;
1692                 break;
1693         case SNDRV_PCM_FORMAT_S8:
1694                 iface |= SDP_I2S_DL_8;
1695                 break;
1696         default:
1697                 return -EINVAL;
1698         }
1699
1700         if (SNDRV_PCM_STREAM_CAPTURE == stream) {
1701                 if (rt5631->dmic_used_flag)
1702                         rt5631_set_dmic_params(codec, params);
1703         }
1704
1705         rt5631_write_mask(codec, RT5631_SDP_CTRL, iface, SDP_I2S_DL_MASK);
1706
1707         if (coeff >= 0)
1708                 rt5631_write(codec, RT5631_STEREO_AD_DA_CLK_CTRL,
1709                                         coeff_div[coeff].reg_val);
1710
1711         return 0;
1712 }
1713
1714 static int rt5631_hifi_codec_set_dai_fmt(struct snd_soc_dai *codec_dai,
1715                                                 unsigned int fmt)
1716 {
1717         struct snd_soc_codec *codec = codec_dai->codec;
1718         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1719         unsigned int iface = 0;
1720
1721         pr_debug("enter %s\n", __func__);
1722
1723         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
1724         case SND_SOC_DAIFMT_CBM_CFM:
1725                 rt5631->master = 1;
1726                 break;
1727         case SND_SOC_DAIFMT_CBS_CFS:
1728                 iface |= SDP_MODE_SEL_SLAVE;
1729                 rt5631->master = 0;
1730                 break;
1731         default:
1732                 return -EINVAL;
1733         }
1734
1735         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
1736         case SND_SOC_DAIFMT_I2S:
1737                 break;
1738         case SND_SOC_DAIFMT_LEFT_J:
1739                 iface |= SDP_I2S_DF_LEFT;
1740                 break;
1741         case SND_SOC_DAIFMT_DSP_A:
1742                 iface |= SDP_I2S_DF_PCM_A;
1743                 break;
1744         case SND_SOC_DAIFMT_DSP_B:
1745                 iface  |= SDP_I2S_DF_PCM_B;
1746                 break;
1747         default:
1748                 return -EINVAL;
1749         }
1750
1751         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
1752         case SND_SOC_DAIFMT_NB_NF:
1753                 break;
1754         case SND_SOC_DAIFMT_IB_NF:
1755                 iface |= SDP_I2S_BCLK_POL_CTRL;
1756                 break;
1757         default:
1758                 return -EINVAL;
1759         }
1760
1761         rt5631_write(codec, RT5631_SDP_CTRL, iface);
1762
1763         return 0;
1764 }
1765
1766 static int rt5631_hifi_codec_set_dai_sysclk(struct snd_soc_dai *codec_dai,
1767                                 int clk_id, unsigned int freq, int dir)
1768 {
1769         struct snd_soc_codec *codec = codec_dai->codec;
1770         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1771
1772         pr_info("enter %s, syclk=%d\n", __func__, freq);
1773         if ((freq >= (256 * 8000)) && (freq <= (512 * 96000))) {
1774                 rt5631->sysclk = freq;
1775                 return 0;
1776         }
1777
1778         pr_info("unsupported sysclk freq %u for audio i2s\n", freq);
1779         pr_info("set sysclk to 24.576Mhz by default\n");
1780
1781         rt5631->sysclk = 24576000;
1782         return 0;
1783 }
1784
1785 static int rt5631_codec_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id,
1786                 int source, unsigned int freq_in, unsigned int freq_out)
1787 {
1788         struct snd_soc_codec *codec = codec_dai->codec;
1789         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1790         int i, ret = -EINVAL;
1791
1792         printk(KERN_DEBUG "enter %s\n", __func__);
1793
1794         if (!freq_in || !freq_out)
1795                 return 0;
1796
1797         if (rt5631->master) {
1798                 for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++)
1799                         if (freq_in == codec_master_pll_div[i].pll_in &&
1800                         freq_out == codec_master_pll_div[i].pll_out) {
1801                                 rt5631_write(codec, RT5631_PLL_CTRL,
1802                                         codec_master_pll_div[i].reg_val);
1803                                 schedule_timeout_uninterruptible(
1804                                         msecs_to_jiffies(20));
1805                                 rt5631_write(codec, RT5631_GLOBAL_CLK_CTRL,
1806                                         SYSCLK_SOUR_SEL_PLL);
1807                                 rt5631->pll_used_flag = 1;
1808                                 ret = 0;
1809                                 break;
1810                         }
1811         } else {
1812                 for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++)
1813                         if (freq_in == codec_slave_pll_div[i].pll_in &&
1814                         freq_out == codec_slave_pll_div[i].pll_out) {
1815                                 rt5631_write(codec, RT5631_PLL_CTRL,
1816                                         codec_slave_pll_div[i].reg_val);
1817                                 schedule_timeout_uninterruptible(
1818                                         msecs_to_jiffies(20));
1819                                 rt5631_write(codec, RT5631_GLOBAL_CLK_CTRL,
1820                                         SYSCLK_SOUR_SEL_PLL |
1821                                         PLLCLK_SOUR_SEL_BITCLK);
1822                                 rt5631->pll_used_flag = 1;
1823                                 ret = 0;
1824                                 break;
1825                         }
1826         }
1827
1828         return ret;
1829 }
1830
1831 #if defined(CONFIG_ADJUST_VOL_BY_CODEC)
1832 static int rt5631_trigger(struct snd_pcm_substream *substream, int status, struct snd_soc_dai *dai)
1833 {
1834         //DBG("rt5631_trigger\n");
1835         if(status == SNDRV_PCM_TRIGGER_VOLUME){
1836                 //DBG("rt5631_trigger: vol = %d\n", substream->number);
1837                 if(substream->number < 100){
1838                         rt5631_set_volume(substream->number);
1839                 } else {
1840                         if(substream->number == 100) { // eq off
1841                                 DBG("---------- eq off\n");
1842                                 rt5631_set_eq(0);
1843                         } else { // eq on   +6dB
1844                                 DBG("---------- eq on\n");
1845                                 rt5631_set_eq(1);
1846                         }
1847                 }
1848         }
1849
1850         return 0;
1851 }
1852 #endif
1853
1854 static ssize_t rt5631_index_reg_show(struct device *dev,
1855         struct device_attribute *attr, char *buf)
1856 {
1857         #define IDX_REG_FMT "%02x: %04x\n"
1858         #define IDX_REG_LEN 9
1859         unsigned int val;
1860         int cnt = 0, i;
1861
1862         cnt += sprintf(buf, "RT5631 index register\n");
1863         for (i = 0; i < 0x55; i++) {
1864                 if (cnt + IDX_REG_LEN >= PAGE_SIZE - 1)
1865                         break;
1866                 val = rt5631_read_index(rt5631_codec, i);
1867                 if (!val)
1868                         continue;
1869                 cnt += sprintf(buf + cnt, IDX_REG_FMT, i, val);
1870         }
1871
1872         if (cnt >= PAGE_SIZE)
1873                 cnt = PAGE_SIZE - 1;
1874
1875         return cnt;
1876 }
1877 static DEVICE_ATTR(index_reg, 0444, rt5631_index_reg_show, NULL);
1878
1879 #define RT5631_STEREO_RATES SNDRV_PCM_RATE_8000_96000
1880 #define RT5631_FORMAT   (SNDRV_PCM_FMTBIT_S16_LE | \
1881                         SNDRV_PCM_FMTBIT_S20_3LE | \
1882                         SNDRV_PCM_FMTBIT_S24_LE | \
1883                         SNDRV_PCM_FMTBIT_S8)
1884
1885 struct snd_soc_dai_ops rt5631_ops = {
1886         .hw_params = rt5631_hifi_pcm_params,
1887         .set_fmt = rt5631_hifi_codec_set_dai_fmt,
1888         .set_sysclk = rt5631_hifi_codec_set_dai_sysclk,
1889         .set_pll = rt5631_codec_set_dai_pll,
1890 #if defined(CONFIG_ADJUST_VOL_BY_CODEC)
1891     .trigger = rt5631_trigger,
1892 #endif
1893 };
1894
1895 struct snd_soc_dai_driver rt5631_dai[] = {
1896         {
1897                 .name = "RT5631 HiFi",
1898                 .playback = {
1899                         .stream_name = "HIFI Playback",
1900                         .channels_min = 1,
1901                         .channels_max = 2,
1902                         .rates = RT5631_STEREO_RATES,
1903                         .formats = RT5631_FORMAT,
1904                 },
1905                 .capture = {
1906                         .stream_name = "HIFI Capture",
1907                         .channels_min = 1,
1908                         .channels_max = 2,
1909                         .rates = RT5631_STEREO_RATES,
1910                         .formats = RT5631_FORMAT,
1911                 },
1912                 .ops = &rt5631_ops,
1913         },
1914 };
1915 EXPORT_SYMBOL_GPL(rt5631_dai);
1916
1917 static int rt5631_set_bias_level(struct snd_soc_codec *codec,
1918                         enum snd_soc_bias_level level)
1919 {
1920         switch (level) {
1921         case SND_SOC_BIAS_ON:
1922                 break;
1923
1924         case SND_SOC_BIAS_PREPARE:
1925                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
1926                         PWR_VREF | PWR_MAIN_BIAS, PWR_VREF | PWR_MAIN_BIAS);
1927                 rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD2,
1928                         PWR_MICBIAS1_VOL | PWR_MICBIAS2_VOL,
1929                         PWR_MICBIAS1_VOL | PWR_MICBIAS2_VOL);
1930                 break;
1931
1932         case SND_SOC_BIAS_STANDBY:
1933         //      rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD2, 0,
1934         //              PWR_MICBIAS1_VOL | PWR_MICBIAS2_VOL);
1935                 printk("standby rt5631\n");
1936                 rt5631_write(codec, RT5631_PWR_MANAG_ADD1, 0x0000);
1937                 rt5631_write(codec, RT5631_PWR_MANAG_ADD2, 0x0000);
1938                 rt5631_write(codec, RT5631_PWR_MANAG_ADD3, 0x0000);
1939                 rt5631_write(codec, RT5631_PWR_MANAG_ADD4, 0x0000);
1940                 break;
1941
1942         case SND_SOC_BIAS_OFF:
1943                 rt5631_write_mask(codec, RT5631_SPK_OUT_VOL,
1944                         RT_L_MUTE | RT_R_MUTE, RT_L_MUTE | RT_R_MUTE);
1945                 rt5631_write_mask(codec, RT5631_HP_OUT_VOL,
1946                         RT_L_MUTE | RT_R_MUTE, RT_L_MUTE | RT_R_MUTE);
1947                 rt5631_write(codec, RT5631_PWR_MANAG_ADD1, 0x0000);
1948                 rt5631_write(codec, RT5631_PWR_MANAG_ADD2, 0x0000);
1949                 rt5631_write(codec, RT5631_PWR_MANAG_ADD3, 0x0000);
1950                 rt5631_write(codec, RT5631_PWR_MANAG_ADD4, 0x0000);
1951                 break;
1952
1953         default:
1954                 break;
1955         }
1956         codec->dapm.bias_level = level;
1957
1958         return 0;
1959 }
1960
1961 static int rt5631_probe(struct snd_soc_codec *codec)
1962 {
1963         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
1964         unsigned int val;
1965         int ret;
1966         ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
1967         if (ret != 0) {
1968                 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret);
1969                 return ret;
1970         }
1971         codec->cache_bypass = 1;
1972
1973         val = rt5631_read_index(codec, RT5631_ADDA_MIXER_INTL_REG3);
1974         if (val & 0x0002)
1975                 rt5631->codec_version = 1;
1976         else
1977                 rt5631->codec_version = 0;
1978
1979         rt5631_reset(codec);
1980         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
1981                 PWR_VREF | PWR_MAIN_BIAS, PWR_VREF | PWR_MAIN_BIAS);
1982         schedule_timeout_uninterruptible(msecs_to_jiffies(80));
1983         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3, PWR_FAST_VREF_CTRL,
1984                                         PWR_FAST_VREF_CTRL);
1985         rt5631_reg_init(codec);
1986
1987         /* power off ClassD auto Recovery */
1988         if (rt5631->codec_version)
1989                 rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
1990                                         0x2000, 0x2000);
1991         else
1992                 rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
1993                                         0, 0x2000);
1994
1995         codec->dapm.bias_level = SND_SOC_BIAS_STANDBY;
1996         rt5631_codec = codec;
1997
1998 #if (RT5631_SPK_TIMER == 1)
1999         /* Timer module installing */
2000         setup_timer( &spk_timer, spk_timer_callback, 0 );
2001         DBG( "Starting timer to fire in 5s (%ld)\n", jiffies );
2002         ret = mod_timer( &spk_timer, jiffies + msecs_to_jiffies(5000) );
2003         if (ret) printk("Error in mod_timer\n");
2004
2005         INIT_WORK(&spk_work, spk_work_handler);
2006 #endif
2007 //bard 7-16 s
2008         INIT_DELAYED_WORK(&rt5631_delay_cap,rt5631_adc_on);
2009 //bard 7-16 e
2010         snd_soc_add_controls(codec, rt5631_snd_controls,
2011                 ARRAY_SIZE(rt5631_snd_controls));
2012         rt5631_add_widgets(codec);
2013
2014         ret = device_create_file(codec->dev, &dev_attr_index_reg);
2015         if (ret != 0) {
2016                 dev_err(codec->dev,
2017                         "Failed to create index_reg sysfs files: %d\n", ret);
2018                 return ret;
2019         }
2020
2021         DBG("RT5631 initial ok!\n");
2022
2023         return 0;
2024 }
2025
2026 static int rt5631_remove(struct snd_soc_codec *codec)
2027 {
2028
2029
2030 #if (RT5631_SPK_TIMER == 1)
2031         /* Timer¡¡module¡¡uninstalling */
2032         int ret;
2033         ret = del_timer(&spk_timer);
2034         if(ret) printk("The timer is still in use...\n");
2035         DBG("Timer module uninstalling\n");
2036 #endif
2037
2038
2039         rt5631_set_bias_level(codec, SND_SOC_BIAS_OFF);
2040         return 0;
2041 }
2042
2043 static int rt5631_suspend(struct snd_soc_codec *codec, pm_message_t state)
2044 {
2045         rt5631_set_bias_level(codec, SND_SOC_BIAS_OFF);
2046         return 0;
2047 }
2048
2049 static int rt5631_resume(struct snd_soc_codec *codec)
2050 {
2051         struct rt5631_priv *rt5631 = snd_soc_codec_get_drvdata(codec);
2052
2053         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
2054                 PWR_VREF | PWR_MAIN_BIAS, PWR_VREF | PWR_MAIN_BIAS);
2055         schedule_timeout_uninterruptible(msecs_to_jiffies(110));
2056         rt5631_write_mask(codec, RT5631_PWR_MANAG_ADD3,
2057                 PWR_FAST_VREF_CTRL, PWR_FAST_VREF_CTRL);
2058         rt5631_reg_init(codec);
2059
2060         /* power off ClassD auto Recovery */
2061         if (rt5631->codec_version)
2062                 rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
2063                                         0x2000, 0x2000);
2064         else
2065                 rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2,
2066                                         0, 0x2000);
2067
2068 #if (RT5631_SPK_TIMER == 1)
2069                 last_is_spk = !last_is_spk;     //wired~, update eqmode right here by spk_timer.
2070 #endif
2071
2072         return 0;
2073 }
2074
2075 void codec_set_spk(bool on)
2076 {
2077         struct snd_soc_codec *codec = rt5631_codec;
2078
2079         DBG("%s: %d\n", __func__, on);
2080
2081         if(!codec)
2082                 return;
2083         mutex_lock(&codec->mutex);
2084         if(on){
2085                 DBG("snd_soc_dapm_enable_pin\n");
2086                 snd_soc_dapm_enable_pin(&codec->dapm, "Headphone Jack");
2087                 snd_soc_dapm_enable_pin(&codec->dapm, "Ext Spk");
2088         }
2089         else{
2090                 DBG("snd_soc_dapm_disable_pin\n");
2091                 snd_soc_dapm_disable_pin(&codec->dapm, "Headphone Jack");
2092                 snd_soc_dapm_disable_pin(&codec->dapm, "Ext Spk");
2093         }
2094
2095         snd_soc_dapm_sync(&codec->dapm);
2096         mutex_unlock(&codec->mutex);
2097         return;
2098 }
2099
2100 /*
2101  * detect short current for mic1
2102  */
2103 int rt5631_ext_mic_detect(void)
2104 {
2105         struct snd_soc_codec *codec = rt5631_codec;
2106         int det;
2107
2108         rt5631_write_mask(codec, RT5631_MIC_CTRL_2, MICBIAS1_S_C_DET_ENA,
2109                                 MICBIAS1_S_C_DET_MASK);
2110         det = rt5631_read(codec, RT5631_INT_ST_IRQ_CTRL_2) & 0x0001;
2111         rt5631_write_mask(codec, RT5631_INT_ST_IRQ_CTRL_2, 0x0001, 0x00001);
2112
2113         return det;
2114 }
2115 EXPORT_SYMBOL_GPL(rt5631_ext_mic_detect);
2116
2117 static struct snd_soc_codec_driver soc_codec_dev_rt5631 = {
2118         .probe = rt5631_probe,
2119         .remove = rt5631_remove,
2120         .suspend = rt5631_suspend,
2121         .resume = rt5631_resume,
2122         .set_bias_level = rt5631_set_bias_level,
2123         .reg_cache_size = ARRAY_SIZE(rt5631_reg),
2124         .reg_word_size = sizeof(u16),
2125         .reg_cache_default = rt5631_reg,
2126         .reg_cache_step = 1,
2127 };
2128
2129 static const struct i2c_device_id rt5631_i2c_id[] = {
2130         { "rt5631", 0 },
2131         { }
2132 };
2133 MODULE_DEVICE_TABLE(i2c, rt5631_i2c_id);
2134
2135 static int rt5631_i2c_probe(struct i2c_client *i2c,
2136                     const struct i2c_device_id *id)
2137 {
2138         struct rt5631_priv *rt5631;
2139         int ret;
2140
2141         DBG("RT5631 Audio Codec %s\n", RT5631_VERSION);
2142
2143         rt5631 = kzalloc(sizeof(struct rt5631_priv), GFP_KERNEL);
2144         if (NULL == rt5631)
2145                 return -ENOMEM;
2146
2147         i2c_set_clientdata(i2c, rt5631);
2148
2149         ret = snd_soc_register_codec(&i2c->dev, &soc_codec_dev_rt5631,
2150                         rt5631_dai, ARRAY_SIZE(rt5631_dai));
2151         if (ret < 0)
2152                 kfree(rt5631);
2153
2154         return ret;
2155 }
2156
2157 static __devexit int rt5631_i2c_remove(struct i2c_client *client)
2158 {
2159         snd_soc_unregister_codec(&client->dev);
2160         kfree(i2c_get_clientdata(client));
2161         return 0;
2162 }
2163
2164 struct i2c_driver rt5631_i2c_driver = {
2165         .driver = {
2166                 .name = "RT5631",
2167                 .owner = THIS_MODULE,
2168         },
2169         .probe = rt5631_i2c_probe,
2170         .remove   = __devexit_p(rt5631_i2c_remove),
2171         .id_table = rt5631_i2c_id,
2172 };
2173
2174 static int __init rt5631_modinit(void)
2175 {
2176         return i2c_add_driver(&rt5631_i2c_driver);
2177 }
2178 module_init(rt5631_modinit);
2179
2180 static void __exit rt5631_modexit(void)
2181 {
2182         i2c_del_driver(&rt5631_i2c_driver);
2183 }
2184 module_exit(rt5631_modexit);
2185
2186 MODULE_DESCRIPTION("ASoC RT5631 driver");
2187 MODULE_AUTHOR("flove <flove@realtek.com>");
2188 MODULE_LICENSE("GPL");