aixiao/build
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
c97506efcc
build/patch/kernel/archive/rockchip64-5.12/board-rockpis-0019-Sync-rk3308_codec-to-BSP-tree.patch

6741 lines
212 KiB
Diff
Raw Normal View History

添加构建Allwinner H616四核2GB RAM SoC WiFi（蓝莓）
2023-09-19 11:24:52 +08:00
From 26d61ff64d9a61425d017846db61e9a06de07286 Mon Sep 17 00:00:00 2001
From: ashthespy <ashthespy@gmail.com>
Date: Mon, 3 Feb 2020 17:13:59 +0100
Subject: [PATCH 19/23] Sync `rk3308_codec` to BSP tree
---
.../bindings/sound/rockchip,rk3308-codec.txt | 78 +
sound/soc/codecs/rk3308_codec.c | 5687 ++++++++++++++---
sound/soc/codecs/rk3308_codec.h | 217 +-
sound/soc/codecs/rk3308_codec_provider.h | 28 +
4 files changed, 4894 insertions(+), 1116 deletions(-)
create mode 100644 Documentation/devicetree/bindings/sound/rockchip,rk3308-codec.txt
create mode 100644 sound/soc/codecs/rk3308_codec_provider.h
diff --git a/Documentation/devicetree/bindings/sound/rockchip,rk3308-codec.txt b/Documentation/devicetree/bindings/sound/rockchip,rk3308-codec.txt
new file mode 100644
index 000000000000..e20bbd73e37e
--- /dev/null
+++ b/Documentation/devicetree/bindings/sound/rockchip,rk3308-codec.txt
@@ -0,0 +1,78 @@
+* Rockchip RK3308 Internal Codec
+
+Required properties:
+
+- compatible: "rockchip,rk3308-codec"
+- reg: The physical base address of the controller and length of memory
+ mapped region.
+- rockchip,grf: The phandle of the syscon node for GRF register.
+- clocks: A list of phandle + clock-specifer pairs, one for each entry in
+ clock-names.
+- clock-names: It should be "acodec".
+- resets : Must contain an entry for each entry in reset-names.
+- reset-names : Must include the following entries: "acodec-reset".
+
+Optional properties:
+- rockchip,enable-all-adcs: This is a boolean type property, that shows whether
+ force enable all of ADCs. The following shows the relationship between grps
+ and ADC:
+ * grp 0 -- select ADC1 / ADC2
+ * grp 1 -- select ADC3 / ADC4
+ * grp 2 -- select ADC5 / ADC6
+ * grp 3 -- select ADC7 / ADC8
+ If the property is not used, the enabled ADC groups refer to needed channels
+ via configure hw_params.
+
+- rockchip,adc-grps-route: This is a variable length array, that shows the
+ mapping route of ACODEC sdo to I2S sdi. By default, they are one-to-one
+ mapping:
+ * sdi_0 <-- sdo_0
+ * sdi_1 <-- sdo_1
+ * sdi_2 <-- sdo_2
+ * sdi_3 <-- sdo_3
+ If you would like to change the route mapping like this:
+ * sdi_0 <-- sdo_3
+ * sdi_1 <-- sdo_0
+ * sdi_2 <-- sdo_2
+ * sdi_3 <-- sdo_1
+ You need to add the property on dts:
+ - rockchip,adc-grps-route = <3 0 2 1>;
+
+- rockchip,delay-loopback-handle-ms: This property points out that the delay for
+ handling ADC after enable PAs during loopback.
+- rockchip,delay-start-play-ms: This property points out the delay ms of start
+ playback according to different amplifier performance.
+- rockchip,en-always-grps: This property will keep the needed ADCs enabled
+ always after enabling once.
+- rockchip,loopback-grp: It points out the ADC group which is the loopback used.
+- rockchip,no-deep-low-power: The codec will not enter deep low power mode
+ during suspend.
+- rockchip,no-hp-det: If there is no headphone on boards, we don't need to
+ enable headphone detection.
+- rockchip,micbias1: Using internal micbias1 supply which are from codec.
+- rockchip,micbias2: Using internal micbias2 supply which are from codec.
+- rockchip,hp-jack-reversed;: To detect headphone via the reversed jack.
+- hp-ctl-gpios: The gpio of head phone controller.
+- pa-drv-gpios: The gpio of poweramplifier controller
+- rockchip,delay-pa-drv-ms: This property points out that the delay for
+ power on amplifier
+- spk-ctl-gpios: The gpio of speak controller.
+- micbias-en-gpios: The GPIO to enable external micbias.
+- vmicbias-supply: The phandle to the regulator to handle external micbias.
+
+Example for rk3308 internal codec:
+
+acodec: acodec@ff560000 {
+ compatible = "rockchip,rk3308-codec";
+ reg = <0x0 0xff560000 0x0 0x10000>;
+ rockchip,grf = <&grf>;
+ clocks = <&cru PCLK_ACODEC>;
+ clock-names = "acodec";
+ resets = <&cru SRST_ACODEC_P>;
+ reset-names = "acodec-reset";
+ rockchip,loopback-grp = <0>;
+ hp-ctl-gpios = <&gpio0 1 GPIO_ACTIVE_HIGH>;
+ pa-drv-gpios = <&gpio0 RK_PC0 GPIO_ACTIVE_HIGH>;
+ spk-ctl-gpios = <&gpio0 5 GPIO_ACTIVE_HIGH>;
+ status = "okay";
+};
diff --git a/sound/soc/codecs/rk3308_codec.c b/sound/soc/codecs/rk3308_codec.c
index 106f09738dd0..815e22fc346c 100644
--- a/sound/soc/codecs/rk3308_codec.c
+++ b/sound/soc/codecs/rk3308_codec.c
@@ -29,1420 +29,4699 @@
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
#include <linux/reset.h>
#include <linux/rockchip/grf.h>
#include <linux/version.h>
#include <sound/core.h>
#include <sound/dmaengine_pcm.h>
#include <sound/initval.h>
+#include <sound/jack.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
+#include <sound/simple_card.h>
#include <sound/soc.h>
#include <sound/tlv.h>
#include "rk3308_codec.h"
+#include "rk3308_codec_provider.h"
+
+#if defined(CONFIG_DEBUG_FS)
+#include <linux/fs.h>
+#include <linux/debugfs.h>
+#include <linux/seq_file.h>
+#endif
+
+#define CODEC_DRV_NAME "rk3308-acodec"
+
+#define ADC_GRP_SKIP_MAGIC 0x1001
+#define ADC_LR_GROUP_MAX 4
+#define ADC_STABLE_MS 200
+#define DEBUG_POP_ALWAYS 0
+#define HPDET_POLL_MS 2000
+#define NOT_USED 255
+#define LOOPBACK_HANDLE_MS 100
+#define PA_DRV_MS 5
+
+#define GRF_SOC_CON1 0x304
+#define GRF_CHIP_ID 0x800
+#define GRF_I2S2_8CH_SDI_SFT 0
+#define GRF_I2S3_4CH_SDI_SFT 8
+#define GRF_I2S1_2CH_SDI_SFT 12
+
+#define GRF_I2S2_8CH_SDI_R_MSK(i, v) ((v >> (i * 2 + GRF_I2S2_8CH_SDI_SFT)) & 0x3)
+#define GRF_I2S2_8CH_SDI_W_MSK(i) (0x3 << (i * 2 + GRF_I2S2_8CH_SDI_SFT + 16))
+#define GRF_I2S2_8CH_SDI(i, v) (((v & 0x3) << (i * 2 + GRF_I2S2_8CH_SDI_SFT)) |\
+ GRF_I2S2_8CH_SDI_W_MSK(i))
+
+#define GRF_I2S3_4CH_SDI_W_MSK(i) (0x3 << (i * 2 + GRF_I2S3_4CH_SDI_SFT + 16))
+#define GRF_I2S3_4CH_SDI(i, v) (((v & 0x3) << (i * 2 + GRF_I2S3_4CH_SDI_SFT)) |\
+ GRF_I2S3_4CH_SDI_W_MSK(i))
+
+#define GRF_I2S1_2CH_SDI_W_MSK (0x3 << (GRF_I2S1_2CH_SDI_SFT + 16))
+#define GRF_I2S1_2CH_SDI(v) (((v & 0x3) << GRF_I2S1_2CH_SDI_SFT) |\
+ GRF_I2S1_2CH_SDI_W_MSK)
+
+#define DETECT_GRF_ACODEC_HPDET_COUNTER 0x0030
+#define DETECT_GRF_ACODEC_HPDET_CON 0x0034
+#define DETECT_GRF_ACODEC_HPDET_STATUS 0x0038
+#define DETECT_GRF_ACODEC_HPDET_STATUS_CLR 0x003c
+
+/* 200ms based on pclk is 100MHz */
+#define DEFAULT_HPDET_COUNT 20000000
+#define HPDET_NEG_IRQ_SFT 1
+#define HPDET_POS_IRQ_SFT 0
+#define HPDET_BOTH_NEG_POS ((1 << HPDET_NEG_IRQ_SFT) |\
+ (1 << HPDET_POS_IRQ_SFT))
+
+#define ACODEC_VERSION_A 0xa
+#define ACODEC_VERSION_B 0xb
+
+enum {
+ ACODEC_TO_I2S2_8CH = 0,
+ ACODEC_TO_I2S3_4CH,
+ ACODEC_TO_I2S1_2CH,
+};
+
+enum {
+ ADC_GRP0_MICIN = 0,
+ ADC_GRP0_LINEIN
+};
+
+enum {
+ ADC_TYPE_NORMAL = 0,
+ ADC_TYPE_LOOPBACK,
+ ADC_TYPE_DBG,
+ ADC_TYPE_ALL,
+};
+
+enum {
+ DAC_LINEOUT = 0,
+ DAC_HPOUT = 1,
+ DAC_LINEOUT_HPOUT = 11,
+};
+
+enum {
+ EXT_MICBIAS_NONE = 0,
+ EXT_MICBIAS_FUNC1, /* enable external micbias via GPIO */
+ EXT_MICBIAS_FUNC2, /* enable external micbias via regulator */
+};
+
+enum {
+ PATH_IDLE = 0,
+ PATH_BUSY,
+};
+
+enum {
+ PM_NORMAL = 0,
+ PM_LLP_DOWN, /* light low power down */
+ PM_LLP_UP,
+ PM_DLP_DOWN, /* deep low power down */
+ PM_DLP_UP,
+ PM_DLP_DOWN2,
+ PM_DLP_UP2,
+};
struct rk3308_codec_priv {
const struct device *plat_dev;
struct device dev;
struct reset_control *reset;
struct regmap *regmap;
+ struct regmap *grf;
+ struct regmap *detect_grf;
struct clk *pclk;
+ struct clk *mclk_rx;
+ struct clk *mclk_tx;
+ struct gpio_desc *micbias_en_gpio;
+ struct gpio_desc *hp_ctl_gpio;
struct gpio_desc *spk_ctl_gpio;
- int adc_ch; /* To select ADCs for channel */
- int adc_ch0_using_linein;
+ struct gpio_desc *pa_drv_gpio;
+ struct snd_soc_codec *codec;
+ struct snd_soc_jack *hpdet_jack;
+ struct regulator *vcc_micbias;
+ u32 codec_ver;
+
+ /*
+ * To select ADCs for groups:
+ *
+ * grp 0 -- select ADC1 / ADC2
+ * grp 1 -- select ADC3 / ADC4
+ * grp 2 -- select ADC5 / ADC6
+ * grp 3 -- select ADC7 / ADC8
+ */
+ u32 used_adc_grps;
+ /* The ADC group which is used for loop back */
+ u32 loopback_grp;
+ u32 cur_dbg_grp;
+ u32 en_always_grps[ADC_LR_GROUP_MAX];
+ u32 en_always_grps_num;
+ u32 skip_grps[ADC_LR_GROUP_MAX];
+ u32 i2s_sdis[ADC_LR_GROUP_MAX];
+ u32 to_i2s_grps;
+ u32 delay_loopback_handle_ms;
+ u32 delay_start_play_ms;
+ u32 delay_pa_drv_ms;
+ u32 micbias_num;
+ u32 micbias_volt;
+ int which_i2s;
+ int irq;
+ int adc_grp0_using_linein;
+ int adc_zerocross;
+ /* 0: line out, 1: hp out, 11: lineout and hpout */
+ int dac_output;
+ int dac_path_state;
+
+ int ext_micbias;
+ int pm_state;
+
+ /* AGC L/R Off/on */
+ unsigned int agc_l[ADC_LR_GROUP_MAX];
+ unsigned int agc_r[ADC_LR_GROUP_MAX];
+
+ /* AGC L/R Approximate Sample Rate */
+ unsigned int agc_asr_l[ADC_LR_GROUP_MAX];
+ unsigned int agc_asr_r[ADC_LR_GROUP_MAX];
+
+ /* ADC MIC Mute/Work */
+ unsigned int mic_mute_l[ADC_LR_GROUP_MAX];
+ unsigned int mic_mute_r[ADC_LR_GROUP_MAX];
+
+ /* For the high pass filter */
+ unsigned int hpf_cutoff[ADC_LR_GROUP_MAX];
+
+ /* Only hpout do fade-in and fade-out */
+ unsigned int hpout_l_dgain;
+ unsigned int hpout_r_dgain;
+
+ bool adc_grps_endisable[ADC_LR_GROUP_MAX];
+ bool dac_endisable;
+ bool enable_all_adcs;
+ bool enable_micbias;
+ bool micbias1;
+ bool micbias2;
+ bool hp_jack_reversed;
+ bool hp_plugged;
+ bool loopback_dacs_enabled;
+ bool no_deep_low_power;
+ bool no_hp_det;
+ struct delayed_work hpdet_work;
+ struct delayed_work loopback_work;
+
+#if defined(CONFIG_DEBUG_FS)
+ struct dentry *dbg_codec;
+#endif
};
-static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_ch_gain_tlv,
+static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_grp_gain_tlv,
-1800, 150, 2850);
-static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_ch_max_gain_tlv,
+static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_grp_max_gain_tlv,
-1350, 600, 2850);
-static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_ch_min_gain_tlv,
+static const DECLARE_TLV_DB_SCALE(rk3308_codec_alc_agc_grp_min_gain_tlv,
-1800, 600, 2400);
-static const DECLARE_TLV_DB_SCALE(rk3308_codec_adc_mic_gain_tlv,
- 0, 600, 3000);
static const DECLARE_TLV_DB_SCALE(rk3308_codec_adc_alc_gain_tlv,
-1800, 150, 2850);
-static const DECLARE_TLV_DB_SCALE(rk3308_codec_dac_gain_tlv,
- 0, 150, 600);
+static const DECLARE_TLV_DB_SCALE(rk3308_codec_dac_lineout_gain_tlv,
+ -600, 150, 0);
static const DECLARE_TLV_DB_SCALE(rk3308_codec_dac_hpout_gain_tlv,
-3900, 150, 600);
static const DECLARE_TLV_DB_SCALE(rk3308_codec_dac_hpmix_gain_tlv,
-600, 600, 0);
+static const DECLARE_TLV_DB_RANGE(rk3308_codec_adc_mic_gain_tlv_a,
+ 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
+ 3, 3, TLV_DB_SCALE_ITEM(2000, 0, 0),
+);
+
+static const DECLARE_TLV_DB_RANGE(rk3308_codec_adc_mic_gain_tlv_b,
+ 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
+ 1, 1, TLV_DB_SCALE_ITEM(660, 0, 0),
+ 2, 2, TLV_DB_SCALE_ITEM(1300, 0, 0),
+ 3, 3, TLV_DB_SCALE_ITEM(2000, 0, 0),
+);
+
+static bool handle_loopback(struct rk3308_codec_priv *rk3308);
+
+static int check_micbias(int micbias);
+
+static int rk3308_codec_micbias_enable(struct rk3308_codec_priv *rk3308,
+ int micbias);
+static int rk3308_codec_micbias_disable(struct rk3308_codec_priv *rk3308);
+
+static int rk3308_codec_hpout_l_get_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_hpout_l_put_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_hpout_r_get_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_hpout_r_put_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_hpf_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_hpf_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_agc_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_agc_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_agc_asr_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_agc_asr_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_mic_mute_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_mic_mute_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_mic_gain_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_mic_gain_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_micbias_volts_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_micbias_volts_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_main_micbias_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+static int rk3308_codec_main_micbias_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol);
+
+static const char *offon_text[2] = {
+ [0] = "Off",
+ [1] = "On",
+};
+
+static const char *mute_text[2] = {
+ [0] = "Work",
+ [1] = "Mute",
+};
+
+/* ADC MICBIAS Volt */
+#define MICBIAS_VOLT_NUM 8
+
+#define MICBIAS_VREFx0_5 0
+#define MICBIAS_VREFx0_55 1
+#define MICBIAS_VREFx0_6 2
+#define MICBIAS_VREFx0_65 3
+#define MICBIAS_VREFx0_7 4
+#define MICBIAS_VREFx0_75 5
+#define MICBIAS_VREFx0_8 6
+#define MICBIAS_VREFx0_85 7
+
+static const char *micbias_volts_enum_array[MICBIAS_VOLT_NUM] = {
+ [MICBIAS_VREFx0_5] = "VREFx0_5",
+ [MICBIAS_VREFx0_55] = "VREFx0_55",
+ [MICBIAS_VREFx0_6] = "VREFx0_6",
+ [MICBIAS_VREFx0_65] = "VREFx0_65",
+ [MICBIAS_VREFx0_7] = "VREFx0_7",
+ [MICBIAS_VREFx0_75] = "VREFx0_75",
+ [MICBIAS_VREFx0_8] = "VREFx0_8",
+ [MICBIAS_VREFx0_85] = "VREFx0_85",
+};
+
+static const struct soc_enum rk3308_micbias_volts_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(micbias_volts_enum_array), micbias_volts_enum_array),
+};
+
+/* ADC MICBIAS1 and MICBIAS2 Main Switch */
+static const struct soc_enum rk3308_main_micbias_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(offon_text), offon_text),
+};
+
+static const struct soc_enum rk3308_hpf_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(1, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(2, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(3, 0, ARRAY_SIZE(offon_text), offon_text),
+};
+
+/* ALC AGC Switch */
+static const struct soc_enum rk3308_agc_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(1, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(1, 1, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(2, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(2, 1, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(3, 0, ARRAY_SIZE(offon_text), offon_text),
+ SOC_ENUM_SINGLE(3, 1, ARRAY_SIZE(offon_text), offon_text),
+};
+
+/* ADC MIC Mute/Work Switch */
+static const struct soc_enum rk3308_mic_mute_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(1, 0, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(1, 1, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(2, 0, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(2, 1, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(3, 0, ARRAY_SIZE(mute_text), mute_text),
+ SOC_ENUM_SINGLE(3, 1, ARRAY_SIZE(mute_text), mute_text),
+};
+
+/* ALC AGC Approximate Sample Rate */
+#define AGC_ASR_NUM 8
+
+#define AGC_ASR_96KHZ 0
+#define AGC_ASR_48KHZ 1
+#define AGC_ASR_44_1KHZ 2
+#define AGC_ASR_32KHZ 3
+#define AGC_ASR_24KHZ 4
+#define AGC_ASR_16KHZ 5
+#define AGC_ASR_12KHZ 6
+#define AGC_ASR_8KHZ 7
+
+static const char *agc_asr_text[AGC_ASR_NUM] = {
+ [AGC_ASR_96KHZ] = "96KHz",
+ [AGC_ASR_48KHZ] = "48KHz",
+ [AGC_ASR_44_1KHZ] = "44.1KHz",
+ [AGC_ASR_32KHZ] = "32KHz",
+ [AGC_ASR_24KHZ] = "24KHz",
+ [AGC_ASR_16KHZ] = "16KHz",
+ [AGC_ASR_12KHZ] = "12KHz",
+ [AGC_ASR_8KHZ] = "8KHz",
+};
+
+static const struct soc_enum rk3308_agc_asr_enum_array[] = {
+ SOC_ENUM_SINGLE(0, 0, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(0, 1, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(1, 0, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(1, 1, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(2, 0, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(2, 1, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(3, 0, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+ SOC_ENUM_SINGLE(3, 1, ARRAY_SIZE(agc_asr_text), agc_asr_text),
+};
+
+static const struct snd_kcontrol_new mic_gains_a[] = {
+ /* ADC MIC */
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 0 Left Volume",
+ RK3308_ADC_ANA_CON01(0),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 0 Right Volume",
+ RK3308_ADC_ANA_CON01(0),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 1 Left Volume",
+ RK3308_ADC_ANA_CON01(1),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 1 Right Volume",
+ RK3308_ADC_ANA_CON01(1),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 2 Left Volume",
+ RK3308_ADC_ANA_CON01(2),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 2 Right Volume",
+ RK3308_ADC_ANA_CON01(2),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 3 Left Volume",
+ RK3308_ADC_ANA_CON01(3),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 3 Right Volume",
+ RK3308_ADC_ANA_CON01(3),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_a),
+};
+
+static const struct snd_kcontrol_new mic_gains_b[] = {
+ /* ADC MIC */
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 0 Left Volume",
+ RK3308_ADC_ANA_CON01(0),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 0 Right Volume",
+ RK3308_ADC_ANA_CON01(0),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 1 Left Volume",
+ RK3308_ADC_ANA_CON01(1),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 1 Right Volume",
+ RK3308_ADC_ANA_CON01(1),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 2 Left Volume",
+ RK3308_ADC_ANA_CON01(2),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 2 Right Volume",
+ RK3308_ADC_ANA_CON01(2),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 3 Left Volume",
+ RK3308_ADC_ANA_CON01(3),
+ RK3308_ADC_CH1_MIC_GAIN_SFT,
+ RK3308_ADC_CH1_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+ SOC_SINGLE_EXT_TLV("ADC MIC Group 3 Right Volume",
+ RK3308_ADC_ANA_CON01(3),
+ RK3308_ADC_CH2_MIC_GAIN_SFT,
+ RK3308_ADC_CH2_MIC_GAIN_MAX,
+ 0,
+ rk3308_codec_mic_gain_get,
+ rk3308_codec_mic_gain_put,
+ rk3308_codec_adc_mic_gain_tlv_b),
+};
+
static const struct snd_kcontrol_new rk3308_codec_dapm_controls[] = {
- /* ALC AGC Channel*/
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 0 Volume",
+ /* ALC AGC Group */
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Left Volume",
RK3308_ALC_L_DIG_CON03(0),
+ RK3308_AGC_PGA_GAIN_SFT,
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Right Volume",
RK3308_ALC_R_DIG_CON03(0),
RK3308_AGC_PGA_GAIN_SFT,
- RK3308_AGC_PGA_GAIN_NDB_18,
- RK3308_AGC_PGA_GAIN_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 1 Volume",
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Left Volume",
RK3308_ALC_L_DIG_CON03(1),
+ RK3308_AGC_PGA_GAIN_SFT,
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Right Volume",
RK3308_ALC_R_DIG_CON03(1),
RK3308_AGC_PGA_GAIN_SFT,
- RK3308_AGC_PGA_GAIN_NDB_18,
- RK3308_AGC_PGA_GAIN_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 2 Volume",
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Left Volume",
RK3308_ALC_L_DIG_CON03(2),
+ RK3308_AGC_PGA_GAIN_SFT,
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Right Volume",
RK3308_ALC_R_DIG_CON03(2),
RK3308_AGC_PGA_GAIN_SFT,
- RK3308_AGC_PGA_GAIN_NDB_18,
- RK3308_AGC_PGA_GAIN_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 3 Volume",
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Left Volume",
RK3308_ALC_L_DIG_CON03(3),
+ RK3308_AGC_PGA_GAIN_SFT,
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Right Volume",
RK3308_ALC_R_DIG_CON03(3),
RK3308_AGC_PGA_GAIN_SFT,
- RK3308_AGC_PGA_GAIN_NDB_18,
- RK3308_AGC_PGA_GAIN_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_gain_tlv),
+ RK3308_AGC_PGA_GAIN_MIN,
+ RK3308_AGC_PGA_GAIN_MAX,
+ 0, rk3308_codec_alc_agc_grp_gain_tlv),
/* ALC AGC MAX */
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 0 Max Volume",
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Left Max Volume",
RK3308_ALC_L_DIG_CON09(0),
+ RK3308_AGC_MAX_GAIN_PGA_SFT,
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Right Max Volume",
RK3308_ALC_R_DIG_CON09(0),
RK3308_AGC_MAX_GAIN_PGA_SFT,
- RK3308_AGC_MAX_GAIN_PGA_NDB_13_5,
- RK3308_AGC_MAX_GAIN_PGA_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_max_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 1 Max Volume",
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Left Max Volume",
RK3308_ALC_L_DIG_CON09(1),
+ RK3308_AGC_MAX_GAIN_PGA_SFT,
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Right Max Volume",
RK3308_ALC_R_DIG_CON09(1),
RK3308_AGC_MAX_GAIN_PGA_SFT,
- RK3308_AGC_MAX_GAIN_PGA_NDB_13_5,
- RK3308_AGC_MAX_GAIN_PGA_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_max_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 2 Max Volume",
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Left Max Volume",
RK3308_ALC_L_DIG_CON09(2),
+ RK3308_AGC_MAX_GAIN_PGA_SFT,
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Right Max Volume",
RK3308_ALC_R_DIG_CON09(2),
RK3308_AGC_MAX_GAIN_PGA_SFT,
- RK3308_AGC_MAX_GAIN_PGA_NDB_13_5,
- RK3308_AGC_MAX_GAIN_PGA_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_max_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 3 Max Volume",
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Left Max Volume",
RK3308_ALC_L_DIG_CON09(3),
+ RK3308_AGC_MAX_GAIN_PGA_SFT,
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Right Max Volume",
RK3308_ALC_R_DIG_CON09(3),
RK3308_AGC_MAX_GAIN_PGA_SFT,
- RK3308_AGC_MAX_GAIN_PGA_NDB_13_5,
- RK3308_AGC_MAX_GAIN_PGA_PDB_28_5,
- 0, rk3308_codec_alc_agc_ch_max_gain_tlv),
+ RK3308_AGC_MAX_GAIN_PGA_MIN,
+ RK3308_AGC_MAX_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_max_gain_tlv),
/* ALC AGC MIN */
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 0 Min Volume",
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Left Min Volume",
RK3308_ALC_L_DIG_CON09(0),
+ RK3308_AGC_MIN_GAIN_PGA_SFT,
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 0 Right Min Volume",
RK3308_ALC_R_DIG_CON09(0),
RK3308_AGC_MIN_GAIN_PGA_SFT,
- RK3308_AGC_MIN_GAIN_PGA_NDB_18,
- RK3308_AGC_MIN_GAIN_PGA_PDB_24,
- 0, rk3308_codec_alc_agc_ch_min_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 1 Min Volume",
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Left Min Volume",
RK3308_ALC_L_DIG_CON09(1),
+ RK3308_AGC_MIN_GAIN_PGA_SFT,
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 1 Right Min Volume",
RK3308_ALC_R_DIG_CON09(1),
RK3308_AGC_MIN_GAIN_PGA_SFT,
- RK3308_AGC_MIN_GAIN_PGA_NDB_18,
- RK3308_AGC_MIN_GAIN_PGA_PDB_24,
- 0, rk3308_codec_alc_agc_ch_min_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 2 Min Volume",
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Left Min Volume",
RK3308_ALC_L_DIG_CON09(2),
+ RK3308_AGC_MIN_GAIN_PGA_SFT,
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 2 Right Min Volume",
RK3308_ALC_R_DIG_CON09(2),
RK3308_AGC_MIN_GAIN_PGA_SFT,
- RK3308_AGC_MIN_GAIN_PGA_NDB_18,
- RK3308_AGC_MIN_GAIN_PGA_PDB_24,
- 0, rk3308_codec_alc_agc_ch_min_gain_tlv),
- SOC_DOUBLE_R_RANGE_TLV("ALC AGC Channel 3 Min Volume",
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Left Min Volume",
RK3308_ALC_L_DIG_CON09(3),
+ RK3308_AGC_MIN_GAIN_PGA_SFT,
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+ SOC_SINGLE_RANGE_TLV("ALC AGC Group 3 Right Min Volume",
RK3308_ALC_R_DIG_CON09(3),
RK3308_AGC_MIN_GAIN_PGA_SFT,
- RK3308_AGC_MIN_GAIN_PGA_NDB_18,
- RK3308_AGC_MIN_GAIN_PGA_PDB_24,
- 0, rk3308_codec_alc_agc_ch_min_gain_tlv),
-
- /* ADC MIC */
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 0 Left Volume",
- RK3308_ADC_ANA_CON01(0),
- RK3308_ADC_CH1_MIC_GAIN_SFT,
- RK3308_ADC_CH1_MIC_GAIN_0DB,
- RK3308_ADC_CH1_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 0 Right Volume",
- RK3308_ADC_ANA_CON01(0),
- RK3308_ADC_CH2_MIC_GAIN_SFT,
- RK3308_ADC_CH2_MIC_GAIN_0DB,
- RK3308_ADC_CH2_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 1 Left Volume",
- RK3308_ADC_ANA_CON01(1),
- RK3308_ADC_CH1_MIC_GAIN_SFT,
- RK3308_ADC_CH1_MIC_GAIN_0DB,
- RK3308_ADC_CH1_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 1 Right Volume",
- RK3308_ADC_ANA_CON01(1),
- RK3308_ADC_CH2_MIC_GAIN_SFT,
- RK3308_ADC_CH2_MIC_GAIN_0DB,
- RK3308_ADC_CH2_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 2 Left Volume",
- RK3308_ADC_ANA_CON01(2),
- RK3308_ADC_CH1_MIC_GAIN_SFT,
- RK3308_ADC_CH1_MIC_GAIN_0DB,
- RK3308_ADC_CH1_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 2 Right Volume",
- RK3308_ADC_ANA_CON01(2),
- RK3308_ADC_CH2_MIC_GAIN_SFT,
- RK3308_ADC_CH2_MIC_GAIN_0DB,
- RK3308_ADC_CH2_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 3 Left Volume",
- RK3308_ADC_ANA_CON01(3),
- RK3308_ADC_CH1_MIC_GAIN_SFT,
- RK3308_ADC_CH1_MIC_GAIN_0DB,
- RK3308_ADC_CH1_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC MIC Channel 3 Right Volume",
- RK3308_ADC_ANA_CON01(3),
- RK3308_ADC_CH2_MIC_GAIN_SFT,
- RK3308_ADC_CH2_MIC_GAIN_0DB,
- RK3308_ADC_CH2_MIC_GAIN_30DB,
- 0, rk3308_codec_adc_mic_gain_tlv),
+ RK3308_AGC_MIN_GAIN_PGA_MIN,
+ RK3308_AGC_MIN_GAIN_PGA_MAX,
+ 0, rk3308_codec_alc_agc_grp_min_gain_tlv),
+
+ /* ALC AGC Switch */
+ SOC_ENUM_EXT("ALC AGC Group 0 Left Switch", rk3308_agc_enum_array[0],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 0 Right Switch", rk3308_agc_enum_array[1],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 1 Left Switch", rk3308_agc_enum_array[2],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 1 Right Switch", rk3308_agc_enum_array[3],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 2 Left Switch", rk3308_agc_enum_array[4],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 2 Right Switch", rk3308_agc_enum_array[5],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 3 Left Switch", rk3308_agc_enum_array[6],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+ SOC_ENUM_EXT("ALC AGC Group 3 Right Switch", rk3308_agc_enum_array[7],
+ rk3308_codec_agc_get, rk3308_codec_agc_put),
+
+ /* ALC AGC Approximate Sample Rate */
+ SOC_ENUM_EXT("AGC Group 0 Left Approximate Sample Rate", rk3308_agc_asr_enum_array[0],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 0 Right Approximate Sample Rate", rk3308_agc_asr_enum_array[1],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 1 Left Approximate Sample Rate", rk3308_agc_asr_enum_array[2],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 1 Right Approximate Sample Rate", rk3308_agc_asr_enum_array[3],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 2 Left Approximate Sample Rate", rk3308_agc_asr_enum_array[4],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 2 Right Approximate Sample Rate", rk3308_agc_asr_enum_array[5],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 3 Left Approximate Sample Rate", rk3308_agc_asr_enum_array[6],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+ SOC_ENUM_EXT("AGC Group 3 Right Approximate Sample Rate", rk3308_agc_asr_enum_array[7],
+ rk3308_codec_agc_asr_get, rk3308_codec_agc_asr_put),
+
+ /* ADC MICBIAS Voltage */
+ SOC_ENUM_EXT("ADC MICBIAS Voltage", rk3308_micbias_volts_enum_array[0],
+ rk3308_codec_micbias_volts_get, rk3308_codec_micbias_volts_put),
+
+ /* ADC Main MICBIAS Switch */
+ SOC_ENUM_EXT("ADC Main MICBIAS", rk3308_main_micbias_enum_array[0],
+ rk3308_codec_main_micbias_get, rk3308_codec_main_micbias_put),
+
+ /* ADC MICBIAS1 and MICBIAS2 Switch */
+ SOC_SINGLE("ADC MICBIAS1", RK3308_ADC_ANA_CON07(1),
+ RK3308_ADC_MIC_BIAS_BUF_SFT, 1, 0),
+ SOC_SINGLE("ADC MICBIAS2", RK3308_ADC_ANA_CON07(2),
+ RK3308_ADC_MIC_BIAS_BUF_SFT, 1, 0),
+
+ /* ADC MIC Mute/Work Switch */
+ SOC_ENUM_EXT("ADC MIC Group 0 Left Switch", rk3308_mic_mute_enum_array[0],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 0 Right Switch", rk3308_mic_mute_enum_array[1],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 1 Left Switch", rk3308_mic_mute_enum_array[2],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 1 Right Switch", rk3308_mic_mute_enum_array[3],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 2 Left Switch", rk3308_mic_mute_enum_array[4],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 2 Right Switch", rk3308_mic_mute_enum_array[5],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 3 Left Switch", rk3308_mic_mute_enum_array[6],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
+ SOC_ENUM_EXT("ADC MIC Group 3 Right Switch", rk3308_mic_mute_enum_array[7],
+ rk3308_codec_mic_mute_get, rk3308_codec_mic_mute_put),
/* ADC ALC */
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 0 Left Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 0 Left Volume",
RK3308_ADC_ANA_CON03(0),
RK3308_ADC_CH1_ALC_GAIN_SFT,
- RK3308_ADC_CH1_ALC_GAIN_NDB_18,
- RK3308_ADC_CH1_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH1_ALC_GAIN_MIN,
+ RK3308_ADC_CH1_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 0 Right Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 0 Right Volume",
RK3308_ADC_ANA_CON04(0),
RK3308_ADC_CH2_ALC_GAIN_SFT,
- RK3308_ADC_CH2_ALC_GAIN_NDB_18,
- RK3308_ADC_CH2_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH2_ALC_GAIN_MIN,
+ RK3308_ADC_CH2_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 1 Left Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 1 Left Volume",
RK3308_ADC_ANA_CON03(1),
RK3308_ADC_CH1_ALC_GAIN_SFT,
- RK3308_ADC_CH1_ALC_GAIN_NDB_18,
- RK3308_ADC_CH1_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH1_ALC_GAIN_MIN,
+ RK3308_ADC_CH1_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 1 Right Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 1 Right Volume",
RK3308_ADC_ANA_CON04(1),
RK3308_ADC_CH2_ALC_GAIN_SFT,
- RK3308_ADC_CH2_ALC_GAIN_NDB_18,
- RK3308_ADC_CH2_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH2_ALC_GAIN_MIN,
+ RK3308_ADC_CH2_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 2 Left Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 2 Left Volume",
RK3308_ADC_ANA_CON03(2),
RK3308_ADC_CH1_ALC_GAIN_SFT,
- RK3308_ADC_CH1_ALC_GAIN_NDB_18,
- RK3308_ADC_CH1_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH1_ALC_GAIN_MIN,
+ RK3308_ADC_CH1_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 2 Right Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 2 Right Volume",
RK3308_ADC_ANA_CON04(2),
RK3308_ADC_CH2_ALC_GAIN_SFT,
- RK3308_ADC_CH2_ALC_GAIN_NDB_18,
- RK3308_ADC_CH2_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH2_ALC_GAIN_MIN,
+ RK3308_ADC_CH2_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 3 Left Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 3 Left Volume",
RK3308_ADC_ANA_CON03(3),
RK3308_ADC_CH1_ALC_GAIN_SFT,
- RK3308_ADC_CH1_ALC_GAIN_NDB_18,
- RK3308_ADC_CH1_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH1_ALC_GAIN_MIN,
+ RK3308_ADC_CH1_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- SOC_SINGLE_RANGE_TLV("ADC ALC Channel 3 Right Volume",
+ SOC_SINGLE_RANGE_TLV("ADC ALC Group 3 Right Volume",
RK3308_ADC_ANA_CON04(3),
RK3308_ADC_CH2_ALC_GAIN_SFT,
- RK3308_ADC_CH2_ALC_GAIN_NDB_18,
- RK3308_ADC_CH2_ALC_GAIN_PDB_28_5,
+ RK3308_ADC_CH2_ALC_GAIN_MIN,
+ RK3308_ADC_CH2_ALC_GAIN_MAX,
0, rk3308_codec_adc_alc_gain_tlv),
- /* DAC */
- SOC_SINGLE_RANGE_TLV("DAC Left Volume",
- RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_GAIN_SFT,
- RK3308_DAC_L_GAIN_0DB,
- RK3308_DAC_L_GAIN_PDB_6,
- 0, rk3308_codec_dac_gain_tlv),
- SOC_SINGLE_RANGE_TLV("DAC Right Volume",
- RK3308_DAC_ANA_CON04,
- RK3308_DAC_R_GAIN_SFT,
- RK3308_DAC_R_GAIN_0DB,
- RK3308_DAC_R_GAIN_PDB_6,
- 0, rk3308_codec_dac_gain_tlv),
+ /* ADC High Pass Filter */
+ SOC_ENUM_EXT("ADC Group 0 HPF Cut-off", rk3308_hpf_enum_array[0],
+ rk3308_codec_hpf_get, rk3308_codec_hpf_put),
+ SOC_ENUM_EXT("ADC Group 1 HPF Cut-off", rk3308_hpf_enum_array[1],
+ rk3308_codec_hpf_get, rk3308_codec_hpf_put),
+ SOC_ENUM_EXT("ADC Group 2 HPF Cut-off", rk3308_hpf_enum_array[2],
+ rk3308_codec_hpf_get, rk3308_codec_hpf_put),
+ SOC_ENUM_EXT("ADC Group 3 HPF Cut-off", rk3308_hpf_enum_array[3],
+ rk3308_codec_hpf_get, rk3308_codec_hpf_put),
+
+ /* DAC LINEOUT */
+ SOC_SINGLE_TLV("DAC LINEOUT Left Volume",
+ RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_GAIN_SFT,
+ RK3308_DAC_L_LINEOUT_GAIN_MAX,
+ 0, rk3308_codec_dac_lineout_gain_tlv),
+ SOC_SINGLE_TLV("DAC LINEOUT Right Volume",
+ RK3308_DAC_ANA_CON04,
+ RK3308_DAC_R_LINEOUT_GAIN_SFT,
+ RK3308_DAC_R_LINEOUT_GAIN_MAX,
+ 0, rk3308_codec_dac_lineout_gain_tlv),
/* DAC HPOUT */
- SOC_SINGLE_RANGE_TLV("DAC HPOUT Left Volume",
- RK3308_DAC_ANA_CON05,
- RK3308_DAC_L_HPOUT_GAIN_SFT,
- RK3308_DAC_L_HPOUT_GAIN_NDB_39,
- RK3308_DAC_L_HPOUT_GAIN_PDB_6,
- 0, rk3308_codec_dac_hpout_gain_tlv),
- SOC_SINGLE_RANGE_TLV("DAC HPOUT Right Volume",
- RK3308_DAC_ANA_CON06,
- RK3308_DAC_R_HPOUT_GAIN_SFT,
- RK3308_DAC_R_HPOUT_GAIN_NDB_39,
- RK3308_DAC_R_HPOUT_GAIN_PDB_6,
- 0, rk3308_codec_dac_hpout_gain_tlv),
+ SOC_SINGLE_EXT_TLV("DAC HPOUT Left Volume",
+ RK3308_DAC_ANA_CON05,
+ RK3308_DAC_L_HPOUT_GAIN_SFT,
+ RK3308_DAC_L_HPOUT_GAIN_MAX,
+ 0,
+ rk3308_codec_hpout_l_get_tlv,
+ rk3308_codec_hpout_l_put_tlv,
+ rk3308_codec_dac_hpout_gain_tlv),
+ SOC_SINGLE_EXT_TLV("DAC HPOUT Right Volume",
+ RK3308_DAC_ANA_CON06,
+ RK3308_DAC_R_HPOUT_GAIN_SFT,
+ RK3308_DAC_R_HPOUT_GAIN_MAX,
+ 0,
+ rk3308_codec_hpout_r_get_tlv,
+ rk3308_codec_hpout_r_put_tlv,
+ rk3308_codec_dac_hpout_gain_tlv),
/* DAC HPMIX */
SOC_SINGLE_RANGE_TLV("DAC HPMIX Left Volume",
- RK3308_DAC_ANA_CON05,
+ RK3308_DAC_ANA_CON12,
RK3308_DAC_L_HPMIX_GAIN_SFT,
- RK3308_DAC_L_HPMIX_GAIN_NDB_6,
- RK3308_DAC_L_HPMIX_GAIN_0DB,
+ RK3308_DAC_L_HPMIX_GAIN_MIN,
+ RK3308_DAC_L_HPMIX_GAIN_MAX,
0, rk3308_codec_dac_hpmix_gain_tlv),
SOC_SINGLE_RANGE_TLV("DAC HPMIX Right Volume",
- RK3308_DAC_ANA_CON05,
+ RK3308_DAC_ANA_CON12,
RK3308_DAC_R_HPMIX_GAIN_SFT,
- RK3308_DAC_R_HPMIX_GAIN_NDB_6,
- RK3308_DAC_R_HPMIX_GAIN_0DB,
+ RK3308_DAC_R_HPMIX_GAIN_MIN,
+ RK3308_DAC_R_HPMIX_GAIN_MAX,
0, rk3308_codec_dac_hpmix_gain_tlv),
};
-static void rk3308_speaker_ctl(struct rk3308_codec_priv *rk3308, int on)
+static int rk3308_codec_agc_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- gpiod_direction_output(rk3308->spk_ctl_gpio, on);
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
+ return -EINVAL;
+ }
+
+ if (e->shift_l)
+ ucontrol->value.integer.value[0] = rk3308->agc_r[e->reg];
+ else
+ ucontrol->value.integer.value[0] = rk3308->agc_l[e->reg];
+
+ return 0;
}
-static int rk3308_codec_reset(struct snd_soc_codec *codec)
+static int rk3308_codec_agc_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value = ucontrol->value.integer.value[0];
+ int grp = e->reg;
- reset_control_assert(rk3308->reset);
- usleep_range(200, 300); /* estimated value */
- reset_control_deassert(rk3308->reset);
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
+ return -EINVAL;
+ }
- regmap_write(rk3308->regmap, RK3308_GLB_CON, 0x00);
- usleep_range(200, 300); /* estimated value */
- regmap_write(rk3308->regmap, RK3308_GLB_CON,
- RK3308_SYS_WORK |
- RK3308_DAC_DIG_WORK |
- RK3308_ADC_DIG_WORK);
+ if (value) {
+ /* ALC AGC On */
+ if (e->shift_l) {
+ /* ALC AGC Right On */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON09(grp),
+ RK3308_AGC_FUNC_SEL_MSK,
+ RK3308_AGC_FUNC_SEL_EN);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(grp),
+ RK3308_ADC_ALCR_CON_GAIN_PGAR_MSK,
+ RK3308_ADC_ALCR_CON_GAIN_PGAR_EN);
+
+ rk3308->agc_r[e->reg] = 1;
+ } else {
+ /* ALC AGC Left On */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON09(grp),
+ RK3308_AGC_FUNC_SEL_MSK,
+ RK3308_AGC_FUNC_SEL_EN);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(grp),
+ RK3308_ADC_ALCL_CON_GAIN_PGAL_MSK,
+ RK3308_ADC_ALCL_CON_GAIN_PGAL_EN);
+
+ rk3308->agc_l[e->reg] = 1;
+ }
+ } else {
+ /* ALC AGC Off */
+ if (e->shift_l) {
+ /* ALC AGC Right Off */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON09(grp),
+ RK3308_AGC_FUNC_SEL_MSK,
+ RK3308_AGC_FUNC_SEL_DIS);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(grp),
+ RK3308_ADC_ALCR_CON_GAIN_PGAR_MSK,
+ RK3308_ADC_ALCR_CON_GAIN_PGAR_DIS);
+
+ rk3308->agc_r[e->reg] = 0;
+ } else {
+ /* ALC AGC Left Off */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON09(grp),
+ RK3308_AGC_FUNC_SEL_MSK,
+ RK3308_AGC_FUNC_SEL_DIS);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(grp),
+ RK3308_ADC_ALCL_CON_GAIN_PGAL_MSK,
+ RK3308_ADC_ALCL_CON_GAIN_PGAL_DIS);
+
+ rk3308->agc_l[e->reg] = 0;
+ }
+ }
return 0;
}
-static int rk3308_set_bias_level(struct snd_soc_codec *codec,
- enum snd_soc_bias_level level)
+static int rk3308_codec_agc_asr_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- switch (level) {
- case SND_SOC_BIAS_ON:
- break;
-
- case SND_SOC_BIAS_PREPARE:
- break;
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value;
+ int grp = e->reg;
- case SND_SOC_BIAS_STANDBY:
- case SND_SOC_BIAS_OFF:
- break;
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
+ return -EINVAL;
}
- snd_soc_codec_force_bias_level(codec, level);
+ if (e->shift_l) {
+ regmap_read(rk3308->regmap, RK3308_ALC_R_DIG_CON04(grp), &value);
+ rk3308->agc_asr_r[e->reg] = value >> RK3308_AGC_APPROX_RATE_SFT;
+ ucontrol->value.integer.value[0] = rk3308->agc_asr_r[e->reg];
+ } else {
+ regmap_read(rk3308->regmap, RK3308_ALC_L_DIG_CON04(grp), &value);
+ rk3308->agc_asr_l[e->reg] = value >> RK3308_AGC_APPROX_RATE_SFT;
+ ucontrol->value.integer.value[0] = rk3308->agc_asr_l[e->reg];
+ }
return 0;
}
-static int rk3308_set_dai_fmt(struct snd_soc_dai *codec_dai,
- unsigned int fmt)
+static int rk3308_codec_agc_asr_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- struct snd_soc_codec *codec = codec_dai->codec;
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- unsigned int adc_aif1 = 0, adc_aif2 = 0, dac_aif1 = 0, dac_aif2 = 0;
- int ch = rk3308->adc_ch;
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value;
+ int grp = e->reg;
- switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
- case SND_SOC_DAIFMT_CBS_CFS:
- adc_aif2 |= RK3308_ADC_IO_MODE_SLAVE;
- adc_aif2 |= RK3308_ADC_MODE_SLAVE;
- dac_aif2 |= RK3308_DAC_IO_MODE_SLAVE;
- dac_aif2 |= RK3308_DAC_MODE_SLAVE;
- break;
- case SND_SOC_DAIFMT_CBM_CFM:
- adc_aif2 |= RK3308_ADC_IO_MODE_MASTER;
- adc_aif2 |= RK3308_ADC_MODE_MASTER;
- dac_aif2 |= RK3308_DAC_IO_MODE_MASTER;
- dac_aif2 |= RK3308_DAC_MODE_MASTER;
- break;
- default:
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
return -EINVAL;
}
- switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
- case SND_SOC_DAIFMT_DSP_A:
- adc_aif1 |= RK3308_ADC_I2S_MODE_PCM;
- dac_aif1 |= RK3308_DAC_I2S_MODE_PCM;
- break;
- case SND_SOC_DAIFMT_I2S:
- adc_aif1 |= RK3308_ADC_I2S_MODE_I2S;
- dac_aif1 |= RK3308_DAC_I2S_MODE_I2S;
- break;
- case SND_SOC_DAIFMT_RIGHT_J:
- adc_aif1 |= RK3308_ADC_I2S_MODE_RJ;
- dac_aif1 |= RK3308_DAC_I2S_MODE_RJ;
- break;
- case SND_SOC_DAIFMT_LEFT_J:
- adc_aif1 |= RK3308_ADC_I2S_MODE_RJ;
- dac_aif1 |= RK3308_DAC_I2S_MODE_LJ;
- break;
- default:
- return -EINVAL;
+ value = ucontrol->value.integer.value[0] << RK3308_AGC_APPROX_RATE_SFT;
+
+ if (e->shift_l) {
+ /* ALC AGC Right Approximate Sample Rate */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON04(grp),
+ RK3308_AGC_APPROX_RATE_MSK,
+ value);
+ rk3308->agc_asr_r[e->reg] = ucontrol->value.integer.value[0];
+ } else {
+ /* ALC AGC Left Approximate Sample Rate */
+ regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON04(grp),
+ RK3308_AGC_APPROX_RATE_MSK,
+ value);
+ rk3308->agc_asr_l[e->reg] = ucontrol->value.integer.value[0];
}
- switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
- case SND_SOC_DAIFMT_NB_NF:
- adc_aif1 |= RK3308_ADC_I2S_LRC_POL_NORMAL;
- adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_NORMAL;
- dac_aif1 |= RK3308_DAC_I2S_LRC_POL_NORMAL;
- dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_NORMAL;
- break;
- case SND_SOC_DAIFMT_IB_IF:
- adc_aif1 |= RK3308_ADC_I2S_LRC_POL_REVERSAL;
- adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_REVERSAL;
- dac_aif1 |= RK3308_DAC_I2S_LRC_POL_REVERSAL;
- dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_REVERSAL;
- break;
- case SND_SOC_DAIFMT_IB_NF:
- adc_aif1 |= RK3308_ADC_I2S_LRC_POL_NORMAL;
- adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_REVERSAL;
- dac_aif1 |= RK3308_DAC_I2S_LRC_POL_NORMAL;
- dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_REVERSAL;
- break;
- case SND_SOC_DAIFMT_NB_IF:
- adc_aif1 |= RK3308_ADC_I2S_LRC_POL_REVERSAL;
- adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_NORMAL;
- dac_aif1 |= RK3308_DAC_I2S_LRC_POL_REVERSAL;
- dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_NORMAL;
- break;
- default:
+ return 0;
+}
+
+static int rk3308_codec_mic_mute_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value;
+ int grp = e->reg;
+
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
return -EINVAL;
}
- regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON01(ch),
- RK3308_ADC_I2S_LRC_POL_MSK |
- RK3308_ADC_I2S_MODE_MSK,
- adc_aif1);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON02(ch),
- RK3308_ADC_IO_MODE_MSK |
- RK3308_ADC_MODE_MSK |
- RK3308_ADC_I2S_BIT_CLK_POL_MSK,
- adc_aif2);
-
- regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON01,
- RK3308_DAC_I2S_LRC_POL_MSK |
- RK3308_DAC_I2S_MODE_MSK,
- dac_aif1);
- regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON02,
- RK3308_DAC_IO_MODE_MSK |
- RK3308_DAC_MODE_MSK |
- RK3308_DAC_I2S_BIT_CLK_POL_MSK,
- dac_aif2);
+ if (e->shift_l) {
+ /* ADC MIC Right Mute/Work Infos */
+ regmap_read(rk3308->regmap, RK3308_ADC_DIG_CON03(grp), &value);
+ rk3308->mic_mute_r[e->reg] = (value & RK3308_ADC_R_CH_BIST_SINE) >>
+ RK3308_ADC_R_CH_BIST_SFT;
+ ucontrol->value.integer.value[0] = rk3308->mic_mute_r[e->reg];
+ } else {
+ /* ADC MIC Left Mute/Work Infos */
+ regmap_read(rk3308->regmap, RK3308_ADC_DIG_CON03(grp), &value);
+ rk3308->mic_mute_l[e->reg] = (value & RK3308_ADC_L_CH_BIST_SINE) >>
+ RK3308_ADC_L_CH_BIST_SFT;
+ ucontrol->value.integer.value[0] = rk3308->mic_mute_l[e->reg];
+ }
return 0;
}
-static int rk3308_hw_params(struct snd_pcm_substream *substream,
- struct snd_pcm_hw_params *params,
- struct snd_soc_dai *dai)
+static int rk3308_codec_mic_mute_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- struct snd_soc_codec *codec = dai->codec;
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- unsigned int adc_aif1 = 0, adc_aif2 = 0, dac_aif1 = 0, dac_aif2 = 0;
- int ch = rk3308->adc_ch;
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value;
+ int grp = e->reg;
- switch (params_format(params)) {
- case SNDRV_PCM_FORMAT_S16_LE:
- adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_16BITS;
- dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_16BITS;
- break;
- case SNDRV_PCM_FORMAT_S20_3LE:
- adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_20BITS;
- dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_20BITS;
- break;
- case SNDRV_PCM_FORMAT_S24_LE:
- adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_24BITS;
- dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_24BITS;
- break;
- case SNDRV_PCM_FORMAT_S32_LE:
- adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_32BITS;
- dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_32BITS;
- break;
- default:
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
return -EINVAL;
}
- switch (params_channels(params)) {
- case 1:
- adc_aif1 |= RK3308_ADC_I2S_MONO;
- break;
- case 2:
- adc_aif1 |= RK3308_ADC_I2S_STEREO;
- break;
- default:
- return -EINVAL;
+ if (e->shift_l) {
+ /* ADC MIC Right Mute/Work Configuration */
+ value = ucontrol->value.integer.value[0] << RK3308_ADC_R_CH_BIST_SFT;
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_SINE,
+ value);
+ rk3308->mic_mute_r[e->reg] = ucontrol->value.integer.value[0];
+ } else {
+ /* ADC MIC Left Mute/Work Configuration */
+ value = ucontrol->value.integer.value[0] << RK3308_ADC_L_CH_BIST_SFT;
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_SINE,
+ value);
+ rk3308->mic_mute_l[e->reg] = ucontrol->value.integer.value[0];
}
- adc_aif1 |= RK3308_ADC_I2S_LR_NORMAL;
- adc_aif2 |= RK3308_ADC_I2S_WORK;
- dac_aif1 |= RK3308_DAC_I2S_LR_NORMAL;
- dac_aif2 |= RK3308_DAC_I2S_WORK;
+ return 0;
+}
- regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON01(ch),
- RK3308_ADC_I2S_VALID_LEN_MSK |
- RK3308_ADC_I2S_LR_MSK |
- RK3308_ADC_I2S_TYPE_MSK,
- adc_aif1);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON02(ch),
- RK3308_ADC_I2S_MSK,
- adc_aif2);
+static int rk3308_codec_micbias_volts_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON01,
- RK3308_DAC_I2S_VALID_LEN_MSK |
- RK3308_DAC_I2S_LR_MSK,
- dac_aif1);
- regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON02,
- RK3308_DAC_I2S_MSK,
- dac_aif2);
+ ucontrol->value.integer.value[0] = rk3308->micbias_volt;
return 0;
}
-static int rk3308_digital_mute(struct snd_soc_dai *dai, int mute)
+static int rk3308_codec_micbias_volts_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int volt = ucontrol->value.integer.value[0];
+ int ret;
+
+ ret = check_micbias(volt);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev, "The invalid micbias volt: %d\n",
+ volt);
+ return ret;
+ }
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(0),
+ RK3308_ADC_LEVEL_RANGE_MICBIAS_MSK,
+ volt);
+
+ rk3308->micbias_volt = volt;
+
return 0;
}
-static int rk3308_codec_dac_enable(struct rk3308_codec_priv *rk3308)
+static int rk3308_codec_main_micbias_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- /* Step 01 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
- RK3308_DAC_CURRENT_MSK,
- RK3308_DAC_CURRENT_EN);
-
- /* Step 02 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_BUF_REF_L_MSK |
- RK3308_DAC_BUF_REF_R_MSK,
- RK3308_DAC_BUF_REF_L_EN |
- RK3308_DAC_BUF_REF_R_EN);
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- /* Step 03 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_POP_SOUND_L_MSK |
- RK3308_DAC_POP_SOUND_R_MSK,
- RK3308_DAC_POP_SOUND_L_WORK |
- RK3308_DAC_POP_SOUND_R_WORK);
+ ucontrol->value.integer.value[0] = rk3308->enable_micbias;
- /* Step 04 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_EN | RK3308_DAC_R_HPMIX_EN,
- RK3308_DAC_L_HPMIX_EN | RK3308_DAC_R_HPMIX_EN);
+ return 0;
+}
- /* Step 05 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_WORK | RK3308_DAC_R_HPMIX_WORK,
- RK3308_DAC_L_HPMIX_WORK | RK3308_DAC_R_HPMIX_WORK);
+static int rk3308_codec_main_micbias_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int on = ucontrol->value.integer.value[0];
+
+ if (on) {
+ if (!rk3308->enable_micbias)
+ rk3308_codec_micbias_enable(rk3308, rk3308->micbias_volt);
+ } else {
+ if (rk3308->enable_micbias)
+ rk3308_codec_micbias_disable(rk3308);
+ }
- /* Step 06 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_LINEOUT_EN | RK3308_DAC_R_LINEOUT_EN,
- RK3308_DAC_L_LINEOUT_EN | RK3308_DAC_R_LINEOUT_EN);
+ return 0;
+}
- /* Step 07 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_EN | RK3308_DAC_R_HPOUT_EN,
- RK3308_DAC_L_HPOUT_EN | RK3308_DAC_R_HPOUT_EN);
+static int rk3308_codec_mic_gain_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ return snd_soc_get_volsw_range(kcontrol, ucontrol);
+}
- /* Step 08 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_WORK | RK3308_DAC_R_HPOUT_WORK,
- RK3308_DAC_L_HPOUT_WORK | RK3308_DAC_R_HPOUT_WORK);
+static int rk3308_codec_mic_gain_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int gain = ucontrol->value.integer.value[0];
- /* Step 09 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_REF_EN | RK3308_DAC_R_REF_EN,
- RK3308_DAC_L_REF_EN | RK3308_DAC_R_REF_EN);
+ if (gain > RK3308_ADC_CH1_MIC_GAIN_MAX) {
+ dev_err(rk3308->plat_dev, "%s: invalid mic gain: %d\n",
+ __func__, gain);
+ return -EINVAL;
+ }
- /* Step 10 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_CLK_EN | RK3308_DAC_R_CLK_EN,
- RK3308_DAC_L_CLK_EN | RK3308_DAC_R_CLK_EN);
+ if (rk3308->codec_ver == ACODEC_VERSION_A) {
+ /*
+ * From the TRM, there are only suupport 0dB(gain==0) and
+ * 20dB(gain==3) on the codec version A.
+ */
+ if (!(gain == 0 || gain == RK3308_ADC_CH1_MIC_GAIN_MAX)) {
+ dev_err(rk3308->plat_dev,
+ "version A doesn't supported: %d, expect: 0,%d\n",
+ gain, RK3308_ADC_CH1_MIC_GAIN_MAX);
+ return 0;
+ }
+ }
- /* Step 11 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_DAC_EN | RK3308_DAC_R_DAC_EN,
- RK3308_DAC_L_DAC_EN | RK3308_DAC_R_DAC_EN);
+ return snd_soc_put_volsw_range(kcontrol, ucontrol);
+}
- /* Step 12 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_DAC_WORK | RK3308_DAC_R_DAC_WORK,
- RK3308_DAC_L_DAC_WORK | RK3308_DAC_R_DAC_WORK);
+static int rk3308_codec_hpf_get(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value;
- /* Step 13 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
- RK3308_DAC_L_HPMIX_SEL_MSK |
- RK3308_DAC_R_HPMIX_SEL_MSK,
- RK3308_DAC_L_HPMIX_I2S |
- RK3308_DAC_R_HPMIX_I2S);
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
+ return -EINVAL;
+ }
- /* Step 14 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_UNMUTE |
- RK3308_DAC_R_HPMIX_UNMUTE,
- RK3308_DAC_L_HPMIX_UNMUTE |
- RK3308_DAC_R_HPMIX_UNMUTE);
+ regmap_read(rk3308->regmap, RK3308_ADC_DIG_CON04(e->reg), &value);
+ if (value & RK3308_ADC_HPF_PATH_MSK)
+ rk3308->hpf_cutoff[e->reg] = 0;
+ else
+ rk3308->hpf_cutoff[e->reg] = 1;
- /* Step 15 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
- RK3308_DAC_L_HPMIX_GAIN_MSK |
- RK3308_DAC_R_HPMIX_GAIN_MSK,
- RK3308_DAC_L_HPMIX_GAIN_0DB |
- RK3308_DAC_R_HPMIX_GAIN_0DB);
+ ucontrol->value.integer.value[0] = rk3308->hpf_cutoff[e->reg];
- /* Step 16 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_UNMUTE |
- RK3308_DAC_R_HPOUT_UNMUTE,
- RK3308_DAC_L_HPOUT_UNMUTE |
- RK3308_DAC_R_HPOUT_UNMUTE);
+ return 0;
+}
- /* Step 17 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_LINEOUT_UNMUTE |
- RK3308_DAC_R_LINEOUT_UNMUTE,
- RK3308_DAC_L_LINEOUT_UNMUTE |
- RK3308_DAC_R_LINEOUT_UNMUTE);
+static int rk3308_codec_hpf_put(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
+ unsigned int value = ucontrol->value.integer.value[0];
- /* Step 18 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON05,
- RK3308_DAC_L_HPOUT_GAIN_MSK,
- RK3308_DAC_L_HPOUT_GAIN_0DB);
+ if (e->reg < 0 || e->reg > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "%s: Invalid ADC grp: %d\n", __func__, e->reg);
+ return -EINVAL;
+ }
- /* Step 18 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON06,
- RK3308_DAC_R_HPOUT_GAIN_MSK,
- RK3308_DAC_R_HPOUT_GAIN_0DB);
+ if (value) {
+ /* Enable high pass filter for ADCs */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON04(e->reg),
+ RK3308_ADC_HPF_PATH_MSK,
+ RK3308_ADC_HPF_PATH_EN);
+ } else {
+ /* Disable high pass filter for ADCs. */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON04(e->reg),
+ RK3308_ADC_HPF_PATH_MSK,
+ RK3308_ADC_HPF_PATH_DIS);
+ }
- /* Step 19 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_GAIN_MSK | RK3308_DAC_R_GAIN_MSK,
- RK3308_DAC_L_GAIN_0DB | RK3308_DAC_R_GAIN_0DB);
+ rk3308->hpf_cutoff[e->reg] = value;
return 0;
}
-static int rk3308_codec_dac_disable(struct rk3308_codec_priv *rk3308)
+static int rk3308_codec_hpout_l_get_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
{
- /* Step 01 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_GAIN_MSK | RK3308_DAC_R_GAIN_MSK,
- RK3308_DAC_L_GAIN_0DB | RK3308_DAC_R_GAIN_0DB);
-
- /*
- * Step 02
- *
- * Note1. In the step2, adjusting the register step by step to the
- * appropriate value and taking 20ms as time step
- */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON05,
- RK3308_DAC_L_HPOUT_GAIN_MSK,
- RK3308_DAC_L_HPOUT_GAIN_NDB_39);
-
- /* Step 02 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON06,
- RK3308_DAC_R_HPOUT_GAIN_MSK,
- RK3308_DAC_R_HPOUT_GAIN_NDB_39);
+ return snd_soc_get_volsw_range(kcontrol, ucontrol);
+}
- /* Step 03 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_UNMUTE |
- RK3308_DAC_R_HPMIX_UNMUTE,
- RK3308_DAC_L_HPMIX_MUTE |
- RK3308_DAC_R_HPMIX_MUTE);
+static int rk3308_codec_hpout_l_put_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int dgain = ucontrol->value.integer.value[0];
- /* Step 04 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
- RK3308_DAC_L_HPMIX_SEL_MSK |
- RK3308_DAC_R_HPMIX_SEL_MSK,
- RK3308_DAC_L_HPMIX_NONE |
- RK3308_DAC_R_HPMIX_NONE);
+ if (dgain > RK3308_DAC_L_HPOUT_GAIN_MAX) {
+ dev_err(rk3308->plat_dev, "%s: invalid l_dgain: %d\n",
+ __func__, dgain);
+ return -EINVAL;
+ }
- /* Step 05 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_UNMUTE |
- RK3308_DAC_R_HPOUT_UNMUTE,
- RK3308_DAC_L_HPOUT_MUTE |
- RK3308_DAC_R_HPOUT_MUTE);
+ rk3308->hpout_l_dgain = dgain;
- /* Step 06 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_DAC_WORK | RK3308_DAC_R_DAC_WORK,
- RK3308_DAC_L_DAC_INIT | RK3308_DAC_R_DAC_INIT);
+ return snd_soc_put_volsw_range(kcontrol, ucontrol);
+}
- /* Step 07 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_EN | RK3308_DAC_R_HPOUT_EN,
- RK3308_DAC_L_HPOUT_DIS | RK3308_DAC_R_HPOUT_DIS);
+static int rk3308_codec_hpout_r_get_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ return snd_soc_get_volsw_range(kcontrol, ucontrol);
+}
- /* Step 08 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_LINEOUT_UNMUTE |
- RK3308_DAC_R_LINEOUT_UNMUTE,
- RK3308_DAC_L_LINEOUT_MUTE |
- RK3308_DAC_R_LINEOUT_MUTE);
+static int rk3308_codec_hpout_r_put_tlv(struct snd_kcontrol *kcontrol,
+ struct snd_ctl_elem_value *ucontrol)
+{
+ struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int dgain = ucontrol->value.integer.value[0];
- /* Step 09 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
- RK3308_DAC_L_LINEOUT_EN | RK3308_DAC_R_LINEOUT_EN,
- RK3308_DAC_L_LINEOUT_DIS | RK3308_DAC_R_LINEOUT_DIS);
+ if (dgain > RK3308_DAC_R_HPOUT_GAIN_MAX) {
+ dev_err(rk3308->plat_dev, "%s: invalid r_dgain: %d\n",
+ __func__, dgain);
+ return -EINVAL;
+ }
- /* Step 10 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_EN | RK3308_DAC_R_HPMIX_EN,
- RK3308_DAC_L_HPMIX_DIS | RK3308_DAC_R_HPMIX_DIS);
+ rk3308->hpout_r_dgain = dgain;
- /* Step 11 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_DAC_EN | RK3308_DAC_R_DAC_EN,
- RK3308_DAC_L_DAC_DIS | RK3308_DAC_R_DAC_DIS);
+ return snd_soc_put_volsw_range(kcontrol, ucontrol);
+}
- /* Step 12 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_CLK_EN | RK3308_DAC_R_CLK_EN,
- RK3308_DAC_L_CLK_DIS | RK3308_DAC_R_CLK_DIS);
+static u32 to_mapped_grp(struct rk3308_codec_priv *rk3308, int idx)
+{
+ return rk3308->i2s_sdis[idx];
+}
- /* Step 13 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
- RK3308_DAC_L_REF_EN | RK3308_DAC_R_REF_EN,
- RK3308_DAC_L_REF_DIS | RK3308_DAC_R_REF_DIS);
+static bool adc_for_each_grp(struct rk3308_codec_priv *rk3308,
+ int type, int idx, u32 *grp)
+{
+ if (type == ADC_TYPE_NORMAL) {
+ u32 mapped_grp = to_mapped_grp(rk3308, idx);
+ int max_grps;
+
+ if (rk3308->enable_all_adcs)
+ max_grps = ADC_LR_GROUP_MAX;
+ else
+ max_grps = rk3308->used_adc_grps;
+
+ if (idx >= max_grps)
+ return false;
+
+ if ((!rk3308->loopback_dacs_enabled) &&
+ handle_loopback(rk3308) &&
+ rk3308->loopback_grp == mapped_grp) {
+ /*
+ * Ths loopback DACs are closed, and specify the
+ * loopback ADCs.
+ */
+ *grp = ADC_GRP_SKIP_MAGIC;
+ } else if (rk3308->en_always_grps_num &&
+ rk3308->skip_grps[mapped_grp]) {
+ /* To set the skip flag if the ADC GRP is enabled. */
+ *grp = ADC_GRP_SKIP_MAGIC;
+ } else {
+ *grp = mapped_grp;
+ }
- /* Step 14 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_POP_SOUND_L_MSK |
- RK3308_DAC_POP_SOUND_R_MSK,
- RK3308_DAC_POP_SOUND_L_INIT |
- RK3308_DAC_POP_SOUND_R_INIT);
+ dev_dbg(rk3308->plat_dev,
+ "ADC_TYPE_NORMAL, idx: %d, mapped_grp: %d, get grp: %d,\n",
+ idx, mapped_grp, *grp);
+ } else if (type == ADC_TYPE_ALL) {
+ if (idx >= ADC_LR_GROUP_MAX)
+ return false;
+
+ *grp = idx;
+ dev_dbg(rk3308->plat_dev,
+ "ADC_TYPE_ALL, idx: %d, get grp: %d\n",
+ idx, *grp);
+ } else if (type == ADC_TYPE_DBG) {
+ if (idx >= ADC_LR_GROUP_MAX)
+ return false;
+
+ if (idx == (int)rk3308->cur_dbg_grp)
+ *grp = idx;
+ else
+ *grp = ADC_GRP_SKIP_MAGIC;
+
+ dev_dbg(rk3308->plat_dev,
+ "ADC_TYPE_DBG, idx: %d, get grp: %d\n",
+ idx, *grp);
+ } else {
+ if (idx >= 1)
+ return false;
+
+ *grp = rk3308->loopback_grp;
+ dev_dbg(rk3308->plat_dev,
+ "ADC_TYPE_LOOPBACK, idx: %d, get grp: %d\n",
+ idx, *grp);
+ }
- /* Step 15 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_BUF_REF_L_EN | RK3308_DAC_BUF_REF_R_EN,
- RK3308_DAC_BUF_REF_L_DIS | RK3308_DAC_BUF_REF_R_DIS);
+ return true;
+}
- /* Step 16 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
- RK3308_DAC_CURRENT_EN,
- RK3308_DAC_CURRENT_DIS);
+static int rk3308_codec_get_dac_path_state(struct rk3308_codec_priv *rk3308)
+{
+ return rk3308->dac_path_state;
+}
- /* Step 17 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
- RK3308_DAC_L_HPOUT_WORK | RK3308_DAC_R_HPOUT_WORK,
- RK3308_DAC_L_HPOUT_INIT | RK3308_DAC_R_HPOUT_INIT);
+static void rk3308_codec_set_dac_path_state(struct rk3308_codec_priv *rk3308,
+ int state)
+{
+ rk3308->dac_path_state = state;
+}
- /* Step 18 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
- RK3308_DAC_L_HPMIX_WORK | RK3308_DAC_R_HPMIX_WORK,
- RK3308_DAC_L_HPMIX_INIT | RK3308_DAC_R_HPMIX_INIT);
+static void rk3308_headphone_ctl(struct rk3308_codec_priv *rk3308, int on)
+{
+ if (rk3308->hp_ctl_gpio)
+ gpiod_direction_output(rk3308->hp_ctl_gpio, on);
+}
- /* Step 19 */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
- RK3308_DAC_L_HPMIX_GAIN_MSK |
- RK3308_DAC_R_HPMIX_GAIN_MSK,
- RK3308_DAC_L_HPMIX_GAIN_NDB_6 |
- RK3308_DAC_R_HPMIX_GAIN_NDB_6);
+static void rk3308_speaker_ctl(struct rk3308_codec_priv *rk3308, int on)
+{
+ if (on) {
+ if (rk3308->pa_drv_gpio) {
+ gpiod_direction_output(rk3308->pa_drv_gpio, on);
+ msleep(rk3308->delay_pa_drv_ms);
+ }
- /*
- * Note2. If the ACODEC_DAC_ANA_CON12[7] or ACODEC_DAC_ANA_CON12[3]
- * is set to 0x1, add the steps from the section Disable DAC
- * Configuration Standard Usage Flow after complete the step 19
- */
+ if (rk3308->spk_ctl_gpio)
+ gpiod_direction_output(rk3308->spk_ctl_gpio, on);
+ } else {
+ if (rk3308->spk_ctl_gpio)
+ gpiod_direction_output(rk3308->spk_ctl_gpio, on);
- return 0;
+ if (rk3308->pa_drv_gpio) {
+ msleep(rk3308->delay_pa_drv_ms);
+ gpiod_direction_output(rk3308->pa_drv_gpio, on);
+ }
+ }
}
-static int rk3308_codec_power_on(struct snd_soc_codec *codec)
+static int rk3308_codec_reset(struct snd_soc_codec *codec)
{
struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- /* 1. Supply the power of digital part and reset the Audio Codec */
- /* Do nothing */
+ reset_control_assert(rk3308->reset);
+ usleep_range(2000, 2500); /* estimated value */
+ reset_control_deassert(rk3308->reset);
- /*
- * 2. Configure ACODEC_DAC_ANA_CON1[1:0] and ACODEC_DAC_ANA_CON1[5:4]
- * to 0x1, to setup dc voltage of the DAC channel output
- */
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_POP_SOUND_L_MSK, RK3308_DAC_POP_SOUND_L_INIT);
- regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
- RK3308_DAC_POP_SOUND_R_MSK, RK3308_DAC_POP_SOUND_R_INIT);
+ regmap_write(rk3308->regmap, RK3308_GLB_CON, 0x00);
+ usleep_range(200, 300); /* estimated value */
+ regmap_write(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_SYS_WORK |
+ RK3308_DAC_DIG_WORK |
+ RK3308_ADC_DIG_WORK);
- /*
- * 3. Configure the register ACODEC_ADC_ANA_CON10[6:0] to 0x1
- *
- * Note: Only the reg (ADC_ANA_CON10+0x0)[6:0] represent the control
- * signal to select current to pre-charge/dis_charge
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_CURRENT_CHARGE_MSK, RK3308_ADC_SEL_I_64(1));
+ return 0;
+}
- /* 4. Supply the power of the analog part(AVDD,AVDDRV) */
+static int rk3308_codec_adc_dig_reset(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_DIG_WORK,
+ RK3308_ADC_DIG_RESET);
+ udelay(50);
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_DIG_WORK,
+ RK3308_ADC_DIG_WORK);
- /*
- * 5. Configure the register ACODEC_ADC_ANA_CON10[7] to 0x1 to setup
- * reference voltage
- *
- * Note: Only the reg (ADC_ANA_CON10+0x0)[7] represent the enable
- * signal of reference voltage module
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_REF_EN, RK3308_ADC_REF_EN);
+ return 0;
+}
- /*
- * 6. Change the register ACODEC_ADC_ANA_CON10[6:0] from the 0x1 to
- * 0x7f step by step or configure the ACODEC_ADC_ANA_CON10[6:0] to
- * 0x7f directly. The suggestion slot time of the step is 20ms.
- */
- mdelay(20);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_CURRENT_CHARGE_MSK,
- RK3308_ADC_DONT_SEL_ALL);
+static int rk3308_codec_dac_dig_reset(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_DAC_DIG_WORK,
+ RK3308_DAC_DIG_RESET);
+ udelay(50);
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_DAC_DIG_WORK,
+ RK3308_DAC_DIG_WORK);
- /* 7. Wait until the voltage of VCM keeps stable at the AVDD/2 */
- usleep_range(200, 300); /* estimated value */
+ return 0;
+}
- /*
- * 8. Configure the register ACODEC_ADC_ANA_CON10[6:0] to the
- * appropriate value(expect 0x0) for reducing power.
- */
+static int rk3308_set_bias_level(struct snd_soc_codec *codec,
+ enum snd_soc_bias_level level)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- /* TODO: choose an appropriate charge value */
+ switch (level) {
+ case SND_SOC_BIAS_ON:
+ break;
+ case SND_SOC_BIAS_PREPARE:
+ break;
+ case SND_SOC_BIAS_STANDBY:
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
+ break;
+ case SND_SOC_BIAS_OFF:
+ break;
+ }
return 0;
}
-static int rk3308_codec_power_off(struct snd_soc_codec *codec)
+static int rk3308_set_dai_fmt(struct snd_soc_dai *codec_dai,
+ unsigned int fmt)
{
+ struct snd_soc_codec *codec = codec_dai->codec;
struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ unsigned int adc_aif1 = 0, adc_aif2 = 0, dac_aif1 = 0, dac_aif2 = 0;
+ int idx, grp, is_master;
+ int type = ADC_TYPE_ALL;
+
+ switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
+ case SND_SOC_DAIFMT_CBS_CFS:
+ adc_aif2 |= RK3308_ADC_IO_MODE_SLAVE;
+ adc_aif2 |= RK3308_ADC_MODE_SLAVE;
+ dac_aif2 |= RK3308_DAC_IO_MODE_SLAVE;
+ dac_aif2 |= RK3308_DAC_MODE_SLAVE;
+ is_master = 0;
+ break;
+ case SND_SOC_DAIFMT_CBM_CFM:
+ adc_aif2 |= RK3308_ADC_IO_MODE_MASTER;
+ adc_aif2 |= RK3308_ADC_MODE_MASTER;
+ dac_aif2 |= RK3308_DAC_IO_MODE_MASTER;
+ dac_aif2 |= RK3308_DAC_MODE_MASTER;
+ is_master = 1;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
+ case SND_SOC_DAIFMT_DSP_A:
+ adc_aif1 |= RK3308_ADC_I2S_MODE_PCM;
+ dac_aif1 |= RK3308_DAC_I2S_MODE_PCM;
+ break;
+ case SND_SOC_DAIFMT_I2S:
+ adc_aif1 |= RK3308_ADC_I2S_MODE_I2S;
+ dac_aif1 |= RK3308_DAC_I2S_MODE_I2S;
+ break;
+ case SND_SOC_DAIFMT_RIGHT_J:
+ adc_aif1 |= RK3308_ADC_I2S_MODE_RJ;
+ dac_aif1 |= RK3308_DAC_I2S_MODE_RJ;
+ break;
+ case SND_SOC_DAIFMT_LEFT_J:
+ adc_aif1 |= RK3308_ADC_I2S_MODE_LJ;
+ dac_aif1 |= RK3308_DAC_I2S_MODE_LJ;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
+ case SND_SOC_DAIFMT_NB_NF:
+ adc_aif1 |= RK3308_ADC_I2S_LRC_POL_NORMAL;
+ adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_NORMAL;
+ dac_aif1 |= RK3308_DAC_I2S_LRC_POL_NORMAL;
+ dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_NORMAL;
+ break;
+ case SND_SOC_DAIFMT_IB_IF:
+ adc_aif1 |= RK3308_ADC_I2S_LRC_POL_REVERSAL;
+ adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_REVERSAL;
+ dac_aif1 |= RK3308_DAC_I2S_LRC_POL_REVERSAL;
+ dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_REVERSAL;
+ break;
+ case SND_SOC_DAIFMT_IB_NF:
+ adc_aif1 |= RK3308_ADC_I2S_LRC_POL_NORMAL;
+ adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_REVERSAL;
+ dac_aif1 |= RK3308_DAC_I2S_LRC_POL_NORMAL;
+ dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_REVERSAL;
+ break;
+ case SND_SOC_DAIFMT_NB_IF:
+ adc_aif1 |= RK3308_ADC_I2S_LRC_POL_REVERSAL;
+ adc_aif2 |= RK3308_ADC_I2S_BIT_CLK_POL_NORMAL;
+ dac_aif1 |= RK3308_DAC_I2S_LRC_POL_REVERSAL;
+ dac_aif2 |= RK3308_DAC_I2S_BIT_CLK_POL_NORMAL;
+ break;
+ default:
+ return -EINVAL;
+ }
/*
- * 1. Keep the power on and disable the DAC and ADC path according to
- * the section power on configuration standard usage flow.
+ * Hold ADC Digital registers start at master mode
+ *
+ * There are 8 ADCs and use the same SCLK and LRCK internal for master
+ * mode, We need to make sure that they are in effect at the same time,
+ * otherwise they will cause the abnormal clocks.
*/
+ if (is_master)
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_DIG_WORK,
+ RK3308_ADC_DIG_RESET);
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON01(grp),
+ RK3308_ADC_I2S_LRC_POL_MSK |
+ RK3308_ADC_I2S_MODE_MSK,
+ adc_aif1);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON02(grp),
+ RK3308_ADC_IO_MODE_MSK |
+ RK3308_ADC_MODE_MSK |
+ RK3308_ADC_I2S_BIT_CLK_POL_MSK,
+ adc_aif2);
+ }
- /* 2. Configure the register ACODEC_ADC_ANA_CON10[6:0] to 0x1 */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_CURRENT_CHARGE_MSK, RK3308_ADC_SEL_I_64(1));
+ /* Hold ADC Digital registers end at master mode */
+ if (is_master)
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_DIG_WORK,
+ RK3308_ADC_DIG_WORK);
- /* 3. Configure the register ACODEC_ADC_ANA_CON10[7] to 0x0 */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_REF_EN, RK3308_ADC_REF_DIS);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON01,
+ RK3308_DAC_I2S_LRC_POL_MSK |
+ RK3308_DAC_I2S_MODE_MSK,
+ dac_aif1);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON02,
+ RK3308_DAC_IO_MODE_MSK |
+ RK3308_DAC_MODE_MSK |
+ RK3308_DAC_I2S_BIT_CLK_POL_MSK,
+ dac_aif2);
+
+ return 0;
+}
+
+static int rk3308_codec_dac_dig_config(struct rk3308_codec_priv *rk3308,
+ struct snd_pcm_hw_params *params)
+{
+ unsigned int dac_aif1 = 0, dac_aif2 = 0;
+
+ /* Clear the status of DAC DIG Digital reigisters */
+ rk3308_codec_dac_dig_reset(rk3308);
+
+ switch (params_format(params)) {
+ case SNDRV_PCM_FORMAT_S16_LE:
+ dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_16BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S20_3LE:
+ dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_20BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S24_LE:
+ dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_24BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S32_LE:
+ dac_aif1 |= RK3308_DAC_I2S_VALID_LEN_32BITS;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ dac_aif1 |= RK3308_DAC_I2S_LR_NORMAL;
+ dac_aif2 |= RK3308_DAC_I2S_WORK;
+
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON01,
+ RK3308_DAC_I2S_VALID_LEN_MSK |
+ RK3308_DAC_I2S_LR_MSK,
+ dac_aif1);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_DIG_CON02,
+ RK3308_DAC_I2S_MSK,
+ dac_aif2);
+
+ return 0;
+}
+
+static int rk3308_codec_adc_dig_config(struct rk3308_codec_priv *rk3308,
+ struct snd_pcm_hw_params *params)
+{
+ unsigned int adc_aif1 = 0, adc_aif2 = 0;
+ int type = ADC_TYPE_NORMAL;
+ int idx, grp;
+
+ /* Clear the status of ADC DIG Digital reigisters */
+ rk3308_codec_adc_dig_reset(rk3308);
+
+ switch (params_format(params)) {
+ case SNDRV_PCM_FORMAT_S16_LE:
+ adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_16BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S20_3LE:
+ adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_20BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S24_LE:
+ adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_24BITS;
+ break;
+ case SNDRV_PCM_FORMAT_S32_LE:
+ adc_aif1 |= RK3308_ADC_I2S_VALID_LEN_32BITS;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ switch (params_channels(params)) {
+ case 1:
+ adc_aif1 |= RK3308_ADC_I2S_MONO;
+ break;
+ case 2:
+ case 4:
+ case 6:
+ case 8:
+ adc_aif1 |= RK3308_ADC_I2S_STEREO;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ adc_aif1 |= RK3308_ADC_I2S_LR_NORMAL;
+ adc_aif2 |= RK3308_ADC_I2S_WORK;
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON01(grp),
+ RK3308_ADC_I2S_VALID_LEN_MSK |
+ RK3308_ADC_I2S_LR_MSK |
+ RK3308_ADC_I2S_TYPE_MSK,
+ adc_aif1);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON02(grp),
+ RK3308_ADC_I2S_MSK,
+ adc_aif2);
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_update_adc_grps(struct rk3308_codec_priv *rk3308,
+ struct snd_pcm_hw_params *params)
+{
+ switch (params_channels(params)) {
+ case 1:
+ rk3308->used_adc_grps = 1;
+ break;
+ case 2:
+ case 4:
+ case 6:
+ case 8:
+ rk3308->used_adc_grps = params_channels(params) / 2;
+ break;
+ default:
+ dev_err(rk3308->plat_dev, "Invalid channels: %d\n",
+ params_channels(params));
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static int rk3308_mute_stream(struct snd_soc_dai *dai, int mute, int stream)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+
+ if (stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ int dgain;
+
+ if (mute) {
+ for (dgain = 0x2; dgain <= 0x7; dgain++) {
+ /*
+ * Keep the max -> min digital CIC interpolation
+ * filter gain step by step.
+ *
+ * loud: 0x2; whisper: 0x7
+ */
+ regmap_update_bits(rk3308->regmap,
+ RK3308_DAC_DIG_CON04,
+ RK3308_DAC_CIC_IF_GAIN_MSK,
+ dgain);
+ usleep_range(200, 300); /* estimated value */
+ }
+
+#if !DEBUG_POP_ALWAYS
+ rk3308_headphone_ctl(rk3308, 0);
+ rk3308_speaker_ctl(rk3308, 0);
+#endif
+ } else {
+#if !DEBUG_POP_ALWAYS
+ if (rk3308->dac_output == DAC_LINEOUT)
+ rk3308_speaker_ctl(rk3308, 1);
+ else if (rk3308->dac_output == DAC_HPOUT)
+ rk3308_headphone_ctl(rk3308, 1);
+
+ if (rk3308->delay_start_play_ms)
+ msleep(rk3308->delay_start_play_ms);
+#endif
+ for (dgain = 0x7; dgain >= 0x2; dgain--) {
+ /*
+ * Keep the min -> max digital CIC interpolation
+ * filter gain step by step
+ *
+ * loud: 0x2; whisper: 0x7
+ */
+ regmap_update_bits(rk3308->regmap,
+ RK3308_DAC_DIG_CON04,
+ RK3308_DAC_CIC_IF_GAIN_MSK,
+ dgain);
+ usleep_range(200, 300); /* estimated value */
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_digital_fadein(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int dgain, dgain_ref;
+
+ if (rk3308->hpout_l_dgain != rk3308->hpout_r_dgain) {
+ pr_warn("HPOUT l_dgain: 0x%x != r_dgain: 0x%x\n",
+ rk3308->hpout_l_dgain, rk3308->hpout_r_dgain);
+ dgain_ref = min(rk3308->hpout_l_dgain, rk3308->hpout_r_dgain);
+ } else {
+ dgain_ref = rk3308->hpout_l_dgain;
+ }
/*
- * 4.Change the register ACODEC_ADC_ANA_CON10[6:0] from the 0x1 to 0x7f
- * step by step or configure the ACODEC_ADC_ANA_CON10[6:0] to 0x7f
- * directly. The suggestion slot time of the step is 20ms
+ * We'd better change the gain of the left and right channels
+ * at the same time to avoid different listening
*/
- mdelay(20);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
- RK3308_ADC_CURRENT_CHARGE_MSK,
- RK3308_ADC_DONT_SEL_ALL);
+ for (dgain = RK3308_DAC_L_HPOUT_GAIN_NDB_39;
+ dgain <= dgain_ref; dgain++) {
+ /* Step 02 decrease dgains for de-pop */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON05,
+ RK3308_DAC_L_HPOUT_GAIN_MSK,
+ dgain);
+
+ /* Step 02 decrease dgains for de-pop */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON06,
+ RK3308_DAC_R_HPOUT_GAIN_MSK,
+ dgain);
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_digital_fadeout(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int l_dgain, r_dgain;
+
+ /*
+ * Note. In the step2, adjusting the register step by step to
+ * the appropriate value and taking 20ms as time step
+ */
+ regmap_read(rk3308->regmap, RK3308_DAC_ANA_CON05, &l_dgain);
+ l_dgain &= RK3308_DAC_L_HPOUT_GAIN_MSK;
+
+ regmap_read(rk3308->regmap, RK3308_DAC_ANA_CON06, &r_dgain);
+ r_dgain &= RK3308_DAC_R_HPOUT_GAIN_MSK;
+
+ if (l_dgain != r_dgain) {
+ pr_warn("HPOUT l_dgain: 0x%x != r_dgain: 0x%x\n",
+ l_dgain, r_dgain);
+ l_dgain = min(l_dgain, r_dgain);
+ }
+
+ /*
+ * We'd better change the gain of the left and right channels
+ * at the same time to avoid different listening
+ */
+ while (l_dgain >= RK3308_DAC_L_HPOUT_GAIN_NDB_39) {
+ /* Step 02 decrease dgains for de-pop */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON05,
+ RK3308_DAC_L_HPOUT_GAIN_MSK,
+ l_dgain);
+
+ /* Step 02 decrease dgains for de-pop */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON06,
+ RK3308_DAC_R_HPOUT_GAIN_MSK,
+ l_dgain);
+
+ usleep_range(200, 300); /* estimated value */
+
+ if (l_dgain == RK3308_DAC_L_HPOUT_GAIN_NDB_39)
+ break;
+
+ l_dgain--;
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_dac_lineout_enable(struct rk3308_codec_priv *rk3308)
+{
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /* Step 04 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_L_SEL_DC_FROM_INTERNAL |
+ RK3308_DAC_R_SEL_DC_FROM_INTERNAL);
+ }
+
+ /* Step 07 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN);
+
+ udelay(20);
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /* Step 10 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_L_SEL_LINEOUT_FROM_INTERNAL |
+ RK3308_DAC_R_SEL_LINEOUT_FROM_INTERNAL);
+
+ udelay(20);
+ }
+
+ /* Step 19 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE);
+ udelay(20);
+
+ return 0;
+}
+
+static int rk3308_codec_dac_lineout_disable(struct rk3308_codec_priv *rk3308)
+{
+ /* Step 08 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE,
+ RK3308_DAC_L_LINEOUT_MUTE |
+ RK3308_DAC_R_LINEOUT_MUTE);
+
+ /* Step 09 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN,
+ RK3308_DAC_L_LINEOUT_DIS |
+ RK3308_DAC_R_LINEOUT_DIS);
+
+ return 0;
+}
+
+static int rk3308_codec_dac_hpout_enable(struct rk3308_codec_priv *rk3308)
+{
+ /* Step 03 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_L_WORK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_WORK);
+
+ udelay(20);
+
+ /* Step 07 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN);
+
+ udelay(20);
+
+ /* Step 08 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK);
+
+ udelay(20);
+
+ /* Step 16 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE);
+
+ udelay(20);
+
+ return 0;
+}
+
+static int rk3308_codec_dac_hpout_disable(struct rk3308_codec_priv *rk3308)
+{
+ /* Step 03 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_L_INIT |
+ RK3308_DAC_HPOUT_POP_SOUND_R_INIT);
+
+ /* Step 07 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN,
+ RK3308_DAC_L_HPOUT_DIS |
+ RK3308_DAC_R_HPOUT_DIS);
+
+ /* Step 08 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK,
+ RK3308_DAC_L_HPOUT_INIT |
+ RK3308_DAC_R_HPOUT_INIT);
+
+ /* Step 16 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE,
+ RK3308_DAC_L_HPOUT_MUTE |
+ RK3308_DAC_R_HPOUT_MUTE);
+
+ return 0;
+}
+
+static int rk3308_codec_dac_switch(struct rk3308_codec_priv *rk3308,
+ int dac_output)
+{ int ret = 0;
+
+ if (rk3308->dac_output == dac_output) {
+ dev_info(rk3308->plat_dev,
+ "Don't need to change dac_output: %d\n", dac_output);
+ goto out;
+ }
+
+ switch (dac_output) {
+ case DAC_LINEOUT:
+ case DAC_HPOUT:
+ case DAC_LINEOUT_HPOUT:
+ break;
+ default:
+ dev_err(rk3308->plat_dev, "Unknown value: %d\n", dac_output);
+ ret = -EINVAL;
+ goto out;
+ }
+
+ if (rk3308_codec_get_dac_path_state(rk3308) == PATH_BUSY) {
+ /*
+ * We can only switch the audio path to LINEOUT or HPOUT on
+ * codec during playbacking, otherwise, just update the
+ * dac_output flag.
+ */
+ switch (dac_output) {
+ case DAC_LINEOUT:
+ rk3308_headphone_ctl(rk3308, 0);
+ rk3308_speaker_ctl(rk3308, 1);
+ rk3308_codec_dac_hpout_disable(rk3308);
+ rk3308_codec_dac_lineout_enable(rk3308);
+ break;
+ case DAC_HPOUT:
+ rk3308_speaker_ctl(rk3308, 0);
+ rk3308_headphone_ctl(rk3308, 1);
+ rk3308_codec_dac_lineout_disable(rk3308);
+ rk3308_codec_dac_hpout_enable(rk3308);
+ break;
+ case DAC_LINEOUT_HPOUT:
+ rk3308_speaker_ctl(rk3308, 1);
+ rk3308_headphone_ctl(rk3308, 1);
+ rk3308_codec_dac_lineout_enable(rk3308);
+ rk3308_codec_dac_hpout_enable(rk3308);
+ break;
+ default:
+ break;
+ }
+ }
+
+ rk3308->dac_output = dac_output;
+out:
+ dev_dbg(rk3308->plat_dev, "switch dac_output to: %d\n",
+ rk3308->dac_output);
+
+ return ret;
+}
+
+static int rk3308_codec_dac_enable(struct rk3308_codec_priv *rk3308)
+{
+ /*
+ * Note1. If the ACODEC_DAC_ANA_CON12[6] or ACODEC_DAC_ANA_CON12[2]
+ * is set to 0x1, ignoring the step9~12.
+ */
+
+ /*
+ * Note2. If the ACODEC_ DAC_ANA_CON12[7] or ACODEC_DAC_ANA_CON12[3]
+ * is set to 0x1, the ADC0 or ADC1 should be enabled firstly, and
+ * please refer to Enable ADC Configuration Standard Usage Flow(expect
+ * step7~step9,step14).
+ */
+
+ /*
+ * Note3. If no opening the line out, ignoring the step6, step17 and
+ * step19.
+ */
+
+ /*
+ * Note4. If no opening the headphone out, ignoring the step3,step7~8,
+ * step16 and step18.
+ */
+
+ /*
+ * Note5. In the step18, adjust the register step by step to the
+ * appropriate value and taking 10ms as one time step
+ */
+
+ /*
+ * 1. Set the ACODEC_DAC_ANA_CON0[0] to 0x1, to enable the current
+ * source of DAC
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
+ RK3308_DAC_CURRENT_MSK,
+ RK3308_DAC_CURRENT_EN);
+
+ udelay(20);
+
+ /*
+ * 2. Set the ACODEC_DAC_ANA_CON1[6] and ACODEC_DAC_ANA_CON1[2] to 0x1,
+ * to enable the reference voltage buffer
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_BUF_REF_L_MSK |
+ RK3308_DAC_BUF_REF_R_MSK,
+ RK3308_DAC_BUF_REF_L_EN |
+ RK3308_DAC_BUF_REF_R_EN);
+
+ /* Waiting the stable reference voltage */
+ mdelay(1);
+
+ if (rk3308->dac_output == DAC_HPOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Step 03 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_L_WORK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_WORK);
+
+ udelay(20);
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B &&
+ (rk3308->dac_output == DAC_LINEOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT)) {
+ /* Step 04 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_L_SEL_DC_FROM_INTERNAL |
+ RK3308_DAC_R_SEL_DC_FROM_INTERNAL);
+
+ udelay(20);
+ }
+
+ /* Step 05 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_EN |
+ RK3308_DAC_R_HPMIX_EN,
+ RK3308_DAC_L_HPMIX_EN |
+ RK3308_DAC_R_HPMIX_EN);
+
+ /* Waiting the stable HPMIX */
+ mdelay(1);
+
+ /* Step 06. Reset HPMIX and recover HPMIX gains */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_WORK |
+ RK3308_DAC_R_HPMIX_WORK,
+ RK3308_DAC_L_HPMIX_INIT |
+ RK3308_DAC_R_HPMIX_INIT);
+ udelay(50);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_WORK |
+ RK3308_DAC_R_HPMIX_WORK,
+ RK3308_DAC_L_HPMIX_WORK |
+ RK3308_DAC_R_HPMIX_WORK);
+
+ udelay(20);
+
+ if (rk3308->dac_output == DAC_LINEOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Step 07 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN);
+
+ udelay(20);
+ }
+
+ if (rk3308->dac_output == DAC_HPOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Step 08 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN);
+
+ udelay(20);
+
+ /* Step 09 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK);
+
+ udelay(20);
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /* Step 10 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_L_SEL_LINEOUT_FROM_INTERNAL |
+ RK3308_DAC_R_SEL_LINEOUT_FROM_INTERNAL);
+
+ udelay(20);
+ }
+
+ /* Step 11 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_REF_EN |
+ RK3308_DAC_R_REF_EN,
+ RK3308_DAC_L_REF_EN |
+ RK3308_DAC_R_REF_EN);
+
+ udelay(20);
+
+ /* Step 12 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_CLK_EN |
+ RK3308_DAC_R_CLK_EN,
+ RK3308_DAC_L_CLK_EN |
+ RK3308_DAC_R_CLK_EN);
+
+ udelay(20);
+
+ /* Step 13 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_DAC_EN |
+ RK3308_DAC_R_DAC_EN,
+ RK3308_DAC_L_DAC_EN |
+ RK3308_DAC_R_DAC_EN);
+
+ udelay(20);
+
+ /* Step 14 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_DAC_WORK |
+ RK3308_DAC_R_DAC_WORK,
+ RK3308_DAC_L_DAC_WORK |
+ RK3308_DAC_R_DAC_WORK);
+
+ udelay(20);
+
+ /* Step 15 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
+ RK3308_DAC_L_HPMIX_SEL_MSK |
+ RK3308_DAC_R_HPMIX_SEL_MSK,
+ RK3308_DAC_L_HPMIX_I2S |
+ RK3308_DAC_R_HPMIX_I2S);
+
+ udelay(20);
+
+ /* Step 16 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_UNMUTE |
+ RK3308_DAC_R_HPMIX_UNMUTE,
+ RK3308_DAC_L_HPMIX_UNMUTE |
+ RK3308_DAC_R_HPMIX_UNMUTE);
+
+ udelay(20);
+
+ /* Step 17: Put configuration HPMIX Gain to DAPM */
+
+ if (rk3308->dac_output == DAC_HPOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Step 18 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE);
+
+ udelay(20);
+ }
+
+ if (rk3308->dac_output == DAC_LINEOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Step 19 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE);
+ udelay(20);
+ }
+
+ /* Step 20, put configuration HPOUT gain to DAPM control */
+ /* Step 21, put configuration LINEOUT gain to DAPM control */
+
+ if (rk3308->dac_output == DAC_HPOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Just for HPOUT */
+ rk3308_codec_digital_fadein(rk3308);
+ }
+
+ rk3308->dac_endisable = true;
+
+ /* TODO: TRY TO TEST DRIVE STRENGTH */
+
+ return 0;
+}
+
+static int rk3308_codec_dac_disable(struct rk3308_codec_priv *rk3308)
+{
+ /*
+ * Step 00 skipped. Keep the DAC channel work and input the mute signal.
+ */
+
+ /* Step 01 skipped. May set the min gain for LINEOUT. */
+
+ /* Step 02 skipped. May set the min gain for HPOUT. */
+
+ if (rk3308->dac_output == DAC_HPOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT) {
+ /* Just for HPOUT */
+ rk3308_codec_digital_fadeout(rk3308);
+ }
+
+ /* Step 03 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_UNMUTE |
+ RK3308_DAC_R_HPMIX_UNMUTE,
+ RK3308_DAC_L_HPMIX_UNMUTE |
+ RK3308_DAC_R_HPMIX_UNMUTE);
+
+ /* Step 04 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
+ RK3308_DAC_L_HPMIX_SEL_MSK |
+ RK3308_DAC_R_HPMIX_SEL_MSK,
+ RK3308_DAC_L_HPMIX_NONE |
+ RK3308_DAC_R_HPMIX_NONE);
+ /* Step 05 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_UNMUTE |
+ RK3308_DAC_R_HPOUT_UNMUTE,
+ RK3308_DAC_L_HPOUT_MUTE |
+ RK3308_DAC_R_HPOUT_MUTE);
+
+ /* Step 06 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_DAC_WORK |
+ RK3308_DAC_R_DAC_WORK,
+ RK3308_DAC_L_DAC_INIT |
+ RK3308_DAC_R_DAC_INIT);
+
+ /* Step 07 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_EN |
+ RK3308_DAC_R_HPOUT_EN,
+ RK3308_DAC_L_HPOUT_DIS |
+ RK3308_DAC_R_HPOUT_DIS);
+
+ /* Step 08 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_UNMUTE |
+ RK3308_DAC_R_LINEOUT_UNMUTE,
+ RK3308_DAC_L_LINEOUT_MUTE |
+ RK3308_DAC_R_LINEOUT_MUTE);
+
+ /* Step 09 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_EN |
+ RK3308_DAC_R_LINEOUT_EN,
+ RK3308_DAC_L_LINEOUT_DIS |
+ RK3308_DAC_R_LINEOUT_DIS);
+
+ /* Step 10 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_EN |
+ RK3308_DAC_R_HPMIX_EN,
+ RK3308_DAC_L_HPMIX_DIS |
+ RK3308_DAC_R_HPMIX_DIS);
+
+ /* Step 11 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_DAC_EN |
+ RK3308_DAC_R_DAC_EN,
+ RK3308_DAC_L_DAC_DIS |
+ RK3308_DAC_R_DAC_DIS);
+
+ /* Step 12 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_CLK_EN |
+ RK3308_DAC_R_CLK_EN,
+ RK3308_DAC_L_CLK_DIS |
+ RK3308_DAC_R_CLK_DIS);
+
+ /* Step 13 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON02,
+ RK3308_DAC_L_REF_EN |
+ RK3308_DAC_R_REF_EN,
+ RK3308_DAC_L_REF_DIS |
+ RK3308_DAC_R_REF_DIS);
+
+ /* Step 14 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_HPOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_L_INIT |
+ RK3308_DAC_HPOUT_POP_SOUND_R_INIT);
+
+ /* Step 15 */
+ if (rk3308->codec_ver == ACODEC_VERSION_B &&
+ (rk3308->dac_output == DAC_LINEOUT ||
+ rk3308->dac_output == DAC_LINEOUT_HPOUT)) {
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK |
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_L_SEL_DC_FROM_VCM |
+ RK3308_DAC_R_SEL_DC_FROM_VCM);
+ }
+
+ /* Step 16 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_BUF_REF_L_EN |
+ RK3308_DAC_BUF_REF_R_EN,
+ RK3308_DAC_BUF_REF_L_DIS |
+ RK3308_DAC_BUF_REF_R_DIS);
+
+ /* Step 17 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
+ RK3308_DAC_CURRENT_EN,
+ RK3308_DAC_CURRENT_DIS);
+
+ /* Step 18 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON03,
+ RK3308_DAC_L_HPOUT_WORK |
+ RK3308_DAC_R_HPOUT_WORK,
+ RK3308_DAC_L_HPOUT_INIT |
+ RK3308_DAC_R_HPOUT_INIT);
+
+ /* Step 19 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON13,
+ RK3308_DAC_L_HPMIX_WORK |
+ RK3308_DAC_R_HPMIX_WORK,
+ RK3308_DAC_L_HPMIX_WORK |
+ RK3308_DAC_R_HPMIX_WORK);
+
+ /* Step 20 skipped, may set the min gain for HPOUT. */
+
+ /*
+ * Note2. If the ACODEC_DAC_ANA_CON12[7] or ACODEC_DAC_ANA_CON12[3]
+ * is set to 0x1, add the steps from the section Disable ADC
+ * Configuration Standard Usage Flow after complete the step 19
+ *
+ * IF USING LINE-IN
+ * rk3308_codec_adc_ana_disable(rk3308, type);
+ */
+
+ rk3308->dac_endisable = false;
+
+ return 0;
+}
+
+static int rk3308_codec_power_on(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int v;
+
+ /* 0. Supply the power of digital part and reset the Audio Codec */
+ /* Do nothing */
+
+ /*
+ * 1. Configure ACODEC_DAC_ANA_CON1[1:0] and ACODEC_DAC_ANA_CON1[5:4]
+ * to 0x1, to setup dc voltage of the DAC channel output.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_L_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_L_INIT);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON01,
+ RK3308_DAC_HPOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_HPOUT_POP_SOUND_R_INIT);
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 2. Configure ACODEC_DAC_ANA_CON15[1:0] and
+ * ACODEC_DAC_ANA_CON15[5:4] to 0x1, to setup dc voltage of
+ * the DAC channel output.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_L_MSK,
+ RK3308_DAC_L_SEL_DC_FROM_VCM);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON15,
+ RK3308_DAC_LINEOUT_POP_SOUND_R_MSK,
+ RK3308_DAC_R_SEL_DC_FROM_VCM);
+ }
+
+ /*
+ * 3. Configure the register ACODEC_ADC_ANA_CON10[3:0] to 7’b000_0001.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK,
+ RK3308_ADC_SEL_I(0x1));
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 4. Configure the register ACODEC_ADC_ANA_CON14[3:0] to
+ * 4’b0001.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_CURRENT_CHARGE_MSK,
+ RK3308_DAC_SEL_I(0x1));
+ }
+
+ /* 5. Supply the power of the analog part(AVDD,AVDDRV) */
+
+ /*
+ * 6. Configure the register ACODEC_ADC_ANA_CON10[7] to 0x1 to setup
+ * reference voltage
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_REF_EN, RK3308_ADC_REF_EN);
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 7. Configure the register ACODEC_ADC_ANA_CON14[4] to 0x1 to
+ * setup reference voltage
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_VCM_LINEOUT_EN,
+ RK3308_DAC_VCM_LINEOUT_EN);
+ }
+
+ /*
+ * 8. Change the register ACODEC_ADC_ANA_CON10[6:0] from the 0x1 to
+ * 0x7f step by step or configure the ACODEC_ADC_ANA_CON10[6:0] to
+ * 0x7f directly. Here the slot time of the step is 200us.
+ */
+ for (v = 0x1; v <= 0x7f; v++) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK,
+ v);
+ udelay(200);
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 9. Change the register ACODEC_ADC_ANA_CON14[3:0] from the 0x1
+ * to 0xf step by step or configure the
+ * ACODEC_ADC_ANA_CON14[3:0] to 0xf directly. Here the slot
+ * time of the step is 200us.
+ */
+ for (v = 0x1; v <= 0xf; v++) {
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_CURRENT_CHARGE_MSK,
+ v);
+ udelay(200);
+ }
+ }
+
+ /* 10. Wait until the voltage of VCM keeps stable at the AVDD/2 */
+ msleep(20); /* estimated value */
+
+ /*
+ * 11. Configure the register ACODEC_ADC_ANA_CON10[6:0] to the
+ * appropriate value(expect 0x0) for reducing power.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK, 0x7c);
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 12. Configure the register ACODEC_DAC_ANA_CON14[6:0] to the
+ * appropriate value(expect 0x0) for reducing power.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_CURRENT_CHARGE_MSK, 0xf);
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_power_off(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int v;
+
+ /*
+ * 0. Keep the power on and disable the DAC and ADC path according to
+ * the section power on configuration standard usage flow.
+ */
+
+ /*
+ * 1. Configure the register ACODEC_ADC_ANA_CON10[6:0] to 7’b000_0001.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK,
+ RK3308_ADC_SEL_I(0x1));
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 2. Configure the register ACODEC_DAC_ANA_CON14[3:0] to
+ * 4’b0001.
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_CURRENT_CHARGE_MSK,
+ RK3308_DAC_SEL_I(0x1));
+ }
+
+ /* 3. Configure the register ACODEC_ADC_ANA_CON10[7] to 0x0 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_REF_EN,
+ RK3308_ADC_REF_DIS);
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /* 4. Configure the register ACODEC_DAC_ANA_CON14[7] to 0x0 */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON14,
+ RK3308_DAC_VCM_LINEOUT_EN,
+ RK3308_DAC_VCM_LINEOUT_DIS);
+ }
+
+ /*
+ * 5. Change the register ACODEC_ADC_ANA_CON10[6:0] from the 0x1 to 0x7f
+ * step by step or configure the ACODEC_ADC_ANA_CON10[6:0] to 0x7f
+ * directly. Here the slot time of the step is 200us.
+ */
+ for (v = 0x1; v <= 0x7f; v++) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK,
+ v);
+ udelay(200);
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /*
+ * 6. Change the register ACODEC_DAC_ANA_CON14[3:0] from the 0x1
+ * to 0xf step by step or configure the
+ * ACODEC_DAC_ANA_CON14[3:0] to 0xf directly. Here the slot
+ * time of the step is 200us.
+ */
+ for (v = 0x1; v <= 0x7f; v++) {
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_ANA_CON10(0),
+ RK3308_ADC_CURRENT_CHARGE_MSK,
+ v);
+ udelay(200);
+ }
+ }
+
+ /* 7. Wait until the voltage of VCM keeps stable at the AGND */
+ msleep(20); /* estimated value */
+
+ /* 8. Power off the analog power supply */
+ /* 9. Power off the digital power supply */
+
+ /* Do something via hardware */
+
+ return 0;
+}
+
+static int rk3308_codec_headset_detect_enable(struct rk3308_codec_priv *rk3308)
+{
+ /*
+ * Set ACODEC_DAC_ANA_CON0[1] to 0x1, to enable the headset insert
+ * detection
+ *
+ * Note. When the voltage of PAD HPDET> 8*AVDD/9, the output value of
+ * the pin_hpdet will be set to 0x1 and assert a interrupt
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
+ RK3308_DAC_HEADPHONE_DET_MSK,
+ RK3308_DAC_HEADPHONE_DET_EN);
+
+ return 0;
+}
+
+static int rk3308_codec_headset_detect_disable(struct rk3308_codec_priv *rk3308)
+{
+ /*
+ * Set ACODEC_DAC_ANA_CON0[1] to 0x0, to disable the headset insert
+ * detection
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON00,
+ RK3308_DAC_HEADPHONE_DET_MSK,
+ RK3308_DAC_HEADPHONE_DET_DIS);
+
+ return 0;
+}
+
+static int rk3308_codec_check_i2s_sdis(struct rk3308_codec_priv *rk3308,
+ int num)
+{
+ int i, j, ret = 0;
+
+ switch (num) {
+ case 1:
+ rk3308->which_i2s = ACODEC_TO_I2S1_2CH;
+ break;
+ case 2:
+ rk3308->which_i2s = ACODEC_TO_I2S3_4CH;
+ break;
+ case 4:
+ rk3308->which_i2s = ACODEC_TO_I2S2_8CH;
+ break;
+ default:
+ dev_err(rk3308->plat_dev, "Invalid i2s sdis num: %d\n", num);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ for (i = 0; i < num; i++) {
+ if (rk3308->i2s_sdis[i] > ADC_LR_GROUP_MAX - 1) {
+ dev_err(rk3308->plat_dev,
+ "i2s_sdis[%d]: %d is overflow\n",
+ i, rk3308->i2s_sdis[i]);
+ ret = -EINVAL;
+ goto err;
+ }
+
+ for (j = 0; j < num; j++) {
+ if (i == j)
+ continue;
+
+ if (rk3308->i2s_sdis[i] == rk3308->i2s_sdis[j]) {
+ dev_err(rk3308->plat_dev,
+ "Invalid i2s_sdis: [%d]%d == [%d]%d\n",
+ i, rk3308->i2s_sdis[i],
+ j, rk3308->i2s_sdis[j]);
+ ret = -EINVAL;
+ goto err;
+ }
+ }
+ }
+
+err:
+ return ret;
+}
+
+static int rk3308_codec_adc_grps_route_config(struct rk3308_codec_priv *rk3308)
+{
+ int idx = 0;
+
+ if (rk3308->which_i2s == ACODEC_TO_I2S2_8CH) {
+ for (idx = 0; idx < rk3308->to_i2s_grps; idx++) {
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S2_8CH_SDI(idx, rk3308->i2s_sdis[idx]));
+ }
+ } else if (rk3308->which_i2s == ACODEC_TO_I2S3_4CH) {
+ for (idx = 0; idx < rk3308->to_i2s_grps; idx++) {
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S3_4CH_SDI(idx, rk3308->i2s_sdis[idx]));
+ }
+ } else if (rk3308->which_i2s == ACODEC_TO_I2S1_2CH) {
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S1_2CH_SDI(rk3308->i2s_sdis[idx]));
+ }
+
+ return 0;
+}
+
+/* Put default one-to-one mapping */
+static int rk3308_codec_adc_grps_route_default(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int idx;
+
+ /*
+ * The GRF values may be kept the previous status after hot reboot,
+ * if the property 'rockchip,adc-grps-route' is not set, we need to
+ * recover default the order of sdi/sdo for i2s2_8ch/i2s3_8ch/i2s1_2ch.
+ */
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S1_2CH_SDI(0));
+
+ for (idx = 0; idx < 2; idx++) {
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S3_4CH_SDI(idx, idx));
+ }
+
+ /* Using i2s2_8ch by default. */
+ rk3308->which_i2s = ACODEC_TO_I2S2_8CH;
+ rk3308->to_i2s_grps = ADC_LR_GROUP_MAX;
+
+ for (idx = 0; idx < ADC_LR_GROUP_MAX; idx++) {
+ rk3308->i2s_sdis[idx] = idx;
+ regmap_write(rk3308->grf, GRF_SOC_CON1,
+ GRF_I2S2_8CH_SDI(idx, idx));
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_adc_grps_route(struct rk3308_codec_priv *rk3308,
+ struct device_node *np)
+{
+ int num, ret;
+
+ num = of_count_phandle_with_args(np, "rockchip,adc-grps-route", NULL);
+ if (num < 0) {
+ if (num == -ENOENT) {
+ /* Not use 'rockchip,adc-grps-route' property here */
+ rk3308_codec_adc_grps_route_default(rk3308);
+ ret = 0;
+ } else {
+ dev_err(rk3308->plat_dev,
+ "Failed to read 'rockchip,adc-grps-route' num: %d\n",
+ num);
+ ret = num;
+ }
+ return ret;
+ }
+
+ ret = of_property_read_u32_array(np, "rockchip,adc-grps-route",
+ rk3308->i2s_sdis, num);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to read 'rockchip,adc-grps-route': %d\n",
+ ret);
+ return ret;
+ }
+
+ ret = rk3308_codec_check_i2s_sdis(rk3308, num);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to check i2s_sdis: %d\n", ret);
+ return ret;
+ }
+
+ rk3308->to_i2s_grps = num;
+
+ rk3308_codec_adc_grps_route_config(rk3308);
+
+ return 0;
+}
+
+static int check_micbias(int micbias)
+{
+ switch (micbias) {
+ case RK3308_ADC_MICBIAS_VOLT_0_85:
+ case RK3308_ADC_MICBIAS_VOLT_0_8:
+ case RK3308_ADC_MICBIAS_VOLT_0_75:
+ case RK3308_ADC_MICBIAS_VOLT_0_7:
+ case RK3308_ADC_MICBIAS_VOLT_0_65:
+ case RK3308_ADC_MICBIAS_VOLT_0_6:
+ case RK3308_ADC_MICBIAS_VOLT_0_55:
+ case RK3308_ADC_MICBIAS_VOLT_0_5:
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+static bool handle_loopback(struct rk3308_codec_priv *rk3308)
+{
+ /* The version B doesn't need to handle loopback. */
+ if (rk3308->codec_ver == ACODEC_VERSION_B)
+ return false;
+
+ switch (rk3308->loopback_grp) {
+ case 0:
+ case 1:
+ case 2:
+ case 3:
+ return true;
+ }
+
+ return false;
+}
+
+static bool has_en_always_grps(struct rk3308_codec_priv *rk3308)
+{
+ int idx;
+
+ if (rk3308->en_always_grps_num) {
+ for (idx = 0; idx < ADC_LR_GROUP_MAX; idx++) {
+ if (rk3308->en_always_grps[idx] >= 0 &&
+ rk3308->en_always_grps[idx] <= ADC_LR_GROUP_MAX - 1)
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static int rk3308_codec_micbias_enable(struct rk3308_codec_priv *rk3308,
+ int micbias)
+{
+ int ret;
+
+ if (rk3308->ext_micbias != EXT_MICBIAS_NONE)
+ return 0;
+
+ /* 0. Power up the ACODEC and keep the AVDDH stable */
+
+ /* Step 1. Configure ACODEC_ADC_ANA_CON7[2:0] to the certain value */
+ ret = check_micbias(micbias);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev, "This is an invalid micbias: %d\n",
+ micbias);
+ return ret;
+ }
+
+ /*
+ * Note: Only the reg (ADC_ANA_CON7+0x0)[2:0] represent the level range
+ * control signal of MICBIAS voltage
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(0),
+ RK3308_ADC_LEVEL_RANGE_MICBIAS_MSK,
+ micbias);
+
+ /* Step 2. Wait until the VCMH keep stable */
+ msleep(20); /* estimated value */
+
+ /*
+ * Step 3. Configure ACODEC_ADC_ANA_CON8[4] to 0x1
+ *
+ * Note: Only the reg (ADC_ANA_CON8+0x0)[4] represent the enable
+ * signal of current source for MICBIAS
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON08(0),
+ RK3308_ADC_MICBIAS_CURRENT_MSK,
+ RK3308_ADC_MICBIAS_CURRENT_EN);
+
+ /*
+ * Step 4. Configure the (ADC_ANA_CON7+0x40)[3] or
+ * (ADC_ANA_CON7+0x80)[3] to 0x1.
+ *
+ * (ADC_ANA_CON7+0x40)[3] used to control the MICBIAS1, and
+ * (ADC_ANA_CON7+0x80)[3] used to control the MICBIAS2
+ */
+ if (rk3308->micbias1)
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(1),
+ RK3308_ADC_MIC_BIAS_BUF_EN,
+ RK3308_ADC_MIC_BIAS_BUF_EN);
+
+ if (rk3308->micbias2)
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(2),
+ RK3308_ADC_MIC_BIAS_BUF_EN,
+ RK3308_ADC_MIC_BIAS_BUF_EN);
+
+ /* waiting micbias stabled*/
+ mdelay(50);
+
+ rk3308->enable_micbias = true;
+
+ return 0;
+}
+
+static int rk3308_codec_micbias_disable(struct rk3308_codec_priv *rk3308)
+{
+ if (rk3308->ext_micbias != EXT_MICBIAS_NONE)
+ return 0;
+
+ /* Step 0. Enable the MICBIAS and keep the Audio Codec stable */
+ /* Do nothing */
+
+ /*
+ * Step 1. Configure the (ADC_ANA_CON7+0x40)[3] or
+ * (ADC_ANA_CON7+0x80)[3] to 0x0
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(1),
+ RK3308_ADC_MIC_BIAS_BUF_EN,
+ RK3308_ADC_MIC_BIAS_BUF_DIS);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(2),
+ RK3308_ADC_MIC_BIAS_BUF_EN,
+ RK3308_ADC_MIC_BIAS_BUF_DIS);
+
+ /*
+ * Step 2. Configure ACODEC_ADC_ANA_CON8[4] to 0x0
+ *
+ * Note: Only the reg (ADC_ANA_CON8+0x0)[4] represent the enable
+ * signal of current source for MICBIAS
+ */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON08(0),
+ RK3308_ADC_MICBIAS_CURRENT_MSK,
+ RK3308_ADC_MICBIAS_CURRENT_DIS);
+
+ rk3308->enable_micbias = false;
+
+ return 0;
+}
+
+static int rk3308_codec_adc_reinit_mics(struct rk3308_codec_priv *rk3308,
+ int type)
+{
+ int idx, grp;
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 1 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK,
+ RK3308_ADC_CH1_ADC_INIT |
+ RK3308_ADC_CH2_ADC_INIT);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 2 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK,
+ RK3308_ADC_CH1_ALC_INIT |
+ RK3308_ADC_CH2_ALC_INIT);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 3 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK,
+ RK3308_ADC_CH1_MIC_INIT |
+ RK3308_ADC_CH2_MIC_INIT);
+ }
+
+ usleep_range(200, 250); /* estimated value */
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 1 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK,
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 2 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK,
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 3 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK,
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK);
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_adc_ana_enable(struct rk3308_codec_priv *rk3308,
+ int type)
+{
+ unsigned int agc_func_en;
+ int idx, grp;
+
+ /*
+ * 1. Set the ACODEC_ADC_ANA_CON7[7:6] and ACODEC_ADC_ANA_CON7[5:4],
+ * to select the line-in or microphone as input of ADC
+ *
+ * Note1. Please ignore the step1 for enabling ADC3, ADC4, ADC5,
+ * ADC6, ADC7, and ADC8
+ */
+ if (rk3308->adc_grp0_using_linein) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(0),
+ RK3308_ADC_CH1_IN_SEL_MSK |
+ RK3308_ADC_CH2_IN_SEL_MSK,
+ RK3308_ADC_CH1_IN_LINEIN |
+ RK3308_ADC_CH2_IN_LINEIN);
+
+ /* Keep other ADCs as MIC-IN */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ /* The groups without line-in are >= 1 */
+ if (grp < 1 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_ANA_CON07(grp),
+ RK3308_ADC_CH1_IN_SEL_MSK |
+ RK3308_ADC_CH2_IN_SEL_MSK,
+ RK3308_ADC_CH1_IN_MIC |
+ RK3308_ADC_CH2_IN_MIC);
+ }
+ } else {
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_ANA_CON07(grp),
+ RK3308_ADC_CH1_IN_SEL_MSK |
+ RK3308_ADC_CH2_IN_SEL_MSK,
+ RK3308_ADC_CH1_IN_MIC |
+ RK3308_ADC_CH2_IN_MIC);
+ }
+ }
+
+ /*
+ * 2. Set ACODEC_ADC_ANA_CON0[7] and [3] to 0x1, to end the mute station
+ * of ADC, to enable the MIC module, to enable the reference voltage
+ * buffer, and to end the initialization of MIC
+ */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_UNMUTE |
+ RK3308_ADC_CH2_MIC_UNMUTE,
+ RK3308_ADC_CH1_MIC_UNMUTE |
+ RK3308_ADC_CH2_MIC_UNMUTE);
+ }
+
+ /*
+ * 3. Set ACODEC_ADC_ANA_CON6[0] to 0x1, to enable the current source
+ * of audio
+ */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON06(grp),
+ RK3308_ADC_CURRENT_MSK,
+ RK3308_ADC_CURRENT_EN);
+ }
+
+ /*
+ * This is mainly used for BIST mode that wait ADCs are stable.
+ *
+ * By tested results, the type delay is >40us, but we need to leave
+ * enough delay margin.
+ */
+ usleep_range(400, 500);
+
+ /* vendor step 4*/
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_BUF_REF_EN |
+ RK3308_ADC_CH2_BUF_REF_EN,
+ RK3308_ADC_CH1_BUF_REF_EN |
+ RK3308_ADC_CH2_BUF_REF_EN);
+ }
+
+ /* vendor step 5 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_EN |
+ RK3308_ADC_CH2_MIC_EN,
+ RK3308_ADC_CH1_MIC_EN |
+ RK3308_ADC_CH2_MIC_EN);
+ }
+
+ /* vendor step 6 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_EN |
+ RK3308_ADC_CH2_ALC_EN,
+ RK3308_ADC_CH1_ALC_EN |
+ RK3308_ADC_CH2_ALC_EN);
+ }
+
+ /* vendor step 7 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_CLK_EN |
+ RK3308_ADC_CH2_CLK_EN,
+ RK3308_ADC_CH1_CLK_EN |
+ RK3308_ADC_CH2_CLK_EN);
+ }
+
+ /* vendor step 8 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_EN |
+ RK3308_ADC_CH2_ADC_EN,
+ RK3308_ADC_CH1_ADC_EN |
+ RK3308_ADC_CH2_ADC_EN);
+ }
+
+ /* vendor step 9 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK,
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK);
+ }
+
+ /* vendor step 10 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK,
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK);
+ }
+
+ /* vendor step 11 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK,
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK);
+ }
+
+ /* vendor step 12 */
+
+ /* vendor step 13 */
+
+ /* vendor step 14 */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_read(rk3308->regmap, RK3308_ALC_L_DIG_CON09(grp),
+ &agc_func_en);
+ if (rk3308->adc_zerocross ||
+ agc_func_en & RK3308_AGC_FUNC_SEL_EN) {
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ZEROCROSS_DET_EN,
+ RK3308_ADC_CH1_ZEROCROSS_DET_EN);
+ }
+ regmap_read(rk3308->regmap, RK3308_ALC_R_DIG_CON09(grp),
+ &agc_func_en);
+ if (rk3308->adc_zerocross ||
+ agc_func_en & RK3308_AGC_FUNC_SEL_EN) {
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH2_ZEROCROSS_DET_EN,
+ RK3308_ADC_CH2_ZEROCROSS_DET_EN);
+ }
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ rk3308->adc_grps_endisable[grp] = true;
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_adc_ana_disable(struct rk3308_codec_priv *rk3308,
+ int type)
+{
+ int idx, grp;
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 1 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ZEROCROSS_DET_EN |
+ RK3308_ADC_CH2_ZEROCROSS_DET_EN,
+ RK3308_ADC_CH1_ZEROCROSS_DET_DIS |
+ RK3308_ADC_CH2_ZEROCROSS_DET_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 2 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_EN |
+ RK3308_ADC_CH2_ADC_EN,
+ RK3308_ADC_CH1_ADC_DIS |
+ RK3308_ADC_CH2_ADC_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 3 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_CLK_EN |
+ RK3308_ADC_CH2_CLK_EN,
+ RK3308_ADC_CH1_CLK_DIS |
+ RK3308_ADC_CH2_CLK_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 4 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_EN |
+ RK3308_ADC_CH2_ALC_EN,
+ RK3308_ADC_CH1_ALC_DIS |
+ RK3308_ADC_CH2_ALC_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 5 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_EN |
+ RK3308_ADC_CH2_MIC_EN,
+ RK3308_ADC_CH1_MIC_DIS |
+ RK3308_ADC_CH2_MIC_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 6 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_BUF_REF_EN |
+ RK3308_ADC_CH2_BUF_REF_EN,
+ RK3308_ADC_CH1_BUF_REF_DIS |
+ RK3308_ADC_CH2_BUF_REF_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 7 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON06(grp),
+ RK3308_ADC_CURRENT_MSK,
+ RK3308_ADC_CURRENT_DIS);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 8 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(grp),
+ RK3308_ADC_CH1_ADC_WORK |
+ RK3308_ADC_CH2_ADC_WORK,
+ RK3308_ADC_CH1_ADC_INIT |
+ RK3308_ADC_CH2_ADC_INIT);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 9 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(grp),
+ RK3308_ADC_CH1_ALC_WORK |
+ RK3308_ADC_CH2_ALC_WORK,
+ RK3308_ADC_CH1_ALC_INIT |
+ RK3308_ADC_CH2_ALC_INIT);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ /* vendor step 10 */
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(grp),
+ RK3308_ADC_CH1_MIC_WORK |
+ RK3308_ADC_CH2_MIC_WORK,
+ RK3308_ADC_CH1_MIC_INIT |
+ RK3308_ADC_CH2_MIC_INIT);
+ }
+
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ rk3308->adc_grps_endisable[grp] = false;
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_open_capture(struct rk3308_codec_priv *rk3308)
+{
+ int idx, grp = 0;
+ int type = ADC_TYPE_NORMAL;
+
+ rk3308_codec_adc_ana_enable(rk3308, type);
+ rk3308_codec_adc_reinit_mics(rk3308, type);
+
+ if (rk3308->adc_grp0_using_linein) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON03(0),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_NORMAL_RIGHT);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_DIG_CON03(0),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_NORMAL_LEFT);
+ } else {
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (handle_loopback(rk3308) &&
+ idx == rk3308->loopback_grp &&
+ grp == ADC_GRP_SKIP_MAGIC) {
+ /*
+ * Switch to dummy BIST mode (BIST keep reset
+ * now) to keep the zero input data in I2S bus.
+ *
+ * It may cause the glitch if we hold the ADC
+ * digtital i2s module in codec.
+ *
+ * Then, the grp which is set from loopback_grp.
+ */
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(rk3308->loopback_grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_BIST_SINE);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(rk3308->loopback_grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_BIST_SINE);
+ } else {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_NORMAL_LEFT);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_NORMAL_RIGHT);
+ }
+ }
+ }
+
+ return 0;
+}
+
+static void rk3308_codec_adc_mclk_disable(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_MCLK_MSK,
+ RK3308_ADC_MCLK_DIS);
+}
+
+static void rk3308_codec_adc_mclk_enable(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_ADC_MCLK_MSK,
+ RK3308_ADC_MCLK_EN);
+ udelay(20);
+}
+
+static void rk3308_codec_dac_mclk_disable(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_DAC_MCLK_MSK,
+ RK3308_DAC_MCLK_DIS);
+}
+
+static void rk3308_codec_dac_mclk_enable(struct rk3308_codec_priv *rk3308)
+{
+ regmap_update_bits(rk3308->regmap, RK3308_GLB_CON,
+ RK3308_DAC_MCLK_MSK,
+ RK3308_DAC_MCLK_EN);
+ udelay(20);
+}
+
+static int rk3308_codec_open_dbg_capture(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_ana_enable(rk3308, ADC_TYPE_DBG);
+
+ return 0;
+}
+
+static int rk3308_codec_close_dbg_capture(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_ana_disable(rk3308, ADC_TYPE_DBG);
+
+ return 0;
+}
+
+static int rk3308_codec_close_all_capture(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_ana_disable(rk3308, ADC_TYPE_ALL);
+
+ return 0;
+}
+
+static int rk3308_codec_close_capture(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_ana_disable(rk3308, ADC_TYPE_NORMAL);
+
+ return 0;
+}
+
+static int rk3308_codec_open_playback(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_dac_enable(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_close_playback(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_dac_disable(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_llp_down(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_mclk_disable(rk3308);
+ rk3308_codec_dac_mclk_disable(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_llp_up(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_adc_mclk_enable(rk3308);
+ rk3308_codec_dac_mclk_enable(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_dlp_down(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_micbias_disable(rk3308);
+ rk3308_codec_power_off(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_dlp_up(struct rk3308_codec_priv *rk3308)
+{
+ rk3308_codec_power_on(rk3308);
+ rk3308_codec_micbias_enable(rk3308, rk3308->micbias_volt);
+
+ return 0;
+}
+
+/* Just used for debug and trace power state */
+static void rk3308_codec_set_pm_state(struct rk3308_codec_priv *rk3308,
+ int pm_state)
+{
+ int ret;
+
+ switch (pm_state) {
+ case PM_LLP_DOWN:
+ rk3308_codec_llp_down(rk3308);
+ break;
+ case PM_LLP_UP:
+ rk3308_codec_llp_up(rk3308);
+ break;
+ case PM_DLP_DOWN:
+ rk3308_codec_dlp_down(rk3308);
+ break;
+ case PM_DLP_UP:
+ rk3308_codec_dlp_up(rk3308);
+ break;
+ case PM_DLP_DOWN2:
+ clk_disable_unprepare(rk3308->mclk_rx);
+ clk_disable_unprepare(rk3308->mclk_tx);
+ clk_disable_unprepare(rk3308->pclk);
+ break;
+ case PM_DLP_UP2:
+ ret = clk_prepare_enable(rk3308->pclk);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable acodec pclk: %d\n", ret);
+ goto err;
+ }
+
+ ret = clk_prepare_enable(rk3308->mclk_rx);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable i2s mclk_rx: %d\n", ret);
+ goto err;
+ }
+
+ ret = clk_prepare_enable(rk3308->mclk_tx);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable i2s mclk_tx: %d\n", ret);
+ goto err;
+ }
+ break;
+ default:
+ dev_err(rk3308->plat_dev, "Invalid pm_state: %d\n", pm_state);
+ goto err;
+ }
+
+ rk3308->pm_state = pm_state;
+
+err:
+ return;
+}
+
+static void rk3308_codec_update_adcs_status(struct rk3308_codec_priv *rk3308,
+ int state)
+{
+ int idx, grp;
+
+ /* Update skip_grps flags if the ADCs need to be enabled always. */
+ if (state == PATH_BUSY) {
+ for (idx = 0; idx < rk3308->used_adc_grps; idx++) {
+ u32 mapped_grp = to_mapped_grp(rk3308, idx);
+
+ for (grp = 0; grp < rk3308->en_always_grps_num; grp++) {
+ u32 en_always_grp = rk3308->en_always_grps[grp];
+
+ if (mapped_grp == en_always_grp)
+ rk3308->skip_grps[en_always_grp] = 1;
+ }
+ }
+ }
+}
+
+static int rk3308_hw_params(struct snd_pcm_substream *substream,
+ struct snd_pcm_hw_params *params,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct snd_pcm_str *playback_str =
+ &substream->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK];
+ int type = ADC_TYPE_LOOPBACK;
+ int idx, grp;
+ int ret;
+
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ /* DAC only supports 2 channels */
+ rk3308_codec_dac_mclk_enable(rk3308);
+ rk3308_codec_open_playback(rk3308);
+ rk3308_codec_dac_dig_config(rk3308, params);
+ rk3308_codec_set_dac_path_state(rk3308, PATH_BUSY);
+ } else {
+ if (rk3308->micbias_num &&
+ !rk3308->enable_micbias)
+ rk3308_codec_micbias_enable(rk3308, rk3308->micbias_volt);
+
+ rk3308_codec_adc_mclk_enable(rk3308);
+ ret = rk3308_codec_update_adc_grps(rk3308, params);
+ if (ret < 0)
+ return ret;
+
+ if (handle_loopback(rk3308)) {
+ if (rk3308->micbias_num &&
+ (params_channels(params) == 2) &&
+ to_mapped_grp(rk3308, 0) == rk3308->loopback_grp)
+ rk3308_codec_micbias_disable(rk3308);
+
+ /* Check the DACs are opened */
+ if (playback_str->substream_opened) {
+ rk3308->loopback_dacs_enabled = true;
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_NORMAL_LEFT);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_NORMAL_RIGHT);
+ }
+ } else {
+ rk3308->loopback_dacs_enabled = false;
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_BIST_SINE);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_BIST_SINE);
+ }
+ }
+ }
+
+ rk3308_codec_open_capture(rk3308);
+ rk3308_codec_adc_dig_config(rk3308, params);
+ rk3308_codec_update_adcs_status(rk3308, PATH_BUSY);
+ }
+
+ return 0;
+}
+
+static int rk3308_pcm_trigger(struct snd_pcm_substream *substream,
+ int cmd, struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ int type = ADC_TYPE_LOOPBACK;
+ int idx, grp;
+
+ if (handle_loopback(rk3308) &&
+ rk3308->dac_output == DAC_LINEOUT &&
+ substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ if (cmd == SNDRV_PCM_TRIGGER_START) {
+ struct snd_pcm_str *capture_str =
+ &substream->pcm->streams[SNDRV_PCM_STREAM_CAPTURE];
+
+ if (capture_str->substream_opened)
+ queue_delayed_work(system_power_efficient_wq,
+ &rk3308->loopback_work,
+ msecs_to_jiffies(rk3308->delay_loopback_handle_ms));
+ } else if (cmd == SNDRV_PCM_TRIGGER_STOP) {
+ /*
+ * Switch to dummy bist mode to kick the glitch during disable
+ * ADCs and keep zero input data
+ */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_BIST_SINE);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_BIST_SINE);
+ }
+ rk3308_codec_adc_ana_disable(rk3308, ADC_TYPE_LOOPBACK);
+ }
+ }
+
+ return 0;
+}
+
+static void rk3308_pcm_shutdown(struct snd_pcm_substream *substream,
+ struct snd_soc_dai *dai)
+{
+ struct snd_soc_codec *codec = dai->codec;
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+
+ if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
+ rk3308_codec_close_playback(rk3308);
+ rk3308_codec_dac_mclk_disable(rk3308);
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
+ rk3308_codec_set_dac_path_state(rk3308, PATH_IDLE);
+ } else {
+ rk3308_codec_close_capture(rk3308);
+ if (!has_en_always_grps(rk3308)) {
+ rk3308_codec_adc_mclk_disable(rk3308);
+ rk3308_codec_update_adcs_status(rk3308, PATH_IDLE);
+ if (rk3308->micbias_num &&
+ rk3308->enable_micbias)
+ rk3308_codec_micbias_disable(rk3308);
+ }
+
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
+ }
+}
+
+static struct snd_soc_dai_ops rk3308_dai_ops = {
+ .hw_params = rk3308_hw_params,
+ .set_fmt = rk3308_set_dai_fmt,
+ .mute_stream = rk3308_mute_stream,
+ .trigger = rk3308_pcm_trigger,
+ .shutdown = rk3308_pcm_shutdown,
+};
+
+static struct snd_soc_dai_driver rk3308_dai[] = {
+ {
+ .name = "rk3308-hifi",
+ .id = RK3308_HIFI,
+ .playback = {
+ .stream_name = "HiFi Playback",
+ .channels_min = 2,
+ .channels_max = 2,
+ .rates = SNDRV_PCM_RATE_8000_192000,
+ .formats = (SNDRV_PCM_FMTBIT_S16_LE |
+ SNDRV_PCM_FMTBIT_S20_3LE |
+ SNDRV_PCM_FMTBIT_S24_LE |
+ SNDRV_PCM_FMTBIT_S32_LE),
+ },
+ .capture = {
+ .stream_name = "HiFi Capture",
+ .channels_min = 1,
+ .channels_max = 8,
+ .rates = SNDRV_PCM_RATE_8000_192000,
+ .formats = (SNDRV_PCM_FMTBIT_S16_LE |
+ SNDRV_PCM_FMTBIT_S20_3LE |
+ SNDRV_PCM_FMTBIT_S24_LE |
+ SNDRV_PCM_FMTBIT_S32_LE),
+ },
+ .ops = &rk3308_dai_ops,
+ },
+};
+
+static int rk3308_suspend(struct snd_soc_codec *codec)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+
+ if (rk3308->no_deep_low_power)
+ goto out;
+
+ rk3308_codec_dlp_down(rk3308);
+ clk_disable_unprepare(rk3308->mclk_rx);
+ clk_disable_unprepare(rk3308->mclk_tx);
+ clk_disable_unprepare(rk3308->pclk);
+
+out:
+ rk3308_set_bias_level(codec, SND_SOC_BIAS_OFF);
+ return 0;
+}
+
+static int rk3308_resume(struct snd_soc_codec *codec)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ int ret = 0;
+
+ if (rk3308->no_deep_low_power)
+ goto out;
+
+ ret = clk_prepare_enable(rk3308->pclk);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable acodec pclk: %d\n", ret);
+ goto out;
+ }
+
+ ret = clk_prepare_enable(rk3308->mclk_rx);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable i2s mclk_rx: %d\n", ret);
+ goto out;
+ }
+
+ ret = clk_prepare_enable(rk3308->mclk_tx);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to enable i2s mclk_tx: %d\n", ret);
+ goto out;
+ }
+
+ rk3308_codec_dlp_up(rk3308);
+out:
+ rk3308_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+ return ret;
+}
+
+static int rk3308_codec_default_gains(struct rk3308_codec_priv *rk3308)
+{
+ int grp;
+
+ /* Prepare ADC gains */
+ /* vendor step 12, set MIC PGA default gains */
+ for (grp = 0; grp < ADC_LR_GROUP_MAX; grp++) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON01(grp),
+ RK3308_ADC_CH1_MIC_GAIN_MSK |
+ RK3308_ADC_CH2_MIC_GAIN_MSK,
+ RK3308_ADC_CH1_MIC_GAIN_0DB |
+ RK3308_ADC_CH2_MIC_GAIN_0DB);
+ }
+
+ /* vendor step 13, set ALC default gains */
+ for (grp = 0; grp < ADC_LR_GROUP_MAX; grp++) {
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON03(grp),
+ RK3308_ADC_CH1_ALC_GAIN_MSK,
+ RK3308_ADC_CH1_ALC_GAIN_0DB);
+ regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON04(grp),
+ RK3308_ADC_CH2_ALC_GAIN_MSK,
+ RK3308_ADC_CH2_ALC_GAIN_0DB);
+ }
+
+ /* Prepare DAC gains */
+ /* Step 15, set HPMIX default gains */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON12,
+ RK3308_DAC_L_HPMIX_GAIN_MSK |
+ RK3308_DAC_R_HPMIX_GAIN_MSK,
+ RK3308_DAC_L_HPMIX_GAIN_NDB_6 |
+ RK3308_DAC_R_HPMIX_GAIN_NDB_6);
+
+ /* Step 18, set HPOUT default gains */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON05,
+ RK3308_DAC_L_HPOUT_GAIN_MSK,
+ RK3308_DAC_L_HPOUT_GAIN_NDB_39);
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON06,
+ RK3308_DAC_R_HPOUT_GAIN_MSK,
+ RK3308_DAC_R_HPOUT_GAIN_NDB_39);
+
+ /* Using the same gain to HPOUT LR channels */
+ rk3308->hpout_l_dgain = RK3308_DAC_L_HPOUT_GAIN_NDB_39;
+
+ /* Step 19, set LINEOUT default gains */
+ regmap_update_bits(rk3308->regmap, RK3308_DAC_ANA_CON04,
+ RK3308_DAC_L_LINEOUT_GAIN_MSK |
+ RK3308_DAC_R_LINEOUT_GAIN_MSK,
+ RK3308_DAC_L_LINEOUT_GAIN_NDB_6 |
+ RK3308_DAC_R_LINEOUT_GAIN_NDB_6);
+
+ return 0;
+}
+
+static int rk3308_codec_setup_en_always_adcs(struct rk3308_codec_priv *rk3308,
+ struct device_node *np)
+{
+ int num, ret;
+
+ num = of_count_phandle_with_args(np, "rockchip,en-always-grps", NULL);
+ if (num < 0) {
+ if (num == -ENOENT) {
+ /*
+ * If there is note use 'rockchip,en-always-grps'
+ * property, return 0 is also right.
+ */
+ ret = 0;
+ } else {
+ dev_err(rk3308->plat_dev,
+ "Failed to read 'rockchip,adc-grps-route' num: %d\n",
+ num);
+ ret = num;
+ }
+
+ rk3308->en_always_grps_num = 0;
+ return ret;
+ }
+
+ rk3308->en_always_grps_num = num;
+
+ ret = of_property_read_u32_array(np, "rockchip,en-always-grps",
+ rk3308->en_always_grps, num);
+ if (ret < 0) {
+ dev_err(rk3308->plat_dev,
+ "Failed to read 'rockchip,en-always-grps': %d\n",
+ ret);
+ return ret;
+ }
+
+ /* Clear all of skip_grps flags. */
+ for (num = 0; num < ADC_LR_GROUP_MAX; num++)
+ rk3308->skip_grps[num] = 0;
+
+ /* The loopback grp should not be enabled always. */
+ for (num = 0; num < rk3308->en_always_grps_num; num++) {
+ if (rk3308->en_always_grps[num] == rk3308->loopback_grp) {
+ dev_err(rk3308->plat_dev,
+ "loopback_grp: %d should not be enabled always!\n",
+ rk3308->loopback_grp);
+ ret = -EINVAL;
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_dapm_mic_gains(struct rk3308_codec_priv *rk3308)
+{
+ int ret;
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ ret = snd_soc_add_codec_controls(rk3308->codec,
+ mic_gains_b,
+ ARRAY_SIZE(mic_gains_b));
+ if (ret) {
+ dev_err(rk3308->plat_dev,
+ "%s: add mic_gains_b failed: %d\n",
+ __func__, ret);
+ return ret;
+ }
+ } else {
+ ret = snd_soc_add_codec_controls(rk3308->codec,
+ mic_gains_a,
+ ARRAY_SIZE(mic_gains_a));
+ if (ret) {
+ dev_err(rk3308->plat_dev,
+ "%s: add mic_gains_a failed: %d\n",
+ __func__, ret);
+ return ret;
+ }
+ }
+
+ return 0;
+}
+
+static int rk3308_codec_check_micbias(struct rk3308_codec_priv *rk3308,
+ struct device_node *np)
+{
+ struct device *dev = (struct device *)rk3308->plat_dev;
+ int num = 0, ret;
+
+ /* Check internal micbias */
+ rk3308->micbias1 =
+ of_property_read_bool(np, "rockchip,micbias1");
+ if (rk3308->micbias1)
+ num++;
+
+ rk3308->micbias2 =
+ of_property_read_bool(np, "rockchip,micbias2");
+ if (rk3308->micbias2)
+ num++;
+
+ rk3308->micbias_volt = RK3308_ADC_MICBIAS_VOLT_0_85; /* by default */
+ rk3308->micbias_num = num;
+
+ /* Check external micbias */
+ rk3308->ext_micbias = EXT_MICBIAS_NONE;
+
+ rk3308->micbias_en_gpio = devm_gpiod_get_optional(dev,
+ "micbias-en",
+ GPIOD_IN);
+ if (!rk3308->micbias_en_gpio) {
+ dev_info(dev, "Don't need micbias-en gpio\n");
+ } else if (IS_ERR(rk3308->micbias_en_gpio)) {
+ ret = PTR_ERR(rk3308->micbias_en_gpio);
+ dev_err(dev, "Unable to claim gpio micbias-en\n");
+ return ret;
+ } else if (gpiod_get_value(rk3308->micbias_en_gpio)) {
+ rk3308->ext_micbias = EXT_MICBIAS_FUNC1;
+ }
+
+ rk3308->vcc_micbias = devm_regulator_get_optional(dev,
+ "vmicbias");
+ if (IS_ERR(rk3308->vcc_micbias)) {
+ if (PTR_ERR(rk3308->vcc_micbias) == -EPROBE_DEFER)
+ return -EPROBE_DEFER;
+ dev_info(dev, "no vmicbias regulator found\n");
+ } else {
+ ret = regulator_enable(rk3308->vcc_micbias);
+ if (ret) {
+ dev_err(dev, "Can't enable vmicbias: %d\n", ret);
+ return ret;
+ }
+ rk3308->ext_micbias = EXT_MICBIAS_FUNC2;
+ }
+
+ dev_info(dev, "Check ext_micbias: %d\n", rk3308->ext_micbias);
+
+ return 0;
+}
+
+static int rk3308_codec_dapm_controls_prepare(struct rk3308_codec_priv *rk3308)
+{
+ int grp;
+
+ for (grp = 0; grp < ADC_LR_GROUP_MAX; grp++) {
+ rk3308->hpf_cutoff[grp] = 0;
+ rk3308->agc_l[grp] = 0;
+ rk3308->agc_r[grp] = 0;
+ rk3308->agc_asr_l[grp] = AGC_ASR_96KHZ;
+ rk3308->agc_asr_r[grp] = AGC_ASR_96KHZ;
+ }
+
+ rk3308_codec_dapm_mic_gains(rk3308);
+
+ return 0;
+}
+
+static int rk3308_codec_prepare(struct rk3308_codec_priv *rk3308)
+{
+ /* Clear registers for ADC and DAC */
+ rk3308_codec_close_playback(rk3308);
+ rk3308_codec_close_all_capture(rk3308);
+ rk3308_codec_default_gains(rk3308);
+ rk3308_codec_llp_down(rk3308);
+ rk3308_codec_dapm_controls_prepare(rk3308);
+
+ return 0;
+}
+
+static int rk3308_probe(struct snd_soc_codec *codec)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ int ext_micbias;
+
+ rk3308->codec = codec;
+ rk3308_codec_set_dac_path_state(rk3308, PATH_IDLE);
+
+ rk3308_codec_reset(codec);
+ rk3308_codec_power_on(rk3308);
+
+ /* From vendor recommend, disable micbias at first. */
+ ext_micbias = rk3308->ext_micbias;
+ rk3308->ext_micbias = EXT_MICBIAS_NONE;
+ rk3308_codec_micbias_disable(rk3308);
+ rk3308->ext_micbias = ext_micbias;
+
+ rk3308_codec_prepare(rk3308);
+ if (!rk3308->no_hp_det)
+ rk3308_codec_headset_detect_enable(rk3308);
+
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
+
+ return 0;
+}
- /* 5. Wait until the voltage of VCM keeps stable at the AGND */
- usleep_range(200, 300); /* estimated value */
+static int rk3308_remove(struct snd_soc_codec *codec)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+
+ rk3308_headphone_ctl(rk3308, 0);
+ rk3308_speaker_ctl(rk3308, 0);
+ if (!rk3308->no_hp_det)
+ rk3308_codec_headset_detect_disable(rk3308);
+ rk3308_codec_micbias_disable(rk3308);
+ rk3308_codec_power_off(rk3308);
- /* 6. Power off the analog power supply */
- /* 7. Power off the digital power supply */
+ rk3308_codec_set_dac_path_state(rk3308, PATH_IDLE);
- /* Do something via hardware */
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
return 0;
}
-static int check_micbias(int micbias)
+static struct snd_soc_codec_driver soc_codec_dev_rk3308 = {
+ .probe = rk3308_probe,
+ .remove = rk3308_remove,
+ .suspend = rk3308_suspend,
+ .resume = rk3308_resume,
+ .set_bias_level = rk3308_set_bias_level,
+ .controls = rk3308_codec_dapm_controls,
+ .num_controls = ARRAY_SIZE(rk3308_codec_dapm_controls),
+};
+
+static const struct reg_default rk3308_codec_reg_defaults[] = {
+ { RK3308_GLB_CON, 0x07 },
+};
+
+static bool rk3308_codec_write_read_reg(struct device *dev, unsigned int reg)
{
- switch (micbias) {
- case RK3308_ADC_MICBIAS_VOLT_0_85:
- case RK3308_ADC_MICBIAS_VOLT_0_8:
- case RK3308_ADC_MICBIAS_VOLT_0_75:
- case RK3308_ADC_MICBIAS_VOLT_0_7:
- case RK3308_ADC_MICBIAS_VOLT_0_65:
- case RK3308_ADC_MICBIAS_VOLT_0_6:
- case RK3308_ADC_MICBIAS_VOLT_0_55:
- case RK3308_ADC_MICBIAS_VOLT_0_5:
- return 0;
- }
+ /* All registers can be read / write */
+ return true;
+}
- return -EINVAL;
+static bool rk3308_codec_volatile_reg(struct device *dev, unsigned int reg)
+{
+ return true;
}
-static int rk3308_codec_micbias_enable(struct rk3308_codec_priv *rk3308,
- int micbias)
+static void rk3308_codec_hpdetect_work(struct work_struct *work)
{
- int ch = rk3308->adc_ch;
- int ret;
+ struct rk3308_codec_priv *rk3308 =
+ container_of(work, struct rk3308_codec_priv, hpdet_work.work);
+ unsigned int val;
+ int need_poll = 0, need_irq = 0;
+ int need_report = 0, report_type = 0;
+ int dac_output = DAC_LINEOUT;
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ /* Check headphone plugged/unplugged directly. */
+ regmap_read(rk3308->detect_grf,
+ DETECT_GRF_ACODEC_HPDET_STATUS, &val);
+ regmap_write(rk3308->detect_grf,
+ DETECT_GRF_ACODEC_HPDET_STATUS_CLR, val);
+
+ if (rk3308->hp_jack_reversed) {
+ switch (val) {
+ case 0x0:
+ case 0x2:
+ dac_output = DAC_HPOUT;
+ report_type = SND_JACK_HEADPHONE;
+ break;
+ default:
+ break;
+ }
+ } else {
+ switch (val) {
+ case 0x1:
+ dac_output = DAC_HPOUT;
+ report_type = SND_JACK_HEADPHONE;
+ break;
+ default:
+ /* Includes val == 2 or others. */
+ break;
+ }
+ }
- if (ch != 1 && ch != 2) {
- dev_err(rk3308->plat_dev,
- "%s: currnet ch: %d, only ch1/2 control MICBIAS1/2\n",
- __func__, ch);
- return -EINVAL;
- }
+ rk3308_codec_dac_switch(rk3308, dac_output);
+ if (rk3308->hpdet_jack)
+ snd_soc_jack_report(rk3308->hpdet_jack,
+ report_type,
+ SND_JACK_HEADPHONE);
- /* 1. Power up the ACODEC and keep the AVDDH stable */
+ enable_irq(rk3308->irq);
- /* 2. Configure ACODEC_ADC_ANA_CON7[2:0] to the certain value */
- ret = check_micbias(micbias);
- if (ret < 0) {
- dev_err(rk3308->plat_dev, "This is an invalid micbias: %d\n",
- micbias);
- return ret;
+ return;
}
- /*
- * Note: Only the reg (ADC_ANA_CON7+0x0)[2:0] represent the level range
- * control signal of MICBIAS voltage
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(0),
- RK3308_ADC_LEVEL_RANGE_MICBIAS_MSK,
- micbias);
+ /* Check headphone unplugged via poll. */
+ regmap_read(rk3308->regmap, RK3308_DAC_DIG_CON14, &val);
- /* 3. Wait until the VCMH keep stable */
- usleep_range(200, 300); /* estimated value */
+ if (rk3308->hp_jack_reversed) {
+ if (!val) {
+ rk3308->hp_plugged = true;
+ report_type = SND_JACK_HEADPHONE;
- /* 4. Configure ACODEC_ADC_ANA_CON8[4] to 0x1 */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON08(ch),
- RK3308_ADC_MICBIAS_CURRENT_MSK,
- RK3308_ADC_MICBIAS_CURRENT_EN);
+ need_report = 1;
+ need_irq = 1;
+ } else {
+ if (rk3308->hp_plugged) {
+ rk3308->hp_plugged = false;
+ need_report = 1;
+ }
+ need_poll = 1;
+ }
+ } else {
+ if (!val) {
+ rk3308->hp_plugged = false;
- /*
- * 5. Configure the (ADC_ANA_CON7+0x40)[3] or (ADC_ANA_CON7+0x80)[3]
- * to 0x1.
- * (ADC_ANA_CON7+0x40)[3] used to control the MICBIAS1, and
- * (ADC_ANA_CON7+0x80)[3] used to control the MICBIAS2
- */
+ need_report = 1;
+ need_irq = 1;
+ } else {
+ if (!rk3308->hp_plugged) {
+ rk3308->hp_plugged = true;
+ report_type = SND_JACK_HEADPHONE;
+ need_report = 1;
+ }
+ need_poll = 1;
+ }
+ }
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_MIC_BIAS_BUF_EN,
- RK3308_ADC_MIC_BIAS_BUF_EN);
+ if (need_poll)
+ queue_delayed_work(system_power_efficient_wq,
+ &rk3308->hpdet_work,
+ msecs_to_jiffies(HPDET_POLL_MS));
- return 0;
-}
+ if (need_report) {
+ if (report_type)
+ dac_output = DAC_HPOUT;
-static int rk3308_codec_micbias_disable(struct rk3308_codec_priv *rk3308)
-{
- int ch = rk3308->adc_ch;
+ rk3308_codec_dac_switch(rk3308, dac_output);
- if (ch != 1 && ch != 2) {
- dev_err(rk3308->plat_dev,
- "%s: currnet ch: %d, only ch1/2 control MICBIAS1/2\n",
- __func__, ch);
- return -EINVAL;
+ if (rk3308->hpdet_jack)
+ snd_soc_jack_report(rk3308->hpdet_jack,
+ report_type,
+ SND_JACK_HEADPHONE);
}
- /* 1. Enable the MICBIAS and keep the Audio Codec stable */
- /* Do nothing */
-
- /*
- * 2. Configure the (ADC_ANA_CON7+0x40)[3] or
- * (ADC_ANA_CON7+0x80)[3] to 0x0
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_MIC_BIAS_BUF_EN,
- RK3308_ADC_MIC_BIAS_BUF_DIS);
-
- /* 3. Configure ACODEC_ADC_ANA_CON8[4] to 0x0 */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON08(ch),
- RK3308_ADC_MICBIAS_CURRENT_MSK,
- RK3308_ADC_MICBIAS_CURRENT_DIS);
+ if (need_irq)
+ enable_irq(rk3308->irq);
+}
- return 0;
+static void rk3308_codec_loopback_work(struct work_struct *work)
+{
+ struct rk3308_codec_priv *rk3308 =
+ container_of(work, struct rk3308_codec_priv, loopback_work.work);
+ int type = ADC_TYPE_LOOPBACK;
+ int idx, grp;
+
+ /* Prepare loopback ADCs */
+ rk3308_codec_adc_ana_enable(rk3308, type);
+
+ /* Waiting ADCs are stable */
+ msleep(ADC_STABLE_MS);
+
+ /* Recover normal mode after enable ADCs */
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++) {
+ if (grp < 0 || grp > ADC_LR_GROUP_MAX - 1)
+ continue;
+
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_L_CH_BIST_MSK,
+ RK3308_ADC_L_CH_NORMAL_LEFT);
+ regmap_update_bits(rk3308->regmap,
+ RK3308_ADC_DIG_CON03(grp),
+ RK3308_ADC_R_CH_BIST_MSK,
+ RK3308_ADC_R_CH_NORMAL_RIGHT);
+ }
}
-static int rk3308_codec_alc_enable(struct rk3308_codec_priv *rk3308)
+static irqreturn_t rk3308_codec_hpdet_isr(int irq, void *data)
{
- int ch = rk3308->adc_ch;
+ struct rk3308_codec_priv *rk3308 = data;
/*
- * 1. Set he max level and min level of the ALC need to control.
- *
- * These values are estimated
+ * For the high level irq trigger, disable irq and avoid a lot of
+ * repeated irq handlers entry.
*/
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON05(ch),
- RK3308_AGC_LO_8BITS_AGC_MIN_MSK,
- 0x16);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON05(ch),
- RK3308_AGC_HI_8BITS_AGC_MIN_MSK,
- 0x40);
-
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON05(ch),
- RK3308_AGC_LO_8BITS_AGC_MAX_MSK,
- 0x26);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON05(ch),
- RK3308_AGC_HI_8BITS_AGC_MAX_MSK,
- 0x40);
+ disable_irq_nosync(rk3308->irq);
+ queue_delayed_work(system_power_efficient_wq,
+ &rk3308->hpdet_work, msecs_to_jiffies(10));
- /*
- * 2. Set ACODEC_ALC_DIG_CON4[2:0] according to the sample rate
- *
- * By default is 44.1KHz for sample.
- */
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON04(ch),
- RK3308_AGC_APPROX_RATE_MSK,
- RK3308_AGC_APPROX_RATE_44_1K);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON04(ch),
- RK3308_AGC_APPROX_RATE_MSK,
- RK3308_AGC_APPROX_RATE_44_1K);
-
- /* 3. Set ACODEC_ALC_DIG_CON9[6] to 0x1, to enable the ALC module */
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON09(ch),
- RK3308_AGC_FUNC_SEL_MSK,
- RK3308_AGC_FUNC_SEL_EN);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON09(ch),
- RK3308_AGC_FUNC_SEL_MSK,
- RK3308_AGC_FUNC_SEL_EN);
+ return IRQ_HANDLED;
+}
- /*
- * 4. Set ACODEC_ADC_ANA_CON11[1:0], (ACODEC_ADC_ANA_CON11+0x40)[1:0],
- * (ACODEC_ADC_ANA_CON11+0x80)[1:0] and (ACODEC_ADC_ANA_CON11+0xc0)[1:0]
- * to 0x3, to enable the ALC module to control the gain of PGA.
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(ch),
- RK3308_ADC_ALCL_CON_GAIN_PGAL_MSK |
- RK3308_ADC_ALCR_CON_GAIN_PGAR_MSK,
- RK3308_ADC_ALCL_CON_GAIN_PGAL_EN |
- RK3308_ADC_ALCR_CON_GAIN_PGAR_EN);
+void (*rk3308_codec_set_jack_detect_cb)(struct snd_soc_codec *codec,
+ struct snd_soc_jack *hpdet_jack);
+EXPORT_SYMBOL_GPL(rk3308_codec_set_jack_detect_cb);
- /*
- * 5.Observe the current ALC output gain by reading
- * ACODEC_ALC_DIG_CON12[4:0]
- *
- * The default GAIN is 0x0c
- */
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON12(ch),
- RK3308_AGC_GAIN_MSK,
- 0x0c);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON12(ch),
- RK3308_AGC_GAIN_MSK,
- 0x0c);
+static void rk3308_codec_set_jack_detect(struct snd_soc_codec *codec,
+ struct snd_soc_jack *hpdet_jack)
+{
+ struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
- return 0;
-}
+ rk3308->hpdet_jack = hpdet_jack;
-static int rk3308_codec_alc_disable(struct rk3308_codec_priv *rk3308)
-{
- int ch = rk3308->adc_ch;
+ /* To detect jack once during startup */
+ disable_irq_nosync(rk3308->irq);
+ queue_delayed_work(system_power_efficient_wq,
+ &rk3308->hpdet_work, msecs_to_jiffies(10));
- /*
- * 1. Set ACODEC_ALC_DIG_CON9[6] to 0x0, to disable the ALC module,
- * then the ALC output gain will keep to the last value
- */
- regmap_update_bits(rk3308->regmap, RK3308_ALC_L_DIG_CON09(ch),
- RK3308_AGC_FUNC_SEL_MSK,
- RK3308_AGC_FUNC_SEL_DIS);
- regmap_update_bits(rk3308->regmap, RK3308_ALC_R_DIG_CON09(ch),
- RK3308_AGC_FUNC_SEL_MSK,
- RK3308_AGC_FUNC_SEL_DIS);
+ dev_info(rk3308->plat_dev, "%s: Request detect hp jack once\n",
+ __func__);
+}
- /*
- * 2. Set ACODEC_ADC_ANA_CON11[1:0], (ACODEC_ADC_ANA_CON11+0x40)[1:0],
- * (ACODEC_ADC_ANA_CON11+0x80)[1:0] and (ACODEC_ADC_ANA_CON11+0xc0)[1:0]
- * to 0x0, to disable the ALC module to control the gain of PGA.
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON11(ch),
- RK3308_ADC_ALCL_CON_GAIN_PGAL_MSK |
- RK3308_ADC_ALCR_CON_GAIN_PGAR_MSK,
- RK3308_ADC_ALCL_CON_GAIN_PGAL_DIS |
- RK3308_ADC_ALCR_CON_GAIN_PGAR_DIS);
+static const struct regmap_config rk3308_codec_regmap_config = {
+ .reg_bits = 32,
+ .reg_stride = 4,
+ .val_bits = 32,
+ .max_register = RK3308_DAC_ANA_CON15,
+ .writeable_reg = rk3308_codec_write_read_reg,
+ .readable_reg = rk3308_codec_write_read_reg,
+ .volatile_reg = rk3308_codec_volatile_reg,
+ .reg_defaults = rk3308_codec_reg_defaults,
+ .num_reg_defaults = ARRAY_SIZE(rk3308_codec_reg_defaults),
+ .cache_type = REGCACHE_FLAT,
+};
- return 0;
+static ssize_t pm_state_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+
+ return sprintf(buf, "pm_state: %d\n", rk3308->pm_state);
}
-static int rk3308_codec_adc_ana_enable(struct rk3308_codec_priv *rk3308)
+static ssize_t pm_state_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- unsigned int adc_aif1 = 0, adc_aif2 = 0;
- unsigned int agc_func_en;
- int ch = rk3308->adc_ch;
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ unsigned long pm_state;
+ int ret = kstrtoul(buf, 10, &pm_state);
- /*
- * 1. Set the ACODEC_ADC_ANA_CON7[7:6] and ACODEC_ADC_ANA_CON7[5:4],
- * to select the line-in or microphone as input of ADC
- *
- * Note1. Please ignore the step1 for enabling ADC3, ADC4, ADC5,
- * ADC6, ADC7, and ADC8
- */
- if (ch == 0) {
- if (rk3308->adc_ch0_using_linein) {
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_CH1_IN_SEL_MSK,
- RK3308_ADC_CH1_IN_LINEIN);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_CH2_IN_SEL_MSK,
- RK3308_ADC_CH2_IN_LINEIN);
- } else {
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_CH1_IN_SEL_MSK,
- RK3308_ADC_CH1_IN_MIC);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON07(ch),
- RK3308_ADC_CH2_IN_SEL_MSK,
- RK3308_ADC_CH2_IN_MIC);
- }
+ if (ret < 0) {
+ dev_err(dev, "Invalid pm_state: %ld, ret: %d\n",
+ pm_state, ret);
+ return -EINVAL;
}
- /*
- * 2. Set ACODEC_ADC_ANA_CON0[7:0] to 0xff, to end the mute station
- * of ADC, to enable the MIC module, to enable the reference voltage
- * buffer, and to end the initialization of MIC
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(ch),
- RK3308_ADC_CH1_CH2_MIC_ALL_MSK,
- RK3308_ADC_CH1_CH2_MIC_ALL);
+ rk3308_codec_set_pm_state(rk3308, pm_state);
- /*
- * 3. Set ACODEC_ADC_ANA_CON6[0] to 0x1, to enable the current source
- * of audio
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON06(ch),
- RK3308_ADC_CURRENT_MSK,
- RK3308_ADC_CURRENT_EN);
+ dev_info(dev, "Store pm_state: %d\n", rk3308->pm_state);
- /*
- * 4. Set ACODEC_ADC_ANA_CON2[7:0] to 0x77, to enable the ALC module,
- * to enable the zero-crossing detection function, and to end the
- * initialization of ALC
- *
- * Note2. Please set ACODEC_ADC_ANA_CON2[7:0] to 0x33 in step4
- * if the AGC function is closed
- */
+ return count;
+}
- adc_aif1 = RK3308_ADC_CH1_ALC_EN | RK3308_ADC_CH1_ALC_WORK;
- regmap_read(rk3308->regmap, RK3308_ALC_L_DIG_CON09(ch), &agc_func_en);
- if (agc_func_en & RK3308_AGC_FUNC_SEL_EN)
- adc_aif1 |= RK3308_ADC_CH1_ZEROCROSS_DET_EN;
+static ssize_t adc_grps_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ u32 grp;
+ int type = ADC_TYPE_NORMAL, count = 0;
+ int idx;
+
+ count += sprintf(buf + count, "current used adc_grps:\n");
+ count += sprintf(buf + count, "- normal:");
+ for (idx = 0; adc_for_each_grp(rk3308, type, idx, &grp); idx++)
+ count += sprintf(buf + count, " %d", grp);
+ count += sprintf(buf + count, "\n");
+ count += sprintf(buf + count, "- loopback: %d\n",
+ rk3308->loopback_grp);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(ch),
- RK3308_ADC_CH1_ALC_ZC_MSK,
- adc_aif1);
+ return count;
+}
- adc_aif2 = RK3308_ADC_CH2_ALC_EN | RK3308_ADC_CH2_ALC_WORK;
- regmap_read(rk3308->regmap, RK3308_ALC_L_DIG_CON09(ch), &agc_func_en);
- if (agc_func_en & RK3308_AGC_FUNC_SEL_EN)
- adc_aif2 |= RK3308_ADC_CH2_ZEROCROSS_DET_EN;
+static ssize_t adc_grps_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
+{
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ char adc_type;
+ int grps, ret;
+
+ ret = sscanf(buf, "%c,%d", &adc_type, &grps);
+ if (ret != 2) {
+ dev_err(rk3308->plat_dev, "%s sscanf failed: %d\n",
+ __func__, ret);
+ return -EFAULT;
+ }
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(ch),
- RK3308_ADC_CH2_ALC_ZC_MSK,
- adc_aif2);
+ if (adc_type == 'n')
+ rk3308->used_adc_grps = grps;
+ else if (adc_type == 'l')
+ rk3308->loopback_grp = grps;
- /*
- * 5. Set ACODEC_ADC_ANA_CON5[7:0] to 0x77, to enable the clock and
- * ADC module, and to end the initialization of ADC
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH1_ADC_CLK_MSK,
- RK3308_ADC_CH1_CLK_EN |
- RK3308_ADC_CH1_ADC_EN |
- RK3308_ADC_CH1_ADC_WORK);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH2_ADC_CLK_MSK,
- RK3308_ADC_CH2_CLK_EN |
- RK3308_ADC_CH2_ADC_EN |
- RK3308_ADC_CH2_ADC_WORK);
+ return count;
+}
- /*
- * 6. Set ACODEC_ADC_ANA_CON1[5:4] and ACODEC_ADC_ANA_CON1[1:0],
- * to select the gain of the MIC
- *
- * By default is 0db.
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH1_MIC_GAIN_MSK,
- RK3308_ADC_CH1_MIC_GAIN_0DB);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH2_MIC_GAIN_MSK,
- RK3308_ADC_CH2_MIC_GAIN_0DB);
+static ssize_t adc_grps_route_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
+{
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ char which_i2s[32] = {0};
+ int count = 0;
+ u32 grp;
- /*
- * 7.Set ACODEC_ADC_ANA_CON3[4:0] and ACODEC_ADC_ANA_CON4[3:0] to
- * select the gain of ALC
- *
- * By default is 0db.
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON03(ch),
- RK3308_ADC_CH1_ALC_GAIN_MSK,
- RK3308_ADC_CH1_ALC_GAIN_0DB);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON04(ch),
- RK3308_ADC_CH2_ALC_GAIN_MSK,
- RK3308_ADC_CH2_ALC_GAIN_0DB);
+ switch (rk3308->which_i2s) {
+ case ACODEC_TO_I2S1_2CH:
+ strcpy(which_i2s, "i2s1_2ch");
+ break;
+ case ACODEC_TO_I2S3_4CH:
+ strcpy(which_i2s, "i2s3_4ch");
+ break;
+ default:
+ strcpy(which_i2s, "i2s2_8ch");
+ break;
+ }
- /* 8.Begin recording */
+ count += sprintf(buf + count, "%s from acodec route mapping:\n",
+ which_i2s);
+ for (grp = 0; grp < rk3308->to_i2s_grps; grp++) {
+ count += sprintf(buf + count, "* sdi_%d <-- sdo_%d\n",
+ grp, rk3308->i2s_sdis[grp]);
+ }
- return 0;
+ return count;
}
-static int rk3308_codec_adc_ana_disable(struct rk3308_codec_priv *rk3308)
+static ssize_t adc_grps_route_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- int ch = rk3308->adc_ch;
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ int which_i2s, idx, i2s_sdis[ADC_LR_GROUP_MAX];
+ int ret;
- /*
- * 1. Set ACODEC_ADC_ANA_CON2[7:0] to 0x0, to disable the ALC module,
- * to disable the zero-crossing detection function, and to begin the
- * initialization of ALC
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(ch),
- RK3308_ADC_CH1_ALC_ZC_MSK,
- 0);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON02(ch),
- RK3308_ADC_CH2_ALC_ZC_MSK,
- 0);
+ ret = sscanf(buf, "%d,%d,%d,%d,%d", &which_i2s,
+ &i2s_sdis[0], &i2s_sdis[1], &i2s_sdis[2], &i2s_sdis[3]);
+ if (ret != 5) {
+ dev_err(rk3308->plat_dev, "%s sscanf failed: %d\n",
+ __func__, ret);
+ goto err;
+ }
- /*
- * 2. Set ACODEC_ADC_ANA_CON5[7:0] to 0x0, to disable the clock and
- * ADC module, and to begin the initialization of ADC
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH1_ADC_CLK_MSK,
- 0);
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON05(ch),
- RK3308_ADC_CH2_ADC_CLK_MSK,
- 0);
+ if (which_i2s < ACODEC_TO_I2S2_8CH ||
+ which_i2s > ACODEC_TO_I2S1_2CH) {
+ dev_err(rk3308->plat_dev, "Invalid i2s type: %d\n", which_i2s);
+ goto err;
+ }
- /*
- * 3. Set ACODEC_ADC_ANA_CON0[7:0] to 0x88, to disable the MIC module,
- * to disable the reference voltage buffer, and to begin the
- * initialization of MIC
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON00(ch),
- RK3308_ADC_CH1_CH2_MIC_ALL_MSK,
- RK3308_ADC_CH1_MIC_UNMUTE |
- RK3308_ADC_CH2_MIC_UNMUTE);
+ rk3308->which_i2s = which_i2s;
- /*
- * 4. Set ACODEC_ADC_ANA_CON6[0] to 0x0, to disable the current
- * source of audio
- */
- regmap_update_bits(rk3308->regmap, RK3308_ADC_ANA_CON06(ch),
- RK3308_ADC_CURRENT_MSK,
- RK3308_ADC_CURRENT_DIS);
+ switch (rk3308->which_i2s) {
+ case ACODEC_TO_I2S1_2CH:
+ rk3308->to_i2s_grps = 1;
+ break;
+ case ACODEC_TO_I2S3_4CH:
+ rk3308->to_i2s_grps = 2;
+ break;
+ default:
+ rk3308->to_i2s_grps = 4;
+ break;
+ }
- return 0;
+ for (idx = 0; idx < rk3308->to_i2s_grps; idx++)
+ rk3308->i2s_sdis[idx] = i2s_sdis[idx];
+
+ rk3308_codec_adc_grps_route_config(rk3308);
+
+err:
+ return count;
}
-static int rk3308_codec_open_capture(struct snd_soc_codec *codec)
+static ssize_t adc_grp0_in_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
-
- rk3308_codec_alc_enable(rk3308);
- rk3308_codec_adc_ana_enable(rk3308);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
- return 0;
+ return sprintf(buf, "adc ch0 using: %s\n",
+ rk3308->adc_grp0_using_linein ? "line in" : "mic in");
}
-static int rk3308_codec_close_capture(struct snd_soc_codec *codec)
+static ssize_t adc_grp0_in_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ unsigned long using_linein;
+ int ret = kstrtoul(buf, 10, &using_linein);
+
+ if (ret < 0 || using_linein > 1) {
+ dev_err(dev, "Invalid input status: %ld, ret: %d\n",
+ using_linein, ret);
+ return -EINVAL;
+ }
- rk3308_codec_alc_disable(rk3308);
- rk3308_codec_adc_ana_disable(rk3308);
+ rk3308->adc_grp0_using_linein = using_linein;
- return 0;
+ dev_info(dev, "store using_linein: %d\n",
+ rk3308->adc_grp0_using_linein);
+
+ return count;
}
-static int rk3308_codec_open_playback(struct snd_soc_codec *codec)
+static ssize_t adc_zerocross_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
-
- rk3308_codec_dac_enable(rk3308);
- rk3308_speaker_ctl(rk3308, 1);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
- return 0;
+ return sprintf(buf, "adc zerocross: %s\n",
+ rk3308->adc_zerocross ? "enabled" : "disabled");
}
-static int rk3308_codec_close_playback(struct snd_soc_codec *codec)
+static ssize_t adc_zerocross_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ unsigned long zerocross;
+ int ret = kstrtoul(buf, 10, &zerocross);
- rk3308_speaker_ctl(rk3308, 0);
- rk3308_codec_dac_disable(rk3308);
+ if (ret < 0 || zerocross > 1) {
+ dev_err(dev, "Invalid zerocross: %ld, ret: %d\n",
+ zerocross, ret);
+ return -EINVAL;
+ }
- return 0;
+ rk3308->adc_zerocross = zerocross;
+
+ dev_info(dev, "store adc zerocross: %d\n", rk3308->adc_zerocross);
+
+ return count;
}
-static int rk3308_pcm_startup(struct snd_pcm_substream *substream,
- struct snd_soc_dai *dai)
+static ssize_t adc_grps_endisable_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
- struct snd_soc_codec *codec = dai->codec;
- int ret = 0;
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ int count = 0, i;
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
- ret = rk3308_codec_open_playback(codec);
- else
- ret = rk3308_codec_open_capture(codec);
+ count += sprintf(buf + count, "enabled adc grps:");
+ for (i = 0; i < ADC_LR_GROUP_MAX; i++)
+ count += sprintf(buf + count, "%d ",
+ rk3308->adc_grps_endisable[i]);
- return ret;
+ count += sprintf(buf + count, "\n");
+ return count;
}
-static void rk3308_pcm_shutdown(struct snd_pcm_substream *substream,
- struct snd_soc_dai *dai)
+static ssize_t adc_grps_endisable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- struct snd_soc_codec *codec = dai->codec;
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ int grp, endisable, ret;
- if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
- rk3308_codec_close_playback(codec);
- else
- rk3308_codec_close_capture(codec);
-}
+ ret = sscanf(buf, "%d,%d", &grp, &endisable);
+ if (ret != 2) {
+ dev_err(rk3308->plat_dev, "%s sscanf failed: %d\n",
+ __func__, ret);
+ return -EFAULT;
+ }
-static struct snd_soc_dai_ops rk3308_dai_ops = {
- .hw_params = rk3308_hw_params,
- .set_fmt = rk3308_set_dai_fmt,
- .digital_mute = rk3308_digital_mute,
- .startup = rk3308_pcm_startup,
- .shutdown = rk3308_pcm_shutdown,
-};
+ rk3308->cur_dbg_grp = grp;
-static struct snd_soc_dai_driver rk3308_dai[] = {
- {
- .name = "rk3308-hifi",
- .id = RK3308_HIFI,
- .playback = {
- .stream_name = "HiFi Playback",
- .channels_min = 2,
- .channels_max = 2,
- .rates = SNDRV_PCM_RATE_8000_96000,
- .formats = (SNDRV_PCM_FMTBIT_S16_LE |
- SNDRV_PCM_FMTBIT_S20_3LE |
- SNDRV_PCM_FMTBIT_S24_LE |
- SNDRV_PCM_FMTBIT_S32_LE),
- },
- .capture = {
- .stream_name = "HiFi Capture",
- .channels_min = 1,
- .channels_max = 8,
- .rates = SNDRV_PCM_RATE_8000_96000,
- .formats = (SNDRV_PCM_FMTBIT_S16_LE |
- SNDRV_PCM_FMTBIT_S20_3LE |
- SNDRV_PCM_FMTBIT_S24_LE |
- SNDRV_PCM_FMTBIT_S32_LE),
- },
- .ops = &rk3308_dai_ops,
- },
-};
+ if (endisable)
+ rk3308_codec_open_dbg_capture(rk3308);
+ else
+ rk3308_codec_close_dbg_capture(rk3308);
-static int rk3308_suspend(struct snd_soc_codec *codec)
-{
- rk3308_set_bias_level(codec, SND_SOC_BIAS_OFF);
+ dev_info(dev, "ADC grp %d endisable: %d\n", grp, endisable);
- return 0;
+ return count;
}
-static int rk3308_resume(struct snd_soc_codec *codec)
+static ssize_t dac_endisable_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
- rk3308_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
- return 0;
+ return sprintf(buf, "%d\n", rk3308->dac_endisable);
}
-static int rk3308_probe(struct snd_soc_codec *codec)
+static ssize_t dac_endisable_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ unsigned long endisable;
+ int ret = kstrtoul(buf, 10, &endisable);
- rk3308_codec_reset(codec);
- rk3308_codec_power_on(codec);
+ if (ret < 0) {
+ dev_err(dev, "Invalid endisable: %ld, ret: %d\n",
+ endisable, ret);
+ return -EINVAL;
+ }
+
+ if (endisable)
+ rk3308_codec_open_playback(rk3308);
+ else
+ rk3308_codec_close_playback(rk3308);
- rk3308_codec_micbias_enable(rk3308, RK3308_ADC_MICBIAS_VOLT_0_7);
+ dev_info(dev, "DAC endisable: %ld\n", endisable);
- return 0;
+ return count;
}
-static int rk3308_remove(struct snd_soc_codec *codec)
+static ssize_t dac_output_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
- struct rk3308_codec_priv *rk3308 = snd_soc_codec_get_drvdata(codec);
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ ssize_t ret = 0;
- rk3308_speaker_ctl(rk3308, 0);
- rk3308_codec_micbias_disable(rk3308);
- rk3308_codec_power_off(codec);
+ switch (rk3308->dac_output) {
+ case DAC_LINEOUT:
+ ret = sprintf(buf, "dac path: %s\n", "line out");
+ break;
+ case DAC_HPOUT:
+ ret = sprintf(buf, "dac path: %s\n", "hp out");
+ break;
+ case DAC_LINEOUT_HPOUT:
+ ret = sprintf(buf, "dac path: %s\n",
+ "both line out and hp out");
+ break;
+ default:
+ pr_err("Invalid dac path: %d ?\n", rk3308->dac_output);
+ break;
+ }
- return 0;
+ return ret;
}
-static struct snd_soc_codec_driver soc_codec_dev_rk3308 = {
- .probe = rk3308_probe,
- .remove = rk3308_remove,
- .suspend = rk3308_suspend,
- .resume = rk3308_resume,
- .set_bias_level = rk3308_set_bias_level,
- .controls = rk3308_codec_dapm_controls,
- .num_controls = ARRAY_SIZE(rk3308_codec_dapm_controls),
-};
-
-static const struct reg_default rk3308_codec_reg_defaults[] = {
- { RK3308_GLB_CON, 0x07 },
-};
-
-static bool rk3308_codec_write_read_reg(struct device *dev, unsigned int reg)
+static ssize_t dac_output_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
- /* All registers can be read / write */
- return true;
-}
+ struct rk3308_codec_priv *rk3308 =
+ container_of(dev, struct rk3308_codec_priv, dev);
+ unsigned long dac_output;
+ int ret = kstrtoul(buf, 10, &dac_output);
-static bool rk3308_codec_volatile_reg(struct device *dev, unsigned int reg)
-{
- switch (reg) {
- case RK3308_GLB_CON:
- return true;
- default:
- return false;
+ if (ret < 0) {
+ dev_err(dev, "Invalid input status: %ld, ret: %d\n",
+ dac_output, ret);
+ return -EINVAL;
}
-}
-static const struct regmap_config rk3308_codec_regmap_config = {
- .reg_bits = 32,
- .reg_stride = 4,
- .val_bits = 32,
- .max_register = RK3308_DAC_ANA_CON13,
- .writeable_reg = rk3308_codec_write_read_reg,
- .readable_reg = rk3308_codec_write_read_reg,
- .volatile_reg = rk3308_codec_volatile_reg,
- .reg_defaults = rk3308_codec_reg_defaults,
- .num_reg_defaults = ARRAY_SIZE(rk3308_codec_reg_defaults),
- .cache_type = REGCACHE_FLAT,
-};
+ rk3308_codec_dac_switch(rk3308, dac_output);
-static ssize_t adc_ch_show(struct device *dev,
- struct device_attribute *attr,
- char *buf)
+ dev_info(dev, "Store dac_output: %d\n", rk3308->dac_output);
+
+ return count;
+}
+
+static ssize_t enable_all_adcs_show(struct device *dev,
+ struct device_attribute *attr,
+ char *buf)
{
struct rk3308_codec_priv *rk3308 =
container_of(dev, struct rk3308_codec_priv, dev);
- return sprintf(buf, "adc_ch: %d\n", rk3308->adc_ch);
+ return sprintf(buf, "%d\n", rk3308->enable_all_adcs);
}
-static ssize_t adc_ch_store(struct device *dev,
- struct device_attribute *attr,
- const char *buf, size_t count)
+static ssize_t enable_all_adcs_store(struct device *dev,
+ struct device_attribute *attr,
+ const char *buf, size_t count)
{
struct rk3308_codec_priv *rk3308 =
container_of(dev, struct rk3308_codec_priv, dev);
- unsigned long ch;
- int ret = kstrtoul(buf, 10, &ch);
+ unsigned long enable;
+ int ret = kstrtoul(buf, 10, &enable);
- if (ret < 0 || ch > 4) {
- dev_err(dev, "Invalid ch: %ld, ret: %d\n", ch, ret);
+ if (ret < 0) {
+ dev_err(dev, "Invalid enable value: %ld, ret: %d\n",
+ enable, ret);
return -EINVAL;
}
- rk3308->adc_ch = ch;
-
- dev_info(dev, "Store ch: %d\n", rk3308->adc_ch);
+ rk3308->enable_all_adcs = enable;
return count;
}
-static const struct device_attribute adc_ch_attrs[] = {
- __ATTR(adc_ch, 0644, adc_ch_show, adc_ch_store),
+static const struct device_attribute acodec_attrs[] = {
+ __ATTR_RW(adc_grps),
+ __ATTR_RW(adc_grps_endisable),
+ __ATTR_RW(adc_grps_route),
+ __ATTR_RW(adc_grp0_in),
+ __ATTR_RW(adc_zerocross),
+ __ATTR_RW(dac_endisable),
+ __ATTR_RW(dac_output),
+ __ATTR_RW(enable_all_adcs),
+ __ATTR_RW(pm_state),
};
static void rk3308_codec_device_release(struct device *dev)
@@ -1468,8 +4747,8 @@ static int rk3308_codec_sysfs_init(struct platform_device *pdev,
return -ENOMEM;
}
- for (i = 0; i < ARRAY_SIZE(adc_ch_attrs); i++) {
- if (device_create_file(dev, &adc_ch_attrs[i])) {
+ for (i = 0; i < ARRAY_SIZE(acodec_attrs); i++) {
+ if (device_create_file(dev, &acodec_attrs[i])) {
dev_err(&pdev->dev,
"Create 'rk3308-acodec-dev' attr failed\n");
device_unregister(dev);
@@ -1480,32 +4759,136 @@ static int rk3308_codec_sysfs_init(struct platform_device *pdev,
return 0;
}
+#if defined(CONFIG_DEBUG_FS)
+static int rk3308_codec_debugfs_reg_show(struct seq_file *s, void *v)
+{
+ struct rk3308_codec_priv *rk3308 = s->private;
+ unsigned int i;
+ unsigned int val;
+
+ for (i = RK3308_GLB_CON; i <= RK3308_DAC_ANA_CON13; i += 4) {
+ regmap_read(rk3308->regmap, i, &val);
+ if (!(i % 16))
+ seq_printf(s, "\nR:%04x: ", i);
+ seq_printf(s, "%08x ", val);
+ }
+
+ seq_puts(s, "\n");
+
+ return 0;
+}
+
+static ssize_t rk3308_codec_debugfs_reg_operate(struct file *file,
+ const char __user *buf,
+ size_t count, loff_t *ppos)
+{
+ struct rk3308_codec_priv *rk3308 =
+ ((struct seq_file *)file->private_data)->private;
+ unsigned int reg, val;
+ char op;
+ char kbuf[32];
+ int ret;
+
+ if (count >= sizeof(kbuf))
+ return -EINVAL;
+
+ if (copy_from_user(kbuf, buf, count))
+ return -EFAULT;
+ kbuf[count] = '\0';
+
+ ret = sscanf(kbuf, "%c,%x,%x", &op, &reg, &val);
+ if (ret != 3) {
+ pr_err("sscanf failed: %d\n", ret);
+ return -EFAULT;
+ }
+
+ if (op == 'w') {
+ pr_info("Write reg: 0x%04x with val: 0x%08x\n", reg, val);
+ regmap_write(rk3308->regmap, reg, val);
+ regcache_cache_only(rk3308->regmap, false);
+ regcache_sync(rk3308->regmap);
+ pr_info("Read back reg: 0x%04x with val: 0x%08x\n", reg, val);
+ } else if (op == 'r') {
+ regmap_read(rk3308->regmap, reg, &val);
+ pr_info("Read reg: 0x%04x with val: 0x%08x\n", reg, val);
+ } else {
+ pr_err("This is an invalid operation: %c\n", op);
+ }
+
+ return count;
+}
+
+static int rk3308_codec_debugfs_open(struct inode *inode, struct file *file)
+{
+ return single_open(file,
+ rk3308_codec_debugfs_reg_show, inode->i_private);
+}
+
+static const struct file_operations rk3308_codec_reg_debugfs_fops = {
+ .owner = THIS_MODULE,
+ .open = rk3308_codec_debugfs_open,
+ .read = seq_read,
+ .write = rk3308_codec_debugfs_reg_operate,
+ .llseek = seq_lseek,
+ .release = single_release,
+};
+#endif /* CONFIG_DEBUG_FS */
+
+static int rk3308_codec_get_version(struct rk3308_codec_priv *rk3308)
+{
+ unsigned int chip_id;
+
+ regmap_read(rk3308->grf, GRF_CHIP_ID, &chip_id);
+ switch (chip_id) {
+ case 3306:
+ rk3308->codec_ver = ACODEC_VERSION_A;
+ break;
+ case 0x3308:
+ rk3308->codec_ver = ACODEC_VERSION_B;
+ break;
+ default:
+ pr_err("Unknown chip_id: %d / 0x%x\n", chip_id, chip_id);
+ return -EFAULT;
+ }
+
+ pr_info("The acodec version is: %x\n", rk3308->codec_ver);
+ return 0;
+}
+
static int rk3308_platform_probe(struct platform_device *pdev)
{
struct device_node *np = pdev->dev.of_node;
struct rk3308_codec_priv *rk3308;
struct resource *res;
void __iomem *base;
- int ret = 0;
- struct regmap *grf;
-
- grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
- if (IS_ERR(grf)) {
- dev_err(&pdev->dev,
- "Missing 'rockchip,grf' property\n");
- return PTR_ERR(grf);
- }
+ int ret;
rk3308 = devm_kzalloc(&pdev->dev, sizeof(*rk3308), GFP_KERNEL);
if (!rk3308)
return -ENOMEM;
+ rk3308->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
+ if (IS_ERR(rk3308->grf)) {
+ dev_err(&pdev->dev,
+ "Missing 'rockchip,grf' property\n");
+ return PTR_ERR(rk3308->grf);
+ }
+
ret = rk3308_codec_sysfs_init(pdev, rk3308);
if (ret < 0) {
dev_err(&pdev->dev, "Sysfs init failed\n");
return ret;
}
+#if defined(CONFIG_DEBUG_FS)
+ rk3308->dbg_codec = debugfs_create_dir(CODEC_DRV_NAME, NULL);
+ if (IS_ERR(rk3308->dbg_codec))
+ dev_err(&pdev->dev,
+ "Failed to create debugfs dir for rk3308!\n");
+ else
+ debugfs_create_file("reg", 0644, rk3308->dbg_codec,
+ rk3308, &rk3308_codec_reg_debugfs_fops);
+#endif
rk3308->plat_dev = &pdev->dev;
rk3308->reset = devm_reset_control_get(&pdev->dev, "acodec-reset");
@@ -1518,27 +4901,146 @@ static int rk3308_platform_probe(struct platform_device *pdev)
rk3308->reset = NULL;
}
- /* GPIO0_A5 control speaker on RK3308 EVB */
- rk3308->spk_ctl_gpio = devm_gpiod_get_optional(&pdev->dev, "spk_ctl",
- GPIOD_OUT_HIGH);
- if (IS_ERR(rk3308->spk_ctl_gpio)) {
+ rk3308->hp_ctl_gpio = devm_gpiod_get_optional(&pdev->dev, "hp-ctl",
+ GPIOD_OUT_LOW);
+ if (!rk3308->hp_ctl_gpio) {
+ dev_info(&pdev->dev, "Don't need hp-ctl gpio\n");
+ } else if (IS_ERR(rk3308->hp_ctl_gpio)) {
+ ret = PTR_ERR(rk3308->hp_ctl_gpio);
+ dev_err(&pdev->dev, "Unable to claim gpio hp-ctl\n");
+ return ret;
+ }
+
+ rk3308->spk_ctl_gpio = devm_gpiod_get_optional(&pdev->dev, "spk-ctl",
+ GPIOD_OUT_LOW);
+
+ if (!rk3308->spk_ctl_gpio) {
+ dev_info(&pdev->dev, "Don't need spk-ctl gpio\n");
+ } else if (IS_ERR(rk3308->spk_ctl_gpio)) {
ret = PTR_ERR(rk3308->spk_ctl_gpio);
- dev_err(&pdev->dev, "Unable to claim gpio spk_ctl\n");
+ dev_err(&pdev->dev, "Unable to claim gpio spk-ctl\n");
+ return ret;
+ }
+
+ rk3308->pa_drv_gpio = devm_gpiod_get_optional(&pdev->dev, "pa-drv",
+ GPIOD_OUT_LOW);
+
+ if (!rk3308->pa_drv_gpio) {
+ dev_info(&pdev->dev, "Don't need pa-drv gpio\n");
+ } else if (IS_ERR(rk3308->pa_drv_gpio)) {
+ ret = PTR_ERR(rk3308->pa_drv_gpio);
+ dev_err(&pdev->dev, "Unable to claim gpio pa-drv\n");
return ret;
}
+ if (rk3308->pa_drv_gpio) {
+ rk3308->delay_pa_drv_ms = PA_DRV_MS;
+ ret = of_property_read_u32(np, "rockchip,delay-pa-drv-ms",
+ &rk3308->delay_pa_drv_ms);
+ }
+
+#if DEBUG_POP_ALWAYS
+ dev_info(&pdev->dev, "Enable all ctl gpios always for debugging pop\n");
+ rk3308_headphone_ctl(rk3308, 1);
+ rk3308_speaker_ctl(rk3308, 1);
+#else
+ dev_info(&pdev->dev, "De-pop as much as possible\n");
+ rk3308_headphone_ctl(rk3308, 0);
+ rk3308_speaker_ctl(rk3308, 0);
+#endif
+
rk3308->pclk = devm_clk_get(&pdev->dev, "acodec");
if (IS_ERR(rk3308->pclk)) {
dev_err(&pdev->dev, "Can't get acodec pclk\n");
return PTR_ERR(rk3308->pclk);
}
+ rk3308->mclk_rx = devm_clk_get(&pdev->dev, "mclk_rx");
+ if (IS_ERR(rk3308->mclk_rx)) {
+ dev_err(&pdev->dev, "Can't get acodec mclk_rx\n");
+ return PTR_ERR(rk3308->mclk_rx);
+ }
+
+ rk3308->mclk_tx = devm_clk_get(&pdev->dev, "mclk_tx");
+ if (IS_ERR(rk3308->mclk_tx)) {
+ dev_err(&pdev->dev, "Can't get acodec mclk_tx\n");
+ return PTR_ERR(rk3308->mclk_tx);
+ }
+
ret = clk_prepare_enable(rk3308->pclk);
if (ret < 0) {
dev_err(&pdev->dev, "Failed to enable acodec pclk: %d\n", ret);
return ret;
}
+ ret = clk_prepare_enable(rk3308->mclk_rx);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to enable i2s mclk_rx: %d\n", ret);
+ return ret;
+ }
+
+ ret = clk_prepare_enable(rk3308->mclk_tx);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to enable i2s mclk_tx: %d\n", ret);
+ return ret;
+ }
+
+ rk3308_codec_check_micbias(rk3308, np);
+
+ rk3308->enable_all_adcs =
+ of_property_read_bool(np, "rockchip,enable-all-adcs");
+
+ rk3308->hp_jack_reversed =
+ of_property_read_bool(np, "rockchip,hp-jack-reversed");
+
+ rk3308->no_deep_low_power =
+ of_property_read_bool(np, "rockchip,no-deep-low-power");
+
+ rk3308->no_hp_det =
+ of_property_read_bool(np, "rockchip,no-hp-det");
+
+ rk3308->delay_loopback_handle_ms = LOOPBACK_HANDLE_MS;
+ ret = of_property_read_u32(np, "rockchip,delay-loopback-handle-ms",
+ &rk3308->delay_loopback_handle_ms);
+
+ rk3308->delay_start_play_ms = 0;
+ ret = of_property_read_u32(np, "rockchip,delay-start-play-ms",
+ &rk3308->delay_start_play_ms);
+
+ rk3308->loopback_grp = NOT_USED;
+ ret = of_property_read_u32(np, "rockchip,loopback-grp",
+ &rk3308->loopback_grp);
+ /*
+ * If there is no loopback on some board, the -EINVAL indicates that
+ * we don't need add the node, and it is not an error.
+ */
+ if (ret < 0 && ret != -EINVAL) {
+ dev_err(&pdev->dev, "Failed to read loopback property: %d\n",
+ ret);
+ return ret;
+ }
+
+ ret = rk3308_codec_adc_grps_route(rk3308, np);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to route ADC groups: %d\n",
+ ret);
+ return ret;
+ }
+
+ ret = rk3308_codec_setup_en_always_adcs(rk3308, np);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to setup enabled always ADCs: %d\n",
+ ret);
+ return ret;
+ }
+
+ ret = rk3308_codec_get_version(rk3308);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to get acodec version: %d\n",
+ ret);
+ return ret;
+ }
+
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
base = devm_ioremap_resource(&pdev->dev, res);
if (IS_ERR(base)) {
@@ -1555,10 +5057,65 @@ static int rk3308_platform_probe(struct platform_device *pdev)
goto failed;
}
+ if (!rk3308->no_hp_det) {
+ int index = 0;
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B)
+ index = 1;
+
+ rk3308->irq = platform_get_irq(pdev, index);
+ if (rk3308->irq < 0) {
+ dev_err(&pdev->dev, "Can not get codec irq\n");
+ goto failed;
+ }
+
+ INIT_DELAYED_WORK(&rk3308->hpdet_work, rk3308_codec_hpdetect_work);
+
+ ret = devm_request_irq(&pdev->dev, rk3308->irq,
+ rk3308_codec_hpdet_isr,
+ 0,
+ "acodec-hpdet",
+ rk3308);
+ if (ret < 0) {
+ dev_err(&pdev->dev, "Failed to request IRQ: %d\n", ret);
+ goto failed;
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_B) {
+ rk3308->detect_grf =
+ syscon_regmap_lookup_by_phandle(np, "rockchip,detect-grf");
+ if (IS_ERR(rk3308->detect_grf)) {
+ dev_err(&pdev->dev,
+ "Missing 'rockchip,detect-grf' property\n");
+ return PTR_ERR(rk3308->detect_grf);
+ }
+
+ /* Configure filter count and enable hpdet irq. */
+ regmap_write(rk3308->detect_grf,
+ DETECT_GRF_ACODEC_HPDET_COUNTER,
+ DEFAULT_HPDET_COUNT);
+ regmap_write(rk3308->detect_grf,
+ DETECT_GRF_ACODEC_HPDET_CON,
+ (HPDET_BOTH_NEG_POS << 16) |
+ HPDET_BOTH_NEG_POS);
+ }
+
+ rk3308_codec_set_jack_detect_cb = rk3308_codec_set_jack_detect;
+ }
+
+ if (rk3308->codec_ver == ACODEC_VERSION_A)
+ INIT_DELAYED_WORK(&rk3308->loopback_work,
+ rk3308_codec_loopback_work);
+
+ rk3308->adc_grp0_using_linein = ADC_GRP0_MICIN;
+ rk3308->dac_output = DAC_LINEOUT;
+ rk3308->adc_zerocross = 1;
+ rk3308->pm_state = PM_NORMAL;
+
platform_set_drvdata(pdev, rk3308);
ret = snd_soc_register_codec(&pdev->dev, &soc_codec_dev_rk3308,
- rk3308_dai, ARRAY_SIZE(rk3308_dai));
+ rk3308_dai, ARRAY_SIZE(rk3308_dai));
if (ret < 0) {
dev_err(&pdev->dev, "Failed to register codec: %d\n", ret);
goto failed;
@@ -1567,7 +5124,10 @@ static int rk3308_platform_probe(struct platform_device *pdev)
return ret;
failed:
+ clk_disable_unprepare(rk3308->mclk_rx);
+ clk_disable_unprepare(rk3308->mclk_tx);
clk_disable_unprepare(rk3308->pclk);
+ device_unregister(&rk3308->dev);
return ret;
}
@@ -1577,8 +5137,11 @@ static int rk3308_platform_remove(struct platform_device *pdev)
struct rk3308_codec_priv *rk3308 =
(struct rk3308_codec_priv *)platform_get_drvdata(pdev);
+ clk_disable_unprepare(rk3308->mclk_rx);
+ clk_disable_unprepare(rk3308->mclk_tx);
clk_disable_unprepare(rk3308->pclk);
snd_soc_unregister_codec(&pdev->dev);
+ device_unregister(&rk3308->dev);
return 0;
}
@@ -1591,7 +5154,7 @@ MODULE_DEVICE_TABLE(of, rk3308codec_of_match);
static struct platform_driver rk3308_codec_driver = {
.driver = {
- .name = "rk3308-acodec",
+ .name = CODEC_DRV_NAME,
.of_match_table = of_match_ptr(rk3308codec_of_match),
},
.probe = rk3308_platform_probe,
diff --git a/sound/soc/codecs/rk3308_codec.h b/sound/soc/codecs/rk3308_codec.h
index 6cfa69157785..93e089dae081 100644
--- a/sound/soc/codecs/rk3308_codec.h
+++ b/sound/soc/codecs/rk3308_codec.h
@@ -26,7 +26,8 @@
#define ACODEC_ADC_I2S_CTL0 0x04 /* REG 0x01 */
#define ACODEC_ADC_I2S_CTL1 0x08 /* REG 0x02 */
#define ACODEC_ADC_BIST_MODE_SEL 0x0c /* REG 0x03 */
-/* Resevred REG 0x04 ~ 0x06 */
+#define ACODEC_ADC_HPF_PATH 0x10 /* REG 0x04 */
+/* Resevred REG 0x05 ~ 0x06 */
#define ACODEC_ADC_DATA_PATH 0x1c /* REG 0x07 */
/* Resevred REG 0x08 ~ 0x0f */
@@ -62,12 +63,15 @@
#define ACODEC_DAC_I2S_CTL0 0x04 /* REG 0x01 */
#define ACODEC_DAC_I2S_CTL1 0x08 /* REG 0x02 */
#define ACODEC_DAC_BIST_MODE_SEL 0x0c /* REG 0x03 */
-/* Resevred REG 0x04 */
+#define ACODEC_DAC_DIGITAL_GAIN 0x10 /* REG 0x04 */
#define ACODEC_DAC_DATA_SEL 0x14 /* REG 0x05 */
/* Resevred REG 0x06 ~ 0x09 */
#define ACODEC_DAC_DATA_HI 0x28 /* REG 0x0a */
#define ACODEC_DAC_DATA_LO 0x2c /* REG 0x0b */
-/* Resevred REG 0x0c ~ 0x0f */
+/* Resevred REG 0x0c */
+#define ACODEC_DAC_HPDET_DELAYTIME 0x34 /* REG 0x0d */
+#define ACODEC_DAC_HPDET_STATUS 0x38 /* REG 0x0e, Read-only */
+/* Resevred REG 0x0f */
/* ADC ANALOG REGISTERS */
#define ACODEC_ADC_ANA_MIC_CTL 0x00 /* REG 0x00 */
@@ -92,10 +96,13 @@
#define ACODEC_DAC_ANA_LINEOUT 0x10 /* REG 0x04 */
#define ACODEC_DAC_ANA_L_HPOUT_GAIN 0x14 /* REG 0x05 */
#define ACODEC_DAC_ANA_R_HPOUT_GAIN 0x18 /* REG 0x06 */
+#define ACODEC_DAC_ANA_DRV_HPOUT 0x1c /* REG 0x07 */
+#define ACODEC_DAC_ANA_DRV_LINEOUT 0x20 /* REG 0x08 */
/* Resevred REG 0x07 ~ 0x0b */
#define ACODEC_DAC_ANA_HPMIX_CTL0 0x30 /* REG 0x0c */
#define ACODEC_DAC_ANA_HPMIX_CTL1 0x34 /* REG 0x0d */
-/* Resevred REG 0x0e ~ 0x0f */
+#define ACODEC_DAC_ANA_LINEOUT_CTL0 0x38 /* REG 0x0e */
+#define ACODEC_DAC_ANA_LINEOUT_CTL1 0x3c /* REG 0x0f */
/*
* These registers are referenced by codec driver
@@ -106,7 +113,7 @@
/* ADC DIGITAL REGISTERS */
/*
- * The ADC chanel are 0 ~ 3, that control:
+ * The ADC group are 0 ~ 3, that control:
*
* CH0: left_0(ADC1) and right_0(ADC2)
* CH1: left_1(ADC3) and right_1(ADC4)
@@ -118,6 +125,7 @@
#define RK3308_ADC_DIG_CON01(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_I2S_CTL0)
#define RK3308_ADC_DIG_CON02(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_I2S_CTL1)
#define RK3308_ADC_DIG_CON03(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_BIST_MODE_SEL)
+#define RK3308_ADC_DIG_CON04(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_HPF_PATH)
#define RK3308_ADC_DIG_CON07(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_DATA_PATH)
#define RK3308_ALC_L_DIG_CON00(ch) (RK3308_ADC_DIG_OFFSET(ch) + ACODEC_ADC_PGA_AGC_L_CTL0)
@@ -150,13 +158,16 @@
#define RK3308_DAC_DIG_CON01 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_I2S_CTL0)
#define RK3308_DAC_DIG_CON02 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_I2S_CTL1)
#define RK3308_DAC_DIG_CON03 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_BIST_MODE_SEL)
+#define RK3308_DAC_DIG_CON04 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_DIGITAL_GAIN)
#define RK3308_DAC_DIG_CON05 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_DATA_SEL)
#define RK3308_DAC_DIG_CON10 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_DATA_HI)
#define RK3308_DAC_DIG_CON11 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_DATA_LO)
+#define RK3308_DAC_DIG_CON13 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_HPDET_DELAYTIME)
+#define RK3308_DAC_DIG_CON14 (RK3308_DAC_DIG_OFFSET + ACODEC_DAC_HPDET_STATUS)
/* ADC ANALOG REGISTERS */
/*
- * The ADC chanel are 0 ~ 3, that control:
+ * The ADC group are 0 ~ 3, that control:
*
* CH0: left_0(ADC1) and right_0(ADC2)
* CH1: left_1(ADC3) and right_1(ADC4)
@@ -179,7 +190,6 @@
/* DAC ANALOG REGISTERS */
#define RK3308_DAC_ANA_OFFSET 0x440
-
#define RK3308_DAC_ANA_CON00 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_CTL0)
#define RK3308_DAC_ANA_CON01 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_POP_VOLT)
#define RK3308_DAC_ANA_CON02 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_CTL1)
@@ -187,8 +197,12 @@
#define RK3308_DAC_ANA_CON04 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_LINEOUT)
#define RK3308_DAC_ANA_CON05 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_L_HPOUT_GAIN)
#define RK3308_DAC_ANA_CON06 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_R_HPOUT_GAIN)
+#define RK3308_DAC_ANA_CON07 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_DRV_HPOUT)
+#define RK3308_DAC_ANA_CON08 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_DRV_LINEOUT)
#define RK3308_DAC_ANA_CON12 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_HPMIX_CTL0)
#define RK3308_DAC_ANA_CON13 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_HPMIX_CTL1)
+#define RK3308_DAC_ANA_CON14 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_LINEOUT_CTL0)
+#define RK3308_DAC_ANA_CON15 (RK3308_DAC_ANA_OFFSET + ACODEC_DAC_ANA_LINEOUT_CTL1)
/*
* These are the bits for registers
@@ -199,6 +213,12 @@
#define RK3308_ADC_BIST_RESET (0 << 7)
#define RK3308_DAC_BIST_WORK (1 << 6)
#define RK3308_DAC_BIST_RESET (0 << 6)
+#define RK3308_ADC_MCLK_MSK (1 << 5)
+#define RK3308_ADC_MCLK_DIS (1 << 5)
+#define RK3308_ADC_MCLK_EN (0 << 5)
+#define RK3308_DAC_MCLK_MSK (1 << 4)
+#define RK3308_DAC_MCLK_DIS (1 << 4)
+#define RK3308_DAC_MCLK_EN (0 << 4)
#define RK3308_CODEC_RST_MSK (0x7 << 0)
#define RK3308_ADC_DIG_WORK (1 << 2)
#define RK3308_ADC_DIG_RESET (0 << 2)
@@ -253,16 +273,27 @@
/* RK3308_ADC_DIG_CON03 - REG: 0x000c */
#define RK3308_ADC_L_CH_BIST_SFT 2
#define RK3308_ADC_L_CH_BIST_MSK (0x3 << RK3308_ADC_L_CH_BIST_SFT)
-#define RK3308_ADC_L_CH_BIST_LEFT (0x3 << RK3308_ADC_L_CH_BIST_SFT) /* normal mode */
-#define RK3308_ADC_L_CH_BIST_SINE (0x2 << RK3308_ADC_L_CH_BIST_SFT)
-#define RK3308_ADC_L_CH_BIST_CUBE (0x1 << RK3308_ADC_L_CH_BIST_SFT)
-#define RK3308_ADC_L_CH_BIST_RIGHT (0x0 << RK3308_ADC_L_CH_BIST_SFT) /* normal mode */
+#define RK3308_ADC_L_CH_NORMAL_RIGHT (0x3 << RK3308_ADC_L_CH_BIST_SFT) /* normal mode */
+#define RK3308_ADC_L_CH_BIST_CUBE (0x2 << RK3308_ADC_L_CH_BIST_SFT)
+#define RK3308_ADC_L_CH_BIST_SINE (0x1 << RK3308_ADC_L_CH_BIST_SFT)
+#define RK3308_ADC_L_CH_NORMAL_LEFT (0x0 << RK3308_ADC_L_CH_BIST_SFT) /* normal mode */
#define RK3308_ADC_R_CH_BIST_SFT 0
#define RK3308_ADC_R_CH_BIST_MSK (0x3 << RK3308_ADC_R_CH_BIST_SFT)
-#define RK3308_ADC_R_CH_BIST_LEFT (0x3 << RK3308_ADC_R_CH_BIST_SFT) /* normal mode */
-#define RK3308_ADC_R_CH_BIST_SINE (0x2 << RK3308_ADC_R_CH_BIST_SFT)
-#define RK3308_ADC_R_CH_BIST_CUBE (0x1 << RK3308_ADC_R_CH_BIST_SFT)
-#define RK3308_ADC_R_CH_BIST_RIGHT (0x0 << RK3308_ADC_R_CH_BIST_SFT) /* normal mode */
+#define RK3308_ADC_R_CH_NORMAL_LEFT (0x3 << RK3308_ADC_R_CH_BIST_SFT) /* normal mode */
+#define RK3308_ADC_R_CH_BIST_CUBE (0x2 << RK3308_ADC_R_CH_BIST_SFT)
+#define RK3308_ADC_R_CH_BIST_SINE (0x1 << RK3308_ADC_R_CH_BIST_SFT)
+#define RK3308_ADC_R_CH_NORMAL_RIGHT (0x0 << RK3308_ADC_R_CH_BIST_SFT) /* normal mode */
+
+/* RK3308_ADC_DIG_CON04 - REG: 0x0010 */
+#define RK3308_ADC_HPF_PATH_SFT 2
+#define RK3308_ADC_HPF_PATH_MSK (1 << RK3308_ADC_HPF_PATH_SFT)
+#define RK3308_ADC_HPF_PATH_DIS (1 << RK3308_ADC_HPF_PATH_SFT)
+#define RK3308_ADC_HPF_PATH_EN (0 << RK3308_ADC_HPF_PATH_SFT)
+#define RK3308_ADC_HPF_CUTOFF_SFT 0
+#define RK3308_ADC_HPF_CUTOFF_MSK (0x3 << RK3308_ADC_HPF_CUTOFF_SFT)
+#define RK3308_ADC_HPF_CUTOFF_612HZ (0x2 << RK3308_ADC_HPF_CUTOFF_SFT)
+#define RK3308_ADC_HPF_CUTOFF_245HZ (0x1 << RK3308_ADC_HPF_CUTOFF_SFT)
+#define RK3308_ADC_HPF_CUTOFF_20HZ (0x0 << RK3308_ADC_HPF_CUTOFF_SFT)
/* RK3308_ADC_DIG_CON07 - REG: 0x001c */
#define RK3308_ADCL_DATA_SFT 4
@@ -391,6 +422,8 @@
*/
#define RK3308_AGC_PGA_ZERO_CRO_EN (0x1 << 5)
#define RK3308_AGC_PGA_ZERO_CRO_DIS (0x0 << 5)
+#define RK3308_AGC_PGA_GAIN_MAX 0x1f
+#define RK3308_AGC_PGA_GAIN_MIN 0
#define RK3308_AGC_PGA_GAIN_SFT 0
#define RK3308_AGC_PGA_GAIN_MSK (0x1f << RK3308_AGC_PGA_GAIN_SFT)
#define RK3308_AGC_PGA_GAIN_PDB_28_5 (0x1f << RK3308_AGC_PGA_GAIN_SFT)
@@ -474,6 +507,8 @@
#define RK3308_AGC_FUNC_SEL_MSK (0x1 << 6)
#define RK3308_AGC_FUNC_SEL_EN (0x1 << 6)
#define RK3308_AGC_FUNC_SEL_DIS (0x0 << 6)
+#define RK3308_AGC_MAX_GAIN_PGA_MAX 0x7
+#define RK3308_AGC_MAX_GAIN_PGA_MIN 0
#define RK3308_AGC_MAX_GAIN_PGA_SFT 3
#define RK3308_AGC_MAX_GAIN_PGA_MSK (0x7 << RK3308_AGC_MAX_GAIN_PGA_SFT)
#define RK3308_AGC_MAX_GAIN_PGA_PDB_28_5 (0x7 << RK3308_AGC_MAX_GAIN_PGA_SFT)
@@ -484,6 +519,8 @@
#define RK3308_AGC_MAX_GAIN_PGA_NDB_1_5 (0x2 << RK3308_AGC_MAX_GAIN_PGA_SFT)
#define RK3308_AGC_MAX_GAIN_PGA_NDB_7_5 (0x1 << RK3308_AGC_MAX_GAIN_PGA_SFT)
#define RK3308_AGC_MAX_GAIN_PGA_NDB_13_5 (0x0 << RK3308_AGC_MAX_GAIN_PGA_SFT)
+#define RK3308_AGC_MIN_GAIN_PGA_MAX 0x7
+#define RK3308_AGC_MIN_GAIN_PGA_MIN 0
#define RK3308_AGC_MIN_GAIN_PGA_SFT 0
#define RK3308_AGC_MIN_GAIN_PGA_MSK (0x7 << RK3308_AGC_MIN_GAIN_PGA_SFT)
#define RK3308_AGC_MIN_GAIN_PGA_PDB_24 (0x7 << RK3308_AGC_MIN_GAIN_PGA_SFT)
@@ -555,6 +592,18 @@
#define RK3308_DAC_R_CH_BIST_SINE (0x1 << RK3308_DAC_R_CH_BIST_SFT)
#define RK3308_DAC_R_CH_BIST_RIGHT (0x0 << RK3308_DAC_R_CH_BIST_SFT) /* normal mode */
+/* RK3308_DAC_DIG_CON04 - REG: 0x0310 */
+#define RK3308_DAC_MODULATOR_GAIN_SFT 4
+#define RK3308_DAC_MODULATOR_GAIN_MSK (0x7 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_4_8DB (0x5 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_4_2DB (0x4 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_3_5DB (0x3 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_2_8DB (0x2 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_2DB (0x1 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_MODULATOR_GAIN_0DB (0x0 << RK3308_DAC_MODULATOR_GAIN_SFT)
+#define RK3308_DAC_CIC_IF_GAIN_SFT 0
+#define RK3308_DAC_CIC_IF_GAIN_MSK (0x7 << RK3308_DAC_CIC_IF_GAIN_SFT)
+
/* RK3308_DAC_DIG_CON05 - REG: 0x0314 */
#define RK3308_DAC_L_REG_CTL_INDATA (0x1 << 2)
#define RK3308_DAC_L_NORMAL_DATA (0x0 << 2)
@@ -587,18 +636,30 @@
#define RK3308_ADC_CH1_BUF_REF_EN (0x1 << 0)
#define RK3308_ADC_CH1_BUF_REF_DIS (0x0 << 0)
-/* RK3308_ADC_ANA_CON01 - REG: 0x0344 */
+/* RK3308_ADC_ANA_CON01 - REG: 0x0344
+ *
+ * The PGA of MIC-INs:
+ * 0x0 - MIC1~MIC8 0dB
+ * 0x1 - MIC1~MIC8 6.6dB
+ * 0x2 - MIC1~MIC8 13dB
+ * 0x3 - MIC1~MIC8 20dB
+ */
+#define RK3308_ADC_CH2_MIC_GAIN_MAX 0x3
+#define RK3308_ADC_CH2_MIC_GAIN_MIN 0
#define RK3308_ADC_CH2_MIC_GAIN_SFT 4
#define RK3308_ADC_CH2_MIC_GAIN_MSK (0x3 << RK3308_ADC_CH2_MIC_GAIN_SFT)
-#define RK3308_ADC_CH2_MIC_GAIN_30DB (0x3 << RK3308_ADC_CH2_MIC_GAIN_SFT)
-#define RK3308_ADC_CH2_MIC_GAIN_20DB (0x2 << RK3308_ADC_CH2_MIC_GAIN_SFT)
-#define RK3308_ADC_CH2_MIC_GAIN_6DB (0x1 << RK3308_ADC_CH2_MIC_GAIN_SFT)
+#define RK3308_ADC_CH2_MIC_GAIN_20DB (0x3 << RK3308_ADC_CH2_MIC_GAIN_SFT)
+#define RK3308_ADC_CH2_MIC_GAIN_13DB (0x2 << RK3308_ADC_CH2_MIC_GAIN_SFT) /* TRM: only used for version B */
+#define RK3308_ADC_CH2_MIC_GAIN_6_6DB (0x1 << RK3308_ADC_CH2_MIC_GAIN_SFT) /* TRM: only used for version B */
#define RK3308_ADC_CH2_MIC_GAIN_0DB (0x0 << RK3308_ADC_CH2_MIC_GAIN_SFT)
+
+#define RK3308_ADC_CH1_MIC_GAIN_MAX 0x3
+#define RK3308_ADC_CH1_MIC_GAIN_MIN 0
#define RK3308_ADC_CH1_MIC_GAIN_SFT 0
#define RK3308_ADC_CH1_MIC_GAIN_MSK (0x3 << RK3308_ADC_CH1_MIC_GAIN_SFT)
-#define RK3308_ADC_CH1_MIC_GAIN_30DB (0x3 << RK3308_ADC_CH1_MIC_GAIN_SFT)
-#define RK3308_ADC_CH1_MIC_GAIN_20DB (0x2 << RK3308_ADC_CH1_MIC_GAIN_SFT)
-#define RK3308_ADC_CH1_MIC_GAIN_6DB (0x1 << RK3308_ADC_CH1_MIC_GAIN_SFT)
+#define RK3308_ADC_CH1_MIC_GAIN_20DB (0x3 << RK3308_ADC_CH1_MIC_GAIN_SFT)
+#define RK3308_ADC_CH1_MIC_GAIN_13DB (0x2 << RK3308_ADC_CH1_MIC_GAIN_SFT) /* TRM: only used for version B */
+#define RK3308_ADC_CH1_MIC_GAIN_6_6DB (0x1 << RK3308_ADC_CH1_MIC_GAIN_SFT) /* TRM: only used for version B */
#define RK3308_ADC_CH1_MIC_GAIN_0DB (0x0 << RK3308_ADC_CH1_MIC_GAIN_SFT)
/* RK3308_ADC_ANA_CON02 - REG: 0x0348 */
@@ -619,6 +680,8 @@
#define RK3308_ADC_CH1_ALC_DIS (0x0 << 0)
/* RK3308_ADC_ANA_CON03 - REG: 0x034c */
+#define RK3308_ADC_CH1_ALC_GAIN_MAX 0x1f
+#define RK3308_ADC_CH1_ALC_GAIN_MIN 0
#define RK3308_ADC_CH1_ALC_GAIN_SFT 0
#define RK3308_ADC_CH1_ALC_GAIN_MSK (0x1f << RK3308_ADC_CH1_ALC_GAIN_SFT)
#define RK3308_ADC_CH1_ALC_GAIN_PDB_28_5 (0x1f << RK3308_ADC_CH1_ALC_GAIN_SFT)
@@ -655,6 +718,8 @@
#define RK3308_ADC_CH1_ALC_GAIN_NDB_18 (0x00 << RK3308_ADC_CH1_ALC_GAIN_SFT)
/* RK3308_ADC_ANA_CON04 - REG: 0x0350 */
+#define RK3308_ADC_CH2_ALC_GAIN_MAX 0x1f
+#define RK3308_ADC_CH2_ALC_GAIN_MIN 0
#define RK3308_ADC_CH2_ALC_GAIN_SFT 0
#define RK3308_ADC_CH2_ALC_GAIN_MSK (0x1f << RK3308_ADC_CH2_ALC_GAIN_SFT)
#define RK3308_ADC_CH2_ALC_GAIN_PDB_28_5 (0x1f << RK3308_ADC_CH2_ALC_GAIN_SFT)
@@ -728,10 +793,16 @@
#define RK3308_ADC_CH1_IN_MIC (0x1 << RK3308_ADC_CH1_IN_SEL_SFT)
#define RK3308_ADC_CH1_IN_NONE (0x0 << RK3308_ADC_CH1_IN_SEL_SFT)
-#define RK3308_ADC_MIC_BIAS_BUF_EN (0x1 << 3)
-#define RK3308_ADC_MIC_BIAS_BUF_DIS (0x0 << 3)
+#define RK3308_ADC_MIC_BIAS_BUF_SFT 3
+#define RK3308_ADC_MIC_BIAS_BUF_EN (0x1 << RK3308_ADC_MIC_BIAS_BUF_SFT)
+#define RK3308_ADC_MIC_BIAS_BUF_DIS (0x0 << RK3308_ADC_MIC_BIAS_BUF_SFT)
#define RK3308_ADC_LEVEL_RANGE_MICBIAS_SFT 0
#define RK3308_ADC_LEVEL_RANGE_MICBIAS_MSK (0x7 << RK3308_ADC_LEVEL_RANGE_MICBIAS_SFT)
+/*
+ * The follow MICBIAS_VOLTs are based on the external reference voltage(Vref).
+ * For example, the Vref == 3.3V, the MICBIAS_VOLT_0_85 is equal:
+ * 3.3V * 0.85 = 2.805V.
+ */
#define RK3308_ADC_MICBIAS_VOLT_0_85 (0x7 << RK3308_ADC_LEVEL_RANGE_MICBIAS_SFT)
#define RK3308_ADC_MICBIAS_VOLT_0_8 (0x6 << RK3308_ADC_LEVEL_RANGE_MICBIAS_SFT)
#define RK3308_ADC_MICBIAS_VOLT_0_75 (0x5 << RK3308_ADC_LEVEL_RANGE_MICBIAS_SFT)
@@ -751,18 +822,11 @@
#define RK3308_ADC_REF_DIS (0x0 << 7)
#define RK3308_ADC_CURRENT_CHARGE_SFT 0
#define RK3308_ADC_CURRENT_CHARGE_MSK (0x7f << RK3308_ADC_CURRENT_CHARGE_SFT)
-#define RK3308_ADC_DONT_SEL_ALL (0x7f << RK3308_ADC_CURRENT_CHARGE_SFT)
/*
- * 0: Choose the current I
- * 1: Don't choose the current I
+ * 1: Choose the current I
+ * 0: Don't choose the current I
*/
-#define RK3308_ADC_SEL_I_1(x) ((x & 0x1) << 6)
-#define RK3308_ADC_SEL_I_2(x) ((x & 0x1) << 5)
-#define RK3308_ADC_SEL_I_4(x) ((x & 0x1) << 4)
-#define RK3308_ADC_SEL_I_8(x) ((x & 0x1) << 3)
-#define RK3308_ADC_SEL_I_16(x) ((x & 0x1) << 2)
-#define RK3308_ADC_SEL_I_32(x) ((x & 0x1) << 1)
-#define RK3308_ADC_SEL_I_64(x) ((x & 0x1) << 0)
+#define RK3308_ADC_SEL_I(x) (x & 0x7f)
/* RK3308_ADC_ANA_CON11 - REG: 0x036c */
#define RK3308_ADC_ALCR_CON_GAIN_PGAR_MSK (0x1 << 1)
@@ -773,6 +837,7 @@
#define RK3308_ADC_ALCL_CON_GAIN_PGAL_DIS (0x0 << 0)
/* RK3308_DAC_ANA_CON00 - REG: 0x0440 */
+#define RK3308_DAC_HEADPHONE_DET_MSK (0x1 << 1)
#define RK3308_DAC_HEADPHONE_DET_EN (0x1 << 1)
#define RK3308_DAC_HEADPHONE_DET_DIS (0x0 << 1)
#define RK3308_DAC_CURRENT_MSK (0x1 << 0)
@@ -783,17 +848,17 @@
#define RK3308_DAC_BUF_REF_R_MSK (0x1 << 6)
#define RK3308_DAC_BUF_REF_R_EN (0x1 << 6)
#define RK3308_DAC_BUF_REF_R_DIS (0x0 << 6)
-#define RK3308_DAC_POP_SOUND_R_SFT 4
-#define RK3308_DAC_POP_SOUND_R_MSK (0x3 << RK3308_DAC_POP_SOUND_R_SFT)
-#define RK3308_DAC_POP_SOUND_R_WORK (0x2 << RK3308_DAC_POP_SOUND_R_SFT)
-#define RK3308_DAC_POP_SOUND_R_INIT (0x1 << RK3308_DAC_POP_SOUND_R_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_R_SFT 4
+#define RK3308_DAC_HPOUT_POP_SOUND_R_MSK (0x3 << RK3308_DAC_HPOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_R_WORK (0x2 << RK3308_DAC_HPOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_R_INIT (0x1 << RK3308_DAC_HPOUT_POP_SOUND_R_SFT)
#define RK3308_DAC_BUF_REF_L_MSK (0x1 << 2)
#define RK3308_DAC_BUF_REF_L_EN (0x1 << 2)
#define RK3308_DAC_BUF_REF_L_DIS (0x0 << 2)
-#define RK3308_DAC_POP_SOUND_L_SFT 0
-#define RK3308_DAC_POP_SOUND_L_MSK (0x3 << RK3308_DAC_POP_SOUND_L_SFT)
-#define RK3308_DAC_POP_SOUND_L_WORK (0x2 << RK3308_DAC_POP_SOUND_L_SFT)
-#define RK3308_DAC_POP_SOUND_L_INIT (0x1 << RK3308_DAC_POP_SOUND_L_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_L_SFT 0
+#define RK3308_DAC_HPOUT_POP_SOUND_L_MSK (0x3 << RK3308_DAC_HPOUT_POP_SOUND_L_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_L_WORK (0x2 << RK3308_DAC_HPOUT_POP_SOUND_L_SFT)
+#define RK3308_DAC_HPOUT_POP_SOUND_L_INIT (0x1 << RK3308_DAC_HPOUT_POP_SOUND_L_SFT)
/* RK3308_DAC_ANA_CON02 - REG: 0x0448 */
#define RK3308_DAC_R_DAC_WORK (0x1 << 7)
@@ -828,28 +893,31 @@
#define RK3308_DAC_L_HPOUT_MUTE (0x0 << 0)
/* RK3308_DAC_ANA_CON04 - REG: 0x0450 */
-#define RK3308_DAC_R_GAIN_SFT 6
-#define RK3308_DAC_R_GAIN_MSK (0x3 << RK3308_DAC_R_GAIN_SFT)
-#define RK3308_DAC_R_GAIN_0DB (0x3 << RK3308_DAC_R_GAIN_SFT)
-#define RK3308_DAC_R_GAIN_PDB_1_5 (0x2 << RK3308_DAC_R_GAIN_SFT)
-#define RK3308_DAC_R_GAIN_PDB_3 (0x1 << RK3308_DAC_R_GAIN_SFT)
-#define RK3308_DAC_R_GAIN_PDB_6 (0x0 << RK3308_DAC_R_GAIN_SFT)
+#define RK3308_DAC_R_LINEOUT_GAIN_MAX 0x3
+#define RK3308_DAC_R_LINEOUT_GAIN_SFT 6
+#define RK3308_DAC_R_LINEOUT_GAIN_MSK (0x3 << RK3308_DAC_R_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_R_LINEOUT_GAIN_0DB (0x3 << RK3308_DAC_R_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_R_LINEOUT_GAIN_NDB_1_5 (0x2 << RK3308_DAC_R_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_R_LINEOUT_GAIN_NDB_3 (0x1 << RK3308_DAC_R_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_R_LINEOUT_GAIN_NDB_6 (0x0 << RK3308_DAC_R_LINEOUT_GAIN_SFT)
#define RK3308_DAC_R_LINEOUT_UNMUTE (0x1 << 5)
#define RK3308_DAC_R_LINEOUT_MUTE (0x0 << 5)
#define RK3308_DAC_R_LINEOUT_EN (0x1 << 4)
#define RK3308_DAC_R_LINEOUT_DIS (0x0 << 4)
-#define RK3308_DAC_L_GAIN_SFT 2
-#define RK3308_DAC_L_GAIN_MSK (0x3 << RK3308_DAC_L_GAIN_SFT)
-#define RK3308_DAC_L_GAIN_0DB (0x3 << RK3308_DAC_L_GAIN_SFT)
-#define RK3308_DAC_L_GAIN_PDB_1_5 (0x2 << RK3308_DAC_L_GAIN_SFT)
-#define RK3308_DAC_L_GAIN_PDB_3 (0x1 << RK3308_DAC_L_GAIN_SFT)
-#define RK3308_DAC_L_GAIN_PDB_6 (0x0 << RK3308_DAC_L_GAIN_SFT)
+#define RK3308_DAC_L_LINEOUT_GAIN_MAX 0x3
+#define RK3308_DAC_L_LINEOUT_GAIN_SFT 2
+#define RK3308_DAC_L_LINEOUT_GAIN_MSK (0x3 << RK3308_DAC_L_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_L_LINEOUT_GAIN_0DB (0x3 << RK3308_DAC_L_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_L_LINEOUT_GAIN_NDB_1_5 (0x2 << RK3308_DAC_L_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_L_LINEOUT_GAIN_NDB_3 (0x1 << RK3308_DAC_L_LINEOUT_GAIN_SFT)
+#define RK3308_DAC_L_LINEOUT_GAIN_NDB_6 (0x0 << RK3308_DAC_L_LINEOUT_GAIN_SFT)
#define RK3308_DAC_L_LINEOUT_UNMUTE (0x1 << 1)
#define RK3308_DAC_L_LINEOUT_MUTE (0x0 << 1)
#define RK3308_DAC_L_LINEOUT_EN (0x1 << 0)
#define RK3308_DAC_L_LINEOUT_DIS (0x0 << 0)
/* RK3308_DAC_ANA_CON05 - REG: 0x0454, step is 1.5db */
+#define RK3308_DAC_L_HPOUT_GAIN_MAX 0x1e
#define RK3308_DAC_L_HPOUT_GAIN_SFT 0
#define RK3308_DAC_L_HPOUT_GAIN_MSK (0x1f << RK3308_DAC_L_HPOUT_GAIN_SFT)
#define RK3308_DAC_L_HPOUT_GAIN_PDB_6 (0x1e << RK3308_DAC_L_HPOUT_GAIN_SFT)
@@ -885,6 +953,7 @@
#define RK3308_DAC_L_HPOUT_GAIN_NDB_39 (0x00 << RK3308_DAC_L_HPOUT_GAIN_SFT)
/* RK3308_DAC_ANA_CON06 - REG: 0x0458, step is 1.5db */
+#define RK3308_DAC_R_HPOUT_GAIN_MAX 0x1e
#define RK3308_DAC_R_HPOUT_GAIN_SFT 0
#define RK3308_DAC_R_HPOUT_GAIN_MSK (0x1f << RK3308_DAC_R_HPOUT_GAIN_SFT)
#define RK3308_DAC_R_HPOUT_GAIN_PDB_6 (0x1e << RK3308_DAC_R_HPOUT_GAIN_SFT)
@@ -919,6 +988,18 @@
#define RK3308_DAC_R_HPOUT_GAIN_NDB_37_5 (0x01 << RK3308_DAC_R_HPOUT_GAIN_SFT)
#define RK3308_DAC_R_HPOUT_GAIN_NDB_39 (0x00 << RK3308_DAC_R_HPOUT_GAIN_SFT)
+/* RK3308_DAC_ANA_CON07 - REG: 0x045c */
+#define RK3308_DAC_R_HPOUT_DRV_SFT 4
+#define RK3308_DAC_R_HPOUT_DRV_MSK (0xf << RK3308_DAC_R_HPOUT_DRV_SFT)
+#define RK3308_DAC_L_HPOUT_DRV_SFT 0
+#define RK3308_DAC_L_HPOUT_DRV_MSK (0xf << RK3308_DAC_L_HPOUT_DRV_SFT)
+
+/* RK3308_DAC_ANA_CON08 - REG: 0x0460 */
+#define RK3308_DAC_R_LINEOUT_DRV_SFT 4
+#define RK3308_DAC_R_LINEOUT_DRV_MSK (0xf << RK3308_DAC_R_LINEOUT_DRV_SFT)
+#define RK3308_DAC_L_LINEOUT_DRV_SFT 0
+#define RK3308_DAC_L_LINEOUT_DRV_MSK (0xf << RK3308_DAC_L_LINEOUT_DRV_SFT)
+
/* RK3308_DAC_ANA_CON12 - REG: 0x0470 */
#define RK3308_DAC_R_HPMIX_SEL_SFT 6
#define RK3308_DAC_R_HPMIX_SEL_MSK (0x3 << RK3308_DAC_R_HPMIX_SEL_SFT)
@@ -926,6 +1007,8 @@
#define RK3308_DAC_R_HPMIX_LINEIN (0x2 << RK3308_DAC_R_HPMIX_SEL_SFT)
#define RK3308_DAC_R_HPMIX_I2S (0x1 << RK3308_DAC_R_HPMIX_SEL_SFT)
#define RK3308_DAC_R_HPMIX_NONE (0x0 << RK3308_DAC_R_HPMIX_SEL_SFT)
+#define RK3308_DAC_R_HPMIX_GAIN_MIN 0x1
+#define RK3308_DAC_R_HPMIX_GAIN_MAX 0x2
#define RK3308_DAC_R_HPMIX_GAIN_SFT 4
#define RK3308_DAC_R_HPMIX_GAIN_MSK (0x3 << RK3308_DAC_R_HPMIX_GAIN_SFT)
#define RK3308_DAC_R_HPMIX_GAIN_0DB (0x2 << RK3308_DAC_R_HPMIX_GAIN_SFT)
@@ -936,6 +1019,8 @@
#define RK3308_DAC_L_HPMIX_LINEIN (0x2 << RK3308_DAC_L_HPMIX_SEL_SFT)
#define RK3308_DAC_L_HPMIX_I2S (0x1 << RK3308_DAC_L_HPMIX_SEL_SFT)
#define RK3308_DAC_L_HPMIX_NONE (0x0 << RK3308_DAC_L_HPMIX_SEL_SFT)
+#define RK3308_DAC_L_HPMIX_GAIN_MIN 0x1
+#define RK3308_DAC_L_HPMIX_GAIN_MAX 0x2
#define RK3308_DAC_L_HPMIX_GAIN_SFT 0
#define RK3308_DAC_L_HPMIX_GAIN_MSK (0x3 << RK3308_DAC_L_HPMIX_GAIN_SFT)
#define RK3308_DAC_L_HPMIX_GAIN_0DB (0x2 << RK3308_DAC_L_HPMIX_GAIN_SFT)
@@ -955,6 +1040,30 @@
#define RK3308_DAC_L_HPMIX_EN (0x1 << 0)
#define RK3308_DAC_L_HPMIX_DIS (0x0 << 0)
+/* RK3308_DAC_ANA_CON14 - REG: 0x0478 */
+#define RK3308_DAC_VCM_LINEOUT_EN (0x1 << 4)
+#define RK3308_DAC_VCM_LINEOUT_DIS (0x0 << 4)
+#define RK3308_DAC_CURRENT_CHARGE_SFT 0
+#define RK3308_DAC_CURRENT_CHARGE_MSK (0xf << RK3308_DAC_CURRENT_CHARGE_SFT)
+
+/*
+ * 1: Choose the current I
+ * 0: Don't choose the current I
+ */
+#define RK3308_DAC_SEL_I(x) (x & 0xf)
+
+/* RK3308_DAC_ANA_CON15 - REG: 0x047C */
+#define RK3308_DAC_LINEOUT_POP_SOUND_R_SFT 4
+#define RK3308_DAC_LINEOUT_POP_SOUND_R_MSK (0x3 << RK3308_DAC_LINEOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_R_SEL_DC_FROM_INTERNAL (0x2 << RK3308_DAC_LINEOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_R_SEL_DC_FROM_VCM (0x1 << RK3308_DAC_LINEOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_R_SEL_LINEOUT_FROM_INTERNAL (0x0 << RK3308_DAC_LINEOUT_POP_SOUND_R_SFT)
+#define RK3308_DAC_LINEOUT_POP_SOUND_L_SFT 0
+#define RK3308_DAC_LINEOUT_POP_SOUND_L_MSK (0x3 << RK3308_DAC_LINEOUT_POP_SOUND_L_SFT)
+#define RK3308_DAC_L_SEL_DC_FROM_INTERNAL (0x2 << RK3308_DAC_LINEOUT_POP_SOUND_L_SFT)
+#define RK3308_DAC_L_SEL_DC_FROM_VCM (0x1 << RK3308_DAC_LINEOUT_POP_SOUND_L_SFT)
+#define RK3308_DAC_L_SEL_LINEOUT_FROM_INTERNAL (0x0 << RK3308_DAC_LINEOUT_POP_SOUND_L_SFT)
+
#define RK3308_HIFI 0x0
#endif /* __RK3308_CODEC_H__ */
diff --git a/sound/soc/codecs/rk3308_codec_provider.h b/sound/soc/codecs/rk3308_codec_provider.h
new file mode 100644
index 000000000000..68042b1328dc
--- /dev/null
+++ b/sound/soc/codecs/rk3308_codec_provider.h
@@ -0,0 +1,28 @@
+/*
+ * rk3308_codec_provider.h -- RK3308 ALSA Soc Audio Driver
+ *
+ * Copyright (c) 2018, Fuzhou Rockchip Electronics Co., Ltd All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#ifndef __RK3308_CODEC_PROVIDER_H__
+#define __RK3308_CODEC_PROVIDER_H__
+
+#ifdef CONFIG_SND_SOC_RK3308
+extern void (*rk3308_codec_set_jack_detect_cb)(struct snd_soc_codec *codec,
+ struct snd_soc_jack *hpdet_jack);
+#endif
+
+#endif /* __RK3308_CODEC_PROVIDER_H__ */
--
2.25.1
Reference in New Issue Copy Permalink