2 * sound/soc/sprd/codec/sprd/sprd-codec.c
4 * SPRD-CODEC -- SpreadTrum Tiger intergrated codec.
6 * Copyright (C) 2012 SpreadTrum Ltd.
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.
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.
17 #define pr_fmt(fmt) "[audio:codec] " fmt
21 #include <asm/atomic.h>
22 #include <ubi_uboot.h>
24 #include <asm/arch/sprd-audio.h>
25 #include "sprd-codec.h"
27 #ifdef CONFIG_SPRD_AUDIO_DEBUG
28 #define sprd_codec_dbg pr_info
29 #define sprd_bug_on BUG_ON
31 #define sprd_codec_dbg(...)
32 #define sprd_bug_on(...)
35 #define SOC_REG(reg) reg
37 #define DEFINE_SPINLOCK(...)
38 #define DEFINE_MUTEX(...)
40 struct snd_soc_codec {
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;
47 static inline void snd_soc_codec_set_drvdata(struct snd_soc_codec *codec,
50 codec->sprd_codec = data;
53 static inline void *snd_soc_codec_get_drvdata(struct snd_soc_codec *codec)
55 return (void *)codec->sprd_codec;
58 const char *sprd_codec_pga_debug_str[SPRD_CODEC_PGA_MAX] = {
68 typedef int (*sprd_codec_pga_set) (struct snd_soc_codec * codec, int pgaval);
70 struct sprd_codec_pga {
71 sprd_codec_pga_set set;
75 struct sprd_codec_pga_op {
77 sprd_codec_pga_set set;
80 const char *sprd_codec_mixer_debug_str[SPRD_CODEC_MIXER_MAX] = {
111 #define IS_SPRD_CODEC_MIXER_RANG(reg) (((reg) >= SPRD_CODEC_MIXER_START) && ((reg) <= SPRD_CODEC_MIXER_MAX))
113 typedef int (*sprd_codec_mixer_set) (struct snd_soc_codec * codec, int on);
114 struct sprd_codec_mixer {
116 sprd_codec_mixer_set set;
119 struct sprd_codec_inter_pa {
120 /* FIXME little endian */
124 int is_classD_mode:1;
126 int is_auto_LDO_mode:1;
130 struct sprd_codec_pa_setting {
132 struct sprd_codec_inter_pa setting;
138 DEFINE_MUTEX(inter_pa_mutex);
139 static struct sprd_codec_pa_setting inter_pa;
141 static const char *mic_bias_name[SPRD_CODEC_MIC_BIAS_MAX] = {
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;
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
165 struct completion completion_hp_pop;
168 struct completion completion_dac_mute;
172 /* codec local power suppliy */
173 static struct sprd_codec_power_suppliy {
176 atomic_t ldo_refcount;
177 int audio_ldo_open_ok;
180 static inline char *_2str(int enable)
182 return enable ? "enable" : "disable";
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);
191 static void sprd_codec_set_fun(int fun)
193 spin_lock(&sprd_codec_fun_lock);
194 sprd_codec_fun |= fun;
195 spin_unlock(&sprd_codec_fun_lock);
198 static void sprd_codec_clr_fun(int fun)
200 spin_lock(&sprd_codec_fun_lock);
201 sprd_codec_fun &= ~fun;
202 spin_unlock(&sprd_codec_fun_lock);
205 static int sprd_codec_test_fun(int fun)
208 spin_lock(&sprd_codec_fun_lock);
209 ret = sprd_codec_fun & fun;
210 spin_unlock(&sprd_codec_fun_lock);
214 static unsigned int sprd_codec_read(struct snd_soc_codec *codec,
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);
222 sprd_codec_dbg("read the register is not codec's reg = 0x%x\n", reg);
226 static int sprd_codec_write(struct snd_soc_codec *codec, unsigned int reg,
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);
235 sprd_codec_dbg("write the register is not codec's reg = 0x%x\n", reg);
239 static inline unsigned int snd_soc_read(struct snd_soc_codec *codec,
242 return sprd_codec_read(codec, reg);
245 static inline unsigned int snd_soc_write(struct snd_soc_codec *codec,
246 unsigned int reg, unsigned int val)
248 return sprd_codec_write(codec, reg, val);
251 static struct sprd_codec_priv s_sprd_codec_priv = { 0 };
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,
260 * snd_soc_update_bits - update codec register bits
261 * @codec: audio codec
262 * @reg: codec register
263 * @mask: register mask
266 * Writes new register value.
268 * Returns 1 for change, 0 for no change, or negative error code.
270 static int snd_soc_update_bits(struct snd_soc_codec *codec, unsigned int reg,
271 unsigned int mask, unsigned int value)
274 unsigned int old, new;
277 ret = snd_soc_read(codec, reg);
282 new = (old & ~mask) | value;
285 ret = snd_soc_write(codec, reg, new);
293 static void sprd_codec_wait(u32 wait_time)
295 udelay(wait_time * 1000);
298 static unsigned int sprd_codec_read(struct snd_soc_codec *codec,
300 static void sprd_codec_print_regs(struct snd_soc_codec *codec)
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)
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)
325 static inline void sprd_codec_vcm_v_sel(int v_sel)
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);
335 static int sprd_codec_pga_spk_set(struct snd_soc_codec *codec, int pgaval)
339 val = (pgaval & 0xF) << 4;
340 return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
343 static int sprd_codec_pga_spkr_set(struct snd_soc_codec *codec, int pgaval)
348 return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
351 static int sprd_codec_pga_hpl_set(struct snd_soc_codec *codec, int pgaval)
355 val = (pgaval & 0xF) << 4;
356 return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
359 static int sprd_codec_pga_hpr_set(struct snd_soc_codec *codec, int pgaval)
364 return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
367 static int sprd_codec_pga_ear_set(struct snd_soc_codec *codec, int pgaval)
371 val = ((pgaval & 0xF) << 4);
372 return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
375 static int sprd_codec_pga_adcl_set(struct snd_soc_codec *codec, int pgaval)
379 val = (pgaval & 0xF) << 4;
380 return snd_soc_update_bits(codec, SOC_REG(reg), 0xF0, val);
383 static int sprd_codec_pga_adcr_set(struct snd_soc_codec *codec, int pgaval)
388 return snd_soc_update_bits(codec, SOC_REG(reg), 0x0F, val);
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},
398 {sprd_codec_pga_adcl_set, 0},
399 {sprd_codec_pga_adcr_set, 0},
404 static int vcmadcl_set(struct snd_soc_codec *codec)
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);
412 static int vcmadcr_set(struct snd_soc_codec *codec)
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);
420 static int sprd_codec_is_ai_enable(struct snd_soc_codec *codec)
422 return ! !(snd_soc_read(codec, AAICR3) &
423 (BIT(AIL_ADCR) | BIT(AIL_ADCL) | BIT(AIR_ADCR) |
427 static int ailadcl_set(struct snd_soc_codec *codec, int on)
430 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
431 ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIL_ADCL),
435 return vcmadcl_set(codec);
438 static int ailadcr_set(struct snd_soc_codec *codec, int on)
441 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
442 ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIL_ADCR),
446 return vcmadcr_set(codec);
449 static int airadcl_set(struct snd_soc_codec *codec, int on)
452 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
453 ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIR_ADCL),
457 return vcmadcl_set(codec);
460 static int airadcr_set(struct snd_soc_codec *codec, int on)
463 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
464 ret = snd_soc_update_bits(codec, SOC_REG(AAICR3), BIT(AIR_ADCR),
468 return vcmadcr_set(codec);
471 static int mainmicadcl_set(struct snd_soc_codec *codec, int on)
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);
479 static int mainmicadcr_set(struct snd_soc_codec *codec, int on)
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);
487 static int auxmicadcl_set(struct snd_soc_codec *codec, int on)
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);
495 static int auxmicadcr_set(struct snd_soc_codec *codec, int on)
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);
503 static int hpmicadcl_set(struct snd_soc_codec *codec, int on)
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);
511 static int hpmicadcr_set(struct snd_soc_codec *codec, int on)
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);
519 /* adcpga*_en setting */
520 static int adcpgax_auto_setting(struct snd_soc_codec *codec)
522 unsigned int reg1, reg2, reg3;
525 reg1 = snd_soc_read(codec, DAOCR1);
526 reg2 = snd_soc_read(codec, DAOCR2);
527 reg3 = snd_soc_read(codec, DAOCR3);
529 if ((reg1 & BIT(ADCL_P_HPL)) || (reg2 & BIT(ADCL_P_AOLP))
530 || (reg3 & BIT(ADCL_P_AORP))) {
531 val |= BIT(ADCPGAL_P_EN);
533 if ((reg1 & BIT(ADCL_N_HPR)) || (reg2 & BIT(ADCL_N_AOLN))
534 || (reg3 & BIT(ADCL_N_AORN))) {
535 val |= BIT(ADCPGAL_N_EN);
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);
541 if ((reg2 & BIT(ADCR_N_AOLN)) || (reg3 & BIT(ADCR_N_AORN))) {
542 val |= BIT(ADCPGAR_N_EN);
545 BIT(ADCPGAL_P_EN) | BIT(ADCPGAL_N_EN) | BIT(ADCPGAR_P_EN) |
547 return snd_soc_update_bits(codec, SOC_REG(AACR2), mask, val);
552 static int daclhpl_set(struct snd_soc_codec *codec, int on)
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),
559 static int daclhpr_set(struct snd_soc_codec *codec, int on)
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),
566 static int dacrhpl_set(struct snd_soc_codec *codec, int on)
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),
573 static int dacrhpr_set(struct snd_soc_codec *codec, int on)
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),
580 static int adclhpl_set(struct snd_soc_codec *codec, int on)
582 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
583 snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCL_P_HPL),
585 return adcpgax_auto_setting(codec);
588 static int adclhpr_set(struct snd_soc_codec *codec, int on)
590 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
591 snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCL_N_HPR),
593 return adcpgax_auto_setting(codec);
596 static int adcrhpl_set(struct snd_soc_codec *codec, int on)
598 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
599 snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCR_P_HPL),
601 return adcpgax_auto_setting(codec);
604 static int adcrhpr_set(struct snd_soc_codec *codec, int on)
606 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
607 snd_soc_update_bits(codec, SOC_REG(DAOCR1), BIT(ADCR_P_HPR),
609 return adcpgax_auto_setting(codec);
614 static int daclspkl_set(struct snd_soc_codec *codec, int on)
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);
621 static int dacrspkl_set(struct snd_soc_codec *codec, int on)
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);
628 static int adclspkl_set(struct snd_soc_codec *codec, int on)
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);
636 static int adcrspkl_set(struct snd_soc_codec *codec, int on)
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);
646 static int daclspkr_set(struct snd_soc_codec *codec, int on)
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);
653 static int dacrspkr_set(struct snd_soc_codec *codec, int on)
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);
660 static int adclspkr_set(struct snd_soc_codec *codec, int on)
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);
668 static int adcrspkr_set(struct snd_soc_codec *codec, int on)
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);
678 static int daclear_set(struct snd_soc_codec *codec, int on)
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);
685 static sprd_codec_mixer_set mixer_setting[SPRD_CODEC_MIXER_MAX] = {
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,
693 daclhpl_set, daclhpr_set,
694 dacrhpl_set, dacrhpr_set,
695 adclhpl_set, adclhpr_set,
696 adcrhpl_set, adcrhpr_set,
698 daclspkl_set, daclspkr_set,
699 dacrspkl_set, dacrspkr_set,
700 adclspkl_set, adclspkr_set,
701 adcrspkl_set, adcrspkr_set,
706 int sprd_codec_digital_loop(int enable)
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);
713 /* DO NOT USE THIS FUNCTION */
714 static inline void __sprd_codec_pa_sw_en(int on)
718 mask = BIT(PA_SW_EN);
720 arch_audio_codec_write_mask(PMUR2, val, mask);
723 DEFINE_SPINLOCK(sprd_codec_pa_sw_lock);
724 static inline void sprd_codec_pa_sw_set(int fun)
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);
733 static inline void sprd_codec_pa_sw_clr(int fun)
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);
745 static inline void sprd_codec_pa_d_en(int on)
749 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
752 arch_audio_codec_write_mask(DCR2, val, mask);
755 static inline void sprd_codec_pa_demi_en(int on)
759 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
760 mask = BIT(PA_DEMI_EN);
762 arch_audio_codec_write_mask(DCR2, val, mask);
764 mask = BIT(DRV_OCP_AOL_PD) | BIT(DRV_OCP_AOR_PD);
766 arch_audio_codec_write_mask(DCR3, val, mask);
769 static inline void sprd_codec_pa_ldo_en(int on)
773 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
774 mask = BIT(PA_LDO_EN);
776 arch_audio_codec_write_mask(PMUR2, val, mask);
778 sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_AOL);
782 static inline void sprd_codec_pa_ldo_v_sel(int v_sel)
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);
792 static inline void sprd_codec_pa_dtri_f_sel(int f_sel)
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);
802 static inline void sprd_codec_pa_en(int on)
806 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
807 spin_lock(&sprd_codec_pa_sw_lock);
812 if (!sprd_codec_test_fun(SPRD_CODEC_PA_SW_FUN))
813 mask = BIT(PA_EN) | BIT(PA_SW_EN) | BIT(PA_LDO_EN);
815 mask = BIT(PA_EN) | BIT(PA_LDO_EN);
818 arch_audio_codec_write_mask(PMUR2, val, mask);
819 spin_unlock(&sprd_codec_pa_sw_lock);
822 static inline void sprd_codec_inter_pa_init(void)
824 inter_pa.setting.LDO_V_sel = 0x03;
825 inter_pa.setting.DTRI_F_sel = 0x01;
828 int sprd_inter_speaker_pa(int on)
830 pr_info("inter PA switch %s\n", on ? "ON" : "OFF");
831 mutex_lock(&inter_pa_mutex);
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); */
840 sprd_codec_pa_ldo_v_sel(inter_pa.
844 sprd_codec_pa_dtri_f_sel(inter_pa.setting.DTRI_F_sel);
850 sprd_codec_pa_ldo_en(0);
852 mutex_unlock(&inter_pa_mutex);
856 EXPORT_SYMBOL(sprd_inter_speaker_pa);
858 /* mic bias external */
860 static inline void sprd_codec_mic_bias_en(int on)
864 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
865 mask = BIT(MICBIAS_EN);
867 arch_audio_codec_write_mask(PMUR1, val, mask);
870 static inline void sprd_codec_auxmic_bias_en(int on)
874 sprd_codec_dbg("Entering %s set %d\n", __func__, on);
875 mask = BIT(AUXMICBIAS_EN);
877 arch_audio_codec_write_mask(PMUR1, val, mask);
880 static int sprd_codec_set_sample_rate(struct snd_soc_codec *codec, int rate,
885 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
886 SPRD_CODEC_RATE_8000 << shift);
889 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
890 SPRD_CODEC_RATE_11025 << shift);
893 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
894 SPRD_CODEC_RATE_16000 << shift);
897 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
898 SPRD_CODEC_RATE_22050 << shift);
901 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
902 SPRD_CODEC_RATE_32000 << shift);
905 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
906 SPRD_CODEC_RATE_44100 << shift);
909 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
910 SPRD_CODEC_RATE_48000 << shift);
913 snd_soc_update_bits(codec, SOC_REG(AUD_DAC_CTL), mask,
914 SPRD_CODEC_RATE_96000 << shift);
917 pr_err("sprd_codec not supports rate %d\n", rate);
923 static int sprd_codec_set_ad_sample_rate(struct snd_soc_codec *codec, int rate,
929 pr_err("sprd_codec not supports ad rate %d\n", rate);
931 snd_soc_update_bits(codec, SOC_REG(AUD_ADC_CTL), mask, set << shift);
935 static int sprd_codec_sample_rate_setting(struct sprd_codec_priv *sprd_codec)
937 if (sprd_codec->ad_sample_val) {
938 sprd_codec_set_ad_sample_rate(sprd_codec->codec,
939 sprd_codec->ad_sample_val, 0x0F,
942 if (sprd_codec->da_sample_val) {
943 sprd_codec_set_sample_rate(sprd_codec->codec,
944 sprd_codec->da_sample_val, 0x0F, 0);
949 static int sprd_codec_update_bits(struct snd_soc_codec *codec,
950 unsigned int reg, unsigned int mask,
954 return arch_audio_codec_write_mask(reg, value, mask);
956 return snd_soc_update_bits(codec, reg, mask, value);
960 static int sprd_codec_ldo_on(struct sprd_codec_priv *sprd_codec)
962 struct snd_soc_codec *codec = 0;
963 sprd_codec_dbg("Entering %s\n", __func__);
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");
969 codec = sprd_codec->codec;
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); */
977 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_IBIAS_EN),
979 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_EN),
981 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_EN),
983 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VCM_BUF_EN),
985 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VB_EN),
987 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(VBO_EN),
991 sprd_codec_wait(SPRD_CODEC_LDO_WAIT_TIME);
995 sprd_codec_dbg("Leaving %s\n", __func__);
999 static int sprd_codec_ldo_off(struct sprd_codec_priv *sprd_codec)
1001 struct snd_soc_codec *codec = 0;
1002 sprd_codec_dbg("Entering %s\n", __func__);
1004 if (atomic_dec_and_test(&sprd_codec_power.ldo_refcount)) {
1006 codec = sprd_codec->codec;
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),
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),
1016 sprd_codec_update_bits(codec, SOC_REG(PMUR1), BIT(BG_EN), 0);
1018 arch_audio_codec_reset();
1019 arch_audio_codec_disable();
1020 arch_audio_codec_analog_reg_disable();
1021 sprd_codec_dbg("ldo off!\n");
1024 sprd_codec_dbg("Leaving %s\n", __func__);
1028 static int sprd_codec_ldo_control(int on)
1031 return sprd_codec_ldo_on(0);
1033 return sprd_codec_ldo_off(0);
1037 static void sprd_codec_mic_delay_worker(void)
1039 int on = atomic_read(&sprd_codec_power.mic_on) > 0;
1040 sprd_codec_ldo_control(on);
1041 sprd_codec_mic_bias_en(on);
1044 static void sprd_codec_auxmic_delay_worker(void)
1046 int on = atomic_read(&sprd_codec_power.auxmic_on) > 0;
1047 sprd_codec_ldo_control(on);
1048 sprd_codec_auxmic_bias_en(on);
1051 static int sprd_codec_mic_bias_inter(int on, atomic_t * v)
1057 if (atomic_read(v) > 0) {
1065 int sprd_codec_mic_bias_control(int on)
1067 if (sprd_codec_mic_bias_inter(on, &sprd_codec_power.mic_on)) {
1068 sprd_codec_mic_delay_worker();
1073 EXPORT_SYMBOL(sprd_codec_mic_bias_control);
1075 int sprd_codec_auxmic_bias_control(int on)
1077 if (sprd_codec_mic_bias_inter(on, &sprd_codec_power.auxmic_on)) {
1078 sprd_codec_auxmic_delay_worker();
1083 EXPORT_SYMBOL(sprd_codec_auxmic_bias_control);
1085 static int sprd_codec_open(struct snd_soc_codec *codec)
1087 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1090 sprd_codec_dbg("Entering %s\n", __func__);
1092 sprd_codec_sample_rate_setting(sprd_codec);
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);
1098 sprd_codec_dbg("Leaving %s\n", __func__);
1102 static void sprd_codec_power_enable(struct snd_soc_codec *codec)
1104 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
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);
1112 pr_err("sprd_codec open ldo error %d\n", ret);
1113 sprd_codec_open(codec);
1114 sprd_codec_dbg("Leaving %s\n", __func__);
1118 static void sprd_codec_power_disable(struct snd_soc_codec *codec)
1120 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
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__);
1129 static int analog_power_enable(int enable)
1131 struct snd_soc_codec *codec = &s_sprd_codec;
1132 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1135 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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);
1143 if (atomic_dec_and_test(&sprd_codec->analog_power_refcount)) {
1144 sprd_codec_power_disable(codec);
1151 static int digital_power_enable(int enable)
1154 struct snd_soc_codec *codec = &s_sprd_codec;
1155 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1157 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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();
1165 if (atomic_dec_and_test(&sprd_codec->digital_power_refcount)) {
1166 arch_audio_codec_digital_reg_disable();
1169 ret = analog_power_enable(enable);
1174 static int adie_dac_enable(int enable)
1176 struct snd_soc_codec *codec = &s_sprd_codec;
1177 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1180 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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),
1187 BIT(AUDIFA_DAC_EN));
1188 pr_info("DAC ON\n");
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");
1198 sprd_codec_dbg("Leaving %s\n", __func__);
1203 static int adie_adc_enable(int enable)
1205 struct snd_soc_codec *codec = &s_sprd_codec;
1206 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
1209 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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),
1216 BIT(AUDIFA_ADC_EN));
1217 pr_info("ADC ON\n");
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");
1227 sprd_codec_dbg("Leaving %s\n", __func__);
1232 static int _mixer_set_mixer(struct snd_soc_codec *codec, int id, int lr,
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]);
1239 mixer->set = mixer_setting[reg];
1240 return mixer->set(codec, mixer->on);
1242 mixer_setting[reg] (codec, 0);
1248 static inline int _mixer_setting(struct snd_soc_codec *codec, int start,
1249 int end, int lr, int try_on)
1252 for (id = start; id < end; id++) {
1253 _mixer_set_mixer(codec, id, lr, try_on);
1258 static inline int _mixer_setting_one(struct snd_soc_codec *codec, int id,
1263 return _mixer_setting(codec, id, id + 1, lr, try_on);
1266 static int dac_digital_power(int enable)
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));
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),
1279 snd_soc_update_bits(codec, SOC_REG(DACR), 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);
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),
1290 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN),
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);
1301 int dacl_digital_switch(int enable)
1304 struct snd_soc_codec *codec = &s_sprd_codec;
1306 ret = dac_digital_power(enable);
1307 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACL_EN),
1309 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_L),
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),
1315 ret = dac_digital_power(enable);
1320 int dacr_digital_switch(int enable)
1323 struct snd_soc_codec *codec = &s_sprd_codec;
1325 ret = dac_digital_power(enable);
1326 snd_soc_update_bits(codec, SOC_REG(DACR), BIT(DACR_EN),
1328 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(DAC_EN_R),
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),
1334 ret = dac_digital_power(enable);
1339 static int dac_power(int enable)
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));
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));
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);
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)
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);
1373 static irqreturn_t sprd_codec_ap_irq(int irq, void *dev_id)
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);
1389 #ifndef CONFIG_CODEC_NO_HP_POP
1390 static inline int is_hp_pop_compelet(struct snd_soc_codec *codec)
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;
1399 static inline int hp_pop_wait_for_compelet(struct snd_soc_codec *codec)
1401 #ifdef CONFIG_SPRD_CODEC_USE_INT
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);
1411 wait_for_completion_timeout(&sprd_codec->completion_hp_pop,
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);
1418 pr_err("hp pop %d timeout but complete\n", i);
1421 /* 01 change to 10 maybe walk to 11 shortly,
1422 so, check it double. */
1424 if (is_hp_pop_compelet(codec)) {
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. */
1436 if (is_hp_pop_compelet(codec)) {
1440 sprd_codec_wait(SPRD_CODEC_HP_POP_TIME_STEP);
1442 pr_err("hp pop wait timeout: times = %d \n", times);
1447 static int hp_pop_enable(int enable)
1449 struct snd_soc_codec *codec = &s_sprd_codec;
1453 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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));
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));
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));
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));
1489 sprd_codec_dbg("Leaving %s\n", __func__);
1494 #ifndef CONFIG_HP_POP_DELAY_TIME
1495 #define CONFIG_HP_POP_DELAY_TIME (0)
1497 static int hp_pop_enable(int enable)
1500 sprd_codec_dbg("Entering %s is %s wait %dms\n", __func__,
1501 _2str(enable), CONFIG_HP_POP_DELAY_TIME);
1503 sprd_codec_wait(CONFIG_HP_POP_DELAY_TIME);
1505 sprd_codec_dbg("Leaving %s\n", __func__);
1510 static int hp_switch_enable(int enable)
1512 struct snd_soc_codec *codec = &s_sprd_codec;
1513 #ifndef CONFIG_CODEC_NO_HP_POP
1518 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(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),
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));
1534 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(DIFF_EN), 0);
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));
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));
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));
1553 sprd_codec_dbg("Leaving %s\n", __func__);
1558 int hp_switch(int enable)
1561 struct snd_soc_codec *codec = &s_sprd_codec;
1564 #ifndef CONFIG_CODEC_NO_HP_POP
1565 hp_pop_enable(enable);
1567 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPL_EN),
1569 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(HPR_EN),
1571 ret = hp_switch_enable(enable);
1572 #ifdef CONFIG_CODEC_NO_HP_POP
1573 hp_pop_enable(enable);
1576 #ifdef CONFIG_CODEC_NO_HP_POP
1577 hp_pop_enable(enable);
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);
1590 static int spk_switch_enable(int enable)
1592 struct snd_soc_codec *codec = &s_sprd_codec;
1593 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1595 if (snd_soc_read(codec, DCR1) & BIT(AOL_EN)) {
1597 sprd_codec_pa_sw_set(SPRD_CODEC_PA_SW_AOL);
1599 sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_AOL);
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)));
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)));
1611 sprd_codec_dbg("Leaving %s\n", __func__);
1616 int spkl_switch(int enable)
1619 struct snd_soc_codec *codec = &s_sprd_codec;
1622 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOL_EN),
1624 ret = spk_switch_enable(enable);
1626 ret = spk_switch_enable(enable);
1627 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOL_EN), 0);
1633 int spkr_switch(int enable)
1636 struct snd_soc_codec *codec = &s_sprd_codec;
1639 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOR_EN),
1641 ret = spk_switch_enable(enable);
1643 ret = spk_switch_enable(enable);
1644 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(AOR_EN), 0);
1650 static int ear_switch_enable(int enable)
1653 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1655 #ifdef CONFIG_SPRD_CODEC_EAR_WITH_IN_SPK
1657 sprd_codec_pa_sw_set(SPRD_CODEC_PA_SW_EAR);
1659 sprd_codec_pa_sw_clr(SPRD_CODEC_PA_SW_EAR);
1663 sprd_codec_dbg("Leaving %s\n", __func__);
1668 int ear_switch(int enable)
1671 struct snd_soc_codec *codec = &s_sprd_codec;
1674 ret = ear_switch_enable(enable);
1675 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(EAR_EN),
1678 snd_soc_update_bits(codec, SOC_REG(DCR1), BIT(EAR_EN), 0);
1679 ret = ear_switch_enable(enable);
1685 static int adc_switch_enable(int enable)
1687 struct snd_soc_codec *codec = &s_sprd_codec;
1688 sprd_codec_dbg("Entering %s is %s\n", __func__, _2str(enable));
1690 _mixer_setting(codec, SPRD_CODEC_AIL, SPRD_CODEC_ADC_MIXER_MAX,
1692 (!(snd_soc_read(codec, AACR2) & BIT(ADCPGAL_PD))));
1694 _mixer_setting(codec, SPRD_CODEC_AIL, SPRD_CODEC_ADC_MIXER_MAX,
1696 (!(snd_soc_read(codec, AACR2) & BIT(ADCPGAR_PD))));
1698 sprd_codec_dbg("Leaving %s\n", __func__);
1703 static int adc_digital_power(int enable)
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));
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);
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);
1730 int adcl_digital_switch(int enable)
1733 struct snd_soc_codec *codec = &s_sprd_codec;
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),
1740 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCL_PD),
1742 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_L),
1744 ret = adc_digital_power(enable);
1749 int adcr_digital_switch(int enable)
1752 struct snd_soc_codec *codec = &s_sprd_codec;
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),
1759 snd_soc_update_bits(codec, SOC_REG(AACR1), BIT(ADCR_PD),
1761 snd_soc_update_bits(codec, SOC_REG(AUD_TOP_CTL), BIT(ADC_EN_R),
1763 ret = adc_digital_power(enable);
1768 static int adc_power(int enable)
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));
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);
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);
1792 int adcl_switch(int enable)
1795 struct snd_soc_codec *codec = &s_sprd_codec;
1798 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAL_PD), 0);
1799 ret = adc_switch_enable(enable);
1801 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAL_PD),
1803 ret = adc_switch_enable(enable);
1809 int adcr_switch(int enable)
1812 struct snd_soc_codec *codec = &s_sprd_codec;
1815 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAR_PD), 0);
1816 ret = adc_switch_enable(enable);
1818 snd_soc_update_bits(codec, SOC_REG(AACR2), BIT(ADCPGAR_PD),
1820 ret = adc_switch_enable(enable);
1826 int pga_enable(int id, int pgaval, int enable)
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]);
1832 int min = sprd_codec_pga_cfg[id].min;
1833 static int s_need_wait = 1;
1835 pga->pgaval = pgaval;
1837 sprd_codec_dbg("Entering %s set %s(%d) is %s\n", __func__,
1838 sprd_codec_pga_debug_str[id], pga->pgaval,
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.
1850 if (sprd_codec_is_ai_enable(codec)) {
1851 sprd_codec_wait(250);
1852 sprd_codec_dbg("ADC Switch ON delay\n");
1857 pga->set = sprd_codec_pga_cfg[id].set;
1858 ret = pga->set(codec, pga->pgaval);
1860 if ((id == SPRD_CODEC_PGA_ADCL) || (id == SPRD_CODEC_PGA_ADCR)) {
1864 ret = sprd_codec_pga_cfg[id].set(codec, min);
1867 sprd_codec_dbg("Leaving %s\n", __func__);
1872 int mic_bias_enable(int id, int enable)
1876 sprd_codec_dbg("Entering %s %s is %s\n", __func__,
1877 mic_bias_name[id], _2str(enable));
1880 case SPRD_CODEC_MIC_BIAS:
1881 if (!(atomic_read(&sprd_codec_power.mic_on) > 0)) {
1882 sprd_codec_mic_bias_en(enable);
1885 case SPRD_CODEC_AUXMIC_BIAS:
1886 if (!(atomic_read(&sprd_codec_power.auxmic_on) > 0)) {
1887 sprd_codec_auxmic_bias_en(enable);
1895 sprd_codec_dbg("Leaving %s\n", __func__);
1900 int mixer_enable(int id, int enable)
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]);
1907 pr_info("%s is %s\n", sprd_codec_mixer_debug_str[id], _2str(enable));
1915 _mixer_setting_one(codec, id, mixer->on);
1917 sprd_codec_dbg("Leaving %s\n", __func__);
1922 int mixer_get(int id)
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;
1929 int mixer_set(int id, int on)
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]);
1936 pr_info("set %s switch %s\n", sprd_codec_mixer_debug_str[id],
1939 if (mixer->on == on)
1945 ret = mixer->set(codec, mixer->on);
1947 sprd_codec_dbg("Leaving %s\n", __func__);
1952 static int sprd_codec_vol_put(int id, int pgaval)
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]);
1959 pr_info("set PGA[%s] to %d\n", sprd_codec_pga_debug_str[id], pgaval);
1961 pga->pgaval = pgaval;
1963 ret = pga->set(codec, pga->pgaval);
1965 sprd_codec_dbg("Leaving %s\n", __func__);
1969 static int sprd_codec_vol_get(int id)
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]);
1978 static int sprd_codec_inter_pa_put(int config)
1982 pr_info("config inter PA 0x%08x\n", config);
1984 mutex_lock(&inter_pa_mutex);
1985 inter_pa.value = (u32) config;
1987 mutex_unlock(&inter_pa_mutex);
1988 sprd_inter_speaker_pa(1);
1990 mutex_unlock(&inter_pa_mutex);
1992 sprd_codec_dbg("Leaving %s\n", __func__);
1996 static int sprd_codec_inter_pa_get(void)
1999 mutex_lock(&inter_pa_mutex);
2000 ret = inter_pa.value;
2001 mutex_unlock(&inter_pa_mutex);
2006 int sprd_codec_pcm_set_sample_rate(int playback, int rate)
2008 struct snd_soc_codec *codec = &s_sprd_codec;
2009 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
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);
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);
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)
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);
2036 static irqreturn_t sprd_codec_dp_irq(int irq, void *dev_id)
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);
2047 if (BIT(DAC_MUTE_U_MASK) & mask) {
2048 mask = BIT(DAC_MUTE_U);
2050 snd_soc_update_bits(codec, SOC_REG(AUD_INT_EN), mask, 0);
2055 static int sprd_codec_digital_mute(int mute)
2057 struct snd_soc_codec *codec = &s_sprd_codec;
2058 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2061 sprd_codec_dbg("Entering %s\n", __func__);
2063 if (atomic_read(&sprd_codec->power_refcount) >= 1) {
2064 sprd_codec_dbg("mute %i\n", mute);
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
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);
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",
2083 if (!dac_mute_complete) {
2084 pr_err("dac mute timeout\n");
2089 sprd_codec_wait(SPRD_CODEC_DAC_MUTE_WAIT_TIME);
2094 sprd_codec_dbg("return %i\n", ret);
2097 sprd_codec_dbg("Leaving %s\n", __func__);
2102 static int sprd_codec_probe(void)
2104 struct snd_soc_codec *codec = &s_sprd_codec;
2105 struct sprd_codec_priv *sprd_codec = snd_soc_codec_get_drvdata(codec);
2107 sprd_codec_dbg("Entering %s\n", __func__);
2109 sprd_codec->codec = codec;
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);
2121 #ifdef CONFIG_SPRD_CODEC_USE_INT
2122 sprd_codec->ap_irq = CODEC_AP_IRQ;
2125 request_irq(sprd_codec->ap_irq, sprd_codec_ap_irq, 0,
2126 "sprd_codec_ap", sprd_codec);
2128 pr_err("request_irq ap failed!\n");
2132 sprd_codec->dp_irq = CODEC_DP_IRQ;
2135 request_irq(sprd_codec->dp_irq, sprd_codec_dp_irq, 0,
2136 "sprd_codec_dp", sprd_codec);
2138 pr_err("request_irq dp failed!\n");
2143 sprd_codec_dbg("Leaving %s\n", __func__);
2147 #ifdef CONFIG_SPRD_CODEC_USE_INT
2149 free_irq(sprd_codec->ap_irq, sprd_codec);
2155 static int sprd_codec_deinit(void)
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);
2166 int sprd_codec_init(void)
2168 sprd_codec_inter_pa_init();
2169 arch_audio_codec_switch(AUDIO_TO_ARM_CTRL);
2174 void sprd_codec_exit(void)
2176 sprd_codec_deinit();
2179 module_init(sprd_codec_init);
2180 module_exit(sprd_codec_exit);
2182 MODULE_DESCRIPTION("SPRD-CODEC ALSA SoC codec driver");
2183 MODULE_AUTHOR("Ken Kuang <ken.kuang@spreadtrum.com>");
2184 MODULE_LICENSE("GPL");