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