drivers/sound/codec/sprd-codec-v3.c

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