RPC_Result_t RPC_PACKET_RegisterDataInd(UInt8 rpcClientID,
PACKET_InterfaceType_t interfaceType,
RPC_PACKET_DataIndCallBackFunc_t
dataIndFunc,
RPC_FlowControlCallbackFunc_t
flowControlCb,
RPC_PACKET_NotificationFunc_t
rpcNtfFn)
{
if (rpcClientID) {
}
/*fixes compiler warnings */
RPC_SetProperty(RPC_PROP_VER, rpcVer);
if (dataIndFunc != NULL && interfaceType < INTERFACE_TOTAL) {
RPC_LOCK;
ipcInfoList[interfaceType].isInit = TRUE;
ipcInfoList[interfaceType].flowControlCb = flowControlCb;
ipcInfoList[interfaceType].pktIndCb = dataIndFunc;
ipcInfoList[interfaceType].rpcNotificationFunc = rpcNtfFn;
RPC_UNLOCK;
return RPC_RESULT_OK;
}
return RPC_RESULT_ERROR;
}
static void bcmpmu_rpc_work(struct work_struct *work)
{
int ret;
struct bcmpmu59xxx *bcmpmu;
struct bcmpmu_adc_result result;
int tem, poll_time;
bool config_tapper = false;
ulong delay;
static int rpc_fw_cnt;
struct bcmpmu_rpc *bcmpmu_rpc =
container_of(work, struct bcmpmu_rpc, work.work);
BUG_ON(!bcmpmu_rpc);
bcmpmu = bcmpmu_rpc->bcmpmu;
pr_rpc(VERBOSE, "%s, called\n", __func__);
ret = bcmpmu_rpc_get_val(bcmpmu, PMU_ADC_CHANN_VMBATT,
PMU_ADC_REQ_SAR_MODE, &result);
if (ret) {
pr_rpc(ERROR, "%s: PMU_ADC_CHANN_VMBATT read error\n",
__func__);
goto err;
}
bcmpmu_rpc->vbat = result.raw & ADC_RAW_MASK;
ret = bcmpmu_rpc_get_val(bcmpmu, PMU_ADC_CHANN_PATEMP,
PMU_ADC_REQ_SAR_MODE, &result);
if (ret) {
pr_rpc(ERROR, "%s: PMU_ADC_CHANN_PATEMP read error\n",
__func__);
goto err;
}
bcmpmu_rpc->temp_pa = result.raw & ADC_RAW_MASK;
tem = result.conv;
pr_rpc(FLOW, "%s, pa_temp %d\n", __func__, result.conv);
ret = bcmpmu_rpc_get_val(bcmpmu, PMU_ADC_CHANN_32KTEMP,
PMU_ADC_REQ_SAR_MODE, &result);
if (ret) {
pr_rpc(ERROR, "%s: PMU_ADC_CHANN_32KTEMP read error\n",
__func__);
goto err;
}
bcmpmu_rpc->temp_32k = result.raw & ADC_RAW_MASK;
bcmpmu_rpc->adc_mux = (bcmpmu_rpc->vbat << VMMBAT_ADC_SHIFT) |
(bcmpmu_rpc->temp_pa << TEMPPA_ADC_SHIFT) |
(bcmpmu_rpc->temp_32k << TEMP32K_ADC_SHIFT);
RPC_SetProperty(RPC_PROP_ADC_MEASUREMENT, bcmpmu_rpc->adc_mux);
pr_rpc(DATA,
"%s, ADC readings result = 0x%x\n",
__func__, bcmpmu_rpc->adc_mux);
if (tem >= bcmpmu_rpc->mod_tem && tem < bcmpmu_rpc->htem) {
poll_time = bcmpmu_rpc->poll_time;
config_tapper = true;
} else if (tem >= bcmpmu_rpc->htem) {
poll_time = bcmpmu_rpc->htem_poll_time;
config_tapper = true;
}
#ifdef CONFIG_WD_TAPPER
if (config_tapper &&
(bcmpmu_rpc->tapper_time != poll_time)) {
bcmpmu_rpc->tapper_time = poll_time;
pr_rpc(FLOW, "==%s== wd tapper timeout to %d\n", __func__,
(poll_time / 1000));
ret = wd_tapper_update_timeout_req(&bcmpmu_rpc->wd_node,
(poll_time / 1000));
BUG_ON(ret);
}
#else
if (config_tapper) {
bcmpmu_rpc->alarm_timeout = poll_time / 1000;
bcmpmu_rpc_program_alarm(bcmpmu_rpc,
bcmpmu_rpc->alarm_timeout);
}
#endif /*CONFIG_WD_TAPPER*/
err:
if (rpc_fw_cnt < bcmpmu_rpc->fw_cnt) {
delay = msecs_to_jiffies(bcmpmu_rpc->fw_delay);
rpc_fw_cnt++;
pr_rpc(VERBOSE, "%s, rpc_fw_cnt %d\n", __func__, rpc_fw_cnt);
} else
delay = msecs_to_jiffies(bcmpmu_rpc->delay);
schedule_delayed_work(&bcmpmu_rpc->work, delay);
}
int AtMaudMode(brcm_alsa_chip_t *pChip, Int32 ParamCount, Int32 *Params)
{
AUDIO_SOURCE_Enum_t mic = AUDIO_SOURCE_ANALOG_MAIN;
AUDIO_SINK_Enum_t spk = AUDIO_SINK_HANDSET;
AudioMode_t mode = AUDIO_SINK_HANDSET;
AudioApp_t app = AUDIO_APP_VOICE_CALL, currapp;
int rtn = 0; /* 0 means Ok */
static UInt8 loopback_status = 0, loopback_input = 0, loopback_output =
0, sidetone_mode = 0;
static UInt8 loopback_api_input, loopback_api_output;
Int32 pCurSel[2];
aTrace(LOG_AUDIO_DRIVER, "%s P1-P6=%ld %ld %ld %ld %ld %ld cnt=%ld\n",
__func__, Params[0], Params[1], Params[2],
Params[3], Params[4], Params[5], ParamCount);
csl_caph_ControlHWClock(TRUE);
switch (Params[0]) {
case 0: /* at*maudmode 0 */
break;
case 1: /* at*maudmode 1 mode */
break;
case 8: /* at*maudmode=8 */
Params[0] = loopback_status;
aTrace(LOG_AUDIO_DRIVER,
" %s loopback status is %d\n", __func__,
loopback_status);
DEBUG(" %s loopback status is %d\n", __func__, loopback_status);
break;
case 9: /* at*maudmode=9,x. x = 0 --> disable; x =1 enable */
loopback_status = Params[1];
if (loopback_status > 1)
loopback_status = 1;
aTrace(LOG_AUDIO_DRIVER,
" %s set loopback status %d (1:ena 0:dis)\n",
__func__, loopback_status);
break;
case 10: /* at*maudmode=10 --> get loopback path */
/* Per PCG request
if (loopback_output > 2) loopback_output = 2; */
Params[0] = loopback_input;
Params[1] = loopback_output;
aTrace(LOG_AUDIO_DRIVER,
"%s loopback path is from src %d to sink %d\n",
__func__, loopback_input, loopback_output);
break;
/* at*maudmode=11,x,y --> set loopback path. */
/* mic: 0 = default mic, 1 = main mic */
/* spk: 0 = handset, 1 = headset, 2 = loud speaker */
case 11:
loopback_input = loopback_api_input = Params[1];
loopback_output = loopback_api_output = Params[2];
sidetone_mode = Params[3];
if (((loopback_input > 6) && (loopback_input != 11)) ||
((loopback_output > 2) && (loopback_output != 9) &&
(loopback_output != 4))) {
aError(
"%s srr/sink exceeds its range.\n",
__func__);
rtn = -1;
break;
}
if (loopback_output == 2) /* use IHF */
loopback_api_output = 4;
if (loopback_input == 0) /* default mic: use main mic */
loopback_api_input = 1;
loopback_status = 1;
/* enable the HW loopback without DSP. */
AUDCTRL_SetAudioLoopback(TRUE, loopback_api_input,
loopback_api_output, sidetone_mode);
aTrace(LOG_AUDIO_DRIVER,
"%s ena lpback: src %d sink %d sidetone %d\n",
__func__, loopback_api_input,
loopback_api_output, sidetone_mode);
break;
case 12: /* at*maudmode=12 --> disable loopback path */
loopback_status = 0;
AUDCTRL_SetAudioLoopback(FALSE, loopback_api_input,
loopback_api_output, sidetone_mode);
aTrace(LOG_AUDIO_DRIVER,
"%s dis lpback: src %d sink %d sidetone %d\n",
__func__, loopback_api_input,
loopback_api_output, sidetone_mode);
break;
case 13: /* at*maudmode=13 --> Get call ID */
aError(
"%s get call ID is not supported\n", __func__);
rtn = -1;
break;
/* at*maudmode=14 --> read current mode and app */
case 14:
Params[0] = AUDCTRL_GetAudioApp();
Params[1] = AUDCTRL_GetAudioMode();
aTrace(LOG_AUDIO_DRIVER, "%s app %ld mode %ld\n",
__func__, Params[0], Params[1]);
break;
/* at*maudmode=15 --> set current mode and app */
case 15:
app = Params[1];
mode = Params[2];
AUDCTRL_GetSrcSinkByMode(mode, &mic, &spk);
pCurSel[0] =
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL -
1].iLineSelect[0];
/* save current setting */
pCurSel[1] = pChip->
streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].iLineSelect[1];
/* Update 'VC-SEL' -- */
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].
iLineSelect[0] = mic;
pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].
iLineSelect[1] = spk;
#ifdef CONFIG_BCM_MODEM
RPC_SetProperty(RPC_PROP_AUDIO_MODE,
(UInt32)(app * AUDIO_MODE_NUMBER + mode));
#endif
/* for PCG to set new app */
currapp = AUDCTRL_GetAudioApp();
if (currapp != app) {
/* Remove the current app
before setting the new app */
AUDCTRL_RemoveAudioApp(currapp);
AUDCTRL_SaveAudioApp(app);
}
if (app == AUDIO_APP_VOICE_CALL
|| app == AUDIO_APP_VOICE_CALL_WB
|| app == AUDIO_APP_VT_CALL
|| app == AUDIO_APP_VT_CALL_WB) {
AUDCTRL_SetTelephonyMicSpkr(mic, spk, false);
AUDCTRL_SetAudioMode(mode, app);
} else if (app == AUDIO_APP_MUSIC) {
if (AUDCTRL_InVoiceCall() == FALSE) {
AUDCTRL_SwitchPlaySpk_forTuning(mode);
AUDCTRL_SaveAudioMode(mode);
AUDCTRL_SaveAudioApp(app);
}
} else {
/* Handling all other apps cases */
/* For PCG to set new Mode */
AUDCTRL_SetAudioMode(mode, app);
}
aTrace(LOG_AUDIO_DRIVER, "%s mic %d spk %d mode %ld app %ld\n",
__func__, mic, spk, Params[2],
Params[1]);
break;
/* read back AUDIO_APP_NUMBER and AUDIO_APP_MM_NUMBER */
/* needs to match to enum AudioTuneCommand_t in at_audtune.c */
case 16:
Params[0] = AUDIO_APP_NUMBER;
Params[1] = AUDIO_APP_MM_NUMBER;
break;
case 99: /* at*maudmode=99 --> stop tuning */
break;
/* at*maudmode=100 --> set external audio
amplifer gain in PMU */
/* PCG and loadcal currently use Q13p2 gain format */
case 100:
{
short gain;
gain = (short)Params[3];
if (Params[1] == 3) {
aTrace(LOG_AUDIO_DRIVER, "Params[2] = %d, "
"Params[3] %d, audio mode %d\n",
(int)Params[2], (int)Params[3],
AUDCTRL_GetAudioMode());
if ((Params[2] == PARAM_PMU_SPEAKER_PGA_LEFT_CHANNEL)
|| (Params[2] == PARAM_PMU_SPEAKER_PGA_RIGHT_CHANNEL)) {
if (AUDCTRL_GetAudioMode() == AUDIO_MODE_HEADSET
|| AUDCTRL_GetAudioMode() ==
AUDIO_MODE_TTY) {
aTrace(LOG_AUDIO_DRIVER,
"%s ext headset "
"speaker gain = %d\n",
__func__, gain);
if (Params[2] ==
PARAM_PMU_SPEAKER_PGA_LEFT_CHANNEL)
extern_hs_set_gain(gain*25,
AUDIO_HS_LEFT);
else if (Params[2] ==
PARAM_PMU_SPEAKER_PGA_RIGHT_CHANNEL)
extern_hs_set_gain(gain*25,
AUDIO_HS_RIGHT);
} else if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_SPEAKERPHONE) {
aTrace(LOG_AUDIO_DRIVER, "%s ext IHF "
"speaker gain = %d\n",
__func__, gain);
extern_ihf_set_gain(gain*25);
}
}
/* Params[2] checking */
aTrace(LOG_AUDIO_DRIVER,
"Params[2] = %d, Params[3] %d,"
" audio mode %d\n",
(int)Params[2], (int)Params[3],
AUDCTRL_GetAudioMode());
if (Params[2] == PARAM_PMU_HIGH_GAIN_MODE_FLAG) {
if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_SPEAKERPHONE) {
aTrace(LOG_AUDIO_DRIVER,
"ext IHF high gain "
"mode = %d\n",
(int)Params[3]);
extern_ihf_en_hi_gain_mode(
(int)Params[3]);
} else if (AUDCTRL_GetAudioMode() ==
AUDIO_MODE_HEADSET ||
AUDCTRL_GetAudioMode() ==
AUDIO_MODE_TTY) {
aTrace(LOG_AUDIO_DRIVER,
"ext HS high gain "
"mode = %d\n",
(int)Params[3]);
extern_hs_en_hi_gain_mode(
(int)Params[3]);
}
}
} /* if (Params[1] == 3) */
} /* case 100 */
break;
default:
aWarn("%s Unsupported cmd %ld\n", __func__,
Params[0]);
rtn = -1;
break;
}
return rtn;
}
