Evolution-X-Devices/kernel_samsung_a71
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

techpack: Import M515FXXU1ATH4 for sm7150 devices

Browse Source 
* The recent kernel sources have broken audio on sm7150 devices, use proper one to fix audio.

Change-Id: I57a0e5e4153e36d24d2fca28151c587c5f307685
This commit is contained in:
Haky86
2023-11-25 00:44:43 +01:00
parent 2a3cecc65f
commit 904a06434c
166 changed files with 9788 additions and 18238 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
techpack/audio/4.0/asoc/Kbuild
View File

@@ -129,11 +129,6 @@ ifdef CONFIG_SND_SOC_SA8155
MACHINE_OBJS += sa8155.o
endif
# for SAMSUNG AUDIO
ifdef CONFIG_SND_SOC_SAMSUNG_AUDIO
MACHINE_OBJS += sec_wcd_sysfs_cb.o
endif
ifdef CONFIG_SND_SOC_CPE
CPE_LSM_OBJS += msm-cpe-lsm.o
endif
@@ -214,13 +209,11 @@ ifeq ($(KERNEL_BUILD), 0)
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/4.0/asoc/codecs/wcd934x/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/4.0/asoc/codecs/wcd937x/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/4.0/asoc/codecs/wcd938x/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/tas2562/Module.symvers
else
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/dsp/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/wcd934x/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/wcd937x/Module.symvers
KBUILD_EXTRA_SYMBOLS +=$(OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/tas2562/Module.symvers
endif
endif
ifeq ($(KERNEL_BUILD), 1)

5
techpack/audio/4.0/asoc/codecs/Kbuild
View File

@@ -217,14 +217,11 @@ ifeq ($(KERNEL_BUILD), 0)
endif
ifeq ($(KERNEL_BUILD), 1)
obj-y += wcd934x/
obj-y += wcd937x/
obj-y += wcd938x/
obj-y += bolero/
endif
ifdef CONFIG_SND_SOC_TAS256x
obj-y += tas256x/
endif
# Module information used by KBuild framework
obj-$(CONFIG_WCD9XXX_CODEC_CORE) += wcd_core_dlkm.o
obj-$(CONFIG_WCD9XXX_CODEC_CORE_V2) += wcd_core_dlkm.o

12
techpack/audio/4.0/asoc/codecs/audio-ext-clk-up.c
View File

@@ -70,8 +70,6 @@ static int audio_ext_clk_prepare(struct clk_hw *hw)
if ((clk_priv->clk_src >= AUDIO_EXT_CLK_LPASS) &&
(clk_priv->clk_src < AUDIO_EXT_CLK_LPASS_MAX)) {
clk_priv->clk_cfg.enable = 1;
trace_printk("%s: vote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_set_lpass_clk_cfg(IDX_RSVD_3, &clk_priv->clk_cfg);
if (ret < 0) {
pr_err_ratelimited("%s afe_set_digital_codec_core_clock failed\n",
@@ -114,8 +112,6 @@ static void audio_ext_clk_unprepare(struct clk_hw *hw)
if ((clk_priv->clk_src >= AUDIO_EXT_CLK_LPASS) &&
(clk_priv->clk_src < AUDIO_EXT_CLK_LPASS_MAX)) {
clk_priv->clk_cfg.enable = 0;
trace_printk("%s: unvote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_set_lpass_clk_cfg(IDX_RSVD_3, &clk_priv->clk_cfg);
if (ret < 0)
pr_err_ratelimited("%s: afe_set_lpass_clk_cfg failed, ret = %d\n",
@@ -150,8 +146,6 @@ static int lpass_hw_vote_prepare(struct clk_hw *hw)
int ret;
if (clk_priv->clk_src == AUDIO_EXT_CLK_LPASS_CORE_HW_VOTE) {
trace_printk("%s: vote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_vote_lpass_core_hw(AFE_LPASS_CORE_HW_MACRO_BLOCK,
"LPASS_HW_MACRO",
&clk_priv->lpass_core_hwvote_client_handle);
@@ -163,8 +157,6 @@ static int lpass_hw_vote_prepare(struct clk_hw *hw)
}
if (clk_priv->clk_src == AUDIO_EXT_CLK_LPASS_AUDIO_HW_VOTE) {
trace_printk("%s: vote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_vote_lpass_core_hw(AFE_LPASS_CORE_HW_DCODEC_BLOCK,
"LPASS_HW_DCODEC",
&clk_priv->lpass_audio_hwvote_client_handle);
@@ -184,8 +176,6 @@ static void lpass_hw_vote_unprepare(struct clk_hw *hw)
int ret = 0;
if (clk_priv->clk_src == AUDIO_EXT_CLK_LPASS_CORE_HW_VOTE) {
trace_printk("%s: unvote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_unvote_lpass_core_hw(
AFE_LPASS_CORE_HW_MACRO_BLOCK,
clk_priv->lpass_core_hwvote_client_handle);
@@ -196,8 +186,6 @@ static void lpass_hw_vote_unprepare(struct clk_hw *hw)
}
if (clk_priv->clk_src == AUDIO_EXT_CLK_LPASS_AUDIO_HW_VOTE) {
trace_printk("%s: unvote for %d clock\n",
__func__, clk_priv->clk_src);
ret = afe_unvote_lpass_core_hw(
AFE_LPASS_CORE_HW_DCODEC_BLOCK,
clk_priv->lpass_audio_hwvote_client_handle);

5
techpack/audio/4.0/asoc/codecs/bolero/bolero-cdc-registers.h
View File

@@ -716,11 +716,6 @@
#define BOLERO_CDC_VA_MACRO_TOP_MAX 0x34 /* 0x0CC/4 = 0x33 + 1 = 0x34 */
#define BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL0 (VA_START_OFFSET + 0x00D0)
#define BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL1 (VA_START_OFFSET + 0x00D4)
#define BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL2 (VA_START_OFFSET + 0x00D8)
#define BOLERO_CDC_VA_TOP_CSR_SWR_CTRL (VA_START_OFFSET + 0x00DC)
#define BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0 (VA_START_OFFSET + 0x0100)
#define BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG1 (VA_START_OFFSET + 0x0104)
#define BOLERO_CDC_VA_INP_MUX_ADC_MUX1_CFG0 (VA_START_OFFSET + 0x0108)

14
techpack/audio/4.0/asoc/codecs/bolero/bolero-cdc-regmap.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018, 2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018, The Linux Foundation. All rights reserved.
*/
#include <linux/regmap.h>
@@ -625,10 +625,6 @@ static const struct reg_default bolero_defaults[] = {
{ BOLERO_CDC_VA_TOP_CSR_CORE_ID_1, 0x00},
{ BOLERO_CDC_VA_TOP_CSR_CORE_ID_2, 0x00},
{ BOLERO_CDC_VA_TOP_CSR_CORE_ID_3, 0x00},
{ BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL0, 0xEE},
{ BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL1, 0xEE},
{ BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL2, 0xEE},
{ BOLERO_CDC_VA_TOP_CSR_SWR_CTRL, 0x06},
/* VA core */
{ BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0, 0x00},
@@ -797,14 +793,6 @@ static bool bolero_is_volatile_register(struct device *dev,
case BOLERO_CDC_VA_TOP_CSR_CORE_ID_1:
case BOLERO_CDC_VA_TOP_CSR_CORE_ID_2:
case BOLERO_CDC_VA_TOP_CSR_CORE_ID_3:
case BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL:
case BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL:
case BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL:
case BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL:
case BOLERO_CDC_TX_TOP_CSR_SWR_DMIC0_CTL:
case BOLERO_CDC_TX_TOP_CSR_SWR_DMIC1_CTL:
case BOLERO_CDC_TX_TOP_CSR_SWR_DMIC2_CTL:
case BOLERO_CDC_TX_TOP_CSR_SWR_DMIC3_CTL:
case BOLERO_CDC_WSA_VBAT_BCL_VBAT_GAIN_MON_VAL:
case BOLERO_CDC_WSA_VBAT_BCL_VBAT_DECODE_ST:
case BOLERO_CDC_WSA_INTR_CTRL_PIN1_STATUS0:

220
techpack/audio/4.0/asoc/codecs/bolero/bolero-cdc-tables.c
View File

@@ -149,96 +149,6 @@ u8 bolero_tx_reg_access[BOLERO_CDC_TX_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_TX7_TX_PATH_SEC6)] = RD_WR_REG,
};
u8 bolero_tx_reg_access_v2[BOLERO_CDC_TX_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_CLK_RST_CTRL_FS_CNT_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_CLK_RST_CTRL_SWR_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_TOP_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_ANC_CFG)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_CTRL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_FREQ_MCLK)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_DEBUG_BUS)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_DEBUG_EN)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_TX_I2S_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_I2S_CLK)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_I2S_RESET)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_DMIC0_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_DMIC1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_DMIC2_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_DMIC3_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_AMIC0_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_TOP_CSR_SWR_AMIC1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_CLK_RESET_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_MODE_1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_MODE_2_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_FF_SHIFT)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_FB_SHIFT)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_LPF_FF_A_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_LPF_FF_B_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_LPF_FB_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_SMLPF_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_DCFLT_SHIFT_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_IIR_ADAPT_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_IIR_COEFF_1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_IIR_COEFF_2_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_FF_A_GAIN_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_FF_B_GAIN_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_ANC0_FB_GAIN_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX1_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX1_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX2_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX2_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX3_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX_INP_MUX_ADC_MUX3_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX0_TX_PATH_SEC7)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX1_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX2_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_TX3_TX_PATH_SEC6)] = RD_WR_REG,
};
u8 bolero_rx_reg_access[BOLERO_CDC_RX_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_RX_TOP_TOP_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_RX_TOP_SWR_CTRL)] = RD_WR_REG,
@@ -671,136 +581,6 @@ u8 bolero_va_top_reg_access[BOLERO_CDC_VA_MACRO_TOP_MAX] = {
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_3)] = RD_REG,
};
u8 bolero_va_reg_access_v2[BOLERO_CDC_VA_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_MCLK_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_FS_CNT_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_SWR_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_TOP_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC_CFG)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DEBUG_BUS)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DEBUG_EN)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_TX_I2S_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_I2S_CLK)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_I2S_RESET)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_0)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_1)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_2)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_3)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_CTRL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX1_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX1_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC7)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC6)] = RD_WR_REG,
};
u8 bolero_va_reg_access_v3[BOLERO_CDC_VA_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_MCLK_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_FS_CNT_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_CLK_RST_CTRL_SWR_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_TOP_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DMIC_CFG)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DEBUG_BUS)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_DEBUG_EN)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_TX_I2S_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_I2S_CLK)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_I2S_RESET)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_0)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_1)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_2)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_CORE_ID_3)] = RD_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TOP_CSR_SWR_CTRL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX1_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX1_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX2_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX2_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX3_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_INP_MUX_ADC_MUX3_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX0_TX_PATH_SEC7)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX1_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX2_TX_PATH_SEC6)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_CFG0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_CFG1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_VOL_CTL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC0)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC1)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC2)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC3)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC4)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC5)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_VA_TX3_TX_PATH_SEC6)] = RD_WR_REG,
};
u8 bolero_wsa_reg_access[BOLERO_CDC_WSA_MACRO_MAX] = {
[BOLERO_REG(BOLERO_CDC_WSA_CLK_RST_CTRL_MCLK_CONTROL)] = RD_WR_REG,
[BOLERO_REG(BOLERO_CDC_WSA_CLK_RST_CTRL_FS_CNT_CONTROL)] = RD_WR_REG,

275
techpack/audio/4.0/asoc/codecs/bolero/bolero-cdc.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/of_platform.h>
@@ -14,7 +14,6 @@
#include <soc/snd_event.h>
#include <linux/pm_runtime.h>
#include <soc/swr-common.h>
#include <dsp/digital-cdc-rsc-mgr.h>
#include "bolero-cdc.h"
#include "internal.h"
#include "bolero-clk-rsc.h"
@@ -100,32 +99,24 @@ static int __bolero_reg_read(struct bolero_priv *priv,
goto ssr_err;
}
if (priv->macro_params[VA_MACRO].dev) {
if (priv->macro_params[VA_MACRO].dev)
pm_runtime_get_sync(priv->macro_params[VA_MACRO].dev);
if (!bolero_check_core_votes(priv->macro_params[VA_MACRO].dev))
goto ssr_err;
}
if (priv->version < BOLERO_VERSION_2_0) {
/* Request Clk before register access */
ret = bolero_clk_rsc_request_clock(
priv->macro_params[macro_id].dev,
/* Request Clk before register access */
ret = bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
priv->macro_params[macro_id].default_clk_id,
priv->macro_params[macro_id].clk_id_req,
true);
if (ret < 0) {
dev_err_ratelimited(priv->dev,
"%s: Failed to enable clock, ret:%d\n",
__func__, ret);
goto err;
}
if (ret < 0) {
dev_err_ratelimited(priv->dev,
"%s: Failed to enable clock, ret:%d\n", __func__, ret);
goto err;
}
bolero_ahb_read_device(
priv->macro_params[macro_id].io_base, reg, val);
if (priv->version < BOLERO_VERSION_2_0)
bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
priv->macro_params[macro_id].default_clk_id,
priv->macro_params[macro_id].clk_id_req,
false);
@@ -152,32 +143,24 @@ static int __bolero_reg_write(struct bolero_priv *priv,
ret = -EINVAL;
goto ssr_err;
}
if (priv->macro_params[VA_MACRO].dev) {
if (priv->macro_params[VA_MACRO].dev)
pm_runtime_get_sync(priv->macro_params[VA_MACRO].dev);
if (!bolero_check_core_votes(priv->macro_params[VA_MACRO].dev))
goto ssr_err;
}
if (priv->version < BOLERO_VERSION_2_0) {
/* Request Clk before register access */
ret = bolero_clk_rsc_request_clock(
priv->macro_params[macro_id].dev,
/* Request Clk before register access */
ret = bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
priv->macro_params[macro_id].default_clk_id,
priv->macro_params[macro_id].clk_id_req,
true);
if (ret < 0) {
dev_err_ratelimited(priv->dev,
"%s: Failed to enable clock, ret:%d\n",
__func__, ret);
goto err;
}
if (ret < 0) {
dev_err_ratelimited(priv->dev,
"%s: Failed to enable clock, ret:%d\n", __func__, ret);
goto err;
}
bolero_ahb_write_device(
priv->macro_params[macro_id].io_base, reg, val);
if (priv->version < BOLERO_VERSION_2_0)
bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
bolero_clk_rsc_request_clock(priv->macro_params[macro_id].dev,
priv->macro_params[macro_id].default_clk_id,
priv->macro_params[macro_id].clk_id_req,
false);
@@ -229,14 +212,6 @@ static int bolero_cdc_update_wcd_event(void *handle, u16 event, u32 data)
priv->codec,
BOLERO_MACRO_EVT_BCS_CLK_OFF, data);
break;
#ifdef CONFIG_SND_SOC_IMPED_SENSING
case SEC_WCD_BOLERO_EVT_IMPED_TRUE:
if (priv->macro_params[RX_MACRO].event_handler)
priv->macro_params[RX_MACRO].event_handler(
priv->codec,
SEC_BOLERO_MACRO_EVT_IMPED_TRUE, data);
break;
#endif
default:
dev_err(priv->dev, "%s: Invalid event %d trigger from wcd\n",
__func__, event);
@@ -482,129 +457,6 @@ void bolero_unregister_res_clk(struct device *dev)
}
EXPORT_SYMBOL(bolero_unregister_res_clk);
static u8 bolero_dmic_clk_div_get(struct snd_soc_codec *codec,
int mode)
{
struct bolero_priv* priv = snd_soc_codec_get_drvdata(codec);
int macro = (mode ? VA_MACRO : TX_MACRO);
int ret = 0;
if (priv->macro_params[macro].clk_div_get) {
ret = priv->macro_params[macro].clk_div_get(codec);
if (ret > 0)
return ret;
}
return 1;
}
int bolero_dmic_clk_enable(struct snd_soc_codec *codec,
u32 dmic, u32 tx_mode, bool enable)
{
struct bolero_priv* priv = snd_soc_codec_get_drvdata(codec);
u8 dmic_clk_en = 0x01;
u16 dmic_clk_reg = 0;
s32 *dmic_clk_cnt = NULL;
u8 *dmic_clk_div = NULL;
u8 freq_change_mask = 0;
u8 clk_div = 0;
dev_dbg(codec->dev, "%s: enable: %d, tx_mode:%d, dmic: %d\n",
__func__, enable, tx_mode, dmic);
switch (dmic) {
case 0:
case 1:
dmic_clk_cnt = &(priv->dmic_0_1_clk_cnt);
dmic_clk_div = &(priv->dmic_0_1_clk_div);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL;
freq_change_mask = 0x01;
break;
case 2:
case 3:
dmic_clk_cnt = &(priv->dmic_2_3_clk_cnt);
dmic_clk_div = &(priv->dmic_2_3_clk_div);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL;
freq_change_mask = 0x02;
break;
case 4:
case 5:
dmic_clk_cnt = &(priv->dmic_4_5_clk_cnt);
dmic_clk_div = &(priv->dmic_4_5_clk_div);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL;
freq_change_mask = 0x04;
break;
case 6:
case 7:
dmic_clk_cnt = &(priv->dmic_6_7_clk_cnt);
dmic_clk_div = &(priv->dmic_6_7_clk_div);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL;
freq_change_mask = 0x08;
break;
default:
dev_err(codec->dev, "%s: Invalid DMIC Selection\n",
__func__);
return -EINVAL;
}
dev_dbg(codec->dev, "%s: DMIC%d dmic_clk_cnt %d\n",
__func__, dmic, *dmic_clk_cnt);
if (enable) {
clk_div = bolero_dmic_clk_div_get(codec, tx_mode);
(*dmic_clk_cnt)++;
if (*dmic_clk_cnt == 1) {
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
0x80, 0x00);
snd_soc_update_bits(codec, dmic_clk_reg,
0x0E, clk_div << 0x1);
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, dmic_clk_en);
} else {
if (*dmic_clk_div > clk_div) {
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
freq_change_mask, freq_change_mask);
snd_soc_update_bits(codec, dmic_clk_reg,
0x0E, clk_div << 0x1);
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
freq_change_mask, 0x00);
} else {
clk_div = *dmic_clk_div;
}
}
*dmic_clk_div = clk_div;
} else {
(*dmic_clk_cnt)--;
if (*dmic_clk_cnt == 0) {
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, 0);
clk_div = 0;
snd_soc_update_bits(codec, dmic_clk_reg,
0x0E, clk_div << 0x1);
} else {
clk_div = bolero_dmic_clk_div_get(codec, tx_mode);
if (*dmic_clk_div > clk_div) {
clk_div = bolero_dmic_clk_div_get(codec, !tx_mode);
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
freq_change_mask, freq_change_mask);
snd_soc_update_bits(codec, dmic_clk_reg,
0x0E, clk_div << 0x1);
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
freq_change_mask, 0x00);
} else {
clk_div = *dmic_clk_div;
}
}
*dmic_clk_div = clk_div;
}
return 0;
}
EXPORT_SYMBOL(bolero_dmic_clk_enable);
/**
* bolero_register_macro - Registers macro to bolero
*
@@ -652,11 +504,7 @@ int bolero_register_macro(struct device *dev, u16 macro_id,
priv->macro_params[macro_id].clk_switch = ops->clk_switch;
priv->macro_params[macro_id].reg_evt_listener =
ops->reg_evt_listener;
priv->macro_params[macro_id].clk_enable = ops->clk_enable;
}
if (macro_id == TX_MACRO || macro_id == VA_MACRO)
priv->macro_params[macro_id].clk_div_get = ops->clk_div_get;
if (priv->version == BOLERO_VERSION_2_1) {
if (macro_id == VA_MACRO)
priv->macro_params[macro_id].reg_wake_irq =
@@ -726,10 +574,7 @@ void bolero_unregister_macro(struct device *dev, u16 macro_id)
priv->macro_params[macro_id].reg_wake_irq = NULL;
priv->macro_params[macro_id].clk_switch = NULL;
priv->macro_params[macro_id].reg_evt_listener = NULL;
priv->macro_params[macro_id].clk_enable = NULL;
}
if (macro_id == TX_MACRO || macro_id == VA_MACRO)
priv->macro_params[macro_id].clk_div_get = NULL;
priv->num_dais -= priv->macro_params[macro_id].num_dais;
priv->num_macros_registered--;
@@ -840,11 +685,6 @@ static int bolero_ssr_enable(struct device *dev, void *data)
priv->codec,
BOLERO_MACRO_EVT_CLK_RESET, 0x0);
}
if (priv->rsc_clk_cb)
priv->rsc_clk_cb(priv->clk_dev, BOLERO_MACRO_EVT_SSR_GFMUX_UP);
trace_printk("%s: clk count reset\n", __func__);
regcache_cache_only(priv->regmap, false);
mutex_lock(&priv->clk_lock);
priv->dev_up = true;
@@ -855,7 +695,6 @@ static int bolero_ssr_enable(struct device *dev, void *data)
/* Add a 100usec sleep to ensure last register write is done */
usleep_range(100,110);
bolero_clk_rsc_enable_all_clocks(priv->clk_dev, false);
trace_printk("%s: regcache_sync done\n", __func__);
/* call ssr event for supported macros */
for (macro_idx = START_MACRO; macro_idx < MAX_MACRO; macro_idx++) {
if (!priv->macro_params[macro_idx].event_handler)
@@ -863,7 +702,6 @@ static int bolero_ssr_enable(struct device *dev, void *data)
priv->macro_params[macro_idx].event_handler(priv->codec,
BOLERO_MACRO_EVT_SSR_UP, 0x0);
}
trace_printk("%s: SSR up events processed by all macros\n", __func__);
bolero_cdc_notifier_call(priv, BOLERO_WCD_EVT_SSR_UP);
return 0;
}
@@ -873,12 +711,6 @@ static void bolero_ssr_disable(struct device *dev, void *data)
struct bolero_priv *priv = data;
int macro_idx;
if (!priv->dev_up) {
dev_err_ratelimited(priv->dev,
"%s: already disabled\n", __func__);
return;
}
bolero_cdc_notifier_call(priv, BOLERO_WCD_EVT_PA_OFF_PRE_SSR);
regcache_cache_only(priv->regmap, true);
@@ -1007,11 +839,9 @@ EXPORT_SYMBOL(bolero_register_wake_irq);
*
* @codec: pointer to codec instance.
*
* @clk_src: 0 for TX_RCG and 1 for VA_RCG 994
*
* Returns 0 on success or -EINVAL on error.
*/
int bolero_tx_clk_switch(struct snd_soc_codec *codec, int clk_src)
int bolero_tx_clk_switch(struct snd_soc_codec *codec)
{
struct bolero_priv *priv = NULL;
int ret = 0;
@@ -1029,46 +859,12 @@ int bolero_tx_clk_switch(struct snd_soc_codec *codec, int clk_src)
}
if (priv->macro_params[TX_MACRO].clk_switch)
ret = priv->macro_params[TX_MACRO].clk_switch(codec, clk_src);
ret = priv->macro_params[TX_MACRO].clk_switch(codec);
return ret;
}
EXPORT_SYMBOL(bolero_tx_clk_switch);
/**
* bolero_tx_mclk_enable - Enable/Disable TX Macro mclk
*
* @component: pointer to codec component instance.
* @enable: set true to enable, otherwise false.
*
* Returns 0 on success or -EINVAL on error.
*/
int bolero_tx_mclk_enable(struct snd_soc_codec *codec,
bool enable)
{
struct bolero_priv *priv = NULL;
int ret = 0;
if (!codec)
return -EINVAL;
priv = snd_soc_codec_get_drvdata(codec);
if (!priv)
return -EINVAL;
if (!bolero_is_valid_codec_dev(priv->dev)) {
dev_err(codec->dev, "%s: invalid codec\n", __func__);
return -EINVAL;
}
if (priv->macro_params[TX_MACRO].clk_enable)
ret = priv->macro_params[TX_MACRO].clk_enable(codec,
enable);
return ret;
}
EXPORT_SYMBOL(bolero_tx_mclk_enable);
/**
* bolero_register_event_listener - Register/Deregister to event listener
*
@@ -1103,7 +899,6 @@ int bolero_register_event_listener(struct snd_soc_codec *codec,
return ret;
}
EXPORT_SYMBOL(bolero_register_event_listener);
static int bolero_soc_codec_probe(struct snd_soc_codec *codec)
{
struct bolero_priv *priv = dev_get_drvdata(codec->dev);
@@ -1237,9 +1032,10 @@ static void bolero_add_child_devices(struct work_struct *work)
pdev->dev.parent = priv->dev;
pdev->dev.of_node = node;
priv->dev->platform_data = platdata;
if (split_codec)
if (split_codec) {
priv->dev->platform_data = platdata;
priv->wcd_dev = &pdev->dev;
}
ret = platform_device_add(pdev);
if (ret) {
@@ -1302,13 +1098,6 @@ static int bolero_probe(struct platform_device *pdev)
__func__);
ret = 0;
}
if (priv->version == BOLERO_VERSION_2_1) {
bolero_reg_access[TX_MACRO] = bolero_tx_reg_access_v2;
bolero_reg_access[VA_MACRO] = bolero_va_reg_access_v2;
} else if (priv->version == BOLERO_VERSION_2_0) {
bolero_reg_access[VA_MACRO] = bolero_va_reg_access_v3;
}
priv->dev = &pdev->dev;
priv->dev_up = true;
priv->initial_boot = true;
@@ -1375,7 +1164,6 @@ static int bolero_remove(struct platform_device *pdev)
return 0;
}
#ifdef CONFIG_PM
int bolero_runtime_resume(struct device *dev)
{
struct bolero_priv *priv = dev_get_drvdata(dev->parent);
@@ -1388,7 +1176,7 @@ int bolero_runtime_resume(struct device *dev)
}
if (priv->core_hw_vote_count == 0) {
ret = digital_cdc_rsc_mgr_hw_vote_enable(priv->lpass_core_hw_vote);
ret = clk_prepare_enable(priv->lpass_core_hw_vote);
if (ret < 0) {
dev_err(dev, "%s:lpass core hw enable failed\n",
__func__);
@@ -1396,8 +1184,6 @@ int bolero_runtime_resume(struct device *dev)
}
}
priv->core_hw_vote_count++;
trace_printk("%s: hw vote count %d\n",
__func__, priv->core_hw_vote_count);
audio_vote:
if (priv->lpass_audio_hw_vote == NULL) {
@@ -1406,7 +1192,7 @@ audio_vote:
}
if (priv->core_audio_vote_count == 0) {
ret = digital_cdc_rsc_mgr_hw_vote_enable(priv->lpass_audio_hw_vote);
ret = clk_prepare_enable(priv->lpass_audio_hw_vote);
if (ret < 0) {
dev_err(dev, "%s:lpass audio hw enable failed\n",
__func__);
@@ -1414,8 +1200,6 @@ audio_vote:
}
}
priv->core_audio_vote_count++;
trace_printk("%s: audio vote count %d\n",
__func__, priv->core_audio_vote_count);
done:
mutex_unlock(&priv->vote_lock);
@@ -1431,35 +1215,28 @@ int bolero_runtime_suspend(struct device *dev)
mutex_lock(&priv->vote_lock);
if (priv->lpass_core_hw_vote != NULL) {
if (--priv->core_hw_vote_count == 0)
digital_cdc_rsc_mgr_hw_vote_disable(
priv->lpass_core_hw_vote);
clk_disable_unprepare(priv->lpass_core_hw_vote);
if (priv->core_hw_vote_count < 0)
priv->core_hw_vote_count = 0;
} else {
dev_dbg(dev, "%s: Invalid lpass core hw node\n",
__func__);
}
trace_printk("%s: hw vote count %d\n",
__func__, priv->core_hw_vote_count);
if (priv->lpass_audio_hw_vote != NULL) {
if (--priv->core_audio_vote_count == 0)
digital_cdc_rsc_mgr_hw_vote_disable(
priv->lpass_audio_hw_vote);
clk_disable_unprepare(priv->lpass_audio_hw_vote);
if (priv->core_audio_vote_count < 0)
priv->core_audio_vote_count = 0;
} else {
dev_dbg(dev, "%s: Invalid lpass audio hw node\n",
__func__);
}
trace_printk("%s: audio vote count %d\n",
__func__, priv->core_audio_vote_count);
mutex_unlock(&priv->vote_lock);
return 0;
}
EXPORT_SYMBOL(bolero_runtime_suspend);
#endif /* CONFIG_PM */
bool bolero_check_core_votes(struct device *dev)
{

53
techpack/audio/4.0/asoc/codecs/bolero/bolero-cdc.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#ifndef BOLERO_CDC_H
@@ -37,11 +37,6 @@ enum {
BOLERO_ADC_MAX
};
enum {
CLK_SRC_TX_RCG = 0,
CLK_SRC_VA_RCG,
};
enum {
BOLERO_MACRO_EVT_RX_MUTE = 1, /* for RX mute/unmute */
BOLERO_MACRO_EVT_IMPED_TRUE, /* for imped true */
@@ -52,29 +47,7 @@ enum {
BOLERO_MACRO_EVT_CLK_RESET,
BOLERO_MACRO_EVT_REG_WAKE_IRQ,
BOLERO_MACRO_EVT_RX_COMPANDER_SOFT_RST,
BOLERO_MACRO_EVT_BCS_CLK_OFF,
BOLERO_MACRO_EVT_SSR_GFMUX_UP,
#ifdef CONFIG_SND_SOC_IMPED_SENSING
SEC_BOLERO_MACRO_EVT_IMPED_TRUE,
#endif
};
enum {
DMIC_TX = 0,
DMIC_VA = 1,
};
enum {
DMIC0 = 0,
DMIC1,
DMIC2,
DMIC3,
DMIC4,
DMIC5,
DMIC6,
DMIC7,
DMIC_MAX
BOLERO_MACRO_EVT_BCS_CLK_OFF
};
struct macro_ops {
@@ -89,10 +62,8 @@ struct macro_ops {
int (*reg_wake_irq)(struct snd_soc_codec *codec, u32 data);
int (*set_port_map)(struct snd_soc_codec *codec, u32 uc,
u32 size, void *data);
int (*clk_div_get)(struct snd_soc_codec *codec);
int (*clk_switch)(struct snd_soc_codec *codec, int clk_src);
int (*clk_switch)(struct snd_soc_codec *codec);
int (*reg_evt_listener)(struct snd_soc_codec *codec, bool en);
int (*clk_enable)(struct snd_soc_codec *c, bool en);
char __iomem *io_base;
u16 clk_id_req;
u16 default_clk_id;
@@ -116,15 +87,12 @@ void bolero_clear_amic_tx_hold(struct device *dev, u16 adc_n);
int bolero_runtime_resume(struct device *dev);
int bolero_runtime_suspend(struct device *dev);
int bolero_set_port_map(struct snd_soc_codec *codec, u32 size, void *data);
int bolero_tx_clk_switch(struct snd_soc_codec *codec, int clk_src);
int bolero_tx_clk_switch(struct snd_soc_codec *codec);
int bolero_register_event_listener(struct snd_soc_codec *codec,
bool enable);
void bolero_wsa_pa_on(struct device *dev);
bool bolero_check_core_votes(struct device *dev);
int bolero_tx_mclk_enable(struct snd_soc_codec *c, bool enable);
int bolero_get_version(struct device *dev);
int bolero_dmic_clk_enable(struct snd_soc_codec *codec,
u32 dmic, u32 tx_mode, bool enable);
#else
static inline int bolero_register_res_clk(struct device *dev, rsc_clk_cb_t cb)
{
@@ -184,8 +152,7 @@ static inline int bolero_set_port_map(struct snd_soc_codec codec,
return 0;
}
static inline int bolero_tx_clk_switch(struct snd_soc_codec *codec,
int clk_src)
static inline int bolero_tx_clk_switch(struct snd_soc_codec *codec)
{
return 0;
}
@@ -210,15 +177,5 @@ static int bolero_get_version(struct device *dev)
{
return 0;
}
static int bolero_dmic_clk_enable(struct snd_soc_codec *codec,
u32 dmic, u32 tx_mode, bool enable)
{
return 0;
}
static int bolero_tx_mclk_enable(struct snd_soc_codec *c, bool enable)
{
return 0;
}
#endif /* CONFIG_SND_SOC_BOLERO */
#endif /* BOLERO_CDC_H */

84
techpack/audio/4.0/asoc/codecs/bolero/bolero-clk-rsc.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2019, The Linux Foundation. All rights reserved.
*/
#include <linux/of_platform.h>
@@ -32,13 +32,11 @@ static char clk_src_name[MAX_CLK][BOLERO_CLK_NAME_LENGTH] = {
struct bolero_clk_rsc {
struct device *dev;
struct mutex rsc_clk_lock;
struct mutex fs_gen_lock;
struct clk *clk[MAX_CLK];
int clk_cnt[MAX_CLK];
int reg_seq_en_cnt;
int va_tx_clk_cnt;
bool dev_up;
bool dev_up_gfmux;
u32 num_fs_reg;
u32 *fs_gen_seq;
int default_clk_id[MAX_CLK];
@@ -66,14 +64,10 @@ static int bolero_clk_rsc_cb(struct device *dev, u16 event)
}
mutex_lock(&priv->rsc_clk_lock);
if (event == BOLERO_MACRO_EVT_SSR_UP) {
if (event == BOLERO_MACRO_EVT_SSR_UP)
priv->dev_up = true;
} else if (event == BOLERO_MACRO_EVT_SSR_DOWN) {
else if (event == BOLERO_MACRO_EVT_SSR_DOWN)
priv->dev_up = false;
priv->dev_up_gfmux = false;
} else if (event == BOLERO_MACRO_EVT_SSR_GFMUX_UP) {
priv->dev_up_gfmux = true;
}
mutex_unlock(&priv->rsc_clk_lock);
return 0;
@@ -134,8 +128,6 @@ int bolero_rsc_clk_reset(struct device *dev, int clk_id)
}
dev_dbg(priv->dev,
"%s: clock reset after ssr, count %d\n", __func__, count);
trace_printk("%s: clock reset after ssr, count %d\n", __func__, count);
while (count--) {
clk_prepare_enable(priv->clk[clk_id]);
clk_prepare_enable(priv->clk[clk_id + NPL_CLK_OFFSET]);
@@ -245,7 +237,6 @@ static int bolero_clk_rsc_mux1_clk_request(struct bolero_clk_rsc *priv,
char __iomem *clk_muxsel = NULL;
int ret = 0;
int default_clk_id = priv->default_clk_id[clk_id];
u32 muxsel = 0;
clk_muxsel = bolero_clk_rsc_get_clk_muxsel(priv, clk_id);
if (!clk_muxsel) {
@@ -255,13 +246,10 @@ static int bolero_clk_rsc_mux1_clk_request(struct bolero_clk_rsc *priv,
if (enable) {
if (priv->clk_cnt[clk_id] == 0) {
if (clk_id != VA_CORE_CLK) {
ret = bolero_clk_rsc_mux0_clk_request(priv,
default_clk_id,
ret = bolero_clk_rsc_mux0_clk_request(priv, default_clk_id,
true);
if (ret < 0)
goto done;
}
if (ret < 0)
goto done;
ret = clk_prepare_enable(priv->clk[clk_id]);
if (ret < 0) {
@@ -279,24 +267,9 @@ static int bolero_clk_rsc_mux1_clk_request(struct bolero_clk_rsc *priv,
goto err_npl_clk;
}
}
/*
* Temp SW workaround to address a glitch issue of
* VA GFMux instance responsible for switching from
* TX MCLK to VA MCLK. This configuration would be taken
* care in DSP itself
*/
if (clk_id != VA_CORE_CLK) {
if (priv->dev_up_gfmux) {
iowrite32(0x1, clk_muxsel);
muxsel = ioread32(clk_muxsel);
trace_printk("%s: muxsel value after enable: %d\n",
__func__, muxsel);
}
bolero_clk_rsc_mux0_clk_request(priv,
default_clk_id,
iowrite32(0x1, clk_muxsel);
bolero_clk_rsc_mux0_clk_request(priv, default_clk_id,
false);
}
}
priv->clk_cnt[clk_id]++;
} else {
@@ -308,36 +281,20 @@ static int bolero_clk_rsc_mux1_clk_request(struct bolero_clk_rsc *priv,
}
priv->clk_cnt[clk_id]--;
if (priv->clk_cnt[clk_id] == 0) {
if (clk_id != VA_CORE_CLK) {
ret = bolero_clk_rsc_mux0_clk_request(priv,
ret = bolero_clk_rsc_mux0_clk_request(priv,
default_clk_id, true);
if (!ret) {
/*
* Temp SW workaround to address a glitch issue
* of VA GFMux instance responsible for
* switching from TX MCLK to VA MCLK.
* This configuration would be taken
* care in DSP itself.
*/
if (priv->dev_up_gfmux) {
iowrite32(0x0, clk_muxsel);
muxsel = ioread32(clk_muxsel);
trace_printk("%s: muxsel value after disable: %d\n",
__func__, muxsel);
}
}
}
if (!ret)
iowrite32(0x0, clk_muxsel);
if (priv->clk[clk_id + NPL_CLK_OFFSET])
clk_disable_unprepare(
priv->clk[clk_id + NPL_CLK_OFFSET]);
clk_disable_unprepare(priv->clk[clk_id]);
if (clk_id != VA_CORE_CLK) {
if (!ret)
bolero_clk_rsc_mux0_clk_request(priv,
if (!ret)
bolero_clk_rsc_mux0_clk_request(priv,
default_clk_id, false);
}
}
}
return ret;
@@ -346,8 +303,7 @@ err_npl_clk:
clk_disable_unprepare(priv->clk[clk_id]);
err_clk:
if (clk_id != VA_CORE_CLK)
bolero_clk_rsc_mux0_clk_request(priv, default_clk_id, false);
bolero_clk_rsc_mux0_clk_request(priv, default_clk_id, false);
done:
return ret;
}
@@ -466,7 +422,6 @@ void bolero_clk_rsc_fs_gen_request(struct device *dev, bool enable)
pr_err("%s: regmap is null\n", __func__);
return;
}
mutex_lock(&priv->fs_gen_lock);
if (enable) {
if (priv->reg_seq_en_cnt++ == 0) {
for (i = 0; i < (priv->num_fs_reg * 2); i += 2) {
@@ -484,7 +439,6 @@ void bolero_clk_rsc_fs_gen_request(struct device *dev, bool enable)
dev_err_ratelimited(priv->dev, "%s: req_seq_cnt: %d is already disabled\n",
__func__, priv->reg_seq_en_cnt);
priv->reg_seq_en_cnt = 0;
mutex_unlock(&priv->fs_gen_lock);
return;
}
if (--priv->reg_seq_en_cnt == 0) {
@@ -497,7 +451,6 @@ void bolero_clk_rsc_fs_gen_request(struct device *dev, bool enable)
}
}
}
mutex_unlock(&priv->fs_gen_lock);
}
EXPORT_SYMBOL(bolero_clk_rsc_fs_gen_request);
@@ -547,7 +500,6 @@ int bolero_clk_rsc_request_clock(struct device *dev,
if (!priv->dev_up && enable) {
dev_err_ratelimited(priv->dev, "%s: SSR is in progress..\n",
__func__);
trace_printk("%s: SSR is in progress..\n", __func__);
ret = -EINVAL;
goto err;
}
@@ -577,9 +529,6 @@ int bolero_clk_rsc_request_clock(struct device *dev,
dev_dbg(priv->dev, "%s: clk_cnt: %d for requested clk: %d, enable: %d\n",
__func__, priv->clk_cnt[clk_id_req], clk_id_req,
enable);
trace_printk("%s: clk_cnt: %d for requested clk: %d, enable: %d\n",
__func__, priv->clk_cnt[clk_id_req], clk_id_req,
enable);
mutex_unlock(&priv->rsc_clk_lock);
@@ -715,9 +664,7 @@ static int bolero_clk_rsc_probe(struct platform_device *pdev)
}
priv->dev = &pdev->dev;
priv->dev_up = true;
priv->dev_up_gfmux = true;
mutex_init(&priv->rsc_clk_lock);
mutex_init(&priv->fs_gen_lock);
dev_set_drvdata(&pdev->dev, priv);
err:
@@ -733,7 +680,6 @@ static int bolero_clk_rsc_remove(struct platform_device *pdev)
if (!priv)
return -EINVAL;
mutex_destroy(&priv->rsc_clk_lock);
mutex_destroy(&priv->fs_gen_lock);
return 0;
}

16
techpack/audio/4.0/asoc/codecs/bolero/internal.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#ifndef _BOLERO_INTERNAL_H
@@ -32,9 +32,6 @@ enum {
WCD_BOLERO_EVT_IMPED_FALSE, /* for imped false */
WCD_BOLERO_EVT_RX_COMPANDER_SOFT_RST,
WCD_BOLERO_EVT_BCS_CLK_OFF,
#ifdef CONFIG_SND_SOC_IMPED_SENSING
SEC_WCD_BOLERO_EVT_IMPED_TRUE, /* for SEC imped true */
#endif
};
struct wcd_ctrl_platform_data {
@@ -85,14 +82,6 @@ struct bolero_priv {
struct blocking_notifier_head notifier;
struct device *clk_dev;
rsc_clk_cb_t rsc_clk_cb;
s32 dmic_0_1_clk_cnt;
s32 dmic_2_3_clk_cnt;
s32 dmic_4_5_clk_cnt;
s32 dmic_6_7_clk_cnt;
u8 dmic_0_1_clk_div;
u8 dmic_2_3_clk_div;
u8 dmic_4_5_clk_div;
u8 dmic_6_7_clk_div;
};
struct regmap *bolero_regmap_init(struct device *dev,
@@ -102,9 +91,6 @@ int bolero_get_macro_id(bool va_no_dec_flag, u16 reg);
extern const struct regmap_config bolero_regmap_config;
extern u8 *bolero_reg_access[MAX_MACRO];
extern u8 bolero_va_top_reg_access[BOLERO_CDC_VA_MACRO_TOP_MAX];
extern u8 bolero_va_reg_access_v2[BOLERO_CDC_VA_MACRO_MAX];
extern u8 bolero_va_reg_access_v3[BOLERO_CDC_VA_MACRO_MAX];
extern u8 bolero_tx_reg_access_v2[BOLERO_CDC_TX_MACRO_MAX];
extern const u16 macro_id_base_offset[MAX_MACRO];
#endif

152
techpack/audio/4.0/asoc/codecs/bolero/rx-macro.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -396,10 +396,6 @@ enum {
RX_MACRO_AIF3_CAP,
RX_MACRO_MAX_AIF_CAP_DAIS
};
#ifdef CONFIG_SND_SOC_IMPED_SENSING
static int wcd_impedance_offset;
#endif
/*
* @dev: rx macro device pointer
* @comp_enabled: compander enable mixer value set
@@ -724,61 +720,6 @@ static struct snd_soc_dai_driver rx_macro_dai[] = {
},
};
#ifdef CONFIG_SND_SOC_IMPED_SENSING
static int wcd_impedance_vol_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
struct soc_mixer_control *mc =
(struct soc_mixer_control *)kcontrol->private_value;
unsigned int reg = mc->reg;
unsigned int shift = mc->shift;
int max = mc->max;
int min = mc->min;
unsigned int mask = (1 << (fls(min + max) - 1)) - 1;
unsigned int val;
int ret;
ret = snd_soc_component_read(component, reg, &val);
if (ret < 0)
return ret;
ucontrol->value.integer.value[0] = ((val >> shift) - min) & mask;
return 0;
}
static int wcd_impedance_vol_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct soc_mixer_control *mc =
(struct soc_mixer_control *)kcontrol->private_value;
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
unsigned int reg = mc->reg;
unsigned int shift = mc->shift;
int min = mc->min;
int max = mc->max;
unsigned int mask = (1U << (fls(min + max) - 1)) - 1;
unsigned int val, val_mask;
int ret;
val = (ucontrol->value.integer.value[0] + min) & mask;
pr_info("%s impedance_offset %d\n", __func__, wcd_impedance_offset);
val += wcd_impedance_offset;
val = val << shift;
val_mask = mask << shift;
ret = snd_soc_update_bits(codec, reg, val_mask, val);
if (ret < 0)
return ret;
return ret;
}
#endif
static int get_impedance_index(int imped)
{
int i = 0;
@@ -807,16 +748,6 @@ ret:
return imped_index[i].index;
}
#ifdef CONFIG_SND_SOC_IMPED_SENSING
static void sec_wcd_imp_offset(struct snd_soc_codec *codec,
int imped)
{
wcd_impedance_offset = imped;
pr_info("%s: selected impedance offset = %d\n",
__func__, wcd_impedance_offset);
}
#endif
/*
* rx_macro_wcd_clsh_imped_config -
* This function updates HPHL and HPHR gain settings
@@ -985,7 +916,7 @@ static int rx_macro_set_prim_interpolator_rate(struct snd_soc_dai *dai,
int_mux_cfg0_val = snd_soc_read(codec, int_mux_cfg0);
int_mux_cfg1_val = snd_soc_read(codec, int_mux_cfg1);
inp0_sel = int_mux_cfg0_val & 0x0F;
inp0_sel = int_mux_cfg0_val & 0x07;
inp1_sel = (int_mux_cfg0_val >> 4) & 0x0F;
inp2_sel = (int_mux_cfg1_val >> 4) & 0x0F;
if ((inp0_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0) ||
@@ -1308,9 +1239,6 @@ static int rx_macro_mclk_enable(struct rx_macro_priv *rx_priv,
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_MCLK_CONTROL,
0x02, 0x02);
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x02, 0x00);
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x01);
@@ -1328,12 +1256,6 @@ static int rx_macro_mclk_enable(struct rx_macro_priv *rx_priv,
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x00);
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x02, 0x02);
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_MCLK_CONTROL,
0x02, 0x00);
regmap_update_bits(regmap,
BOLERO_CDC_RX_CLK_RST_CTRL_MCLK_CONTROL,
0x01, 0x00);
@@ -1347,8 +1269,6 @@ static int rx_macro_mclk_enable(struct rx_macro_priv *rx_priv,
}
}
exit:
trace_printk("%s: mclk_enable = %u, dapm = %d clk_users= %d\n",
__func__, mclk_enable, dapm, rx_priv->rx_mclk_users);
mutex_unlock(&rx_priv->mclk_lock);
return ret;
}
@@ -1431,9 +1351,11 @@ static int rx_macro_event_handler(struct snd_soc_codec *codec, u16 event,
rx_macro_wcd_clsh_imped_config(codec, data, false);
break;
case BOLERO_MACRO_EVT_SSR_DOWN:
trace_printk("%s, enter SSR down\n", __func__);
rx_priv->dev_up = false;
if (rx_priv->swr_ctrl_data) {
swrm_wcd_notify(
rx_priv->swr_ctrl_data[0].rx_swr_pdev,
SWR_DEVICE_DOWN, NULL);
swrm_wcd_notify(
rx_priv->swr_ctrl_data[0].rx_swr_pdev,
SWR_DEVICE_SSR_DOWN, NULL);
@@ -1449,7 +1371,6 @@ static int rx_macro_event_handler(struct snd_soc_codec *codec, u16 event,
}
break;
case BOLERO_MACRO_EVT_SSR_UP:
trace_printk("%s, enter SSR up\n", __func__);
rx_priv->dev_up = true;
/* reset swr after ssr/pdr */
rx_priv->reset_swr = true;
@@ -1474,11 +1395,6 @@ static int rx_macro_event_handler(struct snd_soc_codec *codec, u16 event,
case BOLERO_MACRO_EVT_CLK_RESET:
bolero_rsc_clk_reset(rx_dev, RX_CORE_CLK);
break;
#ifdef CONFIG_SND_SOC_IMPED_SENSING
case SEC_BOLERO_MACRO_EVT_IMPED_TRUE:
sec_wcd_imp_offset(codec, data);
break;
#endif
}
done:
return ret;
@@ -1734,9 +1650,7 @@ static int rx_macro_config_compander(struct snd_soc_codec *codec,
int interp_n, int event)
{
int comp = 0;
u16 comp_ctl0_reg = 0, rx_path_cfg0_reg = 0, rx_path_cfg3_reg = 0;
u16 rx0_path_ctl_reg = 0;
u8 pcm_rate = 0, val = 0;
u16 comp_ctl0_reg = 0, rx_path_cfg0_reg = 0;
/* AUX does not have compander */
if (interp_n == INTERP_AUX)
@@ -1753,20 +1667,6 @@ static int rx_macro_config_compander(struct snd_soc_codec *codec,
(comp * RX_MACRO_COMP_OFFSET);
rx_path_cfg0_reg = BOLERO_CDC_RX_RX0_RX_PATH_CFG0 +
(comp * RX_MACRO_RX_PATH_OFFSET);
rx_path_cfg3_reg = BOLERO_CDC_RX_RX0_RX_PATH_CFG3 +
(comp * RX_MACRO_RX_PATH_OFFSET);
rx0_path_ctl_reg = BOLERO_CDC_RX_RX0_RX_PATH_CTL +
(comp * RX_MACRO_RX_PATH_OFFSET);
pcm_rate = (snd_soc_read(codec, rx0_path_ctl_reg)
& 0x0F);
if (pcm_rate < 0x06)
val = 0x03;
else if (pcm_rate < 0x08)
val = 0x01;
else if (pcm_rate < 0x0B)
val = 0x02;
else
val = 0x00;
if (SND_SOC_DAPM_EVENT_ON(event)) {
/* Enable Compander Clock */
@@ -1774,7 +1674,6 @@ static int rx_macro_config_compander(struct snd_soc_codec *codec,
snd_soc_update_bits(codec, comp_ctl0_reg, 0x02, 0x02);
snd_soc_update_bits(codec, comp_ctl0_reg, 0x02, 0x00);
snd_soc_update_bits(codec, rx_path_cfg0_reg, 0x02, 0x02);
snd_soc_update_bits(codec, rx_path_cfg3_reg, 0x03, val);
}
if (SND_SOC_DAPM_EVENT_OFF(event)) {
@@ -1782,8 +1681,6 @@ static int rx_macro_config_compander(struct snd_soc_codec *codec,
snd_soc_update_bits(codec, rx_path_cfg0_reg, 0x02, 0x00);
snd_soc_update_bits(codec, comp_ctl0_reg, 0x01, 0x00);
snd_soc_update_bits(codec, comp_ctl0_reg, 0x04, 0x00);
snd_soc_update_bits(codec, rx_path_cfg3_reg,
0x03, 0x03);
}
return 0;
@@ -2563,6 +2460,7 @@ static int rx_macro_enable_interp_clk(struct snd_soc_codec *codec,
/* Main path PGA mute enable */
snd_soc_update_bits(codec, main_reg, 0x10, 0x10);
snd_soc_update_bits(codec, dsm_reg, 0x01, 0x01);
snd_soc_update_bits(codec, main_reg, 0x20, 0x20);
snd_soc_update_bits(codec, rx_cfg2_reg, 0x03, 0x03);
rx_macro_load_compander_coeff(codec, rx_priv,
interp_idx, event);
@@ -2963,16 +2861,6 @@ static const struct snd_kcontrol_new rx_macro_snd_controls[] = {
SOC_SINGLE_SX_TLV("RX_RX2 Digital Volume",
BOLERO_CDC_RX_RX2_RX_VOL_CTL,
0, -84, 40, digital_gain),
#ifdef CONFIG_SND_SOC_IMPED_SENSING
SOC_SINGLE_RANGE_EXT_TLV("RX_RX0 HPH Digital Volume",
BOLERO_CDC_RX_RX0_RX_VOL_CTL, 0, -84, 40, 0,
wcd_impedance_vol_get, wcd_impedance_vol_put,
digital_gain),
SOC_SINGLE_RANGE_EXT_TLV("RX_RX1 HPH Digital Volume",
BOLERO_CDC_RX_RX1_RX_VOL_CTL, 0, -84, 40, 0,
wcd_impedance_vol_get, wcd_impedance_vol_put,
digital_gain),
#endif
SOC_SINGLE_SX_TLV("RX_RX0 Mix Digital Volume",
BOLERO_CDC_RX_RX0_RX_VOL_MIX_CTL, 0, -84, 40, digital_gain),
SOC_SINGLE_SX_TLV("RX_RX1 Mix Digital Volume",
@@ -3331,8 +3219,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT0_1 MIX1 INP0", "RX5", "RX_RX5"},
{"RX INT0_1 MIX1 INP0", "IIR0", "IIR0"},
{"RX INT0_1 MIX1 INP0", "IIR1", "IIR1"},
{"RX INT0_1 MIX1 INP0", "DEC0", "RX_TX DEC0_INP"},
{"RX INT0_1 MIX1 INP0", "DEC1", "RX_TX DEC1_INP"},
{"RX INT0_1 MIX1 INP1", "RX0", "RX_RX0"},
{"RX INT0_1 MIX1 INP1", "RX1", "RX_RX1"},
{"RX INT0_1 MIX1 INP1", "RX2", "RX_RX2"},
@@ -3341,8 +3227,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT0_1 MIX1 INP1", "RX5", "RX_RX5"},
{"RX INT0_1 MIX1 INP1", "IIR0", "IIR0"},
{"RX INT0_1 MIX1 INP1", "IIR1", "IIR1"},
{"RX INT0_1 MIX1 INP1", "DEC0", "RX_TX DEC0_INP"},
{"RX INT0_1 MIX1 INP1", "DEC1", "RX_TX DEC1_INP"},
{"RX INT0_1 MIX1 INP2", "RX0", "RX_RX0"},
{"RX INT0_1 MIX1 INP2", "RX1", "RX_RX1"},
{"RX INT0_1 MIX1 INP2", "RX2", "RX_RX2"},
@@ -3351,8 +3235,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT0_1 MIX1 INP2", "RX5", "RX_RX5"},
{"RX INT0_1 MIX1 INP2", "IIR0", "IIR0"},
{"RX INT0_1 MIX1 INP2", "IIR1", "IIR1"},
{"RX INT0_1 MIX1 INP2", "DEC0", "RX_TX DEC0_INP"},
{"RX INT0_1 MIX1 INP2", "DEC1", "RX_TX DEC1_INP"},
{"RX INT1_1 MIX1 INP0", "RX0", "RX_RX0"},
{"RX INT1_1 MIX1 INP0", "RX1", "RX_RX1"},
@@ -3362,8 +3244,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT1_1 MIX1 INP0", "RX5", "RX_RX5"},
{"RX INT1_1 MIX1 INP0", "IIR0", "IIR0"},
{"RX INT1_1 MIX1 INP0", "IIR1", "IIR1"},
{"RX INT1_1 MIX1 INP0", "DEC0", "RX_TX DEC0_INP"},
{"RX INT1_1 MIX1 INP0", "DEC1", "RX_TX DEC1_INP"},
{"RX INT1_1 MIX1 INP1", "RX0", "RX_RX0"},
{"RX INT1_1 MIX1 INP1", "RX1", "RX_RX1"},
{"RX INT1_1 MIX1 INP1", "RX2", "RX_RX2"},
@@ -3372,8 +3252,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT1_1 MIX1 INP1", "RX5", "RX_RX5"},
{"RX INT1_1 MIX1 INP1", "IIR0", "IIR0"},
{"RX INT1_1 MIX1 INP1", "IIR1", "IIR1"},
{"RX INT1_1 MIX1 INP1", "DEC0", "RX_TX DEC0_INP"},
{"RX INT1_1 MIX1 INP1", "DEC1", "RX_TX DEC1_INP"},
{"RX INT1_1 MIX1 INP2", "RX0", "RX_RX0"},
{"RX INT1_1 MIX1 INP2", "RX1", "RX_RX1"},
{"RX INT1_1 MIX1 INP2", "RX2", "RX_RX2"},
@@ -3382,8 +3260,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT1_1 MIX1 INP2", "RX5", "RX_RX5"},
{"RX INT1_1 MIX1 INP2", "IIR0", "IIR0"},
{"RX INT1_1 MIX1 INP2", "IIR1", "IIR1"},
{"RX INT1_1 MIX1 INP2", "DEC0", "RX_TX DEC0_INP"},
{"RX INT1_1 MIX1 INP2", "DEC1", "RX_TX DEC1_INP"},
{"RX INT2_1 MIX1 INP0", "RX0", "RX_RX0"},
{"RX INT2_1 MIX1 INP0", "RX1", "RX_RX1"},
@@ -3393,8 +3269,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT2_1 MIX1 INP0", "RX5", "RX_RX5"},
{"RX INT2_1 MIX1 INP0", "IIR0", "IIR0"},
{"RX INT2_1 MIX1 INP0", "IIR1", "IIR1"},
{"RX INT2_1 MIX1 INP0", "DEC0", "RX_TX DEC0_INP"},
{"RX INT2_1 MIX1 INP0", "DEC1", "RX_TX DEC1_INP"},
{"RX INT2_1 MIX1 INP1", "RX0", "RX_RX0"},
{"RX INT2_1 MIX1 INP1", "RX1", "RX_RX1"},
{"RX INT2_1 MIX1 INP1", "RX2", "RX_RX2"},
@@ -3403,8 +3277,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT2_1 MIX1 INP1", "RX5", "RX_RX5"},
{"RX INT2_1 MIX1 INP1", "IIR0", "IIR0"},
{"RX INT2_1 MIX1 INP1", "IIR1", "IIR1"},
{"RX INT2_1 MIX1 INP1", "DEC0", "RX_TX DEC0_INP"},
{"RX INT2_1 MIX1 INP1", "DEC1", "RX_TX DEC1_INP"},
{"RX INT2_1 MIX1 INP2", "RX0", "RX_RX0"},
{"RX INT2_1 MIX1 INP2", "RX1", "RX_RX1"},
{"RX INT2_1 MIX1 INP2", "RX2", "RX_RX2"},
@@ -3413,8 +3285,6 @@ static const struct snd_soc_dapm_route rx_audio_map[] = {
{"RX INT2_1 MIX1 INP2", "RX5", "RX_RX5"},
{"RX INT2_1 MIX1 INP2", "IIR0", "IIR0"},
{"RX INT2_1 MIX1 INP2", "IIR1", "IIR1"},
{"RX INT2_1 MIX1 INP2", "DEC0", "RX_TX DEC0_INP"},
{"RX INT2_1 MIX1 INP2", "DEC1", "RX_TX DEC1_INP"},
{"RX INT0_1 MIX1", NULL, "RX INT0_1 MIX1 INP0"},
{"RX INT0_1 MIX1", NULL, "RX INT0_1 MIX1 INP1"},
@@ -3632,8 +3502,6 @@ static int rx_swrm_clock(void *handle, bool enable)
mutex_lock(&rx_priv->swr_clk_lock);
trace_printk("%s: swrm clock %s\n",
__func__, (enable ? "enable" : "disable"));
dev_dbg(rx_priv->dev, "%s: swrm clock %s\n",
__func__, (enable ? "enable" : "disable"));
if (enable) {
@@ -3700,8 +3568,6 @@ static int rx_swrm_clock(void *handle, bool enable)
}
}
}
trace_printk("%s: swrm clock users %d\n",
__func__, rx_priv->swr_clk_users);
dev_dbg(rx_priv->dev, "%s: swrm clock users %d\n",
__func__, rx_priv->swr_clk_users);
exit:
@@ -4129,10 +3995,6 @@ static const struct of_device_id rx_macro_dt_match[] = {
};
static const struct dev_pm_ops bolero_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(
pm_runtime_force_suspend,
pm_runtime_force_resume
)
SET_RUNTIME_PM_OPS(
bolero_runtime_suspend,
bolero_runtime_resume,

370
techpack/audio/4.0/asoc/codecs/bolero/tx-macro.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -40,15 +40,12 @@
#define TX_MACRO_MCLK_FREQ 9600000
#define TX_MACRO_TX_PATH_OFFSET 0x80
#define TX_MACRO_SWR_MIC_MUX_SEL_MASK 0xF
#define TX_MACRO_ADC_MUX_CFG_OFFSET 0x8
#define TX_MACRO_ADC_MUX_CFG_OFFSET 0x2
#define TX_MACRO_ADC_MODE_CFG0_SHIFT 1
#define TX_MACRO_DMIC_UNMUTE_DELAY_MS 40
#define TX_MACRO_AMIC_UNMUTE_DELAY_MS 100
#define TX_MACRO_DMIC_HPF_DELAY_MS 300
#define TX_MACRO_AMIC_HPF_DELAY_MS 300
#define TX_MACRO_TX_UNMUTE_DELAY_MS 40
static int tx_unmute_delay = TX_MACRO_DMIC_UNMUTE_DELAY_MS;
static int tx_unmute_delay = TX_MACRO_TX_UNMUTE_DELAY_MS;
module_param(tx_unmute_delay, int, 0664);
MODULE_PARM_DESC(tx_unmute_delay, "delay to unmute the tx path");
@@ -158,6 +155,10 @@ struct tx_macro_priv {
struct work_struct tx_macro_add_child_devices_work;
struct hpf_work tx_hpf_work[NUM_DECIMATORS];
struct tx_mute_work tx_mute_dwork[NUM_DECIMATORS];
s32 dmic_0_1_clk_cnt;
s32 dmic_2_3_clk_cnt;
s32 dmic_4_5_clk_cnt;
s32 dmic_6_7_clk_cnt;
u16 dmic_clk_div;
u32 version;
u32 is_used_tx_swr_gpio;
@@ -175,7 +176,6 @@ struct tx_macro_priv {
int dec_mode[NUM_DECIMATORS];
bool bcs_clk_en;
bool hs_slow_insert_complete;
int amic_sample_rate;
};
static bool tx_macro_get_data(struct snd_soc_codec *codec,
@@ -222,19 +222,19 @@ static int tx_macro_mclk_enable(struct tx_macro_priv *tx_priv,
mutex_lock(&tx_priv->mclk_lock);
if (mclk_enable) {
ret = bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
TX_CORE_CLK,
true);
if (ret < 0) {
dev_err_ratelimited(tx_priv->dev,
"%s: request clock enable failed\n",
__func__);
goto exit;
}
bolero_clk_rsc_fs_gen_request(tx_priv->dev,
true);
if (tx_priv->tx_mclk_users == 0) {
ret = bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
TX_CORE_CLK,
true);
if (ret < 0) {
dev_err_ratelimited(tx_priv->dev,
"%s: request clock enable failed\n",
__func__);
goto exit;
}
bolero_clk_rsc_fs_gen_request(tx_priv->dev,
true);
regcache_mark_dirty(regmap);
regcache_sync_region(regmap,
TX_START_OFFSET,
@@ -265,32 +265,20 @@ static int tx_macro_mclk_enable(struct tx_macro_priv *tx_priv,
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL,
0x01, 0x00);
}
bolero_clk_rsc_fs_gen_request(tx_priv->dev,
false);
bolero_clk_rsc_fs_gen_request(tx_priv->dev,
false);
bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
TX_CORE_CLK,
false);
bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
TX_CORE_CLK,
false);
}
}
exit:
mutex_unlock(&tx_priv->mclk_lock);
return ret;
}
static int __tx_macro_mclk_enable(struct snd_soc_codec *codec,
bool enable)
{
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
if (!tx_macro_get_data(codec, &tx_dev, &tx_priv, __func__))
return -EINVAL;
return tx_macro_mclk_enable(tx_priv, enable);
}
static int tx_macro_va_swr_clk_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
@@ -373,8 +361,10 @@ static int tx_macro_event_handler(struct snd_soc_codec *codec, u16 event,
switch (event) {
case BOLERO_MACRO_EVT_SSR_DOWN:
trace_printk("%s, enter SSR down\n", __func__);
if (tx_priv->swr_ctrl_data) {
swrm_wcd_notify(
tx_priv->swr_ctrl_data[0].tx_swr_pdev,
SWR_DEVICE_DOWN, NULL);
swrm_wcd_notify(
tx_priv->swr_ctrl_data[0].tx_swr_pdev,
SWR_DEVICE_SSR_DOWN, NULL);
@@ -390,7 +380,6 @@ static int tx_macro_event_handler(struct snd_soc_codec *codec, u16 event,
}
break;
case BOLERO_MACRO_EVT_SSR_UP:
trace_printk("%s, enter SSR up\n", __func__);
/* reset swr after ssr/pdr */
tx_priv->reset_swr = true;
if (tx_priv->swr_ctrl_data)
@@ -433,32 +422,6 @@ static int tx_macro_reg_wake_irq(struct snd_soc_codec *codec,
return ret;
}
static int is_amic_enabled(struct snd_soc_codec *codec, int decimator)
{
u16 adc_mux_reg = 0, adc_reg = 0;
u16 adc_n = BOLERO_ADC_MAX;
bool ret = false;
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
if (!tx_macro_get_data(codec, &tx_dev, &tx_priv, __func__))
return ret;
adc_mux_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG1 +
TX_MACRO_ADC_MUX_CFG_OFFSET * decimator;
if (snd_soc_read(codec, adc_mux_reg) & SWR_MIC) {
if (tx_priv->version == BOLERO_VERSION_2_1)
return true;
adc_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG0 +
TX_MACRO_ADC_MUX_CFG_OFFSET * decimator;
adc_n = snd_soc_read(codec, adc_reg) &
TX_MACRO_SWR_MIC_MUX_SEL_MASK;
if (adc_n < BOLERO_ADC_MAX)
return true;
}
return ret;
}
static void tx_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
{
struct delayed_work *hpf_delayed_work = NULL;
@@ -467,7 +430,7 @@ static void tx_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
struct snd_soc_codec *codec = NULL;
u16 dec_cfg_reg = 0, hpf_gate_reg = 0;
u8 hpf_cut_off_freq = 0;
u16 adc_reg = 0, adc_n = 0;
u16 adc_mux_reg = 0, adc_n = 0, adc_reg = 0;
hpf_delayed_work = to_delayed_work(work);
hpf_work = container_of(hpf_delayed_work, struct hpf_work, dwork);
@@ -483,54 +446,25 @@ static void tx_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
dev_dbg(codec->dev, "%s: decimator %u hpf_cut_of_freq 0x%x\n",
__func__, hpf_work->decimator, hpf_cut_off_freq);
if (is_amic_enabled(codec, hpf_work->decimator)) {
adc_mux_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG1 +
TX_MACRO_ADC_MUX_CFG_OFFSET * hpf_work->decimator;
if (snd_soc_read(codec, adc_mux_reg) & SWR_MIC) {
adc_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG0 +
TX_MACRO_ADC_MUX_CFG_OFFSET * hpf_work->decimator;
adc_n = snd_soc_read(codec, adc_reg) &
TX_MACRO_SWR_MIC_MUX_SEL_MASK;
if (adc_n >= BOLERO_ADC_MAX)
goto tx_hpf_set;
/* analog mic clear TX hold */
bolero_clear_amic_tx_hold(codec->dev, adc_n);
snd_soc_update_bits(codec,
dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x02);
/* Add delay between toggle hpf gate based on sample rate */
switch(tx_priv->amic_sample_rate) {
case 8000:
usleep_range(125, 130);
break;
case 16000:
usleep_range(62, 65);
break;
case 32000:
usleep_range(31, 32);
break;
case 48000:
usleep_range(20, 21);
break;
case 96000:
usleep_range(10, 11);
break;
case 192000:
usleep_range(5, 6);
break;
default:
usleep_range(125, 130);
}
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x01);
} else {
snd_soc_update_bits(codec,
dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x02);
/* Minimum 1 clk cycle delay is required as per HW spec */
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x00);
}
tx_hpf_set:
snd_soc_update_bits(codec, dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg, 0x03, 0x02);
/* Minimum 1 clk cycle delay is required as per HW spec */
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg, 0x03, 0x01);
}
static void tx_macro_mute_update_callback(struct work_struct *work)
@@ -812,9 +746,17 @@ static int tx_macro_enable_dmic(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
u8 dmic_clk_en = 0x01;
u16 dmic_clk_reg = 0;
s32 *dmic_clk_cnt = NULL;
unsigned int dmic = 0;
int ret = 0;
char *wname = NULL;
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
if (!tx_macro_get_data(codec, &tx_dev, &tx_priv, __func__))
return -EINVAL;
wname = strpbrk(w->name, "01234567");
if (!wname) {
@@ -829,15 +771,53 @@ static int tx_macro_enable_dmic(struct snd_soc_dapm_widget *w,
return -EINVAL;
}
dev_dbg(codec->dev, "%s: event %d DMIC%d\n",
__func__, event, dmic);
switch (dmic) {
case 0:
case 1:
dmic_clk_cnt = &(tx_priv->dmic_0_1_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL;
break;
case 2:
case 3:
dmic_clk_cnt = &(tx_priv->dmic_2_3_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL;
break;
case 4:
case 5:
dmic_clk_cnt = &(tx_priv->dmic_4_5_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL;
break;
case 6:
case 7:
dmic_clk_cnt = &(tx_priv->dmic_6_7_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL;
break;
default:
dev_err(codec->dev, "%s: Invalid DMIC Selection\n",
__func__);
return -EINVAL;
}
dev_dbg(codec->dev, "%s: event %d DMIC%d dmic_clk_cnt %d\n",
__func__, event, dmic, *dmic_clk_cnt);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
bolero_dmic_clk_enable(codec, dmic, DMIC_TX, true);
(*dmic_clk_cnt)++;
if (*dmic_clk_cnt == 1) {
snd_soc_update_bits(codec, BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
0x80, 0x00);
snd_soc_update_bits(codec, dmic_clk_reg,
0x0E, tx_priv->dmic_clk_div << 0x1);
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, dmic_clk_en);
}
break;
case SND_SOC_DAPM_POST_PMD:
bolero_dmic_clk_enable(codec, dmic, DMIC_TX, false);
(*dmic_clk_cnt)--;
if (*dmic_clk_cnt == 0)
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, 0);
break;
}
@@ -853,14 +833,9 @@ static int tx_macro_enable_dec(struct snd_soc_dapm_widget *w,
u16 dec_cfg_reg = 0;
u16 hpf_gate_reg = 0;
u16 tx_gain_ctl_reg = 0;
u16 tx_fs_reg = 0;
u8 hpf_cut_off_freq = 0;
int hpf_delay = TX_MACRO_DMIC_HPF_DELAY_MS;
int unmute_delay = TX_MACRO_DMIC_UNMUTE_DELAY_MS;
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
u16 adc_mux_reg = 0, adc_reg = 0, adc_n = 0;
u16 dmic_clk_reg = 0;
if (!tx_macro_get_data(codec, &tx_dev, &tx_priv, __func__))
return -EINVAL;
@@ -878,29 +853,9 @@ static int tx_macro_enable_dec(struct snd_soc_dapm_widget *w,
TX_MACRO_TX_PATH_OFFSET * decimator;
tx_gain_ctl_reg = BOLERO_CDC_TX0_TX_VOL_CTL +
TX_MACRO_TX_PATH_OFFSET * decimator;
tx_fs_reg = BOLERO_CDC_TX0_TX_PATH_CTL +
TX_MACRO_TX_PATH_OFFSET * decimator;
tx_priv->amic_sample_rate = (snd_soc_read(codec, tx_fs_reg) & 0x0F);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
adc_mux_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG1 +
TX_MACRO_ADC_MUX_CFG_OFFSET * decimator;
if (snd_soc_read(codec, adc_mux_reg) & SWR_MIC) {
adc_reg = BOLERO_CDC_TX_INP_MUX_ADC_MUX0_CFG0 +
TX_MACRO_ADC_MUX_CFG_OFFSET * decimator;
adc_n = snd_soc_read(codec, adc_reg) &
TX_MACRO_SWR_MIC_MUX_SEL_MASK;
if (adc_n >= BOLERO_ADC_MAX) {
dmic_clk_reg =
BOLERO_CDC_TX_TOP_CSR_SWR_DMIC0_CTL +
((adc_n - 5) / 2) * 4;
snd_soc_update_bits(codec,
dmic_clk_reg,
0x0E, tx_priv->dmic_clk_div << 0x1);
}
}
snd_soc_update_bits(codec,
dec_cfg_reg, 0x06, tx_priv->dec_mode[decimator] <<
TX_MACRO_ADC_MODE_CFG0_SHIFT);
@@ -909,14 +864,8 @@ static int tx_macro_enable_dec(struct snd_soc_dapm_widget *w,
break;
case SND_SOC_DAPM_POST_PMU:
snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x20, 0x20);
if (!is_amic_enabled(codec, decimator)) {
snd_soc_update_bits(codec,
hpf_gate_reg, 0x01, 0x00);
/*
* Minimum 1 clk cycle delay is required as per HW spec
*/
usleep_range(1000, 1010);
}
snd_soc_update_bits(codec, hpf_gate_reg, 0x01, 0x00);
hpf_cut_off_freq = (snd_soc_read(codec, dec_cfg_reg) &
TX_HPF_CUT_OFF_FREQ_MASK) >> 5;
tx_priv->tx_hpf_work[decimator].hpf_cut_off_freq =
@@ -927,32 +876,20 @@ static int tx_macro_enable_dec(struct snd_soc_dapm_widget *w,
TX_HPF_CUT_OFF_FREQ_MASK,
CF_MIN_3DB_150HZ << 5);
if (is_amic_enabled(codec, decimator)) {
hpf_delay = TX_MACRO_AMIC_HPF_DELAY_MS;
unmute_delay = TX_MACRO_AMIC_UNMUTE_DELAY_MS;
}
if (tx_unmute_delay < unmute_delay)
tx_unmute_delay = unmute_delay;
/* schedule work queue to Remove Mute */
queue_delayed_work(system_freezable_wq,
&tx_priv->tx_mute_dwork[decimator].dwork,
msecs_to_jiffies(tx_unmute_delay));
schedule_delayed_work(&tx_priv->tx_mute_dwork[decimator].dwork,
msecs_to_jiffies(tx_unmute_delay));
if (tx_priv->tx_hpf_work[decimator].hpf_cut_off_freq !=
CF_MIN_3DB_150HZ) {
schedule_delayed_work(
&tx_priv->tx_hpf_work[decimator].dwork,
msecs_to_jiffies(hpf_delay));
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x02);
if (!is_amic_enabled(codec, decimator))
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x00);
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x01);
&tx_priv->tx_hpf_work[decimator].dwork,
msecs_to_jiffies(300));
snd_soc_update_bits(codec, hpf_gate_reg, 0x02, 0x02);
/*
* 6ms delay is required as per HW spec
* Minimum 1 clk cycle delay is required as per HW spec
*/
usleep_range(6000, 6010);
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg, 0x02, 0x00);
}
/* apply gain after decimator is enabled */
snd_soc_write(codec, tx_gain_ctl_reg,
@@ -977,21 +914,15 @@ static int tx_macro_enable_dec(struct snd_soc_dapm_widget *w,
snd_soc_update_bits(codec, dec_cfg_reg,
TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
if (is_amic_enabled(codec, decimator))
snd_soc_update_bits(codec,
hpf_gate_reg,
0x03, 0x02);
else
snd_soc_update_bits(codec,
hpf_gate_reg,
0x03, 0x03);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x02);
/*
* Minimum 1 clk cycle delay is required
* as per HW spec
*/
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x01);
0x02, 0x00);
}
}
cancel_delayed_work_sync(
@@ -1516,6 +1447,10 @@ static const struct snd_soc_dapm_widget tx_macro_dapm_widgets_v2[] = {
SND_SOC_DAPM_MIXER("TX_AIF3_CAP Mixer", SND_SOC_NOPM,
TX_MACRO_AIF3_CAP, 0,
tx_aif3_cap_mixer_v2, ARRAY_SIZE(tx_aif3_cap_mixer_v2)),
SND_SOC_DAPM_SUPPLY_S("TX_SWR_CLK", 0, SND_SOC_NOPM, 0, 0,
tx_macro_tx_swr_clk_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
};
static const struct snd_soc_dapm_widget tx_macro_dapm_widgets_v3[] = {
@@ -1565,10 +1500,6 @@ static const struct snd_soc_dapm_widget tx_macro_dapm_widgets_v3[] = {
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY_S("TX_SWR_CLK", 0, SND_SOC_NOPM, 0, 0,
tx_macro_tx_swr_clk_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY_S("VA_SWR_CLK", 0, SND_SOC_NOPM, 0, 0,
tx_macro_va_swr_clk_event,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
@@ -1962,15 +1893,6 @@ static const struct snd_soc_dapm_route tx_audio_map_v3[] = {
{"TX SMIC MUX7", "SWR_MIC9", "TX SWR_MIC9"},
{"TX SMIC MUX7", "SWR_MIC10", "TX SWR_MIC10"},
{"TX SMIC MUX7", "SWR_MIC11", "TX SWR_MIC11"},
{"TX SMIC MUX0", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX1", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX2", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX3", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX4", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX5", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX6", NULL, "TX_SWR_CLK"},
{"TX SMIC MUX7", NULL, "TX_SWR_CLK"},
};
static const struct snd_soc_dapm_route tx_audio_map[] = {
@@ -2352,8 +2274,7 @@ static int tx_macro_register_event_listener(struct snd_soc_codec *codec,
"%s: priv is null for macro!\n", __func__);
return -EINVAL;
}
if (tx_priv->swr_ctrl_data &&
(!tx_priv->tx_swr_clk_cnt || !tx_priv->va_swr_clk_cnt)) {
if (tx_priv->swr_ctrl_data) {
if (enable) {
ret = swrm_wcd_notify(
tx_priv->swr_ctrl_data[0].tx_swr_pdev,
@@ -2378,9 +2299,6 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
{
int ret = 0, clk_tx_ret = 0;
trace_printk("%s: clock type %s, enable: %s tx_mclk_users: %d\n",
__func__, (clk_type ? "VA_MCLK" : "TX_MCLK"),
(enable ? "enable" : "disable"), tx_priv->tx_mclk_users);
dev_dbg(tx_priv->dev,
"%s: clock type %s, enable: %s tx_mclk_users: %d\n",
__func__, (clk_type ? "VA_MCLK" : "TX_MCLK"),
@@ -2388,7 +2306,6 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
if (enable) {
if (tx_priv->swr_clk_users == 0) {
trace_printk("%s: tx swr clk users 0\n", __func__);
ret = msm_cdc_pinctrl_select_active_state(
tx_priv->tx_swr_gpio_p);
if (ret < 0) {
@@ -2404,7 +2321,6 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
TX_CORE_CLK,
true);
if (clk_type == TX_MCLK) {
trace_printk("%s: requesting TX_MCLK\n", __func__);
ret = tx_macro_mclk_enable(tx_priv, 1);
if (ret < 0) {
if (tx_priv->swr_clk_users == 0)
@@ -2417,7 +2333,6 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
}
}
if (clk_type == VA_MCLK) {
trace_printk("%s: requesting VA_MCLK\n", __func__);
ret = bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
VA_CORE_CLK,
@@ -2438,19 +2353,16 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
BOLERO_CDC_TX_TOP_CSR_FREQ_MCLK,
0x01, 0x01);
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL,
BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL,
0x01, 0x01);
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x01);
BOLERO_CDC_TX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x01);
}
tx_priv->tx_mclk_users++;
}
if (tx_priv->swr_clk_users == 0) {
dev_dbg(tx_priv->dev, "%s: reset_swr: %d\n",
__func__, tx_priv->reset_swr);
trace_printk("%s: reset_swr: %d\n",
__func__, tx_priv->reset_swr);
if (tx_priv->reset_swr)
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_SWR_CONTROL,
@@ -2489,24 +2401,16 @@ static int tx_macro_tx_va_mclk_enable(struct tx_macro_priv *tx_priv,
if (clk_type == TX_MCLK)
tx_macro_mclk_enable(tx_priv, 0);
if (clk_type == VA_MCLK) {
if (tx_priv->tx_mclk_users <= 0) {
dev_err(tx_priv->dev, "%s: clock already disabled\n",
__func__);
tx_priv->tx_mclk_users = 0;
return 0;
}
tx_priv->tx_mclk_users--;
if (tx_priv->tx_mclk_users == 0) {
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x00);
BOLERO_CDC_TX_CLK_RST_CTRL_FS_CNT_CONTROL,
0x01, 0x00);
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL,
BOLERO_CDC_TX_CLK_RST_CTRL_MCLK_CONTROL,
0x01, 0x00);
}
bolero_clk_rsc_fs_gen_request(tx_priv->dev,
false);
false);
ret = bolero_clk_rsc_request_clock(tx_priv->dev,
TX_CORE_CLK,
VA_CORE_CLK,
@@ -2543,22 +2447,10 @@ done:
TX_CORE_CLK,
false);
exit:
trace_printk("%s: exit\n", __func__);
return ret;
}
static int tx_macro_clk_div_get(struct snd_soc_codec *codec)
{
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
if (!tx_macro_get_data(codec, &tx_dev, &tx_priv, __func__))
return -EINVAL;
return tx_priv->dmic_clk_div;
}
static int tx_macro_clk_switch(struct snd_soc_codec *codec, int clk_src)
static int tx_macro_clk_switch(struct snd_soc_codec *codec)
{
struct device *tx_dev = NULL;
struct tx_macro_priv *tx_priv = NULL;
@@ -2582,7 +2474,7 @@ static int tx_macro_clk_switch(struct snd_soc_codec *codec, int clk_src)
if (tx_priv->swr_ctrl_data) {
ret = swrm_wcd_notify(
tx_priv->swr_ctrl_data[0].tx_swr_pdev,
SWR_REQ_CLK_SWITCH, &clk_src);
SWR_REQ_CLK_SWITCH, NULL);
}
return ret;
@@ -2620,10 +2512,6 @@ static int tx_macro_swrm_clock(void *handle, bool enable)
}
mutex_lock(&tx_priv->swr_clk_lock);
trace_printk("%s: swrm clock %s tx_swr_clk_cnt: %d va_swr_clk_cnt: %d\n",
__func__,
(enable ? "enable" : "disable"),
tx_priv->tx_swr_clk_cnt, tx_priv->va_swr_clk_cnt);
dev_dbg(tx_priv->dev,
"%s: swrm clock %s tx_swr_clk_cnt: %d va_swr_clk_cnt: %d\n",
__func__, (enable ? "enable" : "disable"),
@@ -2686,9 +2574,6 @@ static int tx_macro_swrm_clock(void *handle, bool enable)
}
}
trace_printk("%s: swrm clock users %d tx_clk_sts_cnt: %d va_clk_sts_cnt: %d\n",
__func__, tx_priv->swr_clk_users, tx_priv->tx_clk_status,
tx_priv->va_clk_status);
dev_dbg(tx_priv->dev,
"%s: swrm clock users %d tx_clk_sts_cnt: %d va_clk_sts_cnt: %d\n",
__func__, tx_priv->swr_clk_users, tx_priv->tx_clk_status,
@@ -2749,7 +2634,7 @@ undefined_rate:
}
static const struct tx_macro_reg_mask_val tx_macro_reg_init[] = {
{BOLERO_CDC_TX0_TX_PATH_SEC7, 0x3F, 0x0A},
{BOLERO_CDC_TX0_TX_PATH_SEC7, 0x3F, 0x02},
};
static int tx_macro_init(struct snd_soc_codec *codec)
{
@@ -2918,13 +2803,6 @@ static int tx_macro_init(struct snd_soc_codec *codec)
tx_macro_reg_init[i].mask,
tx_macro_reg_init[i].val);
if (tx_priv->version == BOLERO_VERSION_2_1)
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_SWR_CTRL, 0xF0, 0xA0);
else if (tx_priv->version == BOLERO_VERSION_2_0)
snd_soc_update_bits(codec,
BOLERO_CDC_TX_TOP_CSR_SWR_CTRL, 0xF0, 0xA0);
return 0;
}
@@ -3083,10 +2961,8 @@ static void tx_macro_init_ops(struct macro_ops *ops,
ops->event_handler = tx_macro_event_handler;
ops->reg_wake_irq = tx_macro_reg_wake_irq;
ops->set_port_map = tx_macro_set_port_map;
ops->clk_div_get = tx_macro_clk_div_get;
ops->clk_switch = tx_macro_clk_switch;
ops->reg_evt_listener = tx_macro_register_event_listener;
ops->clk_enable = __tx_macro_mclk_enable;
}
static int tx_macro_probe(struct platform_device *pdev)
@@ -3234,10 +3110,6 @@ static const struct of_device_id tx_macro_dt_match[] = {
};
static const struct dev_pm_ops bolero_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(
pm_runtime_force_suspend,
pm_runtime_force_resume
)
SET_RUNTIME_PM_OPS(
bolero_runtime_suspend,
bolero_runtime_resume,

612
techpack/audio/4.0/asoc/codecs/bolero/va-macro.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -16,7 +16,6 @@
#include <asoc/msm-cdc-pinctrl.h>
#include <soc/swr-common.h>
#include <soc/swr-wcd.h>
#include <dsp/digital-cdc-rsc-mgr.h>
#include "bolero-cdc.h"
#include "bolero-cdc-registers.h"
#include "bolero-clk-rsc.h"
@@ -45,19 +44,15 @@
#define VA_MACRO_TX_DMIC_CLK_DIV_MASK 0x0E
#define VA_MACRO_TX_DMIC_CLK_DIV_SHFT 0x01
#define VA_MACRO_SWR_MIC_MUX_SEL_MASK 0xF
#define VA_MACRO_ADC_MUX_CFG_OFFSET 0x8
#define VA_MACRO_ADC_MODE_CFG0_SHIFT 1
#define VA_MACRO_ADC_MUX_CFG_OFFSET 0x2
#define BOLERO_CDC_VA_TX_DMIC_UNMUTE_DELAY_MS 40
#define BOLERO_CDC_VA_TX_AMIC_UNMUTE_DELAY_MS 100
#define BOLERO_CDC_VA_TX_DMIC_HPF_DELAY_MS 300
#define BOLERO_CDC_VA_TX_AMIC_HPF_DELAY_MS 300
#define BOLERO_CDC_VA_TX_UNMUTE_DELAY_MS 40
#define MAX_RETRY_ATTEMPTS 500
#define VA_MACRO_SWR_STRING_LEN 80
#define VA_MACRO_CHILD_DEVICES_MAX 3
static const DECLARE_TLV_DB_SCALE(digital_gain, 0, 1, 0);
static int va_tx_unmute_delay = BOLERO_CDC_VA_TX_DMIC_UNMUTE_DELAY_MS;
static int va_tx_unmute_delay = BOLERO_CDC_VA_TX_UNMUTE_DELAY_MS;
module_param(va_tx_unmute_delay, int, 0664);
MODULE_PARM_DESC(va_tx_unmute_delay, "delay to unmute the tx path");
@@ -124,7 +119,6 @@ struct va_macro_swr_ctrl_platform_data {
int (*write)(void *handle, int reg, int val);
int (*bulk_write)(void *handle, u32 *reg, u32 *val, size_t len);
int (*clk)(void *handle, bool enable);
int (*core_vote)(void *handle, bool enable);
int (*handle_irq)(void *handle,
irqreturn_t (*swrm_irq_handler)(int irq,
void *data),
@@ -144,6 +138,10 @@ struct va_macro_priv {
struct va_mute_work va_mute_dwork[VA_MACRO_NUM_DECIMATORS];
unsigned long active_ch_mask[VA_MACRO_MAX_DAIS];
unsigned long active_ch_cnt[VA_MACRO_MAX_DAIS];
s32 dmic_0_1_clk_cnt;
s32 dmic_2_3_clk_cnt;
s32 dmic_4_5_clk_cnt;
s32 dmic_6_7_clk_cnt;
u16 dmic_clk_div;
u16 va_mclk_users;
int swr_clk_users;
@@ -170,9 +168,6 @@ struct va_macro_priv {
int va_swr_clk_cnt;
int va_clk_status;
int tx_clk_status;
bool lpi_enable;
bool register_event_listener;
int dec_mode[VA_MACRO_NUM_DECIMATORS];
};
static bool va_macro_get_data(struct snd_soc_codec *codec,
@@ -195,21 +190,6 @@ static bool va_macro_get_data(struct snd_soc_codec *codec,
return true;
}
static int va_macro_clk_div_get(struct snd_soc_codec *codec)
{
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
if ((va_priv->version == BOLERO_VERSION_2_1)
&& !va_priv->lpi_enable
&& (va_priv->dmic_clk_div == VA_MACRO_CLK_DIV_16))
return VA_MACRO_CLK_DIV_8;
return va_priv->dmic_clk_div;
}
static int va_macro_mclk_enable(struct va_macro_priv *va_priv,
bool mclk_enable, bool dapm)
{
@@ -226,19 +206,19 @@ static int va_macro_mclk_enable(struct va_macro_priv *va_priv,
mutex_lock(&va_priv->mclk_lock);
if (mclk_enable) {
ret = bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
va_priv->clk_id,
true);
if (ret < 0) {
dev_err(va_priv->dev,
"%s: va request clock en failed\n",
__func__);
goto exit;
}
bolero_clk_rsc_fs_gen_request(va_priv->dev,
true);
if (va_priv->va_mclk_users == 0) {
ret = bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
va_priv->clk_id,
true);
if (ret < 0) {
dev_err(va_priv->dev,
"%s: va request clock en failed\n",
__func__);
goto exit;
}
bolero_clk_rsc_fs_gen_request(va_priv->dev,
true);
regcache_mark_dirty(regmap);
regcache_sync_region(regmap,
VA_START_OFFSET,
@@ -253,12 +233,14 @@ static int va_macro_mclk_enable(struct va_macro_priv *va_priv,
goto exit;
}
va_priv->va_mclk_users--;
bolero_clk_rsc_fs_gen_request(va_priv->dev,
false);
bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
va_priv->clk_id,
false);
if (va_priv->va_mclk_users == 0) {
bolero_clk_rsc_fs_gen_request(va_priv->dev,
false);
bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
va_priv->clk_id,
false);
}
}
exit:
mutex_unlock(&va_priv->mclk_lock);
@@ -298,7 +280,6 @@ static int va_macro_event_handler(struct snd_soc_codec *codec, u16 event,
__func__);
break;
case BOLERO_MACRO_EVT_SSR_UP:
trace_printk("%s, enter SSR up\n", __func__);
/* enable&disable VA_CORE_CLK to reset GFMUX reg */
ret = bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
@@ -323,6 +304,9 @@ static int va_macro_event_handler(struct snd_soc_codec *codec, u16 event,
break;
case BOLERO_MACRO_EVT_SSR_DOWN:
if (va_priv->swr_ctrl_data) {
swrm_wcd_notify(
va_priv->swr_ctrl_data[0].va_swr_pdev,
SWR_DEVICE_DOWN, NULL);
swrm_wcd_notify(
va_priv->swr_ctrl_data[0].va_swr_pdev,
SWR_DEVICE_SSR_DOWN, NULL);
@@ -343,32 +327,6 @@ static int va_macro_event_handler(struct snd_soc_codec *codec, u16 event,
return 0;
}
static int va_macro_swr_clk_event_v2(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_codec *codec =
snd_soc_dapm_to_codec(w->dapm);
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
dev_dbg(va_dev, "%s: event = %d\n", __func__, event);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
va_priv->va_swr_clk_cnt++;
break;
case SND_SOC_DAPM_POST_PMD:
va_priv->va_swr_clk_cnt--;
break;
default:
break;
}
return 0;
}
static int va_macro_swr_pwr_event_v2(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
@@ -377,24 +335,18 @@ static int va_macro_swr_pwr_event_v2(struct snd_soc_dapm_widget *w,
int ret = 0;
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
int clk_src = 0;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
dev_dbg(va_dev, "%s: event = %d, lpi_enable = %d\n",
__func__, event, va_priv->lpi_enable);
if (!va_priv->lpi_enable)
return ret;
dev_dbg(va_dev, "%s: event = %d\n", __func__, event);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
va_priv->va_swr_clk_cnt++;
if (va_priv->swr_ctrl_data) {
clk_src = CLK_SRC_VA_RCG;
ret = swrm_wcd_notify(
va_priv->swr_ctrl_data[0].va_swr_pdev,
SWR_REQ_CLK_SWITCH, &clk_src);
SWR_REQ_CLK_SWITCH, NULL);
if (ret)
dev_dbg(va_dev, "%s: clock switch failed\n",
__func__);
@@ -406,14 +358,14 @@ static int va_macro_swr_pwr_event_v2(struct snd_soc_dapm_widget *w,
msm_cdc_pinctrl_set_wakeup_capable(
va_priv->va_swr_gpio_p, true);
if (va_priv->swr_ctrl_data) {
clk_src = CLK_SRC_TX_RCG;
ret = swrm_wcd_notify(
va_priv->swr_ctrl_data[0].va_swr_pdev,
SWR_REQ_CLK_SWITCH, &clk_src);
SWR_REQ_CLK_SWITCH, NULL);
if (ret)
dev_dbg(va_dev, "%s: clock switch failed\n",
__func__);
}
va_priv->va_swr_clk_cnt--;
break;
default:
dev_err(va_priv->dev,
@@ -434,37 +386,25 @@ static int va_macro_swr_pwr_event(struct snd_soc_dapm_widget *w,
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
dev_dbg(va_dev, "%s: event = %d, lpi_enable = %d\n",
__func__, event, va_priv->lpi_enable);
if (!va_priv->lpi_enable)
return ret;
dev_dbg(va_dev, "%s: event = %d\n", __func__, event);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
if (va_priv->lpass_audio_hw_vote) {
ret = digital_cdc_rsc_mgr_hw_vote_enable(
va_priv->lpass_audio_hw_vote);
ret = clk_prepare_enable(va_priv->lpass_audio_hw_vote);
if (ret)
dev_err(va_dev,
"%s: lpass audio hw enable failed\n",
__func__);
}
if (!ret)
if (bolero_tx_clk_switch(codec, CLK_SRC_VA_RCG))
if (bolero_tx_clk_switch(codec))
dev_dbg(va_dev, "%s: clock switch failed\n",
__func__);
if (va_priv->lpi_enable) {
bolero_register_event_listener(codec, true);
va_priv->register_event_listener = true;
}
bolero_register_event_listener(codec, true);
break;
case SND_SOC_DAPM_POST_PMD:
if (va_priv->register_event_listener) {
va_priv->register_event_listener = false;
bolero_register_event_listener(codec, false);
}
if (bolero_tx_clk_switch(codec, CLK_SRC_TX_RCG))
bolero_register_event_listener(codec, false);
if (bolero_tx_clk_switch(codec))
dev_dbg(va_dev, "%s: clock switch failed\n",__func__);
if (va_priv->lpass_audio_hw_vote)
clk_disable_unprepare(va_priv->lpass_audio_hw_vote);
@@ -504,7 +444,6 @@ static int va_macro_mclk_event(struct snd_soc_dapm_widget *w,
int ret = 0;
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
int clk_src = 0;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
@@ -518,35 +457,12 @@ static int va_macro_mclk_event(struct snd_soc_dapm_widget *w,
true);
if (!ret)
va_priv->tx_clk_status++;
if (va_priv->lpi_enable)
ret = va_macro_mclk_enable(va_priv, 1, true);
else
ret = bolero_tx_mclk_enable(codec, 1);
ret = va_macro_mclk_enable(va_priv, 1, true);
break;
case SND_SOC_DAPM_POST_PMD:
if (va_priv->lpi_enable) {
if (va_priv->version == BOLERO_VERSION_2_1) {
if (va_priv->swr_ctrl_data) {
clk_src = CLK_SRC_TX_RCG;
ret = swrm_wcd_notify(
va_priv->swr_ctrl_data[0].va_swr_pdev,
SWR_REQ_CLK_SWITCH, &clk_src);
if (ret)
dev_dbg(va_dev,
"%s: clock switch failed\n",
__func__);
}
} else if (bolero_tx_clk_switch(codec,
CLK_SRC_TX_RCG)) {
dev_dbg(va_dev, "%s: clock switch failed\n",
__func__);
}
va_macro_mclk_enable(va_priv, 0, true);
} else {
bolero_tx_mclk_enable(codec, 0);
}
if (bolero_tx_clk_switch(codec))
dev_dbg(va_dev, "%s: clock switch failed\n",__func__);
va_macro_mclk_enable(va_priv, 0, true);
if (va_priv->tx_clk_status > 0) {
bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
@@ -685,26 +601,6 @@ done:
return ret;
}
static int va_macro_core_vote(void *handle, bool enable)
{
struct va_macro_priv *va_priv = (struct va_macro_priv *) handle;
if (va_priv == NULL) {
pr_err("%s: va priv data is NULL\n", __func__);
return -EINVAL;
}
if (enable) {
pm_runtime_get_sync(va_priv->dev);
pm_runtime_put_autosuspend(va_priv->dev);
pm_runtime_mark_last_busy(va_priv->dev);
}
if (bolero_check_core_votes(va_priv->dev))
return 0;
else
return -EINVAL;
}
static int va_macro_swrm_clock(void *handle, bool enable)
{
struct va_macro_priv *va_priv = (struct va_macro_priv *) handle;
@@ -727,20 +623,14 @@ static int va_macro_swrm_clock(void *handle, bool enable)
if (va_priv->va_swr_clk_cnt && !va_priv->tx_swr_clk_cnt) {
ret = va_macro_tx_va_mclk_enable(va_priv, regmap,
VA_MCLK, enable);
if (ret) {
pm_runtime_mark_last_busy(va_priv->dev);
pm_runtime_put_autosuspend(va_priv->dev);
if (ret)
goto done;
}
va_priv->va_clk_status++;
} else {
ret = va_macro_tx_va_mclk_enable(va_priv, regmap,
TX_MCLK, enable);
if (ret) {
pm_runtime_mark_last_busy(va_priv->dev);
pm_runtime_put_autosuspend(va_priv->dev);
if (ret)
goto done;
}
va_priv->tx_clk_status++;
}
pm_runtime_mark_last_busy(va_priv->dev);
@@ -787,32 +677,6 @@ done:
return ret;
}
static int is_amic_enabled(struct snd_soc_codec *codec, int decimator)
{
u16 adc_mux_reg = 0, adc_reg = 0;
u16 adc_n = BOLERO_ADC_MAX;
bool ret = false;
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return ret;
adc_mux_reg = BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG1 +
VA_MACRO_ADC_MUX_CFG_OFFSET * decimator;
if (snd_soc_read(codec, adc_mux_reg) & SWR_MIC) {
if (va_priv->version == BOLERO_VERSION_2_1)
return true;
adc_reg = BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0 +
VA_MACRO_ADC_MUX_CFG_OFFSET * decimator;
adc_n = snd_soc_read(codec, adc_reg) &
VA_MACRO_SWR_MIC_MUX_SEL_MASK;
if (adc_n < BOLERO_ADC_MAX)
return true;
}
return ret;
}
static void va_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
{
struct delayed_work *hpf_delayed_work;
@@ -821,7 +685,7 @@ static void va_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
struct snd_soc_codec *codec;
u16 dec_cfg_reg, hpf_gate_reg;
u8 hpf_cut_off_freq;
u16 adc_reg = 0, adc_n = 0;
u16 adc_mux_reg = 0, adc_n = 0, adc_reg = 0;
hpf_delayed_work = to_delayed_work(work);
hpf_work = container_of(hpf_delayed_work, struct hpf_work, dwork);
@@ -837,33 +701,25 @@ static void va_macro_tx_hpf_corner_freq_callback(struct work_struct *work)
dev_dbg(va_priv->dev, "%s: decimator %u hpf_cut_of_freq 0x%x\n",
__func__, hpf_work->decimator, hpf_cut_off_freq);
if (is_amic_enabled(codec, hpf_work->decimator)) {
adc_mux_reg = BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG1 +
VA_MACRO_ADC_MUX_CFG_OFFSET * hpf_work->decimator;
if (snd_soc_read(codec, adc_mux_reg) & SWR_MIC) {
adc_reg = BOLERO_CDC_VA_INP_MUX_ADC_MUX0_CFG0 +
VA_MACRO_ADC_MUX_CFG_OFFSET * hpf_work->decimator;
adc_n = snd_soc_read(codec, adc_reg) &
VA_MACRO_SWR_MIC_MUX_SEL_MASK;
if (adc_n >= BOLERO_ADC_MAX)
goto va_hpf_set;
/* analog mic clear TX hold */
bolero_clear_amic_tx_hold(codec->dev, adc_n);
snd_soc_update_bits(codec,
dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x02);
/* Minimum 1 clk cycle delay is required as per HW spec */
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x01);
} else {
snd_soc_update_bits(codec,
dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x02);
/* Minimum 1 clk cycle delay is required as per HW spec */
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x00);
}
va_hpf_set:
snd_soc_update_bits(codec, dec_cfg_reg, TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg, 0x03, 0x02);
/* Minimum 1 clk cycle delay is required as per HW spec */
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg, 0x03, 0x01);
}
static void va_macro_mute_update_callback(struct work_struct *work)
@@ -970,38 +826,6 @@ static int va_macro_put_dec_enum(struct snd_kcontrol *kcontrol,
return snd_soc_dapm_put_enum_double(kcontrol, ucontrol);
}
static int va_macro_lpi_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
ucontrol->value.integer.value[0] = va_priv->lpi_enable;
return 0;
}
static int va_macro_lpi_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
va_priv->lpi_enable = ucontrol->value.integer.value[0];
return 0;
}
static int va_macro_tx_mixer_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -1059,34 +883,82 @@ static int va_macro_tx_mixer_put(struct snd_kcontrol *kcontrol,
static int va_macro_enable_dmic(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_codec *codec =
snd_soc_dapm_to_codec(w->dapm);
unsigned int dmic = 0;
int ret = 0;
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
u8 dmic_clk_en = 0x01;
u16 dmic_clk_reg;
s32 *dmic_clk_cnt;
unsigned int dmic;
int ret;
char *wname;
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
wname = strpbrk(w->name, "01234567");
if (!wname) {
dev_err(codec->dev, "%s: widget not found\n", __func__);
dev_err(va_dev, "%s: widget not found\n", __func__);
return -EINVAL;
}
ret = kstrtouint(wname, 10, &dmic);
if (ret < 0) {
dev_err(codec->dev, "%s: Invalid DMIC line on the codec\n",
dev_err(va_dev, "%s: Invalid DMIC line on the codec\n",
__func__);
return -EINVAL;
}
dev_dbg(codec->dev, "%s: event %d DMIC%d\n",
__func__, event, dmic);
switch (dmic) {
case 0:
case 1:
dmic_clk_cnt = &(va_priv->dmic_0_1_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC0_CTL;
break;
case 2:
case 3:
dmic_clk_cnt = &(va_priv->dmic_2_3_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC1_CTL;
break;
case 4:
case 5:
dmic_clk_cnt = &(va_priv->dmic_4_5_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC2_CTL;
break;
case 6:
case 7:
dmic_clk_cnt = &(va_priv->dmic_6_7_clk_cnt);
dmic_clk_reg = BOLERO_CDC_VA_TOP_CSR_DMIC3_CTL;
break;
default:
dev_err(va_dev, "%s: Invalid DMIC Selection\n",
__func__);
return -EINVAL;
}
dev_dbg(va_dev, "%s: event %d DMIC%d dmic_clk_cnt %d\n",
__func__, event, dmic, *dmic_clk_cnt);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
bolero_dmic_clk_enable(codec, dmic, DMIC_VA, true);
(*dmic_clk_cnt)++;
if (*dmic_clk_cnt == 1) {
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_DMIC_CFG,
0x80, 0x00);
snd_soc_update_bits(codec, dmic_clk_reg,
VA_MACRO_TX_DMIC_CLK_DIV_MASK,
va_priv->dmic_clk_div <<
VA_MACRO_TX_DMIC_CLK_DIV_SHFT);
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, dmic_clk_en);
}
break;
case SND_SOC_DAPM_POST_PMD:
bolero_dmic_clk_enable(codec, dmic, DMIC_VA, false);
(*dmic_clk_cnt)--;
if (*dmic_clk_cnt == 0) {
snd_soc_update_bits(codec, dmic_clk_reg,
dmic_clk_en, 0);
}
break;
}
@@ -1103,8 +975,6 @@ static int va_macro_enable_dec(struct snd_soc_dapm_widget *w,
u8 hpf_cut_off_freq;
struct device *va_dev = NULL;
struct va_macro_priv *va_priv = NULL;
int hpf_delay = BOLERO_CDC_VA_TX_DMIC_HPF_DELAY_MS;
int unmute_delay = BOLERO_CDC_VA_TX_DMIC_UNMUTE_DELAY_MS;
if (!va_macro_get_data(codec, &va_dev, &va_priv, __func__))
return -EINVAL;
@@ -1125,64 +995,38 @@ static int va_macro_enable_dec(struct snd_soc_dapm_widget *w,
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
snd_soc_update_bits(codec,
dec_cfg_reg, 0x06, va_priv->dec_mode[decimator] <<
VA_MACRO_ADC_MODE_CFG0_SHIFT);
/* Enable TX PGA Mute */
snd_soc_update_bits(codec,
tx_vol_ctl_reg, 0x10, 0x10);
snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x10, 0x10);
break;
case SND_SOC_DAPM_POST_PMU:
/* Enable TX CLK */
snd_soc_update_bits(codec, tx_vol_ctl_reg, 0x20, 0x20);
if (!(is_amic_enabled(codec, decimator) < BOLERO_ADC_MAX)) {
snd_soc_update_bits(codec,
hpf_gate_reg, 0x01, 0x00);
/*
* Minimum 1 clk cycle delay is required as per HW spec
*/
usleep_range(1000, 1010);
}
hpf_cut_off_freq = (snd_soc_read(
codec, dec_cfg_reg) &
snd_soc_update_bits(codec, hpf_gate_reg, 0x01, 0x00);
hpf_cut_off_freq = (snd_soc_read(codec, dec_cfg_reg) &
TX_HPF_CUT_OFF_FREQ_MASK) >> 5;
va_priv->va_hpf_work[decimator].hpf_cut_off_freq =
hpf_cut_off_freq;
if (hpf_cut_off_freq != CF_MIN_3DB_150HZ)
if (hpf_cut_off_freq != CF_MIN_3DB_150HZ) {
snd_soc_update_bits(codec, dec_cfg_reg,
TX_HPF_CUT_OFF_FREQ_MASK,
CF_MIN_3DB_150HZ << 5);
if (is_amic_enabled(codec, decimator)) {
hpf_delay = BOLERO_CDC_VA_TX_AMIC_HPF_DELAY_MS;
unmute_delay = BOLERO_CDC_VA_TX_AMIC_UNMUTE_DELAY_MS;
if (va_tx_unmute_delay < unmute_delay)
va_tx_unmute_delay = unmute_delay;
snd_soc_update_bits(codec, hpf_gate_reg, 0x02, 0x02);
/*
* Minimum 1 clk cycle delay is required as per HW spec
*/
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg, 0x02, 0x00);
}
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x02);
if (!is_amic_enabled(codec, decimator))
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x00);
/*
* Minimum 1 clk cycle delay is required as per HW spec
*/
usleep_range(1000, 1010);
snd_soc_update_bits(codec,
hpf_gate_reg, 0x03, 0x01);
/*
* 6ms delay is required as per HW spec
*/
usleep_range(6000, 6010);
/* schedule work queue to Remove Mute */
queue_delayed_work(system_freezable_wq,
&va_priv->va_mute_dwork[decimator].dwork,
msecs_to_jiffies(va_tx_unmute_delay));
schedule_delayed_work(&va_priv->va_mute_dwork[decimator].dwork,
msecs_to_jiffies(va_tx_unmute_delay));
if (va_priv->va_hpf_work[decimator].hpf_cut_off_freq !=
CF_MIN_3DB_150HZ)
queue_delayed_work(system_freezable_wq,
schedule_delayed_work(
&va_priv->va_hpf_work[decimator].dwork,
msecs_to_jiffies(hpf_delay));
msecs_to_jiffies(50));
/* apply gain after decimator is enabled */
snd_soc_write(codec, tx_gain_ctl_reg,
snd_soc_read(codec, tx_gain_ctl_reg));
@@ -1194,25 +1038,18 @@ static int va_macro_enable_dec(struct snd_soc_dapm_widget *w,
if (cancel_delayed_work_sync(
&va_priv->va_hpf_work[decimator].dwork)) {
if (hpf_cut_off_freq != CF_MIN_3DB_150HZ) {
snd_soc_update_bits(codec,
dec_cfg_reg,
TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
if (is_amic_enabled(codec, decimator))
snd_soc_update_bits(codec,
hpf_gate_reg,
0x03, 0x02);
else
snd_soc_update_bits(codec,
hpf_gate_reg,
0x03, 0x03);
snd_soc_update_bits(codec, dec_cfg_reg,
TX_HPF_CUT_OFF_FREQ_MASK,
hpf_cut_off_freq << 5);
snd_soc_update_bits(codec, hpf_gate_reg,
0x02, 0x02);
/*
* Minimum 1 clk cycle delay is required
* as per HW spec
*/
usleep_range(1000, 1010);
snd_soc_update_bits(codec, hpf_gate_reg,
0x03, 0x01);
0x02, 0x00);
}
}
cancel_delayed_work_sync(
@@ -1242,6 +1079,8 @@ static int va_macro_enable_tx(struct snd_soc_dapm_widget *w,
switch (event) {
case SND_SOC_DAPM_POST_PMU:
if (bolero_tx_clk_switch(codec))
dev_dbg(va_dev, "%s: clock switch failed\n",__func__);
if (va_priv->tx_clk_status > 0) {
ret = bolero_clk_rsc_request_clock(va_priv->dev,
va_priv->default_clk_id,
@@ -1333,90 +1172,6 @@ static int va_macro_enable_micbias(struct snd_soc_dapm_widget *w,
return 0;
}
static inline int va_macro_path_get(const char *wname,
unsigned int *path_num)
{
int ret = 0;
char *widget_name = NULL;
char *w_name = NULL;
char *path_num_char = NULL;
char *path_name = NULL;
widget_name = kstrndup(wname, 10, GFP_KERNEL);
if (!widget_name)
return -EINVAL;
w_name = widget_name;
path_name = strsep(&widget_name, " ");
if (!path_name) {
pr_err("%s: Invalid widget name = %s\n",
__func__, widget_name);
ret = -EINVAL;
goto err;
}
path_num_char = strpbrk(path_name, "01234567");
if (!path_num_char) {
pr_err("%s: va path index not found\n",
__func__);
ret = -EINVAL;
goto err;
}
ret = kstrtouint(path_num_char, 10, path_num);
if (ret < 0)
pr_err("%s: Invalid tx path = %s\n",
__func__, w_name);
err:
kfree(w_name);
return ret;
}
static int va_macro_dec_mode_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct va_macro_priv *priv = NULL;
struct device *va_dev = NULL;
int ret = 0;
int path = 0;
if (!va_macro_get_data(codec, &va_dev, &priv, __func__))
return -EINVAL;
ret = va_macro_path_get(kcontrol->id.name, &path);
if (ret)
return ret;
ucontrol->value.integer.value[0] = priv->dec_mode[path];
return 0;
}
static int va_macro_dec_mode_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct va_macro_priv *priv = NULL;
struct device *va_dev = NULL;
int value = ucontrol->value.integer.value[0];
int ret = 0;
int path = 0;
if (!va_macro_get_data(codec, &va_dev, &priv, __func__))
return -EINVAL;
ret = va_macro_path_get(kcontrol->id.name, &path);
if (ret)
return ret;
priv->dec_mode[path] = value;
return 0;
}
static int va_macro_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
@@ -1907,10 +1662,6 @@ static const struct snd_soc_dapm_widget va_macro_dapm_widgets_v2[] = {
SND_SOC_DAPM_SUPPLY_S("VA_TX_SWR_CLK", 0, SND_SOC_NOPM, 0, 0,
va_macro_tx_swr_clk_event_v2,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY_S("VA_SWR_CLK", 0, SND_SOC_NOPM, 0, 0,
va_macro_swr_clk_event_v2,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
};
static const struct snd_soc_dapm_widget va_macro_dapm_widgets_v3[] = {
@@ -2237,12 +1988,6 @@ static const struct snd_soc_dapm_route va_audio_map_v3[] = {
{"VA SMIC MUX3", "SWR_MIC11", "VA SWR_MIC11"},
};
static const struct snd_soc_dapm_route va_audio_map_v2[] = {
{"VA_AIF1 CAP", NULL, "VA_SWR_CLK"},
{"VA_AIF2 CAP", NULL, "VA_SWR_CLK"},
{"VA_AIF3 CAP", NULL, "VA_SWR_CLK"},
};
static const struct snd_soc_dapm_route va_audio_map[] = {
{"VA_AIF1 CAP", NULL, "VA_MCLK"},
{"VA_AIF2 CAP", NULL, "VA_MCLK"},
@@ -2475,24 +2220,8 @@ static const struct snd_soc_dapm_route va_audio_map[] = {
{"VA SWR_ADC1", NULL, "VA_SWR_PWR"},
{"VA SWR_ADC2", NULL, "VA_SWR_PWR"},
{"VA SWR_ADC3", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC0", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC1", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC2", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC3", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC4", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC5", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC6", NULL, "VA_SWR_PWR"},
{"VA SWR_MIC7", NULL, "VA_SWR_PWR"},
};
static const char * const dec_mode_mux_text[] = {
"ADC_DEFAULT", "ADC_LOW_PWR", "ADC_HIGH_PERF",
};
static const struct soc_enum dec_mode_mux_enum =
SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(dec_mode_mux_text),
dec_mode_mux_text);
static const struct snd_kcontrol_new va_macro_snd_controls[] = {
SOC_SINGLE_SX_TLV("VA_DEC0 Volume",
BOLERO_CDC_VA_TX0_TX_VOL_CTL,
@@ -2518,20 +2247,6 @@ static const struct snd_kcontrol_new va_macro_snd_controls[] = {
SOC_SINGLE_SX_TLV("VA_DEC7 Volume",
BOLERO_CDC_VA_TX7_TX_VOL_CTL,
0, -84, 40, digital_gain),
SOC_SINGLE_EXT("LPI Enable", 0, 0, 1, 0,
va_macro_lpi_get, va_macro_lpi_put),
SOC_ENUM_EXT("VA_DEC0 MODE", dec_mode_mux_enum,
va_macro_dec_mode_get, va_macro_dec_mode_put),
SOC_ENUM_EXT("VA_DEC1 MODE", dec_mode_mux_enum,
va_macro_dec_mode_get, va_macro_dec_mode_put),
SOC_ENUM_EXT("VA_DEC2 MODE", dec_mode_mux_enum,
va_macro_dec_mode_get, va_macro_dec_mode_put),
SOC_ENUM_EXT("VA_DEC3 MODE", dec_mode_mux_enum,
va_macro_dec_mode_get, va_macro_dec_mode_put),
};
static const struct snd_kcontrol_new va_macro_snd_controls_common[] = {
@@ -2541,8 +2256,6 @@ static const struct snd_kcontrol_new va_macro_snd_controls_common[] = {
SOC_SINGLE_SX_TLV("VA_DEC1 Volume",
BOLERO_CDC_VA_TX1_TX_VOL_CTL,
0, -84, 40, digital_gain),
SOC_SINGLE_EXT("LPI Enable", 0, 0, 1, 0,
va_macro_lpi_get, va_macro_lpi_put),
};
static const struct snd_kcontrol_new va_macro_snd_controls_v3[] = {
@@ -2552,8 +2265,6 @@ static const struct snd_kcontrol_new va_macro_snd_controls_v3[] = {
SOC_SINGLE_SX_TLV("VA_DEC3 Volume",
BOLERO_CDC_VA_TX3_TX_VOL_CTL,
0, -84, 40, digital_gain),
SOC_SINGLE_EXT("LPI Enable", 0, 0, 1, 0,
va_macro_lpi_get, va_macro_lpi_put),
};
static int va_macro_validate_dmic_sample_rate(u32 dmic_sample_rate,
@@ -2626,9 +2337,6 @@ static int va_macro_init(struct snd_soc_codec *codec)
return -EINVAL;
}
va_priv->lpi_enable = false;
va_priv->register_event_listener = false;
if (va_priv->va_without_decimation) {
ret = snd_soc_dapm_new_controls(dapm, va_macro_wod_dapm_widgets,
ARRAY_SIZE(va_macro_wod_dapm_widgets));
@@ -2684,25 +2392,14 @@ static int va_macro_init(struct snd_soc_codec *codec)
__func__);
return ret;
}
if (va_priv->version == BOLERO_VERSION_2_0) {
if (va_priv->version == BOLERO_VERSION_2_0)
ret = snd_soc_dapm_add_routes(dapm,
va_audio_map_v3,
ARRAY_SIZE(va_audio_map_v3));
if (ret < 0) {
dev_err(va_dev, "%s: Failed to add routes\n",
__func__);
return ret;
}
}
if (va_priv->version == BOLERO_VERSION_2_1) {
ret = snd_soc_dapm_add_routes(dapm,
va_audio_map_v2,
ARRAY_SIZE(va_audio_map_v2));
if (ret < 0) {
dev_err(va_dev, "%s: Failed to add routes\n",
__func__);
return ret;
}
if (ret < 0) {
dev_err(va_dev, "%s: Failed to add routes\n",
__func__);
return ret;
}
} else {
ret = snd_soc_dapm_add_routes(dapm, va_audio_map,
@@ -2795,15 +2492,6 @@ static int va_macro_init(struct snd_soc_codec *codec)
}
va_priv->codec = codec;
if (va_priv->version == BOLERO_VERSION_2_1) {
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL0, 0xEE, 0xCC);
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL1, 0xEE, 0xCC);
snd_soc_update_bits(codec,
BOLERO_CDC_VA_TOP_CSR_SWR_MIC_CTL2, 0xEE, 0xCC);
}
return 0;
}
@@ -2987,7 +2675,6 @@ static void va_macro_init_ops(struct macro_ops *ops,
ops->event_handler = va_macro_event_handler;
ops->set_port_map = va_macro_set_port_map;
ops->reg_wake_irq = va_macro_reg_wake_irq;
ops->clk_div_get = va_macro_clk_div_get;
}
static int va_macro_probe(struct platform_device *pdev)
@@ -3130,7 +2817,6 @@ static int va_macro_probe(struct platform_device *pdev)
va_priv->swr_plat_data.write = NULL;
va_priv->swr_plat_data.bulk_write = NULL;
va_priv->swr_plat_data.clk = va_macro_swrm_clock;
va_priv->swr_plat_data.core_vote = va_macro_core_vote;
va_priv->swr_plat_data.handle_irq = NULL;
mutex_init(&va_priv->swr_clk_lock);
}
@@ -3196,10 +2882,6 @@ static const struct of_device_id va_macro_dt_match[] = {
};
static const struct dev_pm_ops bolero_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(
pm_runtime_force_suspend,
pm_runtime_force_resume
)
SET_RUNTIME_PM_OPS(
bolero_runtime_suspend,
bolero_runtime_resume,

23
techpack/audio/4.0/asoc/codecs/bolero/wsa-macro.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -41,7 +41,7 @@
#define NUM_INTERPOLATORS 2
#define WSA_MACRO_MUX_INP_SHFT 0x3
#define WSA_MACRO_MUX_INP_MASK1 0x07
#define WSA_MACRO_MUX_INP_MASK1 0x38
#define WSA_MACRO_MUX_INP_MASK2 0x38
#define WSA_MACRO_MUX_CFG_OFFSET 0x8
#define WSA_MACRO_MUX_CFG1_OFFSET 0x4
@@ -617,10 +617,10 @@ static int wsa_macro_set_prim_interpolator_rate(struct snd_soc_dai *dai,
inp0_sel = int_mux_cfg0_val & WSA_MACRO_MUX_INP_MASK1;
inp1_sel = (int_mux_cfg0_val >>
WSA_MACRO_MUX_INP_SHFT) &
WSA_MACRO_MUX_INP_MASK1;
WSA_MACRO_MUX_INP_MASK2;
inp2_sel = (int_mux_cfg1_val >>
WSA_MACRO_MUX_INP_SHFT) &
WSA_MACRO_MUX_INP_MASK1;
WSA_MACRO_MUX_INP_MASK2;
if ((inp0_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0) ||
(inp1_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0) ||
(inp2_sel == int_1_mix1_inp + INTn_1_INP_SEL_RX0)) {
@@ -987,8 +987,10 @@ static int wsa_macro_event_handler(struct snd_soc_codec *codec, u16 event,
switch (event) {
case BOLERO_MACRO_EVT_SSR_DOWN:
trace_printk("%s, enter SSR down\n", __func__);
if (wsa_priv->swr_ctrl_data) {
swrm_wcd_notify(
wsa_priv->swr_ctrl_data[0].wsa_swr_pdev,
SWR_DEVICE_DOWN, NULL);
swrm_wcd_notify(
wsa_priv->swr_ctrl_data[0].wsa_swr_pdev,
SWR_DEVICE_SSR_DOWN, NULL);
@@ -1004,7 +1006,6 @@ static int wsa_macro_event_handler(struct snd_soc_codec *codec, u16 event,
}
break;
case BOLERO_MACRO_EVT_SSR_UP:
trace_printk("%s, enter SSR up\n", __func__);
/* reset swr after ssr/pdr */
wsa_priv->reset_swr = true;
/* enable&disable WSA_CORE_CLK to reset GFMUX reg */
@@ -2758,9 +2759,6 @@ static int wsa_swrm_clock(void *handle, bool enable)
mutex_lock(&wsa_priv->swr_clk_lock);
trace_printk("%s: %s swrm clock %s\n",
dev_name(wsa_priv->dev), __func__,
(enable ? "enable" : "disable"));
dev_dbg(wsa_priv->dev, "%s: swrm clock %s\n",
__func__, (enable ? "enable" : "disable"));
if (enable) {
@@ -2826,9 +2824,6 @@ static int wsa_swrm_clock(void *handle, bool enable)
}
}
}
trace_printk("%s: %s swrm clock users: %d\n",
dev_name(wsa_priv->dev), __func__,
wsa_priv->swr_clk_users);
dev_dbg(wsa_priv->dev, "%s: swrm clock users %d\n",
__func__, wsa_priv->swr_clk_users);
exit:
@@ -3170,10 +3165,6 @@ static const struct of_device_id wsa_macro_dt_match[] = {
};
static const struct dev_pm_ops bolero_dev_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(
pm_runtime_force_suspend,
pm_runtime_force_resume
)
SET_RUNTIME_PM_OPS(
bolero_runtime_suspend,
bolero_runtime_resume,

2
techpack/audio/4.0/asoc/codecs/bolero/wsa-macro.h
View File

@@ -30,7 +30,7 @@ static inline int wsa_macro_set_spkr_mode(struct snd_soc_codec *codec, int mode)
return 0;
}
static inline int wsa_macro_set_spkr_gain_offset(struct snd_soc_codec *codec,
int offset)
int offset);
{
return 0;
}

17
techpack/audio/4.0/asoc/codecs/msm-cdc-pinctrl.c
View File

@@ -183,8 +183,7 @@ static int msm_cdc_pinctrl_probe(struct platform_device *pdev)
int ret = 0;
struct msm_cdc_pinctrl_info *gpio_data;
u32 chip_wakeup_reg[MAX_GPIOS] = {0};
u32 chip_wakeup_default_val[MAX_GPIOS] = {0};
u32 i = 0, temp = 0;
u32 i = 0;
int count = 0;
gpio_data = devm_kzalloc(&pdev->dev,
@@ -246,20 +245,6 @@ static int msm_cdc_pinctrl_probe(struct platform_device *pdev)
gpio_data->chip_wakeup_register[i] =
devm_ioremap(&pdev->dev, chip_wakeup_reg[i], 0x4);
}
if (!of_property_read_u32_array(pdev->dev.of_node,
"qcom,chip-wakeup-default-val",
chip_wakeup_default_val, count)) {
for (i = 0; i < count; i++) {
temp = ioread32(gpio_data->chip_wakeup_register[i]);
if (chip_wakeup_default_val[i])
temp |= (1 <<
gpio_data->chip_wakeup_maskbit[i]);
else
temp &= ~(1 <<
gpio_data->chip_wakeup_maskbit[i]);
iowrite32(temp, gpio_data->chip_wakeup_register[i]);
}
}
gpio_data->wakeup_reg_count = count;
}

37
techpack/audio/4.0/asoc/codecs/msm_hdmi_codec_rx.c
View File

@@ -92,15 +92,13 @@ static int msm_ext_disp_edid_ctl_info(struct snd_kcontrol *kcontrol,
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai_id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.get_audio_edid_blk || rc) {
if (!codec_data->ext_disp_ops.get_audio_edid_blk) {
dev_dbg(codec->dev, "%s: get_audio_edid_blk() is NULL\n",
__func__);
uinfo->type = SNDRV_CTL_ELEM_TYPE_BYTES;
uinfo->count = 0;
mutex_unlock(&codec_data->dp_ops_lock);
return 0;
return -EINVAL;
}
rc = codec_data->ext_disp_ops.get_audio_edid_blk(
@@ -138,9 +136,7 @@ static int msm_ext_disp_edid_get(struct snd_kcontrol *kcontrol,
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai_id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.get_audio_edid_blk || rc) {
if (!codec_data->ext_disp_ops.get_audio_edid_blk) {
dev_err(codec->dev, "%s: codec_data or get_audio_edid_blk() is NULL\n",
__func__);
mutex_unlock(&codec_data->dp_ops_lock);
@@ -199,11 +195,9 @@ static int msm_ext_disp_audio_type_get(struct snd_kcontrol *kcontrol,
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai_id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.get_audio_edid_blk ||
!codec_data->ext_disp_ops.get_intf_id || rc) {
!codec_data->ext_disp_ops.get_intf_id) {
dev_err(codec->dev, "%s: get_audio_edid_blk() or get_intf_id is NULL\n",
__func__);
rc = -EINVAL;
@@ -285,10 +279,8 @@ static int msm_ext_disp_audio_ack_set(struct snd_kcontrol *kcontrol,
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai_id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.acknowledge || rc) {
if (!codec_data->ext_disp_ops.acknowledge) {
dev_err(codec->dev,
"%s: codec_data ops acknowledge() is NULL\n",
__func__);
@@ -462,7 +454,7 @@ static int msm_ext_disp_audio_codec_rx_dai_startup(
struct snd_pcm_substream *substream,
struct snd_soc_dai *dai)
{
int ret = 0, rc = 0;
int ret = 0;
struct msm_ext_disp_codec_id codec_info;
struct msm_ext_disp_audio_codec_rx_data *codec_data =
dev_get_drvdata(dai->codec->dev);
@@ -478,10 +470,8 @@ static int msm_ext_disp_audio_codec_rx_dai_startup(
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai->id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.cable_status || rc) {
if (!codec_data->ext_disp_ops.cable_status) {
dev_err(dai->dev, "%s() cable_status is null\n",
__func__);
mutex_unlock(&codec_data->dp_ops_lock);
@@ -534,10 +524,8 @@ static int msm_ext_disp_audio_codec_rx_dai_hw_params(
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai->id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.audio_info_setup || rc) {
if (!codec_data->ext_disp_ops.audio_info_setup) {
dev_err(dai->dev, "%s: audio_info_setup is null\n",
__func__);
mutex_unlock(&codec_data->dp_ops_lock);
@@ -604,13 +592,8 @@ static int msm_ext_disp_audio_codec_rx_dai_hw_params(
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai->id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (rc)
goto end;
rc = codec_data->ext_disp_ops.audio_info_setup(
codec_data->ext_disp_core_pdev, &audio_setup_params);
end:
mutex_unlock(&codec_data->dp_ops_lock);
if (rc < 0) {
dev_err_ratelimited(dai->dev,
@@ -642,11 +625,9 @@ static void msm_ext_disp_audio_codec_rx_dai_shutdown(
mutex_lock(&codec_data->dp_ops_lock);
SWITCH_DP_CODEC(codec_info, codec_data, dai->id);
rc = msm_ext_disp_select_audio_codec(codec_data->ext_disp_core_pdev,
&codec_info);
if (!codec_data->ext_disp_ops.teardown_done ||
!codec_data->ext_disp_ops.cable_status || rc) {
!codec_data->ext_disp_ops.cable_status) {
dev_err(dai->dev, "%s: teardown_done or cable_status is null\n",
__func__);
mutex_unlock(&codec_data->dp_ops_lock);

3
techpack/audio/4.0/asoc/codecs/wcd-clsh.c
View File

@@ -457,9 +457,6 @@ static bool wcd_clsh_is_state_valid(u8 state)
case WCD_CLSH_STATE_HPHR_AUX:
case WCD_CLSH_STATE_HPH_ST_AUX:
case WCD_CLSH_STATE_EAR_AUX:
case WCD_CLSH_STATE_HPHL_EAR:
case WCD_CLSH_STATE_HPHR_EAR:
case WCD_CLSH_STATE_HPH_ST_EAR:
return true;
default:
return false;

212
techpack/audio/4.0/asoc/codecs/wcd-mbhc-adc.c
View File

@@ -1,7 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
*/
#define DEBUG
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
@@ -23,19 +22,12 @@
#include "wcd-mbhc-adc.h"
#include <asoc/wcd-mbhc-v2.h>
#include <asoc/pdata.h>
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
#include "wcd938x/wcd938x-registers.h"
#endif
#define WCD_MBHC_ADC_HS_THRESHOLD_MV 1700
#define WCD_MBHC_ADC_HPH_THRESHOLD_MV 641
#define WCD_MBHC_ADC_MICBIAS_MV 2800
#define WCD_MBHC_ADC_HPH_THRESHOLD_MV 75
#define WCD_MBHC_ADC_MICBIAS_MV 1800
#define WCD_MBHC_FAKE_INS_RETRY 4
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
#define MBHC_SLOW_DET_ADC_COUNT 10
#endif
static int wcd_mbhc_get_micbias(struct wcd_mbhc *mbhc)
{
int micbias = 0;
@@ -91,7 +83,7 @@ static int wcd_measure_adc_continuous(struct wcd_mbhc *mbhc)
while (retry--) {
/* wait for 3 msec before reading ADC result */
usleep_range(20000, 20100);
usleep_range(3000, 3100);
/* Read ADC result */
WCD_MBHC_REG_READ(WCD_MBHC_ADC_RESULT, adc_result);
@@ -102,7 +94,7 @@ static int wcd_measure_adc_continuous(struct wcd_mbhc *mbhc)
/* Get voltage from ADC result */
output_mv = wcd_get_voltage_from_adc(adc_result,
wcd_mbhc_get_micbias(mbhc));
pr_info("%s: adc_result: 0x%x, output_mv: %d\n",
pr_debug("%s: adc_result: 0x%x, output_mv: %d\n",
__func__, adc_result, output_mv);
return output_mv;
@@ -321,12 +313,7 @@ static int wcd_check_cross_conn(struct wcd_mbhc *mbhc)
goto done;
}
/* Update cross connection threshold voltages if needed */
if (mbhc->mbhc_cb->update_cross_conn_thr)
mbhc->mbhc_cb->update_cross_conn_thr(mbhc);
if (hphl_adc_res > mbhc->hphl_cross_conn_thr ||
hphr_adc_res > mbhc->hphr_cross_conn_thr) {
if (hphl_adc_res > 100 || hphr_adc_res > 100) {
plug_type = MBHC_PLUG_TYPE_GND_MIC_SWAP;
pr_debug("%s: Cross connection identified\n", __func__);
} else {
@@ -526,21 +513,18 @@ static bool wcd_is_special_headset(struct wcd_mbhc *mbhc)
static void wcd_mbhc_adc_update_fsm_source(struct wcd_mbhc *mbhc,
enum wcd_mbhc_plug_type plug_type)
{
struct snd_soc_codec *codec = mbhc->codec;
bool micbias2;
micbias2 = mbhc->mbhc_cb->micbias_enable_status(mbhc,
MIC_BIAS_2);
switch (plug_type) {
case MBHC_PLUG_TYPE_HEADPHONE:
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 0);
if (!mbhc->mbhc_cfg->detect_extn_cable)
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, 0);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 3);
break;
case MBHC_PLUG_TYPE_HEADSET:
case MBHC_PLUG_TYPE_ANC_HEADPHONE:
if (mbhc->pullup_enable == false) {
mbhc->mbhc_cb->mbhc_micbias_control(codec,
MIC_BIAS_2, MICB_PULLUP_ENABLE);
mbhc->pullup_enable = true;
}
if (!mbhc->is_hs_recording && !micbias2)
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 3);
break;
default:
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 0);
@@ -579,115 +563,26 @@ static void wcd_cancel_hs_detect_plug(struct wcd_mbhc *mbhc,
static void wcd_mbhc_adc_detect_plug_type(struct wcd_mbhc *mbhc)
{
struct snd_soc_codec *codec = mbhc->codec;
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
/* slow: Check slow insertion with schmitt trigger */
bool hphl_sch_res, hphr_sch_res;
int hphl_adc_res = 0, hphr_adc_res = 0;
u8 fsm_en = 0;
u8 adc_mode = 0;
u8 elect_ctl = 0;
u8 adc_en = 0;
int try_l = 0, try_r = 0;
#endif
pr_debug("%s: enter\n", __func__);
WCD_MBHC_RSC_ASSERT_LOCKED(mbhc);
if (mbhc->mbhc_cb->hph_pull_down_ctrl)
mbhc->mbhc_cb->hph_pull_down_ctrl(codec, false);
/* disable MIC_CLAMP */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_MIC_CLAMP_CTL, 0);
/* disable surge protection */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_EN_SURGE_PROTECTION_HPHL, 0);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_EN_SURGE_PROTECTION_HPHR, 0);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_DETECTION_DONE, 0);
if (mbhc->mbhc_cb->mbhc_micbias_control) {
usleep_range(20000, 20100);
mbhc->mbhc_cb->mbhc_micbias_control(codec, MIC_BIAS_2,
MICB_ENABLE);
} else {
pr_err("%s: Mic Bias is not enabled\n", __func__);
return;
}
/* slow: Check L/R ADC value of each pin */
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
/* Read legacy electircal detection and disable */
WCD_MBHC_REG_READ(WCD_MBHC_ELECT_SCHMT_ISRC, elect_ctl);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ELECT_SCHMT_ISRC, 0);
/* Read and set ADC to single measurement */
WCD_MBHC_REG_READ(WCD_MBHC_ADC_MODE, adc_mode);
/* Read ADC Enable bit to restore after adc measurement */
WCD_MBHC_REG_READ(WCD_MBHC_ADC_EN, adc_en);
/* Read FSM status */
WCD_MBHC_REG_READ(WCD_MBHC_FSM_EN, fsm_en);
/* Get adc result for HPH L */
do {
hphl_adc_res = wcd_measure_adc_once(mbhc, MUX_CTL_HPH_L);
if (hphl_adc_res < 0) {
pr_err("%s: hphl_adc_res adc measurement failed\n", __func__);
hphl_sch_res = true;
} else {
pr_debug("%s: hphl_adc_res adc val : %d\n", __func__, hphl_adc_res);
hphl_sch_res = hphl_adc_res > 50 ? true : false;
break;
}
try_l++;
} while (try_l < MBHC_SLOW_DET_ADC_COUNT);
/* Get adc result for HPH R in mV */
do {
hphr_adc_res = wcd_measure_adc_once(mbhc, MUX_CTL_HPH_R);
if (hphr_adc_res < 0) {
pr_err("%s: hphr_adc_res adc measurement failed\n", __func__);
hphr_sch_res = true;
} else {
pr_debug("%s: hphr_adc_res adc val : %d\n", __func__, hphr_adc_res);
hphr_sch_res = hphr_adc_res > 50 ? true : false;
break;
}
try_r++;
} while (try_r < MBHC_SLOW_DET_ADC_COUNT);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, 0);
/* Set the MUX selection to Auto */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_MUX_CTL, MUX_CTL_AUTO);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, 1);
/* Restore ADC Enable */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ADC_EN, adc_en);
/* Restore ADC mode */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ADC_MODE, adc_mode);
/* Restore FSM state */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, fsm_en);
/* Restore electrical detection */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ELECT_SCHMT_ISRC, elect_ctl);
if ((hphl_sch_res || hphr_sch_res) && !mbhc->is_extn_cable) {
pr_debug("%s: SLOW Insertion [ %d | %d ]\n",
__func__, hphl_sch_res, hphr_sch_res);
mbhc->slow_insertion = true;
} else {
pr_debug("%s: NORMAL Insertion [ %d | %d ]\n",
__func__, hphl_sch_res, hphr_sch_res);
mbhc->slow_insertion = false;
}
/* enable HPH L/R GND switch */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_HPHL_GND, 1);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_HPHR_GND, 1);
/* enable MIC_CLAMP */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_MIC_CLAMP_CTL, 2);
#endif/* CONFIG_SND_SOC_WCD_MBHC_SLOW_DET */
/* Re-initialize button press completion object */
reinit_completion(&mbhc->btn_press_compl);
wcd_schedule_hs_detect_plug(mbhc, &mbhc->correct_plug_swch);
pr_debug("%s: leave\n", __func__);
}
@@ -714,18 +609,11 @@ static int wcd_mbhc_get_plug_from_adc(struct wcd_mbhc *mbhc, int adc_result)
if (adc_result < hph_thr)
plug_type = MBHC_PLUG_TYPE_HEADPHONE;
else if (adc_result > hs_thr) {
if (mbhc->mbhc_cfg->detect_extn_cable)
#ifdef CONFIG_SEC_FACTORY
plug_type = MBHC_PLUG_TYPE_HEADSET;
#else
plug_type = MBHC_PLUG_TYPE_HIGH_HPH;
#endif
else
plug_type = MBHC_PLUG_TYPE_HEADSET;
} else
else if (adc_result > hs_thr)
plug_type = MBHC_PLUG_TYPE_HIGH_HPH;
else
plug_type = MBHC_PLUG_TYPE_HEADSET;
pr_info("%s: plug type is %d found\n", __func__, plug_type);
pr_debug("%s: plug type is %d found\n", __func__, plug_type);
return plug_type;
}
@@ -743,10 +631,8 @@ static void wcd_correct_swch_plug(struct work_struct *work)
int ret = 0;
int spl_hs_count = 0;
int output_mv = 0;
#ifndef CONFIG_SND_SOC_WCD_MBHC_SLOW_DET
int cross_conn;
int try = 0;
#endif
int hs_threshold, micbias_mv;
pr_debug("%s: enter\n", __func__);
@@ -762,7 +648,6 @@ static void wcd_correct_swch_plug(struct work_struct *work)
wcd_mbhc_hs_elec_irq(mbhc, WCD_MBHC_ELEC_HS_INS, false);
WCD_MBHC_RSC_UNLOCK(mbhc);
#ifndef CONFIG_SND_SOC_WCD_MBHC_SLOW_DET
/* Check for cross connection */
do {
cross_conn = wcd_check_cross_conn(mbhc);
@@ -775,7 +660,6 @@ static void wcd_correct_swch_plug(struct work_struct *work)
__func__, plug_type);
goto correct_plug_type;
}
#endif
/* Find plug type */
output_mv = wcd_measure_adc_continuous(mbhc);
plug_type = wcd_mbhc_get_plug_from_adc(mbhc, output_mv);
@@ -784,16 +668,12 @@ static void wcd_correct_swch_plug(struct work_struct *work)
* Report plug type if it is either headset or headphone
* else start the 3 sec loop
*/
if (plug_type == MBHC_PLUG_TYPE_HEADSET ||
plug_type == MBHC_PLUG_TYPE_HEADPHONE) {
if (mbhc->mbhc_cfg->detect_extn_cable &&
wcd_swch_level_remove(mbhc)) {
pr_info("%s: Skipping to report plug\n", __func__);
} else {
WCD_MBHC_RSC_LOCK(mbhc);
wcd_mbhc_find_plug_and_report(mbhc, plug_type);
WCD_MBHC_RSC_UNLOCK(mbhc);
}
if ((plug_type == MBHC_PLUG_TYPE_HEADSET ||
plug_type == MBHC_PLUG_TYPE_HEADPHONE) &&
(!wcd_swch_level_remove(mbhc))) {
WCD_MBHC_RSC_LOCK(mbhc);
wcd_mbhc_find_plug_and_report(mbhc, plug_type);
WCD_MBHC_RSC_UNLOCK(mbhc);
}
/*
@@ -807,26 +687,16 @@ static void wcd_correct_swch_plug(struct work_struct *work)
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_DETECTION_DONE, 1);
}
#ifndef CONFIG_SND_SOC_WCD_MBHC_SLOW_DET
correct_plug_type:
#else
if (!mbhc->slow_insertion &&
mbhc->current_plug == MBHC_PLUG_TYPE_HEADSET) {
pr_debug("%s: plug_type:0x%x already reported\n",
__func__, mbhc->current_plug);
goto report;
}
#endif
/*
* Callback to disable BCS slow insertion detection
*/
if (plug_type == MBHC_PLUG_TYPE_HEADSET ||
plug_type == MBHC_PLUG_TYPE_HEADPHONE)
if (mbhc->mbhc_cb->bcs_enable)
mbhc->mbhc_cb->bcs_enable(mbhc, false);
mbhc->mbhc_cb->bcs_enable(mbhc, false);
timeout = jiffies + msecs_to_jiffies(HS_DETECT_PLUG_TIME_MS);
while (!time_after(jiffies, timeout) && mbhc->slow_insertion) {
while (!time_after(jiffies, timeout)) {
if (mbhc->hs_detect_work_stop) {
pr_debug("%s: stop requested: %d\n", __func__,
mbhc->hs_detect_work_stop);
@@ -857,8 +727,7 @@ correct_plug_type:
plug_type = wcd_mbhc_get_plug_from_adc(mbhc, output_mv);
if ((output_mv > hs_threshold) &&
(spl_hs_count < WCD_MBHC_SPL_HS_CNT) &&
mbhc->mbhc_cfg->mbhc_spl_headset) {
(spl_hs_count < WCD_MBHC_SPL_HS_CNT)) {
spl_hs = wcd_mbhc_adc_check_for_spl_headset(mbhc,
&spl_hs_count);
output_mv = wcd_measure_adc_once(mbhc, MUX_CTL_IN2P);
@@ -875,7 +744,7 @@ correct_plug_type:
is_pa_on = mbhc->mbhc_cb->hph_pa_on_status(mbhc->codec);
if ((output_mv <= hs_threshold) &&
(!is_pa_on) && mbhc->mbhc_cfg->mbhc_spl_headset) {
(!is_pa_on)) {
/* Check for cross connection*/
ret = wcd_check_cross_conn(mbhc);
if (ret < 0)
@@ -930,20 +799,12 @@ correct_plug_type:
if (output_mv > hs_threshold) {
pr_debug("%s: cable is extension cable\n", __func__);
if (mbhc->mbhc_cfg->detect_extn_cable)
#ifdef CONFIG_SEC_FACTORY
plug_type = MBHC_PLUG_TYPE_HEADSET;
#else
plug_type = MBHC_PLUG_TYPE_HIGH_HPH;
#endif
else
plug_type = MBHC_PLUG_TYPE_HEADSET;
plug_type = MBHC_PLUG_TYPE_HIGH_HPH;
wrk_complete = true;
} else {
pr_debug("%s: cable might be headset: %d\n", __func__,
plug_type);
if ((plug_type != MBHC_PLUG_TYPE_GND_MIC_SWAP) &&
mbhc->mbhc_cfg->mbhc_spl_headset){
if (plug_type != MBHC_PLUG_TYPE_GND_MIC_SWAP) {
plug_type = wcd_mbhc_get_plug_from_adc(
mbhc, output_mv);
if (!spl_hs_reported &&
@@ -979,8 +840,7 @@ correct_plug_type:
}
if ((plug_type == MBHC_PLUG_TYPE_HEADSET ||
plug_type == MBHC_PLUG_TYPE_HEADPHONE))
if (mbhc->mbhc_cb->bcs_enable)
mbhc->mbhc_cb->bcs_enable(mbhc, true);
mbhc->mbhc_cb->bcs_enable(mbhc, true);
if (!wrk_complete) {
/*
@@ -988,9 +848,8 @@ correct_plug_type:
* in detect_plug-type or in above while loop, no need to report
* again
*/
if ((mbhc->current_plug == plug_type) &&
((plug_type == MBHC_PLUG_TYPE_HEADSET) ||
(plug_type == MBHC_PLUG_TYPE_ANC_HEADPHONE))) {
if ((plug_type == MBHC_PLUG_TYPE_HEADSET) ||
(plug_type == MBHC_PLUG_TYPE_ANC_HEADPHONE)) {
pr_debug("%s: plug_type:0x%x already reported\n",
__func__, mbhc->current_plug);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ADC_MODE, 0);
@@ -998,8 +857,7 @@ correct_plug_type:
goto enable_supply;
}
}
if (mbhc->mbhc_cfg->mbhc_spl_headset &&
plug_type == MBHC_PLUG_TYPE_HIGH_HPH) {
if (plug_type == MBHC_PLUG_TYPE_HIGH_HPH) {
if (wcd_is_special_headset(mbhc)) {
pr_debug("%s: Special headset found %d\n",
__func__, plug_type);
@@ -1090,9 +948,6 @@ exit:
if (mbhc->mbhc_cb->hph_pull_down_ctrl)
mbhc->mbhc_cb->hph_pull_down_ctrl(codec, true);
/* enable surge protection */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_EN_SURGE_PROTECTION_HPHL, 1);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_EN_SURGE_PROTECTION_HPHR, 1);
mbhc->mbhc_cb->lock_sleep(mbhc, false);
pr_debug("%s: leave\n", __func__);
@@ -1254,7 +1109,6 @@ static irqreturn_t wcd_mbhc_adc_hs_ins_irq(int irq, void *data)
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_ELECT_ISRC_EN, 0);
mbhc->is_extn_cable = true;
mbhc->btn_press_intr = false;
mbhc->force_linein = false;
wcd_mbhc_adc_detect_plug_type(mbhc);
WCD_MBHC_RSC_UNLOCK(mbhc);
pr_debug("%s: leave\n", __func__);

144
techpack/audio/4.0/asoc/codecs/wcd-mbhc-v2.c
View File

@@ -1,7 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
*/
#define DEBUG
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
@@ -19,7 +18,6 @@
#include <linux/firmware.h>
#include <linux/completion.h>
#include <linux/soc/qcom/fsa4480-i2c.h>
#include <linux/wakelock.h>
#include <sound/soc.h>
#include <sound/jack.h>
#include <asoc/msm-cdc-pinctrl.h>
@@ -27,15 +25,6 @@
#include "wcd-mbhc-legacy.h"
#include "wcd-mbhc-adc.h"
#include <asoc/wcd-mbhc-v2-api.h>
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
#include <asoc/pdata.h>
#endif
#ifdef CONFIG_SND_SOC_IMPED_SENSING
#include "wcd938x/internal.h"
#endif
static struct wake_lock det_wake_lock;
static struct wake_lock btn_wake_lock;
void wcd_mbhc_jack_report(struct wcd_mbhc *mbhc,
struct snd_soc_jack *jack, int status, int mask)
@@ -565,8 +554,6 @@ void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion,
pr_debug("%s: enter insertion %d hph_status %x\n",
__func__, insertion, mbhc->hph_status);
wake_lock_timeout(&det_wake_lock, (HZ * 5));
if (!insertion) {
/* Report removal */
mbhc->hph_status &= ~jack_type;
@@ -612,13 +599,6 @@ void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion,
hphlocp_off_report(mbhc, SND_JACK_OC_HPHL);
mbhc->current_plug = MBHC_PLUG_TYPE_NONE;
mbhc->force_linein = false;
#ifdef CONFIG_SEC_FACTORY
/* Insertion debounce set to 256 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 9);
#else
/* Insertion debounce set to 512 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 11);
#endif
} else {
/*
* Report removal of current jack type.
@@ -650,19 +630,11 @@ void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion,
}
mbhc->hph_type = WCD_MBHC_HPH_NONE;
mbhc->zl = mbhc->zr = 0;
if (!mbhc->force_linein) {
pr_debug("%s: Reporting removal (%x)\n",
__func__, mbhc->hph_status);
wcd_mbhc_jack_report(mbhc, &mbhc->headset_jack,
0, WCD_MBHC_JACK_MASK);
}
#ifdef CONFIG_SEC_FACTORY
/* Insertion debounce set to 256 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 9);
#else
/* Insertion debounce set to 512 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 11);
#endif
pr_debug("%s: Reporting removal (%x)\n",
__func__, mbhc->hph_status);
wcd_mbhc_jack_report(mbhc, &mbhc->headset_jack,
0, WCD_MBHC_JACK_MASK);
if (mbhc->hph_status == SND_JACK_LINEOUT) {
pr_debug("%s: Enable micbias\n", __func__);
@@ -711,22 +683,12 @@ void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion,
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_MUX_CTL,
MUX_CTL_AUTO);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, 1);
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
if (!mbhc->slow_insertion)
mbhc->mbhc_cb->compute_impedance(mbhc,
&mbhc->zl, &mbhc->zr);
else
mbhc->impedance_offset = mbhc->default_impedance_offset;
#else
mbhc->mbhc_cb->compute_impedance(mbhc,
&mbhc->zl, &mbhc->zr);
#endif
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN,
fsm_en);
if ((mbhc->zl > mbhc->mbhc_cfg->linein_th &&
mbhc->zl < MAX_IMPED) &&
(mbhc->zr > mbhc->mbhc_cfg->linein_th &&
mbhc->zr < MAX_IMPED) &&
if ((mbhc->zl > mbhc->mbhc_cfg->linein_th) &&
(mbhc->zr > mbhc->mbhc_cfg->linein_th) &&
(jack_type == SND_JACK_HEADPHONE)) {
jack_type = SND_JACK_LINEOUT;
mbhc->force_linein = true;
@@ -766,18 +728,12 @@ void wcd_mbhc_report_plug(struct wcd_mbhc *mbhc, int insertion,
mbhc->hph_status |= jack_type;
if (jack_type == SND_JACK_HEADPHONE &&
mbhc->mbhc_cb->mbhc_micb_ramp_control)
mbhc->mbhc_cb->mbhc_micb_ramp_control(codec, false);
pr_debug("%s: Reporting insertion %d(%x)\n", __func__,
jack_type, mbhc->hph_status);
wcd_mbhc_jack_report(mbhc, &mbhc->headset_jack,
(mbhc->hph_status | SND_JACK_MECHANICAL),
WCD_MBHC_JACK_MASK);
wcd_mbhc_clr_and_turnon_hph_padac(mbhc);
/* Insertion debounce set to 96 */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 6);
}
pr_debug("%s: leave hph_status %x\n", __func__, mbhc->hph_status);
}
@@ -923,8 +879,7 @@ static bool wcd_mbhc_moisture_detect(struct wcd_mbhc *mbhc, bool detection_type)
detection_type);
ret = true;
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_L_DET_EN, 1);
if (mbhc->mbhc_cfg->gnd_det_en)
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_GND_DET_EN, 1);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_GND_DET_EN, 1);
} else {
mbhc->mbhc_cb->mbhc_moisture_polling_ctrl(mbhc, false);
mbhc->mbhc_cb->mbhc_moisture_detect_en(mbhc, false);
@@ -962,10 +917,6 @@ static void wcd_mbhc_swch_irq_handler(struct wcd_mbhc *mbhc)
else
pr_info("%s: hs_detect_plug work not cancelled\n", __func__);
/* Enable micbias ramp */
if (mbhc->mbhc_cb->mbhc_micb_ramp_control)
mbhc->mbhc_cb->mbhc_micb_ramp_control(codec, true);
if (mbhc->mbhc_cb->micbias_enable_status)
micbias1 = mbhc->mbhc_cb->micbias_enable_status(mbhc,
MIC_BIAS_1);
@@ -1014,12 +965,6 @@ static void wcd_mbhc_swch_irq_handler(struct wcd_mbhc *mbhc)
/* Disable HW FSM */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_FSM_EN, 0);
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_ISRC_CTL, 0);
if (mbhc->pullup_enable == true) {
mbhc->mbhc_cb->mbhc_micbias_control(codec,
MIC_BIAS_2, MICB_PULLUP_DISABLE);
mbhc->pullup_enable = false;
}
if (mbhc->mbhc_cb->mbhc_common_micb_ctrl)
mbhc->mbhc_cb->mbhc_common_micb_ctrl(codec,
MBHC_COMMON_MICB_TAIL_CURR, false);
@@ -1072,7 +1017,7 @@ static void wcd_mbhc_swch_irq_handler(struct wcd_mbhc *mbhc)
mbhc->mbhc_cb->clk_setup(mbhc->codec, false);
}
if (mbhc->mbhc_cfg->moisture_en ||
if (mbhc->mbhc_cfg->moisture_en &&
mbhc->mbhc_cfg->moisture_duty_cycle_en) {
if (mbhc->mbhc_cb->mbhc_moisture_polling_ctrl)
mbhc->mbhc_cb->mbhc_moisture_polling_ctrl(mbhc,
@@ -1129,30 +1074,27 @@ int wcd_mbhc_get_button_mask(struct wcd_mbhc *mbhc)
switch (btn) {
case 0:
case 1:
mask = SND_JACK_BTN_0;
break;
case 2:
case 1:
mask = SND_JACK_BTN_1;
break;
case 3:
case 2:
mask = SND_JACK_BTN_2;
break;
case 4:
case 3:
mask = SND_JACK_BTN_3;
break;
case 5:
case 4:
mask = SND_JACK_BTN_4;
break;
case 6:
case 7:
case 5:
mask = SND_JACK_BTN_5;
break;
default:
break;
}
pr_info("%s: button %d\n", __func__, btn);
return mask;
}
EXPORT_SYMBOL(wcd_mbhc_get_button_mask);
@@ -1232,7 +1174,6 @@ static irqreturn_t wcd_mbhc_btn_press_handler(int irq, void *data)
__func__);
goto done;
}
wake_lock_timeout(&btn_wake_lock, (HZ * 5));
mask = wcd_mbhc_get_button_mask(mbhc);
if (mask == SND_JACK_BTN_0)
mbhc->btn_press_intr = true;
@@ -1421,7 +1362,8 @@ static int wcd_mbhc_initialise(struct wcd_mbhc *mbhc)
if (mbhc->mbhc_cfg->moisture_en && mbhc->mbhc_cb->mbhc_moisture_config
&& !mbhc->mbhc_cfg->moisture_duty_cycle_en)
mbhc->mbhc_cb->mbhc_moisture_config(mbhc);
else if (mbhc->mbhc_cb->mbhc_moisture_detect_en)
else if (mbhc->mbhc_cfg->moisture_duty_cycle_en &&
mbhc->mbhc_cb->mbhc_moisture_detect_en)
mbhc->mbhc_cb->mbhc_moisture_detect_en(mbhc, false);
/*
@@ -1461,18 +1403,16 @@ static int wcd_mbhc_initialise(struct wcd_mbhc *mbhc)
/* Insertion debounce set to 48ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 4);
} else {
#ifdef CONFIG_SEC_FACTORY
/* Insertion debounce set to 256 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 9);
#else
/* Insertion debounce set to 512 ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 11);
#endif
/* Insertion debounce set to 96ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_INSREM_DBNC, 6);
}
/* Button Debounce set to 8ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_DBNC, 1);
/* Button Debounce set to 16ms */
WCD_MBHC_REG_UPDATE_BITS(WCD_MBHC_BTN_DBNC, 2);
/* Enable micbias ramp */
if (mbhc->mbhc_cb->mbhc_micb_ramp_control)
mbhc->mbhc_cb->mbhc_micb_ramp_control(codec, true);
/* enable bias */
mbhc->mbhc_cb->mbhc_bias(codec, true);
/* enable MBHC clock */
@@ -1483,14 +1423,6 @@ static int wcd_mbhc_initialise(struct wcd_mbhc *mbhc)
mbhc->mbhc_cb->clk_setup(codec, true);
}
#ifndef CONFIG_SEC_FACTORY
/* Samsung external cable ADC detection flag check */
if (of_find_property(codec->component.card->dev->of_node, "detect-extn-cable", NULL))
mbhc->mbhc_cfg->detect_extn_cable = true;
pr_debug("%s: external cable support : %s\n", __func__,
mbhc->mbhc_cfg->detect_extn_cable ? "true" : "false");
#endif
/* program HS_VREF value */
wcd_program_hs_vref(mbhc);
@@ -1665,7 +1597,6 @@ int wcd_mbhc_start(struct wcd_mbhc *mbhc, struct wcd_mbhc_config *mbhc_cfg)
struct snd_soc_codec *codec;
struct snd_soc_card *card;
const char *usb_c_dt = "qcom,msm-mbhc-usbc-audio-supported";
const char *gnd_det = "qcom,msm-mbhc-gnd-det";
if (!mbhc || !mbhc_cfg)
return -EINVAL;
@@ -1692,12 +1623,6 @@ int wcd_mbhc_start(struct wcd_mbhc *mbhc, struct wcd_mbhc_config *mbhc_cfg)
"%s: skipping USB c analog configuration\n", __func__);
}
mbhc_cfg->gnd_det_en =
of_property_read_bool(card->dev->of_node, gnd_det);
dev_info(card->dev,
"%s: gnd_det_en %d\n", __func__, mbhc_cfg->gnd_det_en);
/* Parse fsa switch handle */
if (mbhc_cfg->enable_usbc_analog) {
dev_dbg(mbhc->codec->dev, "%s: usbc analog enabled\n",
@@ -1801,10 +1726,6 @@ int wcd_mbhc_init(struct wcd_mbhc *mbhc, struct snd_soc_codec *codec,
const char *gnd_switch = "qcom,msm-mbhc-gnd-swh";
const char *hs_thre = "qcom,msm-mbhc-hs-mic-max-threshold-mv";
const char *hph_thre = "qcom,msm-mbhc-hs-mic-min-threshold-mv";
#ifdef CONFIG_SND_SOC_IMPED_SENSING
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
struct wcd938x_pdata *pdata = dev_get_platdata(wcd938x->dev);
#endif
pr_debug("%s: enter\n", __func__);
@@ -1866,16 +1787,6 @@ int wcd_mbhc_init(struct wcd_mbhc *mbhc, struct snd_soc_codec *codec,
mbhc->hph_type = WCD_MBHC_HPH_NONE;
mbhc->wcd_mbhc_regs = wcd_mbhc_regs;
mbhc->swap_thr = GND_MIC_SWAP_THRESHOLD;
mbhc->hphl_cross_conn_thr = HPHL_CROSS_CONN_THRESHOLD;
mbhc->hphr_cross_conn_thr = HPHR_CROSS_CONN_THRESHOLD;
mbhc->pullup_enable = false;
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
mbhc->slow_insertion = false;
#endif
#ifdef CONFIG_SND_SOC_IMPED_SENSING
mbhc->default_impedance_offset =
pdata->imp_table[SND_JACK_HEADSET].gain;
#endif
if (mbhc->intr_ids == NULL) {
pr_err("%s: Interrupt mapping not provided\n", __func__);
@@ -2042,9 +1953,6 @@ int wcd_mbhc_init(struct wcd_mbhc *mbhc, struct snd_soc_codec *codec,
goto err_hphr_ocp_irq;
}
wake_lock_init(&det_wake_lock, WAKE_LOCK_SUSPEND, "mbhc_det_wake_lock");
wake_lock_init(&btn_wake_lock, WAKE_LOCK_SUSPEND, "mbhc_btn_wake_lock");
mbhc->deinit_in_progress = false;
pr_debug("%s: leave ret %d\n", __func__, ret);
return ret;
@@ -2068,8 +1976,6 @@ err_mbhc_sw_irq:
mbhc->mbhc_cb->register_notifier(mbhc, &mbhc->nblock, false);
mutex_destroy(&mbhc->codec_resource_lock);
err:
wake_lock_destroy(&det_wake_lock);
wake_lock_destroy(&btn_wake_lock);
pr_debug("%s: leave ret %d\n", __func__, ret);
return ret;
}
@@ -2099,8 +2005,6 @@ void wcd_mbhc_deinit(struct wcd_mbhc *mbhc)
mutex_destroy(&mbhc->codec_resource_lock);
mutex_destroy(&mbhc->hphl_pa_lock);
mutex_destroy(&mbhc->hphr_pa_lock);
wake_lock_destroy(&det_wake_lock);
wake_lock_destroy(&btn_wake_lock);
}
EXPORT_SYMBOL(wcd_mbhc_deinit);

3
techpack/audio/4.0/asoc/codecs/wcd937x/internal.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#ifndef _WCD937X_INTERNAL_H
@@ -133,7 +133,6 @@ enum {
WCD_BOLERO_EVT_RX_MUTE = 1, /* for RX mute/unmute */
WCD_BOLERO_EVT_IMPED_TRUE, /* for imped true */
WCD_BOLERO_EVT_IMPED_FALSE, /* for imped false */
WCD_BOLERO_EVT_RX_COMPANDER_SOFT_RST,
WCD_BOLERO_EVT_BCS_CLK_OFF,
};

3
techpack/audio/4.0/asoc/codecs/wcd937x/wcd937x-mbhc.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#ifndef __WCD937X_MBHC_H__
#define __WCD937X_MBHC_H__
@@ -51,6 +51,7 @@ static inline int wcd937x_mbhc_post_ssr_init(struct wcd937x_mbhc *mbhc,
static inline void wcd937x_mbhc_ssr_down(struct wcd937x_mbhc *mbhc,
struct snd_soc_component *component)
{
return 0;
}
static inline int wcd937x_mbhc_get_impedance(struct wcd937x_mbhc *wcd937x_mbhc,
uint32_t *zl, uint32_t *zr)

43
techpack/audio/4.0/asoc/codecs/wcd937x/wcd937x.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -36,8 +36,6 @@
#define WCD937X_VERSION_ENTRY_SIZE 32
#define EAR_RX_PATH_AUX 1
#define NUM_ATTEMPTS 5
enum {
CODEC_TX = 0,
CODEC_RX,
@@ -599,6 +597,7 @@ static int wcd937x_codec_aux_dac_event(struct snd_soc_dapm_widget *w,
break;
case SND_SOC_DAPM_POST_PMD:
wcd937x_rx_clk_disable(codec);
snd_soc_update_bits(codec, WCD937X_DIGITAL_CDC_ANA_CLK_CTL,
0x04, 0x00);
break;
@@ -1398,7 +1397,7 @@ int wcd937x_micbias_control(struct snd_soc_codec *codec,
snd_soc_update_bits(codec, WCD937X_MICB2_TEST_CTL_2, 0x01, 0x01);
snd_soc_update_bits(codec, WCD937X_MICB3_TEST_CTL_2, 0x01, 0x01);
snd_soc_update_bits(codec, micb_reg, 0xC0, 0x40);
if (post_on_event)
if (post_on_event && wcd937x->mbhc)
blocking_notifier_call_chain(
&wcd937x->mbhc->notifier, post_on_event,
&wcd937x->mbhc->wcd_mbhc);
@@ -1473,18 +1472,14 @@ static int wcd937x_get_logical_addr(struct swr_device *swr_dev)
{
int ret = 0;
uint8_t devnum = 0;
int num_retry = NUM_ATTEMPTS;
do {
ret = swr_get_logical_dev_num(swr_dev, swr_dev->addr, &devnum);
if (ret) {
dev_err(&swr_dev->dev,
"%s get devnum %d for dev addr %lx failed\n",
__func__, devnum, swr_dev->addr);
/* retry after 1ms */
usleep_range(1000, 1010);
}
} while (ret && --num_retry);
ret = swr_get_logical_dev_num(swr_dev, swr_dev->addr, &devnum);
if (ret) {
dev_err(&swr_dev->dev,
"%s get devnum %d for dev addr %lx failed\n",
__func__, devnum, swr_dev->addr);
return ret;
}
swr_dev->dev_num = devnum;
return 0;
}
@@ -1519,20 +1514,20 @@ static int wcd937x_event_notify(struct notifier_block *block,
snd_soc_update_bits(codec, WCD937X_AUX_AUXPA, 0x80, 0x00);
break;
case BOLERO_WCD_EVT_SSR_DOWN:
wcd937x->mbhc->wcd_mbhc.deinit_in_progress = true;
mbhc = &wcd937x->mbhc->wcd_mbhc;
wcd937x_mbhc_ssr_down(wcd937x->mbhc, codec);
wcd937x_reset_low(wcd937x->dev);
break;
case BOLERO_WCD_EVT_SSR_UP:
wcd937x_reset(wcd937x->dev);
/* allow reset to take effect */
usleep_range(10000, 10010);
wcd937x_get_logical_addr(wcd937x->tx_swr_dev);
wcd937x_get_logical_addr(wcd937x->rx_swr_dev);
wcd937x_init_reg(codec);
regcache_mark_dirty(wcd937x->regmap);
regcache_sync(wcd937x->regmap);
/* Enable surge protection */
snd_soc_update_bits(codec,
WCD937X_HPH_SURGE_HPHLR_SURGE_EN,
0xFF, 0xD9);
/* Initialize MBHC module */
mbhc = &wcd937x->mbhc->wcd_mbhc;
ret = wcd937x_mbhc_post_ssr_init(wcd937x->mbhc, codec);
@@ -1542,7 +1537,6 @@ static int wcd937x_event_notify(struct notifier_block *block,
} else {
wcd937x_mbhc_hs_detect(codec, mbhc->mbhc_cfg);
}
wcd937x->mbhc->wcd_mbhc.deinit_in_progress = false;
break;
default:
dev_err(codec->dev, "%s: invalid event %d\n", __func__, event);
@@ -1607,6 +1601,8 @@ static int __wcd937x_codec_enable_micbias_pullup(struct snd_soc_dapm_widget *w,
micb_num = MIC_BIAS_2;
else if (strnstr(w->name, "VA MIC BIAS3", sizeof("VA MIC BIAS3")))
micb_num = MIC_BIAS_3;
else if (strnstr(w->name, "VA MIC BIAS4", sizeof("VA MIC BIAS4")))
micb_num = MIC_BIAS_4;
else
return -EINVAL;
@@ -1635,7 +1631,6 @@ static int wcd937x_codec_enable_micbias_pullup(struct snd_soc_dapm_widget *w,
{
return __wcd937x_codec_enable_micbias_pullup(w, event);
}
static int wcd937x_rx_hph_mode_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -2384,9 +2379,7 @@ static int wcd937x_soc_codec_probe(struct snd_soc_codec *codec)
return -EINVAL;
wcd937x->codec = codec;
snd_soc_codec_init_regmap(codec, wcd937x->regmap);
variant = (snd_soc_read(codec, WCD937X_DIGITAL_EFUSE_REG_0) & 0x1E)
>> 1;
variant = (snd_soc_read(codec, WCD937X_DIGITAL_EFUSE_REG_0) & 0x0E) >> 1;
wcd937x->variant = variant;
wcd937x->fw_data = devm_kzalloc(codec->dev,
@@ -2485,7 +2478,7 @@ static int wcd937x_soc_codec_remove(struct snd_soc_codec *codec)
return -EINVAL;
if (wcd937x->register_notifier)
wcd937x->register_notifier(wcd937x->handle,
return wcd937x->register_notifier(wcd937x->handle,
&wcd937x->nblock,
false);
return 0;

23
techpack/audio/4.0/asoc/codecs/wcd938x/internal.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2022 The Linux Foundation. All rights reserved.
* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#ifndef _WCD938X_INTERNAL_H
@@ -55,7 +55,6 @@ struct wcd938x_priv {
struct device_node *wcd_rst_np;
struct mutex micb_lock;
struct mutex wakeup_lock;
s32 dmic_0_1_clk_cnt;
s32 dmic_2_3_clk_cnt;
s32 dmic_4_5_clk_cnt;
@@ -67,12 +66,10 @@ struct wcd938x_priv {
struct wcd938x_mbhc *mbhc;
u32 hph_mode;
u32 cfilt_val;
u32 tx_mode[TX_ADC_MAX];
bool comp1_enable;
bool comp2_enable;
bool ldoh;
bool bcs_dis;
struct irq_domain *virq;
struct wcd_irq_info irq_info;
u32 rx_clk_cnt;
@@ -103,7 +100,6 @@ struct wcd938x_priv {
int flyback_cur_det_disable;
int ear_rx_path;
bool dev_up;
int micb_enabled[WCD938X_MAX_MICBIAS];
};
struct wcd938x_micbias_setting {
@@ -116,16 +112,6 @@ struct wcd938x_micbias_setting {
u8 bias1_cfilt_sel;
};
#ifdef CONFIG_SND_SOC_IMPED_SENSING
#define MAX_IMPEDANCE_TABLE 8
struct wcd938x_gain_table {
uint32_t min; /* Min impedance */
uint32_t max; /* Max impedance */
int gain; /* additional gain */
};
#endif
struct wcd938x_pdata {
struct device_node *rst_np;
struct device_node *rx_slave;
@@ -134,10 +120,6 @@ struct wcd938x_pdata {
struct cdc_regulator *regulator;
int num_supplies;
#ifdef CONFIG_SND_SOC_IMPED_SENSING
struct wcd938x_gain_table imp_table[MAX_IMPEDANCE_TABLE];
#endif
};
struct wcd_ctrl_platform_data {
@@ -168,9 +150,6 @@ enum {
WCD_BOLERO_EVT_IMPED_FALSE, /* for imped false */
WCD_BOLERO_EVT_RX_COMPANDER_SOFT_RST,
WCD_BOLERO_EVT_BCS_CLK_OFF,
#ifdef CONFIG_SND_SOC_IMPED_SENSING
SEC_WCD_BOLERO_EVT_IMPED_TRUE, /* for SEC imped true */
#endif
};
enum {

40
techpack/audio/4.0/asoc/codecs/wcd938x/wcd938x-mbhc.c
View File

@@ -2,7 +2,6 @@
/*
* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#define DEBUG
#include <linux/module.h>
#include <linux/init.h>
#include <linux/platform_device.h>
@@ -31,7 +30,7 @@
/* Z floating defined in ohms */
#define WCD938X_ZDET_FLOATING_IMPEDANCE 0x0FFFFFFE
#define WCD938X_ZDET_NUM_MEASUREMENTS 250
#define WCD938X_ZDET_NUM_MEASUREMENTS 900
#define WCD938X_MBHC_GET_C1(c) ((c & 0xC000) >> 14)
#define WCD938X_MBHC_GET_X1(x) (x & 0x3FFF)
/* Z value compared in milliOhm */
@@ -138,10 +137,6 @@ static struct wcd_mbhc_register
WCD938X_MBHC_NEW_CTL_1, 0x04, 2, 0),
WCD_MBHC_REGISTER("WCD_MBHC_ELECT_ISRC_EN",
WCD938X_ANA_MBHC_ZDET, 0x02, 1, 0),
WCD_MBHC_REGISTER("WCD_MBHC_EN_SURGE_PROTECTION_HPHL",
WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0x80, 7, 0),
WCD_MBHC_REGISTER("WCD_MBHC_EN_SURGE_PROTECTION_HPHR",
WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0x40, 6, 0),
};
static const struct wcd_mbhc_intr intr_ids = {
@@ -510,10 +505,6 @@ static void wcd938x_wcd_mbhc_calc_impedance(struct wcd_mbhc *mbhc, uint32_t *zl,
{
struct snd_soc_codec *codec = mbhc->codec;
struct wcd938x_priv *wcd938x = dev_get_drvdata(codec->dev);
#ifdef CONFIG_SND_SOC_IMPED_SENSING
struct wcd938x_pdata *pdata = dev_get_platdata(wcd938x->dev);
int i;
#endif
s16 reg0, reg1, reg2, reg3, reg4;
int32_t z1L, z1R, z1Ls;
int zMono, z_diff1, z_diff2;
@@ -556,6 +547,14 @@ static void wcd938x_wcd_mbhc_calc_impedance(struct wcd_mbhc *mbhc, uint32_t *zl,
regmap_update_bits(wcd938x->regmap,
WCD938X_ANA_MBHC_MECH, 0x01, 0x00);
/* Disable surge protection before impedance detection.
* This is done to give correct value for high impedance.
*/
regmap_update_bits(wcd938x->regmap,
WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0xC0, 0x00);
/* 1ms delay needed after disable surge protection */
usleep_range(1000, 1010);
/* First get impedance on Left */
d1 = d1_a[1];
zdet_param_ptr = &zdet_param[1];
@@ -591,24 +590,6 @@ left_ch_impedance:
dev_dbg(codec->dev, "%s: impedance on HPH_L = %d(ohms)\n",
__func__, *zl);
#ifdef CONFIG_SND_SOC_IMPED_SENSING
/* Samsung impedance detection and additional digital gain */
for (i = 0; i < ARRAY_SIZE(pdata->imp_table); i++) {
if (*zl >= pdata->imp_table[i].min &&
*zl <= pdata->imp_table[i].max) {
mbhc->impedance_offset =
pdata->imp_table[i].gain;
dev_info(codec->dev, "%s: zl = %d, imped offset = %d\n",
__func__, *zl, mbhc->impedance_offset);
break;
}
}
if (wcd938x->update_wcd_event)
wcd938x->update_wcd_event(wcd938x->handle,
SEC_WCD_BOLERO_EVT_IMPED_TRUE,
mbhc->impedance_offset);
#endif
/* Start of right impedance ramp and calculation */
wcd938x_mbhc_zdet_ramp(codec, zdet_param_ptr, NULL, &z1R, d1);
if (WCD938X_MBHC_IS_SECOND_RAMP_REQUIRED(z1R)) {
@@ -683,6 +664,9 @@ right_ch_impedance:
mbhc->hph_type = WCD_MBHC_HPH_MONO;
}
/* Enable surge protection again after impedance detection */
regmap_update_bits(wcd938x->regmap,
WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0xC0, 0xC0);
zdet_complete:
snd_soc_write(codec, WCD938X_ANA_MBHC_BTN5, reg0);
snd_soc_write(codec, WCD938X_ANA_MBHC_BTN6, reg1);

506
techpack/audio/4.0/asoc/codecs/wcd938x/wcd938x.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2022 The Linux Foundation. All rights reserved.
* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -40,12 +40,6 @@
#define ADC_MODE_VAL_ULP1 0x09
#define ADC_MODE_VAL_ULP2 0x0B
#define NUM_ATTEMPTS 5
#define DAPM_MICBIAS1_STANDALONE "MIC BIAS1 Standalone"
#define DAPM_MICBIAS2_STANDALONE "MIC BIAS2 Standalone"
#define DAPM_MICBIAS3_STANDALONE "MIC BIAS3 Standalone"
#define DAPM_MICBIAS4_STANDALONE "MIC BIAS4 Standalone"
enum {
CODEC_TX = 0,
CODEC_RX,
@@ -72,16 +66,6 @@ enum {
ADC_MODE_ULP2,
};
static u8 tx_mode_bit[] = {
[ADC_MODE_INVALID] = 0x00,
[ADC_MODE_HIFI] = 0x01,
[ADC_MODE_LO_HIF] = 0x02,
[ADC_MODE_NORMAL] = 0x04,
[ADC_MODE_LP] = 0x08,
[ADC_MODE_ULP1] = 0x10,
[ADC_MODE_ULP2] = 0x20,
};
static const DECLARE_TLV_DB_SCALE(line_gain, 0, 7, 1);
static const DECLARE_TLV_DB_SCALE(analog_gain, 0, 25, 1);
@@ -154,63 +138,31 @@ static int wcd938x_swr_slv_get_current_bank(struct swr_device *dev, u8 devnum)
return ((bank & 0x40) ? 1: 0);
}
static int wcd938x_get_clk_rate(int mode)
static int wcd938x_swr_slv_set_host_clk_div2(struct swr_device *dev,
u8 devnum, int bank)
{
int rate;
u8 val = (bank ? 1 : 0);
switch (mode) {
case ADC_MODE_ULP2:
rate = SWR_CLK_RATE_0P6MHZ;
break;
case ADC_MODE_ULP1:
rate = SWR_CLK_RATE_1P2MHZ;
break;
case ADC_MODE_LP:
rate = SWR_CLK_RATE_4P8MHZ;
break;
case ADC_MODE_NORMAL:
case ADC_MODE_LO_HIF:
case ADC_MODE_HIFI:
case ADC_MODE_INVALID:
default:
rate = SWR_CLK_RATE_9P6MHZ;
break;
}
return rate;
return (swr_write(dev, devnum,
(SWR_SCP_HOST_CLK_DIV2_CTL_BANK + (0x10 * bank)), &val));
}
static int wcd938x_set_swr_clk_rate(struct snd_soc_codec *codec,
int rate, int bank)
int mode, int bank)
{
u8 mask = (bank ? 0xF0 : 0x0F);
u8 val = 0;
switch (rate) {
case SWR_CLK_RATE_0P6MHZ:
if ((mode == ADC_MODE_ULP1) || (mode == ADC_MODE_ULP2))
val = (bank ? 0x60 : 0x06);
break;
case SWR_CLK_RATE_1P2MHZ:
val = (bank ? 0x50 : 0x05);
break;
case SWR_CLK_RATE_2P4MHZ:
val = (bank ? 0x30 : 0x03);
break;
case SWR_CLK_RATE_4P8MHZ:
val = (bank ? 0x10 : 0x01);
break;
case SWR_CLK_RATE_9P6MHZ:
default:
else
val = 0x00;
break;
}
snd_soc_update_bits(codec,
WCD938X_DIGITAL_SWR_TX_CLK_RATE,
snd_soc_update_bits(codec, WCD938X_DIGITAL_SWR_TX_CLK_RATE,
mask, val);
return 0;
}
static int wcd938x_init_reg(struct snd_soc_codec *codec)
{
snd_soc_update_bits(codec, WCD938X_SLEEP_CTL, 0x0E, 0x0E);
@@ -228,7 +180,6 @@ static int wcd938x_init_reg(struct snd_soc_codec *codec)
snd_soc_update_bits(codec, WCD938X_ANA_BIAS, 0x40, 0x40);
/* 10 msec delay as per HW requirement */
usleep_range(10000, 10010);
snd_soc_update_bits(codec, WCD938X_ANA_BIAS, 0x40, 0x00);
snd_soc_update_bits(codec,
WCD938X_HPH_NEW_INT_RDAC_GAIN_CTL,
0xF0, 0x00);
@@ -248,6 +199,7 @@ static int wcd938x_init_reg(struct snd_soc_codec *codec)
snd_soc_update_bits(codec,
WCD938X_TX_COM_NEW_INT_TXFE_ICTRL_STG2MAIN_ULP,
0x1F, 0x08);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_TX_REQ_FB_CTL_0, 0xFF, 0x55);
snd_soc_update_bits(codec,
@@ -268,13 +220,6 @@ static int wcd938x_init_reg(struct snd_soc_codec *codec)
WCD938X_MICB4_TEST_CTL_1, 0xE0, 0xE0);
snd_soc_update_bits(codec,
WCD938X_TX_3_4_TEST_BLK_EN2, 0x01, 0x00);
snd_soc_update_bits(codec, WCD938X_SLEEP_CTL, 0x0E,
((snd_soc_read(codec,
WCD938X_DIGITAL_EFUSE_REG_30) & 0x07) << 1));
snd_soc_update_bits(codec,
WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0xC0, 0xC0);
snd_soc_update_bits(codec,
WCD938X_MICB2_TEST_CTL_3, 0xFF, 0xA4);
return 0;
}
@@ -404,8 +349,7 @@ err_port_map:
}
static int wcd938x_tx_connect_port(struct snd_soc_codec *codec,
u8 slv_port_type, int clk_rate,
u8 enable)
u8 slv_port_type, u8 enable)
{
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
u8 port_id, num_ch, ch_mask, port_type;
@@ -416,8 +360,6 @@ static int wcd938x_tx_connect_port(struct snd_soc_codec *codec,
ret = wcd938x_set_port_params(codec, slv_port_type, &port_id,
&num_ch, &ch_mask, &ch_rate,
&port_type, CODEC_TX);
if (clk_rate)
ch_rate = clk_rate;
if (ret)
return ret;
@@ -681,15 +623,6 @@ static int wcd938x_codec_ear_dac_event(struct snd_soc_dapm_widget *w,
if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_AUX_GAIN_CTL, 0x01, 0x00);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_DIG_CLK_CTL, 0x04, 0x00);
} else {
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_HPH_GAIN_CTL, 0x04, 0x00);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_DIG_CLK_CTL, 0x01, 0x00);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_COMP_CTL_0, 0x02, 0x00);
}
snd_soc_update_bits(codec,
WCD938X_ANA_EAR_COMPANDER_CTL, 0x80, 0x00);
@@ -769,11 +702,6 @@ static int wcd938x_codec_enable_hphr_pa(struct snd_soc_dapm_widget *w,
WCD_CLSH_EVENT_PRE_DAC,
WCD_CLSH_STATE_HPHR,
hph_mode);
if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
hph_mode == CLS_H_ULP) {
snd_soc_update_bits(codec,
WCD938X_HPH_REFBUFF_LP_CTL, 0x01, 0x01);
}
wcd_clsh_set_hph_mode(codec, CLS_H_HIFI);
snd_soc_update_bits(codec, WCD938X_ANA_HPH,
0x10, 0x10);
@@ -795,12 +723,6 @@ static int wcd938x_codec_enable_hphr_pa(struct snd_soc_dapm_widget *w,
usleep_range(20000, 20100);
else
usleep_range(7000, 7100);
if (hph_mode == CLS_H_LP ||
hph_mode == CLS_H_LOHIFI ||
hph_mode == CLS_H_ULP)
snd_soc_update_bits(codec,
WCD938X_HPH_REFBUFF_LP_CTL, 0x01,
0x00);
clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
}
snd_soc_update_bits(codec,
@@ -906,11 +828,6 @@ static int wcd938x_codec_enable_hphl_pa(struct snd_soc_dapm_widget *w,
WCD_CLSH_STATE_HPHL,
hph_mode);
wcd_clsh_set_hph_mode(codec, CLS_H_HIFI);
if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
hph_mode == CLS_H_ULP) {
snd_soc_update_bits(codec,
WCD938X_HPH_REFBUFF_LP_CTL, 0x01, 0x01);
}
snd_soc_update_bits(codec, WCD938X_ANA_HPH,
0x20, 0x20);
wcd_clsh_set_hph_mode(codec, hph_mode);
@@ -931,12 +848,6 @@ static int wcd938x_codec_enable_hphl_pa(struct snd_soc_dapm_widget *w,
usleep_range(20000, 20100);
else
usleep_range(7000, 7100);
if (hph_mode == CLS_H_LP ||
hph_mode == CLS_H_LOHIFI ||
hph_mode == CLS_H_ULP)
snd_soc_update_bits(codec,
WCD938X_HPH_REFBUFF_LP_CTL,
0x01, 0x00);
clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
}
snd_soc_update_bits(codec,
@@ -1377,12 +1288,10 @@ static int wcd938x_codec_enable_dmic(struct snd_soc_dapm_widget *w,
/* enable clock scaling */
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_DMIC_CTL, 0x06, 0x06);
wcd938x_tx_connect_port(codec, DMIC0 + (w->shift),
SWR_CLK_RATE_2P4MHZ, true);
wcd938x_tx_connect_port(codec, DMIC0 + (w->shift), true);
break;
case SND_SOC_DAPM_POST_PMD:
wcd938x_tx_connect_port(codec, DMIC0 + (w->shift), 0,
false);
wcd938x_tx_connect_port(codec, DMIC0 + (w->shift), false);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_AMIC_CTL,
(0x01 << dmic_ctl_shift),
@@ -1503,54 +1412,32 @@ static int wcd938x_tx_swr_ctrl(struct snd_soc_dapm_widget *w,
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
int ret = 0;
int bank = 0;
u8 mode = 0;
int i = 0;
int rate = 0;
bank = (wcd938x_swr_slv_get_current_bank(wcd938x->tx_swr_dev,
wcd938x->tx_swr_dev->dev_num) ? 0 : 1);
int mode = 0;
bank = wcd938x_swr_slv_get_current_bank(wcd938x->tx_swr_dev,
wcd938x->tx_swr_dev->dev_num);
wcd938x_swr_slv_set_host_clk_div2(wcd938x->tx_swr_dev,
wcd938x->tx_swr_dev->dev_num, bank);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
if (strnstr(w->name, "ADC", sizeof("ADC"))) {
if (test_bit(WCD_ADC1, &wcd938x->status_mask))
mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC1]];
if (test_bit(WCD_ADC2, &wcd938x->status_mask))
mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC2]];
if (test_bit(WCD_ADC3, &wcd938x->status_mask))
mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC3]];
if (test_bit(WCD_ADC4, &wcd938x->status_mask))
mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC4]];
if (mode != 0) {
for (i = 0; i < ADC_MODE_ULP2; i++) {
if (mode & (1 << i)) {
i++;
break;
}
}
}
rate = wcd938x_get_clk_rate(i);
wcd938x_set_swr_clk_rate(codec, mode, bank);
}
ret = swr_slvdev_datapath_control(wcd938x->tx_swr_dev,
wcd938x->tx_swr_dev->dev_num,
true);
if (strnstr(w->name, "ADC", sizeof("ADC"))) {
/* Copy clk settings to active bank */
wcd938x_set_swr_clk_rate(codec, rate, !bank);
}
if (test_bit(WCD_ADC1, &wcd938x->status_mask))
mode |= wcd938x->tx_mode[WCD_ADC1];
if (test_bit(WCD_ADC2, &wcd938x->status_mask))
mode |= wcd938x->tx_mode[WCD_ADC2];
if (test_bit(WCD_ADC3, &wcd938x->status_mask))
mode |= wcd938x->tx_mode[WCD_ADC3];
if (test_bit(WCD_ADC4, &wcd938x->status_mask))
mode |= wcd938x->tx_mode[WCD_ADC4];
wcd938x_set_swr_clk_rate(codec, mode, bank);
break;
case SND_SOC_DAPM_POST_PMD:
if (strnstr(w->name, "ADC", sizeof("ADC"))) {
rate = wcd938x_get_clk_rate(ADC_MODE_INVALID);
wcd938x_set_swr_clk_rate(codec, rate, !bank);
}
ret = swr_slvdev_datapath_control(wcd938x->tx_swr_dev,
wcd938x->tx_swr_dev->dev_num,
false);
if (strnstr(w->name, "ADC", sizeof("ADC")))
wcd938x_set_swr_clk_rate(codec, rate, bank);
wcd938x_set_swr_clk_rate(codec, ADC_MODE_INVALID, bank);
break;
};
@@ -1597,7 +1484,6 @@ static int wcd938x_codec_enable_adc(struct snd_soc_dapm_widget *w,
struct snd_soc_codec *codec =
snd_soc_dapm_to_codec(w->dapm);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
int clk_rate = 0;
dev_dbg(codec->dev, "%s wname: %s event: %d\n", __func__,
w->name, event);
@@ -1608,26 +1494,21 @@ static int wcd938x_codec_enable_adc(struct snd_soc_dapm_widget *w,
WCD938X_DIGITAL_CDC_ANA_CLK_CTL, 0x08, 0x08);
snd_soc_update_bits(codec,
WCD938X_DIGITAL_CDC_ANA_CLK_CTL, 0x10, 0x10);
set_bit(w->shift, &wcd938x->status_mask);
clk_rate = wcd938x_get_clk_rate(wcd938x->tx_mode[w->shift]);
/* Enable BCS for Headset mic */
/* Enable BCS for Headset mic */
if (w->shift == 1 && !(snd_soc_read(codec,
WCD938X_TX_NEW_AMIC_MUX_CFG) & 0x80)) {
if (!wcd938x->bcs_dis)
wcd938x_tx_connect_port(codec, MBHC,
SWR_CLK_RATE_4P8MHZ, true);
wcd938x_tx_connect_port(codec, MBHC, true);
set_bit(AMIC2_BCS_ENABLE, &wcd938x->status_mask);
}
wcd938x_tx_connect_port(codec, ADC1 + (w->shift), clk_rate,
true);
wcd938x_tx_connect_port(codec, ADC1 + (w->shift), true);
break;
case SND_SOC_DAPM_POST_PMD:
wcd938x_tx_connect_port(codec, ADC1 + (w->shift), 0, false);
wcd938x_tx_connect_port(codec, ADC1 + (w->shift), false);
if (w->shift == 1 &&
test_bit(AMIC2_BCS_ENABLE, &wcd938x->status_mask)) {
if (!wcd938x->bcs_dis)
wcd938x_tx_connect_port(codec, MBHC, 0,
false);
wcd938x_tx_connect_port(codec, MBHC, false);
clear_bit(AMIC2_BCS_ENABLE, &wcd938x->status_mask);
}
snd_soc_update_bits(codec,
@@ -1929,7 +1810,7 @@ int wcd938x_micbias_control(struct snd_soc_codec *codec,
pre_off_event,
&wcd938x->mbhc->wcd_mbhc);
snd_soc_update_bits(codec, micb_reg,
0xC0, 0xC0);
0xC0, 0x00);
if (post_off_event && wcd938x->mbhc)
blocking_notifier_call_chain(
&wcd938x->mbhc->notifier,
@@ -1958,18 +1839,15 @@ static int wcd938x_get_logical_addr(struct swr_device *swr_dev)
{
int ret = 0;
uint8_t devnum = 0;
int num_retry = NUM_ATTEMPTS;
do {
ret = swr_get_logical_dev_num(swr_dev, swr_dev->addr, &devnum);
if (ret) {
dev_err(&swr_dev->dev,
"%s get devnum %d for dev addr %lx failed\n",
__func__, devnum, swr_dev->addr);
/* retry after 1ms */
usleep_range(1000, 1010);
}
} while (ret && --num_retry);
ret = swr_get_logical_dev_num(swr_dev, swr_dev->addr, &devnum);
if (ret) {
dev_err(&swr_dev->dev,
"%s get devnum %d for dev addr %lx failed\n",
__func__, devnum, swr_dev->addr);
swr_remove_device(swr_dev);
return ret;
}
swr_dev->dev_num = devnum;
return 0;
}
@@ -2017,19 +1895,14 @@ static int wcd938x_event_notify(struct notifier_block *block,
break;
case BOLERO_WCD_EVT_SSR_DOWN:
wcd938x->dev_up = false;
wcd938x->mbhc->wcd_mbhc.deinit_in_progress = true;
mbhc = &wcd938x->mbhc->wcd_mbhc;
wcd938x_mbhc_ssr_down(wcd938x->mbhc, codec);
wcd938x_reset_low(wcd938x->dev);
break;
case BOLERO_WCD_EVT_SSR_UP:
wcd938x_reset(wcd938x->dev);
/* allow reset to take effect */
usleep_range(10000, 10010);
wcd938x_get_logical_addr(wcd938x->tx_swr_dev);
wcd938x_get_logical_addr(wcd938x->rx_swr_dev);
wcd938x_init_reg(codec);
regcache_mark_dirty(wcd938x->regmap);
regcache_sync(wcd938x->regmap);
@@ -2042,7 +1915,6 @@ static int wcd938x_event_notify(struct notifier_block *block,
} else {
wcd938x_mbhc_hs_detect(codec, mbhc->mbhc_cfg);
}
wcd938x->mbhc->wcd_mbhc.deinit_in_progress = false;
wcd938x->dev_up = true;
break;
case BOLERO_WCD_EVT_CLK_NOTIFY:
@@ -2149,54 +2021,6 @@ static int wcd938x_codec_enable_micbias_pullup(struct snd_soc_dapm_widget *w,
return __wcd938x_codec_enable_micbias_pullup(w, event);
}
static int wcd938x_wakeup(void *handle, bool enable)
{
struct wcd938x_priv *priv;
int ret = 0;
if (!handle) {
pr_err("%s: NULL handle\n", __func__);
return -EINVAL;
}
priv = (struct wcd938x_priv *)handle;
if (!priv->tx_swr_dev) {
pr_err("%s: tx swr dev is NULL\n", __func__);
return -EINVAL;
}
mutex_lock(&priv->wakeup_lock);
if (enable)
ret = swr_device_wakeup_vote(priv->tx_swr_dev);
else
ret = swr_device_wakeup_unvote(priv->tx_swr_dev);
mutex_unlock(&priv->wakeup_lock);
return ret;
}
static int wcd938x_codec_force_enable_micbias(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol,
int event)
{
int ret = 0;
struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
wcd938x_wakeup(wcd938x, true);
ret = __wcd938x_codec_enable_micbias(w, SND_SOC_DAPM_PRE_PMU);
wcd938x_wakeup(wcd938x, false);
break;
case SND_SOC_DAPM_POST_PMD:
wcd938x_wakeup(wcd938x, true);
ret = __wcd938x_codec_enable_micbias(w, SND_SOC_DAPM_POST_PMD);
wcd938x_wakeup(wcd938x, false);
break;
}
return ret;
}
static inline int wcd938x_tx_path_get(const char *wname,
unsigned int *path_num)
{
@@ -2295,34 +2119,6 @@ static int wcd938x_tx_mode_put(struct snd_kcontrol *kcontrol,
return 0;
}
static int wcd938x_micb2_cfilt_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *component = snd_soc_kcontrol_codec(kcontrol);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(component);
ucontrol->value.integer.value[0] = wcd938x->cfilt_val;
return 0;
}
static int wcd938x_micb2_cfilt_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *component = snd_soc_kcontrol_codec(kcontrol);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(component);
u32 cfilt_val;
cfilt_val = ucontrol->value.enumerated.item[0];
if (cfilt_val)
snd_soc_update_bits(component, WCD938X_MICB2_TEST_CTL_3, 0xFF, 0x24);
else
snd_soc_update_bits(component, WCD938X_MICB2_TEST_CTL_3, 0xFF, 0xA4);
wcd938x->cfilt_val = cfilt_val;
return 0;
}
static int wcd938x_rx_hph_mode_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -2518,123 +2314,6 @@ static int wcd938x_ldoh_put(struct snd_kcontrol *kcontrol,
return 0;
}
static int wcd938x_bcs_get(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
ucontrol->value.integer.value[0] = wcd938x->bcs_dis;
return 0;
}
static int wcd938x_bcs_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec =
snd_soc_kcontrol_codec(kcontrol);
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
wcd938x->bcs_dis = ucontrol->value.integer.value[0];
return 0;
}
/*
* wcd938x_codec_enable_standalone_micbias - enable micbias standalone
* @codec: pointer to codec instance
* @micb_num: number of micbias to be enabled
* @enable: true to enable micbias or false to disable
*
* This function is used to enable micbias (1, 2, 3 or 4) during
* standalone independent of whether TX use-case is running or not
*
* Return: error code in case of failure or 0 for success
*/
int wcd938x_codec_enable_standalone_micbias(struct snd_soc_codec *codec,
int micb_num,
bool enable)
{
const char * const micb_names[] = {
DAPM_MICBIAS1_STANDALONE, DAPM_MICBIAS2_STANDALONE,
DAPM_MICBIAS3_STANDALONE, DAPM_MICBIAS4_STANDALONE
};
int micb_index = micb_num - 1;
int rc;
if (!codec) {
pr_err("%s: Codec memory is NULL\n", __func__);
return -EINVAL;
}
if ((micb_index < 0) || (micb_index > WCD938X_MAX_MICBIAS - 1)) {
dev_err(codec->dev, "%s: Invalid micbias index, micb_ind:%d\n",
__func__, micb_index);
return -EINVAL;
}
if (enable)
rc = snd_soc_dapm_force_enable_pin_unlocked(
snd_soc_codec_get_dapm(codec),
micb_names[micb_index]);
else
rc = snd_soc_dapm_disable_pin_unlocked(
snd_soc_codec_get_dapm(codec),
micb_names[micb_index]);
if (!rc)
snd_soc_dapm_sync(snd_soc_codec_get_dapm(codec));
else
dev_err(codec->dev, "%s: micbias%d force %s pin failed\n",
__func__, micb_num, (enable ? "enable" : "disable"));
return rc;
}
EXPORT_SYMBOL(wcd938x_codec_enable_standalone_micbias);
static int wcd938x_codec_get_micb(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
int micb_num = ((struct soc_multi_mixer_control *)
kcontrol->private_value)->shift;
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
ucontrol->value.integer.value[0] = wcd938x->micb_enabled[micb_num - 1];
return 0;
}
static int wcd938x_codec_set_micb(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct snd_soc_codec *codec = snd_soc_kcontrol_codec(kcontrol);
int micb_num = ((struct soc_multi_mixer_control *)
kcontrol->private_value)->shift;
int value = ucontrol->value.integer.value[0];
bool enable;
int ret;
struct wcd938x_priv *wcd938x = snd_soc_codec_get_drvdata(codec);
if ((micb_num != MIC_BIAS_1) && (micb_num != MIC_BIAS_2) &&
(micb_num != MIC_BIAS_3) && (micb_num != MIC_BIAS_4))
return -EINVAL;
enable = !!value;
ret = wcd938x_codec_enable_standalone_micbias(codec, micb_num,
enable);
if (ret) {
dev_err(codec->dev, "%s: Failed to enable standalone micb:%d\n",
__func__, micb_num);
return ret;
}
wcd938x->micb_enabled[micb_num - 1] = enable;
return ret;
}
static const char * const tx_mode_mux_text_wcd9380[] = {
"ADC_INVALID", "ADC_HIFI", "ADC_LO_HIF", "ADC_NORMAL", "ADC_LP",
};
@@ -2658,10 +2337,6 @@ static const char * const rx_hph_mode_mux_text_wcd9380[] = {
"CLS_AB_LOHIFI",
};
static const char * const micb2_cfilt_en_mux_text_wcd9380[] = {
"Enable", "Disable",
};
static const char * const wcd938x_ear_pa_gain_text[] = {
"G_6_DB", "G_4P5_DB", "G_3_DB", "G_1P5_DB", "G_0_DB",
"G_M1P5_DB", "G_M3_DB", "G_M4P5_DB",
@@ -2670,10 +2345,6 @@ static const char * const wcd938x_ear_pa_gain_text[] = {
"G_M15_DB", "G_M16P5_DB", "G_M18_DB",
};
static const struct soc_enum micb2_cfilt_en_mux_enum_wcd9380 =
SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(micb2_cfilt_en_mux_text_wcd9380),
micb2_cfilt_en_mux_text_wcd9380);
static const struct soc_enum rx_hph_mode_mux_enum_wcd9380 =
SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(rx_hph_mode_mux_text_wcd9380),
rx_hph_mode_mux_text_wcd9380);
@@ -2697,9 +2368,6 @@ static const struct snd_kcontrol_new wcd9380_snd_controls[] = {
SOC_ENUM_EXT("RX HPH Mode", rx_hph_mode_mux_enum_wcd9380,
wcd938x_rx_hph_mode_get, wcd938x_rx_hph_mode_put),
SOC_ENUM_EXT("MICB2 CFILT EN", micb2_cfilt_en_mux_enum_wcd9380,
wcd938x_micb2_cfilt_get, wcd938x_micb2_cfilt_put),
SOC_ENUM_EXT("TX0 MODE", tx_mode_mux_enum_wcd9380,
wcd938x_tx_mode_get, wcd938x_tx_mode_put),
SOC_ENUM_EXT("TX1 MODE", tx_mode_mux_enum_wcd9380,
@@ -2729,12 +2397,10 @@ static const struct snd_kcontrol_new wcd938x_snd_controls[] = {
wcd938x_get_compander, wcd938x_set_compander),
SOC_SINGLE_EXT("HPHR_COMP Switch", SND_SOC_NOPM, 1, 1, 0,
wcd938x_get_compander, wcd938x_set_compander),
SOC_SINGLE_EXT("LDOH Enable", SND_SOC_NOPM, 0, 1, 0,
wcd938x_ldoh_get, wcd938x_ldoh_put),
SOC_SINGLE_EXT("ADC2_BCS Disable", SND_SOC_NOPM, 0, 1, 0,
wcd938x_bcs_get, wcd938x_bcs_put),
SOC_SINGLE_TLV("HPHL Volume", WCD938X_HPH_L_EN, 0, 20, 1, line_gain),
SOC_SINGLE_TLV("HPHR Volume", WCD938X_HPH_R_EN, 0, 20, 1, line_gain),
SOC_SINGLE_TLV("ADC1 Volume", WCD938X_ANA_TX_CH1, 0, 20, 0,
@@ -2745,14 +2411,6 @@ static const struct snd_kcontrol_new wcd938x_snd_controls[] = {
analog_gain),
SOC_SINGLE_TLV("ADC4 Volume", WCD938X_ANA_TX_CH4, 0, 20, 0,
analog_gain),
SOC_SINGLE_EXT("MIC BIAS1 Standalone", SND_SOC_NOPM, MIC_BIAS_1, 1, 0,
wcd938x_codec_get_micb, wcd938x_codec_set_micb),
SOC_SINGLE_EXT("MIC BIAS2 Standalone", SND_SOC_NOPM, MIC_BIAS_2, 1, 0,
wcd938x_codec_get_micb, wcd938x_codec_set_micb),
SOC_SINGLE_EXT("MIC BIAS3 Standalone", SND_SOC_NOPM, MIC_BIAS_3, 1, 0,
wcd938x_codec_get_micb, wcd938x_codec_set_micb),
SOC_SINGLE_EXT("MIC BIAS4 Standalone", SND_SOC_NOPM, MIC_BIAS_4, 1, 0,
wcd938x_codec_get_micb, wcd938x_codec_set_micb),
};
static const struct snd_kcontrol_new adc1_switch[] = {
@@ -3025,19 +2683,6 @@ static const struct snd_soc_dapm_widget wcd938x_dapm_widgets[] = {
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU |
SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY(DAPM_MICBIAS1_STANDALONE, SND_SOC_NOPM, 0, 0,
wcd938x_codec_force_enable_micbias,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY(DAPM_MICBIAS2_STANDALONE, SND_SOC_NOPM, 0, 0,
wcd938x_codec_force_enable_micbias,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY(DAPM_MICBIAS3_STANDALONE, SND_SOC_NOPM, 0, 0,
wcd938x_codec_force_enable_micbias,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY(DAPM_MICBIAS4_STANDALONE, SND_SOC_NOPM, 0, 0,
wcd938x_codec_force_enable_micbias,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
SND_SOC_DAPM_SUPPLY("VDD_BUCK", SND_SOC_NOPM, 0, 0,
wcd938x_codec_enable_vdd_buck,
SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
@@ -3563,7 +3208,7 @@ static int wcd938x_soc_codec_remove(struct snd_soc_codec *codec)
return -EINVAL;
}
if (wcd938x->register_notifier)
wcd938x->register_notifier(wcd938x->handle,
return wcd938x->register_notifier(wcd938x->handle,
&wcd938x->nblock,
false);
return 0;
@@ -3731,21 +3376,6 @@ static int wcd938x_reset_low(struct device *dev)
struct wcd938x_pdata *wcd938x_populate_dt_data(struct device *dev)
{
struct wcd938x_pdata *pdata = NULL;
#ifdef CONFIG_SND_SOC_IMPED_SENSING
int rc = 0;
int i;
struct of_phandle_args imp_list;
struct wcd938x_gain_table default_table[MAX_IMPEDANCE_TABLE] = {
{ 0, 0, 6},
{ 1, 13, 0},
{ 14, 25, 3},
{ 26, 42, 4},
{ 43, 100, 5},
{ 101, 200, 7},
{ 201, 1000, 8},
{ 1001, INT_MAX, 6},
};
#endif
pdata = devm_kzalloc(dev, sizeof(struct wcd938x_pdata),
GFP_KERNEL);
@@ -3776,26 +3406,6 @@ struct wcd938x_pdata *wcd938x_populate_dt_data(struct device *dev)
wcd938x_dt_parse_micbias_info(dev, &pdata->micbias);
#ifdef CONFIG_SND_SOC_IMPED_SENSING
for (i = 0; i < ARRAY_SIZE(pdata->imp_table); i++) {
rc = of_parse_phandle_with_args(dev->of_node,
"imp-table", "#list-imp-cells", i, &imp_list);
if (rc < 0) {
pdata->imp_table[i].min = default_table[i].min;
pdata->imp_table[i].max = default_table[i].max;
pdata->imp_table[i].gain = default_table[i].gain;
} else {
pdata->imp_table[i].min = imp_list.args[0];
pdata->imp_table[i].max = imp_list.args[1];
pdata->imp_table[i].gain = imp_list.args[2];
}
dev_info(dev, "impedance gain table %d, %d, %d\n",
pdata->imp_table[i].min,
pdata->imp_table[i].max,
pdata->imp_table[i].gain);
}
#endif
return pdata;
}
@@ -3966,6 +3576,25 @@ static int wcd938x_add_slave_codecs(struct device *dev,
return 0;
}
static int wcd938x_wakeup(void *handle, bool enable)
{
struct wcd938x_priv *priv;
if (!handle) {
pr_err("%s: NULL handle\n", __func__);
return -EINVAL;
}
priv = (struct wcd938x_priv *)handle;
if (!priv->tx_swr_dev) {
pr_err("%s: tx swr dev is NULL\n", __func__);
return -EINVAL;
}
if (enable)
return swr_device_wakeup_vote(priv->tx_swr_dev);
else
return swr_device_wakeup_unvote(priv->tx_swr_dev);
}
static int wcd938x_probe(struct platform_device *pdev)
{
struct component_match *match = NULL;
@@ -4043,7 +3672,6 @@ static int wcd938x_probe(struct platform_device *pdev)
goto err;
}
mutex_init(&wcd938x->wakeup_lock);
mutex_init(&wcd938x->micb_lock);
ret = wcd938x_add_slave_codecs(dev, &match);
if (ret)
@@ -4058,7 +3686,6 @@ static int wcd938x_probe(struct platform_device *pdev)
err_lock_init:
mutex_destroy(&wcd938x->micb_lock);
mutex_destroy(&wcd938x->wakeup_lock);
err:
return ret;
}
@@ -4070,7 +3697,6 @@ static int wcd938x_remove(struct platform_device *pdev)
wcd938x = platform_get_drvdata(pdev);
component_master_del(&pdev->dev, &wcd938x_comp_ops);
mutex_destroy(&wcd938x->micb_lock);
mutex_destroy(&wcd938x->wakeup_lock);
dev_set_drvdata(&pdev->dev, NULL);
return 0;

2
techpack/audio/4.0/asoc/codecs/wsa881x.c
View File

@@ -1197,7 +1197,6 @@ static int wsa881x_probe(struct snd_soc_codec *codec)
if (!wsa881x)
return -EINVAL;
snd_soc_codec_init_regmap(codec, wsa881x->regmap);
dev = wsa881x->swr_slave;
wsa881x->codec = codec;
@@ -1333,7 +1332,6 @@ static int wsa881x_event_notify(struct notifier_block *nb,
snd_soc_update_bits(wsa881x->codec,
WSA881X_SPKR_DRV_EN,
0x80, 0x80);
break;
default:
break;
}

2
techpack/audio/4.0/asoc/codecs/wsa881x.h
View File

@@ -27,7 +27,7 @@ void wsa881x_regmap_defaults(struct regmap *regmap, u8 version);
#else
extern int wsa881x_set_channel_map(struct snd_soc_codec *codec, u8 *port,
u8 num_port, unsigned int *ch_mask,
unsigned int *ch_rate, u8 *port_type)
unsigned int *ch_rate, u8 *port_type);
{
return 0;
}

16
techpack/audio/4.0/asoc/kona-port-config.h
View File

@@ -50,15 +50,6 @@ static struct port_params tx_frame_params_default[SWR_MSTR_PORT_LEN] = {
{3, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1}, /* TX4 */
};
/* TX UC1: TX1: 1ch, TX2: 2chs, TX3: 1ch(MBHC) */
static struct port_params tx_frame_params_v2[SWR_MSTR_PORT_LEN] = {
{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},/* PCM OUT */
{1, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 1}, /* TX1 */
{1, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 2}, /* TX2 */
{3, 2, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0}, /* TX3 */
{3, 0, 0, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 2}, /* TX4 */
};
static struct swr_mstr_port_map sm_port_map[] = {
{TX_MACRO, SWR_UC0, tx_frame_params_default},
{RX_MACRO, SWR_UC0, rx_frame_params_default},
@@ -66,11 +57,4 @@ static struct swr_mstr_port_map sm_port_map[] = {
{WSA_MACRO, SWR_UC0, wsa_frame_params_default},
};
static struct swr_mstr_port_map sm_port_map_v2[] = {
{TX_MACRO, SWR_UC0, tx_frame_params_v2},
{RX_MACRO, SWR_UC0, rx_frame_params_default},
{RX_MACRO, SWR_UC1, rx_frame_params_dsd},
{WSA_MACRO, SWR_UC0, wsa_frame_params_default},
};
#endif /* _KONA_PORT_CONFIG */

641
techpack/audio/4.0/asoc/kona.c
View File

File diff suppressed because it is too large Load Diff

70
techpack/audio/4.0/asoc/msm-compress-q6-v2.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
@@ -395,8 +395,8 @@ static int msm_compr_set_volume(struct snd_compr_stream *cstream,
gain_list[0] = volume_l;
gain_list[1] = volume_r;
gain_list[2] = volume_l;
if (use_default)
num_channels = 3;
num_channels = 3;
use_default = true;
rc = q6asm_set_multich_gain(prtd->audio_client, num_channels,
gain_list, chmap, use_default);
}
@@ -812,23 +812,15 @@ static void compr_event_handler(uint32_t opcode,
* RESUME
*/
if ((prtd->copied_total == prtd->bytes_sent) &&
atomic_read(&prtd->drain)) {
bytes_available = prtd->bytes_received - prtd->copied_total;
if (bytes_available < cstream->runtime->fragment_size) {
pr_debug("%s: RUN ack, wake up & continue pending drain\n",
__func__);
atomic_read(&prtd->drain)) {
pr_debug("RUN ack, wake up & continue pending drain\n");
if (prtd->last_buffer)
prtd->last_buffer = 0;
if (prtd->last_buffer)
prtd->last_buffer = 0;
prtd->drain_ready = 1;
wake_up(&prtd->drain_wait);
atomic_set(&prtd->drain, 0);
} else if (atomic_read(&prtd->xrun)) {
pr_debug("%s: RUN ack, continue write cycle\n", __func__);
atomic_set(&prtd->xrun, 0);
msm_compr_send_buffer(prtd);
}
prtd->drain_ready = 1;
wake_up(&prtd->drain_wait);
atomic_set(&prtd->drain, 0);
}
spin_unlock_irqrestore(&prtd->lock, flags);
@@ -1491,7 +1483,6 @@ static int msm_compr_configure_dsp_for_capture(struct snd_compr_stream *cstream)
struct audio_client *ac = prtd->audio_client;
uint32_t stream_index;
uint32_t enc_cfg_id = ENC_CFG_ID_NONE;
bool compress_ts = false;
switch (prtd->codec_param.codec.format) {
case SNDRV_PCM_FORMAT_S24_LE:
@@ -1541,19 +1532,22 @@ static int msm_compr_configure_dsp_for_capture(struct snd_compr_stream *cstream)
return ret;
}
} else {
if (prtd->codec_param.codec.flags & COMPRESSED_TIMESTAMP_FLAG)
compress_ts = true;
if (q6core_get_avcs_api_version_per_service(
APRV2_IDS_SERVICE_ID_ADSP_ASM_V) >=
ADSP_ASM_API_VERSION_V2)
ret = q6asm_open_read_v5(prtd->audio_client,
prtd->codec, bits_per_sample,
compress_ts, enc_cfg_id);
else
if (prtd->codec_param.codec.flags & COMPRESSED_TIMESTAMP_FLAG) {
ret = q6asm_open_read_v4(prtd->audio_client,
prtd->codec, bits_per_sample,
compress_ts, enc_cfg_id);
prtd->codec,
bits_per_sample, true, enc_cfg_id);
} else {
if (q6core_get_avcs_api_version_per_service(
APRV2_IDS_SERVICE_ID_ADSP_ASM_V) >=
ADSP_ASM_API_VERSION_V2)
ret = q6asm_open_read_v5(prtd->audio_client,
prtd->codec, bits_per_sample,
false, enc_cfg_id);
else
ret = q6asm_open_read_v4(prtd->audio_client,
prtd->codec, bits_per_sample,
false, enc_cfg_id);
}
if (ret < 0) {
pr_err("%s: q6asm_open_read failed:%d\n",
__func__, ret);
@@ -1761,10 +1755,6 @@ static int msm_compr_capture_open(struct snd_compr_stream *cstream)
enum apr_subsys_state subsys_state;
pr_debug("%s\n", __func__);
if (!pdata) {
pr_err("%s: pdata is NULL\n", __func__);
return -EINVAL;
}
subsys_state = apr_get_subsys_state();
if (subsys_state == APR_SUBSYS_DOWN) {
@@ -1772,7 +1762,7 @@ static int msm_compr_capture_open(struct snd_compr_stream *cstream)
return -ENETRESET;
}
prtd = kzalloc(sizeof(struct msm_compr_audio), GFP_KERNEL);
if (!prtd) {
if (prtd == NULL) {
pr_err("Failed to allocate memory for msm_compr_audio\n");
return -ENOMEM;
}
@@ -2311,7 +2301,7 @@ static int msm_compr_trigger(struct snd_compr_stream *cstream, int cmd)
struct snd_soc_pcm_runtime *rtd = cstream->private_data;
struct msm_compr_pdata *pdata =
snd_soc_platform_get_drvdata(rtd->platform);
uint32_t *volume = NULL;
uint32_t *volume = pdata->volume[rtd->dai_link->id];
struct audio_client *ac = prtd->audio_client;
unsigned long fe_id = rtd->dai_link->id;
int rc = 0;
@@ -2321,12 +2311,6 @@ static int msm_compr_trigger(struct snd_compr_stream *cstream, int cmd)
uint32_t stream_index;
uint16_t bits_per_sample = 16;
if (!pdata) {
pr_err("%s: pdata is NULL\n", __func__);
return -EINVAL;
}
volume = pdata->volume[rtd->dai_link->id];
spin_lock_irqsave(&prtd->lock, flags);
if (atomic_read(&prtd->error)) {
pr_err("%s Got RESET EVENTS notification, return immediately",

35
techpack/audio/4.0/asoc/msm-dai-fe.c
View File

@@ -2401,9 +2401,7 @@ static struct snd_soc_dai_driver msm_fe_dais[] = {
.rate_max = 384000,
},
.ops = &msm_fe_Multimedia_dai_ops,
#ifndef CONFIG_SEC_SND_PRIMARY
.compress_new = snd_soc_new_compress,
#endif /* CONFIG_SEC_SND_PRIMARY */
.name = "MultiMedia11",
.probe = fe_dai_probe,
},
@@ -2726,39 +2724,6 @@ static struct snd_soc_dai_driver msm_fe_dais[] = {
.name = "MultiMedia22",
.probe = fe_dai_probe,
},
{
.playback = {
.stream_name = "MultiMedia23 Playback",
.aif_name = "MM_DL23",
.rates = (SNDRV_PCM_RATE_8000_384000 |
SNDRV_PCM_RATE_KNOT),
.formats = (SNDRV_PCM_FMTBIT_S16_LE |
SNDRV_PCM_FMTBIT_S24_LE |
SNDRV_PCM_FMTBIT_S24_3LE |
SNDRV_PCM_FMTBIT_S32_LE),
.channels_min = 1,
.channels_max = 32,
.rate_min = 8000,
.rate_max = 384000,
},
.capture = {
.stream_name = "MultiMedia23 Capture",
.aif_name = "MM_UL23",
.rates = (SNDRV_PCM_RATE_8000_48000|
SNDRV_PCM_RATE_KNOT),
.formats = (SNDRV_PCM_FMTBIT_S16_LE |
SNDRV_PCM_FMTBIT_S24_LE |
SNDRV_PCM_FMTBIT_S24_3LE |
SNDRV_PCM_FMTBIT_S32_LE),
.channels_min = 1,
.channels_max = 32,
.rate_min = 8000,
.rate_max = 48000,
},
.ops = &msm_fe_Multimedia_dai_ops,
.name = "MultiMedia23",
.probe = fe_dai_probe,
},
{
.playback = {
.stream_name = "MultiMedia26 Playback",

149
techpack/audio/4.0/asoc/msm-dai-q6-v2.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/init.h>
@@ -52,8 +52,6 @@ enum {
DEC_FMT_NONE = ENC_FMT_NONE,
ENC_FMT_SBC = ASM_MEDIA_FMT_SBC,
DEC_FMT_SBC = ASM_MEDIA_FMT_SBC,
ENC_FMT_SBC_SS = ASM_MEDIA_FMT_SBC_SS,
ENC_FMT_SSC = ASM_MEDIA_FMT_SSC,
ENC_FMT_AAC_V2 = ASM_MEDIA_FMT_AAC_V2,
DEC_FMT_AAC_V2 = ASM_MEDIA_FMT_AAC_V2,
ENC_FMT_APTX = ASM_MEDIA_FMT_APTX,
@@ -232,7 +230,6 @@ struct msm_dai_q6_dai_data {
u16 afe_rx_in_bitformat;
u32 afe_tx_out_channels;
u16 afe_tx_out_bitformat;
u32 dyn_bitrate;
struct afe_enc_config enc_config;
struct afe_dec_config dec_config;
union afe_port_config port_config;
@@ -1288,7 +1285,6 @@ static int msm_dai_q6_island_mode_put(struct snd_kcontrol *kcontrol,
u16 port_id = (u16)kcontrol->private_value;
pr_debug("%s: island mode = %d\n", __func__, value);
trace_printk("%s: island mode = %d\n", __func__, value);
afe_set_island_mode_cfg(port_id, value);
return 0;
@@ -2476,7 +2472,7 @@ static int msm_dai_q6_usb_audio_hw_params(struct snd_pcm_hw_params *params,
dai_data->port_config.usb_audio.num_channels = dai_data->channels;
dai_data->port_config.usb_audio.sample_rate = dai_data->rate;
dev_info(dai->dev, "%s: dev_id[0x%x] bit_wd[%hu] format[%hu]\n"
dev_dbg(dai->dev, "%s: dev_id[0x%x] bit_wd[%hu] format[%hu]\n"
"num_channel %hu sample_rate %d\n", __func__,
dai_data->port_config.usb_audio.dev_token,
dai_data->port_config.usb_audio.bit_width,
@@ -2624,8 +2620,6 @@ static int msm_dai_q6_hw_params(struct snd_pcm_substream *substream,
case RT_PROXY_DAI_001_RX:
case RT_PROXY_DAI_002_TX:
case RT_PROXY_DAI_002_RX:
case RT_PROXY_PORT_002_TX:
case RT_PROXY_PORT_002_RX:
rc = msm_dai_q6_afe_rtproxy_hw_params(params, dai);
break;
case VOICE_PLAYBACK_TX:
@@ -2936,7 +2930,7 @@ static int msm_dai_q6_usb_audio_cfg_put(struct snd_kcontrol *kcontrol,
if (dai_data) {
dai_data->port_config.usb_audio.dev_token = val;
pr_info("%s: dev_token = 0x%x\n", __func__,
pr_debug("%s: dev_token = 0x%x\n", __func__,
dai_data->port_config.usb_audio.dev_token);
} else {
pr_err("%s: dai_data is NULL\n", __func__);
@@ -3123,11 +3117,6 @@ static int msm_dai_q6_afe_enc_cfg_put(struct snd_kcontrol *kcontrol,
pr_debug("%s: Received encoder config for %d format\n",
__func__, dai_data->enc_config.format);
switch (dai_data->enc_config.format) {
case ENC_FMT_SBC_SS:
memcpy(&dai_data->enc_config.data,
ucontrol->value.bytes.data + format_size,
sizeof(struct asm_ss_sbc_enc_cfg_t));
break;
case ENC_FMT_SBC:
memcpy(&dai_data->enc_config.data,
ucontrol->value.bytes.data + format_size,
@@ -3163,11 +3152,6 @@ static int msm_dai_q6_afe_enc_cfg_put(struct snd_kcontrol *kcontrol,
ucontrol->value.bytes.data + format_size,
sizeof(struct asm_aptx_ad_enc_cfg_t));
break;
case ENC_FMT_SSC:
memcpy(&dai_data->enc_config.data,
ucontrol->value.bytes.data + format_size,
sizeof(struct asm_custom_enc_cfg_ssc_t));
break;
case ENC_FMT_APTX_AD_SPEECH:
memcpy(&dai_data->enc_config.data,
ucontrol->value.bytes.data + format_size,
@@ -3351,46 +3335,6 @@ static int msm_dai_q6_afe_input_bit_format_put(
return 0;
}
static int msm_dai_q6_afe_slimbus_dynamic_bitrate_get(
struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
struct msm_dai_q6_dai_data *dai_data = kcontrol->private_data;
if (!dai_data) {
pr_err("%s: Invalid dai data\n", __func__);
return -EINVAL;
}
ucontrol->value.enumerated.item[0] = dai_data->dyn_bitrate;
pr_debug("%s: afe dynamic bitrate : %ld\n",
__func__, ucontrol->value.integer.value[0]);
return 0;
}
static int msm_dai_q6_afe_slimbus_dynamic_bitrate_put(
struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
int rc = 0;
struct msm_dai_q6_dai_data *dai_data = kcontrol->private_data;
if (!dai_data) {
pr_err("%s: Invalid dai data\n", __func__);
return -EINVAL;
}
dai_data->dyn_bitrate = ucontrol->value.enumerated.item[0];
pr_debug("%s: updating afe dynamic bitrate : %d\n",
__func__, dai_data->dyn_bitrate);
rc = afe_q6_slimbus_update_dyn_bitrate(dai_data->dyn_bitrate);
if (rc < 0)
pr_debug("%s: fail to update dynamic bitrate for AFE APR\n", __func__);
return rc;
}
static int msm_dai_q6_afe_output_bit_format_get(
struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
@@ -3538,10 +3482,7 @@ static const struct snd_kcontrol_new afe_enc_config_controls[] = {
.info = msm_dai_q6_afe_enc_cfg_info,
.get = msm_dai_q6_afe_enc_cfg_get,
.put = msm_dai_q6_afe_enc_cfg_put,
},
SOC_SINGLE_EXT("AFE Dynamic Bitrate", 0, 0, UINT_MAX, 0,
msm_dai_q6_afe_slimbus_dynamic_bitrate_get,
msm_dai_q6_afe_slimbus_dynamic_bitrate_put)
}
};
static int msm_dai_q6_afe_dec_cfg_info(struct snd_kcontrol *kcontrol,
@@ -3668,14 +3609,6 @@ static int msm_dai_q6_afe_dec_cfg_get(struct snd_kcontrol *kcontrol,
case DEC_FMT_MP3:
/* No decoder specific data available */
break;
case ENC_FMT_SBC_SS:
case ENC_FMT_SSC:
pr_debug("%s: SBC_SS or SSC config for %d format: Expect abr_dec_cfg\n",
__func__, dai_data->dec_config.format);
memcpy(ucontrol->value.bytes.data + format_size,
&dai_data->dec_config.abr_dec_cfg,
sizeof(struct afe_abr_dec_cfg_t));
break;
default:
pr_err("%s: Invalid format %d\n",
__func__, dai_data->dec_config.format);
@@ -3722,14 +3655,6 @@ static int msm_dai_q6_afe_dec_cfg_put(struct snd_kcontrol *kcontrol,
ucontrol->value.bytes.data + format_size,
sizeof(struct asm_aptx_ad_dec_cfg_t));
break;
case ENC_FMT_SBC_SS:
case ENC_FMT_SSC:
pr_debug("%s: SBC SS or SSC config for %d format: Expect abr_dec_cfg\n",
__func__, dai_data->dec_config.format);
memcpy(&dai_data->dec_config.abr_dec_cfg,
ucontrol->value.bytes.data + format_size,
sizeof(struct afe_abr_dec_cfg_t));
break;
default:
pr_err("%s: Invalid format %d\n",
__func__, dai_data->dec_config.format);
@@ -3971,9 +3896,6 @@ static int msm_dai_q6_dai_probe(struct snd_soc_dai *dai)
rc = snd_ctl_add(dai->component->card->snd_card,
snd_ctl_new1(&afe_enc_config_controls[5],
dai_data));
rc = snd_ctl_add(dai->component->card->snd_card,
snd_ctl_new1(&afe_enc_config_controls[6],
dai_data));
rc = snd_ctl_add(dai->component->card->snd_card,
snd_ctl_new1(&avd_drift_config_controls[2],
dai));
@@ -4324,42 +4246,6 @@ static struct snd_soc_dai_driver msm_dai_q6_incall_record_dai[] = {
},
};
static struct snd_soc_dai_driver msm_dai_q6_proxy_tx_dai = {
.capture = {
.stream_name = "Proxy Capture",
.aif_name = "PROXY_TX",
.rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_8000 |
SNDRV_PCM_RATE_16000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.channels_min = 1,
.channels_max = 2,
.rate_min = 8000,
.rate_max = 48000,
},
.ops = &msm_dai_q6_ops,
.id = RT_PROXY_PORT_002_TX,
.probe = msm_dai_q6_dai_probe,
.remove = msm_dai_q6_dai_remove,
};
static struct snd_soc_dai_driver msm_dai_q6_proxy_rx_dai = {
.playback = {
.stream_name = "Proxy Playback",
.aif_name = "PROXY_RX",
.rates = SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_8000 |
SNDRV_PCM_RATE_16000,
.formats = SNDRV_PCM_FMTBIT_S16_LE,
.channels_min = 1,
.channels_max = 2,
.rate_min = 8000,
.rate_max = 48000,
},
.ops = &msm_dai_q6_ops,
.id = RT_PROXY_PORT_002_RX,
.probe = msm_dai_q6_dai_probe,
.remove = msm_dai_q6_dai_remove,
};
static struct snd_soc_dai_driver msm_dai_q6_usb_rx_dai = {
.playback = {
.stream_name = "USB Audio Playback",
@@ -5128,9 +5014,6 @@ static const struct snd_kcontrol_new mi2s_config_controls[] = {
SOC_ENUM_EXT("QUIN MI2S RX Format", mi2s_config_enum[0],
msm_dai_q6_mi2s_format_get,
msm_dai_q6_mi2s_format_put),
SOC_ENUM_EXT("SENARY MI2S RX Format", mi2s_config_enum[0],
msm_dai_q6_mi2s_format_get,
msm_dai_q6_mi2s_format_put),
SOC_ENUM_EXT("PRI MI2S TX Format", mi2s_config_enum[0],
msm_dai_q6_mi2s_format_get,
msm_dai_q6_mi2s_format_put),
@@ -5185,8 +5068,6 @@ static int msm_dai_q6_dai_mi2s_probe(struct snd_soc_dai *dai)
ctrl = &mi2s_config_controls[3];
if (dai->id == MSM_QUIN_MI2S)
ctrl = &mi2s_config_controls[4];
if (dai->id == MSM_SENARY_MI2S)
ctrl = &mi2s_config_controls[5];
}
if (ctrl) {
@@ -5203,19 +5084,19 @@ static int msm_dai_q6_dai_mi2s_probe(struct snd_soc_dai *dai)
ctrl = NULL;
if (mi2s_dai_data->tx_dai.mi2s_dai_data.port_config.i2s.channel_mode) {
if (dai->id == MSM_PRIM_MI2S)
ctrl = &mi2s_config_controls[6];
ctrl = &mi2s_config_controls[5];
if (dai->id == MSM_SEC_MI2S)
ctrl = &mi2s_config_controls[7];
ctrl = &mi2s_config_controls[6];
if (dai->id == MSM_TERT_MI2S)
ctrl = &mi2s_config_controls[8];
ctrl = &mi2s_config_controls[7];
if (dai->id == MSM_QUAT_MI2S)
ctrl = &mi2s_config_controls[9];
ctrl = &mi2s_config_controls[8];
if (dai->id == MSM_QUIN_MI2S)
ctrl = &mi2s_config_controls[10];
ctrl = &mi2s_config_controls[9];
if (dai->id == MSM_SENARY_MI2S)
ctrl = &mi2s_config_controls[11];
ctrl = &mi2s_config_controls[10];
if (dai->id == MSM_INT5_MI2S)
ctrl = &mi2s_config_controls[12];
ctrl = &mi2s_config_controls[11];
}
if (ctrl) {
@@ -7401,14 +7282,6 @@ register_uplink_capture:
__func__, stream_name);
break;
case RT_PROXY_PORT_002_RX:
rc = snd_soc_register_component(&pdev->dev,
&msm_dai_q6_component, &msm_dai_q6_proxy_rx_dai, 1);
break;
case RT_PROXY_PORT_002_TX:
rc = snd_soc_register_component(&pdev->dev,
&msm_dai_q6_component, &msm_dai_q6_proxy_tx_dai, 1);
break;
default:
rc = -ENODEV;
break;

76
techpack/audio/4.0/asoc/msm-lsm-client.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/init.h>
#include <linux/err.h>
@@ -25,15 +25,12 @@
#include <dsp/q6lsm.h>
#include "msm-pcm-routing-v2.h"
#define CAPTURE_MIN_NUM_PERIODS 2
#define CAPTURE_MAX_NUM_PERIODS 8
#define CAPTURE_MAX_PERIOD_SIZE 61440
#define CAPTURE_MIN_PERIOD_SIZE 320
#define LISTEN_MAX_STATUS_PAYLOAD_SIZE 256
#define WAKELOCK_TIMEOUT 2000
#define LAB_BUFFER_ALLOC 1
#define LAB_BUFFER_DEALLOC 0
@@ -91,7 +88,6 @@ struct lsm_priv {
int xrun_count;
int xrun_index;
spinlock_t xrun_lock;
struct wakeup_source ws;
};
enum { /* lsm session states */
@@ -219,8 +215,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
}
rtd = substream->private_data;
pm_wakeup_ws_event(&prtd->ws, WAKELOCK_TIMEOUT, true);
dev_dbg(rtd->dev, "%s: opcode %x\n", __func__, opcode);
switch (opcode) {
case LSM_DATA_EVENT_READ_DONE: {
int rc;
@@ -234,13 +228,11 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
"%s: EVENT_READ_DONE invalid callback, session %d callback %d payload %pK",
__func__, prtd->lsm_client->session,
token, read_done);
__pm_relax(&prtd->ws);
return;
}
if (atomic_read(&prtd->read_abort)) {
dev_dbg(rtd->dev,
"%s: read abort set skip data\n", __func__);
__pm_relax(&prtd->ws);
return;
}
if (!lsm_lab_buffer_sanity(prtd, read_done, &buf_index)) {
@@ -253,7 +245,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
"%s: Invalid index %d buf_index max cnt %d\n",
__func__, buf_index,
prtd->lsm_client->out_hw_params.period_count);
__pm_relax(&prtd->ws);
return;
}
spin_lock_irqsave(&prtd->xrun_lock, flags);
@@ -291,7 +282,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
dev_err(rtd->dev,
"%s: client_size has invalid size[%d]\n",
__func__, client_size);
__pm_relax(&prtd->ws);
return;
}
status = (uint16_t)((uint8_t *)payload)[0];
@@ -307,14 +297,13 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
dev_err(rtd->dev,
"%s: client_size has invalid size[%d]\n",
__func__, client_size);
__pm_relax(&prtd->ws);
return;
}
status = (uint16_t)((uint8_t *)payload)[0];
payload_size = (uint16_t)((uint8_t *)payload)[1];
index = 2;
dev_dbg(rtd->dev,
"%s: event detect status_v2 = %d payload size = %d\n",
"%s: event detect status = %d payload size = %d\n",
__func__, status, payload_size);
break;
@@ -323,7 +312,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
dev_err(rtd->dev,
"%s: client_size has invalid size[%d]\n",
__func__, client_size);
__pm_relax(&prtd->ws);
return;
}
event_ts_lsw = ((uint32_t *)payload)[0];
@@ -343,7 +331,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
dev_err(rtd->dev,
"%s: client_size has invalid size[%d]\n",
__func__, client_size);
__pm_relax(&prtd->ws);
return;
}
@@ -363,7 +350,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
"LSM_SESSION_DETECTION_ENGINE_GENERIC_EVENT",
sizeof(struct snd_lsm_event_status) +
payload_size);
__pm_relax(&prtd->ws);
return;
}
@@ -378,7 +364,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
dev_err(rtd->dev,
"%s: Failed to copy memory with invalid size = %d\n",
__func__, payload_size);
__pm_relax(&prtd->ws);
return;
}
prtd->event_avail = 1;
@@ -403,14 +388,12 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
opcode == LSM_SESSION_EVENT_DETECTION_STATUS_V2 ||
opcode == LSM_SESSION_EVENT_DETECTION_STATUS_V3) {
spin_lock_irqsave(&prtd->event_lock, flags);
dev_dbg(rtd->dev, "%s: detection status\n", __func__);
temp = krealloc(prtd->event_status,
sizeof(struct snd_lsm_event_status_v3) +
payload_size, GFP_ATOMIC);
if (!temp) {
dev_err(rtd->dev, "%s: no memory for event status\n",
__func__);
__pm_relax(&prtd->ws);
return;
}
/*
@@ -430,15 +413,12 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
payload_size);
prtd->event_avail = 1;
spin_unlock_irqrestore(&prtd->event_lock, flags);
dev_dbg(rtd->dev, "%s: wakeup event_wait\n",
__func__);
wake_up(&prtd->event_wait);
} else {
spin_unlock_irqrestore(&prtd->event_lock, flags);
dev_err(rtd->dev,
"%s: Failed to copy memory with invalid size = %d\n",
__func__, payload_size);
__pm_relax(&prtd->ws);
return;
}
} else {
@@ -450,7 +430,6 @@ static void lsm_event_handler(uint32_t opcode, uint32_t token,
if (substream->timer_running)
snd_timer_interrupt(substream->timer, 1);
}
dev_dbg(rtd->dev, "%s: leave\n", __func__);
}
static int msm_lsm_lab_buffer_alloc(struct lsm_priv *lsm, int alloc)
@@ -678,10 +657,6 @@ static int msm_lsm_set_conf(struct snd_pcm_substream *substream,
"%s: Failed to set min_conf_levels, err = %d\n",
__func__, rc);
if (prtd->lsm_client->confidence_levels) {
kfree(prtd->lsm_client->confidence_levels);
prtd->lsm_client->confidence_levels = NULL;
}
return rc;
}
@@ -1078,6 +1053,7 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
struct snd_pcm_runtime *runtime;
struct lsm_priv *prtd;
struct snd_lsm_detection_params det_params;
uint8_t *confidence_level = NULL;
uint32_t max_detection_stages_supported = LSM_MAX_STAGES_PER_SESSION;
if (!substream || !substream->private_data) {
@@ -1090,7 +1066,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
prtd = runtime->private_data;
rtd = substream->private_data;
dev_dbg(rtd->dev, "%s: enter, cmd %x\n", __func__, cmd);
switch (cmd) {
case SNDRV_LSM_SET_SESSION_DATA:
case SNDRV_LSM_SET_SESSION_DATA_V2:
@@ -1156,7 +1131,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
dev_err(rtd->dev,
"%s: lsm open failed, %d\n",
__func__, ret);
__pm_relax(&prtd->ws);
return ret;
}
prtd->lsm_client->opened = true;
@@ -1234,12 +1208,12 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
dev_err(rtd->dev,
"%s: Register snd Model v2 failed =%d\n",
__func__, rc);
kfree(confidence_level);
q6lsm_snd_model_buf_free(prtd->lsm_client, &p_info);
}
if (prtd->lsm_client->confidence_levels) {
kfree(prtd->lsm_client->confidence_levels);
prtd->lsm_client->confidence_levels = NULL;
}
kfree(prtd->lsm_client->confidence_levels);
prtd->lsm_client->confidence_levels = NULL;
break;
}
case SNDRV_LSM_SET_PARAMS:
@@ -1271,10 +1245,10 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
dev_err(rtd->dev,
"%s: Failed to set params, err = %d\n",
__func__, rc);
if (prtd->lsm_client->confidence_levels) {
kfree(prtd->lsm_client->confidence_levels);
prtd->lsm_client->confidence_levels = NULL;
}
kfree(prtd->lsm_client->confidence_levels);
prtd->lsm_client->confidence_levels = NULL;
break;
case SNDRV_LSM_DEREG_SND_MODEL:
@@ -1292,8 +1266,7 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
uint32_t ts_lsw, ts_msw;
uint16_t status = 0, payload_size = 0;
dev_dbg(rtd->dev, "%s: Get event status cmd %xx\n",
__func__, cmd);
dev_dbg(rtd->dev, "%s: Get event status\n", __func__);
atomic_set(&prtd->event_wait_stop, 0);
/*
@@ -1306,7 +1279,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
(cmpxchg(&prtd->event_avail, 1, 0) ||
(xchg = atomic_cmpxchg(&prtd->event_wait_stop,
1, 0))));
dev_dbg(rtd->dev, "%s: wait event is done\n", __func__);
mutex_lock(&prtd->lsm_api_lock);
dev_dbg(rtd->dev, "%s: wait_event_freezable %d event_wait_stop %d\n",
__func__, rc, xchg);
@@ -1483,12 +1455,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
prtd->lsm_client->lab_started = false;
}
}
if (!atomic_read(&prtd->read_abort)) {
dev_dbg(rtd->dev,
"%s: set read_abort to stop buffering\n", __func__);
atomic_set(&prtd->read_abort, 1);
}
rc = q6lsm_stop(prtd->lsm_client, true);
if (!rc)
dev_dbg(rtd->dev,
@@ -1505,14 +1471,12 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
if (prtd->lsm_client->num_stages > 1) {
dev_err(rtd->dev, "%s: %s: not supported for multi stage session\n",
__func__, "LSM_LAB_CONTROL");
__pm_relax(&prtd->ws);
return -EINVAL;
}
if (copy_from_user(&enable, arg, sizeof(enable))) {
dev_err(rtd->dev, "%s: %s: copy_frm_user failed\n",
__func__, "LSM_LAB_CONTROL");
__pm_relax(&prtd->ws);
return -EFAULT;
}
@@ -1567,7 +1531,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
if (copy_from_user(&mode, arg, sizeof(mode))) {
dev_err(rtd->dev, "%s: %s: copy_frm_user failed\n",
__func__, "LSM_SET_FWK_MODE_CONFIG");
__pm_relax(&prtd->ws);
return -EFAULT;
}
@@ -1598,7 +1561,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
if (copy_from_user(&params, arg, sizeof(params))) {
dev_err(rtd->dev, "%s: %s: copy_from_user failed\n",
__func__, "LSM_SET_INPUT_HW_PARAMS");
__pm_relax(&prtd->ws);
return -EFAULT;
}
@@ -1625,7 +1587,6 @@ static int msm_lsm_ioctl_shared(struct snd_pcm_substream *substream,
dev_err(rtd->dev, "%s: cmd 0x%x failed %d\n",
__func__, cmd, rc);
__pm_relax(&prtd->ws);
return rc;
}
@@ -2530,7 +2491,6 @@ static int msm_lsm_open(struct snd_pcm_substream *substream)
prtd->lsm_client->fe_id = rtd->dai_link->id;
prtd->lsm_client->unprocessed_data = 0;
wakeup_source_init(&prtd->ws, "lsm-client");
return 0;
}
@@ -2698,12 +2658,6 @@ static int msm_lsm_close(struct snd_pcm_substream *substream)
__func__, ret);
}
}
if (!atomic_read(&prtd->read_abort)) {
dev_dbg(rtd->dev,
"%s: set read_abort to stop buffering\n", __func__);
atomic_set(&prtd->read_abort, 1);
}
ret = q6lsm_stop(prtd->lsm_client, true);
if (ret)
dev_err(rtd->dev,
@@ -2734,11 +2688,6 @@ static int msm_lsm_close(struct snd_pcm_substream *substream)
SNDRV_PCM_STREAM_CAPTURE);
if (prtd->lsm_client->opened) {
if (!atomic_read(&prtd->read_abort)) {
dev_dbg(rtd->dev,
"%s: set read_abort to stop buffering\n", __func__);
atomic_set(&prtd->read_abort, 1);
}
q6lsm_close(prtd->lsm_client);
prtd->lsm_client->opened = false;
}
@@ -2775,7 +2724,6 @@ static int msm_lsm_close(struct snd_pcm_substream *substream)
q6lsm_client_free(prtd->lsm_client);
wakeup_source_trash(&prtd->ws);
spin_lock_irqsave(&prtd->event_lock, flags);
kfree(prtd->event_status);
prtd->event_status = NULL;

43
techpack/audio/4.0/asoc/msm-pcm-loopback-v2.c
View File

@@ -242,6 +242,7 @@ static int msm_pcm_open(struct snd_pcm_substream *substream)
struct msm_pcm_loopback *pcm = NULL;
int ret = 0;
uint16_t bits_per_sample = 16;
struct msm_pcm_routing_evt event;
struct asm_session_mtmx_strtr_param_window_v2_t asm_mtmx_strtr_window;
uint32_t param_id;
struct msm_pcm_pdata *pdata;
@@ -263,6 +264,10 @@ static int msm_pcm_open(struct snd_pcm_substream *substream)
dev_dbg(rtd->platform->dev, "%s: pcm out open: %d,%d\n", __func__,
pcm->instance, substream->stream);
if (pcm->instance == 2) {
struct snd_soc_pcm_runtime *soc_pcm_rx =
pcm->playback_substream->private_data;
struct snd_soc_pcm_runtime *soc_pcm_tx =
pcm->capture_substream->private_data;
if (pcm->audio_client != NULL)
stop_pcm(pcm);
@@ -294,6 +299,15 @@ static int msm_pcm_open(struct snd_pcm_substream *substream)
mutex_unlock(&pcm->lock);
return -ENOMEM;
}
event.event_func = msm_pcm_route_event_handler;
event.priv_data = (void *) pcm;
msm_pcm_routing_reg_phy_stream(soc_pcm_tx->dai_link->id,
pcm->audio_client->perf_mode,
pcm->session_id, pcm->capture_substream->stream);
msm_pcm_routing_reg_phy_stream_v2(soc_pcm_rx->dai_link->id,
pcm->audio_client->perf_mode,
pcm->session_id, pcm->playback_substream->stream,
event);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
pcm->playback_substream = substream;
ret = pcm_loopback_set_volume(pcm, pcm->volume);
@@ -494,21 +508,10 @@ static int msm_pcm_volume_ctl_put(struct snd_kcontrol *kcontrol,
{
int rc = 0;
struct snd_pcm_volume *vol = kcontrol->private_data;
struct snd_pcm_substream *substream = NULL;
struct snd_pcm_substream *substream = vol->pcm->streams[0].substream;
struct msm_pcm_loopback *prtd;
int volume = ucontrol->value.integer.value[0];
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[0].substream;
pr_debug("%s: volume : 0x%x\n", __func__, volume);
if ((!substream) || (!substream->runtime)) {
pr_err("%s substream or runtime not found\n", __func__);
@@ -524,6 +527,7 @@ static int msm_pcm_volume_ctl_put(struct snd_kcontrol *kcontrol,
}
rc = pcm_loopback_set_volume(prtd, volume);
mutex_unlock(&loopback_session_lock);
exit:
return rc;
}
@@ -533,21 +537,11 @@ static int msm_pcm_volume_ctl_get(struct snd_kcontrol *kcontrol,
{
int rc = 0;
struct snd_pcm_volume *vol = snd_kcontrol_chip(kcontrol);
struct snd_pcm_substream *substream = NULL;
struct snd_pcm_substream *substream =
vol->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
struct msm_pcm_loopback *prtd;
pr_debug("%s\n", __func__);
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream;
if ((!substream) || (!substream->runtime)) {
pr_debug("%s substream or runtime not found\n", __func__);
rc = -ENODEV;
@@ -562,6 +556,7 @@ static int msm_pcm_volume_ctl_get(struct snd_kcontrol *kcontrol,
}
ucontrol->value.integer.value[0] = prtd->volume;
mutex_unlock(&loopback_session_lock);
exit:
return rc;
}

30
techpack/audio/4.0/asoc/msm-pcm-q6-noirq.c
View File

@@ -708,23 +708,12 @@ static int msm_pcm_volume_ctl_get(struct snd_kcontrol *kcontrol,
{
struct snd_pcm_volume *vol = snd_kcontrol_chip(kcontrol);
struct msm_plat_data *pdata = NULL;
struct snd_pcm_substream *substream = NULL;
struct snd_pcm_substream *substream =
vol->pcm->streams[vol->stream].substream;
struct snd_soc_pcm_runtime *soc_prtd = NULL;
struct msm_audio *prtd;
pr_debug("%s\n", __func__);
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[vol->stream].substream;
if (!substream) {
pr_err("%s: substream not found\n", __func__);
return -ENODEV;
@@ -756,23 +745,12 @@ static int msm_pcm_volume_ctl_put(struct snd_kcontrol *kcontrol,
int rc = 0;
struct snd_pcm_volume *vol = snd_kcontrol_chip(kcontrol);
struct msm_plat_data *pdata = NULL;
struct snd_pcm_substream *substream = NULL;
struct snd_pcm_substream *substream =
vol->pcm->streams[vol->stream].substream;
struct snd_soc_pcm_runtime *soc_prtd = NULL;
struct msm_audio *prtd;
int volume = ucontrol->value.integer.value[0];
pr_debug("%s\n", __func__);
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[vol->stream].substream;
pr_debug("%s: volume : 0x%x\n", __func__, volume);
if (!substream) {
pr_err("%s substream not found\n", __func__);

34
techpack/audio/4.0/asoc/msm-pcm-q6-v2.c
View File

@@ -1459,23 +1459,12 @@ static int msm_pcm_volume_ctl_get(struct snd_kcontrol *kcontrol,
{
struct snd_pcm_volume *vol = snd_kcontrol_chip(kcontrol);
struct msm_plat_data *pdata = NULL;
struct snd_pcm_substream *substream = NULL;
struct snd_pcm_substream *substream =
vol->pcm->streams[vol->stream].substream;
struct snd_soc_pcm_runtime *soc_prtd = NULL;
struct msm_audio *prtd;
pr_debug("%s\n", __func__);
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[vol->stream].substream;
if (!substream) {
pr_err("%s substream not found\n", __func__);
return -ENODEV;
@@ -1507,29 +1496,18 @@ static int msm_pcm_volume_ctl_put(struct snd_kcontrol *kcontrol,
{
int rc = 0;
struct snd_pcm_volume *vol = snd_kcontrol_chip(kcontrol);
struct snd_pcm_substream *substream = NULL;
struct snd_soc_pcm_runtime *soc_prtd = NULL;
struct msm_plat_data *pdata = NULL;
struct snd_pcm_substream *substream =
vol->pcm->streams[vol->stream].substream;
struct snd_soc_pcm_runtime *soc_prtd = NULL;
struct msm_audio *prtd;
int volume = ucontrol->value.integer.value[0];
pr_debug("%s: volume : 0x%x\n", __func__, volume);
if (!vol) {
pr_err("%s: vol is NULL\n", __func__);
return -ENODEV;
}
if (!vol->pcm) {
pr_err("%s: vol->pcm is NULL\n", __func__);
return -ENODEV;
}
substream = vol->pcm->streams[vol->stream].substream;
if (!substream) {
pr_err("%s: substream not found\n", __func__);
return -ENODEV;
}
soc_prtd = substream->private_data;
if (!substream->runtime || !soc_prtd) {
pr_err("%s: substream runtime or private_data not found\n",
@@ -1738,6 +1716,7 @@ static int msm_pcm_chmap_ctl_put(struct snd_kcontrol *kcontrol,
}
}
if (!rtd)
return 0;
@@ -1750,6 +1729,7 @@ static int msm_pcm_chmap_ctl_put(struct snd_kcontrol *kcontrol,
(char)(ucontrol->value.integer.value[i]);
/* update chmixer_pspd chmap cached with routing driver as well */
rtd = substream->private_data;
if (rtd) {
fe_id = rtd->dai_link->id;
chmixer_pspd = pdata ?

16833
techpack/audio/4.0/asoc/msm-pcm-routing-v2.c
View File

File diff suppressed because it is too large Load Diff

14
techpack/audio/4.0/asoc/msm-pcm-routing-v2.h
View File

@@ -1,13 +1,10 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#ifndef _MSM_PCM_ROUTING_H
#define _MSM_PCM_ROUTING_H
#include <dsp/apr_audio-v2.h>
#include <dsp/q6adm-v2.h>
#ifdef CONFIG_SEC_SND_ADAPTATION
#include <dsp/sec_adaptation.h>
#endif
/*
* These names are used by HAL to specify the BE. If any changes are
@@ -45,8 +42,6 @@
#define LPASS_BE_VOICE2_PLAYBACK_TX "VOICE2_PLAYBACK_TX"
#define LPASS_BE_INCALL_RECORD_RX "INCALL_RECORD_RX"
#define LPASS_BE_INCALL_RECORD_TX "INCALL_RECORD_TX"
#define LPASS_BE_PROXY_RX "PROXY_RX"
#define LPASS_BE_PROXY_TX "PROXY_TX"
#define LPASS_BE_SEC_I2S_RX "SECONDARY_I2S_RX"
#define LPASS_BE_PRI_SPDIF_RX "PRI_SPDIF_RX"
#define LPASS_BE_PRI_SPDIF_TX "PRI_SPDIF_TX"
@@ -265,7 +260,6 @@ enum {
MSM_FRONTEND_DAI_MULTIMEDIA20,
MSM_FRONTEND_DAI_MULTIMEDIA21,
MSM_FRONTEND_DAI_MULTIMEDIA22,
MSM_FRONTEND_DAI_MULTIMEDIA23,
MSM_FRONTEND_DAI_MULTIMEDIA26,
MSM_FRONTEND_DAI_MULTIMEDIA27,
MSM_FRONTEND_DAI_MULTIMEDIA28,
@@ -505,8 +499,6 @@ enum {
MSM_BACKEND_DAI_AFE_LOOPBACK_TX,
MSM_BACKEND_DAI_PRI_META_MI2S_RX,
MSM_BACKEND_DAI_SEC_META_MI2S_RX,
MSM_BACKEND_DAI_PROXY_RX,
MSM_BACKEND_DAI_PROXY_TX,
MSM_BACKEND_DAI_MAX,
};
@@ -652,8 +644,4 @@ int msm_pcm_routing_set_channel_mixer_runtime(
int be_id, int session_id,
int session_type,
struct msm_pcm_channel_mixer *params);
#ifdef CONFIG_SEC_SND_ADAPTATION
int q6audio_get_copp_idx_from_port_id(int port_id, enum sb_type func_type,
int *copp_idx);
#endif /* CONFIG_SEC_SND_ADAPTATION */
#endif /*_MSM_PCM_H*/

16
techpack/audio/4.0/asoc/msm-pcm-voice-v2.c
View File

@@ -582,20 +582,6 @@ static int msm_voice_slowtalk_put(struct snd_kcontrol *kcontrol,
return 0;
}
static int msm_voice_ecns_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
uint32_t enable = ucontrol->value.integer.value[0];
uint32_t session_id = ucontrol->value.integer.value[1];
uint32_t module_id = ucontrol->value.integer.value[2];
pr_debug("%s: ecns enable=%d session_id=%#x\n", __func__, enable,
session_id);
voc_set_ecns_enable(session_id, module_id, enable);
return 0;
}
static int msm_voice_hd_voice_put(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -709,8 +695,6 @@ static struct snd_kcontrol_new msm_voice_controls[] = {
msm_voice_tty_mode_put),
SOC_SINGLE_MULTI_EXT("Slowtalk Enable", SND_SOC_NOPM, 0, VSID_MAX, 0, 2,
NULL, msm_voice_slowtalk_put),
SOC_SINGLE_MULTI_EXT("Voice ECNS Enable", SND_SOC_NOPM, 0, VSID_MAX, 0, 3,
NULL, msm_voice_ecns_put),
SOC_SINGLE_MULTI_EXT("Voice Topology Disable", SND_SOC_NOPM, 0,
VSID_MAX, 0, 2, NULL,
msm_voice_topology_disable_put),

15
techpack/audio/4.0/asoc/msm-pcm-voip-v2.c
View File

@@ -24,7 +24,6 @@
#include "msm-pcm-routing-v2.h"
#define SHARED_MEM_BUF 2
#define VOIP_MIN_Q_LEN 2
#define VOIP_MAX_Q_LEN 10
#define VOIP_MAX_VOC_PKT_SIZE 4096
#define VOIP_MIN_VOC_PKT_SIZE 320
@@ -198,10 +197,10 @@ static struct snd_pcm_hardware msm_pcm_hardware = {
.rate_max = 48000,
.channels_min = 1,
.channels_max = 1,
.buffer_bytes_max = sizeof(struct voip_buf_node) * VOIP_MIN_Q_LEN,
.buffer_bytes_max = sizeof(struct voip_buf_node) * VOIP_MAX_Q_LEN,
.period_bytes_min = VOIP_MIN_VOC_PKT_SIZE,
.period_bytes_max = VOIP_MAX_VOC_PKT_SIZE,
.periods_min = VOIP_MIN_Q_LEN,
.periods_min = VOIP_MAX_Q_LEN,
.periods_max = VOIP_MAX_Q_LEN,
.fifo_size = 0,
};
@@ -1263,17 +1262,11 @@ static int msm_pcm_hw_params(struct snd_pcm_substream *substream,
struct snd_dma_buffer *dma_buf = &substream->dma_buffer;
struct voip_buf_node *buf_node = NULL;
int i = 0, offset = 0;
int periods = VOIP_MIN_Q_LEN;
pr_debug("%s: voip\n", __func__);
mutex_lock(&voip_info.lock);
/* Use various voip Q size */
periods = params_periods(params);
pr_info("%s: periods = %d\n", __func__, periods);
runtime->hw.buffer_bytes_max = sizeof(struct voip_buf_node) * periods;
dma_buf->dev.type = SNDRV_DMA_TYPE_DEV;
dma_buf->dev.dev = substream->pcm->card->dev;
dma_buf->private_data = NULL;
@@ -1291,7 +1284,7 @@ static int msm_pcm_hw_params(struct snd_pcm_substream *substream,
memset(dma_buf->area, 0, runtime->hw.buffer_bytes_max);
if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
for (i = 0; i < periods; i++) {
for (i = 0; i < VOIP_MAX_Q_LEN; i++) {
buf_node = (void *)dma_buf->area + offset;
list_add_tail(&buf_node->list,
@@ -1299,7 +1292,7 @@ static int msm_pcm_hw_params(struct snd_pcm_substream *substream,
offset = offset + sizeof(struct voip_buf_node);
}
} else {
for (i = 0; i < periods; i++) {
for (i = 0; i < VOIP_MAX_Q_LEN; i++) {
buf_node = (void *) dma_buf->area + offset;
list_add_tail(&buf_node->list,
&voip_info.free_out_queue);

54
techpack/audio/4.0/asoc/msm-qti-pp-config.c
View File

@@ -545,8 +545,6 @@ static int msm_route_fm_vol_control;
static int msm_afe_lb_vol_ctrl;
static int msm_afe_sec_mi2s_lb_vol_ctrl;
static int msm_afe_tert_mi2s_lb_vol_ctrl;
static int msm_afe_cdc_tx_3_lb_vol_ctrl;
static int msm_afe_usb_lb_vol_ctrl;
static int msm_afe_quat_mi2s_lb_vol_ctrl;
static int msm_afe_slimbus_7_lb_vol_ctrl;
static int msm_afe_slimbus_8_lb_vol_ctrl;
@@ -654,38 +652,6 @@ static int msm_qti_pp_set_tert_mi2s_lb_vol_mixer(struct snd_kcontrol *kcontrol,
return 0;
}
static int msm_qti_pp_get_usb_tx_lb_vol_mixer(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
ucontrol->value.integer.value[0] = msm_afe_usb_lb_vol_ctrl;
return 0;
}
static int msm_qti_pp_set_usb_tx_lb_vol_mixer(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
afe_loopback_gain(AFE_PORT_ID_USB_TX,
ucontrol->value.integer.value[0]);
msm_afe_usb_lb_vol_ctrl = ucontrol->value.integer.value[0];
return 0;
}
static int msm_qti_pp_get_cdc_tx_3_lb_vol_mixer(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
ucontrol->value.integer.value[0] = msm_afe_cdc_tx_3_lb_vol_ctrl;
return 0;
}
static int msm_qti_pp_set_cdc_tx_3_lb_vol_mixer(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
afe_loopback_gain(AFE_PORT_ID_TX_CODEC_DMA_TX_3,
ucontrol->value.integer.value[0]);
msm_afe_cdc_tx_3_lb_vol_ctrl = ucontrol->value.integer.value[0];
return 0;
}
static int msm_qti_pp_get_slimbus_7_lb_vol_mixer(struct snd_kcontrol *kcontrol,
struct snd_ctl_elem_value *ucontrol)
{
@@ -1475,18 +1441,6 @@ static const struct snd_kcontrol_new tert_mi2s_lb_vol_mixer_controls[] = {
msm_qti_pp_set_tert_mi2s_lb_vol_mixer, afe_lb_vol_gain),
};
static const struct snd_kcontrol_new tx_cdc_dma_tx_3_lb_vol_mixer_controls[] = {
SOC_SINGLE_EXT_TLV("TX_CDC_DMA_TX_3 LOOPBACK Volume", SND_SOC_NOPM, 0,
INT_RX_VOL_GAIN, 0, msm_qti_pp_get_cdc_tx_3_lb_vol_mixer,
msm_qti_pp_set_cdc_tx_3_lb_vol_mixer, afe_lb_vol_gain),
};
static const struct snd_kcontrol_new usb_audio_tx_vol_mixer_controls[] = {
SOC_SINGLE_EXT_TLV("USB_AUDIO_TX LOOPBACK Volume", SND_SOC_NOPM, 0,
INT_RX_VOL_GAIN, 0, msm_qti_pp_get_usb_tx_lb_vol_mixer,
msm_qti_pp_set_usb_tx_lb_vol_mixer, afe_lb_vol_gain),
};
static const struct snd_kcontrol_new slimbus_7_lb_vol_mixer_controls[] = {
SOC_SINGLE_EXT_TLV("SLIMBUS_7 LOOPBACK Volume", SND_SOC_NOPM, 0,
INT_RX_VOL_GAIN, 0,
@@ -1707,14 +1661,6 @@ void msm_qti_pp_add_controls(struct snd_soc_platform *platform)
snd_soc_add_platform_controls(platform, tert_mi2s_lb_vol_mixer_controls,
ARRAY_SIZE(tert_mi2s_lb_vol_mixer_controls));
snd_soc_add_platform_controls(platform,
tx_cdc_dma_tx_3_lb_vol_mixer_controls,
ARRAY_SIZE(tx_cdc_dma_tx_3_lb_vol_mixer_controls));
snd_soc_add_platform_controls(platform,
usb_audio_tx_vol_mixer_controls,
ARRAY_SIZE(usb_audio_tx_vol_mixer_controls));
snd_soc_add_platform_controls(platform, slimbus_7_lb_vol_mixer_controls,
ARRAY_SIZE(slimbus_7_lb_vol_mixer_controls));

16
techpack/audio/4.0/asoc/sm6150.c
View File

@@ -3873,8 +3873,6 @@ static int msm_snd_enable_codec_ext_clk(struct snd_soc_codec *codec,
if (!strcmp(dev_name(codec->dev), "tavil_codec")) {
ret = tavil_cdc_mclk_enable(codec, enable);
} else if (!strcmp(dev_name(codec->dev), "tasha_codec")) {
ret = tasha_cdc_mclk_enable(codec, enable, dapm);
} else {
dev_err(codec->dev, "%s: unknown codec to enable ext clk\n",
__func__);
@@ -4231,8 +4229,6 @@ static int msm_be_hw_params_fixup(struct snd_soc_pcm_runtime *rtd,
SNDRV_PCM_HW_PARAM_RATE);
struct snd_interval *channels = hw_param_interval(params,
SNDRV_PCM_HW_PARAM_CHANNELS);
struct snd_soc_dai *codec_dai = rtd->codec_dai;
int rc = 0;
int idx;
void *config = NULL;
@@ -5900,7 +5896,6 @@ static int msm_mi2s_snd_startup(struct snd_pcm_substream *substream)
if (mi2s_intf_conf[index].msm_is_ext_mclk) {
pr_debug("%s: Enabling mclk, clk_freq_in_hz = %u\n",
__func__, mi2s_mclk[index].clk_freq_in_hz);
mi2s_mclk[index].enable = 1;
ret = afe_set_lpass_clock_v2(port_id,
&mi2s_mclk[index]);
if (ret < 0) {
@@ -5908,6 +5903,7 @@ static int msm_mi2s_snd_startup(struct snd_pcm_substream *substream)
__func__, ret);
goto clk_off;
}
mi2s_mclk[index].enable = 1;
}
if (pdata->mi2s_gpio_p[index])
msm_cdc_pinctrl_select_active_state(
@@ -5960,12 +5956,12 @@ static void msm_mi2s_snd_shutdown(struct snd_pcm_substream *substream)
if (mi2s_intf_conf[index].msm_is_ext_mclk) {
pr_debug("%s: Disabling mclk, clk_freq_in_hz = %u\n",
__func__, mi2s_mclk[index].clk_freq_in_hz);
mi2s_mclk[index].enable = 0;
ret = afe_set_lpass_clock_v2(port_id,
&mi2s_mclk[index]);
if (ret < 0)
pr_err("%s: mclk disable failed for MCLK (%d); ret=%d\n",
__func__, index, ret);
mi2s_mclk[index].enable = 0;
}
}
mutex_unlock(&mi2s_intf_conf[index].lock);
@@ -8307,6 +8303,7 @@ static struct snd_soc_card *populate_snd_card_dailinks(struct device *dev)
sizeof(msm_common_dai_links));
total_links += ARRAY_SIZE(msm_common_dai_links);
pr_err("%s\n. Common dailinks\n", __func__);
memcpy(msm_sm6150_dai_links + total_links,
msm_common_misc_fe_dai_links,
@@ -8314,6 +8311,7 @@ static struct snd_soc_card *populate_snd_card_dailinks(struct device *dev)
total_links += ARRAY_SIZE(msm_common_misc_fe_dai_links);
pr_err("%s\n. Common misc dailinks\n", __func__);
rc = of_property_read_u32(dev->of_node, "qcom,tavil_codec",
&tavil_codec);
if (rc)
@@ -8467,9 +8465,11 @@ static struct snd_soc_card *populate_snd_card_dailinks(struct device *dev)
dailink = msm_stub_dai_links;
}
if (card) {
if (card) {
pr_err("%s\n. dailinks assigned\n", __func__);
card->dai_link = dailink;
card->num_links = total_links;
pr_err("total links %d\n", card->num_links);
}
return card;
@@ -9084,6 +9084,7 @@ static int msm_asoc_machine_probe(struct platform_device *pdev)
ret = -EINVAL;
goto err;
}
dev_err(&pdev->dev, "%s: sound card dailinks populated\n", __func__);
card->dev = &pdev->dev;
platform_set_drvdata(pdev, card);
snd_soc_card_set_drvdata(card, pdata);
@@ -9112,6 +9113,7 @@ static int msm_asoc_machine_probe(struct platform_device *pdev)
if (ret)
goto err;
dev_err(&pdev->dev, "%s: aux init done\n", __func__);
ret = devm_snd_soc_register_card(&pdev->dev, card);
if (ret == -EPROBE_DEFER) {
if (codec_reg_done)

4
techpack/audio/4.0/config/atollauto.conf
View File

@@ -36,7 +36,3 @@ CONFIG_SND_SOC_WCD938X=m
CONFIG_SND_SOC_WCD938X_SLAVE=m
CONFIG_SND_SOC_ATOLL=m
CONFIG_SND_EVENT=m
CONFIG_TDM_DISABLE=m
CONFIG_MI2S_DISABLE=m
CONFIG_AUXPCM_DISABLE=m
CONFIG_DIGITAL_CDC_RSC_MGR=m

6
techpack/audio/4.0/config/atollautoconf.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2019, The Linux Foundation. All rights reserved.
*/
#define CONFIG_PINCTRL_LPI 1
@@ -40,7 +40,3 @@
#define CONFIG_SND_SOC_WCD938X_SLAVE 1
#define CONFIG_SND_SOC_ATOLL 1
#define CONFIG_SND_EVENT 1
#define CONFIG_TDM_DISABLE 1
#define CONFIG_MI2S_DISABLE 1
#define CONFIG_AUXPCM_DISABLE 1
#define CONFIG_DIGITAL_CDC_RSC_MGR 1

8
techpack/audio/4.0/dsp/Kbuild
View File

@@ -138,10 +138,6 @@ ifdef CONFIG_XT_LOGGING
Q6_OBJS += sp_params.o
endif
ifdef CONFIG_SEC_SND_ADAPTATION
Q6_OBJS += q6audio_adaptation.o
endif
ifdef CONFIG_WCD9XXX_CODEC_CORE
Q6_OBJS += audio_slimslave.o
endif
@@ -178,10 +174,6 @@ ifdef CONFIG_VOICE_MHI
Q6_OBJS += voice_mhi.o
endif
ifdef CONFIG_DIGITAL_CDC_RSC_MGR
Q6_OBJS += digital-cdc-rsc-mgr.o
endif
LINUX_INC += -Iinclude/linux
INCS += $(COMMON_INC) \

15
techpack/audio/4.0/dsp/adsp-loader.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2014, 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2014, 2017-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/init.h>
@@ -23,6 +23,7 @@
#define SSR_RESET_CMD 1
#define IMAGE_UNLOAD_CMD 0
#define MAX_FW_IMAGES 4
#define ADSP_FW_NAME_MAX_LENGTH 5
static ssize_t adsp_boot_store(struct kobject *kobj,
struct kobj_attribute *attr,
@@ -324,14 +325,14 @@ static int adsp_loader_probe(struct platform_device *pdev)
{
struct adsp_loader_private *priv = NULL;
struct nvmem_cell *cell;
size_t len;
ssize_t len;
u32 *buf;
const char **adsp_fw_name_array = NULL;
int adsp_fw_cnt;
u32* adsp_fw_bit_values = NULL;
int i;
int fw_name_size;
u32 adsp_var_idx = 0;
u32 adsp_var_idx;
int ret = 0;
ret = adsp_loader_init_sysfs(pdev);
@@ -353,13 +354,7 @@ static int adsp_loader_probe(struct platform_device *pdev)
dev_dbg(&pdev->dev, "%s: FAILED to read nvmem cell \n", __func__);
goto wqueue;
}
if (len <= 0 || len > sizeof(u32)) {
dev_dbg(&pdev->dev, "%s: nvmem cell length out of range: %d\n",
__func__, len);
kfree(buf);
goto wqueue;
}
memcpy(&adsp_var_idx, buf, len);
adsp_var_idx = (*buf);
kfree(buf);
/* Get count of fw images */

25
techpack/audio/4.0/dsp/audio_cal_utils.c
View File

@@ -10,8 +10,6 @@
#include <linux/mutex.h>
#include <dsp/audio_cal_utils.h>
struct mutex cal_lock;
static int unmap_memory(struct cal_type_data *cal_type,
struct cal_block_data *cal_block);
@@ -940,9 +938,7 @@ int cal_utils_dealloc_cal(size_t data_size, void *data,
if (ret < 0)
goto err;
mutex_lock(&cal_lock);
delete_cal_block(cal_block);
mutex_unlock(&cal_lock);
err:
mutex_unlock(&cal_type->lock);
done:
@@ -1057,11 +1053,6 @@ void cal_utils_mark_cal_used(struct cal_block_data *cal_block)
}
EXPORT_SYMBOL(cal_utils_mark_cal_used);
int __init cal_utils_init(void)
{
mutex_init(&cal_lock);
return 0;
}
/**
* cal_utils_is_cal_stale
*
@@ -1071,19 +1062,9 @@ int __init cal_utils_init(void)
*/
bool cal_utils_is_cal_stale(struct cal_block_data *cal_block)
{
bool ret = false;
if ((cal_block) && (cal_block->cal_stale))
return true;
mutex_lock(&cal_lock);
if (!cal_block) {
pr_err("%s: cal_block is Null", __func__);
goto unlock;
}
if (cal_block->cal_stale)
ret = true;
unlock:
mutex_unlock(&cal_lock);
return ret;
return false;
}
EXPORT_SYMBOL(cal_utils_is_cal_stale);

1
techpack/audio/4.0/dsp/audio_calibration.c
View File

@@ -591,7 +591,6 @@ int __init audio_cal_init(void)
pr_debug("%s\n", __func__);
cal_utils_init();
memset(&audio_cal, 0, sizeof(audio_cal));
mutex_init(&audio_cal.common_lock);
for (; i < MAX_CAL_TYPES; i++) {

3
techpack/audio/4.0/dsp/codecs/amrwb_in.c
View File

@@ -152,11 +152,10 @@ static long amrwb_in_ioctl(struct file *file,
}
case AUDIO_GET_AMRWB_ENC_CONFIG: {
if (copy_to_user((void *)arg, audio->enc_cfg,
sizeof(struct msm_audio_amrwb_enc_config))) {
sizeof(struct msm_audio_amrwb_enc_config)))
pr_err("%s: copy_to_user for AUDIO_GET_AMRWB_ENC_CONFIG failed\n",
__func__);
rc = -EFAULT;
}
break;
}
case AUDIO_SET_AMRWB_ENC_CONFIG: {

7
techpack/audio/4.0/dsp/codecs/audio_alac.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/types.h>
@@ -10,7 +10,6 @@
static struct miscdevice audio_alac_misc;
static struct ws_mgr audio_alac_ws_mgr;
#ifdef CONFIG_DEBUG_FS
static const struct file_operations audio_alac_debug_fops = {
.read = audio_aio_debug_read,
.open = audio_aio_debug_open,
@@ -21,7 +20,7 @@ static struct dentry *config_debugfs_create_file(const char *name, void *data)
return debugfs_create_file(name, S_IFREG | 0444,
NULL, (void *)data, &audio_alac_debug_fops);
}
#endif
static int alac_channel_map(u8 *channel_mapping, uint32_t channels);
static long audio_ioctl_shared(struct file *file, unsigned int cmd,
@@ -324,12 +323,10 @@ static int audio_open(struct inode *inode, struct file *file)
}
snprintf(name, sizeof(name), "msm_alac_%04x", audio->ac->session);
#ifdef CONFIG_DEBUG_FS
audio->dentry = config_debugfs_create_file(name, (void *)audio);
if (IS_ERR_OR_NULL(audio->dentry))
pr_debug("debugfs_create_file failed\n");
#endif
pr_debug("%s:alacdec success mode[%d]session[%d]\n", __func__,
audio->feedback,
audio->ac->session);

6
techpack/audio/4.0/dsp/codecs/audio_ape.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/types.h>
@@ -10,7 +10,6 @@
static struct miscdevice audio_ape_misc;
static struct ws_mgr audio_ape_ws_mgr;
#ifdef CONFIG_DEBUG_FS
static const struct file_operations audio_ape_debug_fops = {
.read = audio_aio_debug_read,
.open = audio_aio_debug_open,
@@ -20,7 +19,6 @@ static struct dentry *config_debugfs_create_file(const char *name, void *data)
return debugfs_create_file(name, S_IFREG | 0444,
NULL, (void *)data, &audio_ape_debug_fops);
}
#endif
static long audio_ioctl_shared(struct file *file, unsigned int cmd,
void *arg)
@@ -307,12 +305,10 @@ static int audio_open(struct inode *inode, struct file *file)
}
snprintf(name, sizeof(name), "msm_ape_%04x", audio->ac->session);
#ifdef CONFIG_DEBUG_FS
audio->dentry = config_debugfs_create_file(name, (void *)audio);
if (IS_ERR_OR_NULL(audio->dentry))
pr_debug("debugfs_create_file failed\n");
#endif
pr_debug("%s:apedec success mode[%d]session[%d]\n", __func__,
audio->feedback,
audio->ac->session);

6
techpack/audio/4.0/dsp/codecs/audio_g711alaw.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2016-2017, 2019-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2016-2017, 2019 The Linux Foundation. All rights reserved.
*/
#include <linux/types.h>
@@ -10,7 +10,6 @@
static struct miscdevice audio_g711alaw_misc;
static struct ws_mgr audio_g711_ws_mgr;
#ifdef CONFIG_DEBUG_FS
static const struct file_operations audio_g711_debug_fops = {
.read = audio_aio_debug_read,
.open = audio_aio_debug_open,
@@ -21,7 +20,6 @@ static struct dentry *config_debugfs_create_file(const char *name, void *data)
return debugfs_create_file(name, S_IFREG | 0444,
NULL, (void *)data, &audio_g711_debug_fops);
}
#endif
static int g711_channel_map(u8 *channel_mapping, uint32_t channels);
@@ -280,12 +278,10 @@ static int audio_open(struct inode *inode, struct file *file)
}
snprintf(name, sizeof(name), "msm_g711_%04x", audio->ac->session);
#ifdef CONFIG_DEBUG_FS
audio->dentry = config_debugfs_create_file(name, (void *)audio);
if (IS_ERR_OR_NULL(audio->dentry))
pr_debug("%s: debugfs_create_file failed\n", __func__);
#endif
pr_debug("%s: g711dec success mode[%d]session[%d]\n", __func__,
audio->feedback,
audio->ac->session);

6
techpack/audio/4.0/dsp/codecs/audio_g711mlaw.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2016-2017, 2019-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2016-2017, 2019 The Linux Foundation. All rights reserved.
*/
#include <linux/types.h>
@@ -10,7 +10,6 @@
static struct miscdevice audio_g711mlaw_misc;
static struct ws_mgr audio_g711_ws_mgr;
#ifdef CONFIG_DEBUG_FS
static const struct file_operations audio_g711_debug_fops = {
.read = audio_aio_debug_read,
.open = audio_aio_debug_open,
@@ -21,7 +20,6 @@ static struct dentry *config_debugfs_create_file(const char *name, void *data)
return debugfs_create_file(name, S_IFREG | 0444,
NULL, (void *)data, &audio_g711_debug_fops);
}
#endif
static int g711_channel_map(u8 *channel_mapping, uint32_t channels);
@@ -279,12 +277,10 @@ static int audio_open(struct inode *inode, struct file *file)
}
snprintf(name, sizeof(name), "msm_g711_%04x", audio->ac->session);
#ifdef CONFIG_DEBUG_FS
audio->dentry = config_debugfs_create_file(name, (void *)audio);
if (IS_ERR_OR_NULL(audio->dentry))
pr_debug("%s: debugfs_create_file failed\n", __func__);
#endif
pr_debug("%s: g711dec success mode[%d]session[%d]\n", __func__,
audio->feedback,
audio->ac->session);

5
techpack/audio/4.0/dsp/codecs/audio_native.c
View File

@@ -1,14 +1,12 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017, 2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017, The Linux Foundation. All rights reserved.
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include "audio_utils.h"
spinlock_t enc_dec_lock;
static int __init audio_native_init(void)
{
aac_in_init();
@@ -33,7 +31,6 @@ static int __init audio_native_init(void)
g711alaw_in_init();
g711mlaw_in_init();
qcelp_in_init();
spin_lock_init(&enc_dec_lock);
return 0;
}

5
techpack/audio/4.0/dsp/codecs/audio_utils.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2010-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2010-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -943,11 +943,8 @@ int audio_in_release(struct inode *inode, struct file *file)
audio_in_disable(audio);
q6asm_audio_client_free(audio->ac);
mutex_unlock(&audio->lock);
spin_lock(&enc_dec_lock);
kfree(audio->enc_cfg);
kfree(audio->codec_cfg);
kfree(audio);
file->private_data = NULL;
spin_unlock(&enc_dec_lock);
return 0;
}

4
techpack/audio/4.0/dsp/codecs/audio_utils_aio.c
View File

@@ -1,6 +1,6 @@
/* Copyright (C) 2008 Google, Inc.
* Copyright (C) 2008 HTC Corporation
* Copyright (c) 2009-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2009-2019, The Linux Foundation. All rights reserved.
*
* This software is licensed under the terms of the GNU General Public
* License version 2, as published by the Free Software Foundation, and
@@ -630,11 +630,9 @@ int audio_aio_release(struct inode *inode, struct file *file)
#ifdef CONFIG_DEBUG_FS
debugfs_remove(audio->dentry);
#endif
spin_lock(&enc_dec_lock);
kfree(audio->codec_cfg);
kfree(audio);
file->private_data = NULL;
spin_unlock(&enc_dec_lock);
mutex_unlock(&lock);
return 0;
}

4
techpack/audio/4.0/dsp/codecs/q6audio_common.h
View File

@@ -1,5 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2012-2014, 2017, 2020 The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2014, 2017 The Linux Foundation. All rights reserved.
*/
@@ -9,7 +9,7 @@
#include <dsp/apr_audio-v2.h>
#include <dsp/q6asm-v2.h>
extern spinlock_t enc_dec_lock;
void q6_audio_cb(uint32_t opcode, uint32_t token,
uint32_t *payload, void *priv);

9
techpack/audio/4.0/dsp/codecs/q6audio_v2.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2013, 2015-2017, 2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2013, 2015-2017, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -21,11 +21,6 @@ void q6asm_in_cb(uint32_t opcode, uint32_t token,
struct q6audio_in *audio = (struct q6audio_in *)priv;
unsigned long flags;
spin_lock(&enc_dec_lock);
if (audio == NULL) {
pr_err("%s: failed to get q6audio value\n", __func__);
goto error;
}
pr_debug("%s:session id %d: opcode[0x%x]\n", __func__,
audio->ac->session, opcode);
@@ -63,8 +58,6 @@ void q6asm_in_cb(uint32_t opcode, uint32_t token,
break;
}
spin_unlock_irqrestore(&audio->dsp_lock, flags);
error:
spin_unlock(&enc_dec_lock);
}
void audio_in_get_dsp_frames(void *priv,

9
techpack/audio/4.0/dsp/codecs/q6audio_v2_aio.c
View File

@@ -1,5 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
@@ -43,11 +43,6 @@ void audio_aio_cb(uint32_t opcode, uint32_t token,
struct q6audio_aio *audio = (struct q6audio_aio *)priv;
union msm_audio_event_payload e_payload;
spin_lock(&enc_dec_lock);
if (audio == NULL) {
pr_err("%s: failed to get q6audio value\n", __func__);
goto error;
}
switch (opcode) {
case ASM_DATA_EVENT_WRITE_DONE_V2:
pr_debug("%s[%pK]:ASM_DATA_EVENT_WRITE_DONE token = 0x%x\n",
@@ -112,8 +107,6 @@ void audio_aio_cb(uint32_t opcode, uint32_t token,
default:
break;
}
error:
spin_unlock(&enc_dec_lock);
}
int extract_meta_out_info(struct q6audio_aio *audio,

1
techpack/audio/4.0/dsp/msm-dts-srs-tm-config.c
View File

@@ -296,7 +296,6 @@ static int reg_ion_mem(void)
&po.kvaddr);
if (rc != 0)
pr_err("%s: failed to allocate memory.\n", __func__);
else
pr_debug("%s: exited dma_buf = %pK, phys_addr = %lu, length = %d, vaddr = %pK, rc = 0x%x\n",
__func__, dma_buf, (long)po.paddr,
(unsigned int)po.size, po.kvaddr, rc);

3
techpack/audio/4.0/dsp/msm_audio_ion_vm.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/init.h>
@@ -564,7 +564,6 @@ static int msm_audio_ion_map_buf(void *handle, dma_addr_t *paddr,
if (rc) {
pr_err("%s: failed to do smmu map, err = %d\n",
__func__, rc);
msm_audio_dma_buf_unmap((struct dma_buf *) handle);
goto err;
}
}

11
techpack/audio/4.0/dsp/q6_init.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2017, 2019-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2017, 2019 The Linux Foundation. All rights reserved.
*/
#include <linux/kernel.h>
@@ -24,20 +24,11 @@ static int __init audio_q6_init(void)
avtimer_init();
msm_mdf_init();
voice_mhi_init();
digital_cdc_rsc_mgr_init();
#ifdef CONFIG_SEC_SND_ADAPTATION
sec_soc_platform_init();
#endif /* CONFIG_SEC_SND_ADAPTATION */
return 0;
}
static void __exit audio_q6_exit(void)
{
digital_cdc_rsc_mgr_exit();
#ifdef CONFIG_SEC_SND_ADAPTATION
sec_soc_platform_exit();
#endif /* CONFIG_SEC_SND_ADAPTATION */
msm_mdf_exit();
avtimer_exit();
audio_slimslave_exit();

21
techpack/audio/4.0/dsp/q6_init.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
*/
#ifndef __Q6_INIT_H__
@@ -43,11 +43,6 @@ static inline void spk_params_exit(void)
}
#endif
#ifdef CONFIG_SEC_SND_ADAPTATION
int sec_soc_platform_init(void);
void sec_soc_platform_exit(void);
#endif /* CONFIG_SEC_SND_ADAPTATION */
void avtimer_exit(void);
void msm_audio_ion_exit(void);
void rtac_exit(void);
@@ -85,19 +80,5 @@ static inline void voice_mhi_exit(void)
return;
}
#endif
#ifdef CONFIG_DIGITAL_CDC_RSC_MGR
void digital_cdc_rsc_mgr_init(void);
void digital_cdc_rsc_mgr_exit(void);
#else
static inline void digital_cdc_rsc_mgr_init(void)
{
}
static inline void digital_cdc_rsc_mgr_exit(void)
{
}
#endif /* CONFIG_DIGITAL_CDC_RSC_MGR */
#endif

68
techpack/audio/4.0/dsp/q6adm.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/module.h>
#include <linux/slab.h>
@@ -20,9 +20,6 @@
#include <dsp/q6common.h>
#include <ipc/apr.h>
#include "adsp_err.h"
#ifdef CONFIG_SEC_SND_ADAPTATION
#include <dsp/sec_adaptation.h>
#endif /* CONFIG_SEC_SND_ADAPTATION */
#define TIMEOUT_MS 1000
@@ -2995,11 +2992,9 @@ int adm_open(int port_id, int path, int rate, int channel_mode, int topology,
int param_size;
int num_ec_ref_rx_chans = this_adm.num_ec_ref_rx_chans;
pr_info("%s:port %#x path:%d rate:%d mode:%d perf_mode:%d,topo_id %d\n",
pr_debug("%s:port %#x path:%d rate:%d mode:%d perf_mode:%d,topo_id %d\n",
__func__, port_id, path, rate, channel_mode, perf_mode,
topology);
pr_info("%s:bit_width:%d app_type:%#x acdb_id:%d\n",
__func__, bit_width, app_type, acdb_id);
port_id = q6audio_convert_virtual_to_portid(port_id);
port_idx = adm_validate_and_get_port_index(port_id);
@@ -3064,18 +3059,6 @@ int adm_open(int port_id, int path, int rate, int channel_mode, int topology,
rate = 16000;
}
#ifdef CONFIG_SEC_SND_ADAPTATION
if ((topology == VPM_TX_SM_LVVEFQ_COPP_TOPOLOGY) ||
(topology == VPM_TX_DM_LVVEFQ_COPP_TOPOLOGY) ||
(topology == VPM_TX_SM_LVSAFQ_COPP_TOPOLOGY) ||
(topology == VPM_TX_DM_LVSAFQ_COPP_TOPOLOGY) ||
(topology == VOICE_TX_DIAMONDVOICE_FVSAM_SM) ||
(topology == VOICE_TX_DIAMONDVOICE_FVSAM_DM) ||
(topology == VOICE_TX_DIAMONDVOICE_FVSAM_QM) ||
(topology == VOICE_TX_DIAMONDVOICE_FRSAM_DM))
rate = 16000;
#endif /* CONFIG_SEC_SND_ADAPTATION */
if (topology == FFECNS_TOPOLOGY) {
this_adm.ffecns_port_id = port_id;
pr_debug("%s: ffecns port id =%x\n", __func__,
@@ -3389,7 +3372,7 @@ int adm_open(int port_id, int path, int rate, int channel_mode, int topology,
ret = wait_event_timeout(this_adm.copp.wait[port_idx][copp_idx],
atomic_read(&this_adm.copp.stat
[port_idx][copp_idx]) >= 0,
msecs_to_jiffies(2 * TIMEOUT_MS));
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: ADM open timedout for port_id: 0x%x for [0x%x]\n",
__func__, tmp_port, port_id);
@@ -3815,7 +3798,7 @@ int adm_close(int port_id, int perf_mode, int copp_idx)
int ret = 0, port_idx;
int copp_id = RESET_COPP_ID;
pr_info("%s: port_id=0x%x perf_mode: %d copp_idx: %d\n", __func__,
pr_debug("%s: port_id=0x%x perf_mode: %d copp_idx: %d\n", __func__,
port_id, perf_mode, copp_idx);
port_id = q6audio_convert_virtual_to_portid(port_id);
@@ -4585,49 +4568,6 @@ int adm_set_ffecns_effect(int effect)
}
EXPORT_SYMBOL(adm_set_ffecns_effect);
/**
* adm_set_ffecns_freeze_event -
* command to set event for ffecns module
*
* @event: send ffecns freeze event true or false
*
* Returns 0 on success or error on failure
*/
int adm_set_ffecns_freeze_event(bool ffecns_freeze_event)
{
struct ffv_spf_freeze_param_t ffv_param;
struct param_hdr_v3 param_hdr;
int rc = 0;
int copp_idx = 0;
memset(&param_hdr, 0, sizeof(param_hdr));
memset(&ffv_param, 0, sizeof(ffv_param));
ffv_param.freeze = ffecns_freeze_event ? 1 : 0;
ffv_param.source_id = 0; /*default value*/
copp_idx = adm_get_default_copp_idx(this_adm.ffecns_port_id);
if ((copp_idx < 0) || (copp_idx >= MAX_COPPS_PER_PORT)) {
pr_err("%s, no active copp to query rms copp_idx:%d\n",
__func__, copp_idx);
return -EINVAL;
}
param_hdr.module_id = FFECNS_MODULE_ID;
param_hdr.instance_id = INSTANCE_ID_0;
param_hdr.param_id = PARAM_ID_FFV_SPF_FREEZE;
param_hdr.param_size = sizeof(ffv_param);
rc = adm_pack_and_set_one_pp_param(this_adm.ffecns_port_id, copp_idx,
param_hdr, (uint8_t *) &ffv_param);
if (rc)
pr_err("%s: Failed to set ffecns imc event, err %d\n",
__func__, rc);
return rc;
}
EXPORT_SYMBOL(adm_set_ffecns_freeze_event);
/**
* adm_param_enable -
* command to send params to ADM for given module

1099
techpack/audio/4.0/dsp/q6afe.c
View File

File diff suppressed because it is too large Load Diff

130
techpack/audio/4.0/dsp/q6asm.c
View File

@@ -1,5 +1,5 @@
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
* Author: Brian Swetland <swetland@google.com>
*
* This software is licensed under the terms of the GNU General Public
@@ -144,6 +144,56 @@ struct generic_get_data_ {
};
static struct generic_get_data_ *generic_get_data;
#ifdef CONFIG_DEBUG_FS
#define OUT_BUFFER_SIZE 56
#define IN_BUFFER_SIZE 24
static struct timeval out_cold_tv;
static struct timeval out_warm_tv;
static struct timeval out_cont_tv;
static struct timeval in_cont_tv;
static long out_enable_flag;
static long in_enable_flag;
static struct dentry *out_dentry;
static struct dentry *in_dentry;
static int in_cont_index;
/*This var is used to keep track of first write done for cold output latency */
static int out_cold_index;
static char *out_buffer;
static char *in_buffer;
static uint32_t adsp_reg_event_opcode[] = {
ASM_STREAM_CMD_REGISTER_PP_EVENTS,
ASM_STREAM_CMD_REGISTER_ENCDEC_EVENTS,
ASM_STREAM_CMD_REGISTER_IEC_61937_FMT_UPDATE };
static uint32_t adsp_raise_event_opcode[] = {
ASM_STREAM_PP_EVENT,
ASM_STREAM_CMD_ENCDEC_EVENTS,
ASM_IEC_61937_MEDIA_FMT_EVENT };
static int is_adsp_reg_event(uint32_t cmd)
{
int i;
for (i = 0; i < ARRAY_SIZE(adsp_reg_event_opcode); i++) {
if (cmd == adsp_reg_event_opcode[i])
return i;
}
return -EINVAL;
}
static int is_adsp_raise_event(uint32_t cmd)
{
int i;
for (i = 0; i < ARRAY_SIZE(adsp_raise_event_opcode); i++) {
if (cmd == adsp_raise_event_opcode[i])
return i;
}
return -EINVAL;
}
static inline void q6asm_set_flag_in_token(union asm_token_struct *asm_token,
int flag, int flag_offset)
{
@@ -226,63 +276,6 @@ uint8_t q6asm_get_stream_id_from_token(uint32_t token)
}
EXPORT_SYMBOL(q6asm_get_stream_id_from_token);
static uint32_t adsp_reg_event_opcode[] = {
ASM_STREAM_CMD_REGISTER_PP_EVENTS,
ASM_STREAM_CMD_REGISTER_ENCDEC_EVENTS,
ASM_STREAM_CMD_REGISTER_IEC_61937_FMT_UPDATE };
static int is_adsp_reg_event(uint32_t cmd)
{
int i;
for (i = 0; i < ARRAY_SIZE(adsp_reg_event_opcode); i++) {
if (cmd == adsp_reg_event_opcode[i])
return i;
}
return -EINVAL;
}
static uint32_t adsp_raise_event_opcode[] = {
ASM_STREAM_PP_EVENT,
ASM_STREAM_CMD_ENCDEC_EVENTS,
ASM_IEC_61937_MEDIA_FMT_EVENT };
static int is_adsp_raise_event(uint32_t cmd)
{
int i;
for (i = 0; i < ARRAY_SIZE(adsp_raise_event_opcode); i++) {
if (cmd == adsp_raise_event_opcode[i])
return i;
}
return -EINVAL;
}
#ifdef CONFIG_SEC_SND_ADAPTATION
struct audio_session *q6asm_get_audio_session(void)
{
return session;
}
#endif /* CONFIG_SEC_SND_ADAPTATION */
#ifdef CONFIG_DEBUG_FS
#define OUT_BUFFER_SIZE 56
#define IN_BUFFER_SIZE 24
static struct timeval out_cold_tv;
static struct timeval out_warm_tv;
static struct timeval out_cont_tv;
static struct timeval in_cont_tv;
static long out_enable_flag;
static long in_enable_flag;
static struct dentry *out_dentry;
static struct dentry *in_dentry;
static int in_cont_index;
/*This var is used to keep track of first write done for cold output latency */
static int out_cold_index;
static char *out_buffer;
static char *in_buffer;
static int audio_output_latency_dbgfs_open(struct inode *inode,
struct file *file)
{
@@ -2558,7 +2551,7 @@ void *q6asm_is_cpu_buf_avail(int dir, struct audio_client *ac, uint32_t *size,
/* To make it more robust, we could loop and get the
* next avail buf, its risky though
*/
pr_debug("%s: Next buf idx[0x%x] not available, dir[%d]\n",
pr_err("%s: Next buf idx[0x%x] not available, dir[%d]\n",
__func__, idx, dir);
mutex_unlock(&port->lock);
return NULL;
@@ -3160,7 +3153,7 @@ static int __q6asm_open_read(struct audio_client *ac,
pr_err("%s: AC APR handle NULL\n", __func__);
return -EINVAL;
}
pr_info("%s: session[%d]\n", __func__, ac->session);
pr_debug("%s: session[%d]\n", __func__, ac->session);
q6asm_add_hdr(ac, &open.hdr, sizeof(open), TRUE);
atomic_set(&ac->cmd_state, -1);
@@ -3477,7 +3470,7 @@ static int __q6asm_open_write(struct audio_client *ac, uint32_t format,
return -EINVAL;
}
pr_info("%s: session[%d] wr_format[0x%x]\n",
dev_vdbg(ac->dev, "%s: session[%d] wr_format[0x%x]\n",
__func__, ac->session, format);
q6asm_stream_add_hdr(ac, &open.hdr, sizeof(open), TRUE, stream_id);
@@ -10913,25 +10906,14 @@ EXPORT_SYMBOL(q6asm_get_path_delay);
int q6asm_get_apr_service_id(int session_id)
{
int service_id;
pr_debug("%s:\n", __func__);
if (session_id <= 0 || session_id > ASM_ACTIVE_STREAMS_ALLOWED) {
pr_err("%s: invalid session_id = %d\n", __func__, session_id);
return -EINVAL;
}
mutex_lock(&session[session_id].mutex_lock_per_session);
if (session[session_id].ac != NULL)
if ((session[session_id].ac)->apr != NULL) {
service_id = ((struct apr_svc *)
(session[session_id].ac)->apr)->id;
mutex_unlock(
&session[session_id].mutex_lock_per_session);
return service_id;
}
mutex_unlock(&session[session_id].mutex_lock_per_session);
return -EINVAL;
return ((struct apr_svc *)(session[session_id].ac)->apr)->id;
}
uint8_t q6asm_get_asm_stream_id(int session_id)

12
techpack/audio/4.0/dsp/q6audio-v2.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
@@ -385,10 +385,6 @@ int q6audio_get_port_index(u16 port_id)
return IDX_AFE_PORT_ID_RX_CODEC_DMA_RX_6;
case AFE_PORT_ID_RX_CODEC_DMA_RX_7:
return IDX_AFE_PORT_ID_RX_CODEC_DMA_RX_7;
case RT_PROXY_PORT_002_RX:
return IDX_RT_PROXY_PORT_002_RX;
case RT_PROXY_PORT_002_TX:
return IDX_RT_PROXY_PORT_002_TX;
default: return -EINVAL;
}
}
@@ -771,10 +767,6 @@ int q6audio_get_port_id(u16 port_id)
return AFE_PORT_ID_RX_CODEC_DMA_RX_6;
case AFE_PORT_ID_RX_CODEC_DMA_RX_7:
return AFE_PORT_ID_RX_CODEC_DMA_RX_7;
case RT_PROXY_PORT_002_RX:
return RT_PROXY_PORT_002_RX;
case RT_PROXY_PORT_002_TX:
return RT_PROXY_PORT_002_TX;
default:
pr_warn("%s: Invalid port_id %d\n", __func__, port_id);
return -EINVAL;
@@ -1204,8 +1196,6 @@ int q6audio_validate_port(u16 port_id)
case AFE_PORT_ID_TX_CODEC_DMA_TX_5:
case AFE_PORT_ID_RX_CODEC_DMA_RX_6:
case AFE_PORT_ID_RX_CODEC_DMA_RX_7:
case RT_PROXY_PORT_002_RX:
case RT_PROXY_PORT_002_TX:
{
ret = 0;
break;

9
techpack/audio/4.0/dsp/q6core.c
View File

@@ -502,7 +502,6 @@ static int q6core_send_get_avcs_fwk_ver_cmd(void)
struct apr_hdr avcs_ver_cmd;
int ret;
mutex_lock(&q6core_lcl.cmd_lock);
avcs_ver_cmd.hdr_field =
APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD, APR_HDR_LEN(APR_HDR_SIZE),
APR_PKT_VER);
@@ -549,7 +548,6 @@ static int q6core_send_get_avcs_fwk_ver_cmd(void)
ret = 0;
done:
mutex_unlock(&q6core_lcl.cmd_lock);
return ret;
}
@@ -1430,16 +1428,14 @@ int q6core_map_mdf_shared_memory(uint32_t map_handle, uint64_t *buf_add,
int i = 0;
int cmd_size = 0;
mutex_lock(&q6core_lcl.cmd_lock);
cmd_size = sizeof(struct avs_cmd_map_mdf_shared_memory)
+ sizeof(struct avs_shared_map_region_payload)
* bufcnt;
mmap_region_cmd = kzalloc(cmd_size, GFP_KERNEL);
if (mmap_region_cmd == NULL) {
mutex_unlock(&q6core_lcl.cmd_lock);
if (mmap_region_cmd == NULL)
return -ENOMEM;
}
mmap_regions = (struct avs_cmd_map_mdf_shared_memory *)mmap_region_cmd;
mmap_regions->hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE),
@@ -1506,7 +1502,6 @@ int q6core_map_mdf_shared_memory(uint32_t map_handle, uint64_t *buf_add,
done:
kfree(mmap_region_cmd);
mutex_unlock(&q6core_lcl.cmd_lock);
return ret;
}

2
techpack/audio/4.0/dsp/q6lsm.c
View File

@@ -1973,7 +1973,7 @@ int q6lsm_snd_model_buf_alloc(struct lsm_client *client, size_t len,
size_t total_mem = 0;
struct lsm_sound_model *sm = NULL;
if (!client)
if (!client || len <= LSM_ALIGN_BOUNDARY)
return rc;
pr_debug("%s:Snd Model len = %zd, stage idx %d\n",

168
techpack/audio/4.0/dsp/q6voice.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/slab.h>
#include <linux/kthread.h>
@@ -24,10 +24,6 @@
#include "adsp_err.h"
#include <dsp/voice_mhi.h>
#ifdef CONFIG_SEC_SND_ADAPTATION
#include <dsp/sec_adaptation.h>
#endif /* CONFIG_SEC_SND_ADAPTATION */
#define TIMEOUT_MS 300
@@ -114,10 +110,6 @@ static int32_t qdsp_cvp_callback(struct apr_client_data *data, void *priv);
static int voice_send_set_pp_enable_cmd(
struct voice_data *v, struct module_instance_info mod_inst_info,
int enable);
static int voice_send_cvp_ecns_enable_cmd(struct voice_data *v,
uint32_t module_id, int enable);
static int is_cal_memory_allocated(void);
static bool is_cvd_version_queried(void);
static int is_voip_memory_allocated(void);
@@ -155,13 +147,6 @@ static int voice_pack_and_set_cvs_ui_property(struct voice_data *v,
struct param_hdr_v3 param_hdr,
u8 *param_data);
#ifdef CONFIG_SEC_SND_ADAPTATION
struct common_data *voice_get_common_data(void)
{
return &common;
}
#endif /* CONFIG_SEC_SND_ADAPTATION */
static void voice_itr_init(struct voice_session_itr *itr,
u32 session_id)
{
@@ -559,7 +544,6 @@ static bool is_sub1_vsid(u32 session_id)
case VOLTE_SESSION_VSID:
case VOWLAN_SESSION_VSID:
case VOICEMMODE1_VSID:
case VOIP_SESSION_VSID:
ret = true;
break;
default:
@@ -1285,6 +1269,7 @@ static int voice_unmap_cal_block(struct voice_data *v, int cal_index)
goto unlock;
}
mutex_lock(&common.common_lock);
result = voice_send_mvm_unmap_memory_physical_cmd(
v, cal_block->map_data.q6map_handle);
if (result)
@@ -1292,6 +1277,7 @@ static int voice_unmap_cal_block(struct voice_data *v, int cal_index)
__func__, v->session_id, result);
cal_block->map_data.q6map_handle = 0;
mutex_unlock(&common.common_lock);
unlock:
mutex_unlock(&common.cal_data[cal_index]->lock);
done:
@@ -1558,124 +1544,6 @@ fail:
return ret;
}
static int voice_send_cvp_ecns_enable_cmd(struct voice_data *v,
uint32_t module_id, int enable)
{
int ret;
struct cvp_set_channel_ecns_cmd_v2 cvp_set_ch_ecns_cmd;
void *apr_cvp;
u16 cvp_handle;
struct vss_icommon_param_data_ecns_t *cvp_config_param_data =
&cvp_set_ch_ecns_cmd.
cvp_set_ecns.param_data;
if (v == NULL) {
pr_err("%s: v is NULL\n", __func__);
ret = -EINVAL;
goto done;
}
apr_cvp = common.apr_q6_cvp;
if (!apr_cvp) {
pr_err("%s: apr_cvp is NULL\n", __func__);
ret = -EINVAL;
goto done;
}
cvp_handle = voice_get_cvp_handle(v);
memset(&cvp_set_ch_ecns_cmd, 0,
sizeof(cvp_set_ch_ecns_cmd));
cvp_set_ch_ecns_cmd.hdr.hdr_field =
APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE),
APR_PKT_VER);
cvp_set_ch_ecns_cmd.hdr.pkt_size =
APR_PKT_SIZE(APR_HDR_SIZE,
sizeof(cvp_set_ch_ecns_cmd) - APR_HDR_SIZE);
cvp_set_ch_ecns_cmd.hdr.src_svc = 0;
cvp_set_ch_ecns_cmd.hdr.src_domain = APR_DOMAIN_APPS;
cvp_set_ch_ecns_cmd.hdr.src_port =
voice_get_idx_for_session(v->session_id);
cvp_set_ch_ecns_cmd.hdr.dest_svc = 0;
cvp_set_ch_ecns_cmd.hdr.dest_domain = APR_DOMAIN_ADSP;
cvp_set_ch_ecns_cmd.hdr.dest_port = cvp_handle;
cvp_set_ch_ecns_cmd.hdr.token = 0;
cvp_set_ch_ecns_cmd.hdr.opcode = VSS_ICOMMON_CMD_SET_PARAM_V2;
cvp_set_ch_ecns_cmd.cvp_set_ecns.mem_size =
sizeof(struct vss_icommon_param_data_ecns_t);
cvp_config_param_data->module_id = module_id;
cvp_config_param_data->param_id = VOICE_PARAM_MOD_ENABLE;
cvp_config_param_data->param_size = MOD_ENABLE_PARAM_LEN;
cvp_config_param_data->reserved = 0;
cvp_config_param_data->enable = enable;
v->cvp_state = CMD_STATUS_FAIL;
v->async_err = 0;
ret = apr_send_pkt(apr_cvp, (uint32_t *)&cvp_set_ch_ecns_cmd);
if (ret < 0) {
pr_err("%s: Failed to send VSS_ICOMMON_CMD_SET_PARAM_V2 %d\n",
__func__, ret);
goto done;
}
ret = wait_event_timeout(v->cvp_wait,
(v->cvp_state == CMD_STATUS_SUCCESS),
msecs_to_jiffies(TIMEOUT_MS));
if (!ret) {
pr_err("%s: wait_event timeout\n", __func__);
ret = -ETIMEDOUT;
goto done;
}
if (v->async_err > 0) {
pr_err("%s: DSP returned error[%s] handle = %d\n", __func__,
adsp_err_get_err_str(v->async_err), cvp_handle);
ret = adsp_err_get_lnx_err_code(v->async_err);
goto done;
}
ret = 0;
done:
return ret;
}
/**
* voc_set_ecns_enable -
* Command to set ECNS for voice module
*
* @session_id: voice session ID to send this command
* @module_id: voice module id
* @enable: enable/disable flag
*
* Returns 0 on success or error on failure
*/
int voc_set_ecns_enable(uint32_t session_id, uint32_t module_id,
uint32_t enable)
{
struct voice_data *v = voice_get_session(session_id);
int ret = 0;
if (v == NULL) {
pr_err("%s: invalid session_id 0x%x\n", __func__, session_id);
return -EINVAL;
}
mutex_lock(&v->lock);
v->ecns_enable = enable;
v->ecns_module_id = module_id;
if (is_voc_state_active(v->voc_state))
ret = voice_send_cvp_ecns_enable_cmd(v,
v->ecns_module_id, v->ecns_enable);
mutex_unlock(&v->lock);
return ret;
}
EXPORT_SYMBOL(voc_set_ecns_enable);
static int voice_send_set_pp_enable_cmd(
struct voice_data *v, struct module_instance_info mod_inst_info,
int enable)
@@ -3219,7 +3087,7 @@ static int voice_send_cvp_register_cal_cmd(struct voice_data *v)
cal_block->cal_info)->tx_acdb_id;
v->dev_rx.dev_id = ((struct audio_cal_info_vocproc *)
cal_block->cal_info)->rx_acdb_id;
pr_info("%s: %s: Tx acdb id = %d and Rx acdb id = %d", __func__,
pr_debug("%s: %s: Tx acdb id = %d and Rx acdb id = %d", __func__,
voc_get_session_name(v->session_id), v->dev_tx.dev_id,
v->dev_rx.dev_id);
@@ -4307,7 +4175,6 @@ static int voice_send_cvp_mfc_config_v2(struct voice_data *v)
struct cvp_set_mfc_config_cmd_v2 cvp_set_mfc_config_cmd;
void *apr_cvp;
u16 cvp_handle;
uint8_t ch_idx;
struct vss_icommon_param_data_mfc_config_v2_t *cvp_config_param_data =
&cvp_set_mfc_config_cmd.cvp_set_mfc_param_v2.param_data;
struct vss_param_mfc_config_info_t *mfc_config_info =
@@ -4356,15 +4223,9 @@ static int voice_send_cvp_mfc_config_v2(struct voice_data *v)
mfc_config_info->num_channels = v->dev_rx.no_of_channels;
mfc_config_info->bits_per_sample = 16;
mfc_config_info->sample_rate = v->dev_rx.sample_rate;
/*
* Do not use memcpy here as channel_type in mfc_config structure is a
* uint16_t array while channel_mapping array of device is of uint8_t
*/
for (ch_idx = 0; ch_idx < VSS_NUM_CHANNELS_MAX; ch_idx++) {
mfc_config_info->channel_type[ch_idx] =
v->dev_rx.channel_mapping[ch_idx];
}
memcpy(&mfc_config_info->channel_type,
v->dev_rx.channel_mapping,
VSS_NUM_CHANNELS_MAX * sizeof(uint8_t));
v->cvp_state = CMD_STATUS_FAIL;
v->async_err = 0;
@@ -4559,10 +4420,6 @@ static int voice_setup_vocproc(struct voice_data *v)
if (v->dtmf_rx_detect_en)
voice_send_dtmf_rx_detection_cmd(v, v->dtmf_rx_detect_en);
if (v->ecns_enable)
voice_send_cvp_ecns_enable_cmd(v, v->ecns_module_id,
v->ecns_enable);
if (v->hd_enable)
voice_send_hd_cmd(v, v->hd_enable);
@@ -5219,9 +5076,6 @@ static int voice_destroy_vocproc(struct voice_data *v)
if (v->dtmf_rx_detect_en)
voice_send_dtmf_rx_detection_cmd(v, 0);
if (v->ecns_enable)
voice_send_cvp_ecns_enable_cmd(v, v->ecns_module_id, 0);
/* detach VOCPROC and wait for response from mvm */
mvm_d_vocproc_cmd.hdr.hdr_field = APR_HDR_FIELD(APR_MSG_TYPE_SEQ_CMD,
APR_HDR_LEN(APR_HDR_SIZE),
@@ -6994,10 +6848,6 @@ int voc_end_voice_call(uint32_t session_id)
pr_debug("%s: VOC_STATE: %d\n", __func__, v->voc_state);
#ifdef CONFIG_SEC_SND_ADAPTATION
voice_sec_loopback_end_cmd(session_id);
#endif /* CONFIG_SEC_SND_ADAPTATION */
ret = voice_destroy_vocproc(v);
if (ret < 0)
pr_err("%s: destroy voice failed\n", __func__);
@@ -7408,10 +7258,6 @@ int voc_start_voice_call(uint32_t session_id)
goto fail;
}
#ifdef CONFIG_SEC_SND_ADAPTATION
voice_sec_loopback_start_cmd(session_id);
#endif /* CONFIG_SEC_SND_ADAPTATION */
v->voc_state = VOC_RUN;
} else {
pr_err("%s: Error: Start voice called in state %d\n",

21
techpack/audio/4.0/include/asoc/wcd-mbhc-v2.h
View File

@@ -136,13 +136,10 @@ do { \
#define GND_MIC_SWAP_THRESHOLD 4
#define GND_MIC_USBC_SWAP_THRESHOLD 2
#define WCD_FAKE_REMOVAL_MIN_PERIOD_MS 100
#define HS_VREF_MIN_VAL 1300
#define HS_VREF_MIN_VAL 1400
#define FW_READ_ATTEMPTS 15
#define FW_READ_TIMEOUT 4000000
#define FAKE_REM_RETRY_ATTEMPTS 3
#define HPHL_CROSS_CONN_THRESHOLD 100
#define HPHR_CROSS_CONN_THRESHOLD 100
#define MAX_IMPED 60000
#define WCD_MBHC_BTN_PRESS_COMPL_TIMEOUT_MS 50
#define ANC_DETECT_RETRY_CNT 7
@@ -216,8 +213,6 @@ enum wcd_mbhc_register_function {
WCD_MBHC_ADC_MODE,
WCD_MBHC_DETECTION_DONE,
WCD_MBHC_ELECT_ISRC_EN,
WCD_MBHC_EN_SURGE_PROTECTION_HPHL,
WCD_MBHC_EN_SURGE_PROTECTION_HPHR,
WCD_MBHC_REG_FUNC_MAX,
};
@@ -435,7 +430,6 @@ struct wcd_mbhc_config {
bool enable_anc_mic_detect;
u32 enable_usbc_analog;
bool moisture_duty_cycle_en;
bool mbhc_spl_headset;
};
struct wcd_mbhc_intr {
@@ -457,8 +451,6 @@ struct wcd_mbhc_register {
};
struct wcd_mbhc_cb {
void (*update_cross_conn_thr)
(struct wcd_mbhc *mbhc);
void (*bcs_enable)
(struct wcd_mbhc *mbhc, bool bcs_enable);
int (*enable_mb_source)(struct wcd_mbhc *mbhc, bool turn_on);
@@ -543,8 +535,6 @@ struct wcd_mbhc {
u32 moist_vref;
u32 moist_iref;
u32 moist_rref;
u32 hphl_cross_conn_thr;
u32 hphr_cross_conn_thr;
u8 micbias1_cap_mode; /* track ext cap setting */
u8 micbias2_cap_mode; /* track ext cap setting */
bool hs_detect_work_stop;
@@ -603,15 +593,6 @@ struct wcd_mbhc {
bool force_linein;
struct device_node *fsa_np;
struct notifier_block fsa_nb;
bool pullup_enable;
#if defined(CONFIG_SND_SOC_WCD_MBHC_SLOW_DET)
bool slow_insertion;
#endif
#ifdef CONFIG_SND_SOC_IMPED_SENSING
int default_impedance_offset;
int impedance_offset;
#endif
};
void wcd_mbhc_find_plug_and_report(struct wcd_mbhc *mbhc,

51
techpack/audio/4.0/include/dsp/apr_audio-v2.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
@@ -849,7 +849,6 @@ struct audproc_softvolume_params {
*/
#define AUDPROC_MODULE_ID_MFC_EC_REF 0x0001092C
#define PARAM_ID_FFV_SPF_FREEZE 0x00010960
struct adm_cmd_set_pp_params_v5 {
struct apr_hdr hdr;
@@ -1385,7 +1384,7 @@ struct adm_cmd_connect_afe_port_v5 {
#define AFE_PORT_ID_SLIMBUS_RANGE_SIZE 0xA
/* Size of the range of port IDs for real-time proxy ports. */
#define AFE_PORT_ID_RT_PROXY_PORT_RANGE_SIZE 0x4
#define AFE_PORT_ID_RT_PROXY_PORT_RANGE_SIZE 0x2
/* Size of the range of port IDs for pseudoports. */
#define AFE_PORT_ID_PSEUDOPORT_RANGE_SIZE 0x5
@@ -1664,16 +1663,6 @@ struct adm_cmd_connect_afe_port_v5 {
#define AFE_PORT_ID_VOICE2_PLAYBACK_TX 0x8002
#define AFE_PORT_ID_VOICE_PLAYBACK_TX 0x8005
/*
* Proxyport used for voice call data processing.
* In cases like call-screening feature, where user can communicate
* with caller with the help of "call screen" mode, and without
* connecting the call with any HW input/output devices in the phon,
* voice call can use Pseudo port to start voice data processing.
*/
#define RT_PROXY_PORT_002_TX 0x2003
#define RT_PROXY_PORT_002_RX 0x2002
#define AFE_PORT_ID_PRIMARY_TDM_RX \
(AFE_PORT_ID_TDM_PORT_RANGE_START + 0x00)
#define AFE_PORT_ID_PRIMARY_TDM_RX_1 \
@@ -4073,12 +4062,6 @@ struct afe_id_aptx_adaptive_enc_init
*/
#define AFE_ENCODER_PARAM_ID_PACKETIZER_ID 0x0001322E
/*
* MI2S packetizer id for #AVS_MODULE_ID_ENCODER module.
* Used when I2S interface is selected.
*/
#define AFE_MODULE_ID_PACKETIZER_MI2S 0x1000F101
/*
* Encoder config block parameter for the #AVS_MODULE_ID_ENCODER module.
* This parameter may be set runtime.
@@ -4209,7 +4192,6 @@ struct aptx_channel_mode_param_t {
* @table{weak__asm__sbc__enc__cfg__t}
*/
#define ASM_MEDIA_FMT_SBC 0x00010BF2
#define ASM_MEDIA_FMT_SBC_SS 0x00010BF5
/* SBC channel Mono mode.*/
#define ASM_MEDIA_FMT_SBC_CHANNEL_MODE_MONO 1
@@ -4289,11 +4271,6 @@ struct asm_sbc_enc_cfg_t {
uint32_t sample_rate;
};
struct asm_ss_sbc_enc_cfg_t {
struct asm_sbc_enc_cfg_t custom_config;
struct afe_abr_enc_cfg_t abr_config;
} __packed;
#define ASM_MEDIA_FMT_AAC_AOT_LC 2
#define ASM_MEDIA_FMT_AAC_AOT_SBR 5
#define ASM_MEDIA_FMT_AAC_AOT_PS 29
@@ -4534,22 +4511,6 @@ struct asm_ldac_enc_cfg_t {
struct afe_abr_enc_cfg_t abr_config;
} __packed;
/* FMT ID for SSC */
#define ASM_MEDIA_FMT_SSC 0x00010BF3
struct asm_custom_enc_cfg_ssc_t {
uint32_t sample_rate;
/* Mono or stereo */
uint16_t num_channels;
uint16_t reserved;
/* num_ch == 1, then PCM_CHANNEL_C,
* num_ch == 2, then {PCM_CHANNEL_L, PCM_CHANNEL_R}
*/
uint8_t channel_mapping[8];
uint32_t custom_size;
struct afe_abr_enc_cfg_t abr_config;
} __packed;
struct afe_enc_fmt_id_param_t {
/*
* Supported values:
@@ -4739,14 +4700,12 @@ struct asm_aptx_ad_speech_dec_cfg_t {
union afe_enc_config_data {
struct asm_sbc_enc_cfg_t sbc_config;
struct asm_ss_sbc_enc_cfg_t ss_sbc_config;
struct asm_aac_enc_cfg_t aac_config;
struct asm_custom_enc_cfg_t custom_config;
struct asm_celt_enc_cfg_t celt_config;
struct asm_aptx_enc_cfg_t aptx_config;
struct asm_ldac_enc_cfg_t ldac_config;
struct asm_aptx_ad_enc_cfg_t aptx_ad_config;
struct asm_custom_enc_cfg_ssc_t ssc_config;
struct asm_aptx_ad_speech_enc_cfg_t aptx_ad_speech_config;
};
@@ -4795,8 +4754,6 @@ struct afe_dec_media_fmt_t {
union afe_dec_config_data dec_media_config;
} __packed;
#define AVS_ENCODER_PARAM_ID_ENC_BITRATE 0x0001322D
/*
* Payload of the AVS_ENCODER_PARAM_ID_PACKETIZER_ID parameter.
*/
@@ -6164,10 +6121,6 @@ struct asm_enc_cfg_blk_param_v2 {
} __packed;
struct asm_bitrate_param_t {
u32 enc_bitrate;
} __packed;
struct asm_custom_enc_cfg_t_v2 {
struct apr_hdr hdr;
struct asm_stream_cmd_set_encdec_param encdec;

2
techpack/audio/4.0/include/dsp/audio_cal_utils.h
View File

@@ -95,6 +95,4 @@ int32_t cal_utils_get_cal_type_version(void *cal_type_data);
void cal_utils_mark_cal_used(struct cal_block_data *cal_block);
bool cal_utils_is_cal_stale(struct cal_block_data *cal_block);
int cal_utils_init(void);
#endif

8
techpack/audio/4.0/include/dsp/q6adm-v2.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#ifndef __Q6_ADM_V2_H__
#define __Q6_ADM_V2_H__
@@ -85,11 +85,6 @@ struct msm_pcm_channel_mixer {
bool override_out_ch_map;
};
struct ffv_spf_freeze_param_t {
uint16_t freeze;
uint16_t source_id;
};
int srs_trumedia_open(int port_id, int copp_idx, __s32 srs_tech_id,
void *srs_params);
@@ -226,5 +221,4 @@ int adm_programable_channel_mixer(int port_id, int copp_idx, int session_id,
void msm_dts_srs_acquire_lock(void);
void msm_dts_srs_release_lock(void);
void adm_set_native_mode(int mode);
int adm_set_ffecns_freeze_event(bool ffecns_freeze_event);
#endif /* __Q6_ADM_V2_H__ */

6
techpack/audio/4.0/include/dsp/q6afe-v2.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2012-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2012-2019, The Linux Foundation. All rights reserved.
*/
#ifndef __Q6AFE_V2_H__
#define __Q6AFE_V2_H__
@@ -284,9 +284,6 @@ enum {
/* IDX 208-> 209 */
IDX_AFE_PORT_ID_PRIMARY_META_MI2S_RX,
IDX_AFE_PORT_ID_SECONDARY_META_MI2S_RX,
/* IDX 210-> 211 */
IDX_RT_PROXY_PORT_002_RX,
IDX_RT_PROXY_PORT_002_TX,
AFE_MAX_PORTS
};
@@ -406,7 +403,6 @@ int afe_spk_prot_get_calib_data(struct afe_spkr_prot_get_vi_calib *calib);
int afe_port_stop_nowait(int port_id);
int afe_apply_gain(u16 port_id, u16 gain);
int afe_q6_interface_prepare(void);
int afe_q6_slimbus_update_dyn_bitrate(uint32_t bitrate);
int afe_get_port_type(u16 port_id);
int q6afe_audio_client_buf_alloc_contiguous(unsigned int dir,
struct afe_audio_client *ac,

4
techpack/audio/4.0/include/dsp/q6asm-v2.h
View File

@@ -756,8 +756,4 @@ int q6asm_adjust_session_clock(struct audio_client *ac,
/* Provide default asm channel mapping for given channel count */
int q6asm_map_channels(u8 *channel_mapping, uint32_t channels,
bool use_back_flavor);
#ifdef CONFIG_SEC_SND_ADAPTATION
struct audio_session *q6asm_get_audio_session(void);
#endif /* CONFIG_SEC_SND_ADAPTATION */
#endif /* __Q6_ASM_H__ */

4
techpack/audio/4.0/include/dsp/q6lsm.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2013-2019, The Linux Foundation. All rights reserved.
*/
#ifndef __Q6LSM_H__
#define __Q6LSM_H__
@@ -20,8 +20,6 @@
#define LSM_API_VERSION_V3 3
#define MAX_LSM_SESSIONS 8
typedef void (*lsm_app_cb)(uint32_t opcode, uint32_t token,
uint32_t *payload, uint16_t client_size, void *priv);

57
techpack/audio/4.0/include/dsp/q6voice.h
View File

@@ -312,21 +312,6 @@ struct vss_icommon_param_data_ch_mixer_v2_t {
struct vss_param_channel_mixer_info_t ch_mixer_info;
} __packed;
struct vss_icommon_param_data_ecns_t {
/* Valid ID of the module. */
uint32_t module_id;
/* Valid ID of the parameter. */
uint32_t param_id;
/*
* Data size of the structure relating to the param_id/module_id
* combination in uint8_t bytes.
*/
uint16_t param_size;
/* This field must be set to zero. */
uint16_t reserved;
uint32_t enable;
} __packed;
struct vss_icommon_cmd_set_param_ch_mixer_v2_t {
/*
* Pointer to the unique identifier for an address (physical/virtual).
@@ -353,33 +338,6 @@ struct vss_icommon_cmd_set_param_ch_mixer_v2_t {
struct vss_icommon_param_data_ch_mixer_v2_t param_data;
} __packed;
struct vss_icommon_cmd_set_ecns_enable_t {
/*
* Pointer to the unique identifier for an address (physical/virtual).
*
* If the parameter data payload is within the message payload
* (in-band), set this field to 0. The parameter data begins at the
* specified data payload address.
*
* If the parameter data is out-of-band, this field is the handle to
* the physical address in the shared memory that holds the parameter
* data.
*/
uint32_t mem_handle;
/*
* Location of the parameter data payload.
*
* The payload is an array of vss_icommon_param_data_t. If the
* mem_handle is 0, this field is ignored.
*/
uint64_t mem_address;
/* Size of the parameter data payload in bytes. */
uint32_t mem_size;
struct vss_icommon_param_data_ecns_t param_data;
} __packed;
struct vss_icommon_param_data_mfc_config_v2_t {
/* Valid ID of the module. */
uint32_t module_id;
@@ -851,7 +809,6 @@ struct vss_evt_voice_activity {
#define MODULE_ID_VOICE_MODULE_ST 0x00010EE3
#define VOICE_PARAM_MOD_ENABLE 0x00010E00
#define MOD_ENABLE_PARAM_LEN 4
#define VSS_IPLAYBACK_CMD_START 0x000112BD
/* Start in-call music delivery on the Tx voice path. */
@@ -1722,11 +1679,6 @@ struct cvp_set_vp3_data_cmd {
struct apr_hdr hdr;
} __packed;
struct cvp_set_channel_ecns_cmd_v2 {
struct apr_hdr hdr;
struct vss_icommon_cmd_set_ecns_enable_t cvp_set_ecns;
} __packed;
struct cvp_set_rx_volume_index_cmd {
struct apr_hdr hdr;
struct vss_ivocproc_cmd_set_volume_index_t cvp_set_vol_idx;
@@ -1942,10 +1894,6 @@ struct voice_data {
bool mic_break_status;
struct work_struct voice_mic_break_work;
uint32_t ecns_enable;
uint32_t ecns_module_id;
};
#define MAX_VOC_SESSIONS 8
@@ -2094,8 +2042,6 @@ int voc_get_rx_device_mute(uint32_t session_id);
int voc_set_route_flag(uint32_t session_id, uint8_t path_dir, uint8_t set);
uint8_t voc_get_route_flag(uint32_t session_id, uint8_t path_dir);
bool voc_get_mbd_enable(void);
int voc_set_ecns_enable(uint32_t session_id, uint32_t module_id,
uint32_t enable);
uint8_t voc_set_mbd_enable(bool enable);
int voc_enable_dtmf_rx_detection(uint32_t session_id, uint32_t enable);
void voc_disable_dtmf_det_on_active_sessions(void);
@@ -2146,7 +2092,4 @@ int voc_get_sound_focus(struct sound_focus_param *soundFocusData);
int voc_get_source_tracking(struct source_tracking_param *sourceTrackingData);
int voc_set_afe_sidetone(uint32_t session_id, bool sidetone_enable);
bool voc_get_afe_sidetone(void);
#ifdef CONFIG_SEC_SND_ADAPTATION
struct common_data *voice_get_common_data(void);
#endif /* CONFIG_SEC_SND_ADAPTATION */
#endif

11
techpack/audio/4.0/include/soc/soundwire.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2015-2018, 2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2015-2018, The Linux Foundation. All rights reserved.
*/
#ifndef _LINUX_SOUNDWIRE_H
@@ -10,13 +10,6 @@
#include <linux/mod_devicetable.h>
#include <linux/irqdomain.h>
#define SWR_CLK_RATE_0P6MHZ 600000
#define SWR_CLK_RATE_1P2MHZ 1200000
#define SWR_CLK_RATE_2P4MHZ 2400000
#define SWR_CLK_RATE_4P8MHZ 4800000
#define SWR_CLK_RATE_9P6MHZ 9600000
#define SWR_CLK_RATE_11P2896MHZ 1128960
extern struct bus_type soundwire_type;
/* Soundwire supports max. of 8 channels per port */
@@ -207,7 +200,7 @@ struct swr_device {
struct list_head dev_list;
u8 dev_num;
struct device dev;
u64 addr;
unsigned long addr;
u8 group_id;
struct irq_domain *slave_irq;
bool slave_irq_pending;

1
techpack/audio/4.0/include/soc/swr-wcd.h
View File

@@ -32,7 +32,6 @@ struct swr_mstr_port {
};
#define MCLK_FREQ 9600000
#define MCLK_FREQ_LP 600000
#define MCLK_FREQ_NATIVE 11289600
#if (IS_ENABLED(CONFIG_SOUNDWIRE_WCD_CTRL) || \

8
techpack/audio/4.0/ipc/apr.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2010-2014, 2016-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2010-2014, 2016-2019 The Linux Foundation. All rights reserved.
*/
#include <linux/kernel.h>
@@ -1117,9 +1117,9 @@ static int __init apr_debug_init(void)
}
#else
static int __init apr_debug_init(void)
{
(
return 0;
}
)
#endif
static void apr_cleanup(void)
@@ -1140,9 +1140,7 @@ static void apr_cleanup(void)
mutex_destroy(&client[i][j].svc[k].m_lock);
}
}
#ifdef CONFIG_DEBUG_FS
debugfs_remove(debugfs_apr_debug);
#endif
}
static int apr_probe(struct platform_device *pdev)

8
techpack/audio/4.0/ipc/apr_vm.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2010-2014, 2016-2020 The Linux Foundation. All rights reserved.
* Copyright (c) 2010-2014, 2016-2019 The Linux Foundation. All rights reserved.
*/
#include <linux/kernel.h>
@@ -1308,9 +1308,9 @@ static int __init apr_debug_init(void)
}
#else
static int __init apr_debug_init(void)
{
(
return 0;
}
)
#endif
static void apr_cleanup(void)
@@ -1331,9 +1331,7 @@ static void apr_cleanup(void)
mutex_destroy(&client[i][j].svc[k].m_lock);
}
}
#ifdef CONFIG_DEBUG_FS
debugfs_remove(debugfs_apr_debug);
#endif
}
static int apr_probe(struct platform_device *pdev)

25
techpack/audio/4.0/soc/pinctrl-lpi.c
View File

@@ -1,6 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
*/
#include <linux/gpio.h>
@@ -16,7 +16,6 @@
#include <linux/clk.h>
#include <linux/bitops.h>
#include <soc/snd_event.h>
#include <dsp/digital-cdc-rsc-mgr.h>
#include <linux/pm_runtime.h>
#include <dsp/audio_notifier.h>
@@ -470,7 +469,6 @@ static int lpi_notifier_service_cb(struct notifier_block *this,
unsigned long opcode, void *ptr)
{
static bool initial_boot = true;
struct lpi_gpio_state *state = dev_get_drvdata(lpi_dev);
pr_debug("%s: Service opcode 0x%lx\n", __func__, opcode);
@@ -486,17 +484,6 @@ static int lpi_notifier_service_cb(struct notifier_block *this,
case AUDIO_NOTIFIER_SERVICE_UP:
if (initial_boot)
initial_boot = false;
/* Reset HW votes after SSR */
if (!lpi_dev_up) {
if (state->lpass_core_hw_vote)
digital_cdc_rsc_mgr_hw_vote_reset(
state->lpass_core_hw_vote);
if (state->lpass_audio_hw_vote)
digital_cdc_rsc_mgr_hw_vote_reset(
state->lpass_audio_hw_vote);
}
lpi_dev_up = true;
snd_event_notify(lpi_dev, SND_EVENT_UP);
break;
@@ -510,7 +497,6 @@ int lpi_pinctrl_suspend(struct device *dev)
{
int ret = 0;
trace_printk("%s: system suspend\n", __func__);
dev_dbg(dev, "%s: system suspend\n", __func__);
if ((!pm_runtime_enabled(dev) || !pm_runtime_suspended(dev))) {
@@ -547,7 +533,6 @@ static struct notifier_block service_nb = {
static void lpi_pinctrl_ssr_disable(struct device *dev, void *data)
{
trace_printk("%s: enter\n", __func__);
lpi_dev_up = false;
lpi_pinctrl_suspend(dev);
}
@@ -872,7 +857,6 @@ int lpi_pinctrl_runtime_resume(struct device *dev)
int ret = 0;
struct clk *hw_vote = state->lpass_core_hw_vote;
trace_printk("%s: enter\n", __func__);
if (state->lpass_core_hw_vote == NULL) {
dev_dbg(dev, "%s: Invalid core hw node\n", __func__);
if (state->lpass_audio_hw_vote == NULL) {
@@ -883,7 +867,7 @@ int lpi_pinctrl_runtime_resume(struct device *dev)
}
mutex_lock(&state->core_hw_vote_lock);
ret = digital_cdc_rsc_mgr_hw_vote_enable(hw_vote);
ret = clk_prepare_enable(hw_vote);
if (ret < 0) {
pm_runtime_set_autosuspend_delay(dev,
LPI_AUTO_SUSPEND_DELAY_ERROR);
@@ -898,7 +882,6 @@ int lpi_pinctrl_runtime_resume(struct device *dev)
exit:
mutex_unlock(&state->core_hw_vote_lock);
trace_printk("%s: exit\n", __func__);
return 0;
}
@@ -907,7 +890,6 @@ int lpi_pinctrl_runtime_suspend(struct device *dev)
struct lpi_gpio_state *state = dev_get_drvdata(dev);
struct clk *hw_vote = state->lpass_core_hw_vote;
trace_printk("%s: enter\n", __func__);
if (state->lpass_core_hw_vote == NULL) {
dev_dbg(dev, "%s: Invalid core hw node\n", __func__);
if (state->lpass_audio_hw_vote == NULL) {
@@ -919,11 +901,10 @@ int lpi_pinctrl_runtime_suspend(struct device *dev)
mutex_lock(&state->core_hw_vote_lock);
if (state->core_hw_vote_status) {
digital_cdc_rsc_mgr_hw_vote_disable(hw_vote);
clk_disable_unprepare(hw_vote);
state->core_hw_vote_status = false;
}
mutex_unlock(&state->core_hw_vote_lock);
trace_printk("%s: exit\n", __func__);
return 0;
}

595
techpack/audio/4.0/soc/swr-mstr-ctrl.c
View File

File diff suppressed because it is too large Load Diff

11
techpack/audio/4.0/soc/swr-mstr-ctrl.h
View File

@@ -1,6 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2015-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2015-2019, The Linux Foundation. All rights reserved.
*/
#ifndef _SWR_WCD_CTRL_H
@@ -25,8 +25,7 @@
#define SWR_ROW_48 0
#define SWR_ROW_50 1
#define SWR_ROW_64 3
#define SWR_COL_04 1 /* Cols = 4 */
#define SWR_ROW_64 2
#define SWR_MAX_COL 7 /* Cols = 16 */
#define SWR_MIN_COL 0 /* Cols = 2 */
@@ -43,7 +42,7 @@
#define SWR_MAX_CH_PER_PORT 8
#define SWRM_NUM_AUTO_ENUM_SLAVES 6
#define SWR_MAX_SLAVE_DEVICES 11
enum {
SWR_MSTR_PAUSE,
@@ -82,6 +81,7 @@ struct swrm_mports {
bool port_en;
u8 ch_en;
u8 req_ch;
u8 ch_rate;
u8 offset1;
u8 offset2;
u8 sinterval;
@@ -91,7 +91,6 @@ struct swrm_mports {
u8 blk_pack_mode;
u8 word_length;
u8 lane_ctrl;
u32 ch_rate;
};
struct swrm_port_type {
@@ -125,7 +124,6 @@ struct swr_mstr_ctrl {
struct mutex mlock;
struct mutex reslock;
struct mutex pm_lock;
struct mutex irq_lock;
u32 swrm_base_reg;
char __iomem *swrm_dig_base;
char __iomem *swrm_hctl_reg;
@@ -179,7 +177,6 @@ struct swr_mstr_ctrl {
u32 swr_irq_wakeup_capable;
int hw_core_clk_en;
int aud_core_clk_en;
int clk_src;
#ifdef CONFIG_DEBUG_FS
struct dentry *debugfs_swrm_dent;
struct dentry *debugfs_peek;

1
techpack/audio/4.0/soc/swrm_registers.h
View File

@@ -17,7 +17,6 @@
#define SWRM_COMP_CFG_ENABLE_SHFT 0x0
#define SWRM_COMP_SW_RESET (SWRM_BASE_ADDRESS+0x00000008)
#define SWRM_COMP_STATUS (SWRM_BASE_ADDRESS+0x00000014)
#define SWRM_COMP_PARAMS (SWRM_BASE_ADDRESS+0x100)
#define SWRM_COMP_PARAMS_DOUT_PORTS_MASK 0x0000001F

4
techpack/audio/Android.mk
View File

@@ -1,7 +1,7 @@
# Android makefile for audio kernel modules
MY_LOCAL_PATH := $(call my-dir)
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 sdm660 qcs605 msmnile $(MSMSTEPPE) $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 qcs605 msmnile $(MSMSTEPPE) $(TRINKET)),true)
UAPI_OUT := $(PRODUCT_OUT)/obj/vendor/qcom/opensource/audio-kernel/include
$(shell mkdir -p $(UAPI_OUT)/linux;)
@@ -68,7 +68,7 @@ $(shell rm -rf $(PRODUCT_OUT)/obj/vendor/qcom/opensource/audio-kernel/4.0/asoc/c
include $(MY_LOCAL_PATH)/4.0/asoc/codecs/wcd938x/Android.mk
endif
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 sdm660 qcs605),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 qcs605),true)
$(shell rm -rf $(PRODUCT_OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/sdm660_cdc/Module.symvers)
$(shell rm -rf $(PRODUCT_OUT)/obj/vendor/qcom/opensource/audio-kernel/asoc/codecs/msm_sdw/Module.symvers)
include $(MY_LOCAL_PATH)/asoc/codecs/sdm660_cdc/Android.mk

79
techpack/audio/Makefile
View File

@@ -2,10 +2,6 @@
ifeq ($(CONFIG_ARCH_SDM845), y)
include $(srctree)/techpack/audio/config/sdm845auto.conf
export
ifeq ($(CONFIG_ARCH_SDM660), y)
include $(srctree)/techpack/audio/config/sdm660auto_static.conf
export
endif
endif
ifeq ($(CONFIG_ARCH_SDM670), y)
include $(srctree)/techpack/audio/config/sdm670auto_static.conf
@@ -23,31 +19,15 @@ ifeq ($(CONFIG_ARCH_SDMSHRIKE), y)
include $(srctree)/techpack/audio/config/sm8150auto.conf
export
endif
ifeq ($(CONFIG_ARCH_ATOLL), y)
ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a52q))
include $(srctree)/techpack/audio/4.0/config/sm7125_a52.conf
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),m42q))
include $(srctree)/techpack/audio/4.0/config/sm7125_m42.conf
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a72q))
include $(srctree)/techpack/audio/4.0/config/sm7125_a72.conf
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),gta4xlve gta4xlvewifi))
include $(srctree)/techpack/audio/4.0/config/sm7125_gta4xlve.conf
else
include $(srctree)/techpack/audio/4.0/config/atollauto.conf
endif
export
endif
ifeq ($(CONFIG_ARCH_SM6150), y)
ifeq ($(filter y,$(CONFIG_SEC_A70Q_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm6150_a70q.conf
else ifeq ($(filter y,$(CONFIG_SEC_A70S_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm6150_a70s.conf
else ifeq ($(filter y,$(CONFIG_SEC_A71_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm7150_a71.conf
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a90q r1q))
include $(srctree)/techpack/audio/config/sm7150_a90q.conf
else ifeq ($(filter y,$(CONFIG_SEC_A70SQ_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm7150_a70sq.conf
else ifeq ($(filter y,$(CONFIG_SEC_A71_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm7150_a71.conf
else ifeq ($(filter y,$(CONFIG_SEC_M41_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm7150_m41.conf
else ifeq ($(filter y,$(CONFIG_SEC_M51_PROJECT)),y)
@@ -56,23 +36,14 @@ else ifeq ($(filter y,$(CONFIG_SEC_A60Q_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm6150_a60q.conf
else ifeq ($(filter y,$(CONFIG_SEC_M40_PROJECT)),y)
include $(srctree)/techpack/audio/config/sm6150_m40.conf
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a90q r1q))
include $(srctree)/techpack/audio/config/sm7150_a90q.conf
else
include $(srctree)/techpack/audio/config/sm6150auto.conf
endif
export
endif
ifeq ($(CONFIG_ARCH_ATOLL), y)
# Use USERINCLUDE when you must reference the UAPI directories only.
USERINCLUDE += \
-I$(srctree)/techpack/audio/4.0/include/uapi \
# Use LINUXINCLUDE when you must reference the include/ directory.
# Needed to be compatible with the O= option
LINUXINCLUDE += \
-I$(srctree)/techpack/audio/4.0/include/uapi \
-I$(srctree)/techpack/audio/4.0/include
else
# Use USERINCLUDE when you must reference the UAPI directories only.
USERINCLUDE += \
-I$(srctree)/techpack/audio/include/uapi \
@@ -82,16 +53,11 @@ USERINCLUDE += \
LINUXINCLUDE += \
-I$(srctree)/techpack/audio/include/uapi \
-I$(srctree)/techpack/audio/include
endif
ifeq ($(CONFIG_ARCH_SDM845), y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sdm845autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM660), y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sdm660autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM670), y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sdm670autoconf.h
@@ -108,24 +74,6 @@ ifeq ($(CONFIG_ARCH_SDMSHRIKE), y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm8150autoconf.h
endif
ifeq ($(CONFIG_ARCH_ATOLL), y)
ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a52q))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/4.0/config/sm7125_a52.h
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),m42q))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/4.0/config/sm7125_m42.h
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a72q))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/4.0/config/sm7125_a72.h
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),gta4xlve gta4xlvewifi))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/4.0/config/sm7125_gta4xlve.h
else
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/4.0/config/atollautoconf.h
endif
endif
ifeq ($(CONFIG_ARCH_SM6150), y)
ifeq ($(filter y,$(CONFIG_SEC_A70Q_PROJECT)),y)
LINUXINCLUDE += \
@@ -133,15 +81,12 @@ LINUXINCLUDE += \
else ifeq ($(filter y,$(CONFIG_SEC_A70S_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm6150_a70s.h
else ifeq ($(filter y,$(CONFIG_SEC_A71_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_a71.h
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a90q r1q))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_a90q.h
else ifeq ($(filter y,$(CONFIG_SEC_A70SQ_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_a70sq.h
else ifeq ($(filter y,$(CONFIG_SEC_A71_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_a71.h
else ifeq ($(filter y,$(CONFIG_SEC_M41_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_m41.h
@@ -154,20 +99,16 @@ LINUXINCLUDE += \
else ifeq ($(filter y,$(CONFIG_SEC_M40_PROJECT)),y)
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm6150_m40.h
else ifeq ($(PROJECT_NAME),$(filter $(PROJECT_NAME),a90q r1q))
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm7150_a90q.h
else
LINUXINCLUDE += \
-include $(srctree)/techpack/audio/config/sm6150autoconf.h
endif
endif
ifeq ($(CONFIG_ARCH_ATOLL), y)
obj-y += 4.0/soc/
obj-y += 4.0/dsp/
obj-y += 4.0/ipc/
obj-y += 4.0/asoc/
else
obj-y += soc/
obj-y += dsp/
obj-y += ipc/
obj-y += asoc/
endif

9
techpack/audio/Makefile.am
View File

@@ -14,9 +14,6 @@ AUDIO_KERNEL_HEADERS_PATH3 = $(shell ls ./include/uapi/sound/*.h)
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), sdm670 qcs605))
KBUILD_OPTIONS += CONFIG_ARCH_SDM670=y
endif
ifeq ($(TARGET_SUPPORT),sdm660)
KBUILD_OPTIONS += CONFIG_ARCH_SDM660=y
endif
ifeq ($(TARGET_SUPPORT),sdm845)
KBUILD_OPTIONS += CONFIG_ARCH_SDM845=y
endif
@@ -36,13 +33,13 @@ obj-m += dsp/codecs/
obj-m += soc/
obj-m += asoc/
obj-m += asoc/codecs/
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), sdm670 sdm660 qcs605 sdmsteppe))
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), sdm670 qcs605 sdmsteppe))
obj-m += asoc/codecs/wcd934x/
endif
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), apq8053 sdm670 sdm660 qcs605))
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), apq8053 sdm670 qcs605))
obj-m += asoc/codecs/sdm660_cdc/
endif
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), sdm670 sdm660 qcs605))
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), sdm670 qcs605))
obj-m += asoc/codecs/msm_sdw/
endif
ifeq ($(TARGET_SUPPORT), $(filter $(TARGET_SUPPORT), qcs40x))

9
techpack/audio/asoc/Android.mk
View File

@@ -8,11 +8,6 @@ TARGET := sdm845
AUDIO_SELECT := CONFIG_SND_SOC_SDM845=m
endif
ifeq ($(call is-board-platform,sdm660),true)
TARGET := sdm660
AUDIO_SELECT := CONFIG_SND_SOC_SDM660=m
endif
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 qcs605),true)
TARGET := sdm670
AUDIO_SELECT := CONFIG_SND_SOC_SDM670=m
@@ -35,7 +30,7 @@ endif
AUDIO_CHIPSET := audio
# Build/Package only in case of supported target
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 sdm660 qcs605 msmnile $(MSMSTEPPE) $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 qcs605 msmnile $(MSMSTEPPE) $(TRINKET)),true)
LOCAL_PATH := $(call my-dir)
@@ -70,7 +65,7 @@ LOCAL_MODULE_DEBUG_ENABLE := true
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
include $(DLKM_DIR)/AndroidKernelModule.mk
###########################################################
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 sdm660 qcs605 $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 qcs605 $(TRINKET)),true)
include $(CLEAR_VARS)
LOCAL_MODULE := $(AUDIO_CHIPSET)_cpe_lsm.ko
LOCAL_MODULE_KBUILD_NAME := cpe_lsm_dlkm.ko

12
techpack/audio/asoc/Kbuild
View File

@@ -19,11 +19,6 @@ ifeq ($(KERNEL_BUILD), 0)
export
INCS += -include $(AUDIO_ROOT)/config/sdm845autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM660), y)
include $(AUDIO_ROOT)/config/sdm660auto.conf
export
INCS += -include $(AUDIO_ROOT)/config/sdm660autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM670), y)
include $(AUDIO_ROOT)/config/sdm670auto.conf
export
@@ -89,10 +84,6 @@ COMMON_INC := -I$(AUDIO_ROOT)/$(COMMON_DIR)
# for SDM6xx sound card driver
ifdef CONFIG_SND_SOC_SDM660
MACHINE_OBJS += sdm660-common.o
endif
ifdef CONFIG_SND_SOC_SDM670
MACHINE_OBJS += sdm660-common.o
endif
@@ -247,3 +238,6 @@ machine_dlkm-y := $(MACHINE_OBJS)
obj-$(CONFIG_SND_SOC_CPE) += cpe_lsm_dlkm.o
cpe_lsm_dlkm-y := $(CPE_LSM_OBJS)
# inject some build related information
DEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

10
techpack/audio/asoc/codecs/Android.mk
View File

@@ -7,10 +7,6 @@ ifeq ($(call is-board-platform,sdm845),true)
AUDIO_SELECT := CONFIG_SND_SOC_SDM845=m
endif
ifeq ($(call is-board-platform,sdm660),true)
AUDIO_SELECT := CONFIG_SND_SOC_SDM660=m
endif
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 qcs605),true)
AUDIO_SELECT := CONFIG_SND_SOC_SDM670=m
endif
@@ -29,7 +25,7 @@ endif
AUDIO_CHIPSET := audio
# Build/Package only in case of supported target
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 sdm660 qcs605 msmnile atoll $(MSMSTEPPE) $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm845 sdm670 qcs605 msmnile atoll $(MSMSTEPPE) $(TRINKET)),true)
LOCAL_PATH := $(call my-dir)
@@ -72,7 +68,7 @@ LOCAL_MODULE_DEBUG_ENABLE := true
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
include $(DLKM_DIR)/AndroidKernelModule.mk
###########################################################
ifeq ($(call is-board-platform-in-list,sdm670 sdm660 qcs605 $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,sdm670 qcs605 $(TRINKET)),true)
include $(CLEAR_VARS)
LOCAL_MODULE := $(AUDIO_CHIPSET)_wcd_cpe.ko
LOCAL_MODULE_KBUILD_NAME := wcd_cpe_dlkm.ko
@@ -90,7 +86,7 @@ LOCAL_MODULE_DEBUG_ENABLE := true
LOCAL_MODULE_PATH := $(KERNEL_MODULES_OUT)
include $(DLKM_DIR)/AndroidKernelModule.mk
###########################################################
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 sdm660 qcs605 $(TRINKET)),true)
ifeq ($(call is-board-platform-in-list,msm8953 sdm670 qcs605 $(TRINKET)),true)
include $(CLEAR_VARS)
LOCAL_MODULE := $(AUDIO_CHIPSET)_wcd9335.ko
LOCAL_MODULE_KBUILD_NAME := wcd9335_dlkm.ko

10
techpack/audio/asoc/codecs/Kbuild
View File

@@ -19,11 +19,6 @@ ifeq ($(KERNEL_BUILD), 0)
export
INCS += -include $(AUDIO_ROOT)/config/sdm845autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM660), y)
include $(AUDIO_ROOT)/config/sdm660auto.conf
export
INCS += -include $(AUDIO_ROOT)/config/sdm660autoconf.h
endif
ifeq ($(CONFIG_ARCH_SDM670), y)
include $(AUDIO_ROOT)/config/sdm670auto.conf
export
@@ -122,8 +117,10 @@ ifdef CONFIG_SND_SOC_WSA881X
WSA881X_OBJS += wsa881x-tables.o
WSA881X_OBJS += wsa881x-regmap.o
WSA881X_OBJS += wsa881x-temp-sensor.o
ifdef CONFIG_SND_SOC_SAMSUNG_AUDIO
WSA881X_OBJS += bigdata_wsa_sysfs_cb.o
endif
endif
ifdef CONFIG_SND_SOC_WSA881X_ANALOG
WSA881X_ANALOG_OBJS += wsa881x-analog.o
@@ -250,3 +247,6 @@ mbhc_dlkm-y := $(MBHC_OBJS)
obj-$(CONFIG_SND_SOC_MSM_HDMI_CODEC_RX) += hdmi_dlkm.o
hdmi_dlkm-y := $(HDMICODEC_OBJS)
# inject some build related information
DEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

3
techpack/audio/asoc/codecs/aqt1000/Kbuild
View File

@@ -119,3 +119,6 @@ endif
# Module information used by KBuild framework
obj-$(CONFIG_SND_SOC_AQT1000) += aqt1000_cdc_dlkm.o
aqt1000_cdc_dlkm-y := $(AQT1000_CDC_OBJS)
# inject some build related information
DEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

2
techpack/audio/asoc/codecs/bigdata_wsa_sysfs_cb.c
View File

@@ -87,7 +87,7 @@ static int get_wsa_amp_excursion_max(enum amp_id id)
{
struct snd_soc_component *component = wsa_component;
int value = 0;
int32_t ex_q27 = 0;
int32_t ex_q27 =0;
if (!component || !wsa_bd) {
pr_err("%s: component NULL\n", __func__);

3
techpack/audio/asoc/codecs/bolero/Kbuild
View File

@@ -143,3 +143,6 @@ tx_macro_dlkm-y := $(TX_OBJS)
obj-$(CONFIG_RX_MACRO) += rx_macro_dlkm.o
rx_macro_dlkm-y := $(RX_OBJS)
# inject some build related information
DEFINES += -DBUILD_TIMESTAMP=\"$(shell date -u +'%Y-%m-%dT%H:%M:%SZ')\"

7
techpack/audio/asoc/codecs/bolero/bolero-cdc.c
View File

@@ -857,9 +857,12 @@ static void bolero_add_child_devices(struct work_struct *work)
}
pdev->dev.parent = priv->dev;
pdev->dev.of_node = node;
priv->dev->platform_data = platdata;
if (wcd937x_node)
if (wcd937x_node) {
priv->dev->platform_data = platdata;
priv->wcd_dev = &pdev->dev;
}
ret = platform_device_add(pdev);
if (ret) {
dev_err(&pdev->dev,

11
techpack/audio/asoc/codecs/bolero/rx-macro.c
View File

@@ -1254,6 +1254,17 @@ static int rx_macro_mclk_event(struct snd_soc_dapm_widget *w,
dev_dbg(rx_dev, "%s: event = %d\n", __func__, event);
switch (event) {
case SND_SOC_DAPM_PRE_PMU:
/* if swr_clk_users > 0, call device down */
if (rx_priv->swr_clk_users > 0) {
if ((rx_priv->mclk_mux == MCLK_MUX0 &&
rx_priv->is_native_on) ||
(rx_priv->mclk_mux == MCLK_MUX1 &&
!rx_priv->is_native_on)) {
swrm_wcd_notify(
rx_priv->swr_ctrl_data[0].rx_swr_pdev,
SWR_DEVICE_DOWN, NULL);
}
}
if (rx_priv->is_native_on)
mclk_freq = MCLK_FREQ_NATIVE;
swrm_wcd_notify(

43
techpack/audio/asoc/codecs/bolero/tx-macro.c
View File

@@ -1,4 +1,4 @@
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
@@ -824,28 +824,6 @@ static int tx_macro_enable_micbias(struct snd_soc_dapm_widget *w,
return 0;
}
/* Cutoff frequency for high pass filter */
static const char * const cf_text[] = {
"CF_NEG_3DB_4HZ", "CF_NEG_3DB_75HZ", "CF_NEG_3DB_150HZ"
};
static SOC_ENUM_SINGLE_DECL(cf_dec0_enum, BOLERO_CDC_TX0_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec1_enum, BOLERO_CDC_TX1_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec2_enum, BOLERO_CDC_TX2_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec3_enum, BOLERO_CDC_TX3_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec4_enum, BOLERO_CDC_TX4_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec5_enum, BOLERO_CDC_TX5_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec6_enum, BOLERO_CDC_TX6_TX_PATH_CFG0, 5,
cf_text);
static SOC_ENUM_SINGLE_DECL(cf_dec7_enum, BOLERO_CDC_TX7_TX_PATH_CFG0, 5,
cf_text);
static int tx_macro_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
@@ -1506,22 +1484,6 @@ static const struct snd_kcontrol_new tx_macro_snd_controls[] = {
BOLERO_CDC_TX7_TX_VOL_CTL,
0, -84, 40, digital_gain),
SOC_ENUM("TX0 HPF cut off", cf_dec0_enum),
SOC_ENUM("TX1 HPF cut off", cf_dec1_enum),
SOC_ENUM("TX2 HPF cut off", cf_dec2_enum),
SOC_ENUM("TX3 HPF cut off", cf_dec3_enum),
SOC_ENUM("TX4 HPF cut off", cf_dec4_enum),
SOC_ENUM("TX5 HPF cut off", cf_dec5_enum),
SOC_ENUM("TX6 HPF cut off", cf_dec6_enum),
SOC_ENUM("TX7 HPF cut off", cf_dec7_enum),
SOC_SINGLE_EXT("DEC0_BCS Switch", SND_SOC_NOPM, 0, 1, 0,
tx_macro_get_bcs, tx_macro_set_bcs),
};
@@ -1562,6 +1524,9 @@ static int tx_macro_swrm_clock(void *handle, bool enable)
BOLERO_CDC_TX_CLK_RST_CTRL_SWR_CONTROL,
0x02, 0x00);
tx_priv->reset_swr = false;
regmap_update_bits(regmap,
BOLERO_CDC_TX_CLK_RST_CTRL_SWR_CONTROL,
0x1C, 0x0C);
msm_cdc_pinctrl_select_active_state(
tx_priv->tx_swr_gpio_p);
}

Some files were not shown because too many files have changed in this diff Show More