void cpcap_audio_init(struct cpcap_audio_state *state)
{
CPCAP_AUDIO_DEBUG_LOG("%s() called\n", __func__);
logged_cpcap_write(state->cpcap, CPCAP_REG_CC, 0, 0xFFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_CDI, 0, 0xBFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDACDI, 0, 0x3FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXI, 0, 0xFDF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXMP, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXOA, 0, 0x1FF);
/* logged_cpcap_write(state->cpcap, CPCAP_REG_RXVC, 0, 0xFFF); */
logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA, 0, 0x7FF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA, 0, 0x1FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA, 0, 0x7FFF);
/* Use free running clock for amplifiers */
logged_cpcap_write(state->cpcap, CPCAP_REG_A2LA,
CPCAP_BIT_A2_FREE_RUN, CPCAP_BIT_A2_FREE_RUN);
audio_reg = regulator_get(NULL, "vaudio");
if (IS_ERR(audio_reg))
CPCAP_AUDIO_ERROR_LOG("could not get regulator for audio\n");
}
static void cpcap_audio_configure_power(int power)
{
static int previous_power = -1;
CPCAP_AUDIO_DEBUG_LOG("%s() called with power= %d\n", __func__, power);
if (power != previous_power) {
if (IS_ERR(audio_reg)) {
CPCAP_AUDIO_ERROR_LOG("audio_reg not valid for"
"regulator setup\n");
return;
}
if (power) {
regulator_enable(audio_reg);
regulator_set_mode(audio_reg, REGULATOR_MODE_NORMAL);
} else {
printk(KERN_DEBUG "turning off regulator\n");
regulator_set_mode(audio_reg, REGULATOR_MODE_STANDBY);
regulator_disable(audio_reg);
}
previous_power = power;
if (power)
mdelay(SLEEP_ACTIVATE_POWER);
}
}
void cpcap_audio_init(struct cpcap_audio_state *state)
{
CPCAP_AUDIO_DEBUG_LOG("%s() called\n", __func__);
logged_cpcap_write(state->cpcap, CPCAP_REG_CC, 0, 0xFFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_CDI, 0, 0xBFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDACDI, 0, 0x3FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXI, 0, 0xFDF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXMP, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXOA, 0, 0x1FF);
/* logged_cpcap_write(state->cpcap, CPCAP_REG_RXVC, 0, 0xFFF); */
logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA, 0, 0x7FF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA, 0, 0x1FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA, 0, 0x7FFF);
/* The problem which speaker noise generated
when phone enter the suspend mode is fixed.
*/
logged_cpcap_write(state->cpcap, CPCAP_REG_A2LA,
CPCAP_BIT_A2_FREE_RUN, CPCAP_BIT_A2_FREE_RUN);
#if !defined(CONFIG_MACH_SHOLEST)
logged_cpcap_write(state->cpcap, CPCAP_REG_GPIO4,
CPCAP_BIT_GPIO4DIR, CPCAP_BIT_GPIO4DIR);
#endif /* !CONFIG_MACH_SHOLEST */
audio_reg = regulator_get(NULL, "vaudio");
if (IS_ERR(audio_reg))
CPCAP_AUDIO_ERROR_LOG("could not get regulator for audio\n");
}
void cpcap_audio_init(struct cpcap_audio_state *state)
{
CPCAP_AUDIO_DEBUG_LOG("%s() called\n", __func__);
printk("%s() level 1\n",__func__);
logged_cpcap_write(state->cpcap, CPCAP_REG_CC, 0, 0xFFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_CDI, 0, 0xBFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDAC, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_SDACDI, 0, 0x3FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXI, 0, 0xFDF);
logged_cpcap_write(state->cpcap, CPCAP_REG_TXMP, 0, 0xFFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXOA, 0, 0x1FF);
/* logged_cpcap_write(state->cpcap, CPCAP_REG_RXVC, 0, 0xFFF); */
logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA, 0, 0x7FF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXSDOA, 0, 0x1FFF);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXEPOA, 0, 0x7FFF);
printk("%s() level 2\n",__func__);
if (cpcap_audio_hw_has_hs_driver() || cpcap_audio_hw_has_mic3_switch())
logged_cpcap_write(state->cpcap, CPCAP_REG_GPIO4,
CPCAP_BIT_GPIO4DIR, CPCAP_BIT_GPIO4DIR);
/*hack*/
printk("%s() level 3\n",__func__);
logged_cpcap_write(state->cpcap, CPCAP_REG_RXCOA,0x1e02,0x1FFF );
audio_regu = regulator_get(NULL, "vaudio");
printk("%s() level 4\n",__func__);
if (IS_ERR(audio_regu))
CPCAP_AUDIO_ERROR_LOG("could not get regulator for audio\n");
}
static unsigned short int cpcap_audio_get_ext_output_amp_switches(
int speaker,
int balance)
{
unsigned short int value = 0;
CPCAP_AUDIO_DEBUG_LOG("%s() called with speaker %d\n", __func__,
speaker);
switch (speaker) {
case CPCAP_AUDIO_OUT_HANDSET:
value |= CPCAP_BIT_A1_EAR_EXT_SW | CPCAP_BIT_PGA_EXT_R_EN;
break;
case CPCAP_AUDIO_OUT_MONO_HEADSET:
case CPCAP_AUDIO_OUT_STEREO_HEADSET:
if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
value |= CPCAP_BIT_ARIGHT_HS_EXT_SW |
CPCAP_BIT_PGA_EXT_R_EN;
if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
value |= CPCAP_BIT_ALEFT_HS_EXT_SW |
CPCAP_BIT_PGA_EXT_L_EN;
break;
case CPCAP_AUDIO_OUT_LOUDSPEAKER:
value |= CPCAP_BIT_A2_LDSP_L_EXT_SW | CPCAP_BIT_PGA_EXT_L_EN;
break;
case CPCAP_AUDIO_OUT_LINEOUT:
value |= CPCAP_BIT_A4_LINEOUT_R_EXT_SW |
CPCAP_BIT_A4_LINEOUT_L_EXT_SW |
CPCAP_BIT_PGA_EXT_L_EN | CPCAP_BIT_PGA_EXT_R_EN;
break;
case CPCAP_AUDIO_OUT_BT_MONO:
default:
value = 0;
break;
}
CPCAP_AUDIO_DEBUG_LOG("Exiting %s() with return value = %d\n", __func__,
value);
return value;
}
static bool cpcap_audio_set_bits_for_speaker(int speaker, int balance,
unsigned short int *message)
{
CPCAP_AUDIO_DEBUG_LOG("%s() called with speaker = %d\n", __func__,
speaker);
/* Get the data required to enable each possible path */
switch (speaker) {
case CPCAP_AUDIO_OUT_HANDSET:
(*message) |= CPCAP_BIT_A1_EAR_EN;
break;
case CPCAP_AUDIO_OUT_MONO_HEADSET:
case CPCAP_AUDIO_OUT_STEREO_HEADSET:
if (balance != CPCAP_AUDIO_BALANCE_R_ONLY)
(*message) |= CPCAP_BIT_HS_L_EN;
if (balance != CPCAP_AUDIO_BALANCE_L_ONLY)
(*message) |= CPCAP_BIT_HS_R_EN;
break;
case CPCAP_AUDIO_OUT_LOUDSPEAKER:
(*message) |= CPCAP_BIT_A2_LDSP_L_EN;
break;
case CPCAP_AUDIO_OUT_LINEOUT:
(*message) |= CPCAP_BIT_A4_LINEOUT_R_EN |
CPCAP_BIT_A4_LINEOUT_L_EN;
break;
case CPCAP_AUDIO_OUT_BT_MONO:
default:
(*message) |= 0;
break;
}
return false; /* There is no external loudspeaker on this product */
}
static void cpcap_audio_configure_codec(struct cpcap_audio_state *state,
struct cpcap_audio_state *previous_state) {
const unsigned int CODEC_FREQ_MASK = CPCAP_BIT_CDC_CLK0
| CPCAP_BIT_CDC_CLK1 | CPCAP_BIT_CDC_CLK2;
const unsigned int CODEC_RESET_FREQ_MASK = CODEC_FREQ_MASK
| CPCAP_BIT_CDC_CLOCK_TREE_RESET;
static unsigned int prev_codec_data = 0x0, prev_cdai_data = 0x0;
if (is_codec_changed(state, previous_state)) {
unsigned int temp_codec_rate = state->codec_rate;
struct cpcap_regacc cdai_changes = { 0 };
struct cpcap_regacc codec_changes = { 0 };
int codec_freq_config = 0;
if (state->rat_type == CPCAP_AUDIO_RAT_CDMA)
codec_freq_config = (CPCAP_BIT_CDC_CLK0
| CPCAP_BIT_CDC_CLK1) ; /* 19.2Mhz */
else
codec_freq_config = CPCAP_BIT_CDC_CLK2 ; /* 26Mhz */
/* If a codec is already in use, reset codec to initial state */
if (previous_state->codec_mode != CPCAP_AUDIO_CODEC_OFF) {
codec_changes.mask = prev_codec_data
| CPCAP_BIT_DF_RESET
| CPCAP_BIT_CDC_CLOCK_TREE_RESET;
logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
codec_changes.value, codec_changes.mask);
prev_codec_data = 0;
previous_state->codec_mode = CPCAP_AUDIO_CODEC_OFF;
}
temp_codec_rate &= 0x0000000F;
temp_codec_rate = temp_codec_rate << 9;
switch (state->codec_mode) {
case CPCAP_AUDIO_CODEC_LOOPBACK:
case CPCAP_AUDIO_CODEC_ON:
if (state->codec_primary_speaker !=
CPCAP_AUDIO_OUT_NONE &&
state->dai_config ==
CPCAP_AUDIO_DAI_CONFIG_NORMAL) {
codec_changes.value |= CPCAP_BIT_CDC_EN_RX;
}
if (needs_cpcap_mic1(state->microphone))
codec_changes.value |= CPCAP_BIT_MIC1_CDC_EN;
if (needs_cpcap_mic2(state->microphone))
codec_changes.value |= CPCAP_BIT_MIC2_CDC_EN;
/* use input HPF if either mic is enabled */
if ((codec_changes.value &
(CPCAP_BIT_MIC1_CDC_EN |
CPCAP_BIT_MIC2_CDC_EN)) != 0)
codec_changes.value |= CPCAP_BIT_AUDIHPF_0 |
CPCAP_BIT_AUDIHPF_1;
if(state->mic_mute == CPCAP_AUDIO_MIC_MUTE)
{
codec_changes.value &= ~(CPCAP_BIT_MIC1_CDC_EN | CPCAP_BIT_MIC2_CDC_EN);
CPCAP_AUDIO_DEBUG_LOG("Mic Muted\n");
}
/* falling through intentionally */
case CPCAP_AUDIO_CODEC_CLOCK_ONLY:
codec_changes.value |=
(codec_freq_config | temp_codec_rate |
CPCAP_BIT_DF_RESET);
cdai_changes.value |= CPCAP_BIT_CDC_CLK_EN;
break;
case CPCAP_AUDIO_CODEC_OFF:
cdai_changes.value |= CPCAP_BIT_SMB_CDC;
break;
default:
break;
}
/* Multimedia uses CLK_IN0, incall uses CLK_IN1 */
if (state->rat_type != CPCAP_AUDIO_RAT_NONE)
cdai_changes.value |= CPCAP_BIT_CLK_IN_SEL;
/* Bus bus config: Codec is always master*/
cdai_changes.value |= CPCAP_BIT_CDC_DIG_AUD_FS0;
/*Codec uses independent PLL in normal operation*/
if (state->dai_config == CPCAP_AUDIO_DAI_CONFIG_NORMAL)
cdai_changes.value |= CPCAP_BIT_CDC_PLL_SEL;
if (state->rat_type == CPCAP_AUDIO_RAT_CDMA &&
state->codec_primary_speaker !=
CPCAP_AUDIO_OUT_BT_MONO) {
/* CDMA BP requires I2S mode if not Bluetooth*/
cdai_changes.value |= CPCAP_BIT_CDC_DIG_AUD_FS1 |
CPCAP_BIT_CLK_INV;
} else if (state->rat_type != CPCAP_AUDIO_RAT_NONE) {
/* CDMA BT and all UMTS requires network mode */
cdai_changes.value |= CPCAP_BIT_MIC2_TIMESLOT0;
} else {
if (state->dai_config ==
CPCAP_AUDIO_DAI_CONFIG_HIFI_DUPLEX_1) {
/* duplex I2S operation on DAI1 (untested) */
cdai_changes.value |= CPCAP_BIT_DIG_AUD_IN |
CPCAP_BIT_CDC_DIG_AUD_FS1 |
CPCAP_BIT_CLK_INV;
}
if (needs_outboard_adc(state->microphone)) {
/*if we're using the outboard ADC, then it
* has slots 0 and 1 so cpcap must be on
* 2 and 3. */
cdai_changes.value |=
CPCAP_BIT_MIC1_RX_TIMESLOT1 |
CPCAP_BIT_MIC2_TIMESLOT0 |
CPCAP_BIT_MIC2_TIMESLOT1;
} else {
if (needs_cpcap_mic2(state->microphone) &&
!needs_cpcap_mic1(state->microphone)) {
/*if we're using *only* cpcap mic2,
* put it on slot0 for mono capture.
* This requires mic1 be on a slot other
* than 0 due to cpcap contention logic.
*/
cdai_changes.value |=
CPCAP_BIT_MIC1_RX_TIMESLOT0;
} else {
/*otherwise put MIC1 on slot0 and MIC2
* on slot 1 for either MIC1 mono or
* MIC1+MIC2 stereo configurations
*/
cdai_changes.value |=
CPCAP_BIT_MIC2_TIMESLOT0;
}
}
}
/* FIRST, make sure the frequency config is right... */
logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
codec_freq_config, CODEC_FREQ_MASK);
/* Next, write the CDAI if it's changed */
if (prev_cdai_data != cdai_changes.value) {
cdai_changes.mask = cdai_changes.value
| prev_cdai_data;
prev_cdai_data = cdai_changes.value;
logged_cpcap_write(state->cpcap, CPCAP_REG_CDI,
cdai_changes.value, cdai_changes.mask);
/* Clock tree change -- reset and wait */
codec_freq_config |= CPCAP_BIT_CDC_CLOCK_TREE_RESET;
logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
codec_freq_config, CODEC_RESET_FREQ_MASK);
/* Wait for clock tree reset to complete */
mdelay(CLOCK_TREE_RESET_TIME);
}
/* Clear old settings */
codec_changes.mask = codec_changes.value | prev_codec_data;
prev_codec_data = codec_changes.value;
logged_cpcap_write(state->cpcap, CPCAP_REG_CC,
codec_changes.value, codec_changes.mask);
}
}
static void
audioic_state_dump
(
struct cpcap_audio_state *state
)
{
CPCAP_AUDIO_DEBUG_LOG("***************************************\n");
CPCAP_AUDIO_DEBUG_LOG("state->mode = %d\n", state->mode);
CPCAP_AUDIO_DEBUG_LOG("state->codec_mode = %d\n", state->codec_mode);
CPCAP_AUDIO_DEBUG_LOG("state->codec_rate = %d\n", state->codec_rate);
CPCAP_AUDIO_DEBUG_LOG("state->codec_mute = %d\n", state->codec_mute);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_mode = %d\n", state->stdac_mode);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_rate = %d\n", state->stdac_rate);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_mute = %d\n", state->stdac_mute);
CPCAP_AUDIO_DEBUG_LOG("state->analog_source = %d\n",
state->analog_source);
CPCAP_AUDIO_DEBUG_LOG("state->codec_primary_speaker = %d\n",
state->codec_primary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_primary_speaker = %d\n",
state->stdac_primary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->ext_primary_speaker = %d\n",
state->ext_primary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->codec_secondary_speaker = %d\n",
state->codec_secondary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_secondary_speaker = %d\n",
state->stdac_secondary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->ext_secondary_speaker = %d\n",
state->ext_secondary_speaker);
CPCAP_AUDIO_DEBUG_LOG("state->stdac_primary_balance = %d\n",
state->stdac_primary_balance);
CPCAP_AUDIO_DEBUG_LOG("state->ext_primary_balance = %d\n",
state->ext_primary_balance);
CPCAP_AUDIO_DEBUG_LOG("state->output_gain = %d\n",
state->output_gain);
CPCAP_AUDIO_DEBUG_LOG("state->microphone = %d\n",
state->microphone);
CPCAP_AUDIO_DEBUG_LOG("state->input_gain = %d\n",
state->input_gain);
CPCAP_AUDIO_DEBUG_LOG("state->rat_type = %d\n",
state->rat_type);
CPCAP_AUDIO_DEBUG_LOG("state->mic_mute = %d\n",
state->mic_mute);
CPCAP_AUDIO_DEBUG_LOG("***************************************\n");
}
