sound/soc/codecs/rk616_codec.c

   1 /*
   2  * rk616.c  --  RK616 CODEC ALSA SoC audio driver
   3  *
   4  * Copyright 2013 Rockship
   5  * Author: chenjq <chenjq@rock-chips.com>
   6  */
   7
   8 #include <linux/module.h>
   9 #include <linux/moduleparam.h>
  10 #include <linux/init.h>
  11 #include <linux/delay.h>
  12 #include <linux/pm.h>
  13 #include <linux/i2c.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/spi/spi.h>
  16 #include <sound/core.h>
  17 #include <sound/pcm.h>
  18 #include <sound/pcm_params.h>
  19 #include <sound/soc.h>
  20 #include <sound/soc-dapm.h>
  21 #include <sound/initval.h>
  22 #include <sound/tlv.h>
  23 #include <linux/gpio.h>
  24 #include <linux/mfd/rk616.h>
  25 #include "rk616_codec.h"
  26 #include <mach/board.h>
  27
  28 #if 0
  29 #define DBG(x...)       printk(KERN_INFO x)
  30 #else
  31 #define DBG(x...)
  32 #endif
  33
  34 //#define RK616_HPMIC_FROM_LINEIN
  35
  36 //#define RK616_HPMIC_FROM_MIC2IN
  37
  38 //#define VIRTUAL_HPGND
  39
  40 /* volume setting
  41  *  0: -39dB
  42  *  26: 0dB
  43  *  31: 6dB
  44  *  Step: 1.5dB
  45 */
  46 #ifdef VIRTUAL_HPGND
  47 #define  SPKOUT_VOLUME    24 //0~31
  48 #define  HPOUT_VOLUME     20 //0~31
  49 #else
  50 #define  SPKOUT_VOLUME    24 //0~31
  51 #define  HPOUT_VOLUME     24 //0~31
  52 #endif
  53
  54 /* volume setting
  55  *  0: -18dB
  56  *  12: 0dB
  57  *  31: 28.5dB
  58  *  Step: 1.5dB
  59 */
  60 #define   CAPTURE_VOL     24 //0-31
  61
  62 //sleep for MOSFET or SPK power amplifier chip
  63 #define SPK_AMP_DELAY 150
  64 #define HP_MOS_DELAY 50
  65
  66 //for route
  67 #define RK616_CODEC_PLAYBACK    1
  68 #define RK616_CODEC_CAPTURE     2
  69 #define RK616_CODEC_INCALL      4
  70 #define RK616_CODEC_ALL (RK616_CODEC_PLAYBACK | RK616_CODEC_CAPTURE | RK616_CODEC_INCALL)
  71
  72 //for gpio
  73 #define RK616_CODEC_SET_SPK     1
  74 #define RK616_CODEC_SET_HP      2
  75 #define RK616_CODEC_SET_RCV     4
  76 #define RK616_CODEC_SET_MIC     8
  77
  78 struct rk616_codec_priv {
  79         struct snd_soc_codec *codec;
  80
  81         unsigned int stereo_sysclk;
  82         unsigned int rate;
  83
  84         int spk_ctl_gpio;
  85         int hp_ctl_gpio;
  86         int rcv_ctl_gpio;
  87         int mic_sel_gpio;
  88
  89         bool spk_gpio_level;
  90         bool hp_gpio_level;
  91         bool rcv_gpio_level;
  92         bool mic_gpio_level;
  93
  94         long int playback_path;
  95         long int capture_path;
  96         long int voice_call_path;
  97         long int voip_path;
  98         long int modem_input_enable;
  99 };
 100
 101 static struct rk616_codec_priv *rk616_priv = NULL;
 102 static struct mfd_rk616 *rk616_mfd = NULL;
 103 static bool rk616_for_mid = 1, is_hdmi_in = false;
 104
 105 bool rk616_get_for_mid(void)
 106 {
 107         return rk616_for_mid;
 108 }
 109
 110 static int rk616_get_parameter(void)
 111 {
 112         int val;
 113         char *command_line = strstr(saved_command_line, "ap_has_alsa=");
 114
 115         if (command_line == NULL) {
 116                 printk("%s : Can not get ap_has_alsa from kernel command line!\n", __func__);
 117                 return 0;
 118         }
 119
 120         command_line += 12;
 121
 122         val = simple_strtol(command_line, NULL, 10);
 123         if (val == 0 || val == 1) {
 124                 rk616_for_mid = (val ? 0 : 1);
 125                 printk("%s : THIS IS FOR %s\n", __func__, rk616_for_mid ? "mid" : "phone");
 126         } else {
 127                 printk("%s : get ap_has_alsa error, val = %d\n", __func__, val);
 128         }
 129
 130         return 0;
 131 }
 132
 133 static const unsigned int rk616_reg_defaults[RK616_PGAR_AGC_CTL5 + 1] = {
 134         [RK616_RESET] = 0x0003,
 135         [RK616_DAC_VOL] = 0x0046,
 136         [RK616_ADC_INT_CTL1] = 0x0050,
 137         [RK616_ADC_INT_CTL2] = 0x000e,
 138         [RK616_DAC_INT_CTL1] = 0x0050,
 139         [RK616_DAC_INT_CTL2] = 0x000e,
 140         [RK616_CLK_CHPUMP] = 0x0021,
 141         [RK616_PGA_AGC_CTL] = 0x000c,
 142         [RK616_PWR_ADD1] = 0x007c,
 143         [RK616_BST_CTL] = 0x0099,
 144         [RK616_DIFFIN_CTL] = 0x0024,
 145         [RK616_MIXINL_CTL] = 0x001f,
 146         [RK616_MIXINL_VOL1] = 0x0024,
 147         [RK616_MIXINL_VOL2] = 0x0004,
 148         [RK616_MIXINR_CTL] = 0x003f,
 149         [RK616_MIXINR_VOL1] = 0x0024,
 150         [RK616_MIXINR_VOL2] = 0x0024,
 151         [RK616_PGAL_CTL] = 0x00cc,
 152         [RK616_PGAR_CTL] = 0x00cc,
 153         [RK616_PWR_ADD2] = 0x00ff,
 154         [RK616_DAC_CTL] = 0x003f,
 155         [RK616_LINEMIX_CTL] = 0x001f,
 156         [RK616_MUXHP_HPMIX_CTL] = 0x003c,
 157         [RK616_HPMIX_CTL] = 0x00ff,
 158         [RK616_HPMIX_VOL1] = 0x0000,
 159         [RK616_HPMIX_VOL2] = 0x0000,
 160         [RK616_LINEOUT1_CTL] = 0x0060,
 161         [RK616_LINEOUT2_CTL] = 0x0060,
 162         [RK616_SPKL_CTL] = 0x00e0,
 163         [RK616_SPKR_CTL] = 0x00e0,
 164         [RK616_HPL_CTL] = 0x00e0,
 165         [RK616_HPR_CTL] = 0x00e0,
 166         [RK616_MICBIAS_CTL] = 0x00ff,
 167         [RK616_MICKEY_DET_CTL] = 0x0028,
 168         [RK616_PWR_ADD3] = 0x000f,
 169         [RK616_ADC_CTL] = 0x0036,
 170         [RK616_SINGNAL_ZC_CTL1] = 0x003f,
 171         [RK616_SINGNAL_ZC_CTL2] = 0x00ff,
 172         [RK616_PGAL_AGC_CTL1] = 0x0010,
 173         [RK616_PGAL_AGC_CTL2] = 0x0025,
 174         [RK616_PGAL_AGC_CTL3] = 0x0041,
 175         [RK616_PGAL_AGC_CTL4] = 0x002c,
 176         [RK616_PGAL_ASR_CTL] = 0x0000,
 177         [RK616_PGAL_AGC_MAX_H] = 0x0026,
 178         [RK616_PGAL_AGC_MAX_L] = 0x0040,
 179         [RK616_PGAL_AGC_MIN_H] = 0x0036,
 180         [RK616_PGAL_AGC_MIN_L] = 0x0020,
 181         [RK616_PGAL_AGC_CTL5] = 0x0038,
 182         [RK616_PGAR_AGC_CTL1] = 0x0010,
 183         [RK616_PGAR_AGC_CTL2] = 0x0025,
 184         [RK616_PGAR_AGC_CTL3] = 0x0041,
 185         [RK616_PGAR_AGC_CTL4] = 0x002c,
 186         [RK616_PGAR_ASR_CTL] = 0x0000,
 187         [RK616_PGAR_AGC_MAX_H] = 0x0026,
 188         [RK616_PGAR_AGC_MAX_L] = 0x0040,
 189         [RK616_PGAR_AGC_MIN_H] = 0x0036,
 190         [RK616_PGAR_AGC_MIN_L] = 0x0020,
 191         [RK616_PGAR_AGC_CTL5] = 0x0038,
 192 };
 193
 194 /* mfd registers default list */
 195 static struct rk616_reg_val_typ rk616_mfd_reg_defaults[] = {
 196         {CRU_CODEC_DIV, 0x00000000},
 197         {CRU_IO_CON0, (I2S1_OUT_DISABLE | I2S0_OUT_DISABLE | I2S1_PD_DISABLE | I2S0_PD_DISABLE) |
 198                 ((I2S1_OUT_DISABLE | I2S0_OUT_DISABLE | I2S1_PD_DISABLE | I2S0_PD_DISABLE) << 16)},
 199         {CRU_IO_CON1, (I2S1_SI_EN | I2S0_SI_EN) | ((I2S1_SI_EN | I2S0_SI_EN) << 16)},
 200         {CRU_PCM2IS2_CON2, (0) | ((PCM_TO_I2S_MUX | APS_SEL | APS_CLR | I2S_CHANNEL_SEL) << 16)},
 201         {CRU_CFGMISC_CON, 0x00000000},
 202 };
 203
 204 /* mfd registers cache list */
 205 static struct rk616_reg_val_typ rk616_mfd_reg_cache[] = {
 206         {CRU_CODEC_DIV, 0x00000000},
 207         {CRU_IO_CON0, (I2S1_OUT_DISABLE | I2S0_OUT_DISABLE | I2S1_PD_DISABLE | I2S0_PD_DISABLE) |
 208                 ((I2S1_OUT_DISABLE | I2S0_OUT_DISABLE | I2S1_PD_DISABLE | I2S0_PD_DISABLE) << 16)},
 209         {CRU_IO_CON1, (I2S1_SI_EN | I2S0_SI_EN) | ((I2S1_SI_EN | I2S0_SI_EN) << 16)},
 210         {CRU_PCM2IS2_CON2, (0) | ((PCM_TO_I2S_MUX | APS_SEL | APS_CLR | I2S_CHANNEL_SEL) << 16)},
 211         {CRU_CFGMISC_CON, 0x00000000},
 212 };
 213 #define RK616_MFD_REG_LEN ARRAY_SIZE(rk616_mfd_reg_cache)
 214
 215 static int rk616_mfd_register(unsigned int reg)
 216 {
 217         int i;
 218
 219         for (i = 0; i < RK616_MFD_REG_LEN; i++) {
 220                 if (rk616_mfd_reg_cache[i].reg == reg)
 221                         return 1;
 222         }
 223
 224         return 0;
 225 }
 226
 227 /* If register's bit16-31 is mask bit add to this fun */
 228 static int rk616_mfd_mask_register(unsigned int reg)
 229 {
 230         switch (reg) {
 231         case CRU_IO_CON0:
 232         case CRU_IO_CON1:
 233         case CRU_PCM2IS2_CON2:
 234                 return 1;
 235         default:
 236                 return 0;
 237         }
 238 }
 239
 240 static struct rk616_reg_val_typ rk616_mfd_codec_bit_list[] = {
 241         {CRU_CFGMISC_CON, AD_DA_LOOP | MICDET2_PIN_F_CODEC | MICDET1_PIN_F_CODEC},
 242 };
 243 #define RK616_MFD_CODEC_BIT_LEN ARRAY_SIZE(rk616_mfd_codec_bit_list)
 244
 245 static int rk616_mfd_codec_bit(unsigned int reg)
 246 {
 247         int i;
 248
 249         for (i = 0; i < RK616_MFD_CODEC_BIT_LEN; i++) {
 250                 if (rk616_mfd_codec_bit_list[i].reg == reg)
 251                         return i;
 252         }
 253
 254         return -1;
 255 }
 256
 257 static struct rk616_init_bit_typ rk616_init_bit_list[] = {
 258         {RK616_SPKL_CTL, RK616_MUTE, RK616_INIT_MASK},
 259         {RK616_SPKR_CTL, RK616_MUTE, RK616_INIT_MASK},
 260         {RK616_HPL_CTL, RK616_MUTE, RK616_INIT_MASK},
 261         {RK616_HPR_CTL, RK616_MUTE, RK616_INIT_MASK},
 262         {RK616_MUXHP_HPMIX_CTL, RK616_HML_PWRD, RK616_HML_INIT_MASK},
 263         {RK616_MUXHP_HPMIX_CTL, RK616_HMR_PWRD, RK616_HMR_INIT_MASK},
 264 };
 265 #define RK616_INIT_BIT_LIST_LEN ARRAY_SIZE(rk616_init_bit_list)
 266
 267 static int rk616_init_bit_register(unsigned int reg, int i)
 268 {
 269         for (; i < RK616_INIT_BIT_LIST_LEN; i++) {
 270                 if (rk616_init_bit_list[i].reg == reg)
 271                         return i;
 272         }
 273
 274         return -1;
 275 }
 276
 277 static unsigned int rk616_codec_read(struct snd_soc_codec *codec, unsigned int reg);
 278
 279 static unsigned int rk616_set_init_value(struct snd_soc_codec *codec, unsigned int reg, unsigned int value)
 280 {
 281         unsigned int read_value, power_bit, set_bit;
 282         int i;
 283
 284         // read codec init register
 285         i = rk616_init_bit_register(reg, 0);
 286
 287         // set codec init bit
 288         // widget init bit should be setted 0 after widget power up or unmute,
 289         // and should be setted 1 after widget power down or mute.
 290         if (i >= 0) {
 291                 read_value = rk616_codec_read(codec, reg);
 292                 while (i >= 0) {
 293                         power_bit = rk616_init_bit_list[i].power_bit;
 294                         set_bit = rk616_init_bit_list[i].init_bit;
 295
 296                         if ((read_value & power_bit) != (value & power_bit))
 297                                 value = (value & ~set_bit) | ((value & power_bit) ?  set_bit : 0);
 298
 299                         i = rk616_init_bit_register(reg, ++i);
 300                 }
 301         }
 302
 303         return value;
 304 }
 305
 306 static int rk616_volatile_register(struct snd_soc_codec *codec, unsigned int reg)
 307 {
 308         switch (reg) {
 309         case RK616_RESET:
 310         case RK616_CLK_CHPUMP:
 311         case RK616_MICKEY_DET_CTL:
 312         case CRU_CFGMISC_CON:
 313                 return 1;
 314         default:
 315                 return 0;
 316         }
 317 }
 318
 319 static int rk616_codec_register(struct snd_soc_codec *codec, unsigned int reg)
 320 {
 321         switch (reg) {
 322         case RK616_RESET:
 323         case RK616_DAC_VOL:
 324         case RK616_ADC_INT_CTL1:
 325         case RK616_ADC_INT_CTL2:
 326         case RK616_DAC_INT_CTL1:
 327         case RK616_DAC_INT_CTL2:
 328         case RK616_CLK_CHPUMP:
 329         case RK616_PGA_AGC_CTL:
 330         case RK616_PWR_ADD1:
 331         case RK616_BST_CTL:
 332         case RK616_DIFFIN_CTL:
 333         case RK616_MIXINL_CTL:
 334         case RK616_MIXINL_VOL1:
 335         case RK616_MIXINL_VOL2:
 336         case RK616_MIXINR_CTL:
 337         case RK616_MIXINR_VOL1:
 338         case RK616_MIXINR_VOL2:
 339         case RK616_PGAL_CTL:
 340         case RK616_PGAR_CTL:
 341         case RK616_PWR_ADD2:
 342         case RK616_DAC_CTL:
 343         case RK616_LINEMIX_CTL:
 344         case RK616_MUXHP_HPMIX_CTL:
 345         case RK616_HPMIX_CTL:
 346         case RK616_HPMIX_VOL1:
 347         case RK616_HPMIX_VOL2:
 348         case RK616_LINEOUT1_CTL:
 349         case RK616_LINEOUT2_CTL:
 350         case RK616_SPKL_CTL:
 351         case RK616_SPKR_CTL:
 352         case RK616_HPL_CTL:
 353         case RK616_HPR_CTL:
 354         case RK616_MICBIAS_CTL:
 355         case RK616_MICKEY_DET_CTL:
 356         case RK616_PWR_ADD3:
 357         case RK616_ADC_CTL:
 358         case RK616_SINGNAL_ZC_CTL1:
 359         case RK616_SINGNAL_ZC_CTL2:
 360         case RK616_PGAL_AGC_CTL1:
 361         case RK616_PGAL_AGC_CTL2:
 362         case RK616_PGAL_AGC_CTL3:
 363         case RK616_PGAL_AGC_CTL4:
 364         case RK616_PGAL_ASR_CTL:
 365         case RK616_PGAL_AGC_MAX_H:
 366         case RK616_PGAL_AGC_MAX_L:
 367         case RK616_PGAL_AGC_MIN_H:
 368         case RK616_PGAL_AGC_MIN_L:
 369         case RK616_PGAL_AGC_CTL5:
 370         case RK616_PGAR_AGC_CTL1:
 371         case RK616_PGAR_AGC_CTL2:
 372         case RK616_PGAR_AGC_CTL3:
 373         case RK616_PGAR_AGC_CTL4:
 374         case RK616_PGAR_ASR_CTL:
 375         case RK616_PGAR_AGC_MAX_H:
 376         case RK616_PGAR_AGC_MAX_L:
 377         case RK616_PGAR_AGC_MIN_H:
 378         case RK616_PGAR_AGC_MIN_L:
 379         case RK616_PGAR_AGC_CTL5:
 380                 return 1;
 381         default:
 382                 return 0;
 383         }
 384 }
 385
 386 static inline unsigned int rk616_read_reg_cache(struct snd_soc_codec *codec,
 387         unsigned int reg)
 388 {
 389         unsigned int *cache = codec->reg_cache;
 390         int i;
 391
 392         if (rk616_codec_register(codec, reg))
 393                 return  cache[reg];
 394
 395         if (rk616_mfd_register(reg)) {
 396                 for (i = 0; i < RK616_MFD_REG_LEN; i++) {
 397                         if (rk616_mfd_reg_cache[i].reg == reg)
 398                                 return rk616_mfd_reg_cache[i].value;
 399                 }
 400         }
 401
 402         printk("%s : reg error!\n", __func__);
 403
 404         return -EINVAL;
 405 }
 406
 407 static inline void rk616_write_reg_cache(struct snd_soc_codec *codec,
 408         unsigned int reg, unsigned int value)
 409 {
 410         unsigned int *cache = codec->reg_cache;
 411         int i;
 412
 413         if (rk616_codec_register(codec, reg)) {
 414                 cache[reg] = value;
 415                 return;
 416         }
 417
 418         if (rk616_mfd_register(reg)) {
 419                 for (i = 0; i < RK616_MFD_REG_LEN; i++) {
 420                         if (rk616_mfd_reg_cache[i].reg == reg) {
 421                                 rk616_mfd_reg_cache[i].value = value;
 422                                 return;
 423                         }
 424                 }
 425         }
 426
 427         printk("%s : reg error!\n", __func__);
 428 }
 429
 430 static unsigned int rk616_codec_read(struct snd_soc_codec *codec, unsigned int reg)
 431 {
 432         struct mfd_rk616 *rk616 = rk616_mfd;
 433         unsigned int value;
 434
 435         if (!rk616) {
 436                 printk("%s : rk616 is NULL\n", __func__);
 437                 return -EINVAL;
 438         }
 439
 440         if (!rk616_mfd_register(reg) && !rk616_codec_register(codec, reg)) {
 441                 printk("%s : reg error!\n", __func__);
 442                 return -EINVAL;
 443         }
 444
 445         if (rk616_volatile_register(codec, reg) == 0) {
 446                 value = rk616_read_reg_cache(codec, reg);
 447         } else {
 448                 if (rk616->read_dev(rk616, reg, &value) < 0) {
 449                         printk("%s : reg = 0x%x failed\n", __func__, reg);
 450                         return -EIO;
 451                 }
 452         }
 453
 454         DBG("%s : reg = 0x%x, val= 0x%x\n", __func__, reg, value);
 455
 456         return value;
 457 }
 458
 459 static int rk616_codec_write(struct snd_soc_codec *codec, unsigned int reg, unsigned int value)
 460 {
 461         struct mfd_rk616 *rk616 = rk616_mfd;
 462         unsigned int set_bit, read_value, new_value;
 463         int i;
 464
 465         if (!rk616) {
 466                 printk("%s : rk616 is NULL\n", __func__);
 467                 return -EINVAL;
 468         } else if (!rk616_mfd_register(reg) && !rk616_codec_register(codec, reg)) {
 469                 printk("%s : reg error!\n", __func__);
 470                 return -EINVAL;
 471         }
 472
 473         // set codec mask bit
 474         i = rk616_mfd_codec_bit(reg);
 475         if (i >= 0) {
 476                 set_bit = rk616_mfd_codec_bit_list[i].value;
 477                 read_value = rk616_codec_read(codec, reg);
 478                 value = (read_value & ~set_bit) | (value & set_bit);
 479         } else if (rk616_mfd_mask_register(reg)) {
 480                 value = ((0xffff0000 & rk616_read_reg_cache(codec, reg)) | (value & 0x0000ffff));
 481         }
 482
 483         new_value = rk616_set_init_value(codec, reg, value);
 484
 485         // write i2c
 486         if (rk616->write_dev(rk616, reg, &value) < 0) {
 487                 printk("%s : reg = 0x%x failed\n", __func__, reg);
 488                 return -EIO;
 489         }
 490
 491         if (new_value != value) {
 492                 if (rk616->write_dev(rk616, reg, &new_value) < 0) {
 493                         printk("%s : reg = 0x%x failed\n", __func__, reg);
 494                         return -EIO;
 495                 }
 496                 value = new_value;
 497         }
 498
 499         rk616_write_reg_cache(codec, reg, value);
 500
 501         DBG("%s : reg = 0x%x, val = 0x%x\n", __func__, reg, value);
 502         return 0;
 503 }
 504
 505 static int rk616_hw_write(const struct i2c_client *client, const char *buf, int count)
 506 {
 507         struct rk616_codec_priv *rk616 = rk616_priv;
 508         struct snd_soc_codec *codec;
 509         unsigned int reg, value;
 510         int ret = -1;
 511
 512         if (!rk616 || !rk616->codec) {
 513                 printk("%s : rk616_priv or rk616_priv->codec is NULL\n", __func__);
 514                 return -EINVAL;
 515         }
 516
 517         codec = rk616->codec;
 518
 519         if (count == 3) {
 520                 reg = (unsigned int)buf[0];
 521                 value = (buf[1] & 0xff00) | (0x00ff & buf[2]);
 522                 ret = rk616_codec_write(codec, reg, value);
 523         } else {
 524                 printk("%s : i2c len error\n", __func__);
 525         }
 526
 527         return (ret == 0) ? count : ret;
 528 }
 529
 530 static int rk616_reset(struct snd_soc_codec *codec)
 531 {
 532         int i;
 533
 534         snd_soc_write(codec, RK616_RESET, 0xfc);
 535         mdelay(10);
 536         snd_soc_write(codec, RK616_RESET, 0x43);
 537         mdelay(10);
 538
 539         for (i = 0; i < RK616_MFD_REG_LEN; i++)
 540                 snd_soc_write(codec, rk616_mfd_reg_defaults[i].reg,
 541                         rk616_mfd_reg_defaults[i].value);
 542
 543         memcpy(codec->reg_cache, rk616_reg_defaults,
 544                sizeof(rk616_reg_defaults));
 545
 546         //close charge pump
 547         snd_soc_write(codec, RK616_CLK_CHPUMP, 0x41);
 548
 549         //bypass zero-crossing detection
 550         snd_soc_write(codec, RK616_SINGNAL_ZC_CTL1, 0x3f);
 551         snd_soc_write(codec, RK616_SINGNAL_ZC_CTL2, 0xff);
 552
 553         //set ADC Power for MICBIAS
 554         snd_soc_update_bits(codec, RK616_PWR_ADD1,
 555                 RK616_ADC_PWRD, 0);
 556
 557         return 0;
 558 }
 559
 560 static int rk616_set_gpio(int gpio, bool level)
 561 {
 562         struct rk616_codec_priv *rk616 = rk616_priv;
 563
 564         if (!rk616) {
 565                 printk("%s : rk616_priv is NULL\n", __func__);
 566                 return 0;
 567         }
 568
 569         DBG("%s : set %s %s %s %s ctl gpio %s\n", __func__,
 570                 gpio & RK616_CODEC_SET_SPK ? "spk" : "",
 571                 gpio & RK616_CODEC_SET_HP ? "hp" : "",
 572                 gpio & RK616_CODEC_SET_RCV ? "rcv" : "",
 573                 gpio & RK616_CODEC_SET_MIC ? "mic" : "",
 574                 level ? "HIGH" : "LOW");
 575
 576         if ((gpio & RK616_CODEC_SET_SPK) && rk616 && rk616->spk_ctl_gpio != INVALID_GPIO) {
 577                 gpio_set_value(rk616->spk_ctl_gpio, level);
 578         }
 579
 580         if ((gpio & RK616_CODEC_SET_HP) && rk616 && rk616->hp_ctl_gpio != INVALID_GPIO) {
 581                 gpio_set_value(rk616->hp_ctl_gpio, level);
 582         }
 583
 584         if ((gpio & RK616_CODEC_SET_RCV) && rk616 && rk616->rcv_ctl_gpio != INVALID_GPIO) {
 585                 gpio_set_value(rk616->rcv_ctl_gpio, level);
 586         }
 587
 588         if ((gpio & RK616_CODEC_SET_MIC) && rk616 && rk616->mic_sel_gpio != INVALID_GPIO) {
 589                 gpio_set_value(rk616->mic_sel_gpio, level);
 590         }
 591
 592         if (gpio & RK616_CODEC_SET_SPK)
 593                 mdelay(SPK_AMP_DELAY);
 594         else if (gpio & RK616_CODEC_SET_HP)
 595                 mdelay(HP_MOS_DELAY);
 596
 597         return 0;
 598 }
 599
 600 bool get_hdmi_state(void)
 601 {
 602         return is_hdmi_in;
 603 }
 604
 605 #ifdef CONFIG_MACH_RK_FAC
 606 void rk616_codec_set_spk(bool on)
 607 #else
 608 void codec_set_spk(bool on)
 609 #endif
 610 {
 611         struct rk616_codec_priv *rk616 = rk616_priv;
 612         struct snd_soc_codec *codec;
 613
 614         DBG("%s : %s\n", __func__, on ? "enable spk" : "disable spk");
 615
 616         if (!rk616 || !rk616->codec) {
 617                 printk("%s : rk616_priv or rk616_priv->codec is NULL\n", __func__);
 618                 return;
 619         }
 620
 621         codec = rk616->codec;
 622
 623         if (on) {
 624                 if (rk616_for_mid)
 625                 {
 626                         snd_soc_update_bits(codec, RK616_SPKL_CTL,
 627                                 RK616_MUTE, 0);
 628                         snd_soc_update_bits(codec, RK616_SPKR_CTL,
 629                                 RK616_MUTE, 0);
 630                         snd_soc_update_bits(codec, RK616_HPL_CTL,
 631                                 RK616_MUTE, 0);
 632                         snd_soc_update_bits(codec, RK616_HPR_CTL,
 633                                 RK616_MUTE, 0);
 634                 }
 635                 else
 636                 {
 637                         mutex_lock(&codec->mutex);
 638                         snd_soc_dapm_enable_pin(&codec->dapm, "Headphone Jack");
 639                         snd_soc_dapm_enable_pin(&codec->dapm, "Ext Spk");
 640                         snd_soc_dapm_sync(&codec->dapm);
 641                         mutex_unlock(&codec->mutex);
 642                 }
 643         } else {
 644                 rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_LOW);
 645
 646                 if (rk616_for_mid)
 647                 {
 648                         snd_soc_update_bits(codec, RK616_SPKL_CTL,
 649                                 RK616_MUTE, RK616_MUTE);
 650                         snd_soc_update_bits(codec, RK616_SPKR_CTL,
 651                                 RK616_MUTE, RK616_MUTE);
 652                         snd_soc_update_bits(codec, RK616_HPL_CTL,
 653                                 RK616_MUTE, RK616_MUTE);
 654                         snd_soc_update_bits(codec, RK616_HPR_CTL,
 655                                 RK616_MUTE, RK616_MUTE);
 656                 }
 657                 else
 658                 {
 659                         mutex_lock(&codec->mutex);
 660                         snd_soc_dapm_disable_pin(&codec->dapm, "Headphone Jack");
 661                         snd_soc_dapm_disable_pin(&codec->dapm, "Ext Spk");
 662                         snd_soc_dapm_sync(&codec->dapm);
 663                         mutex_unlock(&codec->mutex);
 664                 }
 665         }
 666
 667         is_hdmi_in = on ? 0 : 1;
 668 }
 669 #ifdef CONFIG_MACH_RK_FAC
 670 EXPORT_SYMBOL_GPL(rk616_codec_set_spk);
 671 #else
 672 EXPORT_SYMBOL_GPL(codec_set_spk);
 673 #endif
 674
 675 static struct rk616_reg_val_typ playback_power_up_list[] = {
 676         {0x804, 0x46}, //DAC DSM, 0x06: x1, 0x26: x1.25, 0x46: x1.5, 0x66: x1.75
 677         {0x868, 0x02}, //power up
 678         {0x86c, 0x0f}, //DACL/R UN INIT
 679         {0x86c, 0x00}, //DACL/R and DACL/R CLK power up
 680         {0x86c, 0x30}, //DACL/R INIT
 681         {0x874, 0x14}, //Mux HPMIXR from HPMIXR(bit 0), Mux HPMIXL from HPMIXL(bit 1),HPMIXL/R power up
 682         {0x878, 0xee}, //HPMIXL/HPMIXR from DACL/DACR(bit 4, bit 0)
 683 #ifdef VIRTUAL_HPGND
 684         {0x898, 3<<5}, //power up HPOUTR (bit 7), volume (bit 0-4)
 685         {0x894, 3<<5}, //power up HPOUTL (bit 7), volume (bit 0-4)
 686         {0x898, 0x00}, //unmute HPOUTR (bit 5), volume (bit 0-4)
 687         {0x894, 0x00}, //unmute HPOUTL (bit 5), volume (bit 0-4)
 688 #endif
 689         {0x88c, 3<<5|SPKOUT_VOLUME},//power up SPKOUTL (bit 7), volume (bit 0-4)
 690         {0x890, 3<<5|SPKOUT_VOLUME}, //power up SPKOUTR (bit 7), volume (bit 0-4)
 691         {0x88c, SPKOUT_VOLUME}, //unmute SPKOUTL (bit 5), volume (bit 0-4)
 692         {0x890, SPKOUT_VOLUME}, //unmute SPKOUTR (bit 5), volume (bit 0-4)
 693 };
 694 #define RK616_CODEC_PLAYBACK_POWER_UP_LIST_LEN ARRAY_SIZE(playback_power_up_list)
 695
 696 static struct rk616_reg_val_typ playback_power_down_list[] = {
 697         {0x898, 0xe0}, //mute HPOUTR (bit 5), volume (bit 0-4)
 698         {0x894, 0xe0}, //mute HPOUTL (bit 5), volume (bit 0-4)
 699         {0x890, 0xe0}, //mute SPKOUTR (bit 5), volume (bit 0-4)
 700         {0x88c, 0xe0}, //mute SPKOUTL (bit 5), volume (bit 0-4)
 701         {0x878, 0xff}, //HPMIXL/HPMIXR from DACL/DACR(bit 4, bit 0)
 702         {0x874, 0x3c}, //Power down HPMIXL/R
 703         {0x86c, 0x3f}, //DACL/R INIT
 704         {0x868, 0xff}, //power down
 705 };
 706 #define RK616_CODEC_PLAYBACK_POWER_DOWN_LIST_LEN ARRAY_SIZE(playback_power_down_list)
 707
 708 static struct rk616_reg_val_typ capture_power_up_list[] = {
 709         {0x848, 0x06}, //MIXINL power up and unmute, MININL from MICMUX, MICMUX from BST_L
 710         {0x84c, 0x3c}, //MIXINL from MIXMUX volume (bit 3-5)
 711         {0x860, CAPTURE_VOL}, //PGAL power up unmute,volume (bit 0-4)
 712         {0x828, 0x09}, //Set for Capture pop noise
 713         {0x83c, 0x00}, //power up
 714         {0x840, 0x69}, //BST_L power up, unmute, and Single-Ended(bit 6), volume 0-20dB(bit 5)
 715         {0x8a8, 0x09}, //ADCL/R power, and clear ADCL/R buf
 716         {0x8a8, 0x00}, //ADCL/R power, and clear ADCL/R buf
 717 };
 718 #define RK616_CODEC_CAPTURE_POWER_UP_LIST_LEN ARRAY_SIZE(capture_power_up_list)
 719
 720 static struct rk616_reg_val_typ capture_power_down_list[] = {
 721         {0x8a8, 0x3f}, //ADCL/R power down, and clear ADCL/R buf
 722         {0x860, 0xc0 | CAPTURE_VOL}, //PGAL power down ,mute,volume 0dB(bit 0-4)
 723         {0x84c, 0x3c}, //MIXINL from MIXMUX volume 0dB(bit 3-5)
 724         {0x848, 0x1f}, //MIXINL power down and mute, MININL No selecting, MICMUX from BST_L
 725         {0x840, 0x99}, //BST_L power down, mute, and Single-Ended(bit 6), volume 0(bit 5)
 726         {0x83c, 0x3c}, //power down
 727 };
 728 #define RK616_CODEC_CAPTURE_POWER_DOWN_LIST_LEN ARRAY_SIZE(capture_power_down_list)
 729
 730 static int rk616_codec_power_up(int type)
 731 {
 732         struct rk616_codec_priv *rk616 = rk616_priv;
 733         struct snd_soc_codec *codec;
 734         int i;
 735
 736         if (!rk616 || !rk616->codec) {
 737                 printk("%s : rk616_priv or rk616_priv->codec is NULL\n", __func__);
 738                 return -EINVAL;
 739         }
 740
 741         codec = rk616->codec;
 742
 743         printk("%s : power up %s %s %s\n", __func__,
 744                 type & RK616_CODEC_PLAYBACK ? "playback" : "",
 745                 type & RK616_CODEC_CAPTURE ? "capture" : "",
 746                 type & RK616_CODEC_INCALL ? "incall" : "");
 747
 748         // mute output for pop noise
 749         if ((type & RK616_CODEC_PLAYBACK) ||
 750                 (type & RK616_CODEC_INCALL)) {
 751                 rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_LOW);
 752         }
 753
 754         if (type & RK616_CODEC_PLAYBACK) {
 755                 for (i = 0; i < RK616_CODEC_PLAYBACK_POWER_UP_LIST_LEN; i++) {
 756                         snd_soc_write(codec, playback_power_up_list[i].reg,
 757                                 playback_power_up_list[i].value);
 758                 }
 759                 #ifdef CONFIG_MACH_RK_FAC
 760                         rk616_codec_set_spk(!get_hdmi_state());
 761                 #else
 762                         codec_set_spk(!get_hdmi_state());
 763                 #endif
 764         }
 765
 766         if (type & RK616_CODEC_CAPTURE) {
 767                 for (i = 0; i < RK616_CODEC_CAPTURE_POWER_UP_LIST_LEN; i++) {
 768                         snd_soc_write(codec, capture_power_up_list[i].reg,
 769                                 capture_power_up_list[i].value);
 770                 }
 771         }
 772
 773         if (type & RK616_CODEC_INCALL) {
 774                 snd_soc_update_bits(codec, RK616_PGA_AGC_CTL,
 775                         0x0f, 0x09); //set for capture pop noise
 776                 if (rk616->modem_input_enable != OFF)
 777                         snd_soc_update_bits(codec, RK616_MIXINL_CTL,
 778                                 RK616_MIL_F_IN3L | RK616_MIL_MUTE | RK616_MIL_PWRD,
 779                                 0); //IN3L to MIXINL, unmute IN3L
 780                 else
 781                         snd_soc_update_bits(codec, RK616_MIXINL_CTL,
 782                                 RK616_MIL_F_IN3L | RK616_MIL_PWRD,
 783                                 0); //IN3L to MIXINL
 784                 snd_soc_update_bits(codec, RK616_PWR_ADD1,
 785                         RK616_ADC_PWRD | RK616_DIFFIN_MIR_PGAR_RLPWRD |
 786                         RK616_MIC1_MIC2_MIL_PGAL_RLPWRD |
 787                         RK616_ADCL_RLPWRD | RK616_ADCR_RLPWRD, 0);
 788                 snd_soc_update_bits(codec, RK616_MIXINL_VOL2,
 789                         RK616_MIL_F_IN3L_VOL_MASK, 0); //IN3L to MIXINL vol
 790                 snd_soc_update_bits(codec, RK616_PGAL_CTL,
 791                         0xff, 0x15); //PU unmute PGAL,PGAL vol
 792                 snd_soc_update_bits(codec, RK616_HPMIX_CTL,
 793                         RK616_HML_F_PGAL | RK616_HMR_F_PGAL, 0);
 794                 //set min volume for incall voice volume setting
 795                 snd_soc_update_bits(codec, RK616_SPKL_CTL,
 796                         RK616_VOL_MASK, 0); //, volume (bit 0-4)
 797                 snd_soc_update_bits(codec, RK616_SPKR_CTL,
 798                         RK616_VOL_MASK, 0);
 799         }
 800
 801         return 0;
 802 }
 803
 804 static int rk616_codec_power_down(int type)
 805 {
 806         struct rk616_codec_priv *rk616 = rk616_priv;
 807         struct snd_soc_codec *codec;
 808         int i;
 809
 810         if (!rk616 || !rk616->codec) {
 811                 printk("%s : rk616_priv or rk616_priv->codec is NULL\n", __func__);
 812                 return -EINVAL;
 813         }
 814
 815         codec = rk616->codec;
 816
 817         printk("%s : power down %s %s %s\n", __func__,
 818                 type & RK616_CODEC_PLAYBACK ? "playback" : "",
 819                 type & RK616_CODEC_CAPTURE ? "capture" : "",
 820                 type & RK616_CODEC_INCALL ? "incall" : "");
 821
 822         // mute output for pop noise
 823         if ((type & RK616_CODEC_PLAYBACK) ||
 824                 (type & RK616_CODEC_INCALL)) {
 825                 rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_LOW);
 826         }
 827
 828         if (type & RK616_CODEC_CAPTURE) {
 829                 for (i = 0; i < RK616_CODEC_CAPTURE_POWER_DOWN_LIST_LEN; i++) {
 830                         snd_soc_write(codec, capture_power_down_list[i].reg,
 831                                 capture_power_down_list[i].value);
 832                 }
 833         }
 834
 835         if (type & RK616_CODEC_PLAYBACK) {
 836                 for (i = 0; i < RK616_CODEC_PLAYBACK_POWER_DOWN_LIST_LEN; i++) {
 837                         snd_soc_write(codec, playback_power_down_list[i].reg,
 838                                 playback_power_down_list[i].value);
 839                 }
 840         }
 841
 842         if (type & RK616_CODEC_INCALL) {
 843                 //close incall route
 844                 snd_soc_update_bits(codec, RK616_HPMIX_CTL,
 845                         RK616_HML_F_PGAL | RK616_HMR_F_PGAL,
 846                         RK616_HML_F_PGAL | RK616_HMR_F_PGAL);
 847                 snd_soc_update_bits(codec, RK616_PGA_AGC_CTL,
 848                         0x0f, 0x0c);
 849                 snd_soc_update_bits(codec, RK616_MIXINL_CTL,
 850                         RK616_MIL_F_IN3L | RK616_MIL_MUTE | RK616_MIL_PWRD,
 851                         RK616_MIL_F_IN3L | RK616_MIL_MUTE | RK616_MIL_PWRD);
 852                 snd_soc_update_bits(codec, RK616_MIXINL_VOL2,
 853                         RK616_MIL_F_IN3L_VOL_MASK, 0);
 854                 snd_soc_update_bits(codec, RK616_PGAL_CTL,
 855                         0xff, 0xd5);
 856         }
 857
 858         return 0;
 859 }
 860 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -3900, 150, 0);
 861 static const DECLARE_TLV_DB_SCALE(pga_vol_tlv, -1800, 150, 0);
 862 static const DECLARE_TLV_DB_SCALE(bst_vol_tlv, 0, 2000, 0);
 863 static const DECLARE_TLV_DB_SCALE(mix_vol_tlv, -1200, 300, 0);
 864 static const DECLARE_TLV_DB_SCALE(pga_agc_max_vol_tlv, -1350, 600, 0);
 865 static const DECLARE_TLV_DB_SCALE(pga_agc_min_vol_tlv, -1800, 600, 0);
 866
 867 static const char *rk616_input_mode[] = {"Differential", "Single-Ended"};
 868
 869 static const char *rk616_micbias_ratio[] = {"1.0 Vref", "1.1 Vref",
 870                 "1.2 Vref", "1.3 Vref", "1.4 Vref", "1.5 Vref", "1.6 Vref", "1.7 Vref",};
 871
 872 static const char *rk616_dis_en_sel[] = {"Disable", "Enable"};
 873
 874 static const char *rk616_mickey_range[] = {"100uA", "300uA",
 875                 "500uA", "700uA", "900uA", "1100uA", "1300uA", "1500uA"};
 876
 877 static const char *rk616_pga_gain_control[] = {"Normal", "AGC"};
 878
 879 static const char *rk616_pga_agc_way[] = {"Normal", "Jack"};
 880
 881 static const char *rk616_pga_agc_hold_time[] = {"0ms", "2ms",
 882                 "4ms", "8ms", "16ms", "32ms", "64ms", "128ms", "256ms", "512ms", "1s"};
 883
 884 static const char *rk616_pga_agc_ramp_up_time[] = {"500us", "1ms", "2ms",
 885                 "4ms", "8ms", "16ms", "32ms", "64ms", "128ms", "256ms", "512ms"};
 886
 887 static const char *rk616_pga_agc_ramp_down_time[] = {"Normal:125us Jack:32us",
 888                 "Normal:250us Jack:64us", "Normal:500us Jack:125us", "Normal:1ms Jack:250us",
 889                 "Normal:2ms Jack:500us", "Normal:4ms Jack:1ms", "Normal:8ms Jack:2ms",
 890                 "Normal:16ms Jack:4ms", "Normal:32ms Jack:8ms", "Normal:64ms Jack:16ms",
 891                 "Normal:128ms Jack:32ms"};
 892
 893 static const char *rk616_pga_agc_mode[] = {"Normal", "Limiter"};
 894
 895 static const char *rk616_pga_agc_recovery_mode[] = {"Right Now", "After AGC to Limiter"};
 896
 897 static const char *rk616_pga_agc_noise_gate_threhold[] = {"-39dB", "-45dB", "-51dB",
 898                 "-57dB", "-63dB", "-69dB", "-75dB", "-81dB"};
 899
 900 static const char *rk616_pga_agc_update_gain[] = {"Right Now", "After 1st Zero Cross"};
 901
 902 static const char *rk616_pga_agc_approximate_sample_rate[] = {"48KHz", "32KHz",
 903                 "24KHz", "16KHz", "12KHz", "8KHz"};
 904
 905 static const char *rk616_gpio_sel[] = {"Low", "High"};
 906
 907 static const struct soc_enum rk616_bst_enum[] = {
 908 SOC_ENUM_SINGLE(RK616_BST_CTL, RK616_BSTL_MODE_SFT, 2, rk616_input_mode),
 909 SOC_ENUM_SINGLE(RK616_BST_CTL, RK616_BSTR_MODE_SFT, 2, rk616_input_mode),
 910 };
 911
 912 static const struct soc_enum rk616_diffin_enum =
 913         SOC_ENUM_SINGLE(RK616_DIFFIN_CTL, RK616_DIFFIN_MODE_SFT, 2, rk616_input_mode);
 914
 915 static const struct soc_enum rk616_micbias_enum[] = {
 916 SOC_ENUM_SINGLE(RK616_MICBIAS_CTL, RK616_MICBIAS1_V_SFT, 8, rk616_micbias_ratio),
 917 SOC_ENUM_SINGLE(RK616_MICBIAS_CTL, RK616_MICBIAS2_V_SFT, 8, rk616_micbias_ratio),
 918 };
 919
 920 static const struct soc_enum rk616_mickey_enum[] = {
 921 SOC_ENUM_SINGLE(RK616_MICKEY_DET_CTL, RK616_MK1_DET_SFT, 2, rk616_dis_en_sel),
 922 SOC_ENUM_SINGLE(RK616_MICKEY_DET_CTL, RK616_MK2_DET_SFT, 2, rk616_dis_en_sel),
 923 SOC_ENUM_SINGLE(RK616_MICKEY_DET_CTL, RK616_MK1_DET_I_SFT, 8, rk616_mickey_range),
 924 SOC_ENUM_SINGLE(RK616_MICKEY_DET_CTL, RK616_MK2_DET_I_SFT, 8, rk616_mickey_range),
 925 };
 926
 927 static const struct soc_enum rk616_agcl_enum[] = {
 928 SOC_ENUM_SINGLE(RK616_PGA_AGC_CTL, RK616_PGAL_AGC_EN_SFT, 2, rk616_pga_gain_control),/*0*/
 929 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL1, RK616_PGA_AGC_WAY_SFT, 2, rk616_pga_agc_way),/*1*/
 930 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL1, RK616_PGA_AGC_HOLD_T_SFT, 11, rk616_pga_agc_hold_time),/*2*/
 931 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL2, RK616_PGA_AGC_GRU_T_SFT, 11, rk616_pga_agc_ramp_up_time),/*3*/
 932 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL2, RK616_PGA_AGC_GRD_T_SFT, 11, rk616_pga_agc_ramp_down_time),/*4*/
 933 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_MODE_SFT, 2, rk616_pga_agc_mode),/*5*/
 934 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_ZO_SFT, 2, rk616_dis_en_sel),/*6*/
 935 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_REC_MODE_SFT, 2, rk616_pga_agc_recovery_mode),/*7*/
 936 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_FAST_D_SFT, 2, rk616_dis_en_sel),/*8*/
 937 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_NG_SFT, 2, rk616_dis_en_sel),/*9*/
 938 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL3, RK616_PGA_AGC_NG_THR_SFT, 8, rk616_pga_agc_noise_gate_threhold),/*10*/
 939 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL4, RK616_PGA_AGC_ZO_MODE_SFT, 2, rk616_pga_agc_update_gain),/*11*/
 940 SOC_ENUM_SINGLE(RK616_PGAL_ASR_CTL, RK616_PGA_SLOW_CLK_SFT, 2, rk616_dis_en_sel),/*12*/
 941 SOC_ENUM_SINGLE(RK616_PGAL_ASR_CTL, RK616_PGA_ASR_SFT, 6, rk616_pga_agc_approximate_sample_rate),/*13*/
 942 SOC_ENUM_SINGLE(RK616_PGAL_AGC_CTL5, RK616_PGA_AGC_SFT, 2, rk616_dis_en_sel),/*14*/
 943 };
 944
 945 static const struct soc_enum rk616_agcr_enum[] = {
 946 SOC_ENUM_SINGLE(RK616_PGA_AGC_CTL, RK616_PGAR_AGC_EN_SFT, 2, rk616_pga_gain_control),/*0*/
 947 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL1, RK616_PGA_AGC_WAY_SFT, 2, rk616_pga_agc_way),/*1*/
 948 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL1, RK616_PGA_AGC_HOLD_T_SFT, 11, rk616_pga_agc_hold_time),/*2*/
 949 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL2, RK616_PGA_AGC_GRU_T_SFT, 11, rk616_pga_agc_ramp_up_time),/*3*/
 950 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL2, RK616_PGA_AGC_GRD_T_SFT, 11, rk616_pga_agc_ramp_down_time),/*4*/
 951 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_MODE_SFT, 2, rk616_pga_agc_mode),/*5*/
 952 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_ZO_SFT, 2, rk616_dis_en_sel),/*6*/
 953 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_REC_MODE_SFT, 2, rk616_pga_agc_recovery_mode),/*7*/
 954 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_FAST_D_SFT, 2, rk616_dis_en_sel),/*8*/
 955 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_NG_SFT, 2, rk616_dis_en_sel),/*9*/
 956 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL3, RK616_PGA_AGC_NG_THR_SFT, 8, rk616_pga_agc_noise_gate_threhold),/*10*/
 957 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL4, RK616_PGA_AGC_ZO_MODE_SFT, 2, rk616_pga_agc_update_gain),/*11*/
 958 SOC_ENUM_SINGLE(RK616_PGAR_ASR_CTL, RK616_PGA_SLOW_CLK_SFT, 2, rk616_dis_en_sel),/*12*/
 959 SOC_ENUM_SINGLE(RK616_PGAR_ASR_CTL, RK616_PGA_ASR_SFT, 6, rk616_pga_agc_approximate_sample_rate),/*13*/
 960 SOC_ENUM_SINGLE(RK616_PGAR_AGC_CTL5, RK616_PGA_AGC_SFT, 2, rk616_dis_en_sel),/*14*/
 961 };
 962
 963 static const struct soc_enum rk616_loop_enum =
 964         SOC_ENUM_SINGLE(CRU_CFGMISC_CON, AD_DA_LOOP_SFT, 2, rk616_dis_en_sel);
 965
 966 static const struct soc_enum rk616_gpio_enum[] = {
 967         SOC_ENUM_SINGLE(RK616_CODEC_SET_SPK, 0, 2, rk616_gpio_sel),
 968         SOC_ENUM_SINGLE(RK616_CODEC_SET_HP, 0, 2, rk616_gpio_sel),
 969         SOC_ENUM_SINGLE(RK616_CODEC_SET_RCV, 0, 2, rk616_gpio_sel),
 970         SOC_ENUM_SINGLE(RK616_CODEC_SET_MIC, 0, 2, rk616_gpio_sel),
 971 };
 972
 973 int snd_soc_put_pgal_volsw(struct snd_kcontrol *kcontrol,
 974         struct snd_ctl_elem_value *ucontrol)
 975 {
 976         struct soc_mixer_control *mc =
 977                 (struct soc_mixer_control *)kcontrol->private_value;
 978         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
 979         unsigned int val;
 980         int max = mc->max;
 981         unsigned int mask = (1 << fls(max)) - 1;
 982
 983         val = (ucontrol->value.integer.value[0] & mask);
 984
 985         //set for capture pop noise
 986         if (val) {
 987                 snd_soc_update_bits(codec, RK616_PGA_AGC_CTL, 0x0f, 0x09);
 988         }
 989
 990         return snd_soc_put_volsw(kcontrol, ucontrol);
 991 }
 992
 993 //for setting volume pop noise, turn volume step up/down.
 994 int snd_soc_put_step_volsw_2r(struct snd_kcontrol *kcontrol,
 995         struct snd_ctl_elem_value *ucontrol)
 996 {
 997         struct soc_mixer_control *mc =
 998                 (struct soc_mixer_control *)kcontrol->private_value;
 999         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1000         unsigned int reg = mc->reg;
1001         unsigned int reg2 = mc->rreg;
1002         unsigned int shift = mc->shift;
1003         int max = mc->max;
1004         unsigned int mask = (1 << fls(max)) - 1;
1005         unsigned int invert = mc->invert;
1006         int err = 0;
1007         unsigned int val, val2, val_mask, old_l, old_r, old_reg_l, old_reg_r, step = 1;
1008
1009         val_mask = mask << shift;
1010         val = (ucontrol->value.integer.value[0] & mask);
1011         val2 = (ucontrol->value.integer.value[1] & mask);
1012
1013         old_reg_l = snd_soc_read(codec, reg);
1014         if (old_l < 0)
1015                 return old_l;
1016
1017         old_l = (old_reg_l & val_mask) >> shift;
1018
1019         old_reg_r = snd_soc_read(codec, reg);
1020         if (old_r < 0)
1021                 return old_r;
1022
1023         old_r = (old_reg_r & val_mask) >> shift;
1024
1025         old_reg_l &= ~mask;
1026         old_reg_r &= ~mask;
1027
1028         while (old_l != val || old_r != val2) {
1029                 if (old_l != val) {
1030                         if (old_l > val) {
1031                                 old_l -= step;
1032                                 if (old_l < val)
1033                                         old_l = val;
1034                         } else {
1035                                 old_l += step;
1036                                 if (old_l > val)
1037                                         old_l = val;
1038                         }
1039
1040                         if (invert) {
1041                                 old_l = max - old_l;
1042                         }
1043
1044                         old_l = old_l << shift;
1045
1046                         mutex_lock(&codec->mutex);
1047                         err = snd_soc_write(codec, reg, old_reg_l | old_l);
1048                         mutex_unlock(&codec->mutex);
1049                         if (err < 0)
1050                                 return err;
1051                 }
1052                 if (old_r != val2) {
1053                         if (old_r > val2) {
1054                                 old_r -= step;
1055                                 if (old_r < val2)
1056                                         old_r = val2;
1057                         } else {
1058                                 old_r += step;
1059                                 if (old_r > val2)
1060                                         old_r = val2;
1061                         }
1062
1063                         if (invert) {
1064                                 old_r = max - old_r;
1065                         }
1066
1067                         old_r = old_r << shift;
1068
1069                         mutex_lock(&codec->mutex);
1070                         err = snd_soc_write(codec, reg2, old_reg_r | old_r);
1071                         mutex_unlock(&codec->mutex);
1072                         if (err < 0)
1073                                 return err;
1074                 }
1075         }
1076         return err;
1077 }
1078
1079 int snd_soc_get_gpio_enum_double(struct snd_kcontrol *kcontrol,
1080         struct snd_ctl_elem_value *ucontrol)
1081 {
1082         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1083         struct rk616_codec_priv *rk616 = rk616_priv;
1084
1085         if (!rk616) {
1086                 printk("%s : rk616_priv is NULL\n", __func__);
1087                 return -EINVAL;
1088         }
1089
1090         switch(e->reg) {
1091         case RK616_CODEC_SET_SPK:
1092                 ucontrol->value.enumerated.item[0] = rk616->spk_gpio_level;
1093                 break;
1094         case RK616_CODEC_SET_HP:
1095                 ucontrol->value.enumerated.item[0] = rk616->hp_gpio_level;
1096                 break;
1097         case RK616_CODEC_SET_RCV:
1098                 ucontrol->value.enumerated.item[0] = rk616->rcv_gpio_level;
1099                 break;
1100         case RK616_CODEC_SET_MIC:
1101                 ucontrol->value.enumerated.item[0] = rk616->mic_gpio_level;
1102                 break;
1103         default:
1104                 return -EINVAL;
1105         }
1106         return 0;
1107 }
1108
1109 int snd_soc_put_gpio_enum_double(struct snd_kcontrol *kcontrol,
1110         struct snd_ctl_elem_value *ucontrol)
1111 {
1112         struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1113         struct rk616_codec_priv *rk616 = rk616_priv;
1114
1115         if (!rk616) {
1116                 printk("%s : rk616_priv is NULL\n", __func__);
1117                 return -EINVAL;
1118         }
1119
1120         if (ucontrol->value.enumerated.item[0] > e->max - 1)
1121                 return -EINVAL;
1122
1123         //The gpio of SPK HP and RCV will be setting in digital_mute for pop noise.
1124         switch(e->reg) {
1125         case RK616_CODEC_SET_SPK:
1126                 rk616->spk_gpio_level = ucontrol->value.enumerated.item[0];
1127                 break;
1128         case RK616_CODEC_SET_HP:
1129                 rk616->hp_gpio_level = ucontrol->value.enumerated.item[0];
1130                 break;
1131         case RK616_CODEC_SET_RCV:
1132                 rk616->rcv_gpio_level = ucontrol->value.enumerated.item[0];
1133                 break;
1134         case RK616_CODEC_SET_MIC:
1135                 rk616->mic_gpio_level = ucontrol->value.enumerated.item[0];
1136                 return rk616_set_gpio(e->reg, ucontrol->value.enumerated.item[0]);
1137         default:
1138                 return -EINVAL;
1139         }
1140
1141         return 0;
1142 }
1143
1144 #define SOC_DOUBLE_R_STEP_TLV(xname, reg_left, reg_right, xshift, xmax, xinvert, tlv_array) \
1145 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\
1146         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
1147                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
1148         .tlv.p = (tlv_array), \
1149         .info = snd_soc_info_volsw_2r, \
1150         .get = snd_soc_get_volsw_2r, .put = snd_soc_put_step_volsw_2r, \
1151         .private_value = (unsigned long)&(struct soc_mixer_control) \
1152                 {.reg = reg_left, .rreg = reg_right, .shift = xshift, \
1153                 .max = xmax, .platform_max = xmax, .invert = xinvert} }
1154
1155 #define SOC_GPIO_ENUM(xname, xenum) \
1156 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname,\
1157         .info = snd_soc_info_enum_double, \
1158         .get = snd_soc_get_gpio_enum_double, .put = snd_soc_put_gpio_enum_double, \
1159         .private_value = (unsigned long)&xenum }
1160
1161 static const struct snd_kcontrol_new rk616_snd_controls[] = {
1162
1163         //add for incall volume setting
1164         SOC_DOUBLE_R_STEP_TLV("Speaker Playback Volume", RK616_SPKL_CTL,
1165                         RK616_SPKR_CTL, RK616_VOL_SFT, SPKOUT_VOLUME, 0, out_vol_tlv),
1166         SOC_DOUBLE_R_STEP_TLV("Headphone Playback Volume", RK616_HPL_CTL,
1167                         RK616_HPR_CTL, RK616_VOL_SFT, HPOUT_VOLUME, 0, out_vol_tlv),
1168         SOC_DOUBLE_R_STEP_TLV("Earpiece Playback Volume", RK616_SPKL_CTL,
1169                         RK616_SPKR_CTL, RK616_VOL_SFT, SPKOUT_VOLUME, 0, out_vol_tlv),
1170
1171         SOC_DOUBLE_R("Speaker Playback Switch", RK616_SPKL_CTL,
1172                 RK616_SPKR_CTL, RK616_MUTE_SFT, 1, 1),
1173
1174         SOC_DOUBLE_R("Headphone Playback Switch", RK616_HPL_CTL,
1175                 RK616_HPR_CTL, RK616_MUTE_SFT, 1, 1),
1176
1177         SOC_DOUBLE_R("Earpiece Playback Switch", RK616_HPL_CTL,
1178                 RK616_HPR_CTL, RK616_MUTE_SFT, 1, 1),
1179
1180         SOC_SINGLE_TLV("LINEOUT1 Playback Volume", RK616_LINEOUT1_CTL,
1181                 RK616_LINEOUT_VOL_SFT, 31, 0, out_vol_tlv),
1182         SOC_SINGLE("LINEOUT1 Playback Switch", RK616_LINEOUT1_CTL,
1183                 RK616_LINEOUT_MUTE_SFT, 1, 1),
1184         SOC_SINGLE_TLV("LINEOUT2 Playback Volume", RK616_LINEOUT2_CTL,
1185                 RK616_LINEOUT_VOL_SFT, 31, 0, out_vol_tlv),
1186         SOC_SINGLE("LINEOUT2 Playback Switch", RK616_LINEOUT2_CTL,
1187                 RK616_LINEOUT_MUTE_SFT, 1, 1),
1188
1189         SOC_SINGLE_TLV("PGAL Capture Volume", RK616_PGAL_CTL,
1190                 RK616_PGA_VOL_SFT, 31, 0, pga_vol_tlv),//0x0a bit 5 is 0
1191         {
1192         .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = "PGAL Capture Switch", \
1193         .info = snd_soc_info_volsw, .get = snd_soc_get_volsw,\
1194         .put = snd_soc_put_pgal_volsw, \
1195         .private_value =  SOC_SINGLE_VALUE(RK616_PGAL_CTL, RK616_PGA_MUTE_SFT, 1, 1)
1196         },
1197         SOC_SINGLE_TLV("PGAR Capture Volume", RK616_PGAR_CTL,
1198                 RK616_PGA_VOL_SFT, 31, 0, pga_vol_tlv),//0x0a bit 4 is 0
1199         SOC_SINGLE("PGAR Capture Switch", RK616_PGAR_CTL,
1200                 RK616_PGA_MUTE_SFT, 1, 1),
1201
1202         SOC_SINGLE_TLV("DIFFIN Capture Volume", RK616_DIFFIN_CTL,
1203                 RK616_DIFFIN_GAIN_SFT, 1, 0, bst_vol_tlv),
1204         SOC_SINGLE("DIFFIN Capture Switch", RK616_DIFFIN_CTL,
1205                 RK616_DIFFIN_MUTE_SFT, 1, 1),
1206
1207         //Add for set capture mute
1208         SOC_SINGLE_TLV("Main Mic Capture Volume", RK616_BST_CTL,
1209                 RK616_BSTL_GAIN_SFT, 1, 0, bst_vol_tlv),
1210         SOC_SINGLE("Main Mic Capture Switch", RK616_BST_CTL,
1211                 RK616_BSTL_MUTE_SFT, 1, 1),
1212         SOC_SINGLE_TLV("Headset Mic Capture Volume", RK616_BST_CTL,
1213                 RK616_BSTR_GAIN_SFT, 1, 0, bst_vol_tlv),
1214         SOC_SINGLE("Headset Mic Capture Switch", RK616_BST_CTL,
1215                 RK616_BSTR_MUTE_SFT, 1, 1),
1216
1217         SOC_ENUM("BST_L Mode",  rk616_bst_enum[0]),
1218         SOC_ENUM("BST_R Mode",  rk616_bst_enum[1]),
1219         SOC_ENUM("DIFFIN Mode",  rk616_diffin_enum),
1220
1221         SOC_SINGLE_TLV("MUXMIC to MIXINL Volume", RK616_MIXINL_VOL1,
1222                 RK616_MIL_F_MUX_VOL_SFT, 7, 0, mix_vol_tlv),
1223         SOC_SINGLE_TLV("IN1P to MIXINL Volume", RK616_MIXINL_VOL1,
1224                 RK616_MIL_F_IN1P_VOL_SFT, 7, 0, mix_vol_tlv),
1225         SOC_SINGLE_TLV("IN3L to MIXINL Volume", RK616_MIXINL_VOL2,
1226                 RK616_MIL_F_IN3L_VOL_SFT, 7, 0, mix_vol_tlv),
1227
1228         SOC_SINGLE_TLV("MIXINR MUX to MIXINR Volume", RK616_MIXINR_VOL1,
1229                 RK616_MIR_F_MIRM_VOL_SFT, 7, 0, mix_vol_tlv),
1230         SOC_SINGLE_TLV("IN3R to MIXINR Volume", RK616_MIXINR_VOL1,
1231                 RK616_MIR_F_IN3R_VOL_SFT, 7, 0, mix_vol_tlv),
1232         SOC_SINGLE_TLV("MIC2N to MIXINR Volume", RK616_MIXINR_VOL2,
1233                 RK616_MIR_F_MIC2N_VOL_SFT, 7, 0, mix_vol_tlv),
1234         SOC_SINGLE_TLV("IN1P to MIXINR Volume", RK616_MIXINR_VOL2,
1235                 RK616_MIR_F_IN1P_VOL_SFT, 7, 0, mix_vol_tlv),
1236
1237         SOC_SINGLE("MIXINL Switch", RK616_MIXINL_CTL,
1238                 RK616_MIL_MUTE_SFT, 1, 1),
1239         SOC_SINGLE("MIXINR Switch", RK616_MIXINR_CTL,
1240                 RK616_MIR_MUTE_SFT, 1, 1),
1241
1242         SOC_SINGLE_TLV("IN1P to HPMIXL Volume", RK616_HPMIX_VOL1,
1243                 RK616_HML_F_IN1P_VOL_SFT, 7, 0, mix_vol_tlv),
1244         SOC_SINGLE_TLV("HPMIX MUX to HPMIXL Volume", RK616_HPMIX_VOL2,
1245                 RK616_HML_F_HMM_VOL_SFT, 7, 0, mix_vol_tlv),
1246         SOC_SINGLE_TLV("HPMIX MUX to HPMIXR Volume", RK616_HPMIX_VOL2,
1247                 RK616_HMR_F_HMM_VOL_SFT, 7, 0, mix_vol_tlv),
1248
1249         SOC_ENUM("Micbias1 Voltage",  rk616_micbias_enum[0]),
1250         SOC_ENUM("Micbias2 Voltage",  rk616_micbias_enum[1]),
1251
1252         SOC_ENUM("MIC1 Key Detection Enable",  rk616_mickey_enum[0]),
1253         SOC_ENUM("MIC2 Key Detection Enable",  rk616_mickey_enum[1]),
1254         SOC_ENUM("MIC1 Key Range",  rk616_mickey_enum[2]),
1255         SOC_ENUM("MIC2 Key Range",  rk616_mickey_enum[3]),
1256
1257         SOC_ENUM("PGAL Gain Control",  rk616_agcl_enum[0]),
1258         SOC_ENUM("PGAL AGC Way",  rk616_agcl_enum[1]),
1259         SOC_ENUM("PGAL AGC Hold Time",  rk616_agcl_enum[2]),
1260         SOC_ENUM("PGAL AGC Ramp Up Time",  rk616_agcl_enum[3]),
1261         SOC_ENUM("PGAL AGC Ramp Down Time",  rk616_agcl_enum[4]),
1262         SOC_ENUM("PGAL AGC Mode",  rk616_agcl_enum[5]),
1263         SOC_ENUM("PGAL AGC Gain Update Zero Enable",  rk616_agcl_enum[6]),
1264         SOC_ENUM("PGAL AGC Gain Recovery LPGA VOL",  rk616_agcl_enum[7]),
1265         SOC_ENUM("PGAL AGC Fast Decrement Enable",  rk616_agcl_enum[8]),
1266         SOC_ENUM("PGAL AGC Noise Gate Enable",  rk616_agcl_enum[9]),
1267         SOC_ENUM("PGAL AGC Noise Gate Threhold",  rk616_agcl_enum[10]),
1268         SOC_ENUM("PGAL AGC Upate Gain",  rk616_agcl_enum[11]),
1269         SOC_ENUM("PGAL AGC Slow Clock Enable",  rk616_agcl_enum[12]),
1270         SOC_ENUM("PGAL AGC Approximate Sample Rate",  rk616_agcl_enum[13]),
1271         SOC_ENUM("PGAL AGC Enable",  rk616_agcl_enum[14]),
1272
1273         SOC_SINGLE_TLV("PGAL AGC Volume", RK616_PGAL_AGC_CTL4,
1274                 RK616_PGA_AGC_VOL_SFT, 31, 0, pga_vol_tlv),//AGC disable and 0x0a bit 5 is 1
1275
1276         SOC_SINGLE("PGAL AGC Max Level High 8 Bits", RK616_PGAL_AGC_MAX_H,
1277                 0, 255, 0),
1278         SOC_SINGLE("PGAL AGC Max Level Low 8 Bits", RK616_PGAL_AGC_MAX_L,
1279                 0, 255, 0),
1280         SOC_SINGLE("PGAL AGC Min Level High 8 Bits", RK616_PGAL_AGC_MIN_H,
1281                 0, 255, 0),
1282         SOC_SINGLE("PGAL AGC Min Level Low 8 Bits", RK616_PGAL_AGC_MIN_L,
1283                 0, 255, 0),
1284
1285         SOC_SINGLE_TLV("PGAL AGC Max Gain", RK616_PGAL_AGC_CTL5,
1286                 RK616_PGA_AGC_MAX_G_SFT, 7, 0, pga_agc_max_vol_tlv),//AGC enable and 0x0a bit 5 is 1
1287         SOC_SINGLE_TLV("PGAL AGC Min Gain", RK616_PGAL_AGC_CTL5,
1288                 RK616_PGA_AGC_MIN_G_SFT, 7, 0, pga_agc_min_vol_tlv),//AGC enable and 0x0a bit 5 is 1
1289
1290         SOC_ENUM("PGAR Gain Control",  rk616_agcr_enum[0]),
1291         SOC_ENUM("PGAR AGC Way",  rk616_agcr_enum[1]),
1292         SOC_ENUM("PGAR AGC Hold Time",  rk616_agcr_enum[2]),
1293         SOC_ENUM("PGAR AGC Ramp Up Time",  rk616_agcr_enum[3]),
1294         SOC_ENUM("PGAR AGC Ramp Down Time",  rk616_agcr_enum[4]),
1295         SOC_ENUM("PGAR AGC Mode",  rk616_agcr_enum[5]),
1296         SOC_ENUM("PGAR AGC Gain Update Zero Enable",  rk616_agcr_enum[6]),
1297         SOC_ENUM("PGAR AGC Gain Recovery LPGA VOL",  rk616_agcr_enum[7]),
1298         SOC_ENUM("PGAR AGC Fast Decrement Enable",  rk616_agcr_enum[8]),
1299         SOC_ENUM("PGAR AGC Noise Gate Enable",  rk616_agcr_enum[9]),
1300         SOC_ENUM("PGAR AGC Noise Gate Threhold",  rk616_agcr_enum[10]),
1301         SOC_ENUM("PGAR AGC Upate Gain",  rk616_agcr_enum[11]),
1302         SOC_ENUM("PGAR AGC Slow Clock Enable",  rk616_agcr_enum[12]),
1303         SOC_ENUM("PGAR AGC Approximate Sample Rate",  rk616_agcr_enum[13]),
1304         SOC_ENUM("PGAR AGC Enable",  rk616_agcr_enum[14]),
1305
1306         SOC_SINGLE_TLV("PGAR AGC Volume", RK616_PGAR_AGC_CTL4,
1307                 RK616_PGA_AGC_VOL_SFT, 31, 0, pga_vol_tlv),//AGC disable and 0x0a bit 4 is 1
1308
1309         SOC_SINGLE("PGAR AGC Max Level High 8 Bits", RK616_PGAR_AGC_MAX_H,
1310                 0, 255, 0),
1311         SOC_SINGLE("PGAR AGC Max Level Low 8 Bits", RK616_PGAR_AGC_MAX_L,
1312                 0, 255, 0),
1313         SOC_SINGLE("PGAR AGC Min Level High 8 Bits", RK616_PGAR_AGC_MIN_H,
1314                 0, 255, 0),
1315         SOC_SINGLE("PGAR AGC Min Level Low 8 Bits", RK616_PGAR_AGC_MIN_L,
1316                 0, 255, 0),
1317
1318         SOC_SINGLE_TLV("PGAR AGC Max Gain", RK616_PGAR_AGC_CTL5,
1319                 RK616_PGA_AGC_MAX_G_SFT, 7, 0, pga_agc_max_vol_tlv),//AGC enable and 0x06 bit 4 is 1
1320         SOC_SINGLE_TLV("PGAR AGC Min Gain", RK616_PGAR_AGC_CTL5,
1321                 RK616_PGA_AGC_MIN_G_SFT, 7, 0, pga_agc_min_vol_tlv),//AGC enable and 0x06 bit 4 is 1
1322
1323         SOC_ENUM("I2S Loop Enable",  rk616_loop_enum),
1324
1325         SOC_GPIO_ENUM("SPK GPIO Control",  rk616_gpio_enum[0]),
1326         SOC_GPIO_ENUM("HP GPIO Control",  rk616_gpio_enum[1]),
1327         SOC_GPIO_ENUM("RCV GPIO Control",  rk616_gpio_enum[2]),
1328         SOC_GPIO_ENUM("MIC GPIO Control",  rk616_gpio_enum[3]),
1329 };
1330
1331 //For tiny alsa playback/capture/voice call path
1332 static const char *rk616_playback_path_mode[] = {"OFF", "RCV", "SPK", "HP", "HP_NO_MIC", "BT", "SPK_HP", //0-6
1333                 "RING_SPK", "RING_HP", "RING_HP_NO_MIC", "RING_SPK_HP"};//7-10
1334
1335 static const char *rk616_capture_path_mode[] = {"MIC OFF", "Main Mic", "Hands Free Mic", "BT Sco Mic"};
1336
1337 static const char *rk616_call_path_mode[] = {"OFF", "RCV", "SPK", "HP", "HP_NO_MIC", "BT"};//0-5
1338
1339 static const char *rk616_modem_input_mode[] = {"OFF", "ON"};
1340
1341 static const SOC_ENUM_SINGLE_DECL(rk616_playback_path_type, 0, 0, rk616_playback_path_mode);
1342
1343 static const SOC_ENUM_SINGLE_DECL(rk616_capture_path_type, 0, 0, rk616_capture_path_mode);
1344
1345 static const SOC_ENUM_SINGLE_DECL(rk616_call_path_type, 0, 0, rk616_call_path_mode);
1346
1347 static const SOC_ENUM_SINGLE_DECL(rk616_modem_input_type, 0, 0, rk616_modem_input_mode);
1348
1349 static int rk616_playback_path_get(struct snd_kcontrol *kcontrol,
1350                 struct snd_ctl_elem_value *ucontrol)
1351 {
1352         struct rk616_codec_priv *rk616 = rk616_priv;
1353
1354         if (!rk616) {
1355                 printk("%s : rk616_priv is NULL\n", __func__);
1356                 return -EINVAL;
1357         }
1358
1359         DBG("%s : playback_path %ld\n", __func__, rk616->playback_path);
1360
1361         ucontrol->value.integer.value[0] = rk616->playback_path;
1362
1363         return 0;
1364 }
1365
1366 static int rk616_playback_path_put(struct snd_kcontrol *kcontrol,
1367                 struct snd_ctl_elem_value *ucontrol)
1368 {
1369         struct rk616_codec_priv *rk616 = rk616_priv;
1370         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1371         long int pre_path;
1372
1373         if (!rk616) {
1374                 printk("%s : rk616_priv is NULL\n", __func__);
1375                 return -EINVAL;
1376         }
1377
1378         if (rk616->playback_path == ucontrol->value.integer.value[0]){
1379                 DBG("%s : playback_path is not changed!\n",__func__);
1380                 return 0;
1381         }
1382
1383         pre_path = rk616->playback_path;
1384         rk616->playback_path = ucontrol->value.integer.value[0];
1385
1386         DBG("%s : set playback_path %ld, pre_path %ld\n", __func__,
1387                 rk616->playback_path, pre_path);
1388
1389         if(get_hdmi_state())
1390                 return 0;
1391
1392         switch (rk616->playback_path) {
1393         case OFF:
1394                 if (pre_path != OFF)
1395                         rk616_codec_power_down(RK616_CODEC_PLAYBACK);
1396                 break;
1397         case RCV:
1398         case SPK_PATH:
1399         case RING_SPK:
1400                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_LOW);
1401
1402                 if (pre_path == OFF)
1403                         rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1404
1405                 snd_soc_update_bits(codec, RK616_SPKL_CTL,
1406                         RK616_VOL_MASK, SPKOUT_VOLUME); //, volume (bit 0-4)
1407                 snd_soc_update_bits(codec, RK616_SPKR_CTL,
1408                         RK616_VOL_MASK, SPKOUT_VOLUME);
1409
1410                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1411                 break;
1412         case HP_PATH:
1413         case HP_NO_MIC:
1414         case RING_HP:
1415         case RING_HP_NO_MIC:
1416                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1417
1418                 if (pre_path == OFF)
1419                         rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1420
1421                 snd_soc_update_bits(codec, RK616_SPKL_CTL,
1422                         RK616_VOL_MASK, HPOUT_VOLUME); //, volume (bit 0-4)
1423                 snd_soc_update_bits(codec, RK616_SPKR_CTL,
1424                         RK616_VOL_MASK, HPOUT_VOLUME);
1425
1426                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1427                 break;
1428         case BT:
1429                 break;
1430         case SPK_HP:
1431         case RING_SPK_HP:
1432                 if (pre_path == OFF)
1433                         rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1434
1435                 snd_soc_update_bits(codec, RK616_SPKL_CTL,
1436                         RK616_VOL_MASK, HPOUT_VOLUME); //, volume (bit 0-4)
1437                 snd_soc_update_bits(codec, RK616_SPKR_CTL,
1438                         RK616_VOL_MASK, HPOUT_VOLUME);
1439
1440                 rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_HIGH);
1441                 break;
1442         default:
1443                 return -EINVAL;
1444         }
1445
1446         return 0;
1447 }
1448
1449 static int rk616_capture_path_get(struct snd_kcontrol *kcontrol,
1450                 struct snd_ctl_elem_value *ucontrol)
1451 {
1452         struct rk616_codec_priv *rk616 = rk616_priv;
1453
1454         if (!rk616) {
1455                 printk("%s : rk616_priv is NULL\n", __func__);
1456                 return -EINVAL;
1457         }
1458
1459         DBG("%s : capture_path %ld\n", __func__,
1460                 rk616->capture_path);
1461
1462         ucontrol->value.integer.value[0] = rk616->capture_path;
1463
1464         return 0;
1465 }
1466
1467 static int rk616_capture_path_put(struct snd_kcontrol *kcontrol,
1468                 struct snd_ctl_elem_value *ucontrol)
1469 {
1470         struct rk616_codec_priv *rk616 = rk616_priv;
1471         long int pre_path;
1472 #if (defined RK616_HPMIC_FROM_LINEIN) || (defined RK616_HPMIC_FROM_MIC2IN)
1473         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1474 #endif
1475
1476         if (!rk616) {
1477                 printk("%s : rk616_priv is NULL\n", __func__);
1478                 return -EINVAL;
1479         }
1480
1481         if (rk616->capture_path == ucontrol->value.integer.value[0]){
1482                 DBG("%s : capture_path is not changed!\n", __func__);
1483                 return 0;
1484         }
1485
1486         pre_path = rk616->capture_path;
1487         rk616->capture_path = ucontrol->value.integer.value[0];
1488
1489         DBG("%s : set capture_path %ld, pre_path %ld\n", __func__,
1490                 rk616->capture_path, pre_path);
1491
1492         switch (rk616->capture_path) {
1493         case MIC_OFF:
1494                 if (pre_path != MIC_OFF)
1495                         rk616_codec_power_down(RK616_CODEC_CAPTURE);
1496                 break;
1497         case Main_Mic:
1498                 if (pre_path == MIC_OFF)
1499                         rk616_codec_power_up(RK616_CODEC_CAPTURE);
1500
1501 #ifdef RK616_HPMIC_FROM_LINEIN
1502                 snd_soc_write(codec, 0x848, 0x06); //MIXINL power up and unmute, MININL from MICMUX, MICMUX from BST_L
1503 #endif
1504
1505 #ifdef RK616_HPMIC_FROM_MIC2IN
1506         snd_soc_write(codec, 0x848, 0x06); //MIXINL power up and unmute, MININL from MICMUX, MICMUX from BST_L
1507         snd_soc_write(codec, 0x840, 0x69); //BST_L power up, unmute, and Single-Ended(bit 6), volume 0-20dB(bit 5)
1508 #endif
1509                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1510                 break;
1511         case Hands_Free_Mic:
1512                 if (pre_path == MIC_OFF)
1513                         rk616_codec_power_up(RK616_CODEC_CAPTURE);
1514
1515 #ifdef RK616_HPMIC_FROM_LINEIN
1516                 snd_soc_write(codec, 0x848, 0x03); //MIXINL power up and unmute, MININL from MICMUX, MICMUX from IN3L
1517 #endif
1518
1519 #ifdef RK616_HPMIC_FROM_MIC2IN
1520         snd_soc_write(codec, 0x848, 0x26); //MIXINL power up and unmute, MININL from MICMUX, MICMUX from BST_R
1521         snd_soc_write(codec, 0x840, 0x96); //BST_R power up, unmute, and Single-Ended(bit 2), volume 0-20dB(bit 1)
1522 #endif
1523                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_LOW);
1524                 break;
1525         case BT_Sco_Mic:
1526                 break;
1527         default:
1528                 return -EINVAL;
1529         }
1530
1531         return 0;
1532 }
1533
1534 static int rk616_voice_call_path_get(struct snd_kcontrol *kcontrol,
1535                 struct snd_ctl_elem_value *ucontrol)
1536 {
1537         struct rk616_codec_priv *rk616 = rk616_priv;
1538
1539         if (!rk616) {
1540                 printk("%s : rk616_priv is NULL\n", __func__);
1541                 return -EINVAL;
1542         }
1543
1544         DBG("%s : voice_call_path %ld\n", __func__,
1545                 rk616->voice_call_path);
1546
1547         ucontrol->value.integer.value[0] = rk616->voice_call_path;
1548
1549         return 0;
1550 }
1551
1552 static int rk616_voice_call_path_put(struct snd_kcontrol *kcontrol,
1553                 struct snd_ctl_elem_value *ucontrol)
1554 {
1555         struct rk616_codec_priv *rk616 = rk616_priv;
1556         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1557         long int pre_path;
1558
1559         if (!rk616) {
1560                 printk("%s : rk616_priv is NULL\n", __func__);
1561                 return -EINVAL;
1562         }
1563
1564         if (rk616->voice_call_path == ucontrol->value.integer.value[0]) {
1565                 DBG("%s : voice_call_path is not changed!\n",__func__);
1566                 return 0;
1567         }
1568
1569         pre_path = rk616->voice_call_path;
1570         rk616->voice_call_path = ucontrol->value.integer.value[0];
1571
1572         DBG("%s : set voice_call_path %ld, pre_path %ld\n", __func__,
1573                 rk616->voice_call_path, pre_path);
1574
1575         //open playback route for incall route and keytone
1576         if (pre_path == OFF && rk616->playback_path == OFF) {
1577                         rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1578         }
1579
1580         switch (rk616->voice_call_path) {
1581         case OFF:
1582                 if (pre_path != RCV &&
1583                         pre_path != BT) {
1584                         rk616_codec_power_down(RK616_CODEC_INCALL);
1585                 }
1586
1587                 if (pre_path == SPK_PATH) {
1588                         rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1589                 } else if (pre_path == HP_PATH || pre_path == HP_NO_MIC) {
1590                         rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1591                 }
1592                 break;
1593         case RCV:
1594                 //set mic for modem
1595                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1596
1597                 //rcv is controled by modem, so close incall route
1598                 if (pre_path != OFF &&
1599                         pre_path != BT) {
1600                         rk616_codec_power_down(RK616_CODEC_INCALL);
1601                 }
1602
1603                 // open spk for key tone
1604                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1605                 break;
1606         case SPK_PATH:
1607                 //set mic for modem
1608                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1609
1610                 //open incall route
1611                 if (pre_path == OFF ||
1612                         pre_path == RCV ||
1613                         pre_path == BT)
1614                         rk616_codec_power_up(RK616_CODEC_INCALL);
1615                 else {
1616                         rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_LOW);
1617
1618                         //set min volume for incall voice volume setting
1619                         snd_soc_update_bits(codec, RK616_SPKL_CTL,
1620                                 RK616_VOL_MASK, 0); //, volume (bit 0-4)
1621                         snd_soc_update_bits(codec, RK616_SPKR_CTL,
1622                                 RK616_VOL_MASK, 0);
1623                 }
1624
1625                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1626                 break;
1627         case HP_PATH:
1628                 //set mic for modem
1629                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_LOW);
1630
1631                 //open incall route
1632                 if (pre_path == OFF ||
1633                         pre_path == RCV ||
1634                         pre_path == BT)
1635                         rk616_codec_power_up(RK616_CODEC_INCALL);
1636                 else {
1637                         rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1638
1639                         //set min volume for incall voice volume setting
1640                         snd_soc_update_bits(codec, RK616_SPKL_CTL,
1641                                 RK616_VOL_MASK, 0); //, volume (bit 0-4)
1642                         snd_soc_update_bits(codec, RK616_SPKR_CTL,
1643                                 RK616_VOL_MASK, 0);
1644                 }
1645
1646                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1647                 break;
1648         case HP_NO_MIC:
1649                 //set mic for modem
1650                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1651
1652                 //open incall route
1653                 if (pre_path == OFF ||
1654                         pre_path == RCV ||
1655                         pre_path == BT)
1656                         rk616_codec_power_up(RK616_CODEC_INCALL);
1657                 else {
1658                         rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1659
1660                         //set min volume for incall voice volume setting
1661                         snd_soc_update_bits(codec, RK616_SPKL_CTL,
1662                                 RK616_VOL_MASK, 0); //, volume (bit 0-4)
1663                         snd_soc_update_bits(codec, RK616_SPKR_CTL,
1664                                 RK616_VOL_MASK, 0);
1665                 }
1666
1667                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1668                 break;
1669         case BT:
1670                 //BT is controled by modem, so close incall route
1671                 if (pre_path != OFF &&
1672                         pre_path != RCV) {
1673                         rk616_codec_power_down(RK616_CODEC_INCALL);
1674                 }
1675
1676                 // open spk for key tone
1677                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1678                 break;
1679         default:
1680                 return -EINVAL;
1681         }
1682
1683         return 0;
1684 }
1685
1686 static int rk616_voip_path_get(struct snd_kcontrol *kcontrol,
1687                 struct snd_ctl_elem_value *ucontrol)
1688 {
1689         struct rk616_codec_priv *rk616 = rk616_priv;
1690
1691         if (!rk616) {
1692                 printk("%s : rk616_priv is NULL\n", __func__);
1693                 return -EINVAL;
1694         }
1695
1696         DBG("%s : voip_path %ld\n", __func__,
1697                 rk616->voip_path);
1698
1699         ucontrol->value.integer.value[0] = rk616->voip_path;
1700
1701         return 0;
1702 }
1703
1704 static int rk616_voip_path_put(struct snd_kcontrol *kcontrol,
1705                 struct snd_ctl_elem_value *ucontrol)
1706 {
1707         struct rk616_codec_priv *rk616 = rk616_priv;
1708         long int pre_path;
1709
1710         if (!rk616) {
1711                 printk("%s : rk616_priv is NULL\n", __func__);
1712                 return -EINVAL;
1713         }
1714
1715         if (rk616->voip_path == ucontrol->value.integer.value[0]) {
1716                 DBG("%s : voip_path is not changed!\n",__func__);
1717                 return 0;
1718         }
1719
1720         pre_path = rk616->voip_path;
1721         rk616->voip_path = ucontrol->value.integer.value[0];
1722
1723         DBG("%s : set voip_path %ld, pre_path %ld\n", __func__,
1724                 rk616->voip_path, pre_path);
1725
1726         switch (rk616->voip_path) {
1727         case OFF:
1728                 if (rk616->playback_path == OFF)
1729                         rk616_codec_power_down(RK616_CODEC_PLAYBACK);
1730                 if (rk616->capture_path == OFF)
1731                         rk616_codec_power_down(RK616_CODEC_CAPTURE);
1732                 break;
1733         case RCV:
1734         case SPK_PATH:
1735                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1736
1737                 if (pre_path == OFF)  {
1738                         if (rk616->playback_path == OFF)
1739                                 rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1740                         else
1741                                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_LOW);
1742
1743                         if (rk616->capture_path == OFF)
1744                                 rk616_codec_power_up(RK616_CODEC_CAPTURE);
1745                 } else
1746                         rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_LOW);
1747
1748                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_HIGH);
1749                 break;
1750         case HP_PATH:
1751                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_LOW);
1752
1753                 if (pre_path == OFF)  {
1754                         if (rk616->playback_path == OFF)
1755                                 rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1756                         else
1757                                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1758
1759                         if (rk616->capture_path == OFF)
1760                                 rk616_codec_power_up(RK616_CODEC_CAPTURE);
1761                 } else
1762                         rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1763
1764                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1765                 break;
1766         case HP_NO_MIC:
1767                 rk616_set_gpio(RK616_CODEC_SET_MIC, GPIO_HIGH);
1768
1769                 if (pre_path == OFF)  {
1770                         if (rk616->playback_path == OFF)
1771                                 rk616_codec_power_up(RK616_CODEC_PLAYBACK);
1772                         else
1773                                 rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1774
1775                         if (rk616->capture_path == OFF)
1776                                 rk616_codec_power_up(RK616_CODEC_CAPTURE);
1777                 } else
1778                         rk616_set_gpio(RK616_CODEC_SET_SPK, GPIO_LOW);
1779
1780                 rk616_set_gpio(RK616_CODEC_SET_HP, GPIO_HIGH);
1781                 break;
1782         case BT:
1783                 break;
1784         default:
1785                 return -EINVAL;
1786         }
1787
1788         return 0;
1789 }
1790
1791 static int rk616_modem_input_get(struct snd_kcontrol *kcontrol,
1792                 struct snd_ctl_elem_value *ucontrol)
1793 {
1794         struct rk616_codec_priv *rk616 = rk616_priv;
1795
1796         if (!rk616) {
1797                 printk("%s : rk616_priv is NULL\n", __func__);
1798                 return -EINVAL;
1799         }
1800
1801         DBG("%s : modem_input_enable %ld\n", __func__,
1802                 rk616->modem_input_enable);
1803
1804         ucontrol->value.integer.value[0] = rk616->modem_input_enable;
1805
1806         return 0;
1807 }
1808
1809 static int rk616_modem_input_put(struct snd_kcontrol *kcontrol,
1810                 struct snd_ctl_elem_value *ucontrol)
1811 {
1812         struct rk616_codec_priv *rk616 = rk616_priv;
1813         struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol);
1814         int set_gpio = 0;
1815
1816         if (!rk616) {
1817                 printk("%s : rk616_priv is NULL\n", __func__);
1818                 return -EINVAL;
1819         }
1820
1821         if (rk616->modem_input_enable == ucontrol->value.integer.value[0]) {
1822                 DBG("%s : modem_input_enable: %ld is not changed!\n", __func__, rk616->modem_input_enable);
1823                 return 0;
1824         }
1825
1826         rk616->modem_input_enable = ucontrol->value.integer.value[0];
1827
1828         DBG("%s : modem_input_enable %ld\n", __func__,
1829                 rk616->modem_input_enable);
1830
1831         switch (rk616->voice_call_path) {
1832         case OFF:
1833                 break;
1834         case RCV:
1835         case SPK_PATH:
1836         case BT:
1837                 set_gpio = RK616_CODEC_SET_SPK;
1838                 break;
1839         case HP_PATH:
1840         case HP_NO_MIC:
1841                 set_gpio = RK616_CODEC_SET_HP;
1842                 break;
1843         default:
1844                 return -EINVAL;
1845         }
1846
1847         if (rk616->modem_input_enable == OFF) {
1848                 if (set_gpio != 0)
1849                         rk616_set_gpio(set_gpio, GPIO_LOW);
1850
1851                 snd_soc_update_bits(codec, RK616_MIXINL_CTL,
1852                         RK616_MIL_MUTE, RK616_MIL_MUTE);
1853
1854                 if (set_gpio != 0)
1855                         rk616_set_gpio(set_gpio, GPIO_HIGH);
1856         } else {
1857                 if (set_gpio != 0)
1858                         rk616_set_gpio(set_gpio, GPIO_LOW);
1859
1860                 snd_soc_update_bits(codec, RK616_MIXINL_CTL,
1861                         RK616_MIL_MUTE, 0);
1862
1863                 if (set_gpio != 0)
1864                         rk616_set_gpio(set_gpio, GPIO_HIGH);
1865         }
1866
1867         return 0;
1868 }
1869
1870 static const struct snd_kcontrol_new rk616_snd_path_controls[] = {
1871         SOC_ENUM_EXT("Playback Path", rk616_playback_path_type,
1872                 rk616_playback_path_get, rk616_playback_path_put),
1873
1874         SOC_ENUM_EXT("Capture MIC Path", rk616_capture_path_type,
1875                 rk616_capture_path_get, rk616_capture_path_put),
1876
1877         SOC_ENUM_EXT("Voice Call Path", rk616_call_path_type,
1878                 rk616_voice_call_path_get, rk616_voice_call_path_put),
1879
1880         SOC_ENUM_EXT("Voip Path", rk616_call_path_type,
1881                 rk616_voip_path_get, rk616_voip_path_put),
1882
1883         //add for incall volume setting
1884         SOC_DOUBLE_R_STEP_TLV("Speaker Playback Volume", RK616_SPKL_CTL,
1885                         RK616_SPKR_CTL, RK616_VOL_SFT, SPKOUT_VOLUME, 0, out_vol_tlv),
1886         SOC_DOUBLE_R_STEP_TLV("Headphone Playback Volume", RK616_SPKL_CTL,
1887                         RK616_SPKR_CTL, RK616_VOL_SFT, HPOUT_VOLUME, 0, out_vol_tlv),
1888         //Earpiece incall volume is setting by modem
1889         //SOC_DOUBLE_R_STEP_TLV("Earpiece Playback Volume", RK616_SPKL_CTL,
1890                         //RK616_SPKR_CTL, RK616_VOL_SFT, SPKOUT_VOLUME, 0, out_vol_tlv),
1891
1892         /*
1893         * When modem connecting, it will make some pop noise.
1894         * So, add this control for modem. Modem will set 'OFF'
1895         * before incall connected, and set 'ON' after connected.
1896         */
1897         SOC_ENUM_EXT("Modem Input Enable", rk616_modem_input_type,
1898                 rk616_modem_input_get, rk616_modem_input_put),
1899 };
1900
1901 static int rk616_dacl_event(struct snd_soc_dapm_widget *w,
1902         struct snd_kcontrol *kcontrol, int event)
1903 {
1904         struct snd_soc_codec *codec = w->codec;
1905
1906         switch (event) {
1907         case SND_SOC_DAPM_POST_PMU:
1908                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1909                         RK616_DACL_INIT_MASK, 0);
1910                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1911                         RK616_DACL_PWRD | RK616_DACL_CLK_PWRD |
1912                         RK616_DACL_INIT_MASK, 0);
1913                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1914                         RK616_DACL_INIT_MASK, RK616_DACL_INIT_WORK);
1915                 break;
1916
1917         case SND_SOC_DAPM_POST_PMD:
1918                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1919                         RK616_DACL_PWRD | RK616_DACL_CLK_PWRD |
1920                         RK616_DACL_INIT_MASK,
1921                         RK616_DACL_PWRD | RK616_DACL_CLK_PWRD |
1922                         RK616_DACL_INIT_WORK);
1923                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1924                         RK616_DACL_INIT_MASK, 0);
1925                 break;
1926
1927         default:
1928                 return 0;
1929         }
1930
1931         return 0;
1932 }
1933
1934 static int rk616_dacr_event(struct snd_soc_dapm_widget *w,
1935         struct snd_kcontrol *kcontrol, int event)
1936 {
1937         struct snd_soc_codec *codec = w->codec;
1938
1939         switch (event) {
1940         case SND_SOC_DAPM_POST_PMU:
1941                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1942                         RK616_DACR_INIT_MASK, 0);
1943                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1944                         RK616_DACR_PWRD | RK616_DACR_CLK_PWRD |
1945                         RK616_DACR_INIT_MASK, 0);
1946                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1947                         RK616_DACR_INIT_MASK, RK616_DACR_INIT_WORK);
1948                 break;
1949
1950         case SND_SOC_DAPM_POST_PMD:
1951                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1952                         RK616_DACR_PWRD | RK616_DACR_CLK_PWRD |
1953                         RK616_DACR_INIT_MASK,
1954                         RK616_DACR_PWRD | RK616_DACR_CLK_PWRD |
1955                         RK616_DACR_INIT_WORK);
1956                 snd_soc_update_bits(codec, RK616_DAC_CTL,
1957                         RK616_DACR_INIT_MASK, 0);
1958                 break;
1959
1960         default:
1961                 return 0;
1962         }
1963
1964         return 0;
1965 }
1966
1967 static int rk616_adcl_event(struct snd_soc_dapm_widget *w,
1968         struct snd_kcontrol *kcontrol, int event)
1969 {
1970         struct snd_soc_codec *codec = w->codec;
1971
1972         switch (event) {
1973         case SND_SOC_DAPM_POST_PMU:
1974                 snd_soc_update_bits(codec, RK616_ADC_CTL,
1975                         RK616_ADCL_CLK_PWRD | RK616_ADCL_PWRD, 0);
1976                 break;
1977
1978         case SND_SOC_DAPM_POST_PMD:
1979                 snd_soc_update_bits(codec, RK616_ADC_CTL,
1980                         RK616_ADCL_CLK_PWRD | RK616_ADCL_PWRD,
1981                         RK616_ADCL_CLK_PWRD | RK616_ADCL_PWRD);
1982                 break;
1983
1984         default:
1985                 return 0;
1986         }
1987
1988         return 0;
1989 }
1990
1991 static int rk616_adcr_event(struct snd_soc_dapm_widget *w,
1992         struct snd_kcontrol *kcontrol, int event)
1993 {
1994         struct snd_soc_codec *codec = w->codec;
1995
1996         switch (event) {
1997         case SND_SOC_DAPM_POST_PMU:
1998                 snd_soc_update_bits(codec, RK616_ADC_CTL,
1999                         RK616_ADCR_CLK_PWRD | RK616_ADCR_PWRD, 0);
2000                 break;
2001
2002         case SND_SOC_DAPM_POST_PMD:
2003                 snd_soc_update_bits(codec, RK616_ADC_CTL,
2004                         RK616_ADCR_CLK_PWRD | RK616_ADCR_PWRD,
2005                         RK616_ADCR_CLK_PWRD | RK616_ADCR_PWRD);
2006                 break;
2007
2008         default:
2009                 return 0;
2010         }
2011
2012         return 0;
2013 }
2014
2015 /* Mixin */
2016 static const struct snd_kcontrol_new rk616_mixinl[] = {
2017         SOC_DAPM_SINGLE("IN3L Switch", RK616_MIXINL_CTL,
2018                                 RK616_MIL_F_IN3L_SFT, 1, 1),
2019         SOC_DAPM_SINGLE("IN1P Switch", RK616_MIXINL_CTL,
2020                                 RK616_MIL_F_IN1P_SFT, 1, 1),
2021         SOC_DAPM_SINGLE("MUXMIC Switch", RK616_MIXINL_CTL,
2022                                 RK616_MIL_F_MUX_SFT, 1, 1),
2023 };
2024
2025 static const struct snd_kcontrol_new rk616_mixinr[] = {
2026         SOC_DAPM_SINGLE("MIC2N Switch", RK616_MIXINR_CTL,
2027                                 RK616_MIR_F_MIC2N_SFT, 1, 1),
2028         SOC_DAPM_SINGLE("IN1P Switch", RK616_MIXINR_CTL,
2029                                 RK616_MIR_F_IN1P_SFT, 1, 1),
2030         SOC_DAPM_SINGLE("IN3R Switch", RK616_MIXINR_CTL,
2031                                 RK616_MIR_F_IN3R_SFT, 1, 1),
2032         SOC_DAPM_SINGLE("MIXINR Mux Switch", RK616_MIXINR_CTL,
2033                                 RK616_MIR_F_MIRM_SFT, 1, 1),
2034 };
2035
2036 /* Linemix */
2037 static const struct snd_kcontrol_new rk616_linemix[] = {
2038         SOC_DAPM_SINGLE("PGAR Switch", RK616_LINEMIX_CTL,
2039                                 RK616_LM_F_PGAR_SFT, 1, 1),
2040         SOC_DAPM_SINGLE("PGAL Switch", RK616_LINEMIX_CTL,
2041                                 RK616_LM_F_PGAL_SFT, 1, 1),
2042         SOC_DAPM_SINGLE("DACR Switch", RK616_LINEMIX_CTL,
2043                                 RK616_LM_F_DACR_SFT, 1, 1),
2044         SOC_DAPM_SINGLE("DACL Switch", RK616_LINEMIX_CTL,
2045                                 RK616_LM_F_DACL_SFT, 1, 1),
2046 };
2047
2048 /* HPmix */
2049 static const struct snd_kcontrol_new rk616_hpmixl[] = {
2050         SOC_DAPM_SINGLE("HPMix Mux Switch", RK616_HPMIX_CTL,
2051                                 RK616_HML_F_HMM_SFT, 1, 1),
2052         SOC_DAPM_SINGLE("IN1P Switch", RK616_HPMIX_CTL,
2053                                 RK616_HML_F_IN1P_SFT, 1, 1),
2054         SOC_DAPM_SINGLE("PGAL Switch", RK616_HPMIX_CTL,
2055                                 RK616_HML_F_PGAL_SFT, 1, 1),
2056         SOC_DAPM_SINGLE("DACL Switch", RK616_HPMIX_CTL,
2057                                 RK616_HML_F_DACL_SFT, 1, 1),
2058 };
2059
2060 static const struct snd_kcontrol_new rk616_hpmixr[] = {
2061         SOC_DAPM_SINGLE("HPMix Mux Switch", RK616_HPMIX_CTL,
2062                                 RK616_HMR_F_HMM_SFT, 1, 1),
2063         SOC_DAPM_SINGLE("PGAR Switch", RK616_HPMIX_CTL,
2064                                 RK616_HMR_F_PGAR_SFT, 1, 1),
2065         SOC_DAPM_SINGLE("PGAL Switch", RK616_HPMIX_CTL,
2066                                 RK616_HMR_F_PGAL_SFT, 1, 1),
2067         SOC_DAPM_SINGLE("DACR Switch", RK616_HPMIX_CTL,
2068                                 RK616_HMR_F_DACR_SFT, 1, 1),
2069 };
2070
2071 /* HP MUX */
2072 static const char *hpl_sel[] = {"HPMIXL", "DACL"};
2073
2074 static const struct soc_enum hpl_sel_enum =
2075         SOC_ENUM_SINGLE(RK616_MUXHP_HPMIX_CTL, RK616_MHL_F_SFT,
2076                         ARRAY_SIZE(hpl_sel), hpl_sel);
2077
2078 static const struct snd_kcontrol_new hpl_sel_mux =
2079         SOC_DAPM_ENUM("HPL select Mux", hpl_sel_enum);
2080
2081 static const char *hpr_sel[] = {"HPMIXR", "DACR"};
2082
2083 static const struct soc_enum hpr_sel_enum =
2084         SOC_ENUM_SINGLE(RK616_MUXHP_HPMIX_CTL, RK616_MHR_F_SFT,
2085                         ARRAY_SIZE(hpr_sel), hpr_sel);
2086
2087 static const struct snd_kcontrol_new hpr_sel_mux =
2088         SOC_DAPM_ENUM("HPR select Mux", hpr_sel_enum);
2089
2090 /* MIC MUX */
2091 static const char *mic_sel[] = {"BSTL", "BSTR"};
2092
2093 static const struct soc_enum mic_sel_enum =
2094         SOC_ENUM_SINGLE(RK616_MIXINL_CTL, RK616_MM_F_SFT,
2095                         ARRAY_SIZE(mic_sel), mic_sel);
2096
2097 static const struct snd_kcontrol_new mic_sel_mux =
2098         SOC_DAPM_ENUM("Mic select Mux", mic_sel_enum);
2099
2100 /* MIXINR MUX */
2101 static const char *mixinr_sel[] = {"DIFFIN", "IN1N"};
2102
2103 static const struct soc_enum mixinr_sel_enum =
2104         SOC_ENUM_SINGLE(RK616_DIFFIN_CTL, RK616_MIRM_F_SFT,
2105                         ARRAY_SIZE(mixinr_sel), mixinr_sel);
2106
2107 static const struct snd_kcontrol_new mixinr_sel_mux =
2108         SOC_DAPM_ENUM("Mixinr select Mux", mixinr_sel_enum);
2109
2110 /* HPMIX MUX */
2111 static const char *hpmix_sel[] = {"DIFFIN", "IN1N"};
2112
2113 static const struct soc_enum hpmix_sel_enum =
2114         SOC_ENUM_SINGLE(RK616_DIFFIN_CTL, RK616_HMM_F_SFT,
2115                         ARRAY_SIZE(hpmix_sel), hpmix_sel);
2116
2117 static const struct snd_kcontrol_new hpmix_sel_mux =
2118         SOC_DAPM_ENUM("HPMix select Mux", hpmix_sel_enum);
2119
2120
2121 static const struct snd_soc_dapm_widget rk616_dapm_widgets[] = {
2122         /* supply */
2123         SND_SOC_DAPM_SUPPLY("I2S0 Interface", CRU_IO_CON0,
2124                 3, 1, NULL, 0),
2125         SND_SOC_DAPM_SUPPLY("I2S1 Interface", CRU_IO_CON0,
2126                 4, 1, NULL, 0),
2127
2128         /* microphone bias */
2129         SND_SOC_DAPM_MICBIAS("Mic1 Bias", RK616_MICBIAS_CTL,
2130                 RK616_MICBIAS1_PWRD_SFT, 1),
2131         SND_SOC_DAPM_MICBIAS("Mic2 Bias", RK616_MICBIAS_CTL,
2132                 RK616_MICBIAS2_PWRD_SFT, 1),
2133
2134         /* DACs */
2135         SND_SOC_DAPM_ADC_E("DACL", NULL, SND_SOC_NOPM,
2136                 0, 0, rk616_dacl_event,
2137                 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
2138         SND_SOC_DAPM_ADC_E("DACR", NULL, SND_SOC_NOPM,
2139                 0, 0, rk616_dacr_event,
2140                 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
2141
2142         /* ADCs */
2143         SND_SOC_DAPM_ADC_E("ADCL", NULL, SND_SOC_NOPM,
2144                 0, 0, rk616_adcl_event,
2145                 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
2146         SND_SOC_DAPM_ADC_E("ADCR", NULL, SND_SOC_NOPM,
2147                 0, 0, rk616_adcr_event,
2148                 SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
2149
2150         /* PGA */
2151         SND_SOC_DAPM_PGA("BSTL", RK616_BST_CTL,
2152                 RK616_BSTL_PWRD_SFT, 1, NULL, 0),
2153         SND_SOC_DAPM_PGA("BSTR", RK616_BST_CTL,
2154                 RK616_BSTR_PWRD_SFT, 1, NULL, 0),
2155         SND_SOC_DAPM_PGA("DIFFIN", RK616_DIFFIN_CTL,
2156                 RK616_DIFFIN_PWRD_SFT, 1, NULL, 0),
2157         SND_SOC_DAPM_PGA("PGAL", RK616_PGAL_CTL,
2158                 RK616_PGA_PWRD_SFT, 1, NULL, 0),
2159         SND_SOC_DAPM_PGA("PGAR", RK616_PGAR_CTL,
2160                 RK616_PGA_PWRD_SFT, 1, NULL, 0),
2161         SND_SOC_DAPM_PGA("SPKL", RK616_SPKL_CTL,
2162                 RK616_PWRD_SFT, 1, NULL, 0),
2163         SND_SOC_DAPM_PGA("SPKR", RK616_SPKR_CTL,
2164                 RK616_PWRD_SFT, 1, NULL, 0),
2165         SND_SOC_DAPM_PGA("HPL", RK616_HPL_CTL,
2166                 RK616_PWRD_SFT, 1, NULL, 0),
2167         SND_SOC_DAPM_PGA("HPR", RK616_HPR_CTL,
2168                 RK616_PWRD_SFT, 1, NULL, 0),
2169         SND_SOC_DAPM_PGA("LINE1", RK616_LINEOUT1_CTL,
2170                 RK616_LINEOUT_PWRD_SFT, 1, NULL, 0),
2171         SND_SOC_DAPM_PGA("LINE2", RK616_LINEOUT2_CTL,
2172                 RK616_LINEOUT_PWRD_SFT, 1, NULL, 0),
2173
2174         /* MIXER */
2175         SND_SOC_DAPM_MIXER("MIXINL", RK616_MIXINL_CTL,
2176                 RK616_MIL_PWRD_SFT, 1, rk616_mixinl,
2177                 ARRAY_SIZE(rk616_mixinl)),
2178         SND_SOC_DAPM_MIXER("MIXINR", RK616_MIXINR_CTL,
2179                 RK616_MIR_PWRD_SFT, 1, rk616_mixinr,
2180                 ARRAY_SIZE(rk616_mixinr)),
2181         SND_SOC_DAPM_MIXER("LINEMIX", RK616_LINEMIX_CTL,
2182                 RK616_LM_PWRD_SFT, 1, rk616_linemix,
2183                 ARRAY_SIZE(rk616_linemix)),
2184         SND_SOC_DAPM_MIXER("HPMIXL", RK616_MUXHP_HPMIX_CTL,
2185                 RK616_HML_PWRD_SFT, 1, rk616_hpmixl,
2186                 ARRAY_SIZE(rk616_hpmixl)),
2187         SND_SOC_DAPM_MIXER("HPMIXR", RK616_MUXHP_HPMIX_CTL,
2188                 RK616_HMR_PWRD_SFT, 1, rk616_hpmixr,
2189                 ARRAY_SIZE(rk616_hpmixr)),
2190
2191         /* MUX */
2192         SND_SOC_DAPM_MUX("HPL Mux", SND_SOC_NOPM, 0, 0,
2193                 &hpl_sel_mux),
2194         SND_SOC_DAPM_MUX("HPR Mux", SND_SOC_NOPM, 0, 0,
2195                 &hpr_sel_mux),
2196         SND_SOC_DAPM_MUX("Mic Mux", SND_SOC_NOPM, 0, 0,
2197                 &mic_sel_mux),
2198         SND_SOC_DAPM_MUX("MIXINR Mux", SND_SOC_NOPM, 0, 0,
2199                 &mixinr_sel_mux),
2200         SND_SOC_DAPM_MUX("HPMix Mux", SND_SOC_NOPM, 0, 0,
2201                 &hpmix_sel_mux),
2202
2203         /* Audio Interface */
2204         SND_SOC_DAPM_AIF_IN("I2S0 DAC", "HiFi Playback", 0,
2205                 SND_SOC_NOPM, 0, 0),
2206         SND_SOC_DAPM_AIF_OUT("I2S0 ADC", "HiFi Capture", 0,
2207                 SND_SOC_NOPM, 0, 0),
2208         SND_SOC_DAPM_AIF_IN("I2S1 DAC", "Voice Playback", 0,
2209                 SND_SOC_NOPM, 0, 0),
2210         SND_SOC_DAPM_AIF_OUT("I2S1 ADC", "Voice Capture", 0,
2211                 SND_SOC_NOPM, 0, 0),
2212
2213         /* Input */
2214         SND_SOC_DAPM_INPUT("IN3L"),
2215         SND_SOC_DAPM_INPUT("IN3R"),
2216         SND_SOC_DAPM_INPUT("IN1P"),
2217         SND_SOC_DAPM_INPUT("IN1N"),
2218         SND_SOC_DAPM_INPUT("MIC2P"),
2219         SND_SOC_DAPM_INPUT("MIC2N"),
2220         SND_SOC_DAPM_INPUT("MIC1P"),
2221         SND_SOC_DAPM_INPUT("MIC1N"),
2222
2223         /* Output */
2224         SND_SOC_DAPM_OUTPUT("SPKOUTL"),
2225         SND_SOC_DAPM_OUTPUT("SPKOUTR"),
2226         SND_SOC_DAPM_OUTPUT("HPOUTL"),
2227         SND_SOC_DAPM_OUTPUT("HPOUTR"),
2228         SND_SOC_DAPM_OUTPUT("LINEOUT1"),
2229         SND_SOC_DAPM_OUTPUT("LINEOUT2"),
2230 };
2231
2232 static const struct snd_soc_dapm_route rk616_dapm_routes[] = {
2233         {"I2S0 DAC", NULL, "I2S0 Interface"},
2234         {"I2S0 ADC", NULL, "I2S0 Interface"},
2235         {"I2S1 DAC", NULL, "I2S1 Interface"},
2236         {"I2S1 ADC", NULL, "I2S1 Interface"},
2237
2238         /* Input */
2239         {"DIFFIN", NULL, "IN1P"},
2240         {"DIFFIN", NULL, "IN1N"},
2241
2242         {"BSTR", NULL, "MIC2P"},
2243         {"BSTR", NULL, "MIC2N"},
2244         {"BSTL", NULL, "MIC1P"},
2245         {"BSTL", NULL, "MIC1N"},
2246
2247         {"HPMix Mux", "DIFFIN", "DIFFIN"},
2248         {"HPMix Mux", "IN1N", "IN1N"},
2249
2250         {"MIXINR Mux", "DIFFIN", "DIFFIN"},
2251         {"MIXINR Mux", "IN1N", "IN1N"},
2252
2253         {"Mic Mux", "BSTR", "BSTR"},
2254         {"Mic Mux", "BSTL", "BSTL"},
2255
2256         {"MIXINR", "MIC2N Switch", "MIC2N"},
2257         {"MIXINR", "IN1P Switch", "IN1P"},
2258         {"MIXINR", "IN3R Switch", "IN3R"},
2259         {"MIXINR", "MIXINR Mux Switch", "MIXINR Mux"},
2260
2261         {"MIXINL", "IN3L Switch", "IN3L"},
2262         {"MIXINL", "IN1P Switch", "IN1P"},
2263         {"MIXINL", "MUXMIC Switch", "Mic Mux"},
2264
2265         {"PGAR", NULL, "MIXINR"},
2266         {"PGAL", NULL, "MIXINL"},
2267
2268         {"ADCR", NULL, "PGAR"},
2269         {"ADCL", NULL, "PGAL"},
2270
2271         {"I2S0 ADC", NULL, "ADCR"},
2272         {"I2S0 ADC", NULL, "ADCL"},
2273
2274         {"I2S1 ADC", NULL, "ADCR"},
2275         {"I2S1 ADC", NULL, "ADCL"},
2276
2277         /* Output */
2278         {"DACR", NULL, "I2S0 DAC"},
2279         {"DACL", NULL, "I2S0 DAC"},
2280
2281         {"DACR", NULL, "I2S1 DAC"},
2282         {"DACL", NULL, "I2S1 DAC"},
2283
2284         {"LINEMIX", "PGAR Switch", "PGAR"},
2285         {"LINEMIX", "PGAL Switch", "PGAL"},
2286         {"LINEMIX", "DACR Switch", "DACR"},
2287         {"LINEMIX", "DACL Switch", "DACL"},
2288
2289         {"HPMIXR", "HPMix Mux Switch", "HPMix Mux"},
2290         {"HPMIXR", "PGAR Switch", "PGAR"},
2291         {"HPMIXR", "PGAL Switch", "PGAL"},
2292         {"HPMIXR", "DACR Switch", "DACR"},
2293
2294         {"HPMIXL", "HPMix Mux Switch", "HPMix Mux"},
2295         {"HPMIXL", "IN1P Switch", "IN1P"},
2296         {"HPMIXL", "PGAL Switch", "PGAL"},
2297         {"HPMIXL", "DACL Switch", "DACL"},
2298
2299         {"HPR Mux", "DACR", "DACR"},
2300         {"HPR Mux", "HPMIXR", "HPMIXR"},
2301         {"HPL Mux", "DACL", "DACL"},
2302         {"HPL Mux", "HPMIXL", "HPMIXL"},
2303
2304         {"LINE1", NULL, "LINEMIX"},
2305         {"LINE2", NULL, "LINEMIX"},
2306         {"SPKR", NULL, "HPR Mux"},
2307         {"SPKL", NULL, "HPL Mux"},
2308         {"HPR", NULL, "HPR Mux"},
2309         {"HPL", NULL, "HPL Mux"},
2310
2311         {"LINEOUT1", NULL, "LINE1"},
2312         {"LINEOUT2", NULL, "LINE2"},
2313         {"SPKOUTR", NULL, "SPKR"},
2314         {"SPKOUTL", NULL, "SPKL"},
2315         {"HPOUTR", NULL, "HPR"},
2316         {"HPOUTL", NULL, "HPL"},
2317 };
2318
2319 static int rk616_set_bias_level(struct snd_soc_codec *codec,
2320                                  enum snd_soc_bias_level level)
2321 {
2322         switch (level) {
2323         case SND_SOC_BIAS_ON:
2324                 break;
2325
2326         case SND_SOC_BIAS_PREPARE:
2327                 if (!rk616_for_mid) {
2328                         snd_soc_update_bits(codec, RK616_MICBIAS_CTL,
2329                                 RK616_MICBIAS2_PWRD | RK616_MICBIAS2_V_MASK,
2330                                 RK616_MICBIAS2_V_1_7);
2331                         mdelay(100);
2332                 }
2333                 break;
2334
2335         case SND_SOC_BIAS_STANDBY:
2336                 if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
2337                         /* set power */
2338                         snd_soc_update_bits(codec, RK616_PWR_ADD1,
2339                                 RK616_ADC_PWRD | RK616_DIFFIN_MIR_PGAR_RLPWRD |
2340                                 RK616_MIC1_MIC2_MIL_PGAL_RLPWRD |
2341                                 RK616_ADCL_RLPWRD | RK616_ADCR_RLPWRD, 0);
2342
2343                         snd_soc_update_bits(codec, RK616_PWR_ADD2,
2344                                 RK616_HPL_HPR_PWRD | RK616_DAC_PWRD |
2345                                 RK616_DACL_SPKL_RLPWRD | RK616_DACL_RLPWRD |
2346                                 RK616_DACR_SPKR_RLPWRD | RK616_DACR_RLPWRD |
2347                                 RK616_LM_LO_RLPWRD | RK616_HM_RLPWRD, 0);
2348
2349                         snd_soc_update_bits(codec, RK616_PWR_ADD3,
2350                                 RK616_ADCL_ZO_PWRD | RK616_ADCR_ZO_PWRD |
2351                                 RK616_DACL_ZO_PWRD | RK616_DACR_ZO_PWRD,
2352                                 RK616_ADCL_ZO_PWRD | RK616_ADCR_ZO_PWRD |
2353                                 RK616_DACL_ZO_PWRD | RK616_DACR_ZO_PWRD );
2354
2355                         if (!rk616_for_mid)
2356                                 snd_soc_update_bits(codec, RK616_MICBIAS_CTL,
2357                                         RK616_MICBIAS2_PWRD | RK616_MICBIAS2_V_MASK,
2358                                         RK616_MICBIAS2_V_1_7);
2359                 }
2360                 break;
2361
2362         case SND_SOC_BIAS_OFF:
2363                 snd_soc_write(codec, RK616_PWR_ADD1, rk616_reg_defaults[RK616_PWR_ADD1] & ~RK616_ADC_PWRD);
2364                 snd_soc_write(codec, RK616_PWR_ADD2, rk616_reg_defaults[RK616_PWR_ADD2]);
2365                 snd_soc_write(codec, RK616_PWR_ADD3, rk616_reg_defaults[RK616_PWR_ADD3]);
2366                 if (!rk616_for_mid)
2367                         snd_soc_update_bits(codec, RK616_MICBIAS_CTL,
2368                                 RK616_MICBIAS1_PWRD,
2369                                 RK616_MICBIAS1_PWRD);
2370                 break;
2371         }
2372
2373         codec->dapm.bias_level = level;
2374
2375         return 0;
2376 }
2377
2378 static int rk616_set_dai_sysclk(struct snd_soc_dai *codec_dai,
2379                                  int clk_id, unsigned int freq, int dir)
2380 {
2381         struct rk616_codec_priv *rk616 = rk616_priv;
2382
2383         if (!rk616 || !rk616_mfd) {
2384                 printk("%s : %s %s\n", __func__, !rk616 ? "rk616 is NULL" : "",
2385                         !rk616_mfd ? "rk616_mfd is NULL" : "");
2386                 return -EINVAL;
2387         }
2388
2389         rk616->stereo_sysclk = freq;
2390
2391         //set I2S mclk for mipi
2392         rk616_mclk_set_rate(rk616_mfd->mclk, freq);
2393
2394         return 0;
2395 }
2396
2397 static int rk616_set_dai_fmt(struct snd_soc_dai *codec_dai,
2398                               unsigned int fmt)
2399 {
2400         struct snd_soc_codec *codec = codec_dai->codec;
2401         unsigned int adc_aif1 = 0, adc_aif2 = 0, dac_aif1 = 0, dac_aif2 = 0;
2402
2403         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
2404         case SND_SOC_DAIFMT_CBS_CFS:
2405                 adc_aif2 |= RK616_I2S_MODE_SLV;
2406                 break;
2407         case SND_SOC_DAIFMT_CBM_CFM:
2408                 adc_aif2 |= RK616_I2S_MODE_MST;
2409                 break;
2410         default:
2411                 printk("%s : set master mask failed!\n", __func__);
2412                 return -EINVAL;
2413         }
2414
2415         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
2416         case SND_SOC_DAIFMT_DSP_A:
2417                 adc_aif1 |= RK616_ADC_DF_PCM;
2418                 dac_aif1 |= RK616_DAC_DF_PCM;
2419                 break;
2420         case SND_SOC_DAIFMT_DSP_B:
2421                 break;
2422         case SND_SOC_DAIFMT_I2S:
2423                 adc_aif1 |= RK616_ADC_DF_I2S;
2424                 dac_aif1 |= RK616_DAC_DF_I2S;
2425                 break;
2426         case SND_SOC_DAIFMT_RIGHT_J:
2427                 adc_aif1 |= RK616_ADC_DF_RJ;
2428                 dac_aif1 |= RK616_DAC_DF_RJ;
2429                 break;
2430         case SND_SOC_DAIFMT_LEFT_J:
2431                 adc_aif1 |= RK616_ADC_DF_LJ;
2432                 dac_aif1 |= RK616_DAC_DF_LJ;
2433                 break;
2434         default:
2435                 printk("%s : set format failed!\n", __func__);
2436                 return -EINVAL;
2437         }
2438
2439         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
2440         case SND_SOC_DAIFMT_NB_NF:
2441                 adc_aif1 |= RK616_ALRCK_POL_DIS;
2442                 adc_aif2 |= RK616_ABCLK_POL_DIS;
2443                 dac_aif1 |= RK616_DLRCK_POL_DIS;
2444                 dac_aif2 |= RK616_DBCLK_POL_DIS;
2445                 break;
2446         case SND_SOC_DAIFMT_IB_IF:
2447                 adc_aif1 |= RK616_ALRCK_POL_EN;
2448                 adc_aif2 |= RK616_ABCLK_POL_EN;
2449                 dac_aif1 |= RK616_DLRCK_POL_EN;
2450                 dac_aif2 |= RK616_DBCLK_POL_EN;
2451                 break;
2452         case SND_SOC_DAIFMT_IB_NF:
2453                 adc_aif1 |= RK616_ALRCK_POL_DIS;
2454                 adc_aif2 |= RK616_ABCLK_POL_EN;
2455                 dac_aif1 |= RK616_DLRCK_POL_DIS;
2456                 dac_aif2 |= RK616_DBCLK_POL_EN;
2457                 break;
2458         case SND_SOC_DAIFMT_NB_IF:
2459                 adc_aif1 |= RK616_ALRCK_POL_EN;
2460                 adc_aif2 |= RK616_ABCLK_POL_DIS;
2461                 dac_aif1 |= RK616_DLRCK_POL_EN;
2462                 dac_aif2 |= RK616_DBCLK_POL_DIS;
2463                 break;
2464         default:
2465                 printk("%s : set dai format failed!\n", __func__);
2466                 return -EINVAL;
2467         }
2468
2469         snd_soc_update_bits(codec, RK616_ADC_INT_CTL1,
2470                         RK616_ALRCK_POL_MASK | RK616_ADC_DF_MASK, adc_aif1);
2471         snd_soc_update_bits(codec, RK616_ADC_INT_CTL2,
2472                         RK616_ABCLK_POL_MASK | RK616_I2S_MODE_MASK, adc_aif2);
2473         snd_soc_update_bits(codec, RK616_DAC_INT_CTL1,
2474                         RK616_DLRCK_POL_MASK | RK616_DAC_DF_MASK, dac_aif1);
2475         snd_soc_update_bits(codec, RK616_DAC_INT_CTL2,
2476                         RK616_DBCLK_POL_MASK, dac_aif2);
2477
2478         return 0;
2479 }
2480
2481 static int rk616_hw_params(struct snd_pcm_substream *substream,
2482                             struct snd_pcm_hw_params *params,
2483                             struct snd_soc_dai *dai)
2484 {
2485         struct snd_soc_pcm_runtime *rtd = substream->private_data;
2486         struct snd_soc_codec *codec =rtd->codec;
2487         struct rk616_codec_priv *rk616 = rk616_priv;
2488         unsigned int rate = params_rate(params);
2489         unsigned int div;
2490         unsigned int adc_aif1 = 0, adc_aif2  = 0, dac_aif1 = 0, dac_aif2  = 0;
2491         u32 mfd_aif1 = 0, mfd_aif2 = 0, mfd_i2s_ctl = 0;
2492
2493         if (!rk616) {
2494                 printk("%s : rk616 is NULL\n", __func__);
2495                 return -EINVAL;
2496         }
2497
2498 #ifdef CONFIG_SND_RK29_CODEC_SOC_MASTER
2499         // bclk = codec_clk / 4
2500         // lrck = bclk / (wl * 2)
2501         div = (((rk616->stereo_sysclk / 4) / rate) / 2);
2502
2503         if ((rk616->stereo_sysclk % (4 * rate * 2) > 0) ||
2504             (div != 16 && div != 20 && div != 24 && div != 32)) {
2505                 printk("%s : need PLL\n", __func__);
2506                 return -EINVAL;
2507         }
2508 #else
2509         //If codec is slave mode, it don't need to set div
2510         //according to sysclk and rate.
2511         div = 32;
2512 #endif
2513
2514         switch (div) {
2515         case 16:
2516                 adc_aif2 |= RK616_ADC_WL_16;
2517                 dac_aif2 |= RK616_DAC_WL_16;
2518                 break;
2519         case 20:
2520                 adc_aif2 |= RK616_ADC_WL_20;
2521                 dac_aif2 |= RK616_DAC_WL_20;
2522                 break;
2523         case 24:
2524                 adc_aif2 |= RK616_ADC_WL_24;
2525                 dac_aif2 |= RK616_DAC_WL_24;
2526                 break;
2527         case 32:
2528                 adc_aif2 |= RK616_ADC_WL_32;
2529                 dac_aif2 |= RK616_DAC_WL_32;
2530                 break;
2531         default:
2532                 return -EINVAL;
2533         }
2534
2535
2536         DBG("%s : MCLK = %dHz, sample rate = %dHz, div = %d\n", __func__,
2537                 rk616->stereo_sysclk, rate, div);
2538
2539         switch (params_format(params)) {
2540         case SNDRV_PCM_FORMAT_S16_LE:
2541                 adc_aif1 |= RK616_ADC_VWL_16;
2542                 dac_aif1 |= RK616_DAC_VWL_16;
2543                 break;
2544         case SNDRV_PCM_FORMAT_S20_3LE:
2545                 adc_aif1 |= RK616_ADC_VWL_20;
2546                 dac_aif1 |= RK616_DAC_VWL_20;
2547                 break;
2548         case SNDRV_PCM_FORMAT_S24_LE:
2549                 adc_aif1 |= RK616_ADC_VWL_24;
2550                 dac_aif1 |= RK616_DAC_VWL_24;
2551                 break;
2552         case SNDRV_PCM_FORMAT_S32_LE:
2553                 adc_aif1 |= RK616_ADC_VWL_32;
2554                 dac_aif1 |= RK616_DAC_VWL_32;
2555                 break;
2556         default:
2557                 return -EINVAL;
2558         }
2559
2560         /*switch (params_channels(params)) {
2561         case RK616_MONO:
2562                 adc_aif1 |= RK616_ADC_TYPE_MONO;
2563                 break;
2564         case RK616_STEREO:
2565                 adc_aif1 |= RK616_ADC_TYPE_STEREO;
2566                 break;
2567         default:
2568                 return -EINVAL;
2569         }*/
2570
2571         //MIC1N/P and MIC2N/P can only line to ADCL, so set mono type.
2572         adc_aif1 |= RK616_ADC_TYPE_MONO;
2573
2574         adc_aif1 |= RK616_ADC_SWAP_DIS;
2575         adc_aif2 |= RK616_ADC_RST_DIS;
2576         dac_aif1 |= RK616_DAC_SWAP_DIS;
2577         dac_aif2 |= RK616_DAC_RST_DIS;
2578
2579         rk616->rate = rate;
2580
2581         snd_soc_update_bits(codec, RK616_ADC_INT_CTL1,
2582                          RK616_ADC_VWL_MASK | RK616_ADC_SWAP_MASK |
2583                          RK616_ADC_TYPE_MASK, adc_aif1);
2584         snd_soc_update_bits(codec, RK616_ADC_INT_CTL2,
2585                         RK616_ADC_WL_MASK | RK616_ADC_RST_MASK, adc_aif2);
2586         snd_soc_update_bits(codec, RK616_DAC_INT_CTL1,
2587                          RK616_DAC_VWL_MASK | RK616_DAC_SWAP_MASK, dac_aif1);
2588         snd_soc_update_bits(codec, RK616_DAC_INT_CTL2,
2589                         RK616_DAC_WL_MASK | RK616_DAC_RST_MASK, dac_aif2);
2590
2591         switch (dai->id) {
2592         case RK616_HIFI:
2593                 mfd_aif1 |= I2S1_OUT_DISABLE | I2S0_PD_DISABLE;
2594                 mfd_aif2 |= I2S0_SI_EN;
2595                 mfd_i2s_ctl |= 0;
2596                 break;
2597         case RK616_VOICE:
2598                 mfd_aif1 |= I2S0_OUT_DISABLE | I2S1_PD_DISABLE;
2599                 mfd_aif2 |= I2S1_SI_EN;
2600                 mfd_i2s_ctl |= I2S_CHANNEL_SEL | PCM_TO_I2S_MUX;
2601                 break;
2602         default:
2603                 return -EINVAL;
2604         }
2605
2606         snd_soc_update_bits(codec, CRU_IO_CON0,
2607                         I2S1_OUT_DISABLE | I2S0_OUT_DISABLE |
2608                         I2S1_PD_DISABLE | I2S0_PD_DISABLE, mfd_aif1);
2609         snd_soc_update_bits(codec, CRU_IO_CON1,
2610                         I2S1_SI_EN | I2S0_SI_EN, mfd_aif2);
2611         snd_soc_update_bits(codec, CRU_PCM2IS2_CON2,
2612                         APS_SEL | APS_CLR | I2S_CHANNEL_SEL,
2613                         mfd_i2s_ctl);
2614         return 0;
2615 }
2616
2617 static int rk616_digital_mute(struct snd_soc_dai *dai, int mute)
2618 {
2619         struct rk616_codec_priv *rk616 = rk616_priv;
2620
2621         if (rk616_for_mid)
2622         {
2623                 DBG("%s immediately return for mid\n",__func__);
2624                 return 0;
2625         }
2626
2627         if (!rk616) {
2628                 printk("%s : rk616_priv is NULL\n", __func__);
2629                 return -EINVAL;
2630         }
2631
2632         if (mute) {
2633                 rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP | RK616_CODEC_SET_RCV, GPIO_LOW);
2634         } else {
2635                 if (rk616->spk_gpio_level)
2636                         rk616_set_gpio(RK616_CODEC_SET_SPK, rk616->spk_gpio_level);
2637
2638                 if (rk616->hp_gpio_level)
2639                         rk616_set_gpio(RK616_CODEC_SET_HP, rk616->hp_gpio_level);
2640
2641                 if (rk616->rcv_gpio_level)
2642                         rk616_set_gpio(RK616_CODEC_SET_RCV, rk616->rcv_gpio_level);
2643         }
2644
2645         return 0;
2646 }
2647
2648 #define RK616_PLAYBACK_RATES (SNDRV_PCM_RATE_8000 |\
2649                               SNDRV_PCM_RATE_16000 |    \
2650                               SNDRV_PCM_RATE_32000 |    \
2651                               SNDRV_PCM_RATE_44100 |    \
2652                               SNDRV_PCM_RATE_48000 |    \
2653                               SNDRV_PCM_RATE_96000)
2654
2655 #define RK616_CAPTURE_RATES (SNDRV_PCM_RATE_8000 |\
2656                               SNDRV_PCM_RATE_16000 |    \
2657                               SNDRV_PCM_RATE_32000 |    \
2658                               SNDRV_PCM_RATE_44100 |    \
2659                               SNDRV_PCM_RATE_48000 |    \
2660                               SNDRV_PCM_RATE_96000)
2661
2662 #define RK616_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
2663                         SNDRV_PCM_FMTBIT_S20_3LE |\
2664                         SNDRV_PCM_FMTBIT_S24_LE |\
2665                         SNDRV_PCM_FMTBIT_S32_LE)
2666
2667 static struct snd_soc_dai_ops rk616_dai_ops = {
2668         .hw_params      = rk616_hw_params,
2669         .set_fmt        = rk616_set_dai_fmt,
2670         .set_sysclk     = rk616_set_dai_sysclk,
2671         .digital_mute   = rk616_digital_mute,
2672 };
2673
2674 static struct snd_soc_dai_driver rk616_dai[] = {
2675         {
2676                 .name = "rk616-hifi",
2677                 .id = RK616_HIFI,
2678                 .playback = {
2679                         .stream_name = "HiFi Playback",
2680                         .channels_min = 2,
2681                         .channels_max = 2,
2682                         .rates = RK616_PLAYBACK_RATES,
2683                         .formats = RK616_FORMATS,
2684                 },
2685                 .capture = {
2686                         .stream_name = "HiFi Capture",
2687                         .channels_min = 2,
2688                         .channels_max = 2,
2689                         .rates = RK616_CAPTURE_RATES,
2690                         .formats = RK616_FORMATS,
2691                 },
2692                 .ops = &rk616_dai_ops,
2693         },
2694         {
2695                 .name = "rk616-voice",
2696                 .id = RK616_VOICE,
2697                 .playback = {
2698                         .stream_name = "Voice Playback",
2699                         .channels_min = 1,
2700                         .channels_max = 2,
2701                         .rates = RK616_PLAYBACK_RATES,
2702                         .formats = RK616_FORMATS,
2703                 },
2704                 .capture = {
2705                         .stream_name = "Voice Capture",
2706                         .channels_min = 1,
2707                         .channels_max = 2,
2708                         .rates = RK616_CAPTURE_RATES,
2709                         .formats = RK616_FORMATS,
2710                 },
2711                 .ops = &rk616_dai_ops,
2712         },
2713
2714 };
2715
2716 static int rk616_suspend(struct snd_soc_codec *codec)
2717 {
2718         if (rk616_for_mid)
2719                 rk616_codec_power_down(RK616_CODEC_ALL);
2720         else
2721                 rk616_set_bias_level(codec, SND_SOC_BIAS_OFF);
2722
2723         return 0;
2724 }
2725
2726 static int rk616_resume(struct snd_soc_codec *codec)
2727 {
2728         if (rk616_for_mid) {
2729                 snd_soc_write(codec, RK616_MICBIAS_CTL,
2730                         RK616_MICBIAS2_PWRD | RK616_MICBIAS1_V_1_7);
2731         } else {
2732                 rk616_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2733         }
2734
2735         return 0;
2736 }
2737
2738 static int rk616_probe(struct snd_soc_codec *codec)
2739 {
2740         struct rk616_codec_priv *rk616;
2741         int ret;
2742         unsigned int val;
2743
2744         DBG("%s\n", __func__);
2745
2746         rk616 = kzalloc(sizeof(struct rk616_codec_priv), GFP_KERNEL);
2747         if (!rk616) {
2748                 printk("%s : rk616 priv kzalloc failed!\n", __func__);
2749                 return -ENOMEM;
2750         }
2751
2752         rk616->codec = codec;
2753
2754         if (rk616_mfd && rk616_mfd->pdata && rk616_mfd->pdata->spk_ctl_gpio) {
2755                 gpio_request(rk616_mfd->pdata->spk_ctl_gpio, NULL);
2756                 gpio_direction_output(rk616_mfd->pdata->spk_ctl_gpio, GPIO_LOW);
2757                 rk616->spk_ctl_gpio = rk616_mfd->pdata->spk_ctl_gpio;
2758         } else {
2759                 printk("%s : rk616 or pdata or spk_ctl_gpio is NULL!\n", __func__);
2760                 rk616->spk_ctl_gpio = INVALID_GPIO;
2761         }
2762
2763         if (rk616_mfd && rk616_mfd->pdata && rk616_mfd->pdata->hp_ctl_gpio) {
2764                 gpio_request(rk616_mfd->pdata->hp_ctl_gpio, NULL);
2765                 gpio_direction_output(rk616_mfd->pdata->hp_ctl_gpio, GPIO_LOW);
2766                 rk616->hp_ctl_gpio = rk616_mfd->pdata->hp_ctl_gpio;
2767         } else {
2768                 printk("%s : rk616 or pdata or hp_ctl_gpio is NULL!\n", __func__);
2769                 rk616->hp_ctl_gpio = INVALID_GPIO;
2770         }
2771
2772         if (rk616_mfd && rk616_mfd->pdata && rk616_mfd->pdata->rcv_ctl_gpio) {
2773                 gpio_request(rk616_mfd->pdata->rcv_ctl_gpio, NULL);
2774                 gpio_direction_output(rk616_mfd->pdata->rcv_ctl_gpio, GPIO_LOW);
2775                 rk616->rcv_ctl_gpio = rk616_mfd->pdata->rcv_ctl_gpio;
2776         } else {
2777                 printk("%s : rk616 or pdata or rcv_ctl_gpio is NULL!\n", __func__);
2778                 rk616->rcv_ctl_gpio = INVALID_GPIO;
2779         }
2780
2781         if (rk616_mfd && rk616_mfd->pdata && rk616_mfd->pdata->mic_sel_gpio) {
2782                 gpio_request(rk616_mfd->pdata->mic_sel_gpio, NULL);
2783                 gpio_direction_output(rk616_mfd->pdata->mic_sel_gpio, GPIO_LOW);
2784                 rk616->mic_sel_gpio = rk616_mfd->pdata->mic_sel_gpio;
2785         } else {
2786                 printk("%s : rk616 or pdata or mic_sel_gpio is NULL!\n", __func__);
2787                 rk616->mic_sel_gpio = INVALID_GPIO;
2788         }
2789
2790         rk616->playback_path = OFF;
2791         rk616->capture_path = MIC_OFF;
2792         rk616->voice_call_path = OFF;
2793         rk616->voip_path = OFF;
2794         rk616->spk_gpio_level = GPIO_LOW;
2795         rk616->hp_gpio_level = GPIO_LOW;
2796         rk616->rcv_gpio_level = GPIO_LOW;
2797         rk616->mic_gpio_level = GPIO_LOW;
2798         rk616->modem_input_enable = 1;
2799
2800         rk616_priv = rk616;
2801
2802         ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_I2C);
2803         if (ret != 0) {
2804                 printk("%s : Failed to set cache I/O: %d\n", __func__, ret);
2805                 goto err__;
2806         }
2807
2808         codec->hw_read = rk616_codec_read;
2809         codec->hw_write = (hw_write_t)rk616_hw_write;
2810         codec->read = rk616_codec_read;
2811         codec->write = rk616_codec_write;
2812
2813         val = snd_soc_read(codec, RK616_RESET);
2814         if (val != rk616_reg_defaults[RK616_RESET]) {
2815                 printk("%s : codec register 0: %x is not a 0x00000003\n", __func__, val);
2816                 ret = -ENODEV;
2817                 goto err__;
2818         }
2819
2820         rk616_reset(codec);
2821
2822         if  (rk616_for_mid) {
2823                 snd_soc_add_codec_controls(codec, rk616_snd_path_controls,
2824                                 ARRAY_SIZE(rk616_snd_path_controls));
2825                 snd_soc_write(codec, RK616_MICBIAS_CTL,
2826                         RK616_MICBIAS2_PWRD | RK616_MICBIAS1_V_1_7);
2827         } else {
2828                 codec->dapm.bias_level = SND_SOC_BIAS_OFF;
2829                 rk616_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
2830
2831                 snd_soc_add_codec_controls(codec, rk616_snd_controls,
2832                                 ARRAY_SIZE(rk616_snd_controls));
2833                 snd_soc_dapm_new_controls(&codec->dapm, rk616_dapm_widgets,
2834                                 ARRAY_SIZE(rk616_dapm_widgets));
2835                 snd_soc_dapm_add_routes(&codec->dapm, rk616_dapm_routes,
2836                                 ARRAY_SIZE(rk616_dapm_routes));
2837         }
2838
2839         return 0;
2840
2841 err__:
2842         kfree(rk616);
2843         rk616 = NULL;
2844         rk616_priv = NULL;
2845
2846         return ret;
2847 }
2848
2849 /* power down chip */
2850 static int rk616_remove(struct snd_soc_codec *codec)
2851 {
2852         struct rk616_codec_priv *rk616 = rk616_priv;
2853
2854         DBG("%s\n", __func__);
2855
2856         if (!rk616) {
2857                 printk("%s : rk616_priv is NULL\n", __func__);
2858                 return 0;
2859         }
2860
2861         rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_LOW);
2862
2863         mdelay(10);
2864
2865         snd_soc_write(codec, RK616_RESET, 0xfc);
2866         mdelay(10);
2867         snd_soc_write(codec, RK616_RESET, 0x3);
2868         mdelay(10);
2869
2870         if (rk616)
2871                 kfree(rk616);
2872
2873         return 0;
2874 }
2875
2876 static struct snd_soc_codec_driver soc_codec_dev_rk616 = {
2877         .probe =        rk616_probe,
2878         .remove =       rk616_remove,
2879         .suspend =      rk616_suspend,
2880         .resume =       rk616_resume,
2881         .set_bias_level = rk616_set_bias_level,
2882         .reg_cache_size = ARRAY_SIZE(rk616_reg_defaults),
2883         .reg_word_size = sizeof(unsigned int),
2884         .reg_cache_default = rk616_reg_defaults,
2885         .volatile_register = rk616_volatile_register,
2886         .readable_register = rk616_codec_register,
2887 };
2888
2889 static int rk616_platform_probe(struct platform_device *pdev)
2890 {
2891         struct mfd_rk616 *rk616 = dev_get_drvdata(pdev->dev.parent);
2892
2893         DBG("%s\n", __func__);
2894
2895         if (!rk616) {
2896                 printk("%s : rk616 is NULL\n", __func__);
2897                 return -EINVAL;
2898         }
2899
2900         rk616_mfd = rk616;
2901
2902         return snd_soc_register_codec(&pdev->dev,
2903                         &soc_codec_dev_rk616, rk616_dai, ARRAY_SIZE(rk616_dai));
2904 }
2905
2906 static int rk616_platform_remove(struct platform_device *pdev)
2907 {
2908         snd_soc_unregister_codec(&pdev->dev);
2909         return 0;
2910 }
2911
2912 void rk616_platform_shutdown(struct platform_device *pdev)
2913 {
2914         struct rk616_codec_priv *rk616 = rk616_priv;
2915         struct snd_soc_codec *codec;
2916
2917         DBG("%s\n", __func__);
2918
2919         if (!rk616 || !rk616->codec) {
2920                 printk("%s : rk616_priv or rk616_priv->codec is NULL\n", __func__);
2921                 return;
2922         }
2923
2924         codec = rk616->codec;
2925
2926         rk616_set_gpio(RK616_CODEC_SET_SPK | RK616_CODEC_SET_HP, GPIO_LOW);
2927
2928         mdelay(10);
2929
2930         snd_soc_write(codec, RK616_RESET, 0xfc);
2931         mdelay(10);
2932         snd_soc_write(codec, RK616_RESET, 0x3);
2933
2934         if (rk616)
2935                 kfree(rk616);
2936 }
2937
2938 static struct platform_driver rk616_codec_driver = {
2939         .driver = {
2940                    .name = "rk616-codec",
2941                    .owner = THIS_MODULE,
2942                    },
2943         .probe = rk616_platform_probe,
2944         .remove = rk616_platform_remove,
2945         .shutdown = rk616_platform_shutdown,
2946 };
2947
2948
2949 static __init int rk616_modinit(void)
2950 {
2951         rk616_get_parameter();
2952         return platform_driver_register(&rk616_codec_driver);
2953 }
2954 module_init(rk616_modinit);
2955
2956 static __exit void rk616_exit(void)
2957 {
2958         platform_driver_unregister(&rk616_codec_driver);
2959 }
2960 module_exit(rk616_exit);
2961
2962 MODULE_DESCRIPTION("ASoC RK616 driver");
2963 MODULE_AUTHOR("chenjq <chenjq@rock-chips.com>");
2964 MODULE_LICENSE("GPL");