Gitiles
Code Review Sign In
192.168.1.100 / T108 / c2023d5d03be91dbb983606f0ec5e9e4ea36c8c2 / . / marvell / linux / drivers / mfd / alc5616.c
blob: 62d61a9422f71181220798cbc609d89c83a9fe95 [file] [log] [blame]
/*
* Base driver for ASR ALC5616
*
* Copyright (C) 2019 ASR.
*
* This file is subject to the terms and conditions of the GNU General
* Public License. See the file "COPYING" in the main directory of this
* archive for more details.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/i2c.h>
#include <linux/irq.h>
#include <linux/mfd/core.h>
#include <linux/mfd/88pm80x.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/of_device.h>
#include <linux/uaccess.h>
#include <linux/proc_fs.h>
#include <linux/fs.h>
#include <linux/debugfs.h>
#include <sound/pcm.h>
#include <sound/soc.h>
#include <linux/gpio.h>
//#include <plat/mfp.h>
#include <linux/regulator/consumer.h>
#include <linux/pinctrl/consumer.h>
#include <linux/platform_device.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_gpio.h>
#include <asm/io.h>
#include <linux/interrupt.h>
#include <linux/cputype.h>
#include <soc/asr/addr-map.h>
#include "alc5616.h"
#include <linux/clk.h>
#include <sound/pcm_params.h>
#include <sound/soc-dapm.h>
#include <sound/initval.h>
#include <sound/tlv.h>
#ifndef APB_VIRT_BASE
#define APB_VIRT_BASE IOMEM(0xfe000000)
#endif
#define SSP1_I2S_CLOCK_REG_ADDR (0xD4050044)
#ifdef Kestrel_Z2
//Kestrel Z2
static void __iomem *VCXO_OUT_MFPR_reg = APB_VIRT_BASE + 0x1E000 + 0x208;/* 0xD401E000+0x208 */
static void __iomem *PM_MN_CLK_reg = APB_VIRT_BASE + 0x51000 + 0xA4;/* 0xD4051000+0xA4 */
static void __iomem *GPCR_reg = APB_VIRT_BASE + 0x50000 + 0x30;/* 0xD4050030 */
#else
//Kestrel A0
static void __iomem *MCLK_CLK_CTRL_reg = NULL;/* 0xD6800000+0x4C */
static void __iomem *MCLK_MN_DIV_reg = NULL;/* 0xD6800000+0x50 */
#endif
//NezhaC/Falcon
#ifdef ALC5616_DEBUG_CLOSE
static void __iomem *SSP1_I2S_CLOCK_reg = APB_VIRT_BASE + 0x50000 + 0x44;/* 0xD4050000+0x44 */
#endif
#if defined(CONFIG_CODEC_PCM_NB)
/* Narrowband */
char Audio_Codec_Fsync_Rate = 0;
#elif defined(CONFIG_CODEC_PCM_WB)
/* Wideband */
char Audio_Codec_Fsync_Rate = 1;
#elif defined(CONFIG_CODEC_PCM_32KHz)
/* 32KHz */
char Audio_Codec_Fsync_Rate = 2;
#elif defined(CONFIG_CODEC_PCM_48KHz)
/* 48KHz */
char Audio_Codec_Fsync_Rate = 3;
#else
/* Narrowband */
char Audio_Codec_Fsync_Rate = 0;
#endif
#ifdef CONFIG_CODEC_PCM_MASTER
/* CODEC is master, GSSP is slave. */
char G_AudioModemMaster = 0;
#else
/* CODEC PCM config is slave in config/defconfig_asr1802sp201
CODEC is slave, GSSP is master. */
char G_AudioModemMaster = 1;
#endif
static const struct i2c_device_id alc5616_id_table[] = {
{"alc5616", 0},
{} /* NULL terminated */
};
MODULE_DEVICE_TABLE(i2c, alc5616_id_table);
static const struct of_device_id alc5616_dt_ids[] = {
{ .compatible = "asrmicro,alc5616", },
{},
};
MODULE_DEVICE_TABLE(of, alc5616_dt_ids);
static struct i2c_client *g_alc5616_client = NULL;
static struct pinctrl *g_alc5616_pinctrl = NULL;
static struct device_node *g_alc5616_node = NULL;
//static void __iomem *i2s_clk_reg = NULL;
static int gpio_tds_dio10 = 0; /* GPIO[78] */
static int gpio_vcxo_out = 0; /* GPIO[126] */
static int gpio_31_CODEC_1V8_EN = 0; /* GPIO[31] */
static int gpio_32_CODEC_3V3_EN = 0; /* GPIO[32] */
static struct regulator *alc5616_regulator_vdd_1v8 = NULL;
static struct regulator *alc5616_regulator_vdd_3v3 = NULL;
#ifdef HEADSET_DETECTION
static int gpio_CODEC_IRQ = 0; /* GPIO[1] */
static int irq_codec;
#endif
//#define HEADSET_DETECTION
//#define ALC5616_DEBUG
//#define ALC5616_DEBUG_CLOSE
#define ALC5616_REG_NUM 0xFF
/* base functions */
static unsigned short alc5616_readable_register(unsigned int reg)
{
switch (reg) {
case RT5616_RESET:
case RT5616_VERSION_ID:
case RT5616_VENDOR_ID:
case RT5616_DEVICE_ID:
case RT5616_HP_VOL:
case RT5616_LOUT_CTRL1:
case RT5616_LOUT_CTRL2:
case RT5616_IN1_IN2:
case RT5616_INL1_INR1_VOL:
case RT5616_DAC1_DIG_VOL:
case RT5616_ADC_DIG_VOL:
case RT5616_ADC_BST_VOL:
case RT5616_STO1_ADC_MIXER:
case RT5616_AD_DA_MIXER:
case RT5616_STO_DAC_MIXER:
case RT5616_REC_L1_MIXER:
case RT5616_REC_L2_MIXER:
case RT5616_REC_R1_MIXER:
case RT5616_REC_R2_MIXER:
case RT5616_HPO_MIXER:
case RT5616_OUT_L1_MIXER:
case RT5616_OUT_L2_MIXER:
case RT5616_OUT_L3_MIXER:
case RT5616_OUT_R1_MIXER:
case RT5616_OUT_R2_MIXER:
case RT5616_OUT_R3_MIXER:
case RT5616_LOUT_MIXER:
case RT5616_PWR_DIG1:
case RT5616_PWR_DIG2:
case RT5616_PWR_ANLG1:
case RT5616_PWR_ANLG2:
case RT5616_PWR_MIXER:
case RT5616_PWR_VOL:
case RT5616_PRIV_INDEX:
case RT5616_PRIV_DATA:
case RT5616_I2S1_SDP:
case RT5616_ADDA_CLK1:
case RT5616_ADDA_CLK2:
case RT5616_GLB_CLK:
case RT5616_PLL_CTRL1:
case RT5616_PLL_CTRL2:
case RT5616_HP_OVCD:
case RT5616_DEPOP_M1:
case RT5616_DEPOP_M2:
case RT5616_DEPOP_M3:
case RT5616_CHARGE_PUMP:
case RT5616_PV_DET_SPK_G:
case RT5616_MICBIAS:
case RT5616_A_JD_CTL1:
case RT5616_A_JD_CTL2:
case RT5616_EQ_CTRL1:
case RT5616_EQ_CTRL2:
case RT5616_WIND_FILTER:
case RT5616_DRC_AGC_1:
case RT5616_DRC_AGC_2:
case RT5616_DRC_AGC_3:
case RT5616_SVOL_ZC:
case RT5616_JD_CTRL1:
case RT5616_JD_CTRL2:
case RT5616_IRQ_CTRL1:
case RT5616_IRQ_CTRL2:
case RT5616_INT_IRQ_ST:
case RT5616_GPIO_CTRL1:
case RT5616_GPIO_CTRL2:
case RT5616_GPIO_CTRL3:
case RT5616_PGM_REG_ARR1:
case RT5616_PGM_REG_ARR2:
case RT5616_PGM_REG_ARR3:
case RT5616_PGM_REG_ARR4:
case RT5616_PGM_REG_ARR5:
case RT5616_SCB_FUNC:
case RT5616_SCB_CTRL:
case RT5616_BASE_BACK:
case RT5616_MP3_PLUS1:
case RT5616_MP3_PLUS2:
case RT5616_ADJ_HPF_CTRL1:
case RT5616_ADJ_HPF_CTRL2:
case RT5616_HP_CALIB_AMP_DET:
case RT5616_HP_CALIB2:
case RT5616_SV_ZCD1:
case RT5616_SV_ZCD2:
case RT5616_D_MISC:
case RT5616_DUMMY2:
case RT5616_DUMMY3:
return 1;
default:
return 0;
}
}
/******************************************************************************
* Function : alc5616_reg_read
*******************************************************************************
*
* Description :
*
* Parameters : char RegAddr
* Parameters : unsigned short *value
*
* Output Param : None.
*
* Return value :
*
* Notes :
*******************************************************************************/
static int alc5616_reg_read(struct i2c_client *client, char reg)
{
char data[2] = {0};
int value = 0x0;
data[0] = reg & 0xFF;
if(i2c_master_send(client, data, 1) == 1) {
i2c_master_recv(client, data, 2);
value = (((unsigned short)data[0]) << 8) | data[1];
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s: alc5616 read reg:[0x%02x]=0x%04x\n", __FUNCTION__, reg, value);
#endif
return value;
} else {
printk(KERN_INFO"%s: alc5616 read failed.\n", __FUNCTION__);
return -EIO;
}
}
static int alc5616_read(char reg, unsigned short *oValue)
{
int value;
value = alc5616_reg_read(g_alc5616_client, reg);
if (value < 0)
{
printk(KERN_INFO"%s: alc5616_reg read failed.\n", __FUNCTION__);
*oValue = 0x00;
return -EIO;
}
*oValue = value & 0xFFFF;
return 0;
}
/******************************************************************************
* Function : alc5616_reg_write
*******************************************************************************
*
* Description :
*
* Parameters : char RegAddr
* Parameters : unsigned short RegData
*
* Output Param : None.
*
* Return value :
*
* Notes :
*******************************************************************************/
static int alc5616_reg_write(struct i2c_client *client, char reg, unsigned short value)
{
char data[3] = {0};
data[0] = reg & 0xFF;
data[1] = (char)((value >> 8) & 0xFF);
data[2] = (char)(value & 0xFF);
if (i2c_master_send(client, data, 3) == 3) {
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s=> reg:0x%02x,value:0x%04x success\n", __FUNCTION__, reg, value);
#endif
return 0;
} else {
printk(KERN_INFO"%s=> reg:0x%02x,value:0x%04x error\n", __FUNCTION__, reg, value);
return -1;
}
}
static int alc5616_write(char reg, unsigned short value)
{
int ret;
#ifdef ALC5616_DEBUG_CLOSE
unsigned short read_value;
#endif
ret = alc5616_reg_write(g_alc5616_client, reg, value);
if (ret < 0)
{
printk(KERN_INFO"%s:L%d: alc5616_reg_write() error.\n", __FUNCTION__, __LINE__);
}
#ifdef ALC5616_DEBUG_CLOSE
//for check whether write is OK or not.
ret = alc5616_read(reg, &read_value);
if (ret < 0)
{
printk(KERN_INFO"%s:L%d: alc5616_read() error.\n", __FUNCTION__, __LINE__);
}
printk(KERN_INFO"%s:L%d: reg=0x%02x, value=0x%04x, read_value=0x%04x. Please check it:%s.\n",
__FUNCTION__, __LINE__, reg, value, read_value, (value == read_value)?"OK":"FAIL");
#endif
return ret;
}
static int alc5616_update_bit(char reg, unsigned short mask, unsigned short value)
{
int status = 0;
unsigned short orig = 0;
unsigned short tmp = 0;
status = alc5616_read(reg, &orig);
if (status < 0)
{
printk(KERN_INFO"%s:L%d: alc5616_read() error.\n", __FUNCTION__, __LINE__);
return status;
}
else
{
tmp = orig & (~mask);
tmp |= (value & mask);
if (tmp != orig)
{
status = alc5616_write(reg, tmp);
if (status < 0)
{
printk(KERN_INFO"%s:L%d: alc5616_write() error.\n", __FUNCTION__, __LINE__);
return status;
}
}
}
#ifdef ALC5616_DEBUG_CLOSE
printk(KERN_INFO"%s:L%d: reg=0x%02x, mask=0x%02x, value=0x%04x, orig=0x%04x, last_value=0x%04x, please check it:%s.\n",
__FUNCTION__, __LINE__, reg, mask, value, orig, tmp, (orig == tmp)?"EQUAL":"UNEQUAL");
#endif
return status;
}
static int alc5616_index_read(char RegAddr, unsigned short *value)
{
int status = -1;
status = alc5616_write(RT5616_PRIV_INDEX, RegAddr);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
return status;
}
status = alc5616_read(RT5616_PRIV_DATA, value);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
return status;
}
return status;
}
static int alc5616_index_write(char RegAddr, unsigned short value)
{
int status = -1;
status = alc5616_write(RT5616_PRIV_INDEX, RegAddr);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
return status;
}
status = alc5616_write(RT5616_PRIV_DATA, value);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
return status;
}
return status;
}
static int alc5616_index_update_bits(char RegAddr, unsigned short mask, unsigned short value)
{
int status = -1;
unsigned short orig;
unsigned short tmp;
status = alc5616_index_read(RegAddr, &orig);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
}
else
{
tmp = orig & (~mask);
tmp |= (value & mask);
if (tmp != orig)
{
status = alc5616_index_write(RegAddr, tmp);
if (status != 0)
{
printk(KERN_INFO"status: %d, RegAddr: 0x%04x\n", status, RegAddr);
}
}
}
return status;
}
#define RT5616_STATE_OFF 0x00
static char rt5616_init_ok = 0;
static char connect_rt5616 = 0;
static char rt5616_work_state = RT5616_STATE_OFF;
static char l_connect_alc5616 = 0;
int codec_alc5616_is_connect(void)
{
return l_connect_alc5616;
}
int codec_alc5616_init(void)
{
static char alc5616_init_ok = 0;
short value = 0;
if(0 == alc5616_init_ok){
//codec_alc5616_enable_mfpr();
/* check if has codec alc5616*/
alc5616_read(0xFE, &value);
if (0x10EC == value) {
alc5616_write(0x00, 0x00);
alc5616_init_ok = 1;
l_connect_alc5616 = 1;
rt5616_init_ok = 1;
connect_rt5616 = 1;
}
}
printk(KERN_INFO"%s:L%d: alc5616_init_ok=%d, l_connect_alc5616 =%d.\n",
__FUNCTION__, __LINE__, alc5616_init_ok, l_connect_alc5616);
return !alc5616_init_ok;
}
static int g_5616_mclk_type = 1; /* 0: use bitclk, 1: use i2s_mclk, 2, use bitclk and turn on i2s_mclk */
static int g_5616_mainmic_type = 0; /* 0: differential mode, 1: single mode */
/***********************************************************************
INTCBind() could only use one lisr for ***all*** GPIOs,
So, headset detection is disabled by default on ASR1802S EVB.
So, we need to set g_5616_headset_plugged=1 by default;
thus user just need to plugin headset and no other operation/command is needed.
************************************************************************/
static int g_5616_headset_plugged = 1; /* 0: headset plug out, 1: headset plug in */
static int g_5616_headset_mic = 0; /* 0: without HS_MIC, 1: with HS_MIC */
/***********************************************************************
When we enable headset detection, could not power off codec
i.e could not call codec_rt5616_power_on/codec_rt5616_power_off
************************************************************************/
int g_5616_headset_detection_enabled = 0; /* 0: disable, 1: enable */
#define is_speaker_on() (rt5616_work_state & 0x01)
#define is_headphone_on() (rt5616_work_state & 0x02)
#define is_main_mic_on() (rt5616_work_state & 0x04)
#define is_headset_mic_on() (rt5616_work_state & 0x08)
struct reg_value_group {
char reg;
unsigned short mask;
unsigned short value;
};
void disable_5616_MClock(void);
void enable_5616_MClock(void);
static int disableRt5616 = 0;
static int disableRt5616HsMic = 0;
void disableCodecRt5616(void)
{
disableRt5616 = 1;
}
static int disableRt5616DefaultPower = 0;
void disableCodecRt5616Power(void)
{
disableRt5616DefaultPower = 1;
}
void disableCodecRt5616HsMic(void)
{
disableRt5616HsMic = 1;
}
int codec_rt5616_is_connect(void)
{
return connect_rt5616;
}
static void rt5616_set_work_state(char device, char onoff)
{
if (device == RT5616_OUTPUT_DEVICE_SPEAKER)
{
if (onoff == RT5616_DEVICE_OFF)
{
rt5616_work_state &= 0xFE;
}
else if (onoff == RT5616_DEVICE_ON)
{
rt5616_work_state |= 0x01;
}
}
else if (device == RT5616_OUTPUT_DEVICE_HEADPHONE)
{
if (onoff == RT5616_DEVICE_OFF)
{
rt5616_work_state &= 0xFD;
}
else if (onoff == RT5616_DEVICE_ON)
{
rt5616_work_state |= 0x02;
}
}
else if (device == RT5616_INPUT_DEVICE_MAIN_MIC)
{
if (onoff == RT5616_DEVICE_OFF)
{
rt5616_work_state &= 0xFB;
}
else if (onoff == RT5616_DEVICE_ON)
{
rt5616_work_state |= 0x04;
}
}
else if (device == RT5616_INPUT_DEVICE_HEADSET_MIC)
{
if (onoff == RT5616_DEVICE_OFF)
{
rt5616_work_state &= 0xF7;
}
else if (onoff == RT5616_DEVICE_ON)
{
rt5616_work_state |= 0x08;
}
}
}
/* audio control functions */
static void alc5616_speaker_on(void)
{
#if 1
alc5616_index_write(0x3D, 0x3600); /*DAC Clock1 Generator Enable*/
alc5616_write(0x63, 0xf8de); /*LOUTMIX Power On*/
alc5616_write(0x61, 0x9804); /*DACL1 Power On*/
alc5616_write(0x62, 0x8800); /*Stereo1 DAC Digital Filter Power On*/
alc5616_write(0x65, 0xc800); /*OUTMIXL Power On*/
alc5616_write(0x66, 0x3000); /*OUTVOLL Power On*/
alc5616_write(0x8F, 0x3100); /*HP Deop Mode mode 2*/
alc5616_write(0x2A, 0x1250); /*DACL1 to Stereo DAC left Mixer*/
alc5616_write(0x4F, 0x0278); /*DACL1 to OUTMIXL*/
alc5616_write(0x52, 0x0278); /*DACR1 to OUTMIXR*/
alc5616_write(0x53, 0xc000); /*OUTVOLL to LOUTMIX Unmute*/
alc5616_write(0x03, 0x0808); /*LOUTL Unmute*/
alc5616_write(0x73, 0x0102); /*Stereo DAC sample Rate 128 FS*/
alc5616_write(0x05, 0x8000); /*enable Differential Line Output*/
#else
alc5616_index_update_bits(0x3D, 1 << 10, 1 << 10); /*DAC Clock1 Generator Enable*/
alc5616_index_update_bits(0x3D, 1 << 9, 1 << 9); /*DAC Clock2 Generator Enable*/
alc5616_update_bit(0x63, 1 << 12, 1 << 12); /*LOUTMIX Power On*/
alc5616_update_bit(0x61, 1 << 12, 1 << 12); /*DACL1 Power On*/
alc5616_update_bit(0x61, 1 << 11, 1 << 11); /*DACR1 Power On*/
alc5616_update_bit(0x62, 1 << 11, 1 << 11); /*Stereo1 DAC Digital Filter Power On*/
alc5616_update_bit(0x65, 1 << 15, 1 << 15); /*OUTMIXL Power On*/
alc5616_update_bit(0x65, 1 << 14, 1 << 14); /*OUTMIXR Power On*/
alc5616_update_bit(0x66, 1 << 13, 1 << 13); /*OUTVOLL Power On*/
alc5616_update_bit(0x66, 1 << 12, 1 << 12); /*OUTVOLR Power On*/
alc5616_update_bit(0x8F, 1 << 13, 1 << 13); /*HP Deop Mode mode 2*/
alc5616_update_bit(0x2A, 1 << 14, 0); /*DACL1 to Stereo DAC left Mixer*/
alc5616_update_bit(0x2A, 1 << 1, 0); /*DACL1 to Stereo DAC Right Mixer*/
alc5616_update_bit(0x4F, 1, 0); /*DACL1 to OUTMIXL*/
alc5616_update_bit(0x52, 1, 0); /*DACR1 to OUTMIXR*/
alc5616_update_bit(0x53, 1 << 13, 0); /*OUTVOLL to LOUTMIX Unmute*/
alc5616_update_bit(0x53, 1 << 12, 0); /*OUTVOLR to LOUTMIX Unmute*/
alc5616_update_bit(0x03, 1 << 15, 0); /*LOUTL Unmute*/
alc5616_update_bit(0x03, 1 << 14, 0); /*OUTVOLL Unmute*/
alc5616_update_bit(0x03, 1 << 7, 0); /*LOUTR Unmute*/
alc5616_update_bit(0x03, 1 << 6, 0); /*OUTVOLR Unmute*/
alc5616_update_bit(0x73, 3 << 2, 0 << 2); /*Stereo DAC sample Rate 128 FS*/
alc5616_update_bit(0x05, 1 << 15, 1 << 15); /*enable Differential Line Output*/
#endif
}
static void alc5616_speaker_off(void)
{
#if 1
alc5616_index_write(0x3D, 0x2000); /*DAC Clock1 Generator Enable*/
alc5616_write(0x63, 0xe8de); /*LOUTMIX Power Off*/
alc5616_write(0x61, 0x8000); /*DACL1 Power On*/
alc5616_write(0x62, 0x0000); /*Stereo1 DAC Digital Filter Power On*/
alc5616_write(0x65, 0x0000); /*OUTMIXL Power On*/
alc5616_write(0x66, 0x0000); /*OUTVOLL Power On*/
alc5616_write(0x8F, 0x1100); /*HP Deop Mode mode 2*/
alc5616_write(0x2A, 0x5250); /*DACL1 to Stereo DAC left Mixer*/
alc5616_write(0x4F, 0x0279); /*DACL1 to OUTMIXL*/
alc5616_write(0x52, 0x0279); /*DACR1 to OUTMIXR*/
alc5616_write(0x53, 0xf000); /*OUTVOLL to LOUTMIX Unmute*/
alc5616_write(0x03, 0xc8c8); /*LOUTL Unmute*/
alc5616_write(0x73, 0x0102); /*Stereo DAC sample Rate 128 FS*/
alc5616_write(0x05, 0x0000); /*disable Differential Line Output*/
#else
alc5616_index_update_bits(0x3D, 1 << 10, 0); /*DAC Clock1 Generator Enable*/
alc5616_index_update_bits(0x3D, 1 << 9, 0); /*DAC Clock2 Generator Enable*/
alc5616_update_bit(0x63, 1 << 12, 0); /*LOUTMIX Power Off*/
alc5616_update_bit(0x61, 1 << 12, 0); /*DACL1 Power On*/
alc5616_update_bit(0x61, 1 << 11, 0); /*DACR1 Power On*/
alc5616_update_bit(0x62, 1 << 11, 0); /*Stereo1 DAC Digital Filter Power On*/
alc5616_update_bit(0x65, 1 << 15, 0); /*OUTMIXL Power On*/
alc5616_update_bit(0x65, 1 << 14, 0); /*OUTMIXR Power On*/
alc5616_update_bit(0x66, 1 << 13, 0); /*OUTVOLL Power On*/
alc5616_update_bit(0x66, 1 << 12, 0); /*OUTVOLR Power On*/
alc5616_update_bit(0x8F, 1 << 13, 0); /*HP Deop Mode mode 2*/
alc5616_update_bit(0x2A, 1 << 14, 1 << 14); /*DACL1 to Stereo DAC left Mixer*/
alc5616_update_bit(0x2A, 1 << 6, 1 << 6); /*DACR1 to Stereo DAC Right Mixer*/
alc5616_update_bit(0x4F, 1, 1); /*DACL1 to OUTMIXL*/
alc5616_update_bit(0x52, 1, 1); /*DACR1 to OUTMIXR*/
alc5616_update_bit(0x53, 1 << 13, 1 << 13); /*OUTVOLL to LOUTMIX Unmute*/
alc5616_update_bit(0x53, 1 << 12, 1 << 12); /*OUTVOLR to LOUTMIX Unmute*/
alc5616_update_bit(0x03, 1 << 15, 1 << 15); /*LOUTL Unmute*/
alc5616_update_bit(0x03, 1 << 14, 1 << 14); /*OUTVOLL Unmute*/
alc5616_update_bit(0x03, 1 << 7, 1 << 7); /*LOUTR Unmute*/
alc5616_update_bit(0x03, 1 << 6, 1 << 6); /*OUTVOLR Unmute*/
alc5616_update_bit(0x73, 3 << 2, 0 << 2); /*Stereo DAC sample Rate 128 FS*/
alc5616_update_bit(0x05, 1 << 15, 0 << 15); /*disable Differential Line Output*/
#endif
}
static void alc5616_headphone_on(void)
{
#if 1
alc5616_index_write(0x3D, 0x3600); /*DAC Clock1 Generator Enable*/
alc5616_write(0x61, 0x9804); /*DACL1 Power On*/
alc5616_write(0x62, 0x8800); /*Stereo1 DAC Digital Filter Power On*/
alc5616_write(0x65, 0xcc00); /*OUTMIXL Power On*/
alc5616_write(0x66, 0x0c00); /*HPOVOLL Power On*/
alc5616_write(0x8E, 0x001d); /*Enable Headphone Output*/
alc5616_write(0x8F, 0x3100); /*HP Deop Mode mode 2*/
alc5616_write(0x2A, 0x1250); /*DACL1 to Stereo DAC left Mixer*/
alc5616_write(0x4F, 0x0278); /*DACL1 to OUTMIXL*/
alc5616_write(0x52, 0x0278); /*DACR1 to OUTMIXR*/
alc5616_write(0x45, 0x5000); /*HPOVOL to HPOMIX Unmute*/
alc5616_write(0x02, 0x0808); /*HPOL UnMute*/
alc5616_write(0x73, 0x0102); /*Stereo DAC sample Rate 128 FS*/
#else
alc5616_index_update_bits(0x3D, 1 << 10, 1 << 10); /*DAC Clock1 Generator Enable*/
alc5616_index_update_bits(0x3D, 1 << 9, 1 << 9); /*DAC Clock2 Generator Enable*/
alc5616_update_bit(0x61, 1 << 12, 1 << 12); /*DACL1 Power On*/
alc5616_update_bit(0x61, 1 << 11, 1 << 11); /*DACR1 Power On*/
alc5616_update_bit(0x62, 1 << 11, 1 << 11); /*Stereo1 DAC Digital Filter Power On*/
alc5616_update_bit(0x65, 1 << 15, 1 << 15); /*OUTMIXL Power On*/
alc5616_update_bit(0x65, 1 << 14, 1 << 14); /*OUTMIXR Power On*/
alc5616_update_bit(0x66, 1 << 11, 1 << 11); /*HPOVOLL Power On*/
alc5616_update_bit(0x66, 1 << 10, 1 << 10); /*HPOVOLR Power On*/
alc5616_update_bit(0x8E, 1 << 4, 1 << 4); /*Enable Headphone Output*/
alc5616_update_bit(0x8E, 1, 1); /*HP Amp All Power On*/
alc5616_update_bit(0x8F, 1 << 13, 1 << 13); /*HP Deop Mode mode 2*/
alc5616_update_bit(0x2A, 1 << 14, 0); /*DACL1 to Stereo DAC left Mixer*/
alc5616_update_bit(0x2A, 1 << 1, 0); /*DACL1 to Stereo DAC Right Mixer*/
alc5616_update_bit(0x4F, 1, 0); /*DACL1 to OUTMIXL*/
alc5616_update_bit(0x52, 1, 0); /*DACR1 to OUTMIXR*/
alc5616_update_bit(0x45, 1 << 13, 0); /*HPOVOL to HPOMIX Unmute*/
alc5616_update_bit(0x02, 1 << 15, 0); /*HPOL UnMute*/
alc5616_update_bit(0x02, 1 << 14, 0); /*HPOVOLL Unmute*/
alc5616_update_bit(0x02, 1 << 7, 0); /*HPOR UnMute*/
alc5616_update_bit(0x02, 1 << 6, 0); /*HPOVOLR Unmute*/
alc5616_update_bit(0x73, 3 << 2, 0 << 2); /*Stereo DAC sample Rate 128 FS*/
#endif
}
static void alc5616_headphone_off(void)
{
#if 1
alc5616_index_write(0x3D, 0x2000); /*DAC Clock1 Generator Enable*/
alc5616_write(0x61, 0x8000); /*DACL1 Power On*/
alc5616_write(0x62, 0x0000); /*Stereo1 DAC Digital Filter Power On*/
alc5616_write(0x65, 0x0000); /*OUTMIXL Power On*/
alc5616_write(0x66, 0x0000); /*HPOVOLL Power On*/
alc5616_write(0x8E, 0x000c); /*Enable Headphone Output*/
alc5616_write(0x8F, 0x1100); /*HP Deop Mode mode 2*/
alc5616_write(0x2A, 0x5252); /*DACR1 to Stereo DAC left Mixer*/
alc5616_write(0x4F, 0x0279); /*DACL1 to OUTMIXL*/
alc5616_write(0x52, 0x0279); /*DACR1 to OUTMIXR*/
alc5616_write(0x45, 0x7000); /*HPOVOL to HPOMIX Unmute*/
alc5616_write(0x02, 0xc8c8); /*HPOL UnMute*/
alc5616_write(0x73, 0x0102); /*Stereo DAC sample Rate 128 FS*/
#else
alc5616_index_update_bits(0x3D, 1 << 10, 0); /*DAC Clock1 Generator Enable*/
alc5616_index_update_bits(0x3D, 1 << 9, 0); /*DAC Clock2 Generator Enable*/
alc5616_update_bit(0x61, 1 << 12, 0); /*DACL1 Power On*/
alc5616_update_bit(0x61, 1 << 11, 0); /*DACR1 Power On*/
alc5616_update_bit(0x62, 1 << 11, 0); /*Stereo1 DAC Digital Filter Power On*/
alc5616_update_bit(0x65, 1 << 15, 0); /*OUTMIXL Power On*/
alc5616_update_bit(0x65, 1 << 14, 0); /*OUTMIXR Power On*/
alc5616_update_bit(0x66, 1 << 11, 0); /*HPOVOLL Power On*/
alc5616_update_bit(0x66, 1 << 10, 0); /*HPOVOLR Power On*/
alc5616_update_bit(0x8E, 1 << 4, 0); /*Enable Headphone Output*/
alc5616_update_bit(0x8E, 1, 0); /*HP Amp All Power On*/
alc5616_update_bit(0x8F, 1 << 13, 0); /*HP Deop Mode mode 2*/
alc5616_update_bit(0x2A, 1 << 14, 1 << 14); /*DACR1 to Stereo DAC left Mixer*/
alc5616_update_bit(0x2A, 1 << 1, 1 << 1); /*DACL1 to Stereo DAC Right Mixer*/
alc5616_update_bit(0x4F, 1, 1); /*DACL1 to OUTMIXL*/
alc5616_update_bit(0x52, 1, 1); /*DACR1 to OUTMIXR*/
alc5616_update_bit(0x45, 1 << 13, 1 << 13); /*HPOVOL to HPOMIX Unmute*/
alc5616_update_bit(0x02, 1 << 15, 1 << 15); /*HPOL UnMute*/
alc5616_update_bit(0x02, 1 << 14, 1 << 14); /*HPOVOLL Unmute*/
alc5616_update_bit(0x02, 1 << 7, 1 << 7); /*HPOR UnMute*/
alc5616_update_bit(0x02, 1 << 6, 1 << 6); /*HPOVOLR Unmute*/
alc5616_update_bit(0x73, 3 << 2, 0 << 2); /*Stereo DAC sample Rate 128 FS*/
#endif
}
static void alc5616_main_mic_on(void)
{
#if 1
alc5616_index_write(0x3D, 0x3600); /*ADC Clock Genaral Enable*/
alc5616_write(0x65, 0xc800); /*RECMIXL Power On*/
alc5616_write(0x61, 0x9804); /*ADCL Power On*/
alc5616_write(0x62, 0x8800); /*Stereo ADC Digital Filter Power On*/
alc5616_write(0x64, 0x4a00); /*BST2 Power On*/
alc5616_write(0x0D, 0x0540); /*IN2 Boost Control +40dB*/
alc5616_write(0x73, 0x0102); /*Stereo ADC Over Sample Rate 32 Fs*/
alc5616_write(0x3C, 0x006b); /*BST2 to RECMIXL Unmute*/
alc5616_write(0x3E, 0x006b); /*BST1 to RECMIXR Unmute*/
alc5616_write(0x27, 0x3860); /*Stereo ADC1 Left Channel Unmute*/
#else
alc5616_index_update_bits(0x3D, 1 << 12, 1 << 12); /*ADC Clock Genaral Enable*/
alc5616_update_bit(0x65, 1 << 11, 1 << 11); /*RECMIXL Power On*/
alc5616_update_bit(0x61, 1 << 2, 1 << 2); /*ADCL Power On*/
alc5616_update_bit(0x62, 1 << 15, 1 << 15); /*Stereo ADC Digital Filter Power On*/
alc5616_update_bit(0x64, 1 << 14, 1 << 14); /*BST2 Power On*/
alc5616_update_bit(0x0D, 0xF << 8, 5 << 8); /*IN2 Boost Control +40dB*/
alc5616_update_bit(0x0D, 1 << 6, 1 << 6); /*IN2 Differential Mode*/
alc5616_update_bit(0x73, 3, 2); /*Stereo ADC Over Sample Rate 32 Fs*/
alc5616_update_bit(0x3C, 1 << 2, 0); /*BST2 to RECMIXL Unmute*/
alc5616_update_bit(0x3E, 1 << 2, 0); /*BST1 to RECMIXR Unmute*/
alc5616_update_bit(0x27, 1 << 14, 0); /*Stereo ADC1 Left Channel Unmute*/
#endif
}
static void alc5616_main_mic_off(void)
{
#if 1
alc5616_index_write(0x3D, 0x2000); /*ADC Clock Genaral Enable*/
alc5616_write(0x65, 0x0000); /*RECMIXL Power On*/
alc5616_write(0x61, 0x8000); /*ADCL Power On*/
alc5616_write(0x62, 0x0000); /*Stereo ADC Digital Filter Power On*/
alc5616_write(0x64, 0x0a00); /*BST2 Power On*/
alc5616_write(0x0D, 0x0000); /*IN2 Boost Control +40dB*/
alc5616_write(0x73, 0x0102); /*Stereo ADC Over Sample Rate 128 Fs*/
alc5616_write(0x3C, 0x006f); /*BST2 to RECMIXL Unmute*/
alc5616_write(0x3E, 0x006f); /*BST2 to RECMIXL Unmute*/
alc5616_write(0x27, 0x7860); /*Stereo ADC1 Left Channel Unmute*/
#else
alc5616_index_update_bits(0x3D, 1 << 12, 0); /*ADC Clock Genaral Enable*/
alc5616_update_bit(0x65, 1 << 11, 0); /*RECMIXL Power On*/
alc5616_update_bit(0x61, 1 << 2, 0); /*ADCL Power On*/
alc5616_update_bit(0x62, 1 << 15, 0); /*Stereo ADC Digital Filter Power On*/
alc5616_update_bit(0x64, 1 << 14, 0); /*BST2 Power On*/
alc5616_update_bit(0x0D, 0xF << 8, 0); /*IN2 Boost Control +40dB*/
alc5616_update_bit(0x0D, 1 << 6, 0); /*IN2 Differential Mode*/
alc5616_update_bit(0x73, 3, 2); /*Stereo ADC Over Sample Rate 128 Fs*/
alc5616_update_bit(0x3C, 1 << 2, 1 << 2); /*BST2 to RECMIXL Unmute*/
alc5616_update_bit(0x3E, 1 << 2, 1 << 2); /*BST2 to RECMIXL Unmute*/
alc5616_update_bit(0x27, 1 << 14, 1 << 14); /*Stereo ADC1 Left Channel Unmute*/
#endif
}
static void alc5616_headset_mic_on(void)
{
#if 1
alc5616_index_write(0x3D, 0x3600); /*ADC Clock Genaral Enable*/
alc5616_write(0x65, 0xcc00); /*RECMIXL Power On*/
alc5616_write(0x61, 0x9804); /*ADCL Power On*/
alc5616_write(0x62, 0x8800); /*Stereo ADC Digital Filter Power On*/
alc5616_write(0x0D, 0x5000); /*IN1 Boost Control +40dB*/
alc5616_write(0x64, 0x4a04); /*BST1 Power On*/
alc5616_write(0x73, 0x0102); /*Stereo ADC Over Sample Rate 128 Fs*/
alc5616_write(0x3C, 0x006D); /*BST1 to RECMIXL Unmute*/
alc5616_write(0x3E, 0x006D); /*BST1 to RECMIXR Unmute*/
alc5616_write(0x27, 0x3820); /*Stereo ADC1 Left Channel Unmute*/
#else
alc5616_index_update_bits(0x3D, 1 << 12, 1 << 12); /*ADC Clock Genaral Enable*/
alc5616_update_bit(0x65, 1 << 11, 1 << 11); /*RECMIXL Power On*/
alc5616_update_bit(0x65, 1 << 10, 1 << 10); /*RECMIXR Power On*/
alc5616_update_bit(0x61, 1 << 2, 1 << 2); /*ADCL Power On*/
alc5616_update_bit(0x61, 1 << 1, 1 << 1); /*ADCR Power On*/
alc5616_update_bit(0x62, 1 << 15, 1 << 15); /*Stereo ADC Digital Filter Power On*/
alc5616_update_bit(0x0D, 0xF << 12, 5 << 12); /*IN1 Boost Control +40dB*/
alc5616_update_bit(0x64, 1 << 15, 0 << 15); /*BST1 Power On*/
alc5616_update_bit(0x64, 1 << 4, 1 << 4); /*MIC2 SE Mode single-end mode*/
alc5616_update_bit(0x73, 3, 2); /*Stereo ADC Over Sample Rate 128 Fs*/
alc5616_update_bit(0x3C, 1 << 1, 0); /*BST1 to RECMIXL Unmute*/
alc5616_update_bit(0x3E, 1 << 1, 0); /*BST1 to RECMIXR Unmute*/
alc5616_update_bit(0x27, 1 << 14, 0); /*Stereo ADC1 Left Channel Unmute*/
alc5616_update_bit(0x27, 1 << 6, 0); /*Stereo ADC1 Right Channel Unmute*/
#endif
}
static void alc5616_headset_mic_off(void)
{
#if 1
alc5616_index_write(0x3D, 0x2000); /*ADC Clock Genaral Enable*/
alc5616_write(0x65, 0x0000); /*recmixl power on*/
alc5616_write(0x61, 0x8000); /*adcl power on*/
alc5616_write(0x62, 0x0000); /*stereo adc digital filter power on*/
alc5616_write(0x0d, 0x0540); /*in1 boost control +40db*/
alc5616_write(0x64, 0x4a00); /*bst1 power on*/
alc5616_write(0x73, 0x0102); /*stereo adc over sample rate 128 fs*/
alc5616_write(0x3c, 0x006b); /*bst1 to recmixl unmute*/
alc5616_write(0x3e, 0x006b); /*bst1 to recmixr unmute*/
alc5616_write(0x27, 0x7860); /*stereo adc1 left channel unmute*/
#else
alc5616_index_update_bits(0x3D, 1 << 12, 0); /*ADC Clock Genaral Enable*/
alc5616_update_bit(0x65, 1 << 11, 0); /*RECMIXL Power On*/
alc5616_update_bit(0x65, 1 << 10, 0); /*RECMIXR Power On*/
alc5616_update_bit(0x61, 1 << 2, 0); /*ADCL Power On*/
alc5616_update_bit(0x61, 1 << 1, 0); /*ADCR Power On*/
alc5616_update_bit(0x62, 1 << 15, 0); /*Stereo ADC Digital Filter Power On*/
alc5616_update_bit(0x0D, 0xF << 12, 0); /*IN1 Boost Control +40dB*/
alc5616_update_bit(0x64, 1 << 15, 0); /*BST1 Power On*/
alc5616_update_bit(0x64, 1 << 4, 0); /*MIC2 SE Mode single-end mode*/
alc5616_update_bit(0x73, 3, 2); /*Stereo ADC Over Sample Rate 128 Fs*/
alc5616_update_bit(0x3C, 1 << 1, 1 << 1); /*BST1 to RECMIXL Unmute*/
alc5616_update_bit(0x3E, 1 << 1, 1 << 1); /*BST1 to RECMIXR Unmute*/
alc5616_update_bit(0x27, 1 << 14, 1 << 14); /*Stereo ADC1 Left Channel Unmute*/
alc5616_update_bit(0x27, 1 << 6, 1 << 6); /*Stereo ADC1 Right Channel Unmute*/
#endif
}
void alc5616_mute_mic(int mute)
{
#if 1
if (mute) {
alc5616_write(0x1c, 0xafaf);
} else {
alc5616_write(0x1c, 0x2f2f);
}
#else
if (mute) {
alc5616_update_bit(0x1c, (1 << 15), (1 << 15));
alc5616_update_bit(0x1c, (1 << 7), (1 << 7));
} else {
alc5616_update_bit(0x1c, (1 << 15), (0 << 15));
alc5616_update_bit(0x1c, (1 << 7), (0 << 7));
}
#endif
return;
}
/*volume level: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 */
int gain_output_ctrl[11] = { 0x0A, 0x09, 0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0x00};
int gain_digital_vol[11] = { 0xAFAF, 0xB7B7, 0xBFBF, 0xC7C7, 0xCFCF, 0xD7D7, 0xDDDD, 0xE5E5, 0xEDED, 0xF5F5, 0xFFFF};
void alc5616_adjust_gain(int gain)
{
/* gain is within 0~10 */
#if 1
alc5616_update_bit(0x02, (0x3F << 8), (gain_output_ctrl[gain] << 8));/* Headphone output control */
alc5616_update_bit(0x02, (0x3F << 0), (gain_output_ctrl[gain] << 0));
alc5616_update_bit(0x03, (0x3F << 8), (gain_output_ctrl[gain] << 8));/* Line Output Control 1 */
alc5616_update_bit(0x03, (0x3F << 0), (gain_output_ctrl[gain] << 0));
alc5616_write(0x19, gain_digital_vol[gain]); /* DACL1/R1 Digital Volume */
#else
alc5616_update_bit(0x02, (0x3F << 8), (gain_output_ctrl[gain] << 8));/* Headphone output control */
alc5616_update_bit(0x02, (0x3F << 0), (gain_output_ctrl[gain] << 0));
alc5616_update_bit(0x03, (0x3F << 8), (gain_output_ctrl[gain] << 8));/* Line Output Control 1 */
alc5616_update_bit(0x03, (0x3F << 0), (gain_output_ctrl[gain] << 0));
alc5616_write(0x19, gain_digital_vol[gain]); /* DACL1/R1 Digital Volume */
#endif
return;
}
void alc5616_check_HS_mic(void)
{
/* Enable MICBIAS1 Short Current Detector, Threshold:1500uA */
alc5616_update_bit(0x93, (7 << 9), (5 << 9));
return;
}
#define RT5616_SPEAKER_ON_REG_GROUP_NUM 23
static struct reg_value_group rt5616_speaker_on_reg_group[] = {
{0x3D, 1 << 10, 1 << 10}, /*DAC Clock1 Generator Enable*/
{0x3D, 1 << 9, 1 << 9}, /*DAC Clock2 Generator Enable*/
{0x63, 1 << 12, 1 << 12}, /*LOUTMIX Power On*/
{0x61, 1 << 12, 1 << 12}, /*DACL1 Power On*/
{0x61, 1 << 11, 1 << 11}, /*DACR1 Power On*/
{0x62, 1 << 11, 1 << 11}, /*Stereo1 DAC Digital Filter Power On*/
{0x65, 1 << 15, 1 << 15}, /*OUTMIXL Power On*/
{0x65, 1 << 14, 1 << 14}, /*OUTMIXR Power On*/
{0x66, 1 << 13, 1 << 13}, /*OUTVOLL Power On*/
{0x66, 1 << 12, 1 << 12}, /*OUTVOLR Power On*/
{0x8F, 1 << 13, 1 << 13}, /*HP Deop Mode mode 2*/
{0x2A, 1 << 14, 0}, /*DACL1 to Stereo DAC left Mixer*/
{0x2A, 1 << 1, 0}, /*DACL1 to Stereo DAC Right Mixer*/
{0x4F, 1, 0}, /*DACL1 to OUTMIXL*/
{0x52, 1, 0}, /*DACR1 to OUTMIXR*/
{0x53, 1 << 13, 0}, /*OUTVOLL to LOUTMIX Unmute*/
{0x53, 1 << 12, 0}, /*OUTVOLR to LOUTMIX Unmute*/
{0x03, 1 << 15, 0}, /*LOUTL Unmute*/
{0x03, 1 << 14, 0}, /*OUTVOLL Unmute*/
{0x03, 1 << 7, 0}, /*LOUTR Unmute*/
{0x03, 1 << 6, 0}, /*OUTVOLR Unmute*/
{0x73, 3 << 2, 0 << 2}, /*Stereo DAC sample Rate 128 FS*/
{0x05, 1 << 15, 1 << 15}, /*enable Differential Line Output*/
};
#define RT5616_SPEAKER_OFF_REG_GROUP_NUM 23
static struct reg_value_group rt5616_speaker_off_reg_group[] = {
{0x3D, 1 << 10, 0}, /*DAC Clock1 Generator Enable*/
{0x3D, 1 << 9, 0}, /*DAC Clock2 Generator Enable*/
{0x63, 1 << 12, 0}, /*LOUTMIX Power Off*/
{0x61, 1 << 12, 0}, /*DACL1 Power On*/
{0x61, 1 << 11, 0}, /*DACR1 Power On*/
{0x62, 1 << 11, 0}, /*Stereo1 DAC Digital Filter Power On*/
{0x65, 1 << 15, 0}, /*OUTMIXL Power On*/
{0x65, 1 << 14, 0}, /*OUTMIXR Power On*/
{0x66, 1 << 13, 0}, /*OUTVOLL Power On*/
{0x66, 1 << 12, 0}, /*OUTVOLR Power On*/
{0x8F, 1 << 13, 0}, /*HP Deop Mode mode 2*/
{0x2A, 1 << 14, 1 << 14}, /*DACL1 to Stereo DAC left Mixer*/
{0x2A, 1 << 6, 1 << 6}, /*DACR1 to Stereo DAC Right Mixer*/
{0x4F, 1, 1}, /*DACL1 to OUTMIXL*/
{0x52, 1, 1}, /*DACR1 to OUTMIXR*/
{0x53, 1 << 13, 1 << 13}, /*OUTVOLL to LOUTMIX Unmute*/
{0x53, 1 << 12, 1 << 12}, /*OUTVOLR to LOUTMIX Unmute*/
{0x03, 1 << 15, 1 << 15}, /*LOUTL Unmute*/
{0x03, 1 << 14, 1 << 14}, /*OUTVOLL Unmute*/
{0x03, 1 << 7, 1 << 7}, /*LOUTR Unmute*/
{0x03, 1 << 6, 1 << 6}, /*OUTVOLR Unmute*/
{0x73, 3 << 2, 0 << 2}, /*Stereo DAC sample Rate 128 FS*/
{0x05, 1 << 15, 0 << 15}, /*disable Differential Line Output*/
};
#define RT5616_HEADPHONE_ON_REG_GROUP_NUM 22
static struct reg_value_group rt5616_headphone_on_reg_group[] = {
{0x3D, 1 << 10, 1 << 10}, /*DAC Clock1 Generator Enable*/
{0x3D, 1 << 9, 1 << 9}, /*DAC Clock2 Generator Enable*/
{0x61, 1 << 12, 1 << 12}, /*DACL1 Power On*/
{0x61, 1 << 11, 1 << 11}, /*DACR1 Power On*/
{0x62, 1 << 11, 1 << 11}, /*Stereo1 DAC Digital Filter Power On*/
{0x65, 1 << 15, 1 << 15}, /*OUTMIXL Power On*/
{0x65, 1 << 14, 1 << 14}, /*OUTMIXR Power On*/
{0x66, 1 << 11, 1 << 11}, /*HPOVOLL Power On*/
{0x66, 1 << 10, 1 << 10}, /*HPOVOLR Power On*/
{0x8E, 1 << 4, 1 << 4}, /*Enable Headphone Output*/
{0x8E, 1, 1}, /*HP Amp All Power On*/
{0x8F, 1 << 13, 1 << 13}, /*HP Deop Mode mode 2*/
{0x2A, 1 << 14, 0}, /*DACL1 to Stereo DAC left Mixer*/
{0x2A, 1 << 1, 0}, /*DACL1 to Stereo DAC Right Mixer*/
{0x4F, 1, 0}, /*DACL1 to OUTMIXL*/
{0x52, 1, 0}, /*DACR1 to OUTMIXR*/
{0x45, 1 << 13, 0}, /*HPOVOL to HPOMIX Unmute*/
{0x02, 1 << 15, 0}, /*HPOL UnMute*/
{0x02, 1 << 14, 0}, /*HPOVOLL Unmute*/
{0x02, 1 << 7, 0}, /*HPOR UnMute*/
{0x02, 1 << 6, 0}, /*HPOVOLR Unmute*/
{0x73, 3 << 2, 0 << 2}, /*Stereo DAC sample Rate 128 FS*/
};
#define RT5616_HEADPHONE_OFF_REG_GROUP_NUM 22
static struct reg_value_group rt5616_headphone_off_reg_group[] = {
{0x3D, 1 << 10, 0}, /*DAC Clock1 Generator Enable*/
{0x3D, 1 << 9, 0}, /*DAC Clock2 Generator Enable*/
{0x61, 1 << 12, 0}, /*DACL1 Power On*/
{0x61, 1 << 11, 0}, /*DACR1 Power On*/
{0x62, 1 << 11, 0}, /*Stereo1 DAC Digital Filter Power On*/
{0x65, 1 << 15, 0}, /*OUTMIXL Power On*/
{0x65, 1 << 14, 0}, /*OUTMIXR Power On*/
{0x66, 1 << 11, 0}, /*HPOVOLL Power On*/
{0x66, 1 << 10, 0}, /*HPOVOLR Power On*/
{0x8E, 1 << 4, 0}, /*Enable Headphone Output*/
{0x8E, 1, 0}, /*HP Amp All Power On*/
{0x8F, 1 << 13, 0}, /*HP Deop Mode mode 2*/
{0x2A, 1 << 14, 1 << 14}, /*DACR1 to Stereo DAC left Mixer*/
{0x2A, 1 << 1, 1 << 1}, /*DACL1 to Stereo DAC Right Mixer*/
{0x4F, 1, 1}, /*DACL1 to OUTMIXL*/
{0x52, 1, 1}, /*DACR1 to OUTMIXR*/
{0x45, 1 << 13, 1 << 13}, /*HPOVOL to HPOMIX Unmute*/
{0x02, 1 << 15, 1 << 15}, /*HPOL UnMute*/
{0x02, 1 << 14, 1 << 14}, /*HPOVOLL Unmute*/
{0x02, 1 << 7, 1 << 7}, /*HPOR UnMute*/
{0x02, 1 << 6, 1 << 6}, /*HPOVOLR Unmute*/
{0x73, 3 << 2, 0 << 2}, /*Stereo DAC sample Rate 128 FS*/
};
#define RT5616_MAIN_MIC_ON_REG_GROUP_NUM 11
static struct reg_value_group rt5616_main_mic_on_reg_group[] = {
{0x3D, 1 << 12, 1 << 12}, /*ADC Clock Genaral Enable*/
{0x65, 1 << 11, 1 << 11}, /*RECMIXL Power On*/
{0x61, 1 << 2, 1 << 2}, /*ADCL Power On*/
{0x62, 1 << 15, 1 << 15}, /*Stereo ADC Digital Filter Power On*/
{0x64, 1 << 14, 1 << 14}, /*BST2 Power On*/
{0x0D, 0xF << 8, 5 << 8}, /*IN2 Boost Control +40dB*/
{0x0D, 1 << 6, 1 << 6}, /*IN2 Differential Mode*/
{0x73, 3, 2}, /*Stereo ADC Over Sample Rate 32 Fs*/
{0x3C, 1 << 2, 0}, /*BST2 to RECMIXL Unmute*/
{0x3E, 1 << 2, 0}, /*BST1 to RECMIXR Unmute*/
{0x27, 1 << 14, 0}, /*Stereo ADC1 Left Channel Unmute*/
};
static struct reg_value_group rt5616_main_mic_on_reg_group_singlemode[] = {
{0x3D, 1 << 12, 1 << 12}, /*ADC Clock Genaral Enable*/
{0x65, 1 << 11, 1 << 11}, /*RECMIXL Power On*/
{0x61, 1 << 2, 1 << 2}, /*ADCL Power On*/
{0x62, 1 << 15, 1 << 15}, /*Stereo ADC Digital Filter Power On*/
{0x64, 1 << 14, 1 << 14}, /*BST2 Power On*/
{0x0D, 0xF << 8, 5 << 8}, /*IN2 Boost Control +40dB*/
{0x0D, 1 << 6, 0}, /*IN2 Single Mode*/
{0x73, 3, 2}, /*Stereo ADC Over Sample Rate 32 Fs*/
{0x3C, 1 << 2, 0}, /*BST2 to RECMIXL Unmute*/
{0x3E, 1 << 2, 0}, /*BST1 to RECMIXR Unmute*/
{0x27, 1 << 14, 0}, /*Stereo ADC1 Left Channel Unmute*/
};
#define RT5616_MAIN_MIC_OFF_REG_GROUP_NUM 11
static struct reg_value_group rt5616_main_mic_off_reg_group[] = {
{0x3D, 1 << 12, 0}, /*ADC Clock Genaral Enable*/
{0x65, 1 << 11, 0}, /*RECMIXL Power On*/
{0x61, 1 << 2, 0}, /*ADCL Power On*/
{0x62, 1 << 15, 0}, /*Stereo ADC Digital Filter Power On*/
{0x64, 1 << 14, 0}, /*BST2 Power On*/
{0x0D, 0xF << 8, 0}, /*IN2 Boost Control +40dB*/
{0x0D, 1 << 6, 0}, /*IN2 Differential Mode*/
{0x73, 3, 2}, /*Stereo ADC Over Sample Rate 128 Fs*/
{0x3C, 1 << 2, 1 << 2}, /*BST2 to RECMIXL Unmute*/
{0x3E, 1 << 2, 1 << 2}, /*BST2 to RECMIXL Unmute*/
{0x27, 1 << 14, 1 << 14}, /*Stereo ADC1 Left Channel Unmute*/
};
#define RT5616_HEADSET_MIC_ON_REG_GROUP_NUM 14
static struct reg_value_group rt5616_headset_mic_on_reg_group[] = {
{0x3D, 1 << 12, 1 << 12}, /*ADC Clock Genaral Enable*/
{0x65, 1 << 11, 1 << 11}, /*RECMIXL Power On*/
{0x65, 1 << 10, 1 << 10}, /*RECMIXR Power On*/
{0x61, 1 << 2, 1 << 2}, /*ADCL Power On*/
{0x61, 1 << 1, 1 << 1}, /*ADCR Power On*/
{0x62, 1 << 15, 1 << 15}, /*Stereo ADC Digital Filter Power On*/
{0x0D, 0xF << 12, 5 << 12}, /*IN1 Boost Control +40dB*/
{0x64, 1 << 15, 0 << 15}, /*BST1 Power On*/
{0x64, 1 << 4, 1 << 4}, /*MIC2 SE Mode single-end mode*/
{0x73, 3, 2}, /*Stereo ADC Over Sample Rate 128 Fs*/
{0x3C, 1 << 1, 0}, /*BST1 to RECMIXL Unmute*/
{0x3E, 1 << 1, 0}, /*BST1 to RECMIXR Unmute*/
{0x27, 1 << 14, 0}, /*Stereo ADC1 Left Channel Unmute*/
{0x27, 1 << 6, 0}, /*Stereo ADC1 Right Channel Unmute*/
};
#define RT5616_HEADSET_MIC_OFF_REG_GROUP_NUM 14
static struct reg_value_group rt5616_headset_mic_off_reg_group[] = {
{0x3D, 1 << 12, 0}, /*ADC Clock Genaral Enable*/
{0x65, 1 << 11, 0}, /*RECMIXL Power On*/
{0x65, 1 << 10, 0}, /*RECMIXR Power On*/
{0x61, 1 << 2, 0}, /*ADCL Power On*/
{0x61, 1 << 1, 0}, /*ADCR Power On*/
{0x62, 1 << 15, 0}, /*Stereo ADC Digital Filter Power On*/
{0x0D, 0xF << 12, 0}, /*IN1 Boost Control +40dB*/
{0x64, 1 << 15, 0}, /*BST1 Power On*/
{0x64, 1 << 4, 0}, /*MIC2 SE Mode single-end mode*/
{0x73, 3, 2}, /*Stereo ADC Over Sample Rate 128 Fs*/
{0x3C, 1 << 1, 1 << 1}, /*BST1 to RECMIXL Unmute*/
{0x3E, 1 << 1, 1 << 1}, /*BST1 to RECMIXR Unmute*/
{0x27, 1 << 14, 1 << 14}, /*Stereo ADC1 Left Channel Unmute*/
{0x27, 1 << 6, 1 << 6}, /*Stereo ADC1 Right Channel Unmute*/
};
/////////////////////////////////////////////////////////////////////////////////
#define RT5616_HEADSET_DETECT_ON_REG_GROUP_NUM 3
static struct reg_value_group rt5616_headset_detect_on_reg_group[] = {
{0x64, 1 << 2, 1 << 2}, /*JD1 Multilevel Power on*/
{0xC0, 1 << 15, 1 << 15}, /*GPIO1 Pin as IRQ output*/
{0xBD, 7 << 7, 4 << 7}, /*jd1_1, jd1_1_stricky disable, Polarity Normal*/
};
#define RT5616_HEADSET_DETECT_OFF_REG_GROUP_NUM 3
static struct reg_value_group rt5616_headset_detect_off_reg_group[] = {
{0x64, 1 << 2, 0 << 2}, /*JD1 Multilevel Power off*/
{0xC0, 1 << 15, 0 << 15}, /*GPIO1 Pin as IRQ output*/
{0xBD, 7 << 7, 0 << 7}, /*jd1_1, jd1_1_stricky disable, Polarity Normal*/
};
static char rt5616_readable_register(unsigned int reg)
{
switch (reg) {
case RT5616_RESET:
case RT5616_VERSION_ID:
case RT5616_VENDOR_ID:
case RT5616_DEVICE_ID:
case RT5616_HP_VOL:
case RT5616_LOUT_CTRL1:
case RT5616_LOUT_CTRL2:
case RT5616_IN1_IN2:
case RT5616_INL1_INR1_VOL:
case RT5616_DAC1_DIG_VOL:
case RT5616_ADC_DIG_VOL:
case RT5616_ADC_BST_VOL:
case RT5616_STO1_ADC_MIXER:
case RT5616_AD_DA_MIXER:
case RT5616_STO_DAC_MIXER:
case RT5616_REC_L1_MIXER:
case RT5616_REC_L2_MIXER:
case RT5616_REC_R1_MIXER:
case RT5616_REC_R2_MIXER:
case RT5616_HPO_MIXER:
case RT5616_OUT_L1_MIXER:
case RT5616_OUT_L2_MIXER:
case RT5616_OUT_L3_MIXER:
case RT5616_OUT_R1_MIXER:
case RT5616_OUT_R2_MIXER:
case RT5616_OUT_R3_MIXER:
case RT5616_LOUT_MIXER:
case RT5616_PWR_DIG1:
case RT5616_PWR_DIG2:
case RT5616_PWR_ANLG1:
case RT5616_PWR_ANLG2:
case RT5616_PWR_MIXER:
case RT5616_PWR_VOL:
case RT5616_PRIV_INDEX:
case RT5616_PRIV_DATA:
case RT5616_I2S1_SDP:
case RT5616_ADDA_CLK1:
case RT5616_ADDA_CLK2:
case RT5616_GLB_CLK:
case RT5616_PLL_CTRL1:
case RT5616_PLL_CTRL2:
case RT5616_HP_OVCD:
case RT5616_DEPOP_M1:
case RT5616_DEPOP_M2:
case RT5616_DEPOP_M3:
case RT5616_CHARGE_PUMP:
case RT5616_PV_DET_SPK_G:
case RT5616_MICBIAS:
case RT5616_A_JD_CTL1:
case RT5616_A_JD_CTL2:
case RT5616_EQ_CTRL1:
case RT5616_EQ_CTRL2:
case RT5616_WIND_FILTER:
case RT5616_DRC_AGC_1:
case RT5616_DRC_AGC_2:
case RT5616_DRC_AGC_3:
case RT5616_SVOL_ZC:
case RT5616_JD_CTRL1:
case RT5616_JD_CTRL2:
case RT5616_IRQ_CTRL1:
case RT5616_IRQ_CTRL2:
case RT5616_INT_IRQ_ST:
case RT5616_GPIO_CTRL1:
case RT5616_GPIO_CTRL2:
case RT5616_GPIO_CTRL3:
case RT5616_PGM_REG_ARR1:
case RT5616_PGM_REG_ARR2:
case RT5616_PGM_REG_ARR3:
case RT5616_PGM_REG_ARR4:
case RT5616_PGM_REG_ARR5:
case RT5616_SCB_FUNC:
case RT5616_SCB_CTRL:
case RT5616_BASE_BACK:
case RT5616_MP3_PLUS1:
case RT5616_MP3_PLUS2:
case RT5616_ADJ_HPF_CTRL1:
case RT5616_ADJ_HPF_CTRL2:
case RT5616_HP_CALIB_AMP_DET:
case RT5616_HP_CALIB2:
case RT5616_SV_ZCD1:
case RT5616_SV_ZCD2:
case RT5616_D_MISC:
case RT5616_DUMMY2:
case RT5616_DUMMY3:
return 1;
default:
return 0;
}
}
int rt5616_reg_dump(void)
{
char index;
unsigned short value;
int status = -1;
printk(KERN_INFO"rt5616_reg_dump_enter\n");
for (index = 0; index < 0xFF; index++)
{
if (rt5616_readable_register(index))
{
status = alc5616_read(index, &value);
if (status != 0)
{
printk(KERN_INFO"status: 0x%x\n", status);
return -1;
}
printk(KERN_INFO"index: 0x%x, value: 0x%x\n", index, value);
}
}
return 0;
}
/*
I2S1 BCLK Polarity Invert
I2S1 PCM Mode A
*/
static void rt5616_set_dai_fmt(char enable)
{
#if 1
if (RT5616_DEVICE_ON == enable)
{
if(0 == G_AudioModemMaster){
/* GSSP is slave, alc5616 is master */
alc5616_write(0x70, 0x0082);
} else {
/* GSSP is master, alc5616 is slave */
alc5616_write(0x70, 0x8082);
}
}
else if (RT5616_DEVICE_OFF == enable)
{
if(0 == G_AudioModemMaster){
/* GSSP is slave, alc5616 is master */
alc5616_write(0x70, 0x0000);
} else {
/* GSSP is master, alc5616 is slave */
alc5616_write(0x70, 0x8000);
}
}
#else
if (RT5616_DEVICE_ON == enable)
{
alc5616_update_bit(0x70, (1 << 7) | 3, (1 << 7) | 2);
if(0 == G_AudioModemMaster){// gssp slave, 5616 master
alc5616_update_bit(0x70, (1 << 15) , (0 << 15) );// set 5616 master
}
}
else if (RT5616_DEVICE_OFF == enable)
{
alc5616_update_bit(0x70, (1 << 7) | 3, 0);
}
#endif
}
/*FS = bitrate = 8K
BCLK = 512K = 64FS , 0x73
FOUT = (sysclk * (N + 2)) / ((M + 2) / (K + 2))
SYSCLK = PLL = 26M
FOUT = (26 * 34) / (9 * 4) = 24.555
CLK = FOUT / 12 = 2048K = 256 * FS
*/
static void rt5616_set_sysclk(char enable)
{
#if 1
if (RT5616_DEVICE_ON == enable)
{
alc5616_write(0xFA, 0x0001); /*Enable MCLK Input*/
alc5616_write(0x73, 0x0002); /*DAC Over Sample Rate: 128Fs, ADC Over Sample Rate: 32Fs*/
if (3 == Audio_Codec_Fsync_Rate)
{
printk(KERN_INFO"%s, sys clock comes from PLL when Fsync = 48K.\n", __FUNCTION__);
alc5616_update_bit(0x64, 1 << 9, 1 << 9); /*PLL Power On*/
alc5616_update_bit(0x73, 7 << 12, 1 << 12); /*sel_i2s_pre_div1 = 1/2*/
}
}
else if (RT5616_DEVICE_OFF == enable)
{
alc5616_write(0xFA, 0x0000); /*Disable MCLK Input*/
if (3 == Audio_Codec_Fsync_Rate)
{
printk(KERN_INFO"%s, sys clock comes from PLL when Fsync = 48K.\n", __FUNCTION__);
alc5616_update_bit(0x64, 1 << 9, 0); /*PLL Power Off*/
}
}
#else
int bclk_type = BCLK_256_FS;
if (RT5616_DEVICE_ON == enable)
{
alc5616_update_bit(0xFA, 1, 1); /*Enable MCLK Input*/
alc5616_update_bit(0x64, 1 << 9, 1 << 9); /*PLL Power On*/
alc5616_update_bit(0x73, 3 << 2, 0 << 2); /*128Fs*/
alc5616_update_bit(0x73, 3, 2); /*32Fs*/
if(1 == g_5616_mclk_type){/*use I2S_SYSCLK as MCLK , 2.048M/4.096M*/
alc5616_update_bit(0x73, 7 << 12, 0 << 12); /*I2S Clock Pre-Divider = 0 for divide 1*/
}
else if(0 == g_5616_mclk_type){//using bitclk as 5616 mclk
alc5616_update_bit(0x73, 7 << 12, 0 << 12); /*I2S Clock Pre-Divider = 0 for divide 1*/
alc5616_update_bit(0x80, 3 << 14, 1 << 14); /*System Clock from PLL*/
alc5616_update_bit(0x80, 3 << 12, 1 << 12); /*PLL from bclk*/
alc5616_update_bit(0x82, 1 << 11, 1 << 11); /*PLL M bypass */
if(BCLK_64_FS == bclk_type){ // 64fs
alc5616_update_bit(0x81, 0x1FF << 7 , 6 << 7);/*PLL K = 0,PLL N = 6*/
}
else if(BCLK_128_FS == bclk_type){// 128fs
alc5616_update_bit(0x81, 0x1FF << 7 , 2 << 7);/*PLL K = 0,PLL N = 2*/
}
else if(BCLK_256_FS == bclk_type){// 256fs
alc5616_update_bit(0x81, 0x1FF << 7 , 0 << 7);/*PLL K = 0,PLL N = 0*/
}
else if(BCLK_32_FS == bclk_type){// 32fs
alc5616_update_bit(0x81, 0x1FF << 7 , 14 << 7);/*PLL K = 0,PLL N = 14*/
}
}
}
else if (RT5616_DEVICE_OFF == enable)
{
alc5616_update_bit(0xFA, 1, 0); /*disable MCLK Input*/
alc5616_update_bit(0x64, 1 << 9, 0); /*PLL Power off*/
}
#endif
}
static void rt5616_set_sys_power(char enable)
{
if (RT5616_DEVICE_ON == enable)
{
alc5616_update_bit(0x63, 1 << 11, 1 << 11); /*MICBIAS Bandgap Power On*/
alc5616_update_bit(0x63, 1 << 15, 1 << 15); /*VREF1 Power On*/
alc5616_update_bit(0x63, 1 << 14, 1 << 14); /*VREF Slow*/
alc5616_update_bit(0x63, 1 << 4, 1 << 4); /*VREF2 Power On*/
alc5616_update_bit(0x63, 1 << 3, 1 << 3); /*VREF2 Slow*/
alc5616_update_bit(0x63, 1 << 13, 1 << 13); /*MBIAS Power On*/
alc5616_update_bit(0x61, 1 << 15, 1 << 15); /*I2S Power On*/
alc5616_update_bit(0x8E, 1 << 3, 1 << 3); /*Charge Pump Power On*/
alc5616_update_bit(0x64, 1 << 11, 1 << 11); /*MICBIAS1 Power On*/
}
else if (RT5616_DEVICE_OFF == enable)
{
alc5616_update_bit(0x63, 1 << 11, 0); /*MICBIAS Bandgap Power Off*/
alc5616_update_bit(0x63, 1 << 15, 0); /*VREF1 Power Off*/
alc5616_update_bit(0x63, 1 << 14, 0); /*VREF Slow*/
alc5616_update_bit(0x63, 1 << 4, 0); /*VREF2 Power Off*/
alc5616_update_bit(0x63, 1 << 3, 0); /*VREF2 Slow*/
alc5616_update_bit(0x63, 1 << 13, 0); /*MBIAS Power Off*/
alc5616_update_bit(0x61, 1 << 15, 0); /*I2S Power Off*/
alc5616_update_bit(0x8E, 1 << 3, 0); /*Charge Pump Power Off*/
alc5616_update_bit(0x64, 1 << 11, 0); /*MICBIAS1 Power Off*/
}
}
static void rt5616_device_enable(char device, char enable)
{
int length;
int index;
struct reg_value_group *reg_group = NULL;
if ((device == RT5616_OUTPUT_DEVICE_SPEAKER) && (enable == RT5616_DEVICE_ON))
{
reg_group = rt5616_speaker_on_reg_group;
length = RT5616_SPEAKER_ON_REG_GROUP_NUM;
}
else if ((device == RT5616_OUTPUT_DEVICE_SPEAKER) && (enable == RT5616_DEVICE_OFF))
{
reg_group = rt5616_speaker_off_reg_group;
length = RT5616_SPEAKER_OFF_REG_GROUP_NUM;
}
else if ((device == RT5616_OUTPUT_DEVICE_HEADPHONE) && (enable == RT5616_DEVICE_ON))
{
reg_group = rt5616_headphone_on_reg_group;
length = RT5616_HEADPHONE_ON_REG_GROUP_NUM;
}
else if ((device == RT5616_OUTPUT_DEVICE_HEADPHONE) && (enable == RT5616_DEVICE_OFF))
{
reg_group = rt5616_headphone_off_reg_group;
length = RT5616_HEADPHONE_OFF_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_MAIN_MIC) && (enable == RT5616_DEVICE_ON))
{
if(g_5616_mainmic_type == 0)
reg_group = rt5616_main_mic_on_reg_group;
else
reg_group = rt5616_main_mic_on_reg_group_singlemode;
length = RT5616_MAIN_MIC_ON_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_MAIN_MIC) && (enable == RT5616_DEVICE_OFF))
{
reg_group = rt5616_main_mic_off_reg_group;
length = RT5616_MAIN_MIC_OFF_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_HEADSET_MIC) && (enable == RT5616_DEVICE_ON))
{
reg_group = rt5616_headset_mic_on_reg_group;
length = RT5616_HEADSET_MIC_ON_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_HEADSET_MIC) && (enable == RT5616_DEVICE_OFF))
{
reg_group = rt5616_headset_mic_off_reg_group;
length = RT5616_HEADSET_MIC_OFF_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_HEADSET_DETECT) && (enable == RT5616_DEVICE_ON))
{
reg_group = rt5616_headset_detect_on_reg_group;
length = RT5616_HEADSET_DETECT_ON_REG_GROUP_NUM;
}
else if ((device == RT5616_INPUT_DEVICE_HEADSET_DETECT) && (enable == RT5616_DEVICE_OFF))
{
reg_group = rt5616_headset_detect_off_reg_group;
length = RT5616_HEADSET_DETECT_OFF_REG_GROUP_NUM;
}
if (reg_group == NULL)
return;
if (enable == RT5616_DEVICE_ON)
{
for (index = 0; index < length; index++)
{
if (reg_group[index].reg != 0x3D)
alc5616_update_bit(reg_group[index].reg, reg_group[index].mask, reg_group[index].value);
else
alc5616_index_update_bits(reg_group[index].reg, reg_group[index].mask, reg_group[index].value);
}
rt5616_set_work_state(device, enable);
//printk(KERN_INFO"device enabled:%e{RT5616_DEVICE}", device);
}
else if (enable == RT5616_DEVICE_OFF)
{
for (index = 0; index < length; index++)
{
if (reg_group[index].reg != 0x3D)
alc5616_update_bit(reg_group[index].reg, reg_group[index].mask, reg_group[index].value);
else
alc5616_index_update_bits(reg_group[index].reg, reg_group[index].mask, reg_group[index].value);
}
rt5616_set_work_state(device, enable);
//printk(KERN_INFO"device disabled:%e{RT5616_DEVICE}", device);
}
}
static void rt5616_speaker_enable(char enable)
{
#ifdef RECONFIGURE_POWER_INCALL
rt5616_set_dai_fmt(enable);
rt5616_set_sysclk(enable);
rt5616_set_sys_power(enable);
#endif
rt5616_device_enable(RT5616_OUTPUT_DEVICE_SPEAKER, enable);
return;
}
static void rt5616_headphone_enable(char enable)
{
#ifdef RECONFIGURE_POWER_INCALL
rt5616_set_dai_fmt(enable);
rt5616_set_sysclk(enable);
rt5616_set_sys_power(enable);
#endif
rt5616_device_enable(RT5616_OUTPUT_DEVICE_HEADPHONE, enable);
return;
}
static void rt5616_main_mic_enable(char enable)
{
#ifdef RECONFIGURE_POWER_INCALL
rt5616_set_dai_fmt(enable);
rt5616_set_sysclk(enable);
rt5616_set_sys_power(enable);
#endif
rt5616_device_enable(RT5616_INPUT_DEVICE_MAIN_MIC, enable);
return;
}
static void rt5616_headset_mic_enable(char enable)
{
#ifdef RECONFIGURE_POWER_INCALL
rt5616_set_dai_fmt(enable);
rt5616_set_sysclk(enable);
rt5616_set_sys_power(enable);
#endif
rt5616_device_enable(RT5616_INPUT_DEVICE_HEADSET_MIC, enable);
return;
}
static void rt5616_device_select(char device, char onoff)
{
if (rt5616_init_ok == 0)
{
printk(KERN_INFO"rt5616 not init\n");
return;
}
switch (onoff)
{
case RT5616_DEVICE_ON:
if (device == RT5616_OUTPUT_DEVICE_SPEAKER)
{
if (is_speaker_on())
{
printk(KERN_INFO"already enabled\n");
return;
}
else
{
if (is_headphone_on())
{
rt5616_headphone_enable(RT5616_DEVICE_OFF);
}
rt5616_speaker_enable(RT5616_DEVICE_ON);
}
}
else if (device == RT5616_OUTPUT_DEVICE_HEADPHONE)
{
if (is_headphone_on())
{
printk(KERN_INFO"already enabled\n");
return;
}
else
{
if (is_speaker_on())
{
rt5616_speaker_enable(RT5616_DEVICE_OFF);
}
rt5616_headphone_enable(RT5616_DEVICE_ON);
}
}
else if (device == RT5616_INPUT_DEVICE_MAIN_MIC)
{
if (is_main_mic_on())
{
printk(KERN_INFO"already enabled\n");
return;
}
else
{
if (is_headset_mic_on())
{
rt5616_headset_mic_enable(RT5616_DEVICE_OFF);
}
rt5616_main_mic_enable(RT5616_DEVICE_ON);
}
}
else if (device == RT5616_INPUT_DEVICE_HEADSET_MIC)
{
if (is_headset_mic_on())
{
printk(KERN_INFO"already enabled\n");
return;
}
else
{
if (is_main_mic_on())
{
rt5616_main_mic_enable(RT5616_DEVICE_OFF);
}
rt5616_headset_mic_enable(RT5616_DEVICE_ON);
}
}
break;
case RT5616_DEVICE_OFF:
if (device == RT5616_OUTPUT_DEVICE_SPEAKER)
{
if (!is_speaker_on())
{
printk(KERN_INFO"already disabled\n");
return;
}
else
{
rt5616_speaker_enable(RT5616_DEVICE_OFF);
}
}
else if (device == RT5616_OUTPUT_DEVICE_HEADPHONE)
{
if (!is_headphone_on())
{
printk(KERN_INFO"already disabled\n");
return;
}
else
{
rt5616_headphone_enable(RT5616_DEVICE_OFF);
}
}
else if (device == RT5616_INPUT_DEVICE_MAIN_MIC)
{
if (!is_main_mic_on())
{
printk(KERN_INFO"already disabled\n");
return;
}
else
{
rt5616_main_mic_enable(RT5616_DEVICE_OFF);
}
}
else if (device == RT5616_INPUT_DEVICE_HEADSET_MIC)
{
if (!is_headset_mic_on())
{
printk(KERN_INFO"already disabled\n");
return;
}
else
{
rt5616_headset_mic_enable(RT5616_DEVICE_OFF);
}
}
if (is_speaker_on())
rt5616_speaker_enable(RT5616_DEVICE_ON);
if (is_headphone_on())
rt5616_headphone_enable(RT5616_DEVICE_ON);
if (is_main_mic_on())
rt5616_main_mic_enable(RT5616_DEVICE_ON);
if (is_headset_mic_on())
rt5616_headset_mic_enable(RT5616_DEVICE_ON);
break;
default:
break;
}
}
void codec_rt5616_set_headphone_gain(void)
{
#if 0
// -6db
alc5616_update_bit(0x45, (1 << 12), (1 << 12));
#else
alc5616_write(0x45, 0x5000);
#endif
return;
}
void codec_rt5616_set_headphone_mic_gain(void)
{
#if 0
// +24db
alc5616_update_bit(0x1c, (0x7F << 8), (0x6F << 8));
alc5616_update_bit(0x1c, (0x7F << 0), (0x6F << 0));
// +24db: Boost will cause something like white noise in background, so just remove it.
//alc5616_update_bit(0x1E, (3 << 14), (2 << 14));
//alc5616_update_bit(0x1E, (3 << 12), (2 << 12));
#else
alc5616_write(0x1c, 0x6f6f);
#endif
return;
}
void codec_rt5616_mute_headphone(int mute)
{
if(mute){
alc5616_update_bit(0x02, (1 << 15), (1 << 15));
alc5616_update_bit(0x02, (1 << 7), (1 << 7));
}
else{
alc5616_update_bit(0x02, (1 << 15), (0 << 15));
alc5616_update_bit(0x02, (1 << 7), (0 << 7));
}
return;
}
void codec_rt5616_mute_speaker(int mute)
{
if(mute){
alc5616_update_bit(0x03, (1 << 15), (1 << 15));
alc5616_update_bit(0x03, (1 << 7), (1 << 7));
}
else{
alc5616_update_bit(0x03, (1 << 15), (0 << 15));
alc5616_update_bit(0x03, (1 << 7), (0 << 7));
}
return;
}
void codec_rt5616_set_speaker_mic_gain(void)
{
// +0db
alc5616_update_bit(0x1c, (0x7F << 8), (0x2F << 8));
alc5616_update_bit(0x1c, (0x7F << 0), (0x2F << 0));
return;
}
void codec_rt5616_enable_headphone_main_mic(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_headphone_main_mic\n");
#ifdef RECONFIGURE_POWER_INCALL
enable_5616_MClock();
#endif
rt5616_device_select(RT5616_OUTPUT_DEVICE_HEADPHONE, RT5616_DEVICE_ON);
rt5616_device_select(RT5616_INPUT_DEVICE_MAIN_MIC, RT5616_DEVICE_ON);
codec_rt5616_set_headphone_gain();
return;
}
void codec_rt5616_enable_headphone(void)
{
if(disableRt5616HsMic){
return codec_rt5616_enable_headphone_main_mic();
}
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_headphone\n");
#ifdef RECONFIGURE_POWER_INCALL
enable_5616_MClock();
#endif
rt5616_device_select(RT5616_OUTPUT_DEVICE_HEADPHONE, RT5616_DEVICE_ON);
rt5616_device_select(RT5616_INPUT_DEVICE_HEADSET_MIC, RT5616_DEVICE_ON);
codec_rt5616_set_headphone_gain();
codec_rt5616_set_headphone_mic_gain();
return;
}
void codec_rt5616_enable_headphone_only(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_headphone_only\n");
#ifdef RECONFIGURE_POWER_INCALL
enable_5616_MClock();
#endif
rt5616_device_select(RT5616_OUTPUT_DEVICE_HEADPHONE, RT5616_DEVICE_ON);
return;
}
void codec_rt5616_enable_main_mic_only(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_main_mic_only\n");
#ifdef RECONFIGURE_POWER_INCALL
enable_5616_MClock();
#endif
rt5616_device_select(RT5616_INPUT_DEVICE_HEADSET_MIC, RT5616_DEVICE_ON);
return;
}
void codec_rt5616_enable_speaker(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_speaker\n");
#ifdef RECONFIGURE_POWER_INCALL
enable_5616_MClock();
#endif
rt5616_device_select(RT5616_OUTPUT_DEVICE_SPEAKER, RT5616_DEVICE_ON);
rt5616_device_select(RT5616_INPUT_DEVICE_MAIN_MIC, RT5616_DEVICE_ON);
codec_rt5616_set_speaker_mic_gain();
return;
}
void codec_rt5616_enable_speaker_only(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_speaker_only\n");
rt5616_device_select(RT5616_OUTPUT_DEVICE_SPEAKER, RT5616_DEVICE_ON);
return;
}
void codec_rt5616_disable_path(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_disable_path\n");
if(is_speaker_on()){
rt5616_device_select(RT5616_OUTPUT_DEVICE_SPEAKER, RT5616_DEVICE_OFF);
}
if(is_headphone_on()){
rt5616_device_select(RT5616_OUTPUT_DEVICE_HEADPHONE, RT5616_DEVICE_OFF);
}
if(is_main_mic_on()){
rt5616_device_select(RT5616_INPUT_DEVICE_MAIN_MIC, RT5616_DEVICE_OFF);
}
if(is_headset_mic_on()){
rt5616_device_select(RT5616_INPUT_DEVICE_HEADSET_MIC, RT5616_DEVICE_OFF);
}
#ifdef RECONFIGURE_POWER_INCALL
disable_5616_MClock();
#endif
return;
}
//Kestrel/Falcon/NezhaC
void disable_5616_MClock(void)
{
printk(KERN_INFO"disable_5616_MClock, g_5616_mclk_type=%d\n", g_5616_mclk_type);
#if 0 //yjg
if(g_5616_mclk_type){
/*GPIO-20 function 0 (default), GPIO-20*/
/* *(volatile unsigned long *)(SSP1_I2S_CLOCK_REG_ADDR) = 0x7820130B; *//*8k, sysclk_en = 0*/
/* *(volatile unsigned long *)(MFPRX_GPIO_20) = 0xB0C0; */
iounmap(i2s_clk_reg);
release_mem_region(SSP1_I2S_CLOCK_REG_ADDR, 4);
}
#endif
return;
}
extern char * get_MCLK_start_addr(void);
#ifdef CONFIG_CPU_ASR1901
extern int enable_pmu_audio_clk(void);
#endif
//Kestrel/Flacon/NezhaC
void enable_5616_MClock(void)
{
#ifdef ALC5616_DEBUG_CLOSE
int reg_value = 0;
printk(KERN_INFO"enable_5616_MClock, g_5616_mclk_type=%d, Audio_Codec_Fsync_Rate=%d\n", g_5616_mclk_type, Audio_Codec_Fsync_Rate);
if (cpu_is_asr1803()) {
printk(KERN_INFO"%s, platform is Falcon.\n", __FUNCTION__);
} else if (cpu_is_asr1806()) {
printk(KERN_INFO"%s, platform is Falcon-T.\n", __FUNCTION__);
} else if (cpu_is_asr1901() || cpu_is_asr1906()) {
printk(KERN_INFO"%s, platform is Kestrel.\n", __FUNCTION__);
} else if (cpu_is_asr1903()) {
printk(KERN_INFO"%s, platform is Lapwing.\n", __FUNCTION__);
} else {
printk(KERN_INFO"%s, platform is Nezhac or Nezha3.\n", __FUNCTION__);
}
#endif
if (of_get_property(g_alc5616_node, "asr,mclk-from-bclk", NULL)) {
//bypass I2S_clock setting
printk(KERN_INFO"%s, mclk-from-bclk.\n", __FUNCTION__);
return;
}
if (cpu_is_asr1901() || cpu_is_asr1906()) {
printk(KERN_INFO"%s, platform is kestrel.\n", __FUNCTION__);
#ifdef Kestrel_Z2
__raw_writel(0x1043, VCXO_OUT_MFPR_reg);
__raw_writel(0x3, PM_MN_CLK_reg);
if(0 == Audio_Codec_Fsync_Rate){
/* config 2.048MHz MCLK for 8KHz Fsync of PCM */
__raw_writel(0x00980001, GPCR_reg);
} else {
/* config 4.096MHz MCLK for 16KHz Fsync of PCM */
__raw_writel(0x004c0001, GPCR_reg);
}
printk(KERN_INFO"%s, VCXO_OUT_MFPR_reg is 0x%0x, PM_MN_CLK_reg is 0x%0x, GPCR_reg is 0x%0x.\n",
__FUNCTION__, *(unsigned int *)VCXO_OUT_MFPR_reg, *(unsigned int *)PM_MN_CLK_reg, *(unsigned int *)GPCR_reg);
#else
MCLK_CLK_CTRL_reg = get_MCLK_start_addr();
if (NULL == MCLK_CLK_CTRL_reg) {
printk(KERN_INFO "%s, MCLK_CLK_CTRL_reg is NULL.\n", __FUNCTION__);
return;
}
MCLK_MN_DIV_reg = (char *)MCLK_CLK_CTRL_reg + 4;
__raw_writel(0x3, MCLK_CLK_CTRL_reg);
if(0 == Audio_Codec_Fsync_Rate){
/* config 2.048MHz MCLK for 8KHz Fsync of PCM */
__raw_writel(0x004b0004, MCLK_MN_DIV_reg);
} else if (1 == Audio_Codec_Fsync_Rate){
/* config 4.096MHz MCLK for 16KHz Fsync of PCM */
__raw_writel(0x004b0008, MCLK_MN_DIV_reg);
} else if (3 == Audio_Codec_Fsync_Rate) {
/* config 12.288MHz MCLK for 48KHz Fsync of PCM */
//__raw_writel(0x004b0018, MCLK_MN_DIV_reg);//1.MCLK 12.288MHz direct connection
__raw_writel(0x000a0001, MCLK_MN_DIV_reg);//MCLK 3.84MHz for PLL and for HP detection
alc5616_write(0x73, 0x1002);
alc5616_write(0x80, 0x4000);//2.MCLK 3.84MHz for PLL
//alc5616_write(0x80, 0x5000);//3.BCLK 3.84MHz for PLL
alc5616_write(0x81, 0x3F02);
alc5616_write(0x82, 0x3000);
} else {
printk(KERN_INFO"%s, please check Audio_Codec_Fsync_Rate = %d.\n",__FUNCTION__, Audio_Codec_Fsync_Rate);
}
printk(KERN_INFO"%s, Audio_Codec_Fsync_Rate = %d.\n",__FUNCTION__, Audio_Codec_Fsync_Rate);
printk(KERN_INFO"%s, MCLK_CLK_CTRL_reg is 0x%0x, MCLK_MN_DIV_reg is 0x%0x.\n",
__FUNCTION__, *(unsigned int *)MCLK_CLK_CTRL_reg, *(unsigned int *)MCLK_MN_DIV_reg);
#endif
} else {
struct clk * mclk;
int ret;
printk(KERN_INFO"%s, platform is NezhaC, Falcon, .etc.\n", __FUNCTION__);
mclk = devm_clk_get(&g_alc5616_client->dev, "i2s_sys_clk");
if(IS_ERR(mclk)){
printk(KERN_INFO"mclk get failed\n");
return;
}
ret = clk_prepare_enable(mclk);
if(ret){
printk(KERN_INFO"mclk prepare enable failed");
return;
}
if(g_5616_mclk_type){
int rate;
if(0 == Audio_Codec_Fsync_Rate){
/*i2s_sysclk = 2M for 8k*/
#ifdef ALC5616_DEBUG_CLOSE
reg_value = ioread32(SSP1_I2S_CLOCK_reg);
//reg_value = *(volatile int*)(i2s_clk_reg);
printk(KERN_INFO"read: reg_value=0x%x\n", reg_value);
//printk(KERN_INFO"read: *register_address = 0x%x, reg_value=0x%x\n",
//*(unsigned int *)i2s_clk_reg, reg_value);
#endif
clk_set_rate(mclk, 2048000);
rate = clk_get_rate(mclk);
printk(KERN_INFO"mclk rate is %d", rate);
/* write value to register */
//*(volatile unsigned int *)i2s_clk_reg = 0xF820130B;
#ifdef ALC5616_DEBUG_CLOSE
/* read value from register */
printk(KERN_INFO"NB, write:0xF820130B(Nezhac, Nezha3),0xE0C472D8(Falcon),*register_address = 0x%x\n", *(unsigned int *)SSP1_I2S_CLOCK_reg);
#endif
}
else{
/*i2s_sysclk = 4M for 16k*/
#ifdef ALC5616_DEBUG_CLOSE
reg_value = ioread32(SSP1_I2S_CLOCK_reg);
printk(KERN_INFO"read: reg_value=0x%x\n", reg_value);
//printk(KERN_INFO"read: *register_address = %x\n", *(unsigned int *)i2s_clk_reg);
//reg_value = *(volatile int*)(i2s_clk_reg);
//printk(KERN_INFO"read: *register_address = 0x%x, reg_value=0x%x\n",
//*(unsigned int *)i2s_clk_reg, reg_value);
#endif
clk_set_rate(mclk, 4096000);
rate = clk_get_rate(mclk);
printk(KERN_INFO"mclk rate is %d", rate);
#ifdef ALC5616_DEBUG_CLOSE
/* write value to register */
//*(volatile unsigned int *)i2s_clk_reg = 0xF840130B;
/* read value from register */
printk(KERN_INFO"WB, write: 0xF840130B(Nezhac, Nezha3),0xE18872D8(Falcon), *register_address = %x\n", *(unsigned int *)SSP1_I2S_CLOCK_reg);
#endif
}
}
}
return;
}
EXPORT_SYMBOL_GPL(enable_5616_MClock);
void codec_rt5616_power_on(void)
{
printk(KERN_INFO"codec_rt5616_power_on\n");
enable_5616_MClock();
rt5616_set_dai_fmt(1);
rt5616_set_sysclk(1);
rt5616_set_sys_power(1);
}
void codec_rt5616_power_off(void)
{
printk(KERN_INFO"codec_rt5616_power_off\n");
rt5616_set_dai_fmt(0);
rt5616_set_sysclk(0);
rt5616_set_sys_power(0);
disable_5616_MClock();
}
void codec_rt5616_enable_headset_detect(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_enable_headset_detect\n");
g_5616_headset_detection_enabled = 1;
g_5616_headset_plugged = 0;
rt5616_device_enable(RT5616_INPUT_DEVICE_HEADSET_DETECT, 1);
return;
}
void codec_rt5616_disable_headset_detect(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_disable_headset_detect\n");
rt5616_device_enable(RT5616_INPUT_DEVICE_HEADSET_DETECT, 0);
g_5616_headset_detection_enabled = 0;
return;
}
/* HS Detection */
static struct mfd_cell headset_devs_alc5616[] = {
{
.name = "alc5616-headset",
.id = -1,
},
};
static void alc5616_headset_detection_init(struct i2c_client *client)
{
int ret = 0;
headset_devs_alc5616[0].platform_data = client;
headset_devs_alc5616[0].pdata_size = sizeof(struct i2c_client);
ret = mfd_add_devices(&client->dev, 0, &headset_devs_alc5616[0],
ARRAY_SIZE(headset_devs_alc5616), NULL,
0,
NULL);
if (ret) {
printk(KERN_INFO"Failed to add headset subdev\n");
return;
}
return;
}
void codec_alc5616_switch_headset(char on)
{
if(on == 1)
{
//codec_rt5616_disable_path();
//msleep(10);
//ACMSetMSAVoicePath(ATC_HEADSET);
codec_rt5616_enable_headphone();
}
else
{
//codec_rt5616_disable_path();
//msleep(10);
//ACMSetMSAVoicePath(ATC_HANDSET);
codec_rt5616_enable_speaker();
}
return;
}
/* Headset function and report to userspace for ACM */
void alc5616_get_headset_status(void)
{
unsigned short value = 0;
int status = -1;
if(!codec_rt5616_is_connect()) {return;}
status = alc5616_read(0xBF, &value);
if(0 != status)
{
printk(KERN_INFO"%s: Read register [0xBF] error = 0x%x\n", __FUNCTION__, status);
return;
}
if((value & 0x3000) == 0)
{/* headset plug in: bit 12 & 13 is 1 */
g_5616_headset_plugged = 1;
/* Enable MICBIAS1 Short Current Detector, Threshold:1500uA */
alc5616_update_bit(0x93, (7 << 9), (5 << 9));
/* wait mic bias stable*/
mdelay(100);
value = 0;
status = alc5616_read(0xBE, &value);
if(0 != status)
{
printk(KERN_INFO"%s: Read register [0xBE] error = 0x%x\n", __FUNCTION__, status);
return;
}
/* MICBIAS1 Over Current status */
if((1 == g_5616_headset_plugged) && ((value & (1 << 3)) == 0))
{
/* Headset with mic */
g_5616_headset_mic = 1;
printk(KERN_INFO"Headset(with mic) plugin!\n");
}
else if((1 == g_5616_headset_plugged) && ((value & (1 << 3)) != 0))
{
/* Headset without mic */
g_5616_headset_mic = 0;
printk(KERN_INFO"Headset(without mic) plugin!\n");
}
}
else if((value & 0x3000) == 0x3000)
{/* headset plug out: bit 12 & 13 is 0 */
g_5616_headset_plugged = 0;
g_5616_headset_mic = 0;
/* Disable MICBIAS1 Short Current Detector */
alc5616_update_bit(0x93, (7 << 9), (0 << 9));
printk(KERN_INFO"Headset plugout!\n");
}
return;
}
int alc5616_get_headset_mic_status(void)
{
return g_5616_headset_mic;
}
EXPORT_SYMBOL_GPL(alc5616_get_headset_mic_status);
int alc5616_get_headset_plugged_status(void)
{
return g_5616_headset_plugged;
}
EXPORT_SYMBOL_GPL(alc5616_get_headset_plugged_status);
void codec_rt5616_clear_headset_status(void)
{
if(!codec_rt5616_is_connect()) {return;}
printk(KERN_INFO"codec_rt5616_clear_headset_status\n");
alc5616_write(0xBF, 0);
return;
}
void codec_rt5616_use_bitclk(void)
{
printk(KERN_INFO"codec_rt5616_use_bitclk\n");
g_5616_mclk_type = 0;
return;
}
void codec_rt5616_use_bitclk_with_mclk_on(void)
{
printk(KERN_INFO"codec_rt5616_use_bitclk_with_mclk_on\n");
g_5616_mclk_type = 2;
return;
}
void codec_rt5616_set_mainmic_singlemode(void)
{
printk(KERN_INFO"codec_rt5616_set_mainmic_singlemode\n");
g_5616_mainmic_type = 1;
return;
}
void alc5616_Enable_Headsetdetection(void)
{
/* Init headset detection for ALC5616 */
if(codec_rt5616_is_connect() && (g_5616_headset_detection_enabled == 0))
{
codec_rt5616_enable_headset_detect();
}
}
EXPORT_SYMBOL_GPL(alc5616_Enable_Headsetdetection);
void alc5616_Disable_Headsetdetection(void)
{
/* Init headset detection for ALC5616 */
if(codec_rt5616_is_connect() && (g_5616_headset_detection_enabled == 1))
{
codec_rt5616_disable_headset_detect();
}
}
EXPORT_SYMBOL_GPL(alc5616_Disable_Headsetdetection);
void codec_rt5616_dump(void)
{
rt5616_reg_dump();
}
/* debug fs for alc5616 register interface of read and write. */
static int reg_alc5616 = 0xffff;
struct dentry *alc5616_dump_reg = NULL;
static ssize_t alc5616_dump_read(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
unsigned short reg_val = 0;
unsigned short out_val = 0;
int i;
int len = 0;
char str[100] = {0};
if (reg_alc5616 == 0xffff) {
len = snprintf(str, sizeof(str) - 1, "%s\n",
"alc5616: register dump:");
for (i = 0; i < ALC5616_REG_NUM; i++) {
if (alc5616_readable_register(i)) {
if (0x3D == i)
{
reg_val = alc5616_index_read(i, &out_val);
}
else
{
reg_val = alc5616_read(i, &out_val);
}
pr_info("%s: [0x%02x]=0x%04x\n", __FUNCTION__, i, out_val);
}
}
} else {
/*
0xFF:get MIC Gain and Speaker Gain
echo 0xFF 4 > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
*/
if (0xFF == reg_alc5616)
{
/* adjust the gain. */
}
else if (0x3D == reg_alc5616)
{
reg_val = alc5616_index_read(reg_alc5616, &out_val);
len = snprintf(str, sizeof(str), "reg_alc5616=0x%02x, val=0x%04x\n",
reg_alc5616, out_val);
printk(KERN_INFO"%s:%s\n", __FUNCTION__, str);
}
else
{
reg_val = alc5616_read(reg_alc5616, &out_val);
len = snprintf(str, sizeof(str), "reg_alc5616=0x%02x, val=0x%04x\n",
reg_alc5616, out_val);
printk(KERN_INFO"%s:%s\n", __FUNCTION__, str);
}
}
return 0;
}
/*
read example:
echo 0x90 > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
read all register:
echo + > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
write example: echo 0x90 0x10 > /sys/kernel/debug/alc5616_reg
read register example:
echo 0x3F > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
read all registers example:
echo + > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
config Gain example:
echo 0xFF 0x00 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x01 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x02 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x03 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x04 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x05 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x06 > /sys/kernel/debug/alc5616_reg
echo 0xFF 0x07 > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
write the register example:
echo 0x2C 0x01 > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
*/
static ssize_t alc5616_dump_write(struct file *file,
const char __user *user_buf,
size_t count, loff_t *ppos)
{
int reg_val;
//struct pm80x_chip *chip = file->private_data;
int i = 0;
int ret;
char messages[20];
memset(messages, '\0', 20);
if (copy_from_user(messages, user_buf, count))
return -EFAULT;
if ('+' == messages[0]) {
/* enable to get all the reg value */
reg_alc5616 = 0xffff;
pr_info("%s: read all reg enabled!\n", __FUNCTION__);
} else {
if (messages[1] != 'x') {
pr_err("Right format: 0x[addr]\n");
return -EINVAL;
}
if (strlen(messages) > 5) {
while (messages[i] != ' ')
i++;
messages[i] = '\0';
if (kstrtouint(messages, 16, &reg_alc5616) < 0)
return -EINVAL;
i++;
if (kstrtouint(messages + i, 16, &reg_val) < 0)
return -EINVAL;
/*
0xFF:set MIC Gain and Speaker Gain
value(0x00~0x07)
echo 0xFF value > /sys/kernel/debug/alc5616_reg
cat /sys/kernel/debug/alc5616_reg
*/
if (0xFF == reg_alc5616)
{
/* adjust the gain within 0~10 */
extern void alc5616_adjust_gain(int gain);
alc5616_adjust_gain(reg_val);
}
else if (0x3D == reg_alc5616)
{
/* config the registers */
ret = alc5616_index_write(reg_alc5616, reg_val & 0xffff);
if (ret < 0) {
pr_err("write reg error!\n");
return -EINVAL;
}
printk(KERN_INFO"%s/L%d: addr=0x%02x, val=0x%04x.\n", __FUNCTION__, __LINE__, reg_alc5616, reg_val);
}
else
{
/* config the registers */
ret = alc5616_write(reg_alc5616, reg_val & 0xffff);
if (ret < 0) {
pr_err("write reg error!\n");
return -EINVAL;
}
printk(KERN_INFO"%s/L%d: addr=0x%02x, val=0x%04x.\n", __FUNCTION__, __LINE__, reg_alc5616, reg_val);
}
} else {
/* point out the register address for read. */
if (kstrtouint(messages, 16, &reg_alc5616) < 0)
return -EINVAL;
}
}
return count;
}
static const struct file_operations alc5616_dump_ops = {
.open = simple_open,
.read = alc5616_dump_read,
.write = alc5616_dump_write,
};
static inline int alc5616_dump_debugfs_init(struct pm80x_chip *chip)
{
alc5616_dump_reg = debugfs_create_file("alc5616_reg", S_IRUGO | S_IFREG,
NULL, NULL, &alc5616_dump_ops);
if (alc5616_dump_reg == NULL) {
pr_err("create alc5616 debugfs error!\n");
return -ENOENT;
} else if (alc5616_dump_reg == ERR_PTR(-ENODEV)) {
pr_err("CONFIG_DEBUG_FS is not enabled!\n");
return -ENOENT;
}
return 0;
}
static void alc5616_dump_debugfs_remove(struct pm80x_chip *chip)
{
if (NULL != alc5616_dump_reg){
debugfs_remove_recursive(alc5616_dump_reg);
}
return;
}
/* debug fs for alc5616 audio control of Earphone, speaker or HS... */
struct dentry *alc5616_audio_control = NULL;
static ssize_t alc5616_audio_read(struct file *file, char __user *user_buf,
size_t count, loff_t *ppos)
{
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
#endif
return 0;
}
/*
1:enable earphone, enable MIC1
2:disable earphone, enable MIC1
3:enable speaker, enable MIC1
4:disable speaker, enable MIC1
5:enable Headphone, enable HSMIC
6:disable Headphone, enable HSMIC
control command:
enable earphone and MIC1: echo 1 > /sys/kernel/debug/alc5616_audio
disable earphone and MIC1: echo 2 > /sys/kernel/debug/alc5616_audio
enable speaker and MIC1: echo 3 > /sys/kernel/debug/alc5616_audio
disable speaker and MIC1: echo 4 > /sys/kernel/debug/alc5616_audio
enable Headphone and HSMIC echo 5 > /sys/kernel/debug/alc5616_audio
disable Headphone and HSMIC echo 6 > /sys/kernel/debug/alc5616_audio
*/
static char msg[10];
static ssize_t alc5616_audio_write(struct file *file,
const char __user *user_buf,
size_t count, loff_t *ppos)
{
int ret = 0;
size_t tmp_count = 0;
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
memset(msg, 0x00, sizeof(msg));
tmp_count = count;
if (tmp_count >= sizeof(msg)){
tmp_count = sizeof(msg) - 1;
}
/* copy the content from user space to kernel space */
ret = copy_from_user(msg, user_buf, tmp_count);
if (ret){
printk(KERN_ALERT"copy from user fail \n");
return -EFAULT;
}
switch (msg[0]){
case '1':/* input command# echo 1 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
alc5616_check_HS_mic();
break;
case '2':/* input command# echo 2 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
enable_5616_MClock();
alc5616_speaker_off();
alc5616_main_mic_off();
break;
case '3':/* input command# echo 3 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
enable_5616_MClock();
alc5616_headphone_on();
alc5616_headset_mic_on();
break;
case '4':/* input command# echo 4 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
codec_rt5616_enable_headset_detect();
break;
case '5':/* input command# echo 5 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
enable_5616_MClock();
alc5616_headphone_off();
alc5616_headset_mic_off();
break;
case '6':/* input command# echo 6 > /sys/kernel/debug/alc5616_audio */
printk(KERN_INFO "input %c. \n", msg[0]);
alc5616_mute_mic(1);
break;
case '7':/* input command# echo 7 > /sys/kernel/debug/alc5616_audio */
enable_5616_MClock();
alc5616_speaker_on();
alc5616_main_mic_on();
break;
case '8':/* input command# echo 8 > /sys/kernel/debug/alc5616_audio */
enable_5616_MClock();
alc5616_speaker_off();
alc5616_main_mic_off();
break;
case '9':/* input command# echo 9 > /sys/kernel/debug/alc5616_audio */
enable_5616_MClock();
codec_rt5616_enable_headphone_main_mic();
break;
default:/* input command# */
printk(KERN_INFO "input invalid. \n");
break;
}
return tmp_count;
}
static const struct file_operations alc5616_audio_ops = {
.open = simple_open,
.read = alc5616_audio_read,
.write = alc5616_audio_write,
};
static inline int alc5616_audio_debugfs_init(struct pm80x_chip *chip)
{
alc5616_audio_control = debugfs_create_file("alc5616_audio", S_IRUGO | S_IFREG,
NULL, NULL, &alc5616_audio_ops);
if (alc5616_audio_control == NULL) {
pr_err("create alc5616 debugfs error!\n");
return -ENOENT;
} else if (alc5616_audio_control == ERR_PTR(-ENODEV)) {
pr_err("CONFIG_DEBUG_FS is not enabled!\n");
return -ENOENT;
}
return 0;
}
static void alc5616_audio_debugfs_remove(struct pm80x_chip *chip)
{
if (NULL != alc5616_audio_control){
debugfs_remove_recursive(alc5616_audio_control);
}
return;
}
/* register codec to ALSA. */
static const struct snd_kcontrol_new alc5616_snd_controls[] = {
SOC_SINGLE("S/W Reset", RT5616_RESET, 0, 0xFFFF, 0), /* 0x0 */
/* 0x01 */
SOC_SINGLE("HPOUT", RT5616_HP_VOL, 0, 0xFFFF, 0), /* 0x2 */
SOC_SINGLE("Line Output Control 1", RT5616_LOUT_CTRL1, 0, 0xFFFF, 0), /* 0x3 */
/* 0x4 */
SOC_SINGLE("Line Output Control 2", RT5616_LOUT_CTRL2, 0, 0xFFFF, 0), /* 0x5 */
/* 0x6~0x0c */
SOC_SINGLE("MIC Input", RT5616_IN1_IN2, 0, 0xFFFF, 0), /* 0x0d */
/* 0x0e */
SOC_SINGLE("Line Input", RT5616_INL1_INR1_VOL, 0, 0xFFFF, 0), /* 0x0f */
/* 0x10~0x1f */
SOC_SINGLE("DACL1/R1", RT5616_DAC1_DIG_VOL, 0, 0xFFFF, 0), /* 0x19 */
/* 0x1a~0x1b */
SOC_SINGLE("ADCL/R-1", RT5616_ADC_DIG_VOL, 0, 0xFFFF, 0), /* 0x1c */
/* 0x1d */
SOC_SINGLE("ADCL/R-2", RT5616_ADC_BST_VOL, 0, 0xFFFF, 0), /* 0x1e */
/* 0x1f~0x26 */
SOC_SINGLE("ADC-1", RT5616_STO1_ADC_MIXER, 0, 0xFFFF, 0), /* 0x27 */
/* 0x28 */
SOC_SINGLE("ADC-2", RT5616_AD_DA_MIXER, 0, 0xFFFF, 0), /* 0x29 */
SOC_SINGLE("DAC-1", RT5616_STO_DAC_MIXER, 0, 0xFFFF, 0), /* 0x2a */
/* 0x2b~0x3a */
SOC_SINGLE("RECMIXL-1", RT5616_REC_L1_MIXER, 0, 0xFFFF, 0), /* 0x3b */
SOC_SINGLE("RECMIXL-2", RT5616_REC_L2_MIXER, 0, 0xFFFF, 0), /* 0x3c */
SOC_SINGLE("RECMIXR-1", RT5616_REC_R1_MIXER, 0, 0xFFFF, 0), /* 0x3d */
SOC_SINGLE("RECMIXR-2", RT5616_REC_R2_MIXER, 0, 0xFFFF, 0), /* 0x3e */
/* 0x3f~0x44 */
SOC_SINGLE("HPOMIX", RT5616_HPO_MIXER, 0, 0xFFFF, 0), /* 0x45 */
/* 0x46~0x4c */
SOC_SINGLE("OUTMIXL-1", RT5616_OUT_L1_MIXER, 0, 0xFFFF, 0), /* 0x4d */
SOC_SINGLE("OUTMIXL-2", RT5616_OUT_L2_MIXER, 0, 0xFFFF, 0), /* 0x4e */
SOC_SINGLE("OUTMIXL-3", RT5616_OUT_L3_MIXER, 0, 0xFFFF, 0), /* 0x4f */
SOC_SINGLE("OUTMIXR-1", RT5616_OUT_R1_MIXER, 0, 0xFFFF, 0), /* 0x50 */
SOC_SINGLE("OUTMIXR-2", RT5616_OUT_R2_MIXER, 0, 0xFFFF, 0), /* 0x51 */
SOC_SINGLE("OUTMIXR-3", RT5616_OUT_R3_MIXER, 0, 0xFFFF, 0), /* 0x52 */
SOC_SINGLE("LOUTMIX", RT5616_LOUT_MIXER, 0, 0xFFFF, 0), /* 0x53 */
/* 0x54~0x60 */
SOC_SINGLE("Management-1", RT5616_PWR_DIG1, 0, 0xFFFF, 0), /* 0x61 */
SOC_SINGLE("Management-2", RT5616_PWR_DIG2, 0, 0xFFFF, 0), /* 0x62 */
SOC_SINGLE("Management-3", RT5616_PWR_ANLG1, 0, 0xFFFF, 0), /* 0x63 */
SOC_SINGLE("Management-4", RT5616_PWR_ANLG2, 0, 0xFFFF, 0), /* 0x64 */
SOC_SINGLE("Management-5", RT5616_PWR_MIXER, 0, 0xFFFF, 0), /* 0x65 */
SOC_SINGLE("Management-6", RT5616_PWR_VOL, 0, 0xFFFF, 0), /* 0x66 */
/* 0x67~0x69 */
SOC_SINGLE("PR Index", RT5616_PRIV_INDEX, 0, 0xFFFF, 0), /* 0x6a */
/* 0x6b */
SOC_SINGLE("PR Data", RT5616_PRIV_DATA, 0, 0xFFFF, 0), /* 0x6c */
/* 0x6b~6f */
SOC_SINGLE("I2S1 Port Ctrl", RT5616_I2S1_SDP, 0, 0xFFFF, 0), /* 0x70 */
/* 0x71~0x72 */
SOC_SINGLE("ADC/DAC Clock-1", RT5616_ADDA_CLK1, 0, 0xFFFF, 0), /* 0x73 */
SOC_SINGLE("ADC/DAC Clock-2", RT5616_ADDA_CLK2, 0, 0xFFFF, 0), /* 0x74 */
/* 0x75~0x7f */
SOC_SINGLE("Global Clock", RT5616_GLB_CLK, 0, 0xFFFF, 0), /* 0x80 */
SOC_SINGLE("PLL-1", RT5616_PLL_CTRL1, 0, 0xFFFF, 0), /* 0x81 */
SOC_SINGLE("PLL-2", RT5616_PLL_CTRL2, 0, 0xFFFF, 0), /* 0x82 */
/* 0x83~0x8a */
SOC_SINGLE("HP OVCD", RT5616_HP_OVCD, 0, 0xFFFF, 0), /* 0x8b */
/* 0x8d */
SOC_SINGLE("HP Amp Control 1", RT5616_DEPOP_M1, 0, 0xFFFF, 0), /* 0x8e */
SOC_SINGLE("HP Amp Control 2", RT5616_DEPOP_M2, 0, 0xFFFF, 0), /* 0x8f */
SOC_SINGLE("DEPOP M3", RT5616_DEPOP_M3, 0, 0xFFFF, 0), /* 0x90 */
SOC_SINGLE("CHARGE PUMP", RT5616_CHARGE_PUMP, 0, 0xFFFF, 0), /* 0x91 */
SOC_SINGLE("PV DET SPK G", RT5616_PV_DET_SPK_G, 0, 0xFFFF, 0), /* 0x92 */
SOC_SINGLE("MICBIAS", RT5616_MICBIAS, 0, 0xFFFF, 0), /* 0x93 */
SOC_SINGLE("JD", RT5616_A_JD_CTL1, 0, 0xFFFF, 0), /* 0x94 */
SOC_SINGLE("A JD CTL2", RT5616_A_JD_CTL2, 0, 0xFFFF, 0), /* 0x95 */
/* 0x96~0xaf */
SOC_SINGLE("EQ-1", RT5616_EQ_CTRL1, 0, 0xFFFF, 0), /* 0xb0 */
SOC_SINGLE("EQ-2", RT5616_EQ_CTRL2, 0, 0xFFFF, 0), /* 0xb1 */
SOC_SINGLE("Wind Filter", RT5616_WIND_FILTER, 0, 0xFFFF, 0), /* 0xb2 */
/* 0xb3 */
SOC_SINGLE("DRC/AGC-1", RT5616_DRC_AGC_1, 0, 0xFFFF, 0), /* 0xb4 */
SOC_SINGLE("DRC/AGC-2", RT5616_DRC_AGC_2, 0, 0xFFFF, 0), /* 0xb5 */
SOC_SINGLE("DRC/AGC-3", RT5616_DRC_AGC_3, 0, 0xFFFF, 0), /* 0xb6 */
SOC_SINGLE("SVOL ZC", RT5616_SVOL_ZC, 0, 0xFFFF, 0), /* 0xb7 */
/* 0xb8~0xba */
SOC_SINGLE("JD-1", RT5616_JD_CTRL1, 0, 0xFFFF, 0), /* 0xbb */
SOC_SINGLE("JD-2", RT5616_JD_CTRL2, 0, 0xFFFF, 0), /* 0xbc */
SOC_SINGLE("IRQ-1", RT5616_IRQ_CTRL1, 0, 0xFFFF, 0), /* 0xbd */
SOC_SINGLE("IRQ-2", RT5616_IRQ_CTRL2, 0, 0xFFFF, 0), /* 0xbe */
SOC_SINGLE("Status", RT5616_INT_IRQ_ST, 0, 0xFFFF, 0), /* 0xbf */
SOC_SINGLE("GPIO-1", RT5616_GPIO_CTRL1, 0, 0xFFFF, 0), /* 0xc0 */
SOC_SINGLE("GPIO-2", RT5616_GPIO_CTRL2, 0, 0xFFFF, 0), /* 0xc1 */
SOC_SINGLE("GPIO CTRL3", RT5616_GPIO_CTRL3, 0, 0xFFFF, 0), /* 0xc2 */
/* 0xc3~0xc7 */
SOC_SINGLE("PGM REG ARR1", RT5616_PGM_REG_ARR1, 0, 0xFFFF, 0), /* 0xc8 */
SOC_SINGLE("PGM REG ARR2", RT5616_PGM_REG_ARR2, 0, 0xFFFF, 0), /* 0xc9 */
SOC_SINGLE("PGM REG ARR3", RT5616_PGM_REG_ARR3, 0, 0xFFFF, 0), /* 0xca */
SOC_SINGLE("PGM REG ARR4", RT5616_PGM_REG_ARR4, 0, 0xFFFF, 0), /* 0xcb */
SOC_SINGLE("PGM REG ARR5", RT5616_PGM_REG_ARR5, 0, 0xFFFF, 0), /* 0xcc */
SOC_SINGLE("SCB FUNC", RT5616_SCB_FUNC, 0, 0xFFFF, 0), /* 0xcd */
SOC_SINGLE("SCB CTRL", RT5616_SCB_CTRL, 0, 0xFFFF, 0), /* 0xce */
SOC_SINGLE("BASE BACK", RT5616_BASE_BACK, 0, 0xFFFF, 0), /* 0xcf */
SOC_SINGLE("MP3 PLUS1", RT5616_MP3_PLUS1, 0, 0xFFFF, 0), /* 0xd0 */
SOC_SINGLE("MP3 PLUS2", RT5616_MP3_PLUS2, 0, 0xFFFF, 0), /* 0xd1 */
/* 0xd2 */
SOC_SINGLE("Control-1", RT5616_ADJ_HPF_CTRL1, 0, 0xFFFF, 0), /* 0xd3 */
SOC_SINGLE("Control-2", RT5616_ADJ_HPF_CTRL2, 0, 0xFFFF, 0), /* 0xd4 */
/* 0xd5 */
SOC_SINGLE("HP CALIB AMP DET", RT5616_HP_CALIB_AMP_DET, 0, 0xFFFF, 0), /* 0xd6 */
SOC_SINGLE("HP CALIB2", RT5616_HP_CALIB2, 0, 0xFFFF, 0), /* 0xd7 */
/* 0xd8 */
SOC_SINGLE("SVOL & ZCD", RT5616_SV_ZCD1, 0, 0xFFFF, 0), /* 0xd9 */
SOC_SINGLE("SV ZCD2", RT5616_SV_ZCD2, 0, 0xFFFF, 0), /* 0xda */
/* 0xdb~0xf9 */
SOC_SINGLE("General Control 1", RT5616_D_MISC, 0, 0xFFFF, 0), /* 0xfa */
SOC_SINGLE("DUMMY2", RT5616_DUMMY2, 0, 0xFFFF, 0), /* 0xfb */
SOC_SINGLE("DUMMY3", RT5616_DUMMY3, 0, 0xFFFF, 0), /* 0xfc */
SOC_SINGLE("VERSION ID", RT5616_VERSION_ID, 0, 0xFFFF, 0), /* 0xfd */
SOC_SINGLE("VENDOR ID", RT5616_VENDOR_ID, 0, 0xFFFF, 0), /* 0xfe */
};
static int alc5616_codec_probe(struct snd_soc_component *component)
{
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
#endif
snd_soc_add_component_controls(component, alc5616_snd_controls, ARRAY_SIZE(alc5616_snd_controls));
return 0;
}
static unsigned int alc5616_codec_read(struct snd_soc_component *component, unsigned int reg)
{
unsigned short out_val = 0;
if (0x3D == reg){
alc5616_index_read(reg, &out_val);
} else {
alc5616_read(reg, &out_val);
}
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.[0x%02x]=[0x%04x]\n", __FUNCTION__, __LINE__, reg, out_val);
#endif
return out_val;
}
static int alc5616_codec_write(struct snd_soc_component *component,
unsigned int reg, unsigned int value)
{
int ret = 0;
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.[0x%02x]=[0x%04x]\n", __FUNCTION__, __LINE__, reg, value);
#endif
if (0x3D == reg) {
ret = alc5616_index_write(reg, value & 0xFFFF);
} else {
ret = alc5616_write(reg, value & 0xFFFF);
}
return ret;
}
#if 0
#define DRC_AGC_MANUAL
#define MANUAL_SWITCH
#endif
/* alc5616_dai_ops */
static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -4650, 150, 0);
static const DECLARE_TLV_DB_SCALE(dac_vol_tlv, -65625, 375, 0);
static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -3450, 150, 0);
static const DECLARE_TLV_DB_SCALE(adc_vol_tlv, -17625, 375, 0);
static const DECLARE_TLV_DB_SCALE(adc_bst_tlv, 0, 1200, 0);
#ifdef DRC_AGC_MANUAL
static const DECLARE_TLV_DB_SCALE(drc_post_gain_tlv, -11625, 375, 0);
static const DECLARE_TLV_DB_SCALE(drc_pre_gain_tlv, 0, 1500, 0);
static const DECLARE_TLV_DB_SCALE(drc_noise_compensation_tlv, 0, 3000, 0);
static const DECLARE_TLV_DB_SCALE(drc_limiter_tlv, -46500, 1500, 0);
static const DECLARE_TLV_DB_SCALE(drc_noise_gate_tlv, -82500, 1500, 0);
static const char *drc_compressor_text[] = {
"1",
"1/2",
"1/4",
"1/8",
};
static SOC_ENUM_SINGLE_DECL(drc_compressor,
RT5616_DRC_AGC_2, 5, drc_compressor_text);
static const char *drc_attack_text[] = {
"83us",
"167us",
"334us",
"668us",
"1.34ms",
"2.68ms",
"5.36ms",
"10.7ms",
"21.4ms",
"42.8ms",
"93.6ms",
"190ms",
"380ms",
"760ms",
"1.43s",
"2.86s",
"5.46s",
"Reserved",
};
static SOC_ENUM_SINGLE_DECL(drc_attack_rate,
RT5616_DRC_AGC_1, 8, drc_attack_text);
static SOC_ENUM_SINGLE_DECL(drc_recovery_rate,
RT5616_DRC_AGC_1, 0, drc_attack_text);
static const char *drc_path_text[] = {
"DRC to DAC",
"AGC TO ADC",
};
static SOC_ENUM_SINGLE_DECL(drc_path,
RT5616_DRC_AGC_1, 15, drc_path_text);
#endif
/* {0, +20, +24, +30, +35, +40, +44, +50, +52} dB */
static const SNDRV_CTL_TLVD_DECLARE_DB_RANGE(bst_tlv,
0, 0, TLV_DB_SCALE_ITEM(0, 0, 0),
1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0),
2, 2, TLV_DB_SCALE_ITEM(2400, 0, 0),
3, 5, TLV_DB_SCALE_ITEM(3000, 500, 0),
6, 6, TLV_DB_SCALE_ITEM(4400, 0, 0),
7, 7, TLV_DB_SCALE_ITEM(5000, 0, 0),
8, 8, TLV_DB_SCALE_ITEM(5200, 0, 0),
);
static const struct snd_kcontrol_new rt5616_snd_controls[] = {
#ifdef DRC_AGC_MANUAL
//DRC and AGC
SOC_SINGLE("DRC Switch", RT5616_DRC_AGC_1, 14, 1, 0),
SOC_ENUM("DRC Path", drc_path),
SOC_ENUM("DRC compression function", drc_compressor),
SOC_SINGLE("DRC compression Switch", RT5616_DRC_AGC_2, 7, 1, 0),
SOC_ENUM("DRC/AGC attack rate", drc_attack_rate),
SOC_ENUM("DRC/AGC recovery rate", drc_recovery_rate),
SOC_SINGLE_TLV("DRC/AGC POST_Boost Gain", RT5616_DRC_AGC_2,
8, 63, 0, drc_post_gain_tlv),
SOC_SINGLE_TLV("DRC/AGC PRE_Boost Gain", RT5616_DRC_AGC_2,
0, 19, 0, drc_pre_gain_tlv),
SOC_SINGLE_TLV("DRC/AGC Noise_Compensation", RT5616_DRC_AGC_3,
12, 15, 0, drc_noise_compensation_tlv),
SOC_SINGLE_TLV("DRC/AGC limiter", RT5616_DRC_AGC_3,
7, 31, 1, drc_limiter_tlv),
SOC_SINGLE("DRC/AGC NOISE GATE Switch", RT5616_DRC_AGC_3,
6, 1, 0),
SOC_SINGLE("DRC/AGC NOISE GATE HOLD DATA Switch", RT5616_DRC_AGC_3,
5, 1, 0),
SOC_SINGLE_TLV("DRC/AGC noise_gate", RT5616_DRC_AGC_3,
0, 31, 1, drc_noise_gate_tlv),
#endif
#ifdef MANUAL_SWITCH
/* Headphone Output Volume */
SOC_SINGLE("HPL Playback Switch", RT5616_HP_VOL,
RT5616_R_MUTE_SFT, 1, 1),
SOC_SINGLE("HPR Playback Switch", RT5616_HP_VOL,
RT5616_L_MUTE_SFT, 1, 1),
SOC_SINGLE("HPVOL L Playback Switch", RT5616_HP_VOL,
RT5616_VOL_L_SFT, 1, 1),
SOC_SINGLE("HPVOL R Playback Switch", RT5616_HP_VOL,
RT5616_VOL_R_SFT, 1, 1),
/* OUTPUT Control */
SOC_SINGLE("LOUT L Playback Switch", RT5616_LOUT_CTRL1,
RT5616_L_MUTE_SFT, 1, 1),
SOC_SINGLE("LOUT R Playback Switch", RT5616_LOUT_CTRL1,
RT5616_R_MUTE_SFT, 1, 1),
SOC_SINGLE("OUTVOLL L Switch", RT5616_LOUT_CTRL1,
RT5616_VOL_L_SFT, 1, 1),
SOC_SINGLE("OUTVOLL R Switch", RT5616_LOUT_CTRL1,
RT5616_VOL_R_SFT, 1, 1),
/* ADC Digital Volume Control */
SOC_SINGLE("ADC L Capture Switch", RT5616_ADC_DIG_VOL,
RT5616_L_MUTE_SFT, 1, 1),
SOC_SINGLE("ADC R Capture Switch", RT5616_ADC_DIG_VOL,
RT5616_R_MUTE_SFT, 1, 1),
#endif
/* DAC Digital Volume */
SOC_SINGLE_TLV("DACL1 Playback Volume", RT5616_DAC1_DIG_VOL,
RT5616_L_VOL_SFT, 175, 0, dac_vol_tlv),
SOC_SINGLE_TLV("DACR1 Playback Volume", RT5616_DAC1_DIG_VOL,
RT5616_R_VOL_SFT, 175, 0, dac_vol_tlv),
SOC_SINGLE_TLV("HPVOL L Playback Volume", RT5616_HP_VOL,
RT5616_L_VOL_SFT, 39, 1, out_vol_tlv),
SOC_SINGLE_TLV("HPVOL R Playback Volume", RT5616_HP_VOL,
RT5616_R_VOL_SFT, 39, 1, out_vol_tlv),
SOC_SINGLE_TLV("OUTVOLL L Playback Volume", RT5616_LOUT_CTRL1,
RT5616_L_VOL_SFT, 39, 1, out_vol_tlv),
SOC_SINGLE_TLV("OUTVOLL R Playback Volume", RT5616_LOUT_CTRL1,
RT5616_R_VOL_SFT, 39, 1, out_vol_tlv),
/*ADC VOLUME*/
SOC_SINGLE_TLV("ADC L Capture Volume", RT5616_ADC_DIG_VOL,
RT5616_L_VOL_SFT, 127, 0, adc_vol_tlv),
SOC_SINGLE_TLV("ADC R Capture Volume", RT5616_ADC_DIG_VOL,
RT5616_R_VOL_SFT, 127, 0, adc_vol_tlv),
/* ADC Boost Volume Control */
SOC_SINGLE_TLV("ADC L Boost Volume", RT5616_ADC_BST_VOL,
RT5616_ADC_L_BST_SFT, 3, 0, adc_bst_tlv),
SOC_SINGLE_TLV("ADC R Boost Volume", RT5616_ADC_BST_VOL,
RT5616_ADC_R_BST_SFT, 3, 0, adc_bst_tlv),
/* IN1/IN2 Control */
SOC_SINGLE_TLV("IN1/BST1 Boost Volume", RT5616_IN1_IN2,
RT5616_BST_SFT1, 8, 0, bst_tlv),
SOC_SINGLE_TLV("IN2/BST2 Boost Volume", RT5616_IN1_IN2,
RT5616_BST_SFT2, 8, 0, bst_tlv),
/* INL/INR Volume Control */
SOC_SINGLE_TLV("INL Capture Volume", RT5616_INL1_INR1_VOL,
RT5616_INL_VOL_SFT, 31, 1, in_vol_tlv),
SOC_SINGLE_TLV("INR Capture Volume", RT5616_INL1_INR1_VOL,
RT5616_INR_VOL_SFT, 31, 1, in_vol_tlv),
};
/* Digital Mixer */
static const struct snd_kcontrol_new rt5616_sto1_adc_l_mix[] = {
SOC_DAPM_SINGLE("ADC1 Switch", RT5616_STO1_ADC_MIXER,
RT5616_M_STO1_ADC_L1_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_sto1_adc_r_mix[] = {
SOC_DAPM_SINGLE("ADC1 Switch", RT5616_STO1_ADC_MIXER,
RT5616_M_STO1_ADC_R1_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_dac_l_mix[] = {
SOC_DAPM_SINGLE("Stereo ADC Switch", RT5616_AD_DA_MIXER,
RT5616_M_ADCMIX_L_SFT, 1, 1),
SOC_DAPM_SINGLE("INF1 Switch", RT5616_AD_DA_MIXER,
RT5616_M_IF1_DAC_L_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_dac_r_mix[] = {
SOC_DAPM_SINGLE("Stereo ADC Switch", RT5616_AD_DA_MIXER,
RT5616_M_ADCMIX_R_SFT, 1, 1),
SOC_DAPM_SINGLE("INF1 Switch", RT5616_AD_DA_MIXER,
RT5616_M_IF1_DAC_R_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_sto_dac_l_mix[] = {
SOC_DAPM_SINGLE("DAC L1 Switch", RT5616_STO_DAC_MIXER,
RT5616_M_DAC_L1_MIXL_SFT, 1, 1),
SOC_DAPM_SINGLE("DAC R1 Switch", RT5616_STO_DAC_MIXER,
RT5616_M_DAC_R1_MIXL_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_sto_dac_r_mix[] = {
SOC_DAPM_SINGLE("DAC R1 Switch", RT5616_STO_DAC_MIXER,
RT5616_M_DAC_R1_MIXR_SFT, 1, 1),
SOC_DAPM_SINGLE("DAC L1 Switch", RT5616_STO_DAC_MIXER,
RT5616_M_DAC_L1_MIXR_SFT, 1, 1),
};
/* Analog Input Mixer */
static const struct snd_kcontrol_new rt5616_rec_l_mix[] = {
SOC_DAPM_SINGLE("INL1 Switch", RT5616_REC_L2_MIXER,
RT5616_M_IN1_L_RM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("BST2 Switch", RT5616_REC_L2_MIXER,
RT5616_M_BST2_RM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("BST1 Switch", RT5616_REC_L2_MIXER,
RT5616_M_BST1_RM_L_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_rec_r_mix[] = {
SOC_DAPM_SINGLE("INR1 Switch", RT5616_REC_R2_MIXER,
RT5616_M_IN1_R_RM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("BST2 Switch", RT5616_REC_R2_MIXER,
RT5616_M_BST2_RM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("BST1 Switch", RT5616_REC_R2_MIXER,
RT5616_M_BST1_RM_R_SFT, 1, 1),
};
/* Analog Output Mixer */
static const struct snd_kcontrol_new rt5616_out_l_mix[] = {
SOC_DAPM_SINGLE("BST1 Switch", RT5616_OUT_L3_MIXER,
RT5616_M_BST1_OM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("BST2 Switch", RT5616_OUT_L3_MIXER,
RT5616_M_BST2_OM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("INL1 Switch", RT5616_OUT_L3_MIXER,
RT5616_M_IN1_L_OM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("REC MIXL Switch", RT5616_OUT_L3_MIXER,
RT5616_M_RM_L_OM_L_SFT, 1, 1),
SOC_DAPM_SINGLE("DAC L1 Switch", RT5616_OUT_L3_MIXER,
RT5616_M_DAC_L1_OM_L_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_out_r_mix[] = {
SOC_DAPM_SINGLE("BST2 Switch", RT5616_OUT_R3_MIXER,
RT5616_M_BST2_OM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("BST1 Switch", RT5616_OUT_R3_MIXER,
RT5616_M_BST1_OM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("INR1 Switch", RT5616_OUT_R3_MIXER,
RT5616_M_IN1_R_OM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("REC MIXR Switch", RT5616_OUT_R3_MIXER,
RT5616_M_RM_R_OM_R_SFT, 1, 1),
SOC_DAPM_SINGLE("DAC R1 Switch", RT5616_OUT_R3_MIXER,
RT5616_M_DAC_R1_OM_R_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_hpo_mix[] = {
SOC_DAPM_SINGLE("DAC1 Switch", RT5616_HPO_MIXER,
RT5616_M_DAC1_HM_SFT, 1, 1),
SOC_DAPM_SINGLE("HPVOL Switch", RT5616_HPO_MIXER,
RT5616_M_HPVOL_HM_SFT, 1, 1),
};
static const struct snd_kcontrol_new rt5616_lout_mix[] = {
SOC_DAPM_SINGLE("DAC L1 Switch", RT5616_LOUT_MIXER,
RT5616_M_DAC_L1_LM_SFT, 1, 1),
SOC_DAPM_SINGLE("DAC R1 Switch", RT5616_LOUT_MIXER,
RT5616_M_DAC_R1_LM_SFT, 1, 1),
SOC_DAPM_SINGLE("OUTVOL L Switch", RT5616_LOUT_MIXER,
RT5616_M_OV_L_LM_SFT, 1, 1),
SOC_DAPM_SINGLE("OUTVOL R Switch", RT5616_LOUT_MIXER,
RT5616_M_OV_R_LM_SFT, 1, 1),
};
static int rt5616_adc_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_ADC_DIG_VOL,
RT5616_L_MUTE | RT5616_R_MUTE, 0);
break;
case SND_SOC_DAPM_POST_PMD:
snd_soc_component_update_bits(component, RT5616_ADC_DIG_VOL,
RT5616_L_MUTE | RT5616_R_MUTE,
RT5616_L_MUTE | RT5616_R_MUTE);
break;
default:
return 0;
}
return 0;
}
static int rt5616_charge_pump_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
/* headphone amp power on */
snd_soc_component_update_bits(component, RT5616_DEPOP_M2,
RT5616_DEPOP_MASK, RT5616_DEPOP_MODE2);
snd_soc_component_write(component, RT5616_DEPOP_M1, 0x83aD);
msleep(100);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_HP_VOL,
RT5616_L_MUTE | RT5616_R_MUTE,
RT5616_L_MUTE | RT5616_R_MUTE);
snd_soc_component_update_bits(component, RT5616_DEPOP_M1,
RT5616_HP_SG_MASK | RT5616_HP_L_SMT_MASK |
RT5616_HP_R_SMT_MASK, RT5616_HP_SG_DIS |
RT5616_HP_L_SMT_DIS | RT5616_HP_R_SMT_DIS);
msleep(20);
/* headphone amp power down */
snd_soc_component_update_bits(component, RT5616_DEPOP_M1,
RT5616_SMT_TRIG_MASK |
RT5616_HP_CD_PD_MASK | RT5616_HP_CO_MASK |
RT5616_HP_CP_MASK | RT5616_HP_SG_MASK |
RT5616_HP_CB_MASK,
RT5616_SMT_TRIG_DIS | RT5616_HP_CD_PD_EN |
RT5616_HP_CO_DIS | RT5616_HP_CP_PD |
RT5616_HP_SG_EN | RT5616_HP_CB_PD);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_HP_L | RT5616_PWR_HP_R |
RT5616_PWR_HA, 0);
break;
default:
return 0;
}
return 0;
}
static int rt5616_hp_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
/* headphone unmute sequence */
snd_soc_component_update_bits(component, RT5616_PWR_VOL,
RT5616_PWR_HV_L | RT5616_PWR_HV_R,
RT5616_PWR_HV_L | RT5616_PWR_HV_R);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_HP_L | RT5616_PWR_HP_R |
RT5616_PWR_HA, RT5616_PWR_HP_L |
RT5616_PWR_HP_R | RT5616_PWR_HA);
snd_soc_component_update_bits(component, RT5616_HP_VOL,
RT5616_L_MUTE | RT5616_R_MUTE, 0);
break;
case SND_SOC_DAPM_PRE_PMD:
/* headphone mute sequence */
snd_soc_component_update_bits(component, RT5616_HP_VOL,
RT5616_L_MUTE | RT5616_R_MUTE,
RT5616_L_MUTE | RT5616_R_MUTE);
break;
default:
return 0;
}
return 0;
}
static int rt5616_lout_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_LM, RT5616_PWR_LM);
snd_soc_component_update_bits(component, RT5616_LOUT_CTRL1,
RT5616_L_MUTE | RT5616_R_MUTE , 0);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_LOUT_CTRL1,
RT5616_L_MUTE | RT5616_R_MUTE,
RT5616_L_MUTE | RT5616_R_MUTE);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_LM, 0);
break;
default:
return 0;
}
return 0;
}
static int rt5616_bst1_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG2,
RT5616_PWR_BST1_OP2, RT5616_PWR_BST1_OP2);
msleep(60);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG2,
RT5616_PWR_BST1_OP2, 0);
break;
default:
return 0;
}
return 0;
}
static int rt5616_bst2_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG2,
RT5616_PWR_BST2_OP2, RT5616_PWR_BST2_OP2);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG2,
RT5616_PWR_BST2_OP2, 0);
break;
default:
return 0;
}
return 0;
}
static int rt5616_hpovoll_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_HP_VOL,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE, 0);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_PWR_ANLG2,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE);
break;
default:
return 0;
}
return 0;
}
static int rt5616_outvoll_event(struct snd_soc_dapm_widget *w,
struct snd_kcontrol *kcontrol, int event)
{
struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
switch (event) {
case SND_SOC_DAPM_POST_PMU:
snd_soc_component_update_bits(component, RT5616_LOUT_CTRL1,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE, 0);
break;
case SND_SOC_DAPM_PRE_PMD:
snd_soc_component_update_bits(component, RT5616_LOUT_CTRL1,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE,
RT5616_VOL_L_MUTE | RT5616_VOL_R_MUTE);
break;
default:
return 0;
}
return 0;
}
static const struct snd_soc_dapm_widget rt5616_dapm_widgets[] = {
SND_SOC_DAPM_SUPPLY("PLL1", RT5616_PWR_ANLG2,
RT5616_PWR_PLL_BIT, 0, NULL, 0),
/* Input Side */
/* micbias */
SND_SOC_DAPM_SUPPLY("LDO", RT5616_PWR_ANLG1,
RT5616_PWR_LDO_BIT, 0, NULL, 0),
SND_SOC_DAPM_SUPPLY("micbias1", RT5616_PWR_ANLG2,
RT5616_PWR_MB1_BIT, 0, NULL, 0),
/* Input Lines */
SND_SOC_DAPM_INPUT("MIC1"),
SND_SOC_DAPM_INPUT("MIC2"),
SND_SOC_DAPM_INPUT("IN1P"),
SND_SOC_DAPM_INPUT("IN2P"),
SND_SOC_DAPM_INPUT("IN2N"),
/* Boost */
SND_SOC_DAPM_PGA_E("BST1", RT5616_PWR_ANLG2,
RT5616_PWR_BST1_BIT, 0, NULL, 0, rt5616_bst1_event,
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_PGA_E("BST2", RT5616_PWR_ANLG2,
RT5616_PWR_BST2_BIT, 0, NULL, 0, rt5616_bst2_event,
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
/* Input Volume */
SND_SOC_DAPM_PGA("INL1 VOL", RT5616_PWR_VOL,
RT5616_PWR_IN1_L_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INR1 VOL", RT5616_PWR_VOL,
RT5616_PWR_IN1_R_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INL2 VOL", RT5616_PWR_VOL,
RT5616_PWR_IN2_L_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INR2 VOL", RT5616_PWR_VOL,
RT5616_PWR_IN2_R_BIT, 0, NULL, 0),
/* REC Mixer */
SND_SOC_DAPM_MIXER("RECMIXL", RT5616_PWR_MIXER, RT5616_PWR_RM_L_BIT, 0,
rt5616_rec_l_mix, ARRAY_SIZE(rt5616_rec_l_mix)),
SND_SOC_DAPM_MIXER("RECMIXR", RT5616_PWR_MIXER, RT5616_PWR_RM_R_BIT, 0,
rt5616_rec_r_mix, ARRAY_SIZE(rt5616_rec_r_mix)),
/* ADCs */
SND_SOC_DAPM_ADC_E("ADC L", NULL, RT5616_PWR_DIG1,
RT5616_PWR_ADC_L_BIT, 0, rt5616_adc_event,
SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_ADC_E("ADC R", NULL, RT5616_PWR_DIG1,
RT5616_PWR_ADC_R_BIT, 0, rt5616_adc_event,
SND_SOC_DAPM_POST_PMD | SND_SOC_DAPM_POST_PMU),
/* ADC Mixer */
SND_SOC_DAPM_SUPPLY("stereo1 filter", RT5616_PWR_DIG2,
RT5616_PWR_ADC_STO1_F_BIT, 0, NULL, 0),
SND_SOC_DAPM_MIXER("Stereo1 ADC MIXL", SND_SOC_NOPM, 0, 0,
rt5616_sto1_adc_l_mix,
ARRAY_SIZE(rt5616_sto1_adc_l_mix)),
SND_SOC_DAPM_MIXER("Stereo1 ADC MIXR", SND_SOC_NOPM, 0, 0,
rt5616_sto1_adc_r_mix,
ARRAY_SIZE(rt5616_sto1_adc_r_mix)),
/* Digital Interface */
SND_SOC_DAPM_SUPPLY("I2S1", RT5616_PWR_DIG1,
RT5616_PWR_I2S1_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("IF1 DAC", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_PGA("IF1 DAC1 L", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_PGA("IF1 DAC1 R", SND_SOC_NOPM, 0, 0, NULL, 0),
SND_SOC_DAPM_PGA("IF1 ADC1", SND_SOC_NOPM, 0, 0, NULL, 0),
/* Audio Interface */
SND_SOC_DAPM_AIF_IN("AIF1RX", "PCM Playback", 0, SND_SOC_NOPM, 0, 0),
SND_SOC_DAPM_AIF_OUT("AIF1TX", "PCM Capture", 0, SND_SOC_NOPM, 0, 0),
/* Audio DSP */
SND_SOC_DAPM_PGA("Audio DSP", SND_SOC_NOPM, 0, 0, NULL, 0),
/* Output Side */
/* DAC mixer before sound effect */
SND_SOC_DAPM_MIXER("DAC MIXL", SND_SOC_NOPM, 0, 0,
rt5616_dac_l_mix, ARRAY_SIZE(rt5616_dac_l_mix)),
SND_SOC_DAPM_MIXER("DAC MIXR", SND_SOC_NOPM, 0, 0,
rt5616_dac_r_mix, ARRAY_SIZE(rt5616_dac_r_mix)),
SND_SOC_DAPM_SUPPLY("Stero1 DAC Power", RT5616_PWR_DIG2,
RT5616_PWR_DAC_STO1_F_BIT, 0, NULL, 0),
/* DAC Mixer */
SND_SOC_DAPM_MIXER("Stereo DAC MIXL", SND_SOC_NOPM, 0, 0,
rt5616_sto_dac_l_mix,
ARRAY_SIZE(rt5616_sto_dac_l_mix)),
SND_SOC_DAPM_MIXER("Stereo DAC MIXR", SND_SOC_NOPM, 0, 0,
rt5616_sto_dac_r_mix,
ARRAY_SIZE(rt5616_sto_dac_r_mix)),
/* DACs */
SND_SOC_DAPM_DAC("DAC L1", NULL, RT5616_PWR_DIG1,
RT5616_PWR_DAC_L1_BIT, 0),
SND_SOC_DAPM_DAC("DAC R1", NULL, RT5616_PWR_DIG1,
RT5616_PWR_DAC_R1_BIT, 0),
/* OUT Mixer */
SND_SOC_DAPM_MIXER("OUT MIXL", RT5616_PWR_MIXER, RT5616_PWR_OM_L_BIT,
0, rt5616_out_l_mix, ARRAY_SIZE(rt5616_out_l_mix)),
SND_SOC_DAPM_MIXER("OUT MIXR", RT5616_PWR_MIXER, RT5616_PWR_OM_R_BIT,
0, rt5616_out_r_mix, ARRAY_SIZE(rt5616_out_r_mix)),
/* Output Volume */
SND_SOC_DAPM_PGA_E("OUTVOL L", RT5616_PWR_VOL,
RT5616_PWR_OV_L_BIT, 0, NULL, 0, rt5616_outvoll_event,
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_PGA("OUTVOL R", RT5616_PWR_VOL,
RT5616_PWR_OV_R_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA_E("HPOVOL L", RT5616_PWR_VOL,
RT5616_PWR_HV_L_BIT, 0, NULL, 0, rt5616_hpovoll_event,
SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_PGA("HPOVOL R", RT5616_PWR_VOL,
RT5616_PWR_HV_R_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("DAC 1", SND_SOC_NOPM,
0, 0, NULL, 0),
SND_SOC_DAPM_PGA("HPOVOL", SND_SOC_NOPM,
0, 0, NULL, 0),
SND_SOC_DAPM_PGA("INL1", RT5616_PWR_VOL,
RT5616_PWR_IN1_L_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INR1", RT5616_PWR_VOL,
RT5616_PWR_IN1_R_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INL2", RT5616_PWR_VOL,
RT5616_PWR_IN2_L_BIT, 0, NULL, 0),
SND_SOC_DAPM_PGA("INR2", RT5616_PWR_VOL,
RT5616_PWR_IN2_R_BIT, 0, NULL, 0),
/* HPO/LOUT/Mono Mixer */
SND_SOC_DAPM_MIXER("HPO MIX", SND_SOC_NOPM, 0, 0,
rt5616_hpo_mix, ARRAY_SIZE(rt5616_hpo_mix)),
SND_SOC_DAPM_MIXER("LOUT MIX", SND_SOC_NOPM, 0, 0,
rt5616_lout_mix, ARRAY_SIZE(rt5616_lout_mix)),
SND_SOC_DAPM_PGA_S("HP amp", 1, SND_SOC_NOPM, 0, 0,
rt5616_hp_event, SND_SOC_DAPM_PRE_PMD |
SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_PGA_S("LOUT amp", 1, SND_SOC_NOPM, 0, 0,
rt5616_lout_event, SND_SOC_DAPM_PRE_PMD |
SND_SOC_DAPM_POST_PMU),
SND_SOC_DAPM_SUPPLY_S("Charge Pump", 1, SND_SOC_NOPM, 0, 0,
rt5616_charge_pump_event, SND_SOC_DAPM_POST_PMU |
SND_SOC_DAPM_PRE_PMD),
/* Output Lines */
SND_SOC_DAPM_OUTPUT("HPOL"),
SND_SOC_DAPM_OUTPUT("HPOR"),
SND_SOC_DAPM_OUTPUT("LOUTL"),
SND_SOC_DAPM_OUTPUT("LOUTR"),
};
static const struct snd_soc_dapm_route rt5616_dapm_routes[] = {
{"IN1P", NULL, "LDO"},
{"IN2P", NULL, "LDO"},
{"IN1P", NULL, "MIC1"},
{"IN2P", NULL, "MIC2"},
{"IN2N", NULL, "MIC2"},
{"BST1", NULL, "IN1P"},
{"BST2", NULL, "IN2P"},
{"BST2", NULL, "IN2N"},
{"BST1", NULL, "micbias1"},
{"BST2", NULL, "micbias1"},
{"INL1 VOL", NULL, "IN2P"},
{"INR1 VOL", NULL, "IN2N"},
{"RECMIXL", "INL1 Switch", "INL1 VOL"},
{"RECMIXL", "BST2 Switch", "BST2"},
{"RECMIXL", "BST1 Switch", "BST1"},
{"RECMIXR", "INR1 Switch", "INR1 VOL"},
{"RECMIXR", "BST2 Switch", "BST2"},
{"RECMIXR", "BST1 Switch", "BST1"},
{"ADC L", NULL, "RECMIXL"},
{"ADC R", NULL, "RECMIXR"},
{"Stereo1 ADC MIXL", "ADC1 Switch", "ADC L"},
{"Stereo1 ADC MIXL", NULL, "stereo1 filter"},
{"Stereo1 ADC MIXR", "ADC1 Switch", "ADC R"},
{"Stereo1 ADC MIXR", NULL, "stereo1 filter"},
{"IF1 ADC1", NULL, "Stereo1 ADC MIXL"},
{"IF1 ADC1", NULL, "Stereo1 ADC MIXR"},
{"IF1 ADC1", NULL, "I2S1"},
{"AIF1TX", NULL, "IF1 ADC1"},
{"IF1 DAC", NULL, "AIF1RX"},
{"IF1 DAC", NULL, "I2S1"},
{"IF1 DAC1 L", NULL, "IF1 DAC"},
{"IF1 DAC1 R", NULL, "IF1 DAC"},
{"DAC MIXL", "Stereo ADC Switch", "Stereo1 ADC MIXL"},
{"DAC MIXL", "INF1 Switch", "IF1 DAC1 L"},
{"DAC MIXR", "Stereo ADC Switch", "Stereo1 ADC MIXR"},
{"DAC MIXR", "INF1 Switch", "IF1 DAC1 R"},
{"Audio DSP", NULL, "DAC MIXL"},
{"Audio DSP", NULL, "DAC MIXR"},
{"Stereo DAC MIXL", "DAC L1 Switch", "Audio DSP"},
{"Stereo DAC MIXL", "DAC R1 Switch", "DAC MIXR"},
{"Stereo DAC MIXL", NULL, "Stero1 DAC Power"},
{"Stereo DAC MIXR", "DAC R1 Switch", "Audio DSP"},
{"Stereo DAC MIXR", "DAC L1 Switch", "DAC MIXL"},
{"Stereo DAC MIXR", NULL, "Stero1 DAC Power"},
{"DAC L1", NULL, "Stereo DAC MIXL"},
{"DAC R1", NULL, "Stereo DAC MIXR"},
{"OUT MIXL", "BST1 Switch", "BST1"},
{"OUT MIXL", "BST2 Switch", "BST2"},
{"OUT MIXL", "INL1 Switch", "INL1 VOL"},
{"OUT MIXL", "REC MIXL Switch", "RECMIXL"},
{"OUT MIXL", "DAC L1 Switch", "DAC L1"},
{"OUT MIXR", "BST2 Switch", "BST2"},
{"OUT MIXR", "BST1 Switch", "BST1"},
{"OUT MIXR", "INR1 Switch", "INR1 VOL"},
{"OUT MIXR", "REC MIXR Switch", "RECMIXR"},
{"OUT MIXR", "DAC R1 Switch", "DAC R1"},
{"HPOVOL L", NULL, "OUT MIXL"},
{"HPOVOL R", NULL, "OUT MIXR"},
{"OUTVOL L", NULL, "OUT MIXL"},
{"OUTVOL R", NULL, "OUT MIXR"},
{"DAC 1", NULL, "DAC L1"},
{"DAC 1", NULL, "DAC R1"},
{"HPOVOL", NULL, "HPOVOL L"},
{"HPOVOL", NULL, "HPOVOL R"},
{"HPO MIX", "DAC1 Switch", "DAC 1"},
{"HPO MIX", "HPVOL Switch", "HPOVOL"},
{"LOUT MIX", "DAC L1 Switch", "DAC L1"},
{"LOUT MIX", "DAC R1 Switch", "DAC R1"},
{"LOUT MIX", "OUTVOL L Switch", "OUTVOL L"},
{"LOUT MIX", "OUTVOL R Switch", "OUTVOL R"},
{"HP amp", NULL, "HPO MIX"},
{"HP amp", NULL, "Charge Pump"},
{"HPOL", NULL, "HP amp"},
{"HPOR", NULL, "HP amp"},
{"LOUT amp", NULL, "LOUT MIX"},
{"LOUT amp", NULL, "Charge Pump"},
{"LOUTL", NULL, "LOUT amp"},
{"LOUTR", NULL, "LOUT amp"},
};
static int alc5616_digital_mute(struct snd_soc_dai *codec_dai, int mute)
{
struct snd_soc_component *component = codec_dai->component;
unsigned int reg;
reg = snd_soc_component_read32(component, RT5616_AD_DA_MIXER);
if (mute)
reg |= RT5616_M_IF1_DAC_L | RT5616_M_IF1_DAC_R;
else
reg &= ~(RT5616_M_IF1_DAC_L | RT5616_M_IF1_DAC_R);
snd_soc_component_write(component, RT5616_AD_DA_MIXER, reg);
//printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
return 0;
}
static int alc5616_hw_params(struct snd_pcm_substream *substream,
struct snd_pcm_hw_params *params,
struct snd_soc_dai *dai)
{
struct snd_soc_component* component = dai->component;
unsigned short reg,reg1;
int rate = params_rate(params);
reg = alc5616_codec_read(component, RT5616_I2S1_SDP);
switch(params_format(params)){
case SNDRV_PCM_FORMAT_S16_LE:
reg &= ~(0x3 << 2);
break;
case SNDRV_PCM_FORMAT_S20_3LE:
reg &= ~(0x3 << 2);
reg |= 0x1 << 2;
break;
case SNDRV_PCM_FORMAT_S24_LE:
case SNDRV_PCM_FORMAT_S32_LE:
reg &= ~(0x3 << 2);
reg |= 0x2 << 2;
break;
case SNDRV_PCM_FORMAT_S8:
reg &= ~(0x3 << 2);
reg |= 0x3 << 2;
break;
default:
break;
}
alc5616_codec_write(component, RT5616_I2S1_SDP, reg);
if(substream->stream == SNDRV_PCM_STREAM_CAPTURE)
{
reg1 = alc5616_codec_read(component, RT5616_ADJ_HPF_CTRL1);
alc5616_update_bit(RT5616_ADJ_HPF_CTRL1, 1 << 15, 0);
/* wind filter parameter, different frequency has different setting
* according to the alc5616 datasheet, here we just support 8K/16K/44.1k/48k
* wind noise filter can significantly decrease the effect of wind noise, if the default
* parameter is not suitable for your application, please refer to the datasheet,
* recommended coefficient is between 800 -- 1000
*/
switch (rate){
case 8000:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
alc5616_write(0xD4, 0x2121);
break;
case 12000:
case 16000:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
alc5616_write(0xD4, 0x1313);
break;
case 24000:
case 32000:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
reg1 |= 0x1 << 12 | 0x1 << 8;
break;
case 48000:
case 44100:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
reg1 |= 0x2 << 12 | 0x2 << 8;
alc5616_write(0xD4, 0x1d1d);
break;
case 96000:
case 88200:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
reg1 |= 0x3 << 12 | 0x3 << 8;
break;
case 192000:
case 176400:
reg1 &= ~(0x7 << 12 | 0x7 << 8);
reg1 |= 0x4 << 12 | 0x4 << 8;
break;
default:
break;
}
alc5616_write(0xD3, reg1);
alc5616_update_bit(0xD3, 0x1 << 15, 0x1 << 15);
}
#ifndef DRC_AGC_MANUAL
/* we just set agc to avoid sinal amplitude over target level and
* make noise suppression when signal amplitude under noise target level
* this moudule can make sound softer and better
* turnning up volume has influence with DRC_AGC prarameters
* if default parameter is not suitable for your application, please
* refer to the datasheet
*
* the default parameter:
* the interval of sound level: -82.5dB - 0dB
* the limiter level threshold : -10.5dB (suppress signal over target threshold)
* noise gate level threshold : -42dB (suppress background noise)
* noise reducing level: 45db
*
* due to huge span of 8K-48KHz, the attack time and recovery time
* of limiter level are a little different in different frequency
* 8k/16k attack time = 0.5ms, recovery time = 8ms
* 48k attack time = 0.33ms, recovery time = 5.3ms
* 44.1k attack time = 0.36ms, recovery time = 5.8ms
* the value of attack time and recovery time are reverse in noise reduce level
*/
if(substream->stream == SNDRV_PCM_STREAM_CAPTURE){
snd_soc_component_update_bits(component, RT5616_DRC_AGC_1,
0x3 << 14 , 0x3 << 14);
snd_soc_component_update_bits(component, RT5616_DRC_AGC_2,
0x3F << 8 | 0x1F | 0x1 << 7 | 0x3 << 5,
0x30 << 8 | 0x5 | 0x1 << 7 | 0x2 << 5);
snd_soc_component_update_bits(component, RT5616_DRC_AGC_3,
0xF << 12 | 0x1F << 7 | 0x1 << 6 | 0x1F,
0xF << 12 | 0x7 << 7 | 0x1 << 6 | 0x4);
reg = alc5616_codec_read(component, RT5616_DRC_AGC_1);
switch(rate){
case 8000:
reg &= ~(0x1F << 8| 0x1F | 0x7 << 5);
reg |= 0x1 << 5 | 3;
alc5616_index_update_bits(0x06, 0x1F, 4);
alc5616_index_update_bits(0x02, 0x1F << 8, 0 << 8);
break;
case 16000:
reg &= ~(0x1F << 8| 0x1F | 0x7 << 5);
reg |= 0x1 << 8 | 4 | 0x1 << 5;
alc5616_index_update_bits(0x06, 0x1F, 5);
alc5616_index_update_bits(0x02, 0x1F << 8, 1 << 8);
break;
case 44100:
reg &= ~(0x1F << 8| 0x1F | 0x7 << 5);
reg |= 0x2 << 8 | 0x6 | 0x5 << 5;
alc5616_index_update_bits(0x06, 0x1F, 6);
alc5616_index_update_bits(0x02, 0x1F << 8, 2 << 8);
break;
default:
reg &= ~(0x1F << 8| 0x1F | 0x7 << 5);
reg |= 0x2 << 8 | 0x1 | 0x5 << 5;
alc5616_index_update_bits(0x06, 0x1F, 6);
alc5616_index_update_bits(0x02, 0x1F << 8, 2 << 8);
break;
}
alc5616_write(RT5616_DRC_AGC_1, reg);
}
#endif
//printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
return 0;
}
static int alc5616_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
{
struct snd_soc_component *component = codec_dai->component;
unsigned short reg;
reg = alc5616_codec_read(component, RT5616_I2S1_SDP);
/* set master/slave audio interface */
switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
case SND_SOC_DAIFMT_CBM_CFM:
reg &= ~(0x1 << 15);
break;
case SND_SOC_DAIFMT_CBS_CFS:
reg |= 0x1 << 15;
break;
default:
return -EINVAL;
}
/* interface format */
switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
case SND_SOC_DAIFMT_I2S:
reg &= ~0x3;
break;
case SND_SOC_DAIFMT_LEFT_J:
reg &= ~0x3;
reg |= 0x1;
break;
case SND_SOC_DAIFMT_DSP_A:
reg &= ~0x3;
reg |= 0x2;
break;
case SND_SOC_DAIFMT_DSP_B:
reg &= ~0x3;
reg |= 0x3;
break;
default:
return -EINVAL;
}
/* clock inversion
* the ssp driver is opposite to normal setting
* NB_NF of ssp is corresponding to IB_IF of alc5616
*/
switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
case SND_SOC_DAIFMT_NB_NF:
case SND_SOC_DAIFMT_NB_IF:
reg |= 0x1 << 7;
break;
case SND_SOC_DAIFMT_IB_IF:
case SND_SOC_DAIFMT_IB_NF:
reg &= ~(0x1 << 7);
break;
default:
return -EINVAL;
}
snd_soc_component_write(component, RT5616_I2S1_SDP, reg);
//printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
return 0;
}
static int alc5616_set_dai_sysclk(struct snd_soc_dai *dai,
int clk_id, unsigned int freq, int dir)
{
struct clk* mclk;
struct snd_soc_component *component = dai->component;
mclk = devm_clk_get(&g_alc5616_client->dev ,"i2s_sys_clk");
clk_set_rate(mclk, 256*freq);
msleep(20);
snd_soc_component_write(component, 0x73, 0x0102);
alc5616_index_write(RT5616_CHOP_DAC_ADC, 0x3600);
//printk(KERN_INFO"%s/L%d/L%d.\n", __FUNCTION__, __LINE__, freq);
return 0;
}
static int rt5616_set_bias_level(struct snd_soc_component *component,
enum snd_soc_bias_level level)
{
struct clk* mclk;
unsigned short reg;
mclk = devm_clk_get(&g_alc5616_client->dev ,"i2s_sys_clk");
switch (level) {
case SND_SOC_BIAS_ON:
/*this delay means the play or capture is really started
*if pop noise is unbearable, enlarge it and ignore power down time
*/
msleep(300);
reg = alc5616_codec_read(component, RT5616_HP_VOL);
if(!(reg & RT5616_L_MUTE))
snd_soc_component_update_bits(component, RT5616_DEPOP_M1,
RT5616_HP_CO_MASK, RT5616_HP_CO_EN);
break;
case SND_SOC_BIAS_PREPARE:
break;
case SND_SOC_BIAS_STANDBY:
if(snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF){
clk_prepare_enable(mclk);
/* here is replication of rt5616_set_dai_sysclk part setting
* for loopback mode, the upper is for depop noise in playback
* and capture mode
*/
snd_soc_component_write(component, 0x73, 0x0102);
alc5616_index_write(RT5616_CHOP_DAC_ADC, 0x3600);
msleep(20);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_FV1 | RT5616_PWR_FV2,
RT5616_PWR_FV1 | RT5616_PWR_FV2);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_VREF1 | RT5616_PWR_MB |
RT5616_PWR_BG | RT5616_PWR_VREF2 ,
RT5616_PWR_VREF1 | RT5616_PWR_MB |
RT5616_PWR_BG | RT5616_PWR_VREF2);
snd_soc_component_update_bits(component, RT5616_PWR_ANLG1,
RT5616_PWR_LDO_DVO_MASK, RT5616_PWR_LDO_DVO_1_2V);
msleep(60);
snd_soc_component_update_bits(component, RT5616_D_MISC,
RT5616_D_GATE_EN, RT5616_D_GATE_EN);
snd_soc_component_update_bits(component, RT5616_DRC_AGC_1,
0x1 << 13, 0x1 << 13);
}
break;
case SND_SOC_BIAS_OFF:
alc5616_index_write(RT5616_CHOP_DAC_ADC, 0x2000);
if(g_5616_headset_detection_enabled){
snd_soc_component_update_bits(component, RT5616_D_MISC,
RT5616_D_GATE_EN, 1);
}else{
clk_disable_unprepare(mclk);
snd_soc_component_update_bits(component,RT5616_D_MISC,
RT5616_D_GATE_EN, 0);
}
snd_soc_component_write(component, RT5616_PWR_DIG1, 0x0000);
snd_soc_component_write(component, RT5616_PWR_DIG2, 0x0000);
snd_soc_component_write(component, RT5616_PWR_VOL, 0x0000);
snd_soc_component_write(component, RT5616_PWR_MIXER, 0x0000);
snd_soc_component_write(component, RT5616_PWR_ANLG1, 0x00c2);
snd_soc_component_write(component, RT5616_PWR_ANLG2, 0x0004);
break;
default:
break;
}
return 0;
}
static const struct snd_soc_component_driver soc_component_dev_alc5616 = {
.probe = alc5616_codec_probe,
.read = alc5616_codec_read,
.write = alc5616_codec_write,
.set_bias_level = rt5616_set_bias_level,
.controls = rt5616_snd_controls,
.num_controls = ARRAY_SIZE(rt5616_snd_controls),
.dapm_widgets = rt5616_dapm_widgets,
.num_dapm_widgets = ARRAY_SIZE(rt5616_dapm_widgets),
.dapm_routes = rt5616_dapm_routes,
.num_dapm_routes = ARRAY_SIZE(rt5616_dapm_routes),
.use_pmdown_time = 1,
.endianness = 1,
.non_legacy_dai_naming = 1,
};
static struct snd_soc_dai_ops alc5616_dai_ops = {
.digital_mute = alc5616_digital_mute,
.hw_params = alc5616_hw_params,
.set_fmt = alc5616_set_dai_fmt,
.set_sysclk = alc5616_set_dai_sysclk,
};
static struct snd_soc_dai_driver alc5616_dai[] ={
{
/* DAI I2S(SAI1) */
.name = "alc5616-i2s",
.id = 1,
.playback = {
.stream_name = "I2S Playback",
.channels_min = 2,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S8| \
SNDRV_PCM_FMTBIT_S16_LE | \
SNDRV_PCM_FMTBIT_S20_3LE | \
SNDRV_PCM_FMTBIT_S24_LE | \
SNDRV_PCM_FMTBIT_S32_LE,
},
.capture = {
.stream_name = "I2S Capture",
.channels_min = 2,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S8| \
SNDRV_PCM_FMTBIT_S16_LE | \
SNDRV_PCM_FMTBIT_S20_3LE | \
SNDRV_PCM_FMTBIT_S24_LE | \
SNDRV_PCM_FMTBIT_S32_LE,
},
.ops = &alc5616_dai_ops,
}, {
/* DAI PCM(SAI2) */
.name = "alc5616-pcm",
.id = 2,
.playback = {
.stream_name = "PCM Playback",
.channels_min = 1,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S8| \
SNDRV_PCM_FMTBIT_S16_LE | \
SNDRV_PCM_FMTBIT_S20_3LE | \
SNDRV_PCM_FMTBIT_S24_LE | \
SNDRV_PCM_FMTBIT_S32_LE,
},
.capture = {
.stream_name = "PCM Capture",
.channels_min = 1,
.channels_max = 2,
.rates = SNDRV_PCM_RATE_8000_48000,
.formats = SNDRV_PCM_FMTBIT_S8| \
SNDRV_PCM_FMTBIT_S16_LE | \
SNDRV_PCM_FMTBIT_S20_3LE | \
SNDRV_PCM_FMTBIT_S24_LE | \
SNDRV_PCM_FMTBIT_S32_LE,
},
.ops = &alc5616_dai_ops,
},
};
#ifdef HEADSET_DETECTION
irqreturn_t codec_irq_handler(int irq, void *dev_id)
{
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
/* check the headset plug in/out */
alc5616_get_headset_status();
return IRQ_HANDLED;
}
#endif
//Kestrel
void audio_set_codec_vdd(int on_off)
{
struct regulator *vdd_1v8 = NULL;
struct regulator *vdd_3v3 = NULL;
static int codec_on_off = 0;
printk(KERN_INFO"%s: codec now:%d, to be:%d\n", __FUNCTION__, codec_on_off, on_off);
if (!(cpu_is_asr1901() || cpu_is_asr1906()) || codec_on_off == on_off)
{
return;
}
if(on_off) {
/* 1V8 */
vdd_1v8 = regulator_get(&g_alc5616_client->dev, "vdd18");
if (IS_ERR_OR_NULL(vdd_1v8)) {
if (PTR_ERR(vdd_1v8) < 0) {
printk(KERN_INFO"%s: the regulator for vdd_1v8 not found.\n", __FUNCTION__);
}
} else {
alc5616_regulator_vdd_1v8 = vdd_1v8;
printk(KERN_INFO"%s: the regulator for vdd_1v8 is OK.\n", __FUNCTION__);
}
if (alc5616_regulator_vdd_1v8 > 0) {
if (regulator_set_voltage(alc5616_regulator_vdd_1v8, 1800000, 1800000))
printk(KERN_INFO"fail to set regulator with 1.8v.\n");
if (regulator_enable(alc5616_regulator_vdd_1v8))
printk(KERN_INFO"fail to enable regulator vdd_1v8.\n");
}
/* 3V3 */
vdd_3v3 = regulator_get(&g_alc5616_client->dev, "vdd33");
if (IS_ERR_OR_NULL(vdd_3v3)) {
if (PTR_ERR(vdd_3v3) < 0) {
printk(KERN_INFO"%s: the regulator for vdd_3v3 not found.\n", __FUNCTION__);
}
} else {
alc5616_regulator_vdd_3v3 = vdd_3v3;
printk(KERN_INFO"%s: the regulator for vdd_3v3 is OK.\n", __FUNCTION__);
}
if (alc5616_regulator_vdd_3v3 > 0) {
if (regulator_set_voltage(alc5616_regulator_vdd_3v3, 3300000, 3300000))
printk(KERN_INFO"fail to set regulator with 3.3v.\n");
if (regulator_enable(alc5616_regulator_vdd_3v3))
printk(KERN_INFO"fail to enable regulator vdd_3v3.\n");
}
codec_on_off = 1;
}
else {
if (alc5616_regulator_vdd_1v8 > 0) {
if (regulator_disable(alc5616_regulator_vdd_1v8))
printk(KERN_INFO"fail to disable regulator vdd_1v8\n");
}
if (alc5616_regulator_vdd_3v3 > 0) {
if (regulator_disable(alc5616_regulator_vdd_3v3))
printk(KERN_INFO"fail to disable regulator vdd_3v3\n");
}
codec_on_off = 0;
}
}
EXPORT_SYMBOL_GPL(audio_set_codec_vdd);
//Kestrel/NezhaC/Falcon
static void alc5616_config_init(void)
{
struct pinctrl_state *pin_AUDIO = NULL;
int gpio_1V8 = 0;
int gpio_3V3 = 0;
#ifdef HEADSET_DETECTION
int ret = -1;
#endif
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
#endif
if (cpu_is_asr1803()) {
printk(KERN_INFO"%s, platform is Falcon.\n", __FUNCTION__);
} else if (cpu_is_asr1806()) {
printk(KERN_INFO"%s, platform is Falcon-T.\n", __FUNCTION__);
} else if (cpu_is_asr1901() || cpu_is_asr1906()) {
printk(KERN_INFO"%s, platform is Kestrel.\n", __FUNCTION__);
} else if (cpu_is_asr1903()) {
printk(KERN_INFO"%s, platform is Lapwing.\n", __FUNCTION__);
} else if (cpu_is_asr1802s()) {
printk(KERN_INFO"%s, platform is Nezhac.\n", __FUNCTION__);
} else {
printk(KERN_INFO"%s, please check the platform.\n", __FUNCTION__);
}
/*
NezhaC AUDIO_PIN_CTRL = TDS_DIO10 = function 1 , GPIO-78
Config MPFR in arch/arm/boot/dts/asr1802s-p201.dts
*/
pin_AUDIO = pinctrl_lookup_state(g_alc5616_pinctrl, "default");
pinctrl_select_state(g_alc5616_pinctrl, pin_AUDIO);
/* config MPFR of device node "asrmicro,alc5616" */
if (cpu_is_asr1802s()) {
gpio_tds_dio10 = of_get_named_gpio(g_alc5616_node, "tds_dio10-gpio", 0);/* GPIO[78] */
gpio_vcxo_out = of_get_named_gpio(g_alc5616_node, "vcxo_out-gpio", 0);/* GPIO[126] */
}
printk(KERN_INFO"%s/L%d, gpio_tds_dio10 = %d, gpio_vcxo_out = %d\n", __FUNCTION__, __LINE__, gpio_tds_dio10, gpio_vcxo_out);
/* TDS_DIO10 */
//gpio_request(gpio_tds_dio10, "TDS_DIO10");
//gpio_direction_output(gpio_tds_dio10, 0);
/* VCXO_OUT */
if (cpu_is_asr1802s()) {
gpio_request(gpio_vcxo_out, "VCXO_OUT");
gpio_direction_input(gpio_vcxo_out);
}
/* config VDD */
if (cpu_is_asr1802s()) {
gpio_1V8 = of_get_named_gpio(g_alc5616_node, "1V8-gpio", 0);
}
gpio_3V3 = of_get_named_gpio(g_alc5616_node, "3V3-gpio", 0);
printk(KERN_INFO"%s/L%d, gpio_1V8=%d, gpio_3V3=%d.\n", __FUNCTION__, __LINE__, gpio_1V8, gpio_3V3);
/* GPIO_31 for CODEC_1V8_EN.
GPIO_32 for CODEC_3V3_EN. */
//gpio_31_CODEC_1V8_EN = mfp_to_gpio(MFP_PIN_GPIO31);
//gpio_32_CODEC_3V3_EN = mfp_to_gpio(MFP_PIN_GPIO32);
if (cpu_is_asr1802s()) {
gpio_31_CODEC_1V8_EN = gpio_1V8;
}
gpio_32_CODEC_3V3_EN = gpio_3V3;
if (cpu_is_asr1802s()) {
if (gpio_31_CODEC_1V8_EN) {
if (gpio_request(gpio_31_CODEC_1V8_EN, "power on/off 1V8")) {
gpio_31_CODEC_1V8_EN = 0;
} else {
gpio_direction_output(gpio_31_CODEC_1V8_EN, 0);
}
}
}
if (gpio_32_CODEC_3V3_EN >= 0) {
if (gpio_request(gpio_32_CODEC_3V3_EN, "power on/off 3V3")) {
gpio_32_CODEC_3V3_EN = 0;
} else {
gpio_direction_output(gpio_32_CODEC_3V3_EN, 0);
}
}
if (cpu_is_asr1802s()) {
gpio_direction_output(gpio_31_CODEC_1V8_EN, 1);
}
if (gpio_32_CODEC_3V3_EN >= 0) {
gpio_direction_output(gpio_32_CODEC_3V3_EN, 1);
}
/* Power on for ASR1901 kestrel */
audio_set_codec_vdd(1);
#ifdef HEADSET_DETECTION
/* CODEC_IRQ */
gpio_CODEC_IRQ = of_get_named_gpio(g_alc5616_node, "irq-gpio", 0); //GPIO[1]
printk(KERN_INFO"%s/L%d, gpio_CODEC_IRQ=%d.\n", __FUNCTION__, __LINE__, gpio_CODEC_IRQ);
gpio_request(gpio_CODEC_IRQ, "CODEC_IRQ");
gpio_direction_input(gpio_CODEC_IRQ);
irq_codec = gpio_to_irq(gpio_CODEC_IRQ);
printk(KERN_INFO"%s/L%d, irq_codec=%d.\n", __FUNCTION__, __LINE__, irq_codec);
/* request irq */
ret = request_threaded_irq(irq_codec, NULL, codec_irq_handler,
IRQF_SHARED | IRQF_TRIGGER_RISING |
IRQF_TRIGGER_FALLING | IRQF_ONESHOT, "alc5616-headset_detection",
g_alc5616_client);
if (ret < 0) {
printk(KERN_INFO"%s: request irq failed!\n",__FUNCTION__);
}
#endif
#if 0 //The vdds should be supplied
/* Power off for ASR1901 kestrel */
audio_set_codec_vdd(0);
#endif
return;
}
static int g_fsync_rate = 0;
static ssize_t alc5616_switch_rate_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
int s = 0;
s += sprintf(buf, "%d", g_fsync_rate);
return s;
}
static ssize_t alc5616_switch_rate_set(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int ret;
ret = kstrtoint(buf, 10, &g_fsync_rate);
if (ret)
return ret;
Audio_Codec_Fsync_Rate = g_fsync_rate;
enable_5616_MClock();
printk(KERN_INFO"%s, Audio_Codec_Fsync_Rate=%d\n", __FUNCTION__, Audio_Codec_Fsync_Rate);
return count;
}
static DEVICE_ATTR(alc5616_switch_rate, 0644, alc5616_switch_rate_show, alc5616_switch_rate_set);
/* i2c driver */
static int alc5616_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int ret = 0;
printk(KERN_INFO"[5616 codec-dai probe: begin] %s/L%d.\n", __FUNCTION__, __LINE__);
if (NULL == client) {
printk(KERN_INFO"Please check codec input parameter for client.\n");
return 0;
}
g_alc5616_client = client;
g_alc5616_pinctrl = devm_pinctrl_get(&client->dev);
if (NULL == g_alc5616_pinctrl){
printk(KERN_INFO"Please check codec input parameter for g_alc5616_pinctrl.\n");
return 0;
}
g_alc5616_node = client->dev.of_node;
if (NULL == g_alc5616_node){
printk(KERN_INFO"Please check codec input parameter for g_alc5616_node.\n");
return 0;
}
alc5616_dump_debugfs_init(NULL);
alc5616_audio_debugfs_init(NULL);
/* Power on the ALC5616. */
alc5616_config_init();
/* initiate the ALC5616 codec. */
codec_alc5616_init();
if (!codec_alc5616_is_connect()) {
printk(KERN_INFO"Please check codec alc5616 OK or not.\n");
return 0;
}
#ifdef CONFIG_CPU_ASR1901
if(!enable_pmu_audio_clk())
{
#endif
enable_5616_MClock();
rt5616_set_sysclk(1);
#ifdef CONFIG_CPU_ASR1901
}
#endif
#if 0
/* if debug the codec in kernel, could open the procedure */
/* enable the path. */
codec_rt5616_power_on();
//codec_rt5616_enable_headphone_main_mic();
//codec_alc5616_switch_headset(1);
alc5616_headphone_on();
alc5616_headset_mic_on();
codec_rt5616_set_headphone_gain();
codec_rt5616_set_headphone_mic_gain();
#endif
#if 0
/* if debug the codec in kernel, could open the procedure for spk */
/* enable the path. */
codec_rt5616_power_on();
alc5616_speaker_on();
alc5616_main_mic_on();
/* Enable the speaker path using the command:echo 7 > /sys/kernel/debug/alc5616_audio */
/* Enable PA from CP or Enable PA using the command:echo 0 > /sys/kernel/debug/alc5616_audio */
#endif
/*
create the platform device, and platform driver will register codec to ALSA.
which will be for device node, such as /dev/snd/timer, control0, ...
snd_soc_register_codec(&client->dev, &soc_codec_dev_alc5616,
alc5616_dai, ARRAY_SIZE(alc5616_dai));
int snd_soc_register_card(struct snd_soc_card *card)
*/
ret = devm_snd_soc_register_component(&client->dev, &soc_component_dev_alc5616,
alc5616_dai, ARRAY_SIZE(alc5616_dai));
if (ret < 0) {
printk(KERN_INFO"Failed to register codec alc5616: %d.\n", ret);
return ret;
}
/* Headset detection platform device */
alc5616_headset_detection_init(client);
/* create the interface for audio_if command "config_pcm" */
ret = device_create_file(&client->dev, &dev_attr_alc5616_switch_rate);
if (ret < 0) {
printk(KERN_INFO"attr alc5616_switch_rate create fail: %d.\n", ret);
return ret;
}
printk(KERN_INFO"[5616 codec-dai probe: end] %s/L%d.\n", __FUNCTION__, __LINE__);
return 0;
}
static int alc5616_remove(struct i2c_client *client)
{
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
#endif
alc5616_dump_debugfs_remove(NULL);
alc5616_audio_debugfs_remove(NULL);
/* free gpio resource. */
//gpio_free(gpio_tds_dio10);
if (cpu_is_asr1802s()) {
gpio_free(gpio_vcxo_out);
}
if (cpu_is_asr1802s()) {
gpio_free(gpio_31_CODEC_1V8_EN);
}
if (gpio_32_CODEC_3V3_EN >= 0) {
gpio_free(gpio_32_CODEC_3V3_EN);
}
/* Power off for ASR1901 kestrel */
audio_set_codec_vdd(0);
#ifdef HEADSET_DETECTION
gpio_free(gpio_CODEC_IRQ);
free_irq(irq_codec, g_alc5616_client);
#endif
/* disable the path. */
//codec_alc5616_disable_path();
//codec_alc5616_disable_path_app();
codec_rt5616_power_off();
g_alc5616_client = NULL;
mfd_remove_devices(&client->dev);
return 0;
}
void alc5616_shutdown(struct i2c_client *client)
{
#ifdef ALC5616_DEBUG
printk(KERN_INFO"%s/L%d.\n", __FUNCTION__, __LINE__);
#endif
return;
}
static struct i2c_driver alc5616_driver = {
.driver = {
.name = "alc5616",
.of_match_table = of_match_ptr(alc5616_dt_ids),
},
.probe = alc5616_probe,
.remove = alc5616_remove,
//.shutdown = alc5616_shutdown,
.id_table = alc5616_id_table,
};
static int alc5616_i2c_init(void)
{
return i2c_add_driver(&alc5616_driver);
}
module_init(alc5616_i2c_init);
static void alc5616_i2c_exit(void)
{
i2c_del_driver(&alc5616_driver);
}
module_exit(alc5616_i2c_exit);
MODULE_DESCRIPTION("Driver for alc5616");
MODULE_AUTHOR("wenchen@asrmicro.com");
MODULE_LICENSE("GPL");