sound/soc/codecs/msm8x16-wcd.c

   1 #include <linux/delay.h>
   2 #include <linux/err.h>
   3 #include <linux/interrupt.h>
   4 #include <linux/module.h>
   5 #include <linux/regulator/consumer.h>
   6 #include <linux/types.h>
   7 #include <linux/clk.h>
   8 #include <linux/io.h>
   9 #include <linux/of.h>
  10 #include <linux/of_device.h>
  11 #include <linux/platform_device.h>
  12 #include <linux/regmap.h>
  13 #include <linux/mfd/syscon.h>
  14
  15 #include <sound/soc.h>
  16 #include <sound/soc-dapm.h>
  17 #include <sound/pcm.h>
  18 #include <sound/pcm_params.h>
  19 #include <sound/tlv.h>
  20
  21 #include "msm8x16-wcd.h"
  22 #include "msm8x16_wcd_registers.h"
  23
  24 #define MSM8X16_WCD_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
  25                         SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000)
  26 #define MSM8X16_WCD_FORMATS (SNDRV_PCM_FMTBIT_S16_LE |\
  27                 SNDRV_PCM_FMTBIT_S24_LE)
  28
  29 #define TOMBAK_VERSION_1_0      0
  30 #define TOMBAK_IS_1_0(ver) \
  31         ((ver == TOMBAK_VERSION_1_0) ? 1 : 0)
  32
  33 #define HPHL_PA_DISABLE (0x01 << 1)
  34 #define HPHR_PA_DISABLE (0x01 << 2)
  35 #define EAR_PA_DISABLE (0x01 << 3)
  36 #define SPKR_PA_DISABLE (0x01 << 4)
  37
  38 #define MICBIAS_DEFAULT_VAL 1800000
  39 #define MICBIAS_MIN_VAL 1600000
  40 #define MICBIAS_STEP_SIZE 50000
  41
  42 #define DEFAULT_BOOST_VOLTAGE 5000
  43 #define MIN_BOOST_VOLTAGE 4000
  44 #define MAX_BOOST_VOLTAGE 5550
  45 #define BOOST_VOLTAGE_STEP 50
  46
  47 #define VOLTAGE_CONVERTER(value, min_value, step_size)\
  48         ((value - min_value)/step_size);
  49
  50 enum {
  51         AIF1_PB = 0,
  52         AIF1_CAP,
  53         NUM_CODEC_DAIS,
  54 };
  55
  56 static unsigned long rx_digital_gain_reg[] = {
  57         MSM8X16_WCD_A_CDC_RX1_VOL_CTL_B2_CTL,
  58         MSM8X16_WCD_A_CDC_RX2_VOL_CTL_B2_CTL,
  59         MSM8X16_WCD_A_CDC_RX3_VOL_CTL_B2_CTL,
  60 };
  61
  62 static unsigned long tx_digital_gain_reg[] = {
  63         MSM8X16_WCD_A_CDC_TX1_VOL_CTL_GAIN,
  64         MSM8X16_WCD_A_CDC_TX2_VOL_CTL_GAIN,
  65 };
  66
  67 struct wcd_chip {
  68         struct regmap   *analog_map;
  69         struct regmap   *digital_map;
  70         unsigned int    analog_base;
  71         u16 pmic_rev;
  72         u16 codec_version;
  73         bool spk_boost_set;
  74         u32 mute_mask;
  75         u32 rx_bias_count;
  76         bool ear_pa_boost_set;
  77         bool lb_mode;
  78         struct clk *mclk;
  79
  80         struct regulator *vddio;
  81         struct regulator *vdd_pa;
  82         struct regulator *vdd_px;
  83         struct regulator *vdd_cp;
  84         struct regulator *vdd_mic_bias;
  85 };
  86
  87 static int msm8x16_wcd_volatile(struct snd_soc_codec *codec, unsigned int reg)
  88 {
  89         return msm8x16_wcd_reg_readonly[reg];
  90 }
  91
  92 static int msm8x16_wcd_readable(struct snd_soc_codec *ssc, unsigned int reg)
  93 {
  94         return msm8x16_wcd_reg_readable[reg];
  95 }
  96
  97 static int __msm8x16_wcd_reg_write(struct snd_soc_codec *codec,
  98                         unsigned short reg, u8 val)
  99 {
 100         int ret = -EINVAL;
 101         struct wcd_chip *chip = dev_get_drvdata(codec->dev);
 102
 103         if (MSM8X16_WCD_IS_TOMBAK_REG(reg)) {
 104                 ret = regmap_write(chip->analog_map,
 105                                    chip->analog_base + reg, val);
 106         } else if (MSM8X16_WCD_IS_DIGITAL_REG(reg)) {
 107                 u32 temp = val & 0x000000FF;
 108                 u16 offset = (reg ^ 0x0200) & 0x0FFF;
 109
 110                 ret = regmap_write(chip->digital_map, offset, temp);
 111         }
 112
 113         return ret;
 114 }
 115
 116 static int msm8x16_wcd_write(struct snd_soc_codec *codec, unsigned int reg,
 117                              unsigned int value)
 118 {
 119         if (reg == SND_SOC_NOPM)
 120                 return 0;
 121
 122         BUG_ON(reg > MSM8X16_WCD_MAX_REGISTER);
 123         if (!msm8x16_wcd_volatile(codec, reg))
 124                 msm8x16_wcd_reset_reg_defaults[reg] = value;
 125
 126         return __msm8x16_wcd_reg_write(codec, reg, (u8)value);
 127 }
 128
 129 static int __msm8x16_wcd_reg_read(struct snd_soc_codec *codec,
 130                                 unsigned short reg)
 131 {
 132         int ret = -EINVAL;
 133         u32 temp = 0;
 134         struct wcd_chip *chip = dev_get_drvdata(codec->dev);
 135
 136         if (MSM8X16_WCD_IS_TOMBAK_REG(reg)) {
 137                 ret = regmap_read(chip->analog_map,
 138                                   chip->analog_base + reg, &temp);
 139         } else if (MSM8X16_WCD_IS_DIGITAL_REG(reg)) {
 140                 u32 val;
 141                 u16 offset = (reg ^ 0x0200) & 0x0FFF;
 142
 143                 ret = regmap_read(chip->digital_map, offset, &val);
 144                 temp = (u8)val;
 145         }
 146
 147         if (ret < 0) {
 148                 dev_err(codec->dev,
 149                                 "%s: codec read failed for reg 0x%x\n",
 150                                 __func__, reg);
 151                 return ret;
 152         }
 153
 154         dev_dbg(codec->dev, "Read 0x%02x from 0x%x\n", temp, reg);
 155
 156         return temp;
 157 }
 158
 159 static unsigned int msm8x16_wcd_read(struct snd_soc_codec *codec,
 160                                 unsigned int reg)
 161 {
 162         unsigned int val;
 163
 164         if (reg == SND_SOC_NOPM)
 165                 return 0;
 166
 167         BUG_ON(reg > MSM8X16_WCD_MAX_REGISTER);
 168
 169         if (!msm8x16_wcd_volatile(codec, reg) &&
 170             msm8x16_wcd_readable(codec, reg) &&
 171                 reg < codec->driver->reg_cache_size) {
 172                 return msm8x16_wcd_reset_reg_defaults[reg];
 173         }
 174
 175         val = __msm8x16_wcd_reg_read(codec, reg);
 176
 177         return val;
 178 }
 179
 180 static const struct msm8x16_wcd_reg_mask_val msm8x16_wcd_reg_defaults[] = {
 181         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 0x03),
 182         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_CURRENT_LIMIT, 0x82),
 183         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_OCP_CTL, 0xE1),
 184 };
 185
 186 static const struct msm8x16_wcd_reg_mask_val msm8x16_wcd_reg_defaults_2_0[] = {
 187         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_DIGITAL_PERPH_RESET_CTL3, 0x0F),
 188         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_TX_1_2_OPAMP_BIAS, 0x4B),
 189         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_NCP_FBCTRL, 0x28),
 190         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_DRV_CTL, 0x69),
 191         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_DRV_DBG, 0x01),
 192         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_BOOST_EN_CTL, 0x5F),
 193         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SLOPE_COMP_IP_ZERO, 0x88),
 194         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_PERPH_RESET_CTL3, 0x0F),
 195         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_CURRENT_LIMIT, 0x82),
 196         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 0x03),
 197         MSM8X16_WCD_REG_VAL(MSM8X16_WCD_A_ANALOG_SPKR_OCP_CTL, 0xE1),
 198 };
 199
 200 static int msm8x16_wcd_bringup(struct snd_soc_codec *codec)
 201 {
 202         snd_soc_write(codec, MSM8X16_WCD_A_DIGITAL_PERPH_RESET_CTL4, 0x01);
 203         snd_soc_write(codec, MSM8X16_WCD_A_ANALOG_PERPH_RESET_CTL4, 0x01);
 204         return 0;
 205 }
 206
 207 static const struct msm8x16_wcd_reg_mask_val
 208         msm8x16_wcd_codec_reg_init_val[] = {
 209
 210         /* Initialize current threshold to 350MA
 211          * number of wait and run cycles to 4096
 212          */
 213         {MSM8X16_WCD_A_ANALOG_RX_COM_OCP_CTL, 0xFF, 0xD1},
 214         {MSM8X16_WCD_A_ANALOG_RX_COM_OCP_COUNT, 0xFF, 0xFF},
 215 };
 216
 217 static void msm8x16_wcd_codec_init_reg(struct snd_soc_codec *codec)
 218 {
 219         u32 i;
 220
 221         for (i = 0; i < ARRAY_SIZE(msm8x16_wcd_codec_reg_init_val); i++)
 222                 snd_soc_update_bits(codec,
 223                                     msm8x16_wcd_codec_reg_init_val[i].reg,
 224                                     msm8x16_wcd_codec_reg_init_val[i].mask,
 225                                     msm8x16_wcd_codec_reg_init_val[i].val);
 226 }
 227
 228 static void msm8x16_wcd_update_reg_defaults(struct snd_soc_codec *codec)
 229 {
 230         u32 i;
 231         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
 232
 233         if (TOMBAK_IS_1_0(msm8x16_wcd->pmic_rev)) {
 234                 for (i = 0; i < ARRAY_SIZE(msm8x16_wcd_reg_defaults); i++)
 235                         snd_soc_write(codec, msm8x16_wcd_reg_defaults[i].reg,
 236                                         msm8x16_wcd_reg_defaults[i].val);
 237         } else {
 238                 for (i = 0; i < ARRAY_SIZE(msm8x16_wcd_reg_defaults_2_0); i++)
 239                         snd_soc_write(codec,
 240                                 msm8x16_wcd_reg_defaults_2_0[i].reg,
 241                                 msm8x16_wcd_reg_defaults_2_0[i].val);
 242         }
 243 }
 244
 245 static int msm8x16_wcd_device_up(struct snd_soc_codec *codec)
 246 {
 247         u32 reg;
 248
 249         dev_dbg(codec->dev, "%s: device up!\n", __func__);
 250         msm8x16_wcd_bringup(codec);
 251
 252         for (reg = 0; reg < ARRAY_SIZE(msm8x16_wcd_reset_reg_defaults); reg++)
 253                 if (msm8x16_wcd_reg_readable[reg])
 254                         msm8x16_wcd_write(codec,
 255                                 reg, msm8x16_wcd_reset_reg_defaults[reg]);
 256
 257         /* delay is required to make sure sound card state updated */
 258         usleep_range(5000, 5100);
 259
 260         msm8x16_wcd_codec_init_reg(codec);
 261         msm8x16_wcd_update_reg_defaults(codec);
 262
 263         return 0;
 264 }
 265
 266 static int msm8x16_wcd_codec_enable_clock_block(struct snd_soc_codec *codec,
 267                                                 int enable)
 268 {
 269         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
 270         unsigned long mclk_rate;
 271
 272         if (enable) {
 273                 snd_soc_update_bits(codec,
 274                         MSM8X16_WCD_A_CDC_CLK_MCLK_CTL, 0x01, 0x01);
 275                 snd_soc_update_bits(codec,
 276                         MSM8X16_WCD_A_CDC_CLK_PDM_CTL, 0x03, 0x03);
 277                 snd_soc_update_bits(codec,
 278                         MSM8X16_WCD_A_ANALOG_MASTER_BIAS_CTL, 0x30, 0x30);
 279                 snd_soc_update_bits(codec,
 280                         MSM8X16_WCD_A_DIGITAL_CDC_RST_CTL, 0x80, 0x80);
 281                 snd_soc_update_bits(codec,
 282                         MSM8X16_WCD_A_DIGITAL_CDC_TOP_CLK_CTL, 0x0C, 0x0C);
 283
 284                 mclk_rate = clk_get_rate(msm8x16_wcd->mclk);
 285
 286                 if (mclk_rate == 12288000)
 287                         snd_soc_update_bits(codec,
 288                                 MSM8X16_WCD_A_CDC_TOP_CTL, 0x01, 0x00);
 289                 else if (mclk_rate == 9600000)
 290                         snd_soc_update_bits(codec,
 291                                 MSM8X16_WCD_A_CDC_TOP_CTL, 0x01, 0x01);
 292         } else {
 293                 snd_soc_update_bits(codec,
 294                         MSM8X16_WCD_A_DIGITAL_CDC_TOP_CLK_CTL, 0x0C, 0x00);
 295                 snd_soc_update_bits(codec,
 296                                 MSM8X16_WCD_A_CDC_CLK_PDM_CTL, 0x03, 0x00);
 297
 298         }
 299         return 0;
 300 }
 301
 302 #define MICBIAS_EXT_BYP_CAP 0x00
 303 #define MICBIAS_NO_EXT_BYP_CAP 0x01
 304
 305 static void msm8x16_wcd_configure_cap(struct snd_soc_codec *codec,
 306                 bool micbias1, bool micbias2)
 307 {
 308
 309 //      struct msm8916_asoc_mach_data *pdata = NULL;
 310 //FIXME should come from DT
 311         int micbias1_cap_mode = MICBIAS_EXT_BYP_CAP, micbias2_cap_mode = MICBIAS_NO_EXT_BYP_CAP;
 312
 313         //pdata = snd_soc_card_get_drvdata(codec->card);
 314
 315         pr_debug("\n %s: micbias1 %x micbias2 = %d\n", __func__, micbias1,
 316                         micbias2);
 317         if (micbias1 && micbias2) {
 318                 if ((micbias1_cap_mode
 319                      == MICBIAS_EXT_BYP_CAP) ||
 320                     (micbias2_cap_mode
 321                      == MICBIAS_EXT_BYP_CAP))
 322                         snd_soc_update_bits(codec,
 323                                 MSM8X16_WCD_A_ANALOG_MICB_1_EN,
 324                                 0x40, (MICBIAS_EXT_BYP_CAP << 6));
 325                 else
 326                         snd_soc_update_bits(codec,
 327                                 MSM8X16_WCD_A_ANALOG_MICB_1_EN,
 328                                 0x40, (MICBIAS_NO_EXT_BYP_CAP << 6));
 329         } else if (micbias2) {
 330                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_MICB_1_EN,
 331                                 0x40, (micbias2_cap_mode << 6));
 332         } else if (micbias1) {
 333                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_MICB_1_EN,
 334                                 0x40, (micbias1_cap_mode << 6));
 335         } else {
 336                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_MICB_1_EN,
 337                                 0x40, 0x00);
 338         }
 339 }
 340
 341 static int msm8x16_wcd_codec_probe(struct snd_soc_codec *codec)
 342 {
 343         struct wcd_chip *chip = dev_get_drvdata(codec->dev);
 344         int err;
 345
 346         snd_soc_codec_set_drvdata(codec, chip);
 347
 348         regulator_set_voltage(chip->vddio, 1800000, 1800000);
 349         err = regulator_enable(chip->vddio);
 350         if (err < 0) {
 351                 dev_err(codec->dev, "failed to enable VDD regulator\n");
 352                 return err;
 353         }
 354         regulator_set_voltage(chip->vdd_pa, 1800000, 2200000);
 355         err = regulator_enable(chip->vdd_pa);
 356         if (err < 0) {
 357                 dev_err(codec->dev, "failed to enable VDD regulator\n");
 358                 return err;
 359         }
 360
 361         regulator_set_voltage(chip->vdd_mic_bias, 3075000, 3075000);
 362         err = regulator_enable(chip->vdd_mic_bias);
 363         if (err < 0) {
 364                 dev_err(codec->dev, "failed to enable micbias regulator\n");
 365                 return err;
 366         }
 367
 368         chip->pmic_rev = snd_soc_read(codec, MSM8X16_WCD_A_DIGITAL_REVISION1);
 369         dev_info(codec->dev, "%s :PMIC REV: %d", __func__,
 370                                         chip->pmic_rev);
 371
 372         chip->codec_version = snd_soc_read(codec,
 373                         MSM8X16_WCD_A_DIGITAL_PERPH_SUBTYPE);
 374         dev_info(codec->dev, "%s :CODEC Version: %d", __func__,
 375                                 chip->codec_version);
 376
 377         msm8x16_wcd_device_up(codec);
 378
 379         /* Set initial cap mode */
 380         msm8x16_wcd_configure_cap(codec, false, false);
 381
 382         msm8x16_wcd_codec_enable_clock_block(codec, 1);
 383
 384         return 0;
 385 }
 386
 387 static int msm8x16_wcd_startup(struct snd_pcm_substream *substream,
 388                 struct snd_soc_dai *dai)
 389 {
 390         dev_dbg(dai->codec->dev, "%s(): substream = %s  stream = %d\n",
 391                 __func__,
 392                 substream->name, substream->stream);
 393         return 0;
 394 }
 395
 396 static void msm8x16_wcd_shutdown(struct snd_pcm_substream *substream,
 397                 struct snd_soc_dai *dai)
 398 {
 399         dev_dbg(dai->codec->dev,
 400                 "%s(): substream = %s  stream = %d\n", __func__,
 401                 substream->name, substream->stream);
 402 }
 403
 404 static int msm8x16_wcd_set_interpolator_rate(struct snd_soc_dai *dai,
 405         u8 rx_fs_rate_reg_val, u32 sample_rate)
 406 {
 407         return 0;
 408 }
 409
 410 static int msm8x16_wcd_set_decimator_rate(struct snd_soc_dai *dai,
 411         u8 tx_fs_rate_reg_val, u32 sample_rate)
 412 {
 413
 414         return 0;
 415 }
 416
 417 static int msm8x16_wcd_hw_params(struct snd_pcm_substream *substream,
 418                             struct snd_pcm_hw_params *params,
 419                             struct snd_soc_dai *dai)
 420 {
 421         u8 tx_fs_rate, rx_fs_rate;
 422         int ret;
 423
 424         dev_err(dai->codec->dev,
 425                 "%s: dai_name = %s DAI-ID %x rate %d num_ch %d format %d\n",
 426                 __func__, dai->name, dai->id, params_rate(params),
 427                 params_channels(params), params_format(params));
 428
 429         switch (params_rate(params)) {
 430         case 8000:
 431                 tx_fs_rate = 0x00;
 432                 rx_fs_rate = 0x00;
 433                 break;
 434         case 16000:
 435                 tx_fs_rate = 0x01;
 436                 rx_fs_rate = 0x20;
 437                 break;
 438         case 32000:
 439                 tx_fs_rate = 0x02;
 440                 rx_fs_rate = 0x40;
 441                 break;
 442         case 48000:
 443                 tx_fs_rate = 0x03;
 444                 rx_fs_rate = 0x60;
 445                 break;
 446         case 96000:
 447                 tx_fs_rate = 0x04;
 448                 rx_fs_rate = 0x80;
 449                 break;
 450         case 192000:
 451                 tx_fs_rate = 0x05;
 452                 rx_fs_rate = 0xA0;
 453                 break;
 454         default:
 455                 dev_err(dai->codec->dev,
 456                         "%s: Invalid sampling rate %d\n", __func__,
 457                         params_rate(params));
 458                 return -EINVAL;
 459         }
 460
 461         switch (substream->stream) {
 462         case SNDRV_PCM_STREAM_CAPTURE:
 463                 snd_soc_update_bits(dai->codec,
 464                                 MSM8X16_WCD_A_CDC_CLK_TX_I2S_CTL, 0x07, tx_fs_rate);
 465                 ret = msm8x16_wcd_set_decimator_rate(dai, tx_fs_rate,
 466                                                params_rate(params));
 467                 if (ret < 0) {
 468                         dev_err(dai->codec->dev,
 469                                 "%s: set decimator rate failed %d\n", __func__,
 470                                 ret);
 471                         return ret;
 472                 }
 473                 break;
 474         case SNDRV_PCM_STREAM_PLAYBACK:
 475                 ret = msm8x16_wcd_set_interpolator_rate(dai, rx_fs_rate,
 476                                                   params_rate(params));
 477                 if (ret < 0) {
 478                         dev_err(dai->codec->dev,
 479                                 "%s: set decimator rate failed %d\n", __func__,
 480                                 ret);
 481                         return ret;
 482                 }
 483                 break;
 484         default:
 485                 dev_err(dai->codec->dev,
 486                         "%s: Invalid stream type %d\n", __func__,
 487                         substream->stream);
 488                 return -EINVAL;
 489         }
 490
 491         switch (params_format(params)) {
 492         case SNDRV_PCM_FORMAT_S16_LE:
 493                 snd_soc_update_bits(dai->codec,
 494                                 MSM8X16_WCD_A_CDC_CLK_TX_I2S_CTL, 0x20, 0x20);
 495                 snd_soc_update_bits(dai->codec,
 496                                 MSM8X16_WCD_A_CDC_CLK_RX_I2S_CTL, 0x20, 0x20);
 497                 break;
 498         case SNDRV_PCM_FORMAT_S24_LE:
 499                 snd_soc_update_bits(dai->codec,
 500                                 MSM8X16_WCD_A_CDC_CLK_TX_I2S_CTL, 0x20, 0x00);
 501                 snd_soc_update_bits(dai->codec,
 502                                 MSM8X16_WCD_A_CDC_CLK_RX_I2S_CTL, 0x20, 0x00);
 503                 break;
 504         default:
 505                 dev_err(dai->dev, "%s: wrong format selected\n",
 506                                 __func__);
 507                 return -EINVAL;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int msm8x16_wcd_set_dai_sysclk(struct snd_soc_dai *dai,
 514                 int clk_id, unsigned int freq, int dir)
 515 {
 516         dev_dbg(dai->codec->dev, "%s\n", __func__);
 517         return 0;
 518 }
 519
 520 static int msm8x16_wcd_set_channel_map(struct snd_soc_dai *dai,
 521                                 unsigned int tx_num, unsigned int *tx_slot,
 522                                 unsigned int rx_num, unsigned int *rx_slot)
 523
 524 {
 525         dev_dbg(dai->codec->dev, "%s\n", __func__);
 526         return 0;
 527 }
 528
 529 static int msm8x16_wcd_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt)
 530 {
 531         dev_dbg(dai->codec->dev, "%s\n", __func__);
 532
 533         return 0;
 534 }
 535
 536 static struct snd_soc_dai_ops msm8x16_wcd_dai_ops = {
 537         .startup = msm8x16_wcd_startup,
 538         .shutdown = msm8x16_wcd_shutdown,
 539         .hw_params = msm8x16_wcd_hw_params,
 540         .set_sysclk = msm8x16_wcd_set_dai_sysclk,
 541         .set_fmt = msm8x16_wcd_set_dai_fmt,
 542         .set_channel_map = msm8x16_wcd_set_channel_map,
 543 };
 544
 545 static struct snd_soc_dai_driver msm8x16_wcd_codec_dai[] = {
 546         [0] = {
 547                 .name = "msm8x16_wcd_i2s_rx1",
 548                 .id = AIF1_PB,
 549                 .playback = {
 550                         .stream_name = "AIF1 Playback",
 551                         .rates = MSM8X16_WCD_RATES,
 552                         .formats = MSM8X16_WCD_FORMATS,
 553                         .rate_max = 192000,
 554                         .rate_min = 8000,
 555                         .channels_min = 1,
 556                         .channels_max = 3,
 557                 },
 558                 .ops = &msm8x16_wcd_dai_ops,
 559         },
 560         [1] = {
 561                 .name = "msm8x16_wcd_i2s_tx1",
 562                 .id = AIF1_CAP,
 563                 .capture = {
 564                         .stream_name = "AIF1 Capture",
 565                         .rates = MSM8X16_WCD_RATES,
 566                         .formats = MSM8X16_WCD_FORMATS,
 567                         .rate_max = 192000,
 568                         .rate_min = 8000,
 569                         .channels_min = 1,
 570                         .channels_max = 4,
 571                 },
 572                 .ops = &msm8x16_wcd_dai_ops,
 573         },
 574 };
 575
 576 static int msm8x16_wcd_codec_remove(struct snd_soc_codec *codec)
 577 {
 578         /* TODO */
 579         return 0;
 580 };
 581
 582 static int msm8x16_wcd_spk_boost_get(struct snd_kcontrol *kcontrol,
 583                                 struct snd_ctl_elem_value *ucontrol)
 584 {
 585         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 586         struct wcd_chip *msm8x16_wcd = dev_get_drvdata(codec->dev);
 587
 588         if (msm8x16_wcd->spk_boost_set == false) {
 589                 ucontrol->value.integer.value[0] = 0;
 590         } else if (msm8x16_wcd->spk_boost_set == true) {
 591                 ucontrol->value.integer.value[0] = 1;
 592         } else  {
 593                 dev_err(codec->dev, "%s: ERROR: Unsupported Speaker Boost = %d\n",
 594                         __func__, msm8x16_wcd->spk_boost_set);
 595                 return -EINVAL;
 596         }
 597
 598         dev_dbg(codec->dev, "%s: msm8x16_wcd->spk_boost_set = %d\n", __func__,
 599                         msm8x16_wcd->spk_boost_set);
 600         return 0;
 601 }
 602
 603 static int msm8x16_wcd_spk_boost_set(struct snd_kcontrol *kcontrol,
 604                                 struct snd_ctl_elem_value *ucontrol)
 605 {
 606         struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
 607         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
 608
 609         switch (ucontrol->value.integer.value[0]) {
 610         case 0:
 611                 msm8x16_wcd->spk_boost_set = false;
 612                 break;
 613         case 1:
 614                 msm8x16_wcd->spk_boost_set = true;
 615                 break;
 616         default:
 617                 return -EINVAL;
 618         }
 619         dev_dbg(codec->dev, "%s: msm8x16_wcd->spk_boost_set = %d\n",
 620                 __func__, msm8x16_wcd->spk_boost_set);
 621         return 0;
 622 }
 623
 624 static const char * const hph_text[] = {
 625         "ZERO", "Switch",
 626 };
 627
 628 static const struct soc_enum hph_enum =
 629         SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(hph_text), hph_text);
 630
 631 static const struct snd_kcontrol_new hphl_mux[] = {
 632         SOC_DAPM_ENUM("HPHL", hph_enum)
 633 };
 634
 635 static const struct snd_kcontrol_new hphr_mux[] = {
 636         SOC_DAPM_ENUM("HPHR", hph_enum)
 637 };
 638
 639 static const struct snd_kcontrol_new spkr_switch[] = {
 640         SOC_DAPM_SINGLE("Switch",
 641                 MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 7, 1, 0)
 642 };
 643
 644 static void msm8x16_wcd_codec_enable_adc_block(struct snd_soc_codec *codec,
 645                                          int enable)
 646 {
 647         //struct msm8x16_wcd_priv *wcd8x16 = snd_soc_codec_get_drvdata(codec);
 648
 649         dev_dbg(codec->dev, "%s %d\n", __func__, enable);
 650
 651         if (enable) {
 652                 //wcd8x16->adc_count++;
 653                 snd_soc_update_bits(codec,
 654                                     MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL,
 655                                     0x20, 0x20);
 656                 snd_soc_update_bits(codec,
 657                                     MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
 658                                     0x10, 0x10);
 659         } else {
 660                 //wcd8x16->adc_count--;
 661                 //if (!wcd8x16->adc_count) {
 662                         snd_soc_update_bits(codec,
 663                                     MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
 664                                     0x10, 0x00);
 665                         snd_soc_update_bits(codec,
 666                                     MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL,
 667                                             0x20, 0x0);
 668                 //}
 669         }
 670 }
 671
 672 static const DECLARE_TLV_DB_SCALE(digital_gain, 0, 1, 0);
 673 static const DECLARE_TLV_DB_SCALE(analog_gain, 0, 25, 1);
 674
 675 static const char * const rx_mix1_text[] = {
 676         "ZERO", "IIR1", "IIR2", "RX1", "RX2", "RX3"
 677 };
 678
 679 static const char * const rx_mix2_text[] = {
 680         "ZERO", "IIR1", "IIR2"
 681 };
 682
 683 static const char * const dec_mux_text[] = {
 684         "ZERO", "ADC1", "ADC2", "ADC3", "DMIC1", "DMIC2"
 685 };
 686
 687 static const char * const adc2_mux_text[] = {
 688         "ZERO", "INP2", "INP3"
 689 };
 690
 691 static const char * const rdac2_mux_text[] = {
 692         "ZERO", "RX2", "RX1"
 693 };
 694
 695 static const char * const iir_inp1_text[] = {
 696         "ZERO", "DEC1", "DEC2", "RX1", "RX2", "RX3"
 697 };
 698
 699 static const char * const iir1_inp1_text[] = {
 700         "ZERO", "DEC1", "DEC2", "RX1", "RX2", "RX3"
 701 };
 702
 703 static const struct soc_enum adc2_enum =
 704         SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(adc2_mux_text), adc2_mux_text);
 705
 706 /* RX1 MIX1 */
 707 static const struct soc_enum rx_mix1_inp1_chain_enum =
 708         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX1_B1_CTL,
 709                 0, 6, rx_mix1_text);
 710
 711 static const struct soc_enum rx_mix1_inp2_chain_enum =
 712         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX1_B1_CTL,
 713                 3, 6, rx_mix1_text);
 714
 715 static const struct soc_enum rx_mix1_inp3_chain_enum =
 716         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX1_B2_CTL,
 717                 0, 6, rx_mix1_text);
 718 /* RX1 MIX2 */
 719 static const struct soc_enum rx_mix2_inp1_chain_enum =
 720         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX1_B3_CTL,
 721                 0, 3, rx_mix2_text);
 722
 723 /* RX2 MIX1 */
 724 static const struct soc_enum rx2_mix1_inp1_chain_enum =
 725         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX2_B1_CTL,
 726                 0, 6, rx_mix1_text);
 727
 728 static const struct soc_enum rx2_mix1_inp2_chain_enum =
 729         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX2_B1_CTL,
 730                 3, 6, rx_mix1_text);
 731
 732 static const struct soc_enum rx2_mix1_inp3_chain_enum =
 733         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX2_B1_CTL,
 734                 0, 6, rx_mix1_text);
 735
 736 /* RX2 MIX2 */
 737 static const struct soc_enum rx2_mix2_inp1_chain_enum =
 738         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX2_B3_CTL,
 739                 0, 3, rx_mix2_text);
 740
 741 /* RX3 MIX1 */
 742 static const struct soc_enum rx3_mix1_inp1_chain_enum =
 743         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX3_B1_CTL,
 744                 0, 6, rx_mix1_text);
 745
 746 static const struct soc_enum rx3_mix1_inp2_chain_enum =
 747         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX3_B1_CTL,
 748                 3, 6, rx_mix1_text);
 749
 750 /* DEC */
 751 static const struct soc_enum dec1_mux_enum =
 752         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_TX_B1_CTL,
 753                 0, 6, dec_mux_text);
 754
 755 static const struct soc_enum dec2_mux_enum =
 756         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_TX_B1_CTL,
 757                 3, 6, dec_mux_text);
 758
 759 static const struct soc_enum rdac2_mux_enum =
 760         SOC_ENUM_SINGLE(MSM8X16_WCD_A_DIGITAL_CDC_CONN_HPHR_DAC_CTL,
 761                 0, 3, rdac2_mux_text);
 762
 763 static const struct soc_enum iir1_inp1_mux_enum =
 764         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_EQ1_B1_CTL,
 765                 0, 6, iir_inp1_text);
 766
 767 static const struct soc_enum iir2_inp1_mux_enum =
 768         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_EQ2_B1_CTL,
 769                 0, 6, iir_inp1_text);
 770 static const struct snd_kcontrol_new iir2_inp1_mux =
 771         SOC_DAPM_ENUM("IIR2 INP1 Mux", iir2_inp1_mux_enum);
 772
 773 static const struct soc_enum rx3_mix1_inp3_chain_enum =
 774         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_CONN_RX3_B1_CTL,
 775                 0, 6, rx_mix1_text);
 776 static const struct snd_kcontrol_new rx_mix1_inp1_mux =
 777         SOC_DAPM_ENUM("RX1 MIX1 INP1 Mux", rx_mix1_inp1_chain_enum);
 778
 779 static const struct snd_kcontrol_new dec1_mux =
 780         SOC_DAPM_ENUM("DEC1 MUX Mux", dec1_mux_enum);
 781
 782 static const struct snd_kcontrol_new dec2_mux =
 783         SOC_DAPM_ENUM("DEC2 MUX Mux", dec2_mux_enum);
 784
 785 static const struct snd_kcontrol_new rdac2_mux =
 786         SOC_DAPM_ENUM("RDAC2 MUX Mux", rdac2_mux_enum);
 787
 788 static const struct snd_kcontrol_new iir1_inp1_mux =
 789         SOC_DAPM_ENUM("IIR1 INP1 Mux", iir1_inp1_mux_enum);
 790
 791 static const struct snd_kcontrol_new rx_mix1_inp2_mux =
 792         SOC_DAPM_ENUM("RX1 MIX1 INP2 Mux", rx_mix1_inp2_chain_enum);
 793
 794 static const struct snd_kcontrol_new rx_mix1_inp3_mux =
 795         SOC_DAPM_ENUM("RX1 MIX1 INP3 Mux", rx_mix1_inp3_chain_enum);
 796
 797 static const struct snd_kcontrol_new rx2_mix1_inp1_mux =
 798         SOC_DAPM_ENUM("RX2 MIX1 INP1 Mux", rx2_mix1_inp1_chain_enum);
 799
 800 static const struct snd_kcontrol_new rx2_mix1_inp2_mux =
 801         SOC_DAPM_ENUM("RX2 MIX1 INP2 Mux", rx2_mix1_inp2_chain_enum);
 802
 803 static const struct snd_kcontrol_new rx2_mix1_inp3_mux =
 804         SOC_DAPM_ENUM("RX2 MIX1 INP3 Mux", rx2_mix1_inp3_chain_enum);
 805
 806 static const struct snd_kcontrol_new rx3_mix1_inp1_mux =
 807         SOC_DAPM_ENUM("RX3 MIX1 INP1 Mux", rx3_mix1_inp1_chain_enum);
 808
 809 static const struct snd_kcontrol_new rx3_mix1_inp2_mux =
 810         SOC_DAPM_ENUM("RX3 MIX1 INP2 Mux", rx3_mix1_inp2_chain_enum);
 811
 812 static const struct snd_kcontrol_new rx3_mix1_inp3_mux =
 813         SOC_DAPM_ENUM("RX3 MIX1 INP3 Mux", rx3_mix1_inp3_chain_enum);
 814
 815 static const struct snd_kcontrol_new rx1_mix2_inp1_mux =
 816         SOC_DAPM_ENUM("RX1 MIX2 INP1 Mux", rx_mix2_inp1_chain_enum);
 817
 818 static const struct snd_kcontrol_new rx2_mix2_inp1_mux =
 819         SOC_DAPM_ENUM("RX2 MIX2 INP1 Mux", rx2_mix2_inp1_chain_enum);
 820
 821 static const struct snd_kcontrol_new tx_adc2_mux =
 822         SOC_DAPM_ENUM("ADC2 MUX Mux", adc2_enum);
 823
 824 static const char * const msm8x16_wcd_loopback_mode_ctrl_text[] = {
 825                 "DISABLE", "ENABLE"};
 826 static const struct soc_enum msm8x16_wcd_loopback_mode_ctl_enum[] = {
 827                 SOC_ENUM_SINGLE_EXT(2, msm8x16_wcd_loopback_mode_ctrl_text),
 828 };
 829
 830 static int msm8x16_wcd_codec_enable_on_demand_supply(
 831                 struct snd_soc_dapm_widget *w,
 832                 struct snd_kcontrol *kcontrol, int event)
 833 {
 834         int ret = 0;
 835         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 836         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
 837
 838         switch (event) {
 839         case SND_SOC_DAPM_PRE_PMU:
 840                 ret = regulator_enable(msm8x16_wcd->vdd_mic_bias);
 841                 if (ret)
 842                 dev_err(codec->dev, "%s: Failed to enable vdd micbias\n",
 843                         __func__);
 844                 break;
 845         case SND_SOC_DAPM_POST_PMD:
 846                 ret = regulator_disable(msm8x16_wcd->vdd_mic_bias);
 847                 if (ret)
 848                         dev_err(codec->dev, "%s: Failed to disable vdd-micbias\n",
 849                                 __func__);
 850                 break;
 851         default:
 852                 break;
 853         }
 854
 855         return ret;
 856 }
 857
 858 static const char * const msm8x16_wcd_ear_pa_boost_ctrl_text[] = {
 859                 "DISABLE", "ENABLE"};
 860 static const struct soc_enum msm8x16_wcd_ear_pa_boost_ctl_enum[] = {
 861                 SOC_ENUM_SINGLE_EXT(2, msm8x16_wcd_ear_pa_boost_ctrl_text),
 862 };
 863
 864 static const char * const msm8x16_wcd_ear_pa_gain_text[] = {
 865                 "POS_6_DB", "POS_1P5_DB"};
 866 static const struct soc_enum msm8x16_wcd_ear_pa_gain_enum[] = {
 867                 SOC_ENUM_SINGLE_EXT(2, msm8x16_wcd_ear_pa_gain_text),
 868 };
 869
 870 static const char * const msm8x16_wcd_spk_boost_ctrl_text[] = {
 871                 "DISABLE", "ENABLE"};
 872 static const struct soc_enum msm8x16_wcd_spk_boost_ctl_enum[] = {
 873                 SOC_ENUM_SINGLE_EXT(2, msm8x16_wcd_spk_boost_ctrl_text),
 874 };
 875
 876 /*cut of frequency for high pass filter*/
 877 static const char * const cf_text[] = {
 878         "MIN_3DB_4Hz", "MIN_3DB_75Hz", "MIN_3DB_150Hz"
 879 };
 880
 881 static const struct soc_enum cf_dec1_enum =
 882         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_TX1_MUX_CTL, 4, 3, cf_text);
 883
 884 static const struct soc_enum cf_dec2_enum =
 885         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_TX2_MUX_CTL, 4, 3, cf_text);
 886
 887 static const struct soc_enum cf_rxmix1_enum =
 888         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_RX1_B4_CTL, 0, 3, cf_text);
 889
 890 static const struct soc_enum cf_rxmix2_enum =
 891         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_RX2_B4_CTL, 0, 3, cf_text);
 892
 893 static const struct soc_enum cf_rxmix3_enum =
 894         SOC_ENUM_SINGLE(MSM8X16_WCD_A_CDC_RX3_B4_CTL, 0, 3, cf_text);
 895
 896 static const struct snd_kcontrol_new msm8x16_wcd_snd_controls[] = {
 897
 898         SOC_ENUM_EXT("Speaker Boost", msm8x16_wcd_spk_boost_ctl_enum[0],
 899                 msm8x16_wcd_spk_boost_get, msm8x16_wcd_spk_boost_set),
 900
 901         SOC_SINGLE_TLV("ADC1 Volume", MSM8X16_WCD_A_ANALOG_TX_1_EN, 3,
 902                                         8, 0, analog_gain),
 903         SOC_SINGLE_TLV("ADC2 Volume", MSM8X16_WCD_A_ANALOG_TX_2_EN, 3,
 904                                         8, 0, analog_gain),
 905         SOC_SINGLE_TLV("ADC3 Volume", MSM8X16_WCD_A_ANALOG_TX_3_EN, 3,
 906                                         8, 0, analog_gain),
 907
 908         SOC_SINGLE_SX_TLV("RX1 Digital Volume",
 909                           MSM8X16_WCD_A_CDC_RX1_VOL_CTL_B2_CTL,
 910                         0,  -84, 40, digital_gain),
 911         SOC_SINGLE_SX_TLV("RX2 Digital Volume",
 912                           MSM8X16_WCD_A_CDC_RX2_VOL_CTL_B2_CTL,
 913                         0,  -84, 40, digital_gain),
 914         SOC_SINGLE_SX_TLV("RX3 Digital Volume",
 915                           MSM8X16_WCD_A_CDC_RX3_VOL_CTL_B2_CTL,
 916                         0,  -84, 40, digital_gain),
 917
 918         SOC_SINGLE("RX1 HPF Switch",
 919                 MSM8X16_WCD_A_CDC_RX1_B5_CTL, 2, 1, 0),
 920         SOC_SINGLE("RX2 HPF Switch",
 921                 MSM8X16_WCD_A_CDC_RX2_B5_CTL, 2, 1, 0),
 922         SOC_SINGLE("RX3 HPF Switch",
 923                 MSM8X16_WCD_A_CDC_RX3_B5_CTL, 2, 1, 0),
 924
 925         SOC_ENUM("RX1 HPF cut off", cf_rxmix1_enum),
 926         SOC_ENUM("RX2 HPF cut off", cf_rxmix2_enum),
 927         SOC_ENUM("RX3 HPF cut off", cf_rxmix3_enum),
 928 };
 929
 930 static const struct snd_kcontrol_new ear_pa_switch[] = {
 931         SOC_DAPM_SINGLE("Switch",
 932                 MSM8X16_WCD_A_ANALOG_RX_EAR_CTL, 5, 1, 0)
 933 };
 934
 935 static int msm8x16_wcd_codec_enable_ear_pa(struct snd_soc_dapm_widget *w,
 936         struct snd_kcontrol *kcontrol, int event)
 937 {
 938         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 939         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
 940
 941         switch (event) {
 942         case SND_SOC_DAPM_PRE_PMU:
 943                 dev_dbg(codec->dev,
 944                         "%s: Sleeping 20ms after select EAR PA\n",
 945                         __func__);
 946                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_RX_EAR_CTL,
 947                             0x80, 0x80);
 948                 break;
 949         case SND_SOC_DAPM_POST_PMU:
 950                 dev_dbg(codec->dev,
 951                         "%s: Sleeping 20ms after enabling EAR PA\n",
 952                         __func__);
 953                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_RX_EAR_CTL,
 954                             0x40, 0x40);
 955                 usleep_range(7000, 7100);
 956                 snd_soc_update_bits(codec,
 957                         MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x00);
 958                 break;
 959         case SND_SOC_DAPM_PRE_PMD:
 960                 snd_soc_update_bits(codec,
 961                         MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x01);
 962                 msleep(20);
 963                 msm8x16_wcd->mute_mask |= EAR_PA_DISABLE;
 964                 break;
 965         case SND_SOC_DAPM_POST_PMD:
 966                 dev_dbg(codec->dev,
 967                         "%s: Sleeping 7ms after disabling EAR PA\n",
 968                         __func__);
 969                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_RX_EAR_CTL,
 970                             0x40, 0x00);
 971                 usleep_range(7000, 7100);
 972                 /*
 973                  * Reset pa select bit from ear to hph after ear pa
 974                  * is disabled to reduce ear turn off pop
 975                  */
 976                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_RX_EAR_CTL,
 977                             0x80, 0x00);
 978                 break;
 979         }
 980         return 0;
 981 }
 982
 983 static int msm8x16_wcd_codec_enable_adc(struct snd_soc_dapm_widget *w,
 984         struct snd_kcontrol *kcontrol, int event)
 985 {
 986         //struct snd_soc_codec *codec = w->codec;
 987         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
 988         u16 adc_reg;
 989         u8 init_bit_shift;
 990
 991         dev_dbg(codec->dev, "%s %d\n", __func__, event);
 992
 993         adc_reg = MSM8X16_WCD_A_ANALOG_TX_1_2_TEST_CTL_2;
 994
 995         if (w->reg == MSM8X16_WCD_A_ANALOG_TX_1_EN)
 996                 init_bit_shift = 5;
 997         else if ((w->reg == MSM8X16_WCD_A_ANALOG_TX_2_EN) ||
 998                  (w->reg == MSM8X16_WCD_A_ANALOG_TX_3_EN))
 999                 init_bit_shift = 4;
1000         else {
1001                 dev_err(codec->dev, "%s: Error, invalid adc register\n",
1002                         __func__);
1003                 return -EINVAL;
1004         }
1005
1006         switch (event) {
1007         case SND_SOC_DAPM_PRE_PMU:
1008                 msm8x16_wcd_codec_enable_adc_block(codec, 1);
1009                 if (w->reg == MSM8X16_WCD_A_ANALOG_TX_2_EN)
1010                         snd_soc_update_bits(codec,
1011                         MSM8X16_WCD_A_ANALOG_MICB_1_CTL, 0x02, 0x02);
1012                 /*
1013                  * Add delay of 10 ms to give sufficient time for the voltage
1014                  * to shoot up and settle so that the txfe init does not
1015                  * happen when the input voltage is changing too much.
1016                  */
1017                 usleep_range(10000, 10010);
1018                 snd_soc_update_bits(codec, adc_reg, 1 << init_bit_shift,
1019                                 1 << init_bit_shift);
1020                 if (w->reg == MSM8X16_WCD_A_ANALOG_TX_1_EN)
1021                         snd_soc_update_bits(codec,
1022                                 MSM8X16_WCD_A_DIGITAL_CDC_CONN_TX1_CTL,
1023                                 0x03, 0x00);
1024                 else if ((w->reg == MSM8X16_WCD_A_ANALOG_TX_2_EN) ||
1025                         (w->reg == MSM8X16_WCD_A_ANALOG_TX_3_EN))
1026                         snd_soc_update_bits(codec,
1027                                 MSM8X16_WCD_A_DIGITAL_CDC_CONN_TX2_CTL,
1028                                 0x03, 0x00);
1029                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1030                 break;
1031         case SND_SOC_DAPM_POST_PMU:
1032                 /*
1033                  * Add delay of 12 ms before deasserting the init
1034                  * to reduce the tx pop
1035                  */
1036         usleep_range(12000, 12010);
1037                 snd_soc_update_bits(codec, adc_reg, 1 << init_bit_shift, 0x00);
1038                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1039                 break;
1040         case SND_SOC_DAPM_POST_PMD:
1041                 msm8x16_wcd_codec_enable_adc_block(codec, 0);
1042                 if (w->reg == MSM8X16_WCD_A_ANALOG_TX_2_EN)
1043                         snd_soc_update_bits(codec,
1044                         MSM8X16_WCD_A_ANALOG_MICB_1_CTL, 0x02, 0x00);
1045                 if (w->reg == MSM8X16_WCD_A_ANALOG_TX_1_EN)
1046                         snd_soc_update_bits(codec,
1047                                 MSM8X16_WCD_A_DIGITAL_CDC_CONN_TX1_CTL,
1048                                 0x03, 0x02);
1049                 else if ((w->reg == MSM8X16_WCD_A_ANALOG_TX_2_EN) ||
1050                         (w->reg == MSM8X16_WCD_A_ANALOG_TX_3_EN))
1051                         snd_soc_update_bits(codec,
1052                                 MSM8X16_WCD_A_DIGITAL_CDC_CONN_TX2_CTL,
1053                                 0x03, 0x02);
1054
1055                 break;
1056         }
1057         return 0;
1058 }
1059
1060 static int msm8x16_wcd_codec_enable_spk_pa(struct snd_soc_dapm_widget *w,
1061                                      struct snd_kcontrol *kcontrol, int event)
1062 {
1063         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1064         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1065
1066         switch (event) {
1067         case SND_SOC_DAPM_PRE_PMU:
1068                 snd_soc_update_bits(codec,
1069                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x10, 0x10);
1070                 snd_soc_update_bits(codec,
1071                         MSM8X16_WCD_A_ANALOG_SPKR_PWRSTG_CTL, 0x01, 0x01);
1072                 if (!msm8x16_wcd->spk_boost_set)
1073                         snd_soc_update_bits(codec,
1074                                 MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 0x10, 0x10);
1075                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1076                 snd_soc_update_bits(codec,
1077                         MSM8X16_WCD_A_ANALOG_SPKR_PWRSTG_CTL, 0xE0, 0xE0);
1078                 if (!TOMBAK_IS_1_0(msm8x16_wcd->pmic_rev))
1079                         snd_soc_update_bits(codec,
1080                                 MSM8X16_WCD_A_ANALOG_RX_EAR_CTL, 0x01, 0x01);
1081                 break;
1082         case SND_SOC_DAPM_POST_PMU:
1083                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1084                 if (msm8x16_wcd->spk_boost_set)
1085                         snd_soc_update_bits(codec,
1086                                 MSM8X16_WCD_A_ANALOG_SPKR_DRV_CTL, 0xEF, 0xEF);
1087                 else
1088                         snd_soc_update_bits(codec,
1089                                 MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 0x10, 0x00);
1090                 snd_soc_update_bits(codec,
1091                         MSM8X16_WCD_A_CDC_RX3_B6_CTL, 0x01, 0x00);
1092                 snd_soc_update_bits(codec, w->reg, 0x80, 0x80);
1093                 break;
1094         case SND_SOC_DAPM_PRE_PMD:
1095                 snd_soc_update_bits(codec,
1096                         MSM8X16_WCD_A_CDC_RX3_B6_CTL, 0x01, 0x01);
1097                 msleep(20);
1098                 msm8x16_wcd->mute_mask |= SPKR_PA_DISABLE;
1099                 snd_soc_update_bits(codec, w->reg, 0x80, 0x00);
1100                 if (msm8x16_wcd->spk_boost_set)
1101                         snd_soc_update_bits(codec,
1102                                 MSM8X16_WCD_A_ANALOG_SPKR_DRV_CTL, 0xEF, 0x00);
1103                 else
1104                         snd_soc_update_bits(codec,
1105                                 MSM8X16_WCD_A_ANALOG_SPKR_DAC_CTL, 0x10, 0x00);
1106                 break;
1107         case SND_SOC_DAPM_POST_PMD:
1108                 snd_soc_update_bits(codec,
1109                         MSM8X16_WCD_A_ANALOG_SPKR_PWRSTG_CTL, 0xE0, 0x00);
1110                 if (!TOMBAK_IS_1_0(msm8x16_wcd->pmic_rev))
1111                         snd_soc_update_bits(codec,
1112                                 MSM8X16_WCD_A_ANALOG_RX_EAR_CTL, 0x01, 0x00);
1113                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1114                 snd_soc_update_bits(codec,
1115                         MSM8X16_WCD_A_ANALOG_SPKR_PWRSTG_CTL, 0x01, 0x00);
1116                 snd_soc_update_bits(codec,
1117                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x10, 0x00);
1118                 break;
1119         }
1120         return 0;
1121 }
1122
1123 static void msm8x16_wcd_micbias_2_enable(struct snd_soc_codec *codec, bool on)
1124 {
1125         if (on) {
1126                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_MICB_1_CTL,
1127                                         0x60, 0x60);
1128                 snd_soc_write(codec, MSM8X16_WCD_A_ANALOG_MICB_1_VAL,
1129                                         0xC0);
1130                 /*
1131                  * Special headset needs MICBIAS as 2.7V so wait for
1132                  * 50 msec for the MICBIAS to reach 2.7 volts.
1133                  */
1134                 msleep(50);
1135                 snd_soc_update_bits(codec, MSM8X16_WCD_A_ANALOG_MICB_1_CTL,
1136                                 0x60, 0x00);
1137         }
1138 }
1139
1140 static s32 g_dmic_clk_cnt;
1141 static int msm8x16_wcd_codec_enable_dmic(struct snd_soc_dapm_widget *w,
1142         struct snd_kcontrol *kcontrol, int event)
1143 {
1144         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1145         u8  dmic_clk_en;
1146         u16 dmic_clk_reg;
1147         s32 *dmic_clk_cnt;
1148         unsigned int dmic;
1149         int ret;
1150         char *dec_num = strpbrk(w->name, "12");
1151
1152         if (dec_num == NULL) {
1153                 dev_err(codec->dev, "%s: Invalid DMIC\n", __func__);
1154                 return -EINVAL;
1155         }
1156
1157         ret = kstrtouint(dec_num, 10, &dmic);
1158         if (ret < 0) {
1159                 dev_err(codec->dev,
1160                         "%s: Invalid DMIC line on the codec\n", __func__);
1161                 return -EINVAL;
1162         }
1163
1164         switch (dmic) {
1165         case 1:
1166         case 2:
1167                 dmic_clk_en = 0x01;
1168                 dmic_clk_cnt = &g_dmic_clk_cnt;
1169                 dmic_clk_reg = MSM8X16_WCD_A_CDC_CLK_DMIC_B1_CTL;
1170                 dev_dbg(codec->dev,
1171                         "%s() event %d DMIC%d dmic_1_2_clk_cnt %d\n",
1172                         __func__, event,  dmic, *dmic_clk_cnt);
1173                 break;
1174         default:
1175                 dev_err(codec->dev, "%s: Invalid DMIC Selection\n", __func__);
1176                 return -EINVAL;
1177         }
1178
1179         switch (event) {
1180         case SND_SOC_DAPM_PRE_PMU:
1181                 (*dmic_clk_cnt)++;
1182                 if (*dmic_clk_cnt == 1) {
1183                         snd_soc_update_bits(codec, dmic_clk_reg,
1184                                         0x0E, 0x02);
1185                         snd_soc_update_bits(codec, dmic_clk_reg,
1186                                         dmic_clk_en, dmic_clk_en);
1187                 }
1188                 if (dmic == 1)
1189                         snd_soc_update_bits(codec,
1190                         MSM8X16_WCD_A_CDC_TX1_DMIC_CTL, 0x07, 0x01);
1191                 if (dmic == 2)
1192                         snd_soc_update_bits(codec,
1193                         MSM8X16_WCD_A_CDC_TX2_DMIC_CTL, 0x07, 0x01);
1194                 break;
1195         case SND_SOC_DAPM_POST_PMD:
1196                 (*dmic_clk_cnt)--;
1197                 if (*dmic_clk_cnt  == 0)
1198                         snd_soc_update_bits(codec, dmic_clk_reg,
1199                                         dmic_clk_en, 0);
1200                 break;
1201         }
1202         return 0;
1203 }
1204
1205 static int msm8x16_wcd_codec_enable_micbias(struct snd_soc_dapm_widget *w,
1206         struct snd_kcontrol *kcontrol, int event)
1207 {
1208         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1209         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1210         u16 micb_int_reg;
1211         char *internal1_text = "Internal1";
1212         char *internal2_text = "Internal2";
1213         char *internal3_text = "Internal3";
1214         char *external2_text = "External2";
1215         char *external_text = "External";
1216         bool micbias2;
1217
1218         switch (w->reg) {
1219         case MSM8X16_WCD_A_ANALOG_MICB_1_EN:
1220         case MSM8X16_WCD_A_ANALOG_MICB_2_EN:
1221                 micb_int_reg = MSM8X16_WCD_A_ANALOG_MICB_1_INT_RBIAS;
1222                 break;
1223         default:
1224                 dev_err(codec->dev,
1225                         "%s: Error, invalid micbias register 0x%x\n",
1226                         __func__, w->reg);
1227                 return -EINVAL;
1228         }
1229
1230         micbias2 = (snd_soc_read(codec, MSM8X16_WCD_A_ANALOG_MICB_2_EN) & 0x80);
1231
1232         switch (event) {
1233         case SND_SOC_DAPM_PRE_PMU:
1234                 if (strnstr(w->name, internal1_text, 30)) {
1235                         snd_soc_update_bits(codec, micb_int_reg, 0x80, 0x80);
1236                 } else if (strnstr(w->name, internal2_text, 30)) {
1237                         snd_soc_update_bits(codec, micb_int_reg, 0x10, 0x10);
1238                         snd_soc_update_bits(codec, w->reg, 0x60, 0x00);
1239                 } else if (strnstr(w->name, internal3_text, 30)) {
1240                         snd_soc_update_bits(codec, micb_int_reg, 0x2, 0x2);
1241                 }
1242                 if (!strnstr(w->name, external_text, 30))
1243                         snd_soc_update_bits(codec,
1244                                 MSM8X16_WCD_A_ANALOG_MICB_1_EN, 0x05, 0x04);
1245                 if (w->reg == MSM8X16_WCD_A_ANALOG_MICB_1_EN)
1246                         msm8x16_wcd_configure_cap(codec, true, micbias2);
1247
1248                 break;
1249         case SND_SOC_DAPM_POST_PMU:
1250                 usleep_range(20000, 20100);
1251                 if (strnstr(w->name, internal1_text, 30)) {
1252                         snd_soc_update_bits(codec, micb_int_reg, 0x40, 0x40);
1253                 } else if (strnstr(w->name, internal2_text, 30)) {
1254                         snd_soc_update_bits(codec, micb_int_reg, 0x08, 0x08);
1255                         msm8x16_wcd_micbias_2_enable(codec, true);
1256
1257                         msm8x16_wcd_configure_cap(codec, false, true);
1258                         regmap_write(msm8x16_wcd->analog_map, 0xf144, 0x95);
1259                 } else if (strnstr(w->name, internal3_text, 30)) {
1260                         snd_soc_update_bits(codec, micb_int_reg, 0x01, 0x01);
1261                 }  else if (strnstr(w->name, external2_text, 30)) {
1262                         msm8x16_wcd_micbias_2_enable(codec, true);
1263                 }
1264                 break;
1265         case SND_SOC_DAPM_POST_PMD:
1266                 if (strnstr(w->name, internal1_text, 30)) {
1267                         snd_soc_update_bits(codec, micb_int_reg, 0xC0, 0x40);
1268                 } else if (strnstr(w->name, internal2_text, 30)) {
1269                         msm8x16_wcd_micbias_2_enable(codec, false);
1270                 } else if (strnstr(w->name, internal3_text, 30)) {
1271                         snd_soc_update_bits(codec, micb_int_reg, 0x2, 0x0);
1272                 } else if (strnstr(w->name, external2_text, 30)) {
1273                         /*
1274                          * send micbias turn off event to mbhc driver and then
1275                          * break, as no need to set MICB_1_EN register.
1276                          */
1277                         msm8x16_wcd_micbias_2_enable(codec, false);
1278                         break;
1279                 }
1280                 if (w->reg == MSM8X16_WCD_A_ANALOG_MICB_1_EN)
1281                         msm8x16_wcd_configure_cap(codec, false, micbias2);
1282                 break;
1283         }
1284
1285         return 0;
1286 }
1287
1288 #define  TX_MUX_CTL_CUT_OFF_FREQ_MASK   0x30
1289 #define  CF_MIN_3DB_4HZ                 0x0
1290 #define  CF_MIN_3DB_75HZ                0x1
1291 #define  CF_MIN_3DB_150HZ               0x2
1292
1293 static int msm8x16_wcd_codec_enable_dec(struct snd_soc_dapm_widget *w,
1294         struct snd_kcontrol *kcontrol, int event)
1295 {
1296         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1297         unsigned int decimator;
1298         char *dec_name = NULL;
1299         char *widget_name = NULL;
1300         char *temp;
1301         int ret = 0;
1302         u16 dec_reset_reg, tx_vol_ctl_reg, tx_mux_ctl_reg;
1303         u8 dec_hpf_cut_of_freq;
1304         int offset;
1305         char *dec_num;
1306         dev_dbg(codec->dev, "%s %d\n", __func__, event);
1307
1308         widget_name = kstrndup(w->name, 15, GFP_KERNEL);
1309         if (!widget_name)
1310                 return -ENOMEM;
1311         temp = widget_name;
1312
1313         dec_name = strsep(&widget_name, " ");
1314         widget_name = temp;
1315         if (!dec_name) {
1316                 dev_err(codec->dev,
1317                         "%s: Invalid decimator = %s\n", __func__, w->name);
1318                 ret = -EINVAL;
1319                 goto out;
1320         }
1321
1322         dec_num = strpbrk(dec_name, "12");
1323         if (dec_num == NULL) {
1324                 dev_err(codec->dev, "%s: Invalid Decimator\n", __func__);
1325                 ret = -EINVAL;
1326                 goto out;
1327         }
1328
1329         ret = kstrtouint(dec_num, 10, &decimator);
1330         if (ret < 0) {
1331                 dev_err(codec->dev,
1332                         "%s: Invalid decimator = %s\n", __func__, dec_name);
1333                 ret = -EINVAL;
1334                 goto out;
1335         }
1336
1337         dev_err(codec->dev,
1338                 "%s(): widget = %s dec_name = %s decimator = %u\n", __func__,
1339                 w->name, dec_name, decimator);
1340
1341         if (w->reg == MSM8X16_WCD_A_CDC_CLK_TX_CLK_EN_B1_CTL) {
1342                 dec_reset_reg = MSM8X16_WCD_A_CDC_CLK_TX_RESET_B1_CTL;
1343                 offset = 0;
1344         } else {
1345                 dev_err(codec->dev, "%s: Error, incorrect dec\n", __func__);
1346                 ret = -EINVAL;
1347                 goto out;
1348         }
1349
1350         tx_vol_ctl_reg = MSM8X16_WCD_A_CDC_TX1_VOL_CTL_CFG +
1351                          32 * (decimator - 1);
1352         tx_mux_ctl_reg = MSM8X16_WCD_A_CDC_TX1_MUX_CTL +
1353                           32 * (decimator - 1);
1354
1355         switch (event) {
1356         case SND_SOC_DAPM_PRE_PMU:
1357                 /* Enableable TX digital mute */
1358                 snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x01, 0x01);
1359                 dec_hpf_cut_of_freq = snd_soc_read(codec, tx_mux_ctl_reg);
1360                 dec_hpf_cut_of_freq = (dec_hpf_cut_of_freq & 0x30) >> 4;
1361                 if ((dec_hpf_cut_of_freq != CF_MIN_3DB_150HZ)) {
1362
1363                         /* set cut of freq to CF_MIN_3DB_150HZ (0x1); */
1364                         snd_soc_update_bits(codec, tx_mux_ctl_reg, 0x30,
1365                                             CF_MIN_3DB_150HZ << 4);
1366                 }
1367                 snd_soc_update_bits(codec,
1368                                 MSM8X16_WCD_A_ANALOG_TX_1_2_TXFE_CLKDIV,
1369                                 0xFF, 0x42);
1370
1371                 break;
1372         case SND_SOC_DAPM_POST_PMU:
1373                 /* enable HPF */
1374                 snd_soc_update_bits(codec, tx_mux_ctl_reg , 0x08, 0x00);
1375                 /* apply the digital gain after the decimator is enabled*/
1376                 if ((w->shift) < ARRAY_SIZE(tx_digital_gain_reg))
1377                         snd_soc_write(codec,
1378                                   tx_digital_gain_reg[w->shift + offset],
1379                                   snd_soc_read(codec,
1380                                   tx_digital_gain_reg[w->shift + offset])
1381                                   );
1382                 snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x01, 0x00);
1383                 break;
1384         case SND_SOC_DAPM_PRE_PMD:
1385                 snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x01, 0x01);
1386                 msleep(20);
1387                 snd_soc_update_bits(codec, tx_mux_ctl_reg, 0x08, 0x08);
1388                 break;
1389         case SND_SOC_DAPM_POST_PMD:
1390                 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift,
1391                         1 << w->shift);
1392                 snd_soc_update_bits(codec, dec_reset_reg, 1 << w->shift, 0x0);
1393                 snd_soc_update_bits(codec, tx_mux_ctl_reg, 0x08, 0x08);
1394                 snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x01, 0x00);
1395                 break;
1396         }
1397
1398 out:
1399         kfree(widget_name);
1400         return ret;
1401 }
1402
1403 static int msm8x16_wcd_codec_enable_interpolator(struct snd_soc_dapm_widget *w,
1404                                                  struct snd_kcontrol *kcontrol,
1405                                                  int event)
1406 {
1407         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1408         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1409
1410         switch (event) {
1411         case SND_SOC_DAPM_POST_PMU:
1412                 /* apply the digital gain after the interpolator is enabled*/
1413                 if ((w->shift) < ARRAY_SIZE(rx_digital_gain_reg))
1414                         snd_soc_write(codec,
1415                                   rx_digital_gain_reg[w->shift],
1416                                   snd_soc_read(codec,
1417                                   rx_digital_gain_reg[w->shift])
1418                                   );
1419                 break;
1420         case SND_SOC_DAPM_POST_PMD:
1421                 snd_soc_update_bits(codec,
1422                         MSM8X16_WCD_A_CDC_CLK_RX_RESET_CTL,
1423                         1 << w->shift, 1 << w->shift);
1424                 snd_soc_update_bits(codec,
1425                         MSM8X16_WCD_A_CDC_CLK_RX_RESET_CTL,
1426                         1 << w->shift, 0x0);
1427                 /*
1428                  * disable the mute enabled during the PMD of this device
1429                  */
1430                 if (msm8x16_wcd->mute_mask & HPHL_PA_DISABLE) {
1431                         pr_debug("disabling HPHL mute\n");
1432                         snd_soc_update_bits(codec,
1433                                 MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x00);
1434                         msm8x16_wcd->mute_mask &= ~(HPHL_PA_DISABLE);
1435                 }
1436                 if (msm8x16_wcd->mute_mask & HPHR_PA_DISABLE) {
1437                         pr_debug("disabling HPHR mute\n");
1438                         snd_soc_update_bits(codec,
1439                                 MSM8X16_WCD_A_CDC_RX2_B6_CTL, 0x01, 0x00);
1440                         msm8x16_wcd->mute_mask &= ~(HPHR_PA_DISABLE);
1441                 }
1442                 if (msm8x16_wcd->mute_mask & SPKR_PA_DISABLE) {
1443                         pr_debug("disabling SPKR mute\n");
1444                         snd_soc_update_bits(codec,
1445                                 MSM8X16_WCD_A_CDC_RX3_B6_CTL, 0x01, 0x00);
1446                         msm8x16_wcd->mute_mask &= ~(SPKR_PA_DISABLE);
1447                 }
1448                 if (msm8x16_wcd->mute_mask & EAR_PA_DISABLE) {
1449                         pr_debug("disabling EAR mute\n");
1450                         snd_soc_update_bits(codec,
1451                                 MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x00);
1452                         msm8x16_wcd->mute_mask &= ~(EAR_PA_DISABLE);
1453                 }
1454         }
1455         return 0;
1456 }
1457
1458 static int msm8x16_wcd_codec_enable_dig_clk(struct snd_soc_dapm_widget *w,
1459                                      struct snd_kcontrol *kcontrol, int event)
1460 {
1461         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1462         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1463
1464         switch (event) {
1465         case SND_SOC_DAPM_PRE_PMU:
1466                 if (w->shift == 2)
1467                         snd_soc_update_bits(codec, w->reg, 0x80, 0x80);
1468                 if (msm8x16_wcd->spk_boost_set) {
1469                         snd_soc_update_bits(codec,
1470                                         MSM8X16_WCD_A_ANALOG_SEC_ACCESS,
1471                                         0xA5, 0xA5);
1472                         snd_soc_update_bits(codec,
1473                                         MSM8X16_WCD_A_ANALOG_PERPH_RESET_CTL3,
1474                                         0x0F, 0x0F);
1475                         snd_soc_update_bits(codec,
1476                                         MSM8X16_WCD_A_ANALOG_CURRENT_LIMIT,
1477                                         0x82, 0x82);
1478                         snd_soc_update_bits(codec,
1479                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1480                                         0x20, 0x20);
1481                         snd_soc_update_bits(codec,
1482                                         MSM8X16_WCD_A_ANALOG_BOOST_EN_CTL,
1483                                         0xDF, 0xDF);
1484                         usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1485                         snd_soc_update_bits(codec,
1486                                         MSM8X16_WCD_A_ANALOG_CURRENT_LIMIT,
1487                                         0x83, 0x83);
1488                 } else if (msm8x16_wcd->ear_pa_boost_set) {
1489                         snd_soc_update_bits(codec,
1490                                         MSM8X16_WCD_A_ANALOG_SEC_ACCESS,
1491                                         0xA5, 0xA5);
1492                         snd_soc_update_bits(codec,
1493                                         MSM8X16_WCD_A_ANALOG_PERPH_RESET_CTL3,
1494                                         0x07, 0x07);
1495                         snd_soc_update_bits(codec,
1496                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1497                                         0x40, 0x40);
1498                         snd_soc_update_bits(codec,
1499                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1500                                         0x80, 0x80);
1501                         snd_soc_update_bits(codec,
1502                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1503                                         0x02, 0x02);
1504                         snd_soc_update_bits(codec,
1505                                         MSM8X16_WCD_A_ANALOG_BOOST_EN_CTL,
1506                                         0xDF, 0xDF);
1507                 } else {
1508                         snd_soc_update_bits(codec, w->reg, 1<<w->shift,
1509                                         1<<w->shift);
1510                 }
1511                 break;
1512         case SND_SOC_DAPM_POST_PMD:
1513                 if (msm8x16_wcd->spk_boost_set) {
1514                         snd_soc_update_bits(codec,
1515                                         MSM8X16_WCD_A_ANALOG_BOOST_EN_CTL,
1516                                         0xDF, 0x5F);
1517                         snd_soc_update_bits(codec,
1518                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1519                                         0x20, 0x00);
1520                 } else if (msm8x16_wcd->ear_pa_boost_set) {
1521                         snd_soc_update_bits(codec,
1522                                         MSM8X16_WCD_A_ANALOG_BOOST_EN_CTL,
1523                                         0x80, 0x00);
1524                         snd_soc_update_bits(codec,
1525                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1526                                         0x80, 0x00);
1527                         snd_soc_update_bits(codec,
1528                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1529                                         0x02, 0x00);
1530                         snd_soc_update_bits(codec,
1531                                         MSM8X16_WCD_A_ANALOG_BYPASS_MODE,
1532                                         0x40, 0x00);
1533                 } else {
1534                         snd_soc_update_bits(codec, w->reg, 1<<w->shift, 0x00);
1535                 }
1536                 break;
1537         }
1538         return 0;
1539 }
1540
1541 static int msm8x16_wcd_codec_enable_rx_chain(struct snd_soc_dapm_widget *w,
1542         struct snd_kcontrol *kcontrol, int event)
1543 {
1544         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1545
1546         switch (event) {
1547         case SND_SOC_DAPM_POST_PMU:
1548                 snd_soc_update_bits(codec,
1549                                 MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1550                                 0x80, 0x80);
1551                 dev_dbg(codec->dev,
1552                         "%s: PMU:Sleeping 20ms after disabling mute\n",
1553                         __func__);
1554                 break;
1555         case SND_SOC_DAPM_POST_PMD:
1556                 snd_soc_update_bits(codec,
1557                                 MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1558                                 0x80, 0x00);
1559                 dev_dbg(codec->dev,
1560                         "%s: PMD:Sleeping 20ms after disabling mute\n",
1561                         __func__);
1562                 snd_soc_update_bits(codec, w->reg,
1563                             1 << w->shift, 0x00);
1564                 msleep(20);
1565                 break;
1566         }
1567         return 0;
1568 }
1569
1570 static int msm8x16_wcd_codec_enable_rx_bias(struct snd_soc_dapm_widget *w,
1571         struct snd_kcontrol *kcontrol, int event)
1572 {
1573         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1574         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1575
1576         switch (event) {
1577         case SND_SOC_DAPM_PRE_PMU:
1578                 msm8x16_wcd->rx_bias_count++;
1579                 if (msm8x16_wcd->rx_bias_count == 1)
1580                         snd_soc_update_bits(codec,
1581                                         MSM8X16_WCD_A_ANALOG_RX_COM_BIAS_DAC,
1582                                         0x81, 0x81);
1583                 break;
1584         case SND_SOC_DAPM_POST_PMD:
1585                 msm8x16_wcd->rx_bias_count--;
1586                 if (msm8x16_wcd->rx_bias_count == 0)
1587                         snd_soc_update_bits(codec,
1588                                         MSM8X16_WCD_A_ANALOG_RX_COM_BIAS_DAC,
1589                                         0x81, 0x00);
1590                 break;
1591         }
1592         dev_dbg(codec->dev, "%s rx_bias_count = %d\n",
1593                         __func__, msm8x16_wcd->rx_bias_count);
1594         return 0;
1595 }
1596
1597 static int msm8x16_wcd_codec_enable_charge_pump(struct snd_soc_dapm_widget *w,
1598                 struct snd_kcontrol *kcontrol, int event)
1599 {
1600         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1601         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1602
1603         switch (event) {
1604         case SND_SOC_DAPM_PRE_PMU:
1605                 if (!(strcmp(w->name, "EAR CP")))
1606                         snd_soc_update_bits(codec,
1607                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1608                                         0x80, 0x80);
1609                 else
1610                         snd_soc_update_bits(codec,
1611                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1612                                         0xC0, 0xC0);
1613                 break;
1614         case SND_SOC_DAPM_POST_PMU:
1615                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1616                 break;
1617         case SND_SOC_DAPM_POST_PMD:
1618                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1619                 if (!(strcmp(w->name, "EAR CP")))
1620                         snd_soc_update_bits(codec,
1621                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1622                                         0x80, 0x00);
1623                 else {
1624                         snd_soc_update_bits(codec,
1625                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1626                                         0x40, 0x00);
1627                         if (msm8x16_wcd->rx_bias_count == 0)
1628                                 snd_soc_update_bits(codec,
1629                                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1630                                         0x80, 0x00);
1631                         dev_dbg(codec->dev, "%s: rx_bias_count = %d\n",
1632                                         __func__, msm8x16_wcd->rx_bias_count);
1633                 }
1634                 break;
1635         }
1636         return 0;
1637 }
1638
1639 static int msm8x16_wcd_hphl_dac_event(struct snd_soc_dapm_widget *w,
1640         struct snd_kcontrol *kcontrol, int event)
1641 {
1642         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1643
1644         switch (event) {
1645         case SND_SOC_DAPM_PRE_PMU:
1646                 snd_soc_update_bits(codec,
1647                         MSM8X16_WCD_A_ANALOG_RX_HPH_L_PA_DAC_CTL, 0x02, 0x02);
1648                 snd_soc_update_bits(codec,
1649                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL, 0x01, 0x01);
1650                 snd_soc_update_bits(codec,
1651                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x02, 0x02);
1652                 break;
1653         case SND_SOC_DAPM_POST_PMU:
1654                 snd_soc_update_bits(codec,
1655                         MSM8X16_WCD_A_ANALOG_RX_HPH_L_PA_DAC_CTL, 0x02, 0x00);
1656                 break;
1657         case SND_SOC_DAPM_POST_PMD:
1658                 snd_soc_update_bits(codec,
1659                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x02, 0x00);
1660                 snd_soc_update_bits(codec,
1661                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL, 0x01, 0x00);
1662                 break;
1663         }
1664         return 0;
1665 }
1666
1667 static int msm8x16_wcd_hph_pa_event(struct snd_soc_dapm_widget *w,
1668                               struct snd_kcontrol *kcontrol, int event)
1669 {
1670         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1671         struct wcd_chip *msm8x16_wcd = snd_soc_codec_get_drvdata(codec);
1672
1673         switch (event) {
1674         case SND_SOC_DAPM_PRE_PMU:
1675                 if (w->shift == 5) {
1676                         snd_soc_update_bits(codec,
1677                                 MSM8X16_WCD_A_ANALOG_RX_HPH_L_TEST, 0x04, 0x04);
1678                 } else if (w->shift == 4) {
1679                         snd_soc_update_bits(codec,
1680                                 MSM8X16_WCD_A_ANALOG_RX_HPH_R_TEST, 0x04, 0x04);
1681                 }
1682                 snd_soc_update_bits(codec,
1683                                 MSM8X16_WCD_A_ANALOG_NCP_FBCTRL, 0x20, 0x20);
1684                 break;
1685
1686         case SND_SOC_DAPM_POST_PMU:
1687                 usleep_range(4000, 4100);
1688                 if (w->shift == 5)
1689                         snd_soc_update_bits(codec,
1690                                 MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x00);
1691                 else if (w->shift == 4)
1692                         snd_soc_update_bits(codec,
1693                                 MSM8X16_WCD_A_CDC_RX2_B6_CTL, 0x01, 0x00);
1694                 usleep_range(10000, 10100);
1695                 break;
1696
1697         case SND_SOC_DAPM_PRE_PMD:
1698                 if (w->shift == 5) {
1699                         snd_soc_update_bits(codec,
1700                                 MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0x01, 0x01);
1701                         msleep(20);
1702                         msm8x16_wcd->mute_mask |= HPHL_PA_DISABLE;
1703                 } else if (w->shift == 4) {
1704                         snd_soc_update_bits(codec,
1705                                 MSM8X16_WCD_A_CDC_RX2_B6_CTL, 0x01, 0x01);
1706                         msleep(20);
1707                         msm8x16_wcd->mute_mask |= HPHR_PA_DISABLE;
1708                 }
1709                 break;
1710         case SND_SOC_DAPM_POST_PMD:
1711                 if (w->shift == 5) {
1712                         snd_soc_update_bits(codec,
1713                                 MSM8X16_WCD_A_ANALOG_RX_HPH_L_TEST, 0x04, 0x00);
1714
1715                 } else if (w->shift == 4) {
1716                         snd_soc_update_bits(codec,
1717                                 MSM8X16_WCD_A_ANALOG_RX_HPH_R_TEST, 0x04, 0x00);
1718                 }
1719                 usleep_range(4000, 4100);
1720
1721                 usleep_range(CODEC_DELAY_1_MS, CODEC_DELAY_1_1_MS);
1722                 snd_soc_update_bits(codec,
1723                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL, 0x40, 0x40);
1724                 dev_dbg(codec->dev,
1725                         "%s: sleep 10 ms after %s PA disable.\n", __func__,
1726                         w->name);
1727                 usleep_range(10000, 10100);
1728                 break;
1729         }
1730         return 0;
1731 }
1732
1733 static const struct snd_soc_dapm_route audio_map[] = {
1734         {"RX_I2S_CLK", NULL, "CDC_CONN"},
1735         {"I2S RX1", NULL, "RX_I2S_CLK"},
1736         {"I2S RX2", NULL, "RX_I2S_CLK"},
1737         {"I2S RX3", NULL, "RX_I2S_CLK"},
1738
1739         {"I2S TX1", NULL, "TX_I2S_CLK"},
1740         {"I2S TX2", NULL, "TX_I2S_CLK"},
1741
1742         {"I2S TX1", NULL, "DEC1 MUX"},
1743         {"I2S TX2", NULL, "DEC2 MUX"},
1744
1745         /* RDAC Connections */
1746         {"HPHR DAC", NULL, "RDAC2 MUX"},
1747         {"RDAC2 MUX", "RX1", "RX1 CHAIN"},
1748         {"RDAC2 MUX", "RX2", "RX2 CHAIN"},
1749
1750         /* Earpiece (RX MIX1) */
1751         {"EAR", NULL, "EAR_S"},
1752         {"EAR_S", "Switch", "EAR PA"},
1753         {"EAR PA", NULL, "RX_BIAS"},
1754         {"EAR PA", NULL, "HPHL DAC"},
1755         {"EAR PA", NULL, "HPHR DAC"},
1756         {"EAR PA", NULL, "EAR CP"},
1757
1758         /* Headset (RX MIX1 and RX MIX2) */
1759         {"HEADPHONE", NULL, "HPHL PA"},
1760         {"HEADPHONE", NULL, "HPHR PA"},
1761
1762         {"HPHL PA", NULL, "HPHL"},
1763         {"HPHR PA", NULL, "HPHR"},
1764         {"HPHL", "Switch", "HPHL DAC"},
1765         {"HPHR", "Switch", "HPHR DAC"},
1766         {"HPHL PA", NULL, "CP"},
1767         {"HPHL PA", NULL, "RX_BIAS"},
1768         {"HPHR PA", NULL, "CP"},
1769         {"HPHR PA", NULL, "RX_BIAS"},
1770         {"HPHL DAC", NULL, "RX1 CHAIN"},
1771
1772         {"SPK_OUT", NULL, "SPK PA"},
1773         {"SPK PA", NULL, "SPK_RX_BIAS"},
1774         {"SPK PA", NULL, "SPK DAC"},
1775         {"SPK DAC", "Switch", "RX3 CHAIN"},
1776         {"SPK DAC", NULL, "VDD_SPKDRV"},
1777
1778         {"RX1 CHAIN", NULL, "RX1 CLK"},
1779         {"RX2 CHAIN", NULL, "RX2 CLK"},
1780         {"RX3 CHAIN", NULL, "RX3 CLK"},
1781         {"RX1 CHAIN", NULL, "RX1 MIX2"},
1782         {"RX2 CHAIN", NULL, "RX2 MIX2"},
1783         {"RX3 CHAIN", NULL, "RX3 MIX1"},
1784
1785         {"RX1 MIX1", NULL, "RX1 MIX1 INP1"},
1786         {"RX1 MIX1", NULL, "RX1 MIX1 INP2"},
1787         {"RX1 MIX1", NULL, "RX1 MIX1 INP3"},
1788         {"RX2 MIX1", NULL, "RX2 MIX1 INP1"},
1789         {"RX2 MIX1", NULL, "RX2 MIX1 INP2"},
1790         {"RX3 MIX1", NULL, "RX3 MIX1 INP1"},
1791         {"RX3 MIX1", NULL, "RX3 MIX1 INP2"},
1792         {"RX1 MIX2", NULL, "RX1 MIX1"},
1793         {"RX1 MIX2", NULL, "RX1 MIX2 INP1"},
1794         {"RX2 MIX2", NULL, "RX2 MIX1"},
1795         {"RX2 MIX2", NULL, "RX2 MIX2 INP1"},
1796
1797         {"RX1 MIX1 INP1", "RX1", "I2S RX1"},
1798         {"RX1 MIX1 INP1", "RX2", "I2S RX2"},
1799         {"RX1 MIX1 INP1", "RX3", "I2S RX3"},
1800         {"RX1 MIX1 INP1", "IIR1", "IIR1"},
1801         {"RX1 MIX1 INP1", "IIR2", "IIR2"},
1802         {"RX1 MIX1 INP2", "RX1", "I2S RX1"},
1803         {"RX1 MIX1 INP2", "RX2", "I2S RX2"},
1804         {"RX1 MIX1 INP2", "RX3", "I2S RX3"},
1805         {"RX1 MIX1 INP2", "IIR1", "IIR1"},
1806         {"RX1 MIX1 INP2", "IIR2", "IIR2"},
1807         {"RX1 MIX1 INP3", "RX1", "I2S RX1"},
1808         {"RX1 MIX1 INP3", "RX2", "I2S RX2"},
1809         {"RX1 MIX1 INP3", "RX3", "I2S RX3"},
1810
1811         {"RX2 MIX1 INP1", "RX1", "I2S RX1"},
1812         {"RX2 MIX1 INP1", "RX2", "I2S RX2"},
1813         {"RX2 MIX1 INP1", "RX3", "I2S RX3"},
1814         {"RX2 MIX1 INP1", "IIR1", "IIR1"},
1815         {"RX2 MIX1 INP1", "IIR2", "IIR2"},
1816         {"RX2 MIX1 INP2", "RX1", "I2S RX1"},
1817         {"RX2 MIX1 INP2", "RX2", "I2S RX2"},
1818         {"RX2 MIX1 INP2", "RX3", "I2S RX3"},
1819         {"RX2 MIX1 INP2", "IIR1", "IIR1"},
1820         {"RX2 MIX1 INP2", "IIR2", "IIR2"},
1821
1822         {"RX3 MIX1 INP1", "RX1", "I2S RX1"},
1823         {"RX3 MIX1 INP1", "RX2", "I2S RX2"},
1824         {"RX3 MIX1 INP1", "RX3", "I2S RX3"},
1825         {"RX3 MIX1 INP1", "IIR1", "IIR1"},
1826         {"RX3 MIX1 INP1", "IIR2", "IIR2"},
1827         {"RX3 MIX1 INP2", "RX1", "I2S RX1"},
1828         {"RX3 MIX1 INP2", "RX2", "I2S RX2"},
1829         {"RX3 MIX1 INP2", "RX3", "I2S RX3"},
1830         {"RX3 MIX1 INP2", "IIR1", "IIR1"},
1831         {"RX3 MIX1 INP2", "IIR2", "IIR2"},
1832
1833         {"RX1 MIX2 INP1", "IIR1", "IIR1"},
1834         {"RX2 MIX2 INP1", "IIR1", "IIR1"},
1835         {"RX1 MIX2 INP1", "IIR2", "IIR2"},
1836         {"RX2 MIX2 INP1", "IIR2", "IIR2"},
1837
1838         /* Decimator Inputs */
1839         {"DEC1 MUX", "DMIC1", "DMIC1"},
1840         {"DEC1 MUX", "DMIC2", "DMIC2"},
1841         {"DEC1 MUX", "ADC1", "ADC1"},
1842         {"DEC1 MUX", "ADC2", "ADC2"},
1843         {"DEC1 MUX", "ADC3", "ADC3"},
1844         {"DEC1 MUX", NULL, "CDC_CONN"},
1845
1846         {"DEC2 MUX", "DMIC1", "DMIC1"},
1847         {"DEC2 MUX", "DMIC2", "DMIC2"},
1848         {"DEC2 MUX", "ADC1", "ADC1"},
1849         {"DEC2 MUX", "ADC2", "ADC2"},
1850         {"DEC2 MUX", "ADC3", "ADC3"},
1851         {"DEC2 MUX", NULL, "CDC_CONN"},
1852
1853         /* ADC Connections */
1854         {"ADC2", NULL, "ADC2 MUX"},
1855         {"ADC3", NULL, "ADC2 MUX"},
1856         {"ADC2 MUX", "INP2", "ADC2_INP2"},
1857         {"ADC2 MUX", "INP3", "ADC2_INP3"},
1858
1859         {"ADC1", NULL, "AMIC1"},
1860         {"ADC2_INP2", NULL, "AMIC2"},
1861         {"ADC2_INP3", NULL, "AMIC3"},
1862
1863         /* TODO: Fix this */
1864         {"IIR1", NULL, "IIR1 INP1 MUX"},
1865         {"IIR1 INP1 MUX", "DEC1", "DEC1 MUX"},
1866         {"IIR1 INP1 MUX", "DEC2", "DEC2 MUX"},
1867         {"IIR2", NULL, "IIR2 INP1 MUX"},
1868         {"IIR2 INP1 MUX", "DEC1", "DEC1 MUX"},
1869         {"IIR2 INP1 MUX", "DEC2", "DEC2 MUX"},
1870         {"MIC BIAS Internal1", NULL, "INT_LDO_H"},
1871         {"MIC BIAS Internal2", NULL, "INT_LDO_H"},
1872         {"MIC BIAS External", NULL, "INT_LDO_H"},
1873         {"MIC BIAS External2", NULL, "INT_LDO_H"},
1874         {"MIC BIAS Internal1", NULL, "MICBIAS_REGULATOR"},
1875         {"MIC BIAS Internal2", NULL, "MICBIAS_REGULATOR"},
1876         {"MIC BIAS External", NULL, "MICBIAS_REGULATOR"},
1877         {"MIC BIAS External2", NULL, "MICBIAS_REGULATOR"},
1878 };
1879
1880 static int msm8x16_wcd_hphr_dac_event(struct snd_soc_dapm_widget *w,
1881         struct snd_kcontrol *kcontrol, int event)
1882 {
1883         struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
1884
1885         switch (event) {
1886         case SND_SOC_DAPM_PRE_PMU:
1887                 snd_soc_update_bits(codec,
1888                         MSM8X16_WCD_A_ANALOG_RX_HPH_R_PA_DAC_CTL, 0x02, 0x02);
1889                 snd_soc_update_bits(codec,
1890                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL, 0x02, 0x02);
1891                 snd_soc_update_bits(codec,
1892                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x01, 0x01);
1893                 break;
1894         case SND_SOC_DAPM_POST_PMU:
1895                 snd_soc_update_bits(codec,
1896                         MSM8X16_WCD_A_ANALOG_RX_HPH_R_PA_DAC_CTL, 0x02, 0x00);
1897                 break;
1898         case SND_SOC_DAPM_POST_PMD:
1899                 snd_soc_update_bits(codec,
1900                         MSM8X16_WCD_A_DIGITAL_CDC_ANA_CLK_CTL, 0x01, 0x00);
1901                 snd_soc_update_bits(codec,
1902                         MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL, 0x02, 0x00);
1903                 break;
1904         }
1905         return 0;
1906 }
1907
1908 static const struct snd_soc_dapm_widget msm8x16_wcd_dapm_widgets[] = {
1909         /*RX stuff */
1910         SND_SOC_DAPM_OUTPUT("EAR"),
1911
1912         SND_SOC_DAPM_PGA_E("EAR PA", SND_SOC_NOPM,
1913                         0, 0, NULL, 0, msm8x16_wcd_codec_enable_ear_pa,
1914                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1915                         SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
1916         SND_SOC_DAPM_MIXER("EAR_S", SND_SOC_NOPM, 0, 0,
1917                 ear_pa_switch, ARRAY_SIZE(ear_pa_switch)),
1918
1919         SND_SOC_DAPM_AIF_IN("I2S RX1", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1920
1921         SND_SOC_DAPM_AIF_IN("I2S RX2", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1922
1923         SND_SOC_DAPM_AIF_IN("I2S RX3", "AIF1 Playback", 0, SND_SOC_NOPM, 0, 0),
1924
1925         SND_SOC_DAPM_SUPPLY("INT_LDO_H", SND_SOC_NOPM, 1, 0, NULL, 0),
1926
1927         SND_SOC_DAPM_OUTPUT("HEADPHONE"),
1928         SND_SOC_DAPM_PGA_E("HPHL PA", MSM8X16_WCD_A_ANALOG_RX_HPH_CNP_EN,
1929                 5, 0, NULL, 0,
1930                 msm8x16_wcd_hph_pa_event, SND_SOC_DAPM_PRE_PMU |
1931                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD |
1932                 SND_SOC_DAPM_POST_PMD),
1933
1934         SND_SOC_DAPM_MUX("HPHL", SND_SOC_NOPM, 0, 0, hphl_mux),
1935
1936         SND_SOC_DAPM_MIXER_E("HPHL DAC",
1937                 MSM8X16_WCD_A_ANALOG_RX_HPH_L_PA_DAC_CTL, 3, 0, NULL,
1938                 0, msm8x16_wcd_hphl_dac_event,
1939                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1940                 SND_SOC_DAPM_POST_PMD),
1941
1942         SND_SOC_DAPM_PGA_E("HPHR PA", MSM8X16_WCD_A_ANALOG_RX_HPH_CNP_EN,
1943                 4, 0, NULL, 0,
1944                 msm8x16_wcd_hph_pa_event, SND_SOC_DAPM_PRE_PMU |
1945                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD |
1946                 SND_SOC_DAPM_POST_PMD),
1947         SND_SOC_DAPM_MUX("HPHR", SND_SOC_NOPM, 0, 0, hphr_mux),
1948
1949         SND_SOC_DAPM_MIXER_E("HPHR DAC",
1950                 MSM8X16_WCD_A_ANALOG_RX_HPH_R_PA_DAC_CTL, 3, 0, NULL,
1951                 0, msm8x16_wcd_hphr_dac_event,
1952                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1953                 SND_SOC_DAPM_POST_PMD),
1954
1955         SND_SOC_DAPM_MIXER("SPK DAC", SND_SOC_NOPM, 0, 0,
1956                 spkr_switch, ARRAY_SIZE(spkr_switch)),
1957
1958         /* Speaker */
1959         SND_SOC_DAPM_OUTPUT("SPK_OUT"),
1960
1961         SND_SOC_DAPM_PGA_E("SPK PA", MSM8X16_WCD_A_ANALOG_SPKR_DRV_CTL,
1962                         6, 0, NULL, 0, msm8x16_wcd_codec_enable_spk_pa,
1963                         SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
1964                         SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
1965
1966         SND_SOC_DAPM_MIXER_E("RX1 MIX1",
1967                         MSM8X16_WCD_A_CDC_CLK_RX_B1_CTL, 0, 0, NULL, 0,
1968                         msm8x16_wcd_codec_enable_interpolator,
1969                 SND_SOC_DAPM_PRE_REG|
1970                         SND_SOC_DAPM_POST_PMU |
1971                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD|
1972                         SND_SOC_DAPM_POST_PMD),
1973
1974         SND_SOC_DAPM_MIXER_E("RX2 MIX1",
1975                         MSM8X16_WCD_A_CDC_CLK_RX_B1_CTL, 1, 0, NULL, 0,
1976                         msm8x16_wcd_codec_enable_interpolator,
1977                 SND_SOC_DAPM_PRE_REG|
1978                         SND_SOC_DAPM_POST_PMU |
1979                         SND_SOC_DAPM_POST_PMD),
1980
1981         SND_SOC_DAPM_MIXER_E("RX1 MIX2",
1982                 MSM8X16_WCD_A_CDC_CLK_RX_B1_CTL, 0, 0, NULL,
1983                 0, msm8x16_wcd_codec_enable_interpolator,
1984                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1985         SND_SOC_DAPM_MIXER_E("RX2 MIX2",
1986                 MSM8X16_WCD_A_CDC_CLK_RX_B1_CTL, 1, 0, NULL,
1987                 0, msm8x16_wcd_codec_enable_interpolator,
1988                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1989         SND_SOC_DAPM_MIXER_E("RX3 MIX1",
1990                 MSM8X16_WCD_A_CDC_CLK_RX_B1_CTL, 2, 0, NULL,
1991                 0, msm8x16_wcd_codec_enable_interpolator,
1992                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
1993
1994         SND_SOC_DAPM_SUPPLY("RX1 CLK", MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1995                 0, 0, NULL, 0),
1996         SND_SOC_DAPM_SUPPLY("RX2 CLK", MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1997                 1, 0, NULL, 0),
1998         SND_SOC_DAPM_SUPPLY("RX3 CLK", MSM8X16_WCD_A_DIGITAL_CDC_DIG_CLK_CTL,
1999                 2, 0, msm8x16_wcd_codec_enable_dig_clk, SND_SOC_DAPM_PRE_PMU |
2000                 SND_SOC_DAPM_POST_PMD),
2001         SND_SOC_DAPM_MIXER_E("RX1 CHAIN", MSM8X16_WCD_A_CDC_RX1_B6_CTL, 0, 0,
2002                 NULL, 0,
2003                 msm8x16_wcd_codec_enable_rx_chain,
2004                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2005         SND_SOC_DAPM_MIXER_E("RX2 CHAIN", MSM8X16_WCD_A_CDC_RX2_B6_CTL, 0, 0,
2006                 NULL, 0,
2007                 msm8x16_wcd_codec_enable_rx_chain,
2008                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2009         SND_SOC_DAPM_MIXER_E("RX3 CHAIN", MSM8X16_WCD_A_CDC_RX3_B6_CTL, 0, 0,
2010                 NULL, 0,
2011                 msm8x16_wcd_codec_enable_rx_chain,
2012                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2013
2014         SND_SOC_DAPM_MUX("RX1 MIX1 INP1", SND_SOC_NOPM, 0, 0,
2015                 &rx_mix1_inp1_mux),
2016         SND_SOC_DAPM_MUX("RX1 MIX1 INP2", SND_SOC_NOPM, 0, 0,
2017                 &rx_mix1_inp2_mux),
2018         SND_SOC_DAPM_MUX("RX1 MIX1 INP3", SND_SOC_NOPM, 0, 0,
2019                 &rx_mix1_inp3_mux),
2020
2021         SND_SOC_DAPM_MUX("RX2 MIX1 INP1", SND_SOC_NOPM, 0, 0,
2022                 &rx2_mix1_inp1_mux),
2023         SND_SOC_DAPM_MUX("RX2 MIX1 INP2", SND_SOC_NOPM, 0, 0,
2024                 &rx2_mix1_inp2_mux),
2025         SND_SOC_DAPM_MUX("RX2 MIX1 INP3", SND_SOC_NOPM, 0, 0,
2026                 &rx2_mix1_inp3_mux),
2027
2028         SND_SOC_DAPM_MUX("RX3 MIX1 INP1", SND_SOC_NOPM, 0, 0,
2029                 &rx3_mix1_inp1_mux),
2030         SND_SOC_DAPM_MUX("RX3 MIX1 INP2", SND_SOC_NOPM, 0, 0,
2031                 &rx3_mix1_inp2_mux),
2032         SND_SOC_DAPM_MUX("RX3 MIX1 INP3", SND_SOC_NOPM, 0, 0,
2033                 &rx3_mix1_inp3_mux),
2034
2035         SND_SOC_DAPM_MUX("RX1 MIX2 INP1", SND_SOC_NOPM, 0, 0,
2036                 &rx1_mix2_inp1_mux),
2037         SND_SOC_DAPM_MUX("RX2 MIX2 INP1", SND_SOC_NOPM, 0, 0,
2038                 &rx2_mix2_inp1_mux),
2039
2040         SND_SOC_DAPM_SUPPLY("MICBIAS_REGULATOR", SND_SOC_NOPM,
2041                 ON_DEMAND_MICBIAS, 0,
2042                 msm8x16_wcd_codec_enable_on_demand_supply,
2043                 SND_SOC_DAPM_PRE_PMU |
2044                 SND_SOC_DAPM_POST_PMD),
2045
2046         SND_SOC_DAPM_SUPPLY("CP", MSM8X16_WCD_A_ANALOG_NCP_EN, 0, 0,
2047                 msm8x16_wcd_codec_enable_charge_pump, SND_SOC_DAPM_PRE_PMU |
2048                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2049
2050         SND_SOC_DAPM_SUPPLY("EAR CP", MSM8X16_WCD_A_ANALOG_NCP_EN, 4, 0,
2051                 msm8x16_wcd_codec_enable_charge_pump, SND_SOC_DAPM_PRE_PMU |
2052                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2053
2054         SND_SOC_DAPM_SUPPLY("RX_BIAS", SND_SOC_NOPM,
2055                 0, 0, msm8x16_wcd_codec_enable_rx_bias,
2056                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
2057
2058         SND_SOC_DAPM_SUPPLY("SPK_RX_BIAS", SND_SOC_NOPM, 0, 0,
2059                 msm8x16_wcd_codec_enable_rx_bias, SND_SOC_DAPM_PRE_PMU |
2060                 SND_SOC_DAPM_POST_PMD),
2061
2062         /* TX */
2063
2064         SND_SOC_DAPM_SUPPLY_S("CDC_CONN", -2, MSM8X16_WCD_A_CDC_CLK_OTHR_CTL,
2065                 2, 0, NULL, 0),
2066
2067         SND_SOC_DAPM_INPUT("AMIC1"),
2068         SND_SOC_DAPM_SUPPLY("MIC BIAS Internal1",
2069                 MSM8X16_WCD_A_ANALOG_MICB_1_EN, 7, 0,
2070                 msm8x16_wcd_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
2071                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2072         SND_SOC_DAPM_SUPPLY("MIC BIAS Internal2",
2073                 MSM8X16_WCD_A_ANALOG_MICB_2_EN, 7, 0,
2074                 msm8x16_wcd_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
2075                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2076         SND_SOC_DAPM_SUPPLY("MIC BIAS Internal3",
2077                 MSM8X16_WCD_A_ANALOG_MICB_1_EN, 7, 0,
2078                 msm8x16_wcd_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
2079                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2080         SND_SOC_DAPM_ADC_E("ADC1", NULL, MSM8X16_WCD_A_ANALOG_TX_1_EN, 7, 0,
2081                 msm8x16_wcd_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
2082                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2083         SND_SOC_DAPM_ADC_E("ADC2_INP2",
2084                 NULL, MSM8X16_WCD_A_ANALOG_TX_2_EN, 7, 0,
2085                 msm8x16_wcd_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
2086                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2087         SND_SOC_DAPM_ADC_E("ADC2_INP3",
2088                 NULL, MSM8X16_WCD_A_ANALOG_TX_3_EN, 7, 0,
2089                 msm8x16_wcd_codec_enable_adc, SND_SOC_DAPM_PRE_PMU |
2090                 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD),
2091
2092         SND_SOC_DAPM_MIXER("ADC2", SND_SOC_NOPM, 0, 0, NULL, 0),
2093         SND_SOC_DAPM_MIXER("ADC3", SND_SOC_NOPM, 0, 0, NULL, 0),
2094
2095         SND_SOC_DAPM_MUX("ADC2 MUX", SND_SOC_NOPM, 0, 0,
2096                 &tx_adc2_mux),
2097
2098         SND_SOC_DAPM_SUPPLY("MIC BIAS External",
2099                 MSM8X16_WCD_A_ANALOG_MICB_1_EN, 7, 0,
2100                 msm8x16_wcd_codec_enable_micbias, SND_SOC_DAPM_PRE_PMU |
2101                 SND_SOC_DAPM_POST_PMD),
2102
2103         SND_SOC_DAPM_SUPPLY("MIC BIAS External2",
2104                 MSM8X16_WCD_A_ANALOG_MICB_2_EN, 7, 0,
2105                 msm8x16_wcd_codec_enable_micbias, SND_SOC_DAPM_POST_PMU |
2106                 SND_SOC_DAPM_POST_PMD),
2107
2108
2109         SND_SOC_DAPM_INPUT("AMIC3"),
2110
2111         SND_SOC_DAPM_MUX_E("DEC1 MUX",
2112                 MSM8X16_WCD_A_CDC_CLK_TX_CLK_EN_B1_CTL, 0, 0,
2113                 &dec1_mux, msm8x16_wcd_codec_enable_dec,
2114                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2115                 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
2116
2117         SND_SOC_DAPM_MUX_E("DEC2 MUX",
2118                 MSM8X16_WCD_A_CDC_CLK_TX_CLK_EN_B1_CTL, 1, 0,
2119                 &dec2_mux, msm8x16_wcd_codec_enable_dec,
2120                 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
2121                 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
2122
2123         SND_SOC_DAPM_MUX("RDAC2 MUX", SND_SOC_NOPM, 0, 0, &rdac2_mux),
2124
2125         SND_SOC_DAPM_INPUT("AMIC2"),
2126
2127         SND_SOC_DAPM_AIF_OUT("I2S TX1", "AIF1 Capture", 0, SND_SOC_NOPM,
2128                 0, 0),
2129         SND_SOC_DAPM_AIF_OUT("I2S TX2", "AIF1 Capture", 0, SND_SOC_NOPM,
2130                 0, 0),
2131         SND_SOC_DAPM_AIF_OUT("I2S TX3", "AIF1 Capture", 0, SND_SOC_NOPM,
2132                 0, 0),
2133
2134
2135         /* Digital Mic Inputs */
2136         SND_SOC_DAPM_ADC_E("DMIC1", NULL, SND_SOC_NOPM, 0, 0,
2137                 msm8x16_wcd_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
2138                 SND_SOC_DAPM_POST_PMD),
2139
2140         SND_SOC_DAPM_ADC_E("DMIC2", NULL, SND_SOC_NOPM, 0, 0,
2141                 msm8x16_wcd_codec_enable_dmic, SND_SOC_DAPM_PRE_PMU |
2142                 SND_SOC_DAPM_POST_PMD),
2143
2144         /* Sidetone */
2145         SND_SOC_DAPM_MUX("IIR1 INP1 MUX", SND_SOC_NOPM, 0, 0, &iir1_inp1_mux),
2146         SND_SOC_DAPM_PGA("IIR1",
2147                 MSM8X16_WCD_A_CDC_CLK_SD_CTL, 0, 0, NULL, 0),
2148
2149         SND_SOC_DAPM_MUX("IIR2 INP1 MUX", SND_SOC_NOPM, 0, 0, &iir2_inp1_mux),
2150         SND_SOC_DAPM_PGA("IIR2",
2151                 MSM8X16_WCD_A_CDC_CLK_SD_CTL, 1, 0, NULL, 0),
2152
2153         SND_SOC_DAPM_SUPPLY("RX_I2S_CLK",
2154                 MSM8X16_WCD_A_CDC_CLK_RX_I2S_CTL,       4, 0, NULL, 0),
2155         SND_SOC_DAPM_SUPPLY("TX_I2S_CLK",
2156                 MSM8X16_WCD_A_CDC_CLK_TX_I2S_CTL, 4, 0,
2157                 NULL, 0),
2158 };
2159
2160 static struct snd_soc_codec_driver msm8x16_wcd_codec = {
2161         .probe  = msm8x16_wcd_codec_probe,
2162         .remove = msm8x16_wcd_codec_remove,
2163         .read = msm8x16_wcd_read,
2164         .write = msm8x16_wcd_write,
2165         .reg_cache_size = MSM8X16_WCD_CACHE_SIZE,
2166         .reg_cache_default = msm8x16_wcd_reset_reg_defaults,
2167         .reg_word_size = 1,
2168         .controls = msm8x16_wcd_snd_controls,
2169         .num_controls = ARRAY_SIZE(msm8x16_wcd_snd_controls),
2170         .dapm_widgets = msm8x16_wcd_dapm_widgets,
2171         .num_dapm_widgets = ARRAY_SIZE(msm8x16_wcd_dapm_widgets),
2172         .dapm_routes = audio_map,
2173         .num_dapm_routes = ARRAY_SIZE(audio_map),
2174 };
2175
2176 static int msm8x16_wcd_codec_parse_dt(struct platform_device *pdev,
2177                                       struct wcd_chip *chip)
2178 {
2179         struct device *dev = &pdev->dev;
2180         struct device_node *np = dev->of_node;
2181         int ret;
2182         u32 res[2];
2183
2184         ret = of_property_read_u32_array(np, "reg", res, 2);
2185         if (ret < 0)
2186                 return ret;
2187
2188         chip->analog_base = res[0];
2189
2190         chip->digital_map = syscon_regmap_lookup_by_phandle(np, "digital");
2191         if (IS_ERR(chip->digital_map))
2192                 return PTR_ERR(chip->digital_map);
2193
2194         chip->vddio = devm_regulator_get(dev, "vddio");
2195         if (IS_ERR(chip->vddio)) {
2196                 dev_err(dev, "Failed to get vdd supply\n");
2197                 return PTR_ERR(chip->vddio);
2198         }
2199
2200         chip->vdd_pa = devm_regulator_get(dev, "vdd-pa");
2201         if (IS_ERR(chip->vdd_pa)) {
2202                 dev_err(dev, "Failed to get vdd supply\n");
2203                 return PTR_ERR(chip->vdd_pa);
2204         }
2205
2206         chip->vdd_mic_bias = devm_regulator_get(dev, "vdd-mic-bias");
2207         if (IS_ERR(chip->vdd_mic_bias)) {
2208                 dev_err(dev, "Failed to get vdd micbias supply\n");
2209                 return PTR_ERR(chip->vdd_mic_bias);
2210         }
2211
2212         chip->mclk = devm_clk_get(dev, "mclk");
2213
2214         return 0;
2215 }
2216
2217 static int wcd_probe(struct platform_device *pdev)
2218 {
2219         struct wcd_chip *chip;
2220         struct device *dev = &pdev->dev;
2221         int ret;
2222
2223         chip = devm_kzalloc(dev, sizeof(*chip), GFP_KERNEL);
2224         if (!chip)
2225                 return -ENOMEM;
2226
2227         chip->analog_map = dev_get_regmap(dev->parent, NULL);
2228         if (!chip->analog_map)
2229                 return -ENXIO;
2230
2231         ret = msm8x16_wcd_codec_parse_dt(pdev, chip);
2232         if (IS_ERR_VALUE(ret))
2233                 return ret;
2234
2235         clk_set_rate(chip->mclk, 9600000);
2236         clk_prepare_enable(chip->mclk);
2237
2238         dev_set_drvdata(dev, chip);
2239
2240         return snd_soc_register_codec(dev, &msm8x16_wcd_codec,
2241                                       msm8x16_wcd_codec_dai,
2242                                       ARRAY_SIZE(msm8x16_wcd_codec_dai));
2243 }
2244
2245 static int wcd_remove(struct platform_device *pdev)
2246 {
2247         snd_soc_unregister_codec(&pdev->dev);
2248
2249         return 0;
2250 }
2251
2252 static const struct of_device_id wcd_match_table[] = {
2253         { .compatible = "qcom,apq8016-wcd-codec" },
2254         { .compatible = "qcom,msm8x16-wcd-codec" },
2255         { }
2256 };
2257 MODULE_DEVICE_TABLE(of, wcd_match_table);
2258
2259 static struct platform_driver wcd_driver = {
2260         .driver = {
2261                 .name = "msm8x16-wcd-codec",
2262                 .of_match_table = wcd_match_table,
2263         },
2264         .probe  = wcd_probe,
2265         .remove = wcd_remove,
2266 };
2267 module_platform_driver(wcd_driver);
2268
2269 MODULE_ALIAS("platform:spmi-wcd-codec");
2270 MODULE_DESCRIPTION("SPMI PMIC WCD codec driver");
2271 MODULE_LICENSE("GPL v2");