[参考译文] TLV320AIC3254：TLV320AIC3254驱动程序问题

https://e2e.ti.com/support/audio-group/audio/f/audio-forum/831795/tlv320aic3254-tlv320aic3254-driver-problem

主控件的这一侧是 RK3288、I2C、I2S 已连接、声卡也已注册。 使用 EVM 板和 I2C 写入配置、有声音输出、拔下电源插头。 证明硬件已连接、主要问题正在驱动这里。

以下是原理图和代码、您中的哪一个已经完成了此芯片、请提供一些建议？

/*
Linux/sound/soc/codecs/tlv320aic32x4.c
*
版权所有2011 Vista Silicon S.L.
*
*作者：Javier Martin 
*
*基于 sound/soc/codecs/wm8974和内核2.6.27的 TI 驱动程序。
*
*此程序是免费软件；您可以根据

*免费软件基金会发布的 GNU 通用公共许可证条款重新分发和/或修改*它；许可证的第2版或
*(您可以选择)任何后续版本。
*
**本计划的发布目的是希望其有用
、*但没有任何保证；甚至没有*
适销性或特定用途适用性的暗示保证。 有关
更多详细信息、请参阅* GNU 通用公共许可证。
*
*您应该已经收到 GNU 通用公共许可证*的副本
以及此程序；如果没有，请写信至 Free Software
* Foundation、Inc.，51 Franklin Street，Fifth Floor，Boston，
* MA 02110-1301、美国。
*/

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#include "tlv320aic32x4.h"

结构 aic32x4_rate_divs｛
u32 MCLK；
u32速率；
u8 p_val；
u8 pll_j；
u16 pll_d；
U16 dosr；
u8 ndac；
u8
aosr；
u8 nadc；
U8 mAdc；
u8 blck_N；
｝；

struct aic32x4_priv{
struct regmap * regmap；
u32 SYSCLK；
u32 power_cfg；
u32 micpga_routing；
bool swapdacs；
int RSTN_GPIO；
struct clk * MCLK；

struct regulator * supply_ldo；
struct regulator * supply_IOV；
struct regulator * supply_dv；
struct 电脑控制器* supply_av；
｝；

//* 0dB min、0.5dB step */
static decl_TLV_DB_scale (tlv_step_0_5、0、50、0)；
//-63.5dB min、 0.5dB 步长*/
静态 REGAL_TLV_DB_SCALE (tlv_PCM、-6350、50、0)；
/*-6dB 最小值、 1dB 步长*/
static decl_tlv_driver_gain (tlv_driver_gain、-600、100、0)；
/*-12dB min、 0.5dB 步长*
/ static decl_TLV_DB_scale (tlv_adc_vol、-1200、50、0)；

static const struct snd_kcontrol_new aic32x4_snd_control[]=｛
SOC_double_R_S_TLV ("PCM 播放 AICVolume"、AIC32X4_LDACVOL、
0x7x4、Rd_TLV、0x32f、Rd_TLV 0x30、7、0、tlv_PCM)、
SOC_DOUBLE_R_S_TLV ("HP 驱动程序增益卷"、AIC32X4_HPLINGAIN、
AIC32X4_HPRGAIN、0、-0x6、 0x1d、5、0、
tlv_driver_gain)、
SOC_DOUBLE_R_S_TLV ("LO 驱动器增益卷"、AIC32X4_LOLGAIN、
AIC32X4_LORGAIN、0、-0x6、 0x1d、5、0、
tlv_driver_gain)、
SOC_double_R ("HP DAC 播放开关"、AIC32X4_HPLINGAIN、
AIC32X4_HPRGAIN、6、0x01、 1)、
SOC_DOUBLE_R ("LO DAC 回放开关"、AIC32X4_LOLGAIN、
AIC32X4_LORGAIN、6、0x01、 1)、
SOC_DOUBLE_R ("麦克风 PGA 开关"、AIC32X4_LMICPGAVOL、
AIC32X4_RMICPGAVOL、7、 0x01、1)、

SOC_SINGLE ("ADCFGA 左侧静音开关"、AIC32X4_ADCFGA、7、1、0)、
SoC_SINGLE ("ADCFGA 右静音开关"、AIC32X4_ADCFGA、3、1、0)、

SoC_DOUBLE_R_S_TLV ("ADC 级别音量"、AIC32X4_LADCVOL、
AIC32X4_RADCVOL、0、-0x18、 0x28、6、0、tlv_adc_vol)、
SOC_double_R_TLV ("PGA 级别音量"、 AIC32X4_LMICPGAVOL、
AIC32X4_RMICPGAVOL、0、0x5f、0、 TLV_STEP_0_5)、

SOC_SINGLE ("自动静音开关"、AIC32X4_DACMUTE、4、7、 0)、

SOC_SINGLE ("AGC 左侧开关"、AIC32X4_LAGC1、7、1、 0)、
SOC_SINGLE ("AGC 右开关"、AIC32X4_RAGC1、7、1、 0)、
SOC_DOUBLE_R ("AGC 目标级别"、AIC32X4_LAGC1、AIC32X4_RAGC1、
4、 0x07、0)、
SOC_DOUBLE_R ("AGC 增益迟滞"、AIC32X4_LAGC1、AIC32X4_RAGC1、
0、0x03、0)、
SOC_DOUBLE_R ("AGC 迟滞"、AIC32X4_LAGC2、 AIC32X4_RAGC2、
6、0x03、0)、
SOC_DOUBLE_R ("AGC 噪声阈值"、 AIC32X4_LAGC2、AIC32X4_RAGC2、
1、0x1F、0)、
SoC_DOUBLE_R ("AGC Max PGA"、AIC32X4_LAGC3、AIC32X4_RAGC3、
0、0x7F、 0)、
SOC_DOUBLE_R ("AGC 攻击时间"、AIC32X4_LAGC4、AIC32X4_RAGC4、
3、 0x1f、0)、
SOC_DOUBLE_R ("AGC 衰减时间"、AIC32X4_LAGC5、AIC32X4_RAGC5、
3、0x1F、0)、
SOC_DOUBLE_R ("AGC 噪声去抖"、AIC32X4_LAGC6、 AIC32X4_RAGC6、
0、0x1F、0)、
SOC_DOUBLE_R ("AGC 信号去抖"、 AIC32X4_LAGC7、AIC32X4_RAGC7、
0、0x0F、0)、
}；

静态常量结构 aic32x4_rate_divs aic32x4_divs[]=｛
/*MCLK；rate；p_val；pll_d;dosr;ndac;MDAC；aosr;nadc;mAdc;blk_N;*/*
8k rate */
｛AIC8k、8000、0007、000_00、0008、0008、0008、0008、0008、0008、0008 768、5、3、128、5、 18、24｝、
｛AIC32X4_FREQ_24000000、8000、2、 7、6800、768、15、1、 64、45、4、24｝、
｛AIC32X4_FREQ_25000000、 8000、2、7、3728、768、 15、1、64、45、4、 24｝、
｛AIC32X4_FREQ_11289600、8000、1、7、 5264、128、2、8、128、 2、8、4｝、
｛AIC32X4_FREQ_12288000、8000、 1、7、5264、128、2、 8、128、2、8、4｝、

/* 11.025k 速率*/
｛AIC32X4_FREQ_12000000、11025、1、7、5264、 512、8、2、128、8、 8、16｝、
｛AIC32X4_FREQ_24000000、11025、2、 7、5264、512、16、1、 64、32、4、16｝、
｛AIC32X4_FREQ_11289600、 11025、1、7、5264、128、 2、8、128、2、8、 4｝、
｛AIC32X4_FREQ_12288000、11025、1、7、 5264、128、2、8、128、 2、8、4｝、

/* 16k 速率*/
｛AIC32X4_FREQ_12000000、16000、1、7、6800、 384、5、3、128、5、 9、12｝、
｛AIC32X4_FREQ_24000000、16000、2、 7、6800、384、15、1、 64、18、5、12｝、
｛AIC32X4_FREQ_25000000、 16000、2、7、3728、384、 15、1、64、18、5、 12｝、
｛AIC32X4_FREQ_11289600、16000、1、7、 5264、128、2、8、128、 2、8、4｝、
｛AIC32X4_FREQ_12288000、16000、 1、7、5264、128、2、 8、128、2、8、4｝、

/* 22.05k 速率*/
｛AIC32X4_FREQ_12000000、22050、1、7、5264、 256、4、4、128、4、 8、8｝、
｛AIC32X4_FREQ_24000000、22050、2、 7、5264、256、16、1、 64、16、4、8｝、
｛AIC32X4_FREQ_25000000、 22050、2、7、2253、256、 16、1、64、16、4、 8｝、
｛AIC32X4_FREQ_11289600、22000、1、7、 5264、128、2、8、128、 2、8、4｝、
｛AIC32X4_FREQ_12288000、22000、 1、7、5264、128、2、 8、128、2、8、4｝、

/* 32k 速率*/
｛AIC32X4_FREQ_12000000、32000、1、7、1680、 192、2、7、64、2、 21、6｝、
｛AIC32X4_FREQ_24000000、32000、2、 7、1680、192、7、2、 64、7、6、6｝、
｛AIC32X4_FREQ_11289600、 32000、1、7、5264、128、 2、8、128、2、8、 4｝、
｛AIC32X4_FREQ_12288000、32000、1、7、 5264、128、2、8、128、 2、8、4｝、

/* 44.1k 速率*/
｛AIC32X4_FREQ_12000000、44100、1、7、5264、 128、2、8、128、2、 8、4｝、
｛AIC32X4_FREQ_24000000、44100、2、 7、5264、128、8、2、 64、8、4、4｝、
｛AIC32X4_FREQ_25000000、 44100、2、7、2253、128、 8、2、64、8、4、 4｝、
｛AIC32X4_FREQ_11289600、44100、1、7、 5264、128、2、8、128、 2、8、4｝、
｛AIC32X4_FREQ_12288000、44100、 1、7、5264、128、2、 8、128、2、8、4｝、

/* 48K 速率*/
｛AIC32X4_FREQ_12000000、48000、1、8、1920、 128、2、8、128、2、 8、4｝、
｛AIC32X4_FREQ_24000000、48000、2、 8、1920、128、8、2、 64、8、4、4｝、
｛AIC32X4_FREQ_25000000、 48000、2、7、8643、128、 8、2、64、8、4、 4｝、
｛AIC32X4_FREQ_11289600、48000、1、8、 5264、128、2、8、128、 2、8、4｝、
｛AIC32X4_FREQ_12288000、48000、 1、8、5264、128、2、 8、128、2、8、4｝、

｝；

静态常量结构 snd_kcontrol_new HPL_output_mixer_control[]=｛
SOC_DAPM_single ("L_DAC Switch"、AIC32X4_HPROUTE、3、1、0)、
SoC_DAPM_SINGLE ("IN1_L 开关"、AIC32X4_HPROUTE、2、1、0)、
｝；

静态常量结构 snd_kcontrol_new HPR_output_mixer_control[]=｛
SOC_DAPM_single ("R_DAC Switch"、AIC32X4_HPRROUTE、3、1、0)、
SoC_DAPM_SINGLE ("IN1_R 开关"、AIC32X4_HPRROUTE、2、1、0)、
｝；

静态常量结构 snd_kcontrol_new lol_output_mixer_control[]=｛
SOC_DAPM_single ("L_DAC Switch"、AIC32X4_LOLROUTE、3、1、0)、
｝；

静态常量结构 snd_kcontrol_new ler_output_mixer_control[]=｛
SOC_DAPM_single ("R_DAC Switch"、AIC32X4_LORROUTE、3、1、0)、
｝；

静态常量结构 snd_kcontrol_new left_input_mixer_control[]=｛
SOC_DAPM_single ("IN1_L P Switch"、AIC32X4_LMICPGAPIN、6、1、0)、
SoC_DAPM_SINGLE ("IN2_L P 开关"、AIC32X4_LMICPGAPIN、4、1、0)、
SoC_DAPM_SINGLE ("in3_L P Switch"、AIC32X4_LMICPGAPIN、2、1、0)、
｝；

静态常量结构 snd_kcontrol_new right_input_mixer_control[]=｛
SOC_DAPM_single ("IN1_R P Switch"、AIC32X4_RMICPGAPIN、6、1、0)、
SoC_DAPM_SINGLE ("IN2_R P 开关"、AIC32X4_RMICPGAPIN、4、1、0)、
SoC_DAPM_SINGLE ("in3_R P 开关"、AIC32X4_RMICPGAPIN、2、1、0)、
｝；

静态常量结构 snd_soc_dapm_widget aic32x4_dapm_widget[]=｛
snd_SOC_DAPM_DAC ("左侧 DAC"、"左侧播放"、AIC32X4_DACSETUP、7、0)、
Snd_SOC_DAPM_Mixer ("HPL 输出混频器"、Snd_SOC_NOPM、0、0、
&HPL_OUTPUT 混频器_control[0]、
array_size (HPL_output_Mixer_controls)、
snd_SOC_DAPM_PGA ("HPL Power"、AIC32X4_OUTPWRCTL、5、0、 空、0)、

snd_SOC_DAPM_Mixer ("LOL 输出混频器"、snd_SOC_NOPM、0、 0、
&LOL_OUTPOUT_MUSTER_control[0]、
array_size (LOL_OUTPOUT_MUSTER_controls)、
snd_SOC_DAPM_PGA ("LOL Power"、AIC32X4_OUTPWRCTL、 3、0、NULL、0)、

SND_SOC_DAPM_DAC ("右侧 DAC"、 "右回放"、AIC32X4_DACSETUP、6、0)、
SND_SOC_DAPM_Mixer ("HPR 输出混频器"、 SND_SOC_NOPM、0、0、
&HPR_OUTPSI_MUSTER_control[0]、
array_size (HPR_OUTPSIMPER_controls))、
SND_SOC_DAPM_PGA ("HPR Power"、AIC32X4_OUTPWRCTL、4、0、NULL、 0)、
snd_SOC_DAPM_Mixer ("左声道输出混频器"、snd_SOC_NOPM、0、0、0、
&ler_output_Mixer_control[0]、
array_size (ler_output_Mixer_controls)、
snd_SOC_DAPM_PGA ("Lor Power"、AIC32X4_OUTPWRCTL、2、 0、NULL、0)、
snd_SOC_DAPM_Mixer ("左输入混频器"、snd_SOC_NOPM、 0、0、
&LEFT_INPUT_MUSTER_control[0]、
array_size (LEFT_INPUT_MUSTER_controls)、
SND_SOC_DAPM_MUSGER_（"右输入混频器"、 Snd_SOC_NOPM、0、0
、&right_input_Mixer_control[0]、
array_size (right_input_Mixer_controls)、
SND_SOC_DAPM_ADC ("左侧 ADC"、"左侧捕获"、AIC32X4_ADCSETUP、7、0)、
SND_SOC_DAPM_ADC ("右侧 ADC"、"右侧捕获"、AIC32X4_ADCSETUP、6、0)、
SND_SOC_DAPM_MICBIAS ("麦克风偏置"、AIC32X4_MICBIAS、6、0)、

SND_SOC_DAPM_OUTPUT ("HPL")、
SND_SOC_DAPM_OUTPUT ("HPR")、
SND_SOC_DAPM_OUTPUT ("LOL")、
SND_SOC_DAPM_OUTPUT ("LO")、
SND_SOC_DAPM_INPUT"("IN1_L")、
SND_SOC_DAPM_INPUT"("IN1_R")、
SND_SOC_DAPM_INPUT ("IN2_L")、
SND_SOC_DAPM_INPUT ("IN2_R")、
SND_SOC_DAPM_INPUT ("in3_L")、
SND_SOC_DAPM_INPUT ("in3_R")、
｝；

静态常量结构 snd_soc_dapm_route aic32x4_dapm_routes[]=｛
//左侧输出*/
｛"HPL 输出混频器"、"L_DAC 开关"、"left DAC"｝、
｛"HPL 输出混频器"、"IN1_L 开关"、 "IN1_L"｝、

｛"HPL 电源"、NULL、"HPL 输出混频器"｝、
｛"HPL"、 空、"HPL Power"｝、

｛"LOL 输出混频器"、"L_DAC 开关"、"左侧 DAC"｝、

｛"LOL Power"、NULL、"LOL Output Mixer"｝、
｛"LOL"、NULL、 "LOL Power"｝、

/*右输出*/
｛"HPR 输出混频器"、"R_DAC 开关"、"Right DAC"｝、
｛"HPR 输出混频器"、"IN1_R 开关"、 "IN1_R"｝、

｛"HPR 电源"、NULL、"HPR 输出混频器"｝、
｛"HPR"、 空、"HPR 电源"｝、

｛"LOR 输出混频器"、"R_DAC 开关"、"右侧 DAC"｝、

｛"LOR Power"、NULL、"LOR 输出混频器"｝、
｛"LOR "、NULL、 "Lor Power"｝、

//左侧输入*/
｛"Left Input Mixer"、"IN1_L P Switch"、"IN1_L"｝、
｛"Left Input Mixer"、"IN2_L P Switch"、 "IN2_L"｝、
｛"左输入混频器"、"in3_L P 开关"、"in3_L"｝、

｛"left ADC"、 空、"左输入混频器"｝、

/*右输入*/
｛"右输入混频器"、"IN1_R P 开关"、"IN1_R"｝、
｛"右输入混频器"、"IN2_R P 开关"、 "IN2_R"｝、
｛"右侧输入混频器"、"in3_R P 开关"、"in3_R"｝、

｛"右侧 ADC"、 空、"右输入混频器"｝、
｝；

静态 const 结构 regmap_range_cfg aic32x4_regmap_pages[]=｛
｛
.selecter_reg = 0、
.selecter_mask = 0xff、
.window_start = 0、
.window_len = 128、
.range_min = 0、
.range_max = AIC32X4_RMICPGAVOL、
｝、
｝；

静态 const 结构 regmap_config aic32x4_regmap =｛
.reg_bits = 8、
.val_bits = 8、

.max_register = AIC32X4_RMICPGAVOL、
.ranges = aic32x4_regmap_pages、
.reg32x4_ranges_num_array = rgap_size_s、.num_regap_pages (reg32x4)
｝；

静态内联 int aic32x4_get_divs (int MCLK、int rate)
｛
int i；

printk (kern_ERR "音频 MCLK 为%d \n"、MCLK)；
printk (kern_ERR "音频速率为%d \n"、rate)；

for (i = 0；i < array_size_s_dive+(i_divi+
)= 32x4+(i_divi+)；(如果 divich4_divi+)
&&(aic32x4_divs[i]。MCLK == MCLK)｛
return i；
｝

printk (kern_ERR "aic32x4：不支持主时钟和采样率\n");
return -eINVAL；
｝

static int 1200aic32x4_set_dai SYSCLK (aic32x4：不支持主时钟和采样率)；return -eoct_unsigned t_scodecc





= t_dicht dec v_t_scodr (soc)

案例 AIC32X4_FREQ_24000000：
案例 AIC32X4_FREQ_25000000：
案例 AIC32X4_FREQ_11289600：
案例 AIC32X4_FREQ_12288000：

aic32x4->SYSCLK = freq；
返回0；
｝
printk (kern_CODEC 时钟"aic32x4：设置 DA_FREQ_12288000的频率无效
；*i_0_d_e+ v_unsigned



toct_unsigned tec

= ni_unsigned t_unt d_estructure；toccr &ni_e+ tec = ni_unt d_unt d_unsigned toctec d_unt d_unt d_unt d_unt d_unt dit d_unt dit dit dit d_quot；


U8 iface_reg_3；
printk (Kern_ERR "aic32x4_set_da_fmt\n")；
iface_reg_1 = snd_soc_read (编解码器、AIC32X4_IFACE1)；
iface_reg_1 = iface_reg_1和~(3 << 6 | 3 << 2)；
iface_reg_2 = snd_soc_read (编解码器、AIC32X4_IFACE2)；
iface_reg_2 = iface_soc
reg = 0；iface_read_reg_3 = iface_soc (codec_0 = snfoc_re_re_0；iface_codec = iface_read_ AIC32X4_IFACE3)；
iface_reg_3 = iface_reg_3和~(1 <<3)；

//设置主/从音频接口*
开关(fmt & snd_x4_DAIFMT_MASTER_MASK)｛
case snd_SOC_DAIFMT_CFM_CFM_SET：
iface_reg_1 | s= sn32x4_DAIFMT_cl_office_clus_clus_ap_ap_ap_cr；








｛cr：sn32_cus_cus_clus_am_cl_am_cl_am_cl_am_cl_ap_cr｝



iface_reg_1 |=(AIC32X4_DSP_MODE << AIC32X4_PLLJ_SHIFT)；
iface_reg_3 |=(1 << 3)；//反转位时钟*/
iface_reg_2 = 0x01；//添加偏移1 */
break；
case snd_SOC_DAIFMT_DSP_DSP_CLIFCLOCK <*





= AIC32X4_REG_1；*(AIC32_RE_CL_CLK_RE_1)|= AIC32_MODE_CL_1 |= 1 *(AIC32ACT_FOC |= 1 = 1)|(AIC32ACT_MODE_CL_CL_RE_CL_CL_CL_CL_CL_1)|= AIC32ACT_OCE_CL_CL_CL_CL_CL_CL_1；*= AIC32_CL_CL_CL_CL_1 *= 1 *(AIC32_

case snd_SOC_DAIFMT_LEFT_J：
iface_reg_1 |=
(AIC32X4_LEFT_ANCED_MODE << AIC32X4_PLLJ_SHIFT)；
break；
default：
printk (Kern_ERR "aic32x4：无效 DAI 接口格式\n")；
return -EINVAL；
｝

sniface_soc (ace_write_tocc)
SND_SoC_WRITE (编解码器、AIC32X4_IFACE2、iface_reg_2)；
SND_SoC_WRITE (编解码器、AIC32X4_IFACE3、 iface_reg_3)；

printk (Kern_ERR "aic32x4_set_da_fmt\n")；
return 0；
｝

static int aic32x4_hw_params (struct snd_PCM_Substream *子流、
struct snd_pcm_hw_params *参数、
struct snd_soc_dai *dai)
{
struct snd_soc_codec *codec = dai ->编解码器；
struct aic32x4_priv* aic32x4 = snd_soc_get_drvdata (编解码器)；
u8数据；
int i；

i = aic32x4_get_divs (aic32x4 -> params (aic32x4->SYSCL)；params (param)；park_param (park_param)
如果(i < 0)｛
printk (kern_ERR "aic32x4：不支持采样率\n")；
返回 i；
｝

//使用 PLL 作为 CODEC _CLKIN 和 DAC_MOD_CLK 作为 BDIV_CLKIN *
/ snd_SoC_write (CODEC、AIC32X4_CLKMUX、AIC32X4_PLIN_CLKIN
、CODEC)；sn32X4_CLKADIC_WRITE (CODEC) AIC32X4_DACMOD2BCLK)；

//我们将 R 值固定为1并使 P & J=KD 成为可变变量*/
data = snd_SoC_read (CODEC、AIC32X4_PLLPR)；
data &=~(7 << 4)；
snd_SoC_write (CODEC、AIC32X4_PLLPR、
(data |(aic32x4_divs[i]。p_val << 4)| 0x01))；

snd_soc_write (codec、AIC32X4_PLLJ、aic32x4_divs[i]。pll_j)；

snd_soc_write (codec、 AIC32X4_PLLDMSB、(aic32x4_DIVS[i]。pll_d >> 8)；
snd_SoC_write (codec、AIC32X4_PLLDLSB、
(aic32x4_divs[i]。pll_d 和0xff))；

// NDAC 分频器值*
数据= snd_soc_read (编解码器、AIC32X4_NDAC)；
数据&=~(0x7f)；
snd_soc_write (编解码器、AIC32X4_NDAC、 数据| aic32x4_divs[i].ndac)；

//
数据= snd_soc_read (编解码器、AIC32X4_MDAC)；
数据&=~(0x7f)；
snd_soc_write (编解码器、AIC32X4_MDAC、 数据| aic32x4_divs[i].MDAC)；

/* DOSR MSB 和 LSB 值*/
snd_soc_write (CODEC、AIC32X4_DOSRMSB、aic32x4_divs[i].dosr >> 8)；
snds_soc_write (CODEC、AIC32X4_DOSRLSB、
(aic32x4_divs[i].dosr 和0xff))；

//
数据= snd_soc_read (编解码器、AIC32X4_NADC)；
数据&=~(0x7f)；
snd_soc_write (编解码器、AIC32X4_NADC、 数据| aic32x4_divs[i]。nadc)；

//
数据= snd_soc_read (编解码器、AIC32X4_mAdc)；
数据&&~(0x7f)；
snd_soc_write (编解码器、AIC32X4_mAdc、 数据| aic32x4_divs[i].mAdc)；

// AOSR 值*/
snd_soc_write (codec、AIC32X4_AOSR、aic32x4_divs[i].aosr)；

// BCLK N divider */
data = snd_soc_read (codec、AIC32X4_BCLK[i].aosr)；//
~
cData = sn32X4_clk_clf (codec_cl_cl_clnf (codec、？soc)；sn32x4_clk_cln_clk_clnf (codec 数据| aic32x4_divs[i]。blk_N)；

数据= snd_soc_read (codec、AIC32X4_IFACE1)；
数据= data &~(3 << 4)；
开关(params_width (params)))｛
case 16：
break；
case 20：
data |=(AIC32X4_word_LE20s= AIC32X4_64_ms_ble<)；AIC32X4_64_64_b_b_msp_64_64_b_64_b_b_





(case = AIC32_64_64_64_64_b_64_64_b_64_b_b_64_b_64_64_b_64_b_64_b_64_b_64_64_64_64_64_b_64_64_64_64_64_b_64_64_b_64_64_64_64_64_64_64_64_64_64




if (params_channels (params)=1)｛
data = AIC32X4_RDAC2LCHN | AIC32X4_LDAC2LCHN；
｝否则｛
if (aic32x4->swapdacs)
data = AIC32X4_RDAC2LCHN | AIC32X4_LDAC2RCHN；
else
data = AIC32X4_LDAC2X4_DAC32X4_LDCC24_SET_64_DAC32SN_64_DAC32SN_SN_SN64_DAC32SND


；｝
printk (Kern_ERR "data1为%x \n"、data)；
// snd_soc_write (codec、AIC32X4_DACSETUP、0xD6)；
//printk (kx4_ERR "data2为%d \n"、data)；

printk (kcodec_ERR "aic32x4_hw_sus_return




)；*nstructure d4 socc = n_mute dac (n_t

)；dac n_mute _t_tu_tu_tu_tu_tu_dac (dac)；

DAC_reg = snd_soc_read (CODEC、AIC32X4_DACMUTE)和~AIC32X4_MUTEON；
if (MUTE)
snd_soc_write (CODEC、AIC32X4_DACMUTE、DAC_reg | AIC32X4_MUTEON)；
否则
snd_soc_write (codec、AIC32X4_DACMUTE、DAC_reg)；

return 0；
｝

static int aic32x4_set_bias _level (struct snd_soc_codec *编解码器、
enum snd_soc_bias _level)
｛
struct aic32x4_codec * aic32x4 = snd_level_clt；






(struct soc_clrt) n)；
enable soc clrac _clret (enable soc _clrt + clret)；(if) ret_clrt clrac _clrt + clret (rac _clret = sn32x_clrt)；(clrt + clrt + clrt + clrac ret = sn32x_clret = soc) r on



/*打开 PLL */
snd_soc_update_bits (编解码器、AIC32X4_PLLPR、
AIC32X4_PLLEN、AIC32X4_PLLEN)；

//打开 NDAC 分频器*/
snd_SoC_update_bits (编解码器、AIC32X4_NDAC、
AIC32X4_NDACEN、AIC32X4_NDACEN)；

/*打开 MDAC 分频器*/
snd_SoC_update_bits (编解码器、AIC32X4_MDAC、
AIC32X4_MDACEN、AIC32X4_MDACEN)；

//打开 NADC 分频器*/
snd_SoC_update_bits (编解码器、AIC32X4_NADC、
AIC32X4_NADCEN、AIC32X4_NADCEN)；

//打开 mAdc 分频器*/
snd_soc_update_bits (编解码器、AIC32X4_mAdc、
AIC32X4_MADCEN、AIC32X4_MADCEN)；

//打开 BCLK_N 分频器*
snd_soc_update_bits (编解码器、AIC32X4_BCLKN、
AIC32X4_BCLKEN、AIC32X4_BCLKEN)；
break；
case snd_SOC_BIAS_PREPARE：
break；
case snd_SOC_BIAS_STANDBY：
//关闭 BCLK_N 分频器*/snd_SoC_update_bits
(CODEC、AIC32X4_BCLKN、
AIC32X4_BCLKEN、0)；

//关闭 mAdc 除法器*/
snd_soc_update_bits (编解码器、AIC32X4_mAdc、
AIC32X4_MADCEN、0)；

//关闭 NADC 分频器*/
snd_soc_update_bits (编解码器、AIC32X4_NADC、
AIC32X4_NADCEN、0)；

/*关闭 MDAC 分频器*/
snd_soc_update_bits (编解码器、AIC32X4_MDAC、
AIC32X4_MDACEN、0)；

//关闭 NDAC 分频器*/
snd_soc_update_bits (编解码器、AIC32X4_NDAC、
AIC32X4_NDACEN、0)；

/*关闭 PLL */
snd_soc_update_bits (编解码器、AIC32X4_PLLPR、
AIC32X4_PLLEN、0)；

//关闭主时钟*/
clk_disable_unprepare (aic32x4->MCLK)；
break；
case snd_SOC_BIAS_off：
break；
｝


printk (Kern_ERR "aic32x4_set_bias level\n")；
return 0；
｝

#define AIC32X4_RATSSNDRV_PCM_RATE_8000_48000
#define AIC32X4_formats(SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3ams | SNDRV_PCM_FMTBIT_S24_3LE
| SNDRV_PCM_FMTBIT_S16_LE | SNDRV_ST_32x4_SAT_S32RAT_S20_S



= S32RAM_S = S32_A SIT_S = S32_A SITE_S = t_S = S32_S t_S t_S = S32_S t_S t_S t_S = t_S t_S t_S t_paraT
= t_para64_S = t_S = t_park_t_t_t_para32x4_S = t_t_t_mT_S = d



静态结构 snd_soc_da_driver aic32x4_dai =｛
.name ="tlv320aic32x4-hifi"、
.playback =｛
stream_name ="播放"、
CHANNES_MIN = 1、
.channels_max = 2、
.RAates = AIC32X4_RARates、
.formats = AIC32X4_formats、｝、
.capture =｛
.stream_name ="捕捉"、
CHANNES_MIN = 1、
.channels_max = 2、
.RAates = AIC32X4_RARates、
.formats = AIC32X4_formats、｝、
.ops =&aic32x4_ops、
.symmetrates = 1、
｝；

静态 int aic32x4_probe (struct snd_soc_codec *编解码器)
｛
struct aic32x4_tmp * aic32x4 = snd_socd_get_drvdata (struct)；
uic32x4

(codec)、
r32x4_dr_r_rt)、r32x4 (gpio (nic32x4_rn)、e+ r32x4_drt)、r32x4_dr_r_r32x4_dr_rt (gpegot_r_r_rt)、r32x4 (r32x4 (r



0x01)；

/*电源平台配置*/
if (aic32x4->power_cfg & AIC32X4_PWR_MICBIAS_2075_LDOIN){
snd_SoC_write (CODEC、AIC32X4_MICBIAS、AIC32X4_MICBIAS_LDOIN |
AIC32X4_MICBIAS_2075V)；
}
IF (aic32x4->POWER_CFG 和 AIC32X4_PWR_AVDD_DVDD_weak)
SND_SoC_WRITE (编解码器、AIC32X4_PWRCFG、AIC32X4_AVDDWEAKDISABLE)；

tmp_reg =(aic32X4_LDO_weake_enable？AIC32X4_POWER_ENABLE？)
AIC32X4_LDOCTLEN：0；
SND_SoC_WRITE (CODEC、AIC32X4_LDOCTL、tmp_reg)；

tmp_reg = snd_soc_read (CODEC、 AIC32X4_CMMODE)；
IF (aic32x4->POWER_CFG 和 AIC32X4_PWR_CMODE_LDOIN_RANGE_18_36)
tmp_reg |= AIC32X4_LDOIN_18_36；
IF (aic32x4->POWER_CFG 和 AIC32X4_CMMODE_HP_CFG_WM_PG32X4_ROP_ENCODEC

)、AIC32X4_INTX_IN64_INTX_R_IN64_INTXC_W/ IN64_IN64_INTXD、AIC32x4_INTXC_W_

编

解码器*、IN64_INTXC_W_INTXC_W_INTXD、IN64_INTXC_W_编解码器+ IN64_INTXD、INTXC_W_INTXC_W_编解码器+ IN64_INTXD、INTXC_W_INTXC_W_编解码器+ INTXC_W_、INTXC_W_ INTXC_W_ INTXD、INTXC_W_ INTXD、INTXD、



AIC32X4_LMICPGANIN_CM1L_10K)；
IF (aic32x4->micpga_routing 和 AIC32X4_MICPGA_route_rmic_IN1L_10K)
snd_soc_write (codec、AIC32X4_RMICPGANIN、
AIC32X4_RMICPGANIN_10K)；toc_r32X4_RMICPGANIN1L_tocc、AIC32X4_RPGANINTXD

、AIC3L、CANTXC_WRITE
AIC32X4_RMICPGANIN_CM1R_10K)；

//
*变通办法：出于未知原因，ADC 需要加电
*和断电，以便第一次捕获正常工作。 它似乎与
*硬件错误或数据表中未记录的某种行为有关。
tmp_reg
= snd_soc_read (codec、AIC32X4_ADCSETUP)；
snd_soc_write (codec、AIC32X4_ADCSETUP、tmp_reg |
AIC32X4_LADC_EN | AIC32X4_RADC_EN)；
snd_soc_write (codec、AIC32X4_ADCSETUP*、tmp_ENC)；sn32X4_code_write*



0x49、0xff)；
SND_SoC_WRITE (编解码器、0x4a、0xff)；
SND_SoC_WRITE (编解码器、0x47、0x80)；

/*来自 EVM 代码*/
snd_SoC_WRITE (编解码器、0x00、0x00)；
snd_SoC_WRITE (编解码器、0x01、 0x01)；
snd_soc_write (codec、0x00、0x00)；
snd_soc_write (codec、 0x0B、0x81)；
SND_SoC_WRITE (编解码器、0x0c、0x82)；
SND_SoC_WRITE (编解码器、0x00、0x00)；
SND_SoC_WRITE (编解码器、0x3c、 0x08)；
SND_SoC_WRITE (编解码器、0x00、0x01)；
SND_SoC_WRITE (编解码器、 0x01、0x08)；
SND_SoC_WRITE (编解码器、0x02、0x00)；
SND_SoC_WRITE (编解码器、0x47、0x32)；
SND_SoC_WRITE (编解码器、0x7B、 0x01)；
snd_soc_write (codec、0x00、0x01)；
snd_soc_write (codec、 0x14、0x25)；
SND_SoC_WRITE (编解码器、0x0c、0x08)；
SND_SoC_WRITE (编解码器、0x0d、0x08)；
SND_SoC_WRITE (编解码器、0x0E、 0x08)；
SND_SoC_WRITE (编解码器、0x0F、0x08)；
SND_SoC_WRITE (编解码器、 0x09、0x3c)；
SND_SoC_WRITE (编解码器、0x10、0x00)；
SND_SoC_WRITE (编解码器、0x11、0x00)；
SND_SoC_WRITE (编解码器、0x12、 0x00)；
snd_soc_write (codec、0x13、0x00)；
snd_soc_write (codec、 0x00、0x00)；
SND_SoC_WRITE (编解码器、0x41、0x00)；
SND_SoC_WRITE (编解码器、0x42、0x00)；
SND_SoC_WRITE (编解码器、0x3f、 0xd6)；
snd_soc_write (codec、0x40、0x00)；

printk (Kern_ERR "aic32x4_prob\n")；
返回0；
｝

静态结构 snd_soc_codec_driver soc_codec_dev_aic32x4 =｛
.probe = aic32x4_probe、
.set_bias level = aic32x4_set_bias _level、
.suspend_bias = true、

.controls = aic32x4_snd_controls、
.num_controls = array_size_size_se_size_sular_off
.dapm_widget = aic32x4_dapm_widget、
.num_dapm_widget = array_size (aic32x4_dapm_widget)、
.dapm_routes = aic32x4_dapm_routes、
.num_dapm_routes = array_size (aic32x4_dapm_routes
)、｝

静态 int aic32x4_pars_dt (struct aic32x4_priv* aic32x4、
struct device_node * np)
｛
aic32x4->swapdacs = false；
aic32x4->micpga_routing = 0；
aic32x4->RSTN_gpio = of _get_named_gpio (npos、"np"、"pnp"、"ret-0")

return 0；
｝

static void aic32x4_disable_regulators(struct aic32x4_priv_aic32x4)
｛
regulator_disable(aic32x4->supply_oV)；

if (!is_err (aic32x4->supply_v)v=aicx4-v=dicv=stators_de32x4-v=(aicv=v_devic32x4-v=v=v=v_devicet_statulators_dive_dive_det-(aicv->aporg)














；if (aicv_devic32x4-v_devic32x4-v_devic32x4-v_devicet_stators=v->ap_devicet_devicet_agors=v-v-v-v_devic32x4-v-v->ap_devicet_devicet_devicet_devicet_agricv-(aicv->aporg)；

aic32x4->supply_dv = devm_reguler_get_optional (dev、"dv")；
aic32x4->supply_av = devm_reguler_get_optional (dev、"av")；

//检查是否满足了稳压器要求*

(is_ERR (aic32x4->supply_IOV)；









如果缺少、则为"a32x4-v_offer
(aic32x4)；如果缺少)、则为"aicv_retr_offer (aic32x4)；如果缺少)-aic32x4 (如果没有)、则为"aicv_abr_dr_retr_offer)、则为"aic32x4-v_aic32x4 (如果没有)、则为"aic32v_offer)；(如果没有)；(如果没有)

如果(is_ERR (aic32x4->supply_av))｛
dev_err (dev、"缺少电源'av'或'ldoin')；
返回 ptr_ERR (aic32x4->supply_ret)；







如果(is_ERR (aic32x4->supply_rt


))、则延迟｝其他｛if (is_err (aic32x4->probe_rt)；如果设置


为 probe_v_ret_aicv_aicv=&aicv=e= aicv_ret_ret_abe=-aicv_ret_abe+)；如果为 probe (aic32x4-aicv_ab_abe+)、则为 probe (aicv_en_en_en_offer)；如果为<probe_rer (aicv=<probe_r= probe_r= probe_r= probe_ag_aicv_aicv_aicv


如果(！is_ERR (aic32x4->supply_ldo))｛
ret = reguler_enable (aic32x4->supply_ldo)；
如果(ret)｛
DEV_err (dev、"启用稳压器 LDO\n")；
转至 ERROR_ldo；
｝


如果(！is_ERR (aic32x4->supply_dv
)

；如果(aic32x4v)= aicv_rac





(aicv_dac)、则转至<aic32x4-v->supply)；如果(aic32x4v (aicv_rac)= dac (aicv_rac)；
if (ret)｛
DEV_ERR (dev、"无法启用稳压器 av\n")；
转至 ERROR_av；
｝


if (！is_ERR (aic32x4->supply_ldo)&& is_ERR (aic32x4->supply_2c)
) aic32x4->power_cfg |= AIC32x4_v_prob_ldo
















(aic32x4->icv_prob_offer)；ic32x4_ic32x4-v_prob_ldo (如果<ic32x4->aicv_prob_prob_agc)<ic32x4-v_prob_ic32x4-v_prob_icv_it_rgor_ic32x4->aicv_it_it_it_agc (aic32x4-v_icv_icv_icv_icv_icv_icv_icv_icv_icv_icv_icv_probt)；(aic32x4-v_probt)<ic
const struct i2c_device_id *id)
{
struct aic32x4_pdata *pdata = i2c->dev.platform_data;
struct aic32x4_priv* aic32x4；
struct device_node *np = i2c->dev.of_node；
int ret;

aic32x4 = devm_kzx4 (&i2c->strature_div->sizuc、
gfp_kernel)；
if (aic32x4 == NULL)
return -ENOMEM；

aic32x4->regmap = devm_regmap_init_i2c (iic32x4_regmap)；
if (is_err (aic32x4->regmap)
ret_ERR (aic32x4->prue->p32x4->pnp











)；if ipic32x4->pv2_rac (pic32x4->pv4)；pic32x4->ap_data_rn)
return；
｝
否则｛
aic32x4->power_cfg = 0；
aic32x4->swapdacs = false；
aic32x4->micpga_routing = 0；
aic32x4->RSTN_gpO =-1；
｝

aic32x4->MCLK = devm_clk_get (&i2c->MCLK

、如果 MCLK 失败)、则为"DEV-"DEV_"MCLDCR-2c"(如果 MCLK、则为 MCLK)。 当前的实现不支持在没有 MCLK 的情况下使用此编解码器\n");
返回 PTR_ERR (aic32x4->MCLK)；
}

if (GPIO_is_VALID (aic32x4->RSTN_GPIO))｛
ret = devm_GPIO_request_one (&i32x4->dev、aic32x4->ret

)



；
如果
设置为"a32x4-_ret_out"、
则为"a32x4-_reet (&i32x4->e+)；如果为"i32x4-_reet、则为"a32x4-_reet)、则为"vret (_reet)；如果为"i32x4-n_reet、则为 rit_reet、则为32x4-_reet、则为32x4-n_reet (_reet)；如果为"


RET = snd_soc_register_codec (&i2c->dev、
&soc_codec_dev_aic32x4、&aic32x4_dai、1)；
if (ret)｛
DEV_err (&i2c->dev、"注册编解码器失败\n")；
aic32x4_disable_regulators (aic32x4)；



i2c、iocet_ret_ret_ret_return；i32x4数据；i2c；i32x4
return 0；
｝

static int aic32x4_i2c_remove (struct i2c_client * client)
｛
struct aic32x4_privt * aic32x4 = i2c_get_clientdata (client)；

aic32x4_disable_regulators（aic32x4)；

snd_soc_con2c_codec (&client->dev)；




｛i32x4_disable_static


｝；i32x4_det_it_itec｝｛i32x4_decc｝、i32x4_decc｝、i32x4_decc =静态、i32x4_decc；i32x4_dect｝

static const struct of _device_id aic32x4_for_id[]=｛
.compatible ="ti、tlv320aic32x4"、｝
｛// senitel *｝
；
module_device_table (of、aic322c_for_id)；

static struct i32x4_driver aic32x4_ic32x4_i_name



=｛ic32x4_v_probe =.abit_.a32x4_name =.aic32x4_remove =.text、ic32x4_it_probe =.a32x4_it_probe =.a32x4_it_probe =.a32x4_it_probe =.a32x4_a32x4_it_probe、.a32x4_


id_table = aic32x4_i2c_id、
｝；

module_i2c_driver (aic32x4_i2c_driver)；

module_description ("asoc tlv320aic32x4编解码器驱动程序")；
module_Author ("Javier Martin ")；
module_license ("GPL")；