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