static int nc_set_selected_output_dev(u8 value)
{
struct sc_reg_access sc_access_HP[] = {
{LMUTE, 0x02, 0x06},
{RMUTE, 0x02, 0x06}
};
struct sc_reg_access sc_access_IS[] = {
{LMUTE, 0x04, 0x06},
{RMUTE, 0x04, 0x06}
};
int retval = 0;
snd_pmic_ops_nc.output_dev_id = value;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
pr_debug("nc set selected output:%d\n", value);
switch (value) {
case STEREO_HEADPHONE:
retval = sst_sc_reg_access(sc_access_HP, PMIC_WRITE, 2);
break;
case INTERNAL_SPKR:
retval = sst_sc_reg_access(sc_access_IS, PMIC_WRITE, 2);
break;
default:
pr_err("rcvd illegal request: %d\n", value);
return -EINVAL;
}
return retval;
}
int msic_get_headset_state(int mic_bias)
{
struct sc_reg_access msic_hs_toggle[] = {
{0x070, 0x00, 0x01},
};
if (mic_bias >= 0 && mic_bias < 400) {
pr_debug("Detected Headphone!!!\n");
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
} else if (mic_bias > 400 && mic_bias < 650) {
pr_debug("Detected American headset\n");
msic_hs_toggle[0].value = 0x01;
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
} else if (mic_bias >= 650 && mic_bias < 2000) {
pr_debug("Detected Headset!!!\n");
sst_sc_reg_access(msic_hs_toggle, PMIC_READ_MODIFY, 1);
/*power on jack and btn*/
snd_msic_ops.jack_interrupt_status = true;
msic_enable_jack_btn();
msic_enable_mic_bias();
return SND_JACK_HEADSET;
} else
pr_debug("Detected Open Cable!!!\n");
return SND_JACK_HEADPHONE;
}
static int fs_set_voice_port(int status)
{
struct sc_reg_access sc_access[2];
int retval = 0;
if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
retval = fs_init_card();
if (retval)
return retval;
if (status == DEACTIVATE) {
/* Deactivate audio port-tristate and power */
sc_access[0].value = 0x00;
sc_access[0].mask = MASK6|MASK7;
sc_access[0].reg_addr = VOICEPORT1;
sc_access[1].value = 0x00;
sc_access[1].mask = MASK0|MASK1;
sc_access[1].reg_addr = POWERCTRL2;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
} else if (status == ACTIVATE) {
/* activate audio port */
sc_access[0].value = 0xC0;
sc_access[0].mask = MASK6|MASK7;
sc_access[0].reg_addr = VOICEPORT1;
sc_access[1].value = 0x03;
sc_access[1].mask = MASK0|MASK1;
sc_access[1].reg_addr = POWERCTRL2;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
} else
return -EINVAL;
}
static int msic_set_selected_input_dev(u8 value)
{
struct sc_reg_access sc_access_dmic[] = {
{0x24C, 0x10, 0x0},
};
struct sc_reg_access sc_access_amic[] = {
{0x24C, 0x76, 0x0},
};
int retval = 0;
pr_debug("msic_set_selected_input_dev:%d\n", value);
snd_msic_ops.input_dev_id = value;
switch (value) {
case AMIC:
pr_debug("Selecting AMIC1\n");
retval = sst_sc_reg_access(sc_access_amic, PMIC_WRITE, 1);
break;
case DMIC:
pr_debug("Selecting DMIC1\n");
retval = sst_sc_reg_access(sc_access_dmic, PMIC_WRITE, 1);
break;
default:
return -EINVAL;
}
if (snd_msic_ops.cap_on)
retval = msic_power_up_cp(SND_SST_DEVICE_CAPTURE);
return retval;
}
static int msic_power_down(void)
{
struct sc_reg_access power_dn[] = {
/* VHSP */
{0x0DC, 0xC4, 0},
/* VHSN */
{0x0DD, 0x04, 0},
/* VIHF */
{0x0C9, 0x24, 0},
};
struct sc_reg_access pll[] = {
/* turn off PLL*/
{0x240, 0x00, 0x0},
};
struct sc_reg_access vaud[] = {
/* turn off VAUD*/
{0x0DB, 0x04, 0},
};
pr_debug("powering dn msic\n");
snd_msic_ops.pbhs_on = 0;
snd_msic_ops.pb_on = 0;
snd_msic_ops.cap_on = 0;
sst_sc_reg_access(power_dn, PMIC_WRITE, 3);
msleep(1);
sst_sc_reg_access(pll, PMIC_WRITE, 1);
msleep(1);
sst_sc_reg_access(vaud, PMIC_WRITE, 1);
return 0;
}
static int msic_power_down_cp(unsigned int device)
{
struct sc_reg_access dmic[] = {
{0x247, 0x00, 0xA0},
{0x245, 0x00, 0x38},
{0x246, 0x00, 0x07},
};
struct sc_reg_access amic[] = {
{0x248, 0x00, 0x05},
{0x249, 0x00, 0x01},
{0x24A, 0x00, 0x01},
{0x247, 0x00, 0xA3},
};
struct sc_reg_access tx_off[] = {
{0x24F, 0x00, 0x3C},
};
pr_debug("powering dn cp....\n");
snd_msic_ops.cap_on = 0;
sst_sc_reg_access(tx_off, PMIC_READ_MODIFY, 1);
if (snd_msic_ops.input_dev_id == DMIC)
sst_sc_reg_access(dmic, PMIC_READ_MODIFY, 3);
else
sst_sc_reg_access(amic, PMIC_READ_MODIFY, 4);
return 0;
}
static int nc_set_audio_port(int status)
{
struct sc_reg_access sc_access[2] = {{0,},};
int retval = 0;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
if (status == DEACTIVATE) {
/* Deactivate audio port-tristate and power */
sc_access[0].value = 0x00;
sc_access[0].mask = MASK4|MASK5;
sc_access[0].reg_addr = AUDIOPORT1;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
} else if (status == ACTIVATE) {
/* activate audio port */
nc_audio_init();
sc_access[0].value = 0x10;
sc_access[0].mask = MASK4|MASK5 ;
sc_access[0].reg_addr = AUDIOPORT1;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
} else
return -EINVAL;
}
static int fs_set_selected_output_dev(u8 value)
{
struct sc_reg_access sc_access_hp[] = {
{0x191, 0x11, 0x0},
{0x192, 0x0E, 0x0},
};
struct sc_reg_access sc_access_is[] = {
{0x191, 0x17, 0xFF},
{0x192, 0x08, 0xFF},
};
int retval = 0;
if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
retval = fs_init_card();
if (retval)
return retval;
switch (value) {
case STEREO_HEADPHONE:
pr_debug("SST DBG:Selecting headphone\n");
return sst_sc_reg_access(sc_access_hp, PMIC_WRITE, 2);
break;
case MONO_EARPIECE:
case INTERNAL_SPKR:
pr_debug("SST DBG:Selecting internal spkr\n");
return sst_sc_reg_access(sc_access_is, PMIC_READ_MODIFY, 2);
break;
default:
return -EINVAL;
}
}
static int mx_enable_audiodac(int value)
{
struct sc_reg_access sc_access[3];
int mute_val = 0;
int mute_val1 = 0;
int retval = 0;
sc_access[0].reg_addr = AS_LEFT_HP_VOL_CTL;
sc_access[1].reg_addr = AS_RIGHT_HP_VOL_CTL;
if (value == UNMUTE) {
mute_val = 0x1F;
mute_val1 = 0x00;
} else {
mute_val = 0x00;
mute_val1 = 0x40;
}
sc_access[0].mask = sc_access[1].mask = MASK0|MASK1|MASK2|MASK3|MASK4;
sc_access[0].value = sc_access[1].value = (u8)mute_val;
retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
if (retval)
return retval;
pr_debug("mute status = %d\n", snd_pmic_ops_mx.mute_status);
if (snd_pmic_ops_mx.mute_status == MUTE ||
snd_pmic_ops_mx.master_mute == MUTE)
return retval;
sc_access[0].reg_addr = VOL_CTRL_LT;
sc_access[1].reg_addr = VOL_CTRL_RT;
sc_access[0].mask = sc_access[1].mask = MASK6;
sc_access[0].value = sc_access[1].value = mute_val1;
if (snd_pmic_ops_mx.num_channel == 1)
sc_access[1].value = 0x40;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
}
static int nc_set_voice_port(int status)
{
struct sc_reg_access sc_access[2] = {{0,},};
int retval = 0;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
if (status == DEACTIVATE) {
/* Activate Voice port */
sc_access[0].value = 0x00;
sc_access[0].mask = MASK4;
sc_access[0].reg_addr = VOICEPORT1;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
} else if (status == ACTIVATE) {
/* Deactivate voice port */
nc_set_pcm_voice_params();
sc_access[0].value = 0x10;
sc_access[0].mask = MASK4;
sc_access[0].reg_addr = VOICEPORT1;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
} else
return -EINVAL;
}
static int fs_set_vol(int dev_id, int value)
{
struct sc_reg_access sc_acces, sc_access[4] = {{0},};
int reg_num = 0;
int retval = 0;
if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
retval = fs_init_card();
if (retval)
return retval;
switch (dev_id) {
case PMIC_SND_LEFT_PB_VOL:
pr_debug("PMIC_SND_LEFT_PB_VOL:%d\n", value);
sc_access[0].value = sc_access[1].value = value;
sc_access[0].reg_addr = AUD16;
sc_access[1].reg_addr = AUD15;
sc_access[0].mask = sc_access[1].mask =
(MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
reg_num = 2;
break;
case PMIC_SND_RIGHT_PB_VOL:
pr_debug("PMIC_SND_RIGHT_PB_VOL:%d\n", value);
sc_access[0].value = sc_access[1].value = value;
sc_access[0].reg_addr = AUD17;
sc_access[1].reg_addr = AUD15;
sc_access[0].mask = sc_access[1].mask =
(MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
if (snd_pmic_ops_fs.num_channel == 1) {
sc_access[0].value = sc_access[1].value = 0x80;
sc_access[0].mask = sc_access[1].mask = MASK7;
}
reg_num = 2;
break;
case PMIC_SND_CAPTURE_VOL:
pr_debug("PMIC_SND_CAPTURE_VOL:%d\n", value);
sc_access[0].reg_addr = MICLICTRL1;
sc_access[1].reg_addr = MICLICTRL2;
sc_access[2].reg_addr = DMICCTRL1;
sc_access[2].value = value;
sc_access[0].value = sc_access[1].value = value;
sc_acces.reg_addr = MICLICTRL3;
sc_acces.value = value;
sc_acces.mask = (MASK0|MASK1|MASK2|MASK3|MASK5|MASK6|MASK7);
retval = sst_sc_reg_access(&sc_acces, PMIC_READ_MODIFY, 1);
sc_access[0].mask = sc_access[1].mask =
sc_access[2].mask = (MASK0|MASK1|MASK2|MASK3|MASK4|MASK5);
reg_num = 3;
break;
default:
return -EINVAL;
}
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, reg_num);
}
static int nc_power_up_pb(unsigned int port)
{
struct sc_reg_access sc_access[7];
int retval = 0;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
if (port == 0xFF)
return 0;
nc_enable_audiodac(MUTE);
msleep(30);
pr_debug("powering up pb....\n");
sc_access[0].reg_addr = VAUDIOCNT;
sc_access[0].value = 0x27;
sc_access[0].mask = 0x27;
sc_access[1].reg_addr = VREFPLL;
if (port == 0) {
sc_access[1].value = 0x3A;
sc_access[1].mask = 0x3A;
} else if (port == 1) {
sc_access[1].value = 0x35;
sc_access[1].mask = 0x35;
}
retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
sc_access[0].reg_addr = POWERCTRL1;
if (port == 0) {
sc_access[0].value = 0x40;
sc_access[0].mask = 0x40;
} else if (port == 1) {
sc_access[0].value = 0x01;
sc_access[0].mask = 0x01;
}
sc_access[1].reg_addr = POWERCTRL2;
sc_access[1].value = 0x0C;
sc_access[1].mask = 0x0C;
sc_access[2].reg_addr = DRVPOWERCTRL;
sc_access[2].value = 0x86;
sc_access[2].mask = 0x86;
sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 3);
msleep(30);
return nc_enable_audiodac(UNMUTE);
}
static int nc_power_down(void)
{
int retval = 0;
struct sc_reg_access sc_access[5];
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
nc_enable_audiodac(MUTE);
pr_debug("powering dn nc_power_down ....\n");
if (snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE ||
snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)
nc_set_amp_power(0);
msleep(30);
sc_access[0].reg_addr = DRVPOWERCTRL;
sc_access[0].value = 0x00;
sc_access[0].mask = 0x00;
sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
sc_access[0].reg_addr = POWERCTRL1;
sc_access[0].value = 0x00;
sc_access[0].mask = 0x00;
sc_access[1].reg_addr = POWERCTRL2;
sc_access[1].value = 0x00;
sc_access[1].mask = 0x00;
sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
msleep(30);
sc_access[0].reg_addr = VREFPLL;
sc_access[0].value = 0x10;
sc_access[0].mask = 0x10;
sc_access[1].reg_addr = VAUDIOCNT;
sc_access[1].value = 0x25;
sc_access[1].mask = 0x25;
retval = sst_sc_reg_access(sc_access, PMIC_WRITE, 2);
msleep(30);
return nc_enable_audiodac(UNMUTE);
}
static int nc_power_up_cp(unsigned int port)
{
struct sc_reg_access sc_access[5];
int retval = 0;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
pr_debug("powering up cp....\n");
if (port == 0xFF)
return 0;
sc_access[0].reg_addr = VAUDIOCNT;
sc_access[0].value = 0x27;
sc_access[0].mask = 0x27;
sc_access[1].reg_addr = VREFPLL;
if (port == 0) {
sc_access[1].value = 0x3E;
sc_access[1].mask = 0x3E;
} else if (port == 1) {
sc_access[1].value = 0x35;
sc_access[1].mask = 0x35;
}
retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
sc_access[0].reg_addr = POWERCTRL1;
if (port == 0) {
sc_access[0].value = 0xB4;
sc_access[0].mask = 0xB4;
} else if (port == 1) {
sc_access[0].value = 0xBF;
sc_access[0].mask = 0xBF;
}
sc_access[1].reg_addr = POWERCTRL2;
if (port == 0) {
sc_access[1].value = 0x0C;
sc_access[1].mask = 0x0C;
} else if (port == 1) {
sc_access[1].value = 0x02;
sc_access[1].mask = 0x02;
}
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
}
static int msic_enable_mic_bias(void)
{
struct sc_reg_access jack_interrupt_reg[] = {
{0x0DB, 0x07, 0x00},
};
struct sc_reg_access jack_bias_reg[] = {
{0x247, 0x0C, 0x0C},
};
sst_sc_reg_access(jack_interrupt_reg, PMIC_WRITE, 1);
sst_sc_reg_access(jack_bias_reg, PMIC_READ_MODIFY, 1);
return 0;
}
static int mx_get_mute(int dev_id, u8 *value)
{
struct sc_reg_access sc_access[4] = {{0},};
int retval = 0, num_reg = 0, mask = 0;
if (snd_pmic_ops_mx.card_status == SND_CARD_UN_INIT) {
retval = mx_init_card();
if (retval)
return retval;
}
switch (dev_id) {
case PMIC_SND_DMIC_MUTE:
case PMIC_SND_AMIC_MUTE:
case PMIC_SND_HP_MIC_MUTE:
sc_access[0].reg_addr = 0x220;
mask = MASK5|MASK6;
num_reg = 1;
retval = sst_sc_reg_access(sc_access, PMIC_READ, num_reg);
if (retval)
return retval;
*value = sc_access[0].value & mask;
if (*value)
*value = UNMUTE;
else
*value = MUTE;
return retval;
case PMIC_SND_LEFT_HP_MUTE:
case PMIC_SND_LEFT_SPEAKER_MUTE:
sc_access[0].reg_addr = VOL_CTRL_LT;
num_reg = 1;
mask = MASK6;
break;
case PMIC_SND_RIGHT_HP_MUTE:
case PMIC_SND_RIGHT_SPEAKER_MUTE:
sc_access[0].reg_addr = VOL_CTRL_RT;
num_reg = 1;
mask = MASK6;
break;
}
retval = sst_sc_reg_access(sc_access, PMIC_READ, num_reg);
if (retval)
return retval;
*value = sc_access[0].value & mask;
if (*value)
*value = MUTE;
else
*value = UNMUTE;
return retval;
}
static int msic_get_mic_bias(void *arg)
{
struct snd_intelmad *intelmad_drv = (struct snd_intelmad *)arg;
u16 adc_adr = intelmad_drv->adc_address;
u16 adc_val;
int ret;
struct sc_reg_access adc_ctrl3[2] = {
{0x1C2, 0x05, 0x0},
};
struct sc_reg_access audio_adc_reg1 = {0,};
struct sc_reg_access audio_adc_reg2 = {0,};
msic_enable_mic_bias();
/* Enable the msic for conversion before reading */
ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
if (ret)
return ret;
adc_ctrl3[0].value = 0x04;
/* Re-toggle the RRDATARD bit */
ret = sst_sc_reg_access(adc_ctrl3, PMIC_WRITE, 1);
if (ret)
return ret;
audio_adc_reg1.reg_addr = adc_adr;
/* Read the higher bits of data */
msleep(1000);
ret = sst_sc_reg_access(&audio_adc_reg1, PMIC_READ, 1);
if (ret)
return ret;
pr_debug("adc read value %x", audio_adc_reg1.value);
/* Shift bits to accomodate the lower two data bits */
adc_val = (audio_adc_reg1.value << 2);
adc_adr++;
audio_adc_reg2. reg_addr = adc_adr;
ret = sst_sc_reg_access(&audio_adc_reg2, PMIC_READ, 1);
if (ret)
return ret;
pr_debug("adc read value %x", audio_adc_reg2.value);
/* Adding lower two bits to the higher bits */
audio_adc_reg2.value &= 03;
adc_val += audio_adc_reg2.value;
pr_debug("ADC value 0x%x", adc_val);
msic_disable_mic_bias();
return adc_val;
}
static int msic_set_hw_dmic_route(u8 hw_ch_index)
{
struct sc_reg_access sc_access_router;
int retval = -EINVAL;
switch (hw_ch_index) {
case HW_CH0:
sc_access_router.reg_addr = AUDIOMUX12;
sc_access_router.value = snd_msic_ops.hw_dmic_map[0];
sc_access_router.mask = (MASK2 | MASK1 | MASK0);
pr_debug("hw_ch0. value = 0x%x\n",
sc_access_router.value);
retval = sst_sc_reg_access(&sc_access_router,
PMIC_READ_MODIFY, 1);
break;
case HW_CH1:
sc_access_router.reg_addr = AUDIOMUX12;
sc_access_router.value = (snd_msic_ops.hw_dmic_map[1]) << 4;
sc_access_router.mask = (MASK6 | MASK5 | MASK4);
pr_debug("### hw_ch1. value = 0x%x\n",
sc_access_router.value);
retval = sst_sc_reg_access(&sc_access_router,
PMIC_READ_MODIFY, 1);
break;
case HW_CH2:
sc_access_router.reg_addr = AUDIOMUX34;
sc_access_router.value = snd_msic_ops.hw_dmic_map[2];
sc_access_router.mask = (MASK2 | MASK1 | MASK0);
pr_debug("hw_ch2. value = 0x%x\n",
sc_access_router.value);
retval = sst_sc_reg_access(&sc_access_router,
PMIC_READ_MODIFY, 1);
break;
case HW_CH3:
sc_access_router.reg_addr = AUDIOMUX34;
sc_access_router.value = (snd_msic_ops.hw_dmic_map[3]) << 4;
sc_access_router.mask = (MASK6 | MASK5 | MASK4);
pr_debug("hw_ch3. value = 0x%x\n",
sc_access_router.value);
retval = sst_sc_reg_access(&sc_access_router,
PMIC_READ_MODIFY, 1);
break;
}
return retval;
}
static int msic_set_headset_state(int state)
{
struct sc_reg_access hs_enable[] = {
{0x25D, 0x03, 0x03},
};
if (state)
/*enable*/
sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
else {
hs_enable[0].value = 0;
sst_sc_reg_access(hs_enable, PMIC_READ_MODIFY, 1);
}
return 0;
}
static int nc_get_mute(int dev_id, u8 *value)
{
int retval = 0, mask = 0;
struct sc_reg_access sc_access = {0,};
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
pr_debug("get mute::%d\n", dev_id);
switch (dev_id) {
case PMIC_SND_AMIC_MUTE:
pr_debug("PMIC_SND_INPUT_MUTE_MIC1\n");
sc_access.reg_addr = LILSEL;
mask = MASK6;
break;
case PMIC_SND_HP_MIC_MUTE:
pr_debug("PMIC_SND_INPUT_MUTE_MIC2\n");
sc_access.reg_addr = LIRSEL;
mask = MASK6;
break;
case PMIC_SND_LEFT_HP_MUTE:
case PMIC_SND_RIGHT_HP_MUTE:
mask = MASK2;
pr_debug("PMIC_SN_LEFT/RIGHT_HP_MUTE\n");
if (dev_id == PMIC_SND_RIGHT_HP_MUTE)
sc_access.reg_addr = RMUTE;
else
sc_access.reg_addr = LMUTE;
break;
case PMIC_SND_LEFT_SPEAKER_MUTE:
pr_debug("PMIC_MONO_EARPIECE_MUTE\n");
sc_access.reg_addr = RMUTE;
mask = MASK1;
break;
case PMIC_SND_DMIC_MUTE:
pr_debug("PMIC_SND_INPUT_MUTE_DMIC\n");
sc_access.reg_addr = 0x105;
mask = MASK6;
break;
default:
return -EINVAL;
}
retval = sst_sc_reg_access(&sc_access, PMIC_READ, 1);
pr_debug("reg value = %d\n", sc_access.value);
if (retval)
return retval;
*value = (sc_access.value) & mask;
pr_debug("masked value = %d\n", *value);
if (*value)
*value = 0;
else
*value = 1;
pr_debug("value returned = 0x%x\n", *value);
return retval;
}
static int nc_enable_audiodac(int value)
{
struct sc_reg_access sc_access[3];
int mute_val = 0;
if (snd_pmic_ops_nc.mute_status == MUTE)
return 0;
if (((snd_pmic_ops_nc.output_dev_id == MONO_EARPIECE) ||
(snd_pmic_ops_nc.output_dev_id == INTERNAL_SPKR)) &&
(value == UNMUTE))
return 0;
if (value == UNMUTE) {
/* unmute the system, set the 7th bit to zero */
mute_val = 0x00;
} else {
/* MUTE:Set the seventh bit */
mute_val = 0x04;
}
sc_access[0].reg_addr = LMUTE;
sc_access[1].reg_addr = RMUTE;
sc_access[0].mask = sc_access[1].mask = MASK2;
sc_access[0].value = sc_access[1].value = mute_val;
if (snd_pmic_ops_nc.num_channel == 1)
sc_access[1].value = 0x04;
return sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
}
static int mx_get_vol(int dev_id, int *value)
{
struct sc_reg_access sc_access = {0,};
int retval = 0, mask = 0, num_reg = 0;
if (snd_pmic_ops_mx.card_status == SND_CARD_UN_INIT) {
retval = mx_init_card();
if (retval)
return retval;
}
switch (dev_id) {
case PMIC_SND_CAPTURE_VOL:
sc_access.reg_addr = 0x220;
mask = MASK0|MASK1|MASK2|MASK3|MASK4;
num_reg = 1;
break;
case PMIC_SND_LEFT_PB_VOL:
sc_access.reg_addr = VOL_CTRL_LT;
mask = MASK0|MASK1|MASK2|MASK3|MASK4|MASK5;
num_reg = 1;
break;
case PMIC_SND_RIGHT_PB_VOL:
sc_access.reg_addr = VOL_CTRL_RT;
mask = MASK0|MASK1|MASK2|MASK3|MASK4|MASK5;
num_reg = 1;
break;
}
retval = sst_sc_reg_access(&sc_access, PMIC_READ, num_reg);
if (retval)
return retval;
*value = -(sc_access.value & mask);
pr_debug("get volume value extracted %d\n", *value);
return retval;
}
static int mx_power_down_pb(unsigned int device)
{
struct sc_reg_access sc_access[3];
int retval = 0;
if (snd_pmic_ops_mx.card_status == SND_CARD_UN_INIT) {
retval = mx_init_card();
if (retval)
return retval;
}
retval = mx_enable_audiodac(MUTE);
if (retval)
return retval;
sc_access[0].reg_addr = ENABLE_OPDEV_CTRL;
sc_access[0].mask = MASK3|MASK2;
sc_access[0].value = 0x00;
retval = sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 1);
if (retval)
return retval;
return mx_enable_audiodac(UNMUTE);
}
static int nc_set_pcm_voice_params(void)
{
struct sc_reg_access sc_access[] = {
{0x100, 0xD5, 0},
{0x101, 0x08, 0},
{0x104, 0x03, 0},
{0x107, 0x10, 0},
{0x10B, 0x0E, 0},
{0x10E, 0x03, 0},
{0x10F, 0x03, 0},
{0x114, 0x13, 0},
{0x115, 0x00, 0},
{0x128, 0xFE, 0},
{0x129, 0xFE, 0},
{0x12A, 0xFE, 0},
{0x12B, 0xDE, 0},
{0x12C, 0xDE, 0},
};
int retval = 0;
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
sst_sc_reg_access(sc_access, PMIC_WRITE, 14);
pr_debug("Voice parameters set successfully!!\n");
return 0;
}
static int msic_enable_jack_btn(void)
{
struct sc_reg_access btn_enable[] = {
{0x26b, 0x77, 0x00},
{0x26C, 0x01, 0x00},
};
return sst_sc_reg_access(btn_enable, PMIC_WRITE, 2);
}
static int mx_set_pcm_voice_params(void)
{
int retval = 0;
struct sc_reg_access sc_access[] = {
{0x200, 0x80, 0x00},
{0x201, 0xC0, 0x00},
{0x202, 0x00, 0x00},
{0x203, 0x00, 0x00},
{0x204, 0x0e, 0x00},
{0x205, 0x20, 0x00},
{0x206, 0x8f, 0x00},
{0x207, 0x21, 0x00},
{0x208, 0x18, 0x00},
{0x209, 0x32, 0x00},
{0x20a, 0x00, 0x00},
{0x20b, 0x5A, 0x00},
{0x20c, 0xBE, 0x00},/* 0x00 -> 0xBE Koski */
{0x20d, 0x00, 0x00}, /* DAI2 'off' */
{0x20e, 0x40, 0x00},
{0x20f, 0x00, 0x00},
{0x210, 0x84, 0x00},
{0x211, 0x33, 0x00}, /* Voice filter */
{0x212, 0x00, 0x00},
{0x213, 0x00, 0x00},
{0x214, 0x41, 0x00},
{0x215, 0x00, 0x00},
{0x216, 0x00, 0x00},
{0x217, 0x20, 0x00},
{0x218, 0x00, 0x00},
{0x219, 0x00, 0x00},
{0x21a, 0x40, 0x00},
{0x21b, 0x40, 0x00},
{0x21c, 0x09, 0x00},
{0x21d, 0x09, 0x00},
{0x21e, 0x00, 0x00},
{0x21f, 0x00, 0x00},
{0x220, 0x00, 0x00}, /* Microphone configurations */
{0x221, 0x00, 0x00}, /* Microphone configurations */
{0x222, 0x50, 0x00}, /* Microphone configurations */
{0x223, 0x21, 0x00}, /* Microphone configurations */
{0x224, 0x00, 0x00},
{0x225, 0x80, 0x00},
{0xf9, 0x40, 0x00},
{0xfa, 0x19, 0x00},
{0xfb, 0x19, 0x00},
{0xfc, 0x12, 0x00},
{0xfd, 0x12, 0x00},
{0xfe, 0x00, 0x00},
};
if (snd_pmic_ops_mx.card_status == SND_CARD_UN_INIT) {
retval = mx_init_card();
if (retval)
return retval;
}
pr_debug("SST DBG:mx_set_pcm_voice_params called\n");
return sst_sc_reg_access(sc_access, PMIC_WRITE, 44);
}
static int nc_power_down_pb(unsigned int device)
{
int retval = 0;
struct sc_reg_access sc_access[5];
if (snd_pmic_ops_nc.card_status == SND_CARD_UN_INIT)
retval = nc_init_card();
if (retval)
return retval;
pr_debug("powering dn pb....\n");
mutex_lock(&snd_pmic_ops_nc.lock);
nc_enable_audiodac(MUTE);
msleep(30);
sc_access[0].reg_addr = DRVPOWERCTRL;
sc_access[0].value = 0x00;
sc_access[0].mask = 0x00;
sst_sc_reg_access(sc_access, PMIC_WRITE, 1);
msleep(30);
sc_access[0].reg_addr = POWERCTRL1;
sc_access[0].value = 0x00;
sc_access[0].mask = 0x41;
sc_access[1].reg_addr = POWERCTRL2;
sc_access[1].value = 0x00;
sc_access[1].mask = 0x0C;
sst_sc_reg_access(sc_access, PMIC_READ_MODIFY, 2);
msleep(30);
snd_pmic_ops_nc.pb_on = 0;
nc_enable_audiodac(UNMUTE);
mutex_unlock(&snd_pmic_ops_nc.lock);
return 0;
}
static u8 mx_get_jack_status(void)
{
struct sc_reg_access sc_access_read = {0,};
sc_access_read.reg_addr = 0x201;
sst_sc_reg_access(&sc_access_read, PMIC_READ, 1);
pr_debug("value returned = 0x%x\n", sc_access_read.value);
return sc_access_read.value;
}
/**
* mx_init_card - initialize the sound card
*
* This initializes the audio paths to know values in case of this sound card
*/
static int mx_init_card(void)
{
struct sc_reg_access sc_access[] = {
{0x200, 0x80, 0x00},
{0x201, 0xC0, 0x00},
{0x202, 0x00, 0x00},
{0x203, 0x00, 0x00},
{0x204, 0x02, 0x00},
{0x205, 0x10, 0x00},
{0x206, 0x60, 0x00},
{0x207, 0x00, 0x00},
{0x208, 0x90, 0x00},
{0x209, 0x51, 0x00},
{0x20a, 0x00, 0x00},
{0x20b, 0x10, 0x00},
{0x20c, 0x00, 0x00},
{0x20d, 0x00, 0x00},
{0x20e, 0x21, 0x00},
{0x20f, 0x00, 0x00},
{0x210, 0x84, 0x00},
{0x211, 0xB3, 0x00},
{0x212, 0x00, 0x00},
{0x213, 0x00, 0x00},
{0x214, 0x41, 0x00},
{0x215, 0x00, 0x00},
{0x216, 0x00, 0x00},
{0x217, 0x00, 0x00},
{0x218, 0x03, 0x00},
{0x219, 0x03, 0x00},
{0x21a, 0x00, 0x00},
{0x21b, 0x00, 0x00},
{0x21c, 0x00, 0x00},
{0x21d, 0x00, 0x00},
{0x21e, 0x00, 0x00},
{0x21f, 0x00, 0x00},
{0x220, 0x20, 0x00},
{0x221, 0x20, 0x00},
{0x222, 0x51, 0x00},
{0x223, 0x20, 0x00},
{0x224, 0x04, 0x00},
{0x225, 0x80, 0x00},
{0x226, 0x0F, 0x00},
{0x227, 0x08, 0x00},
{0xf9, 0x40, 0x00},
{0xfa, 0x1f, 0x00},
{0xfb, 0x1f, 0x00},
{0xfc, 0x1f, 0x00},
{0xfd, 0x1f, 0x00},
{0xfe, 0x00, 0x00},
{0xff, 0x0c, 0x00},
};
snd_pmic_ops_mx.card_status = SND_CARD_INIT_DONE;
snd_pmic_ops_mx.num_channel = 2;
snd_pmic_ops_mx.master_mute = UNMUTE;
snd_pmic_ops_mx.mute_status = UNMUTE;
return sst_sc_reg_access(sc_access, PMIC_WRITE, 47);
}
static int fs_set_selected_input_dev(u8 value)
{
struct sc_reg_access sc_access_dmic[] = {
{MICCTRL, 0x81, 0xf7},
{MICLICTRL3, 0x00, 0xE0},
};
struct sc_reg_access sc_access_mic[] = {
{MICCTRL, 0x40, MASK2|MASK4|MASK5|MASK6|MASK7},
{MICLICTRL3, 0x00, 0xE0},
};
struct sc_reg_access sc_access_hsmic[] = {
{MICCTRL, 0x10, MASK2|MASK4|MASK5|MASK6|MASK7},
{MICLICTRL3, 0x00, 0xE0},
};
int retval = 0;
if (snd_pmic_ops_fs.card_status == SND_CARD_UN_INIT)
retval = fs_init_card();
if (retval)
return retval;
switch (value) {
case AMIC:
pr_debug("Selecting amic not supported in mono cfg\n");
return sst_sc_reg_access(sc_access_mic, PMIC_READ_MODIFY, 2);
break;
case HS_MIC:
pr_debug("Selecting hsmic\n");
return sst_sc_reg_access(sc_access_hsmic,
PMIC_READ_MODIFY, 2);
break;
case DMIC:
pr_debug("Selecting dmic\n");
return sst_sc_reg_access(sc_access_dmic, PMIC_READ_MODIFY, 2);
break;
default:
return -EINVAL;
}
}
