drivers/sound/codec/sprd-codec.c

   1 /*
   2  * sound/soc/sprd/codec/sprd/sprd-codec.c
   3  *
   4  * SPRD-CODEC -- SpreadTrum Tiger intergrated codec.
   5  *
   6  * Copyright (C) 2012 SpreadTrum Ltd.
   7  *
   8  * This software is licensed under the terms of the GNU General Public
   9  * License version 2, as published by the Free Software Foundation, and
  10  * may be copied, distributed, and modified under those terms.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  */
  17 #define pr_fmt(fmt) "[audio:codec] " fmt
  18
  19 #include <common.h>
  20 #include <errno.h>
  21 #include <asm/atomic.h>
  22 #include <ubi_uboot.h>
  23
  24 #include <asm/arch/sprd-audio.h>
  25 #include "sprd-codec.h"
  26
  27 #ifdef CONFIG_SPRD_AUDIO_DEBUG
  28 #define sprd_codec_dbg pr_info
  29 #define sprd_bug_on BUG_ON
  30 #else
  31 #define sprd_codec_dbg(...)
  32 #define sprd_bug_on(...)
  33 #endif
  34
  35 #define SOC_REG(reg) reg
  36
  37 #define DEFINE_SPINLOCK(...)
  38 #define DEFINE_MUTEX(...)
  39
  40 struct snd_soc_codec {
  41         /* codec IO */
  42         unsigned int (*read) (struct snd_soc_codec *, unsigned int);
  43         int (*write) (struct snd_soc_codec *, unsigned int, unsigned int);
  44         struct sprd_codec_priv *sprd_codec;
  45 };
  46
  47 static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
  48                                              void *data)
  49 {
  50         codec->sprd_codec = data;
  51 }
  52
  53 static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
  54 {
  55         return (void *)codec->sprd_codec;
  56 }
  57
  58 const char *sprd_codec_pga_debug_str[SPRD_CODEC_PGA_MAX] = {
  59         "SPKL",
  60         "SPKR",
  61         "HPL",
  62         "HPR",
  63         "EAR",
  64         "ADCL",
  65         "ADCR",
  66 };
  67
  68 typedef int (*sprd_codec_pga_set) (struct snd_soc_codec * codec, int pgaval);
  69
  70 struct sprd_codec_pga {
  71         sprd_codec_pga_set set;
  72         int min;
  73 };
  74
  75 struct sprd_codec_pga_op {
  76         int pgaval;
  77         sprd_codec_pga_set set;
  78 };
  79
  80 const char *sprd_codec_mixer_debug_str[SPRD_CODEC_MIXER_MAX] = {
  81         "AIL->ADCL",
  82         "AIL->ADCR",
  83         "AIR->ADCL",
  84         "AIR->ADCR",
  85         "MAIN MIC->ADCL",
  86         "MAIN MIC->ADCR",
  87         "AUX MIC->ADCL",
  88         "AUX MIC->ADCR",
  89         "HP MIC->ADCL",
  90         "HP MIC->ADCR",
  91         "DACL->HPL",
  92         "DACL->HPR",
  93         "DACR->HPL",
  94         "DACR->HPR",
  95         "ADCL->HPL",
  96         "ADCL->HPR",
  97         "ADCR->HPL",
  98         "ADCR->HPR",
  99         "DACL->SPKL",
 100         "DACL->SPKR",
 101         "DACR->SPKL",
 102         "DACR->SPKR",
 103         "ADCL->SPKL",
 104         "ADCL->SPKR",
 105         "ADCR->SPKL",
 106         "ADCR->SPKR",
 107         "DACL->EAR",
 108         "DACR->EAR(bug)"
 109 };
 110
 111 #define IS_SPRD_CODEC_MIXER_RANG(reg) (((reg) >= SPRD_CODEC_MIXER_START) && ((reg) <= SPRD_CODEC_MIXER_MAX))
 112
 113 typedef int (*sprd_codec_mixer_set) (struct snd_soc_codec * codec, int on);
 114 struct sprd_codec_mixer {
 115         int on;
 116         sprd_codec_mixer_set set;
 117 };
 118
 119 struct sprd_codec_inter_pa {
 120         /* FIXME little endian */
 121         int LDO_V_sel:4;
 122         int DTRI_F_sel:4;
 123         int is_DEMI_mode:1;
 124         int is_classD_mode:1;
 125         int is_LDO_mode:1;
 126         int is_auto_LDO_mode:1;
 127         int RESV:20;
 128 };
 129
 130 struct sprd_codec_pa_setting {
 131         union {
 132                 struct sprd_codec_inter_pa setting;
 133                 u32 value;
 134         };
 135         int set;
 136 };
 137
 138 DEFINE_MUTEX(inter_pa_mutex);
 139 static struct sprd_codec_pa_setting inter_pa;
 140
 141 static const char *mic_bias_name[SPRD_CODEC_MIC_BIAS_MAX] = {
 142         "Mic Bias",
 143         "AuxMic Bias",
 144 };
 145
 146 /* codec private data */
 147 struct sprd_codec_priv {
 148         struct snd_soc_codec *codec;
 149         atomic_t power_refcount;
 150         atomic_t adie_dac_refcount;
 151         atomic_t adie_adc_refcount;
 152         atomic_t adc_power_refcount;
 153         atomic_t adc_digital_power_refcount;
 154         atomic_t dac_power_refcount;
 155         atomic_t dac_digital_power_refcount;
 156         atomic_t digital_power_refcount;
 157         atomic_t analog_power_refcount;
 158         int da_sample_val;
 159         int ad_sample_val;
 160         struct sprd_codec_mixer mixer[SPRD_CODEC_MIXER_MAX];
 161         struct sprd_codec_pga_op pga[SPRD_CODEC_PGA_MAX];
 162         int mic_bias[SPRD_CODEC_MIC_BIAS_MAX];
 163 #ifdef CONFIG_SPRD_CODEC_USE_INT
 164         int ap_irq;
 165         struct completion completion_hp_pop;
 166
 167         int dp_irq;
 168         struct completion completion_dac_mute;
 169 #endif
 170 };
 171
 172 /* codec local power suppliy */
 173 static struct sprd_codec_power_suppliy {
 174         atomic_t mic_on;
 175         atomic_t auxmic_on;
 176         atomic_t ldo_refcount;
 177         int audio_ldo_open_ok;
 178 } sprd_codec_power;
 179
 180 static inline char *_2str(int enable)
 181 {
 182         return enable ? "enable" : "disable";
 183 }
 184
 185 #define SPRD_CODEC_PA_SW_AOL (BIT(0))
 186 #define SPRD_CODEC_PA_SW_EAR (BIT(1))
 187 #define SPRD_CODEC_PA_SW_FUN (SPRD_CODEC_PA_SW_AOL | SPRD_CODEC_PA_SW_EAR)
 188 static int sprd_codec_fun = 0;
 189 DEFINE_SPINLOCK(sprd_codec_fun_lock);
 190
 191 static void sprd_codec_set_fun(int fun)
 192 {
 193         spin_lock(&sprd_codec_fun_lock);
 194         sprd_codec_fun |= fun;
 195         spin_unlock(&sprd_codec_fun_lock);
 196 }
 197
 198 static void sprd_codec_clr_fun(int fun)
 199 {
 200         spin_lock(&sprd_codec_fun_lock);
 201         sprd_codec_fun &= ~fun;
 202         spin_unlock(&sprd_codec_fun_lock);
 203 }
 204
 205 static int sprd_codec_test_fun(int fun)
 206 {
 207         int ret;
 208         spin_lock(&sprd_codec_fun_lock);
 209         ret = sprd_codec_fun & fun;
 210         spin_unlock(&sprd_codec_fun_lock);
 211         return ret;
 212 }
 213
 214 static unsigned int sprd_codec_read(struct snd_soc_codec *codec,
 215                                     unsigned int reg)
 216 {
 217         if (IS_SPRD_CODEC_AP_RANG(reg)) {
 218                 return arch_audio_codec_read(reg);
 219         } else if (IS_SPRD_CODEC_DP_RANG(reg)) {
 220                 return __raw_readl(reg);
 221         }
 222         sprd_codec_dbg("read the register is not codec's reg = 0x%x\n", reg);
 223         return 0;
 224 }
 225
 226 static int sprd_codec_write(struct snd_soc_codec *codec, unsigned int reg,
 227                             unsigned int val)
 228 {
 229         sprd_codec_dbg("reg = 0x%08x val = 0x%08x\n", reg, val);
 230         if (IS_SPRD_CODEC_AP_RANG(reg)) {
 231                 return arch_audio_codec_write(reg, val);
 232         } else if (IS_SPRD_CODEC_DP_RANG(reg)) {
 233                 return __raw_writel(val, reg);
 234         }
 235         sprd_codec_dbg("write the register is not codec's reg = 0x%x\n", reg);
 236         return 0;
 237 }
 238
 239 static inline unsigned int snd_soc_read(struct snd_soc_codec *codec,
 240                                         unsigned int reg)
 241 {
 242         return sprd_codec_read(codec, reg);
 243 }
 244
 245 static inline unsigned int snd_soc_write(struct snd_soc_codec *codec,
 246                                          unsigned int reg, unsigned int val)
 247 {
 248         return sprd_codec_write(codec, reg, val);
 249 }
 250
 251 static struct sprd_codec_priv s_sprd_codec_priv = { 0 };
 252
 253 static struct snd_soc_codec s_sprd_codec = {
 254         .read = sprd_codec_read,
 255         .write = sprd_codec_write,
 256         .sprd_codec = &s_sprd_codec_priv,
 257 };
 258
 259 /**
 260  * snd_soc_update_bits - update codec register bits
 261  * @codec: audio codec
 262  * @reg: codec register
 263  * @mask: register mask
 264  * @value: new value
 265  *
 266  * Writes new register value.
 267  *
 268  * Returns 1 for change, 0 for no change, or negative error code.
 269  */
 270 static int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
 271                                unsigned int mask, unsigned int value)
 272 {
 273         int change;
 274         unsigned int old, new;
 275         int ret;
 276
 277         ret = snd_soc_read(codec, reg);
 278         if (ret < 0)
 279                 return ret;
 280
 281         old = ret;
 282         new = (old & ~mask) | value;
 283         change = old != new;
 284         if (change) {
 285                 ret = snd_soc_write(codec, reg, new);
 286                 if (ret < 0)
 287                         return ret;
 288         }
 289
 290         return change;
 291 }
 292
 293 static void sprd_codec_wait(u32 wait_time)
 294 {
 295         udelay(wait_time * 1000);
 296 }
 297
 298 static unsigned int sprd_codec_read(struct snd_soc_codec *codec,
 299                                     unsigned int reg);
 300 static void sprd_codec_print_regs(struct snd_soc_codec *codec)
 301 {
 302         int reg;
 303         pr_warn("sprd_codec register digital part\n");
 304         for (reg = SPRD_CODEC_DP_BASE; reg < SPRD_CODEC_DP_END; reg += 0x10) {
 305                 pr_warn("0x%04x | 0x%04x 0x%04x 0x%04x 0x%04x\n",
 306                         (reg - SPRD_CODEC_DP_BASE)
 307                         , sprd_codec_read(codec, reg + 0x00)
 308                         , sprd_codec_read(codec, reg + 0x04)
 309                         , sprd_codec_read(codec, reg + 0x08)
 310                         , sprd_codec_read(codec, reg + 0x0C)
 311                     );
 312         }
 313         pr_warn("sprd_codec register analog part\n");
 314         for (reg = SPRD_CODEC_AP_BASE; reg < SPRD_CODEC_AP_END; reg += 0x10) {
 315                 pr_warn("0x%04x | 0x%04x 0x%04x 0x%04x 0x%04x\n",
 316                         (reg - SPRD_CODEC_AP_BASE)
 317                         , sprd_codec_read(codec, reg + 0x00)
 318                         , sprd_codec_read(codec, reg + 0x04)
 319                         , sprd_codec_read(codec, reg + 0x08)
 320                         , sprd_codec_read(codec, reg + 0x0C)
 321                     );
 322         }
 323 }
 324
 325 static inline void sprd_codec_vcm_v_sel(int v_sel)
 326 {
 327         int mask;
 328         int val;
 329         sprd_codec_dbg("Entering %s set %d\n", __func__, v_sel);
 330         mask = VCM_V_MASK << VCM_V;
 331         val = (v_sel << VCM_V) & mask;
 332         arch_audio_codec_write_mask(PMUR3, val, mask);
 333 }
 334
 335 static int sprd_codec_pga_spk_set(struct snd_soc_codec *codec, int pgaval)
 336 {
 337         int reg, val;
 338         reg = DCGR3;
 339         val = (pgaval & 0xF) << 4;
 340         return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
 341 }
 342
 343 static int sprd_codec_pga_spkr_set(struct snd_soc_codec *codec, int pgaval)
 344 {
 345         int reg, val;
 346         reg = DCGR3;
 347         val = pgaval & 0xF;
 348         return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
 349 }
 350
 351 static int sprd_codec_pga_hpl_set(struct snd_soc_codec *codec, int pgaval)
 352 {
 353         int reg, val;
 354         reg = DCGR1;
 355         val = (pgaval & 0xF) << 4;
 356         return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
 357 }
 358
 359 static int sprd_codec_pga_hpr_set(struct snd_soc_codec *codec, int pgaval)
 360 {
 361         int reg, val;
 362         reg = DCGR1;
 363         val = pgaval & 0xF;
 364         return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
 365 }
 366
 367 static int sprd_codec_pga_ear_set(struct snd_soc_codec *codec, int pgaval)
 368 {
 369         int reg, val;
 370         reg = DCGR2;
 371         val = ((pgaval & 0xF) << 4);
 372         return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
 373 }
 374
 375 static int sprd_codec_pga_adcl_set(struct snd_soc_codec *codec, int pgaval)
 376 {
 377         int reg, val;
 378         reg = ACGR;
 379         val = (pgaval & 0xF) << 4;
 380         return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
 381 }
 382
 383 static int sprd_codec_pga_adcr_set(struct snd_soc_codec *codec, int pgaval)
 384 {
 385         int reg, val;
 386         reg = ACGR;
 387         val = pgaval & 0xF;
 388         return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
 389 }
 390
 391 static struct sprd_codec_pga sprd_codec_pga_cfg[SPRD_CODEC_PGA_MAX] = {
 392         {sprd_codec_pga_spk_set, 0},
 393         {sprd_codec_pga_spkr_set, 0},
 394         {sprd_codec_pga_hpl_set, 0},
 395         {sprd_codec_pga_hpr_set, 0},
 396         {sprd_codec_pga_ear_set, 0},
 397
 398         {sprd_codec_pga_adcl_set, 0},
 399         {sprd_codec_pga_adcr_set, 0},
 400 };
 401
 402 /* adc mixer */
 403
 404 static int vcmadcl_set(struct snd_soc_codec *codec)
 405 {
 406         int need_on;
 407         need_on = snd_soc_read(codec, AAICR3) & (BIT(AIL_ADCL) | BIT(AIR_ADCL));
 408         return snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(VCM_ADCL),
 409                                    (! !need_on) << VCM_ADCL);
 410 }
 411
 412 static int vcmadcr_set(struct snd_soc_codec *codec)
 413 {
 414         int need_on;
 415         need_on = snd_soc_read(codec, AAICR3) & (BIT(AIL_ADCR) | BIT(AIR_ADCR));
 416         return snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(VCM_ADCR),
 417                                    (! !need_on) << VCM_ADCR);
 418 }
 419
 420 static int sprd_codec_is_ai_enable(struct snd_soc_codec *codec)
 421 {
 422         return ! !(snd_soc_read(codec, AAICR3) &
 423                    (BIT(AIL_ADCR) | BIT(AIL_ADCL) | BIT(AIR_ADCR) |
 424                     BIT(AIR_ADCL)));
 425 }
 426
 427 static int ailadcl_set(struct snd_soc_codec *codec, int on)
 428 {
 429         int ret;
 430         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 431         ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIL_ADCL),
 432                                   on << AIL_ADCL);
 433         if (ret < 0)
 434                 return ret;
 435         return vcmadcl_set(codec);
 436 }
 437
 438 static int ailadcr_set(struct snd_soc_codec *codec, int on)
 439 {
 440         int ret;
 441         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 442         ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIL_ADCR),
 443                                   on << AIL_ADCR);
 444         if (ret < 0)
 445                 return ret;
 446         return vcmadcr_set(codec);
 447 }
 448
 449 static int airadcl_set(struct snd_soc_codec *codec, int on)
 450 {
 451         int ret;
 452         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 453         ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIR_ADCL),
 454                                   on << AIR_ADCL);
 455         if (ret < 0)
 456                 return ret;
 457         return vcmadcl_set(codec);
 458 }
 459
 460 static int airadcr_set(struct snd_soc_codec *codec, int on)
 461 {
 462         int ret;
 463         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 464         ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIR_ADCR),
 465                                   on << AIR_ADCR);
 466         if (ret < 0)
 467                 return ret;
 468         return vcmadcr_set(codec);
 469 }
 470
 471 static int mainmicadcl_set(struct snd_soc_codec *codec, int on)
 472 {
 473         int mask;
 474         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 475         mask = BIT(MICP_ADCL) | BIT(MICN_ADCL);
 476         return snd_soc_update_bits(codec, SOC_REG(AAICR1), mask, on ? mask : 0);
 477 }
 478
 479 static int mainmicadcr_set(struct snd_soc_codec *codec, int on)
 480 {
 481         int mask;
 482         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 483         mask = BIT(MICP_ADCR) | BIT(MICN_ADCR);
 484         return snd_soc_update_bits(codec, SOC_REG(AAICR1), mask, on ? mask : 0);
 485 }
 486
 487 static int auxmicadcl_set(struct snd_soc_codec *codec, int on)
 488 {
 489         int mask;
 490         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 491         mask = BIT(AUXMICP_ADCL) | BIT(AUXMICN_ADCL);
 492         return snd_soc_update_bits(codec, SOC_REG(AAICR2), mask, on ? mask : 0);
 493 }
 494
 495 static int auxmicadcr_set(struct snd_soc_codec *codec, int on)
 496 {
 497         int mask;
 498         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 499         mask = BIT(AUXMICP_ADCR) | BIT(AUXMICN_ADCR);
 500         return snd_soc_update_bits(codec, SOC_REG(AAICR2), mask, on ? mask : 0);
 501 }
 502
 503 static int hpmicadcl_set(struct snd_soc_codec *codec, int on)
 504 {
 505         int mask;
 506         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 507         mask = BIT(HPMICP_ADCL) | BIT(HPMICN_ADCL);
 508         return snd_soc_update_bits(codec, SOC_REG(AAICR1), mask, on ? mask : 0);
 509 }
 510
 511 static int hpmicadcr_set(struct snd_soc_codec *codec, int on)
 512 {
 513         int mask;
 514         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 515         mask = BIT(HPMICP_ADCR) | BIT(HPMICN_ADCR);
 516         return snd_soc_update_bits(codec, SOC_REG(AAICR1), mask, on ? mask : 0);
 517 }
 518
 519 /* adcpga*_en setting */
 520 static int adcpgax_auto_setting(struct snd_soc_codec *codec)
 521 {
 522         unsigned int reg1, reg2, reg3;
 523         int val;
 524         int mask;
 525         reg1 = snd_soc_read(codec, DAOCR1);
 526         reg2 = snd_soc_read(codec, DAOCR2);
 527         reg3 = snd_soc_read(codec, DAOCR3);
 528         val = 0;
 529         if ((reg1 & BIT(ADCL_P_HPL)) || (reg2 & BIT(ADCL_P_AOLP))
 530             || (reg3 & BIT(ADCL_P_AORP))) {
 531                 val |= BIT(ADCPGAL_P_EN);
 532         }
 533         if ((reg1 & BIT(ADCL_N_HPR)) || (reg2 & BIT(ADCL_N_AOLN))
 534             || (reg3 & BIT(ADCL_N_AORN))) {
 535                 val |= BIT(ADCPGAL_N_EN);
 536         }
 537         if ((reg1 & (BIT(ADCR_P_HPL) | BIT(ADCR_P_HPR)))
 538             || (reg2 & BIT(ADCR_P_AOLP)) || (reg3 & BIT(ADCR_P_AORP))) {
 539                 val |= BIT(ADCPGAR_P_EN);
 540         }
 541         if ((reg2 & BIT(ADCR_N_AOLN)) || (reg3 & BIT(ADCR_N_AORN))) {
 542                 val |= BIT(ADCPGAR_N_EN);
 543         }
 544         mask =
 545             BIT(ADCPGAL_P_EN) | BIT(ADCPGAL_N_EN) | BIT(ADCPGAR_P_EN) |
 546             BIT(ADCPGAR_N_EN);
 547         return snd_soc_update_bits(codec, SOC_REG(AACR2), mask, val);
 548 }
 549
 550 /* hp mixer */
 551
 552 static int daclhpl_set(struct snd_soc_codec *codec, int on)
 553 {
 554         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 555         return snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(DACL_P_HPL),
 556                                    on << DACL_P_HPL);
 557 }
 558
 559 static int daclhpr_set(struct snd_soc_codec *codec, int on)
 560 {
 561         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 562         return snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(DACL_N_HPR),
 563                                    on << DACL_N_HPR);
 564 }
 565
 566 static int dacrhpl_set(struct snd_soc_codec *codec, int on)
 567 {
 568         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 569         return snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(DACR_P_HPL),
 570                                    on << DACR_P_HPL);
 571 }
 572
 573 static int dacrhpr_set(struct snd_soc_codec *codec, int on)
 574 {
 575         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 576         return snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(DACR_P_HPR),
 577                                    on << DACR_P_HPR);
 578 }
 579
 580 static int adclhpl_set(struct snd_soc_codec *codec, int on)
 581 {
 582         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 583         snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCL_P_HPL),
 584                             on << ADCL_P_HPL);
 585         return adcpgax_auto_setting(codec);
 586 }
 587
 588 static int adclhpr_set(struct snd_soc_codec *codec, int on)
 589 {
 590         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 591         snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCL_N_HPR),
 592                             on << ADCL_N_HPR);
 593         return adcpgax_auto_setting(codec);
 594 }
 595
 596 static int adcrhpl_set(struct snd_soc_codec *codec, int on)
 597 {
 598         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 599         snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCR_P_HPL),
 600                             on << ADCR_P_HPL);
 601         return adcpgax_auto_setting(codec);
 602 }
 603
 604 static int adcrhpr_set(struct snd_soc_codec *codec, int on)
 605 {
 606         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 607         snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCR_P_HPR),
 608                             on << ADCR_P_HPR);
 609         return adcpgax_auto_setting(codec);
 610 }
 611
 612 /* spkl mixer */
 613
 614 static int daclspkl_set(struct snd_soc_codec *codec, int on)
 615 {
 616         int mask = BIT(DACL_P_AOLP) | BIT(DACL_N_AOLN);
 617         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 618         return snd_soc_update_bits(codec, SOC_REG(DAOCR2), mask, on ? mask : 0);
 619 }
 620
 621 static int dacrspkl_set(struct snd_soc_codec *codec, int on)
 622 {
 623         int mask = BIT(DACR_P_AOLP) | BIT(DACR_N_AOLN);
 624         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 625         return snd_soc_update_bits(codec, SOC_REG(DAOCR2), mask, on ? mask : 0);
 626 }
 627
 628 static int adclspkl_set(struct snd_soc_codec *codec, int on)
 629 {
 630         int mask = BIT(ADCL_P_AOLP) | BIT(ADCL_N_AOLN);
 631         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 632         snd_soc_update_bits(codec, SOC_REG(DAOCR2), mask, on ? mask : 0);
 633         return adcpgax_auto_setting(codec);
 634 }
 635
 636 static int adcrspkl_set(struct snd_soc_codec *codec, int on)
 637 {
 638         int mask = BIT(ADCR_P_AOLP) | BIT(ADCR_N_AOLN);
 639         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 640         snd_soc_update_bits(codec, SOC_REG(DAOCR2), mask, on ? mask : 0);
 641         return adcpgax_auto_setting(codec);
 642 }
 643
 644 /* spkr mixer */
 645
 646 static int daclspkr_set(struct snd_soc_codec *codec, int on)
 647 {
 648         int mask = BIT(DACL_P_AORP) | BIT(DACL_N_AORN);
 649         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 650         return snd_soc_update_bits(codec, SOC_REG(DAOCR3), mask, on ? mask : 0);
 651 }
 652
 653 static int dacrspkr_set(struct snd_soc_codec *codec, int on)
 654 {
 655         int mask = BIT(DACR_P_AORP) | BIT(DACR_N_AORN);
 656         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 657         return snd_soc_update_bits(codec, SOC_REG(DAOCR3), mask, on ? mask : 0);
 658 }
 659
 660 static int adclspkr_set(struct snd_soc_codec *codec, int on)
 661 {
 662         int mask = BIT(ADCL_P_AORP) | BIT(ADCL_N_AORN);
 663         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 664         snd_soc_update_bits(codec, SOC_REG(DAOCR3), mask, on ? mask : 0);
 665         return adcpgax_auto_setting(codec);
 666 }
 667
 668 static int adcrspkr_set(struct snd_soc_codec *codec, int on)
 669 {
 670         int mask = BIT(ADCR_P_AORP) | BIT(ADCR_N_AORN);
 671         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 672         snd_soc_update_bits(codec, SOC_REG(DAOCR3), mask, on ? mask : 0);
 673         return adcpgax_auto_setting(codec);
 674 }
 675
 676 /* ear mixer */
 677
 678 static int daclear_set(struct snd_soc_codec *codec, int on)
 679 {
 680         int mask = BIT(DACL_P_EARP) | BIT(DACL_N_EARN);
 681         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 682         return snd_soc_update_bits(codec, SOC_REG(DAOCR4), mask, on ? mask : 0);
 683 }
 684
 685 static sprd_codec_mixer_set mixer_setting[SPRD_CODEC_MIXER_MAX] = {
 686         /* adc mixer */
 687         ailadcl_set, ailadcr_set,
 688         airadcl_set, airadcr_set,
 689         mainmicadcl_set, mainmicadcr_set,
 690         auxmicadcl_set, auxmicadcr_set,
 691         hpmicadcl_set, hpmicadcr_set,
 692         /* hp mixer */
 693         daclhpl_set, daclhpr_set,
 694         dacrhpl_set, dacrhpr_set,
 695         adclhpl_set, adclhpr_set,
 696         adcrhpl_set, adcrhpr_set,
 697         /* spk mixer */
 698         daclspkl_set, daclspkr_set,
 699         dacrspkl_set, dacrspkr_set,
 700         adclspkl_set, adclspkr_set,
 701         adcrspkl_set, adcrspkr_set,
 702         /* ear mixer */
 703         daclear_set, 0,
 704 };
 705
 706 int sprd_codec_digital_loop(int enable)
 707 {
 708         struct snd_soc_codec *codec = &s_sprd_codec;
 709         int mask = BIT(AUDIFA_ADIE_LOOP_EN);
 710         snd_soc_update_bits(codec, SOC_REG(AUDIF_ENB), mask, enable ? mask : 0);
 711 }
 712
 713 /* DO NOT USE THIS FUNCTION */
 714 static inline void __sprd_codec_pa_sw_en(int on)
 715 {
 716         int mask;
 717         int val;
 718         mask = BIT(PA_SW_EN);
 719         val = on ? mask : 0;
 720         arch_audio_codec_write_mask(PMUR2, val, mask);
 721 }
 722
 723 DEFINE_SPINLOCK(sprd_codec_pa_sw_lock);
 724 static inline void sprd_codec_pa_sw_set(int fun)
 725 {
 726         sprd_codec_dbg("Entering %s fun 0x%08x\n", __func__, fun);
 727         spin_lock(&sprd_codec_pa_sw_lock);
 728         sprd_codec_set_fun(fun);
 729         __sprd_codec_pa_sw_en(1);
 730         spin_unlock(&sprd_codec_pa_sw_lock);
 731 }
 732
 733 static inline void sprd_codec_pa_sw_clr(int fun)
 734 {
 735         sprd_codec_dbg("Entering %s fun 0x%08x\n", __func__, fun);
 736         spin_lock(&sprd_codec_pa_sw_lock);
 737         sprd_codec_clr_fun(fun);
 738         if (!sprd_codec_test_fun(SPRD_CODEC_PA_SW_FUN))
 739                 __sprd_codec_pa_sw_en(0);
 740         spin_unlock(&sprd_codec_pa_sw_lock);
 741 }
 742
 743 /* inter PA */
 744
 745 static inline void sprd_codec_pa_d_en(int on)
 746 {
 747         int mask;
 748         int val;
 749         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 750         mask = BIT(PA_D_EN);
 751         val = on ? mask : 0;
 752         arch_audio_codec_write_mask(DCR2, val, mask);
 753 }
 754
 755 static inline void sprd_codec_pa_demi_en(int on)
 756 {
 757         int mask;
 758         int val;
 759         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 760         mask = BIT(PA_DEMI_EN);
 761         val = on ? mask : 0;
 762         arch_audio_codec_write_mask(DCR2, val, mask);
 763
 764         mask = BIT(DRV_OCP_AOL_PD) | BIT(DRV_OCP_AOR_PD);
 765         val = mask;
 766         arch_audio_codec_write_mask(DCR3, val, mask);
 767 }
 768
 769 static inline void sprd_codec_pa_ldo_en(int on)
 770 {
 771         int mask;
 772         int val;
 773         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 774         mask = BIT(PA_LDO_EN);
 775         val = on ? mask : 0;
 776         arch_audio_codec_write_mask(PMUR2, val, mask);
 777         if (on) {
 778                 sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_AOL);
 779         }
 780 }
 781
 782 static inline void sprd_codec_pa_ldo_v_sel(int v_sel)
 783 {
 784         int mask;
 785         int val;
 786         sprd_codec_dbg("Entering %s set %d\n", __func__, v_sel);
 787         mask = PA_LDO_V_MASK << PA_LDO_V;
 788         val = (v_sel << PA_LDO_V) & mask;
 789         arch_audio_codec_write_mask(PMUR4, val, mask);
 790 }
 791
 792 static inline void sprd_codec_pa_dtri_f_sel(int f_sel)
 793 {
 794         int mask;
 795         int val;
 796         sprd_codec_dbg("Entering %s set %d\n", __func__, f_sel);
 797         mask = PA_DTRI_F_MASK << PA_DTRI_F;
 798         val = (f_sel << PA_DTRI_F) & mask;
 799         arch_audio_codec_write_mask(DCR2, val, mask);
 800 }
 801
 802 static inline void sprd_codec_pa_en(int on)
 803 {
 804         int mask;
 805         int val;
 806         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 807         spin_lock(&sprd_codec_pa_sw_lock);
 808         if (on) {
 809                 mask = BIT(PA_EN);
 810                 val = mask;
 811         } else {
 812                 if (!sprd_codec_test_fun(SPRD_CODEC_PA_SW_FUN))
 813                         mask = BIT(PA_EN) | BIT(PA_SW_EN) | BIT(PA_LDO_EN);
 814                 else
 815                         mask = BIT(PA_EN) | BIT(PA_LDO_EN);
 816                 val = 0;
 817         }
 818         arch_audio_codec_write_mask(PMUR2, val, mask);
 819         spin_unlock(&sprd_codec_pa_sw_lock);
 820 }
 821
 822 static inline void sprd_codec_inter_pa_init(void)
 823 {
 824         inter_pa.setting.LDO_V_sel = 0x03;
 825         inter_pa.setting.DTRI_F_sel = 0x01;
 826 }
 827
 828 int sprd_inter_speaker_pa(int on)
 829 {
 830         pr_info("inter PA switch %s\n", on ? "ON" : "OFF");
 831         mutex_lock(&inter_pa_mutex);
 832         if (on) {
 833                 sprd_codec_pa_d_en(inter_pa.setting.is_classD_mode);
 834                 sprd_codec_pa_demi_en(inter_pa.setting.is_DEMI_mode);
 835                 sprd_codec_pa_ldo_en(inter_pa.setting.is_LDO_mode);
 836                 if (inter_pa.setting.is_LDO_mode) {
 837                         if (inter_pa.setting.is_auto_LDO_mode) {
 838                                 /* sprd_codec_pa_ldo_v_sel(1); */
 839                         } else {
 840                                 sprd_codec_pa_ldo_v_sel(inter_pa.
 841                                                         setting.LDO_V_sel);
 842                         }
 843                 }
 844                 sprd_codec_pa_dtri_f_sel(inter_pa.setting.DTRI_F_sel);
 845                 sprd_codec_pa_en(1);
 846                 inter_pa.set = 1;
 847         } else {
 848                 inter_pa.set = 0;
 849                 sprd_codec_pa_en(0);
 850                 sprd_codec_pa_ldo_en(0);
 851         }
 852         mutex_unlock(&inter_pa_mutex);
 853         return 0;
 854 }
 855
 856 EXPORT_SYMBOL(sprd_inter_speaker_pa);
 857
 858 /* mic bias external */
 859
 860 static inline void sprd_codec_mic_bias_en(int on)
 861 {
 862         int mask;
 863         int val;
 864         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 865         mask = BIT(MICBIAS_EN);
 866         val = on ? mask : 0;
 867         arch_audio_codec_write_mask(PMUR1, val, mask);
 868 }
 869
 870 static inline void sprd_codec_auxmic_bias_en(int on)
 871 {
 872         int mask;
 873         int val;
 874         sprd_codec_dbg("Entering %s set %d\n", __func__, on);
 875         mask = BIT(AUXMICBIAS_EN);
 876         val = on ? mask : 0;
 877         arch_audio_codec_write_mask(PMUR1, val, mask);
 878 }
 879
 880 static int sprd_codec_set_sample_rate(struct snd_soc_codec *codec, int rate,
 881                                       int mask, int shift)
 882 {
 883         switch (rate) {
 884         case 8000:
 885                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 886                                     SPRD_CODEC_RATE_8000 << shift);
 887                 break;
 888         case 11025:
 889                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 890                                     SPRD_CODEC_RATE_11025 << shift);
 891                 break;
 892         case 16000:
 893                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 894                                     SPRD_CODEC_RATE_16000 << shift);
 895                 break;
 896         case 22050:
 897                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 898                                     SPRD_CODEC_RATE_22050 << shift);
 899                 break;
 900         case 32000:
 901                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 902                                     SPRD_CODEC_RATE_32000 << shift);
 903                 break;
 904         case 44100:
 905                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 906                                     SPRD_CODEC_RATE_44100 << shift);
 907                 break;
 908         case 48000:
 909                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 910                                     SPRD_CODEC_RATE_48000 << shift);
 911                 break;
 912         case 96000:
 913                 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
 914                                     SPRD_CODEC_RATE_96000 << shift);
 915                 break;
 916         default:
 917                 pr_err("sprd_codec not supports rate %d\n", rate);
 918                 break;
 919         }
 920         return 0;
 921 }
 922
 923 static int sprd_codec_set_ad_sample_rate(struct snd_soc_codec *codec, int rate,
 924                                          int mask, int shift)
 925 {
 926         int set;
 927         set = rate / 4000;
 928         if (set > 13) {
 929                 pr_err("sprd_codec not supports ad rate %d\n", rate);
 930         }
 931         snd_soc_update_bits(codec, SOC_REG(AUD_ADC_CTL), mask, set << shift);
 932         return 0;
 933 }
 934
 935 static int sprd_codec_sample_rate_setting(struct sprd_codec_priv *sprd_codec)
 936 {
 937         if (sprd_codec->ad_sample_val) {
 938                 sprd_codec_set_ad_sample_rate(sprd_codec->codec,
 939                                               sprd_codec->ad_sample_val, 0x0F,
 940                                               0);
 941         }
 942         if (sprd_codec->da_sample_val) {
 943                 sprd_codec_set_sample_rate(sprd_codec->codec,
 944                                            sprd_codec->da_sample_val, 0x0F, 0);
 945         }
 946         return 0;
 947 }
 948
 949 static int sprd_codec_update_bits(struct snd_soc_codec *codec,
 950                                   unsigned int reg, unsigned int mask,
 951                                   unsigned int value)
 952 {
 953         if (!codec) {
 954                 return arch_audio_codec_write_mask(reg, value, mask);
 955         } else {
 956                 return snd_soc_update_bits(codec, reg, mask, value);
 957         }
 958 }
 959
 960 static int sprd_codec_ldo_on(struct sprd_codec_priv *sprd_codec)
 961 {
 962         struct snd_soc_codec *codec = 0;
 963         sprd_codec_dbg("Entering %s\n", __func__);
 964
 965         atomic_inc(&sprd_codec_power.ldo_refcount);
 966         if (atomic_read(&sprd_codec_power.ldo_refcount) == 1) {
 967                 sprd_codec_dbg("ldo on!\n");
 968                 if (sprd_codec) {
 969                         codec = sprd_codec->codec;
 970                 }
 971                 arch_audio_codec_switch(AUDIO_TO_ARM_CTRL);
 972                 arch_audio_codec_analog_reg_enable();
 973                 arch_audio_codec_enable();
 974                 arch_audio_codec_reset();
 975                 /* sprd_codec_vcm_v_sel(0); */
 976
 977                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_IBIAS_EN),
 978                                        BIT(BG_IBIAS_EN));
 979                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_EN),
 980                                        BIT(BG_EN));
 981                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_EN),
 982                                        BIT(VCM_EN));
 983                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_BUF_EN),
 984                                        BIT(VCM_BUF_EN));
 985                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VB_EN),
 986                                        BIT(VB_EN));
 987                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VBO_EN),
 988                                        BIT(VBO_EN));
 989
 990                 if (sprd_codec) {
 991                         sprd_codec_wait(SPRD_CODEC_LDO_WAIT_TIME);
 992                 }
 993         }
 994
 995         sprd_codec_dbg("Leaving %s\n", __func__);
 996         return 0;
 997 }
 998
 999 static int sprd_codec_ldo_off(struct sprd_codec_priv *sprd_codec)
1000 {
1001         struct snd_soc_codec *codec = 0;
1002         sprd_codec_dbg("Entering %s\n", __func__);
1003
1004         if (atomic_dec_and_test(&sprd_codec_power.ldo_refcount)) {
1005                 if (sprd_codec) {
1006                         codec = sprd_codec->codec;
1007                 }
1008                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_EN), 0);
1009                 sprd_codec_wait(SPRD_CODEC_LDO_VCM_TIME);
1010                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_BUF_EN),
1011                                        0);
1012                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VB_EN), 0);
1013                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VBO_EN), 0);
1014                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_IBIAS_EN),
1015                                        0);
1016                 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_EN), 0);
1017
1018                 arch_audio_codec_reset();
1019                 arch_audio_codec_disable();
1020                 arch_audio_codec_analog_reg_disable();
1021                 sprd_codec_dbg("ldo off!\n");
1022         }
1023
1024         sprd_codec_dbg("Leaving %s\n", __func__);
1025         return 0;
1026 }
1027
1028 static int sprd_codec_ldo_control(int on)
1029 {
1030         if (on) {
1031                 return sprd_codec_ldo_on(0);
1032         } else {
1033                 return sprd_codec_ldo_off(0);
1034         }
1035 }
1036
1037 static void sprd_codec_mic_delay_worker(void)
1038 {
1039         int on = atomic_read(&sprd_codec_power.mic_on) > 0;
1040         sprd_codec_ldo_control(on);
1041         sprd_codec_mic_bias_en(on);
1042 }
1043
1044 static void sprd_codec_auxmic_delay_worker(void)
1045 {
1046         int on = atomic_read(&sprd_codec_power.auxmic_on) > 0;
1047         sprd_codec_ldo_control(on);
1048         sprd_codec_auxmic_bias_en(on);
1049 }
1050
1051 static int sprd_codec_mic_bias_inter(int on, atomic_t * v)
1052 {
1053         if (on) {
1054                 atomic_inc(v);
1055                 return 1;
1056         } else {
1057                 if (atomic_read(v) > 0) {
1058                         atomic_dec(v);
1059                         return 1;
1060                 }
1061         }
1062         return 0;
1063 }
1064
1065 int sprd_codec_mic_bias_control(int on)
1066 {
1067         if (sprd_codec_mic_bias_inter(on, &sprd_codec_power.mic_on)) {
1068                 sprd_codec_mic_delay_worker();
1069         }
1070         return 0;
1071 }
1072
1073 EXPORT_SYMBOL(sprd_codec_mic_bias_control);
1074
1075 int sprd_codec_auxmic_bias_control(int on)
1076 {
1077         if (sprd_codec_mic_bias_inter(on, &sprd_codec_power.auxmic_on)) {
1078                 sprd_codec_auxmic_delay_worker();
1079         }
1080         return 0;
1081 }
1082
1083 EXPORT_SYMBOL(sprd_codec_auxmic_bias_control);
1084
1085 static int sprd_codec_open(struct snd_soc_codec *codec)
1086 {
1087         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1088         int ret = 0;
1089
1090         sprd_codec_dbg("Entering %s\n", __func__);
1091
1092         sprd_codec_sample_rate_setting(sprd_codec);
1093
1094         /* SC8825 ask from ASIC to set initial value */
1095         snd_soc_write(codec, AUD_SDM_CTL0, 0x400);
1096         snd_soc_write(codec, AUD_SDM_CTL1, 0);
1097
1098         sprd_codec_dbg("Leaving %s\n", __func__);
1099         return ret;
1100 }
1101
1102 static void sprd_codec_power_enable(struct snd_soc_codec *codec)
1103 {
1104         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1105         int ret;
1106
1107         atomic_inc(&sprd_codec->power_refcount);
1108         if (atomic_read(&sprd_codec->power_refcount) == 1) {
1109                 sprd_codec_dbg("Entering %s\n", __func__);
1110                 ret = sprd_codec_ldo_on(sprd_codec);
1111                 if (ret != 0)
1112                         pr_err("sprd_codec open ldo error %d\n", ret);
1113                 sprd_codec_open(codec);
1114                 sprd_codec_dbg("Leaving %s\n", __func__);
1115         }
1116 }
1117
1118 static void sprd_codec_power_disable(struct snd_soc_codec *codec)
1119 {
1120         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1121
1122         if (atomic_dec_and_test(&sprd_codec->power_refcount)) {
1123                 sprd_codec_dbg("Entering %s\n", __func__);
1124                 sprd_codec_ldo_off(sprd_codec);
1125                 sprd_codec_dbg("Leaving %s\n", __func__);
1126         }
1127 }
1128
1129 static int analog_power_enable(int enable)
1130 {
1131         struct snd_soc_codec *codec = &s_sprd_codec;
1132         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1133         int ret = 0;
1134
1135         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1136
1137         if (enable) {
1138                 atomic_inc(&sprd_codec->analog_power_refcount);
1139                 if (atomic_read(&sprd_codec->analog_power_refcount) == 1) {
1140                         sprd_codec_power_enable(codec);
1141                 }
1142         } else {
1143                 if (atomic_dec_and_test(&sprd_codec->analog_power_refcount)) {
1144                         sprd_codec_power_disable(codec);
1145                 }
1146         }
1147
1148         return ret;
1149 }
1150
1151 static int digital_power_enable(int enable)
1152 {
1153         int ret = 0;
1154         struct snd_soc_codec *codec = &s_sprd_codec;
1155         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1156
1157         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1158
1159         if (enable) {
1160                 atomic_inc(&sprd_codec->digital_power_refcount);
1161                 if (atomic_read(&sprd_codec->digital_power_refcount) == 1) {
1162                         arch_audio_codec_digital_reg_enable();
1163                 }
1164         } else {
1165                 if (atomic_dec_and_test(&sprd_codec->digital_power_refcount)) {
1166                         arch_audio_codec_digital_reg_disable();
1167                 }
1168         }
1169         ret = analog_power_enable(enable);
1170
1171         return ret;
1172 }
1173
1174 static int adie_dac_enable(int enable)
1175 {
1176         struct snd_soc_codec *codec = &s_sprd_codec;
1177         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1178         int ret = 0;
1179
1180         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1181
1182         if (enable) {
1183                 atomic_inc(&sprd_codec->adie_dac_refcount);
1184                 if (atomic_read(&sprd_codec->adie_dac_refcount) == 1) {
1185                         snd_soc_update_bits(codec, SOC_REG(AUDIF_ENB),
1186                                             BIT(AUDIFA_DAC_EN),
1187                                             BIT(AUDIFA_DAC_EN));
1188                         pr_info("DAC ON\n");
1189                 }
1190         } else {
1191                 if (atomic_dec_and_test(&sprd_codec->adie_dac_refcount)) {
1192                         snd_soc_update_bits(codec, SOC_REG(AUDIF_ENB),
1193                                             BIT(AUDIFA_DAC_EN), 0);
1194                         pr_info("DAC OFF\n");
1195                 }
1196         }
1197
1198         sprd_codec_dbg("Leaving %s\n", __func__);
1199
1200         return ret;
1201 }
1202
1203 static int adie_adc_enable(int enable)
1204 {
1205         struct snd_soc_codec *codec = &s_sprd_codec;
1206         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1207         int ret = 0;
1208
1209         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1210
1211         if (enable) {
1212                 atomic_inc(&sprd_codec->adie_adc_refcount);
1213                 if (atomic_read(&sprd_codec->adie_adc_refcount) == 1) {
1214                         snd_soc_update_bits(codec, SOC_REG(AUDIF_ENB),
1215                                             BIT(AUDIFA_ADC_EN),
1216                                             BIT(AUDIFA_ADC_EN));
1217                         pr_info("ADC ON\n");
1218                 }
1219         } else {
1220                 if (atomic_dec_and_test(&sprd_codec->adie_adc_refcount)) {
1221                         snd_soc_update_bits(codec, SOC_REG(AUDIF_ENB),
1222                                             BIT(AUDIFA_ADC_EN), 0);
1223                         pr_info("ADC OFF\n");
1224                 }
1225         }
1226
1227         sprd_codec_dbg("Leaving %s\n", __func__);
1228
1229         return ret;
1230 }
1231
1232 static int _mixer_set_mixer(struct snd_soc_codec *codec, int id, int lr,
1233                             int try_on)
1234 {
1235         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1236         int reg = ID_FUN(id, lr);
1237         struct sprd_codec_mixer *mixer = &(sprd_codec->mixer[reg]);
1238         if (try_on) {
1239                 mixer->set = mixer_setting[reg];
1240                 return mixer->set(codec, mixer->on);
1241         } else {
1242                 mixer_setting[reg] (codec, 0);
1243                 mixer->set = 0;
1244         }
1245         return 0;
1246 }
1247
1248 static inline int _mixer_setting(struct snd_soc_codec *codec, int start,
1249                                  int end, int lr, int try_on)
1250 {
1251         int id;
1252         for (id = start; id < end; id++) {
1253                 _mixer_set_mixer(codec, id, lr, try_on);
1254         }
1255         return 0;
1256 }
1257
1258 static inline int _mixer_setting_one(struct snd_soc_codec *codec, int id,
1259                                      int try_on)
1260 {
1261         int lr = id & 0x1;
1262         id >>= 1;
1263         return _mixer_setting(codec, id, id + 1, lr, try_on);
1264 }
1265
1266 static int dac_digital_power(int enable)
1267 {
1268         int ret = 0;
1269         struct snd_soc_codec *codec = &s_sprd_codec;
1270         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1271         sprd_codec_dbg("%s %s %d\n", __func__, _2str(enable),
1272                        atomic_read(&sprd_codec->dac_digital_power_refcount));
1273         if (enable) {
1274                 atomic_inc(&sprd_codec->dac_digital_power_refcount);
1275                 if (atomic_read(&sprd_codec->dac_digital_power_refcount) == 1) {
1276                         digital_power_enable(enable);
1277                         snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACL_EN),
1278                                             BIT(DACL_EN));
1279                         snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN),
1280                                             BIT(DACR_EN));
1281                         snd_soc_update_bits(codec, SOC_REG(CCR),
1282                                             BIT(DAC_CLK_EN), BIT(DAC_CLK_EN));
1283                         ret = adie_dac_enable(enable);
1284                 }
1285         } else {
1286                 if (atomic_dec_and_test
1287                     (&sprd_codec->dac_digital_power_refcount)) {
1288                         snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACL_EN),
1289                                             0);
1290                         snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN),
1291                                             0);
1292                         snd_soc_update_bits(codec, SOC_REG(CCR),
1293                                             BIT(DAC_CLK_EN), 0);
1294                         ret = adie_dac_enable(enable);
1295                         digital_power_enable(enable);
1296                 }
1297         }
1298         return ret;
1299 }
1300
1301 int dacl_digital_switch(int enable)
1302 {
1303         int ret = 0;
1304         struct snd_soc_codec *codec = &s_sprd_codec;
1305         if (enable) {
1306                 ret = dac_digital_power(enable);
1307                 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACL_EN),
1308                                     BIT(DACL_EN));
1309                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_L),
1310                                     BIT(DAC_EN_L));
1311         } else {
1312                 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACL_EN), 0);
1313                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_L),
1314                                     0);
1315                 ret = dac_digital_power(enable);
1316         }
1317         return ret;
1318 }
1319
1320 int dacr_digital_switch(int enable)
1321 {
1322         int ret = 0;
1323         struct snd_soc_codec *codec = &s_sprd_codec;
1324         if (enable) {
1325                 ret = dac_digital_power(enable);
1326                 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN),
1327                                     BIT(DACR_EN));
1328                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_R),
1329                                     BIT(DAC_EN_R));
1330         } else {
1331                 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN), 0);
1332                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_R),
1333                                     0);
1334                 ret = dac_digital_power(enable);
1335         }
1336         return ret;
1337 }
1338
1339 static int dac_power(int enable)
1340 {
1341         int ret = 0;
1342         struct snd_soc_codec *codec = &s_sprd_codec;
1343         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1344         sprd_codec_dbg("%s %s %d\n", __func__, _2str(enable),
1345                        atomic_read(&sprd_codec->dac_power_refcount));
1346         if (enable) {
1347                 atomic_inc(&sprd_codec->dac_power_refcount);
1348                 if (atomic_read(&sprd_codec->dac_power_refcount) == 1) {
1349                         analog_power_enable(enable);
1350                         snd_soc_update_bits(codec, SOC_REG(CCR),
1351                                             BIT(DRV_CLK_EN), BIT(DRV_CLK_EN));
1352                 }
1353         } else {
1354                 if (atomic_dec_and_test(&sprd_codec->dac_power_refcount)) {
1355                         snd_soc_update_bits(codec, SOC_REG(CCR),
1356                                             BIT(DRV_CLK_EN), 0);
1357                         analog_power_enable(enable);
1358                 }
1359         }
1360         return ret;
1361 }
1362
1363 #ifdef CONFIG_SPRD_CODEC_USE_INT
1364 #ifndef CONFIG_CODEC_NO_HP_POP
1365 static void sprd_codec_hp_pop_irq_enable(struct snd_soc_codec *codec)
1366 {
1367         int mask = BIT(AUDIO_POP_IRQ);
1368         snd_soc_update_bits(codec, SOC_REG(AUDIF_INT_CLR), mask, mask);
1369         snd_soc_update_bits(codec, SOC_REG(AUDIF_INT_EN), mask, mask);
1370 }
1371 #endif
1372
1373 static irqreturn_t sprd_codec_ap_irq(int irq, void *dev_id)
1374 {
1375         int mask;
1376         struct sprd_codec_priv *sprd_codec = dev_id;
1377         struct snd_soc_codec *codec = sprd_codec->codec;
1378         mask = snd_soc_read(codec, AUDIF_INT_MASK);
1379         sprd_codec_dbg("hp pop irq mask = 0x%x\n", mask);
1380         if (BIT(AUDIO_POP_IRQ) & mask) {
1381                 mask = BIT(AUDIO_POP_IRQ);
1382                 snd_soc_update_bits(codec, SOC_REG(AUDIF_INT_EN), mask, 0);
1383                 complete(&sprd_codec->completion_hp_pop);
1384         }
1385         return IRQ_HANDLED;
1386 }
1387 #endif
1388
1389 #ifndef CONFIG_CODEC_NO_HP_POP
1390 static inline int is_hp_pop_compelet(struct snd_soc_codec *codec)
1391 {
1392         int val;
1393         val = snd_soc_read(codec, IFR1);
1394         val = (val >> HP_POP_FLG) & HP_POP_FLG_MASK;
1395         sprd_codec_dbg("HP POP= 0x%x\n", val);
1396         return HP_POP_FLG_NEAR_CMP == val;
1397 }
1398
1399 static inline int hp_pop_wait_for_compelet(struct snd_soc_codec *codec)
1400 {
1401 #ifdef CONFIG_SPRD_CODEC_USE_INT
1402         int i;
1403         int hp_pop_complete;
1404         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1405         hp_pop_complete = msecs_to_jiffies(SPRD_CODEC_HP_POP_TIMEOUT);
1406         for (i = 0; i < 2; i++) {
1407                 sprd_codec_dbg("hp pop %d irq enable\n", i);
1408                 sprd_codec_hp_pop_irq_enable(codec);
1409                 init_completion(&sprd_codec->completion_hp_pop);
1410                 hp_pop_complete =
1411                     wait_for_completion_timeout(&sprd_codec->completion_hp_pop,
1412                                                 hp_pop_complete);
1413                 sprd_codec_dbg("hp pop %d completion %d\n", i, hp_pop_complete);
1414                 if (!hp_pop_complete) {
1415                         if (!is_hp_pop_compelet(codec)) {
1416                                 pr_err("hp pop %d timeout not complete\n", i);
1417                         } else {
1418                                 pr_err("hp pop %d timeout but complete\n", i);
1419                         }
1420                 } else {
1421                         /* 01 change to 10 maybe walk to 11 shortly,
1422                            so, check it double. */
1423                         sprd_codec_wait(2);
1424                         if (is_hp_pop_compelet(codec)) {
1425                                 return 0;
1426                         }
1427                 }
1428         }
1429 #else
1430         int times;
1431         for (times = 0; times < SPRD_CODEC_HP_POP_TIME_COUNT; times++) {
1432                 if (is_hp_pop_compelet(codec)) {
1433                         /* 01 change to 10 maybe walk to 11 shortly,
1434                            so, check it double. */
1435                         sprd_codec_wait(2);
1436                         if (is_hp_pop_compelet(codec)) {
1437                                 return 0;
1438                         }
1439                 }
1440                 sprd_codec_wait(SPRD_CODEC_HP_POP_TIME_STEP);
1441         }
1442         pr_err("hp pop wait timeout: times = %d \n", times);
1443 #endif
1444         return 0;
1445 }
1446
1447 static int hp_pop_enable(int enable)
1448 {
1449         struct snd_soc_codec *codec = &s_sprd_codec;
1450         int mask;
1451         int ret = 0;
1452
1453         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1454
1455         if (enable) {
1456                 mask = HP_POP_STEP_MASK << HP_POP_STEP;
1457                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1458                                     HP_POP_STEP_2 << HP_POP_STEP);
1459                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1460                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1461                                     HP_POP_CTL_UP << HP_POP_CTL);
1462                 sprd_codec_dbg("U PNRCR1 = 0x%x\n",
1463                                snd_soc_read(codec, PNRCR1));
1464
1465                 ret = hp_pop_wait_for_compelet(codec);
1466                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1467                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1468                                     HP_POP_CTL_HOLD << HP_POP_CTL);
1469                 sprd_codec_dbg("HOLD PNRCR1 = 0x%x\n",
1470                                snd_soc_read(codec, PNRCR1));
1471         } else {
1472                 mask = HP_POP_STEP_MASK << HP_POP_STEP;
1473                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1474                                     HP_POP_STEP_1 << HP_POP_STEP);
1475                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1476                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1477                                     HP_POP_CTL_DOWN << HP_POP_CTL);
1478                 sprd_codec_dbg("D PNRCR1 = 0x%x\n",
1479                                snd_soc_read(codec, PNRCR1));
1480
1481                 ret = hp_pop_wait_for_compelet(codec);
1482                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1483                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1484                                     HP_POP_CTL_DIS << HP_POP_CTL);
1485                 sprd_codec_dbg("DIS PNRCR1 = 0x%x\n",
1486                                snd_soc_read(codec, PNRCR1));
1487         }
1488
1489         sprd_codec_dbg("Leaving %s\n", __func__);
1490
1491         return ret;
1492 }
1493 #else
1494 #ifndef CONFIG_HP_POP_DELAY_TIME
1495 #define CONFIG_HP_POP_DELAY_TIME (0)
1496 #endif
1497 static int hp_pop_enable(int enable)
1498 {
1499         int ret = 0;
1500         sprd_codec_dbg("Entering %s is %s wait %dms\n", __func__,
1501                        _2str(enable), CONFIG_HP_POP_DELAY_TIME);
1502         if (enable) {
1503                 sprd_codec_wait(CONFIG_HP_POP_DELAY_TIME);
1504         }
1505         sprd_codec_dbg("Leaving %s\n", __func__);
1506         return ret;
1507 }
1508 #endif
1509
1510 static int hp_switch_enable(int enable)
1511 {
1512         struct snd_soc_codec *codec = &s_sprd_codec;
1513 #ifndef CONFIG_CODEC_NO_HP_POP
1514         int mask;
1515 #endif
1516         int ret = 0;
1517
1518         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1519
1520         if (enable) {
1521 #if 0                           /* do not enable the diff function from weifeng.ni */
1522                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(DIFF_EN),
1523                                     BIT(DIFF_EN));
1524 #endif
1525
1526 #ifndef CONFIG_CODEC_NO_HP_POP
1527                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1528                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1529                                     HP_POP_CTL_DIS << HP_POP_CTL);
1530                 sprd_codec_dbg("DIS(en) PNRCR1 = 0x%x\n",
1531                                snd_soc_read(codec, PNRCR1));
1532 #endif
1533         } else {
1534                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(DIFF_EN), 0);
1535
1536 #ifndef CONFIG_CODEC_NO_HP_POP
1537                 mask = HP_POP_CTL_MASK << HP_POP_CTL;
1538                 snd_soc_update_bits(codec, SOC_REG(PNRCR1), mask,
1539                                     HP_POP_CTL_HOLD << HP_POP_CTL);
1540                 sprd_codec_dbg("HOLD(en) PNRCR1 = 0x%x\n",
1541                                snd_soc_read(codec, PNRCR1));
1542 #endif
1543         }
1544
1545         _mixer_setting(codec, SPRD_CODEC_HP_DACL,
1546                        SPRD_CODEC_HP_MIXER_MAX, SPRD_CODEC_LEFT,
1547                        snd_soc_read(codec, DCR1) & BIT(HPL_EN));
1548
1549         _mixer_setting(codec, SPRD_CODEC_HP_DACL,
1550                        SPRD_CODEC_HP_MIXER_MAX, SPRD_CODEC_RIGHT,
1551                        snd_soc_read(codec, DCR1) & BIT(HPR_EN));
1552
1553         sprd_codec_dbg("Leaving %s\n", __func__);
1554
1555         return ret;
1556 }
1557
1558 int hp_switch(int enable)
1559 {
1560         int ret = 0;
1561         struct snd_soc_codec *codec = &s_sprd_codec;
1562         if (enable) {
1563                 dac_power(enable);
1564 #ifndef CONFIG_CODEC_NO_HP_POP
1565                 hp_pop_enable(enable);
1566 #endif
1567                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPL_EN),
1568                                     BIT(HPL_EN));
1569                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPR_EN),
1570                                     BIT(HPR_EN));
1571                 ret = hp_switch_enable(enable);
1572 #ifdef CONFIG_CODEC_NO_HP_POP
1573                 hp_pop_enable(enable);
1574 #endif
1575         } else {
1576 #ifdef CONFIG_CODEC_NO_HP_POP
1577                 hp_pop_enable(enable);
1578 #endif
1579                 ret = hp_switch_enable(enable);
1580                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPL_EN), 0);
1581                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPR_EN), 0);
1582 #ifndef CONFIG_CODEC_NO_HP_POP
1583                 hp_pop_enable(enable);
1584 #endif
1585                 dac_power(enable);
1586         }
1587         return ret;
1588 }
1589
1590 static int spk_switch_enable(int enable)
1591 {
1592         struct snd_soc_codec *codec = &s_sprd_codec;
1593         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1594
1595         if (snd_soc_read(codec, DCR1) & BIT(AOL_EN)) {
1596                 if (enable) {
1597                         sprd_codec_pa_sw_set(SPRD_CODEC_PA_SW_AOL);
1598                 } else {
1599                         sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_AOL);
1600                 }
1601         }
1602
1603         _mixer_setting(codec, SPRD_CODEC_SPK_DACL,
1604                        SPRD_CODEC_SPK_MIXER_MAX, SPRD_CODEC_LEFT,
1605                        (snd_soc_read(codec, DCR1) & BIT(AOL_EN)));
1606
1607         _mixer_setting(codec, SPRD_CODEC_SPK_DACL,
1608                        SPRD_CODEC_SPK_MIXER_MAX, SPRD_CODEC_RIGHT,
1609                        (snd_soc_read(codec, DCR1) & BIT(AOR_EN)));
1610
1611         sprd_codec_dbg("Leaving %s\n", __func__);
1612
1613         return 0;
1614 }
1615
1616 int spkl_switch(int enable)
1617 {
1618         int ret = 0;
1619         struct snd_soc_codec *codec = &s_sprd_codec;
1620         if (enable) {
1621                 dac_power(enable);
1622                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOL_EN),
1623                                     BIT(AOL_EN));
1624                 ret = spk_switch_enable(enable);
1625         } else {
1626                 ret = spk_switch_enable(enable);
1627                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOL_EN), 0);
1628                 dac_power(enable);
1629         }
1630         return ret;
1631 }
1632
1633 int spkr_switch(int enable)
1634 {
1635         int ret = 0;
1636         struct snd_soc_codec *codec = &s_sprd_codec;
1637         if (enable) {
1638                 dac_power(enable);
1639                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOR_EN),
1640                                     BIT(AOR_EN));
1641                 ret = spk_switch_enable(enable);
1642         } else {
1643                 ret = spk_switch_enable(enable);
1644                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOR_EN), 0);
1645                 dac_power(enable);
1646         }
1647         return ret;
1648 }
1649
1650 static int ear_switch_enable(int enable)
1651 {
1652         int ret = 0;
1653         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1654
1655 #ifdef CONFIG_SPRD_CODEC_EAR_WITH_IN_SPK
1656         if (enable) {
1657                 sprd_codec_pa_sw_set(SPRD_CODEC_PA_SW_EAR);
1658         } else {
1659                 sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_EAR);
1660         }
1661 #endif
1662
1663         sprd_codec_dbg("Leaving %s\n", __func__);
1664
1665         return ret;
1666 }
1667
1668 int ear_switch(int enable)
1669 {
1670         int ret = 0;
1671         struct snd_soc_codec *codec = &s_sprd_codec;
1672         if (enable) {
1673                 dac_power(enable);
1674                 ret = ear_switch_enable(enable);
1675                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(EAR_EN),
1676                                     BIT(EAR_EN));
1677         } else {
1678                 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(EAR_EN), 0);
1679                 ret = ear_switch_enable(enable);
1680                 dac_power(enable);
1681         }
1682         return ret;
1683 }
1684
1685 static int adc_switch_enable(int enable)
1686 {
1687         struct snd_soc_codec *codec = &s_sprd_codec;
1688         sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1689
1690         _mixer_setting(codec, SPRD_CODEC_AIL, SPRD_CODEC_ADC_MIXER_MAX,
1691                        SPRD_CODEC_LEFT,
1692                        (!(snd_soc_read(codec, AACR2) & BIT(ADCPGAL_PD))));
1693
1694         _mixer_setting(codec, SPRD_CODEC_AIL, SPRD_CODEC_ADC_MIXER_MAX,
1695                        SPRD_CODEC_RIGHT,
1696                        (!(snd_soc_read(codec, AACR2) & BIT(ADCPGAR_PD))));
1697
1698         sprd_codec_dbg("Leaving %s\n", __func__);
1699
1700         return 0;
1701 }
1702
1703 static int adc_digital_power(int enable)
1704 {
1705         int ret = 0;
1706         struct snd_soc_codec *codec = &s_sprd_codec;
1707         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1708         sprd_codec_dbg("%s %s %d\n", __func__, _2str(enable),
1709                        atomic_read(&sprd_codec->adc_digital_power_refcount));
1710         if (enable) {
1711                 atomic_inc(&sprd_codec->adc_digital_power_refcount);
1712                 if (atomic_read(&sprd_codec->adc_digital_power_refcount) == 1) {
1713                         digital_power_enable(enable);
1714                         snd_soc_update_bits(codec, SOC_REG(CCR),
1715                                             BIT(ADC_CLK_PD), 0);
1716                         adie_adc_enable(enable);
1717                 }
1718         } else {
1719                 if (atomic_dec_and_test
1720                     (&sprd_codec->adc_digital_power_refcount)) {
1721                         snd_soc_update_bits(codec, SOC_REG(CCR),
1722                                             BIT(ADC_CLK_PD), BIT(ADC_CLK_PD));
1723                         adie_adc_enable(enable);
1724                         digital_power_enable(enable);
1725                 }
1726         }
1727         return ret;
1728 }
1729
1730 int adcl_digital_switch(int enable)
1731 {
1732         int ret = 0;
1733         struct snd_soc_codec *codec = &s_sprd_codec;
1734         if (enable) {
1735                 ret = adc_digital_power(enable);
1736                 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCL_PD), 0);
1737                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_L),
1738                                     BIT(ADC_EN_L));
1739         } else {
1740                 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCL_PD),
1741                                     BIT(ADCL_PD));
1742                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_L),
1743                                     0);
1744                 ret = adc_digital_power(enable);
1745         }
1746         return ret;
1747 }
1748
1749 int adcr_digital_switch(int enable)
1750 {
1751         int ret = 0;
1752         struct snd_soc_codec *codec = &s_sprd_codec;
1753         if (enable) {
1754                 ret = adc_digital_power(enable);
1755                 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCR_PD), 0);
1756                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_R),
1757                                     BIT(ADC_EN_R));
1758         } else {
1759                 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCR_PD),
1760                                     BIT(ADCR_PD));
1761                 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_R),
1762                                     0);
1763                 ret = adc_digital_power(enable);
1764         }
1765         return ret;
1766 }
1767
1768 static int adc_power(int enable)
1769 {
1770         int ret = 0;
1771         struct snd_soc_codec *codec = &s_sprd_codec;
1772         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1773         sprd_codec_dbg("%s %s %d\n", __func__, _2str(enable),
1774                        atomic_read(&sprd_codec->adc_power_refcount));
1775         if (enable) {
1776                 atomic_inc(&sprd_codec->adc_power_refcount);
1777                 if (atomic_read(&sprd_codec->adc_power_refcount) == 1) {
1778                         analog_power_enable(enable);
1779                         snd_soc_update_bits(codec, SOC_REG(AACR1),
1780                                             BIT(ADC_IBUF_PD), 0);
1781                 }
1782         } else {
1783                 if (atomic_dec_and_test(&sprd_codec->adc_power_refcount)) {
1784                         snd_soc_update_bits(codec, SOC_REG(AACR1),
1785                                             BIT(ADC_IBUF_PD), BIT(ADC_IBUF_PD));
1786                         analog_power_enable(enable);
1787                 }
1788         }
1789         return ret;
1790 }
1791
1792 int adcl_switch(int enable)
1793 {
1794         int ret = 0;
1795         struct snd_soc_codec *codec = &s_sprd_codec;
1796         if (enable) {
1797                 adc_power(enable);
1798                 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAL_PD), 0);
1799                 ret = adc_switch_enable(enable);
1800         } else {
1801                 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAL_PD),
1802                                     BIT(ADCPGAL_PD));
1803                 ret = adc_switch_enable(enable);
1804                 adc_power(enable);
1805         }
1806         return ret;
1807 }
1808
1809 int adcr_switch(int enable)
1810 {
1811         int ret = 0;
1812         struct snd_soc_codec *codec = &s_sprd_codec;
1813         if (enable) {
1814                 adc_power(enable);
1815                 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAR_PD), 0);
1816                 ret = adc_switch_enable(enable);
1817         } else {
1818                 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAR_PD),
1819                                     BIT(ADCPGAR_PD));
1820                 ret = adc_switch_enable(enable);
1821                 adc_power(enable);
1822         }
1823         return ret;
1824 }
1825
1826 int pga_enable(int id, int pgaval, int enable)
1827 {
1828         struct snd_soc_codec *codec = &s_sprd_codec;
1829         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1830         struct sprd_codec_pga_op *pga = &(sprd_codec->pga[id]);
1831         int ret = 0;
1832         int min = sprd_codec_pga_cfg[id].min;
1833         static int s_need_wait = 1;
1834
1835         pga->pgaval = pgaval;
1836
1837         sprd_codec_dbg("Entering %s set %s(%d) is %s\n", __func__,
1838                        sprd_codec_pga_debug_str[id], pga->pgaval,
1839                        _2str(enable));
1840
1841         if (enable) {
1842                 if ((id == SPRD_CODEC_PGA_ADCL) || (id == SPRD_CODEC_PGA_ADCR)) {
1843                         if (s_need_wait == 1) {
1844                                 /* NOTES: reduce linein pop noise must delay 250ms
1845                                    after linein mixer switch on.
1846                                    actually this function perform after
1847                                    adc_switch_enable function for
1848                                    both ADCL/ADCR switch complete.
1849                                  */
1850                                 if (sprd_codec_is_ai_enable(codec)) {
1851                                         sprd_codec_wait(250);
1852                                         sprd_codec_dbg("ADC Switch ON delay\n");
1853                                 }
1854                                 s_need_wait++;
1855                         }
1856                 }
1857                 pga->set = sprd_codec_pga_cfg[id].set;
1858                 ret = pga->set(codec, pga->pgaval);
1859         } else {
1860                 if ((id == SPRD_CODEC_PGA_ADCL) || (id == SPRD_CODEC_PGA_ADCR)) {
1861                         s_need_wait = 1;
1862                 }
1863                 pga->set = 0;
1864                 ret = sprd_codec_pga_cfg[id].set(codec, min);
1865         }
1866
1867         sprd_codec_dbg("Leaving %s\n", __func__);
1868
1869         return ret;
1870 }
1871
1872 int mic_bias_enable(int id, int enable)
1873 {
1874         int ret = 0;
1875
1876         sprd_codec_dbg("Entering %s %s is %s\n", __func__,
1877                        mic_bias_name[id], _2str(enable));
1878
1879         switch (id) {
1880         case SPRD_CODEC_MIC_BIAS:
1881                 if (!(atomic_read(&sprd_codec_power.mic_on) > 0)) {
1882                         sprd_codec_mic_bias_en(enable);
1883                 }
1884                 break;
1885         case SPRD_CODEC_AUXMIC_BIAS:
1886                 if (!(atomic_read(&sprd_codec_power.auxmic_on) > 0)) {
1887                         sprd_codec_auxmic_bias_en(enable);
1888                 }
1889                 break;
1890         default:
1891                 BUG();
1892                 ret = -EINVAL;
1893         }
1894
1895         sprd_codec_dbg("Leaving %s\n", __func__);
1896
1897         return ret;
1898 }
1899
1900 int mixer_enable(int id, int enable)
1901 {
1902         struct snd_soc_codec *codec = &s_sprd_codec;
1903         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1904         struct sprd_codec_mixer *mixer = &(sprd_codec->mixer[id]);
1905         int ret = 0;
1906
1907         pr_info("%s is %s\n", sprd_codec_mixer_debug_str[id], _2str(enable));
1908
1909         if (enable) {
1910                 mixer->on = 1;
1911         } else {
1912                 mixer->on = 0;
1913         }
1914         if (ret >= 0)
1915                 _mixer_setting_one(codec, id, mixer->on);
1916
1917         sprd_codec_dbg("Leaving %s\n", __func__);
1918
1919         return ret;
1920 }
1921
1922 int mixer_get(int id)
1923 {
1924         struct snd_soc_codec *codec = &s_sprd_codec;
1925         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1926         return sprd_codec->mixer[id].on;
1927 }
1928
1929 int mixer_set(int id, int on)
1930 {
1931         struct snd_soc_codec *codec = &s_sprd_codec;
1932         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1933         struct sprd_codec_mixer *mixer = &(sprd_codec->mixer[id]);
1934         int ret = 0;
1935
1936         pr_info("set %s switch %s\n", sprd_codec_mixer_debug_str[id],
1937                 on ? "ON" : "OFF");
1938
1939         if (mixer->on == on)
1940                 return 0;
1941
1942         mixer->on = on;
1943
1944         if (mixer->set)
1945                 ret = mixer->set(codec, mixer->on);
1946
1947         sprd_codec_dbg("Leaving %s\n", __func__);
1948
1949         return ret;
1950 }
1951
1952 static int sprd_codec_vol_put(int id, int pgaval)
1953 {
1954         struct snd_soc_codec *codec = &s_sprd_codec;
1955         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1956         struct sprd_codec_pga_op *pga = &(sprd_codec->pga[id]);
1957         int ret = 0;
1958
1959         pr_info("set PGA[%s] to %d\n", sprd_codec_pga_debug_str[id], pgaval);
1960
1961         pga->pgaval = pgaval;
1962         if (pga->set) {
1963                 ret = pga->set(codec, pga->pgaval);
1964         }
1965         sprd_codec_dbg("Leaving %s\n", __func__);
1966         return ret;
1967 }
1968
1969 static int sprd_codec_vol_get(int id)
1970 {
1971         struct snd_soc_codec *codec = &s_sprd_codec;
1972         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1973         struct sprd_codec_pga_op *pga = &(sprd_codec->pga[id]);
1974
1975         return pga->pgaval;
1976 }
1977
1978 static int sprd_codec_inter_pa_put(int config)
1979 {
1980         int ret = 0;
1981
1982         pr_info("config inter PA 0x%08x\n", config);
1983
1984         mutex_lock(&inter_pa_mutex);
1985         inter_pa.value = (u32) config;
1986         if (inter_pa.set) {
1987                 mutex_unlock(&inter_pa_mutex);
1988                 sprd_inter_speaker_pa(1);
1989         } else {
1990                 mutex_unlock(&inter_pa_mutex);
1991         }
1992         sprd_codec_dbg("Leaving %s\n", __func__);
1993         return ret;
1994 }
1995
1996 static int sprd_codec_inter_pa_get(void)
1997 {
1998         int ret;
1999         mutex_lock(&inter_pa_mutex);
2000         ret = inter_pa.value;
2001         mutex_unlock(&inter_pa_mutex);
2002
2003         return ret;
2004 }
2005
2006 int sprd_codec_pcm_set_sample_rate(int playback, int rate)
2007 {
2008         struct snd_soc_codec *codec = &s_sprd_codec;
2009         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2010         int mask = 0x0F;
2011         int shift = 0;
2012
2013         if (playback) {
2014                 sprd_codec->da_sample_val = rate;
2015                 pr_info("playback rate is [%d]\n", rate);
2016                 sprd_codec_set_sample_rate(codec, rate, mask, shift);
2017         } else {
2018                 sprd_codec->ad_sample_val = rate;
2019                 pr_info("capture rate is [%d]\n", rate);
2020                 sprd_codec_set_ad_sample_rate(codec, rate, mask, shift);
2021         }
2022
2023         return 0;
2024 }
2025
2026 #ifdef CONFIG_SPRD_CODEC_USE_INT
2027 #ifdef CONFIG_CODEC_DAC_MUTE_WAIT
2028 static void sprd_codec_dac_mute_irq_enable(struct snd_soc_codec *codec)
2029 {
2030         int mask = BIT(DAC_MUTE_D);
2031         snd_soc_update_bits(codec, SOC_REG(AUD_INT_CLR), mask, mask);
2032         snd_soc_update_bits(codec, SOC_REG(AUD_INT_EN), mask, mask);
2033 }
2034 #endif
2035
2036 static irqreturn_t sprd_codec_dp_irq(int irq, void *dev_id)
2037 {
2038         int mask;
2039         struct sprd_codec_priv *sprd_codec = dev_id;
2040         struct snd_soc_codec *codec = sprd_codec->codec;
2041         mask = snd_soc_read(codec, AUD_AUD_STS0);
2042         sprd_codec_dbg("dac mute irq mask = 0x%x\n", mask);
2043         if (BIT(DAC_MUTE_D_MASK) & mask) {
2044                 mask = BIT(DAC_MUTE_D);
2045                 complete(&sprd_codec->completion_dac_mute);
2046         }
2047         if (BIT(DAC_MUTE_U_MASK) & mask) {
2048                 mask = BIT(DAC_MUTE_U);
2049         }
2050         snd_soc_update_bits(codec, SOC_REG(AUD_INT_EN), mask, 0);
2051         return IRQ_HANDLED;
2052 }
2053 #endif
2054
2055 static int sprd_codec_digital_mute(int mute)
2056 {
2057         struct snd_soc_codec *codec = &s_sprd_codec;
2058         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2059         int ret = 0;
2060
2061         sprd_codec_dbg("Entering %s\n", __func__);
2062
2063         if (atomic_read(&sprd_codec->power_refcount) >= 1) {
2064                 sprd_codec_dbg("mute %i\n", mute);
2065
2066                 ret =
2067                     snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL),
2068                                         BIT(DAC_MUTE_START),
2069                                         mute ? BIT(DAC_MUTE_START) : 0);
2070 #ifdef CONFIG_CODEC_DAC_MUTE_WAIT
2071 #ifdef CONFIG_SPRD_CODEC_USE_INT
2072                 if (mute && ret) {
2073                         int dac_mute_complete;
2074                         sprd_codec_dbg("dac mute irq enable\n");
2075                         sprd_codec_dac_mute_irq_enable(codec);
2076                         init_completion(&sprd_codec->completion_dac_mute);
2077                         dac_mute_complete =
2078                             wait_for_completion_timeout
2079                             (&sprd_codec->completion_dac_mute,
2080                              msecs_to_jiffies(SPRD_CODEC_DAC_MUTE_TIMEOUT));
2081                         sprd_codec_dbg("dac mute completion %d\n",
2082                                        dac_mute_complete);
2083                         if (!dac_mute_complete) {
2084                                 pr_err("dac mute timeout\n");
2085                         }
2086                 }
2087 #else
2088                 if (mute && ret) {
2089                         sprd_codec_wait(SPRD_CODEC_DAC_MUTE_WAIT_TIME);
2090                 }
2091 #endif
2092 #endif
2093
2094                 sprd_codec_dbg("return %i\n", ret);
2095         }
2096
2097         sprd_codec_dbg("Leaving %s\n", __func__);
2098
2099         return ret;
2100 }
2101
2102 static int sprd_codec_probe(void)
2103 {
2104         struct snd_soc_codec *codec = &s_sprd_codec;
2105         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2106
2107         sprd_codec_dbg("Entering %s\n", __func__);
2108
2109         sprd_codec->codec = codec;
2110
2111         atomic_set(&sprd_codec->power_refcount, 0);
2112         atomic_set(&sprd_codec->adie_adc_refcount, 0);
2113         atomic_set(&sprd_codec->adie_dac_refcount, 0);
2114         atomic_set(&sprd_codec->adc_power_refcount, 0);
2115         atomic_set(&sprd_codec->adc_digital_power_refcount, 0);
2116         atomic_set(&sprd_codec->dac_power_refcount, 0);
2117         atomic_set(&sprd_codec->dac_digital_power_refcount, 0);
2118         atomic_set(&sprd_codec->digital_power_refcount, 0);
2119         atomic_set(&sprd_codec->analog_power_refcount, 0);
2120
2121 #ifdef CONFIG_SPRD_CODEC_USE_INT
2122         sprd_codec->ap_irq = CODEC_AP_IRQ;
2123
2124         ret =
2125             request_irq(sprd_codec->ap_irq, sprd_codec_ap_irq, 0,
2126                         "sprd_codec_ap", sprd_codec);
2127         if (ret) {
2128                 pr_err("request_irq ap failed!\n");
2129                 goto err_irq;
2130         }
2131
2132         sprd_codec->dp_irq = CODEC_DP_IRQ;
2133
2134         ret =
2135             request_irq(sprd_codec->dp_irq, sprd_codec_dp_irq, 0,
2136                         "sprd_codec_dp", sprd_codec);
2137         if (ret) {
2138                 pr_err("request_irq dp failed!\n");
2139                 goto dp_err_irq;
2140         }
2141 #endif
2142
2143         sprd_codec_dbg("Leaving %s\n", __func__);
2144
2145         return 0;
2146
2147 #ifdef CONFIG_SPRD_CODEC_USE_INT
2148 dp_err_irq:
2149         free_irq(sprd_codec->ap_irq, sprd_codec);
2150 err_irq:
2151         return -EINVAL;
2152 #endif
2153 }
2154
2155 static int sprd_codec_deinit(void)
2156 {
2157 #ifdef CONFIG_SPRD_CODEC_USE_INT
2158         struct snd_soc_codec *codec = &s_sprd_codec;
2159         struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2160         free_irq(sprd_codec->ap_irq, sprd_codec);
2161         free_irq(sprd_codec->dp_irq, sprd_codec);
2162 #endif
2163         return 0;
2164 }
2165
2166 int sprd_codec_init(void)
2167 {
2168         sprd_codec_inter_pa_init();
2169         arch_audio_codec_switch(AUDIO_TO_ARM_CTRL);
2170         sprd_codec_probe();
2171         return 0;
2172 }
2173
2174 void sprd_codec_exit(void)
2175 {
2176         sprd_codec_deinit();
2177 }
2178
2179 module_init(sprd_codec_init);
2180 module_exit(sprd_codec_exit);
2181
2182 MODULE_DESCRIPTION("SPRD-CODEC ALSA SoC codec driver");
2183 MODULE_AUTHOR("Ken Kuang <ken.kuang@spreadtrum.com>");
2184 MODULE_LICENSE("GPL");