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