/* Description: AT command handler, handle command AT commands at*maudvol=P1,P2,P3 Parameters: pChip -- Pointer to chip data structure ParamCount -- Count of parameter array Params --- P1,P2,...,P6 */ int AtMaudVol(brcm_alsa_chip_t *pChip, Int32 ParamCount, Int32 *Params) { int *pVolume; int mode, vol; 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 6: /*at*maudvol=6 */ mode = AUDCTRL_GetAudioMode(); /*Get volume. Range -36 ~ 0 dB in Driver and DSP: */ Params[0] = AUDCTRL_GetTelephonySpkrVolume(AUDIO_GAIN_FORMAT_mB); Params[0] = Params[0] / 100; /* dB */ Params[0] += AudParmP()[mode].voice_volume_max; /* Range 0~36 dB shown in PCG */ /* pVolume = pChip->streamCtl[ CTL_STREAM_PANEL_VOICECALL -1].ctlLine[mode].iVolume; Params[0] = pVolume[0]; */ aTrace(LOG_AUDIO_DRIVER, "%s pVolume[0] %ld\n", __func__, Params[0]); return 0; case 7: /* at*maudvol=7,x Range 0~36 dB in PCG */ mode = AUDCTRL_GetAudioMode(); /* mode = pChip->streamCtl[ CTL_STREAM_PANEL_VOICECALL-1].iLineSelect[1]; */ pVolume = pChip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1].ctlLine[mode].iVolume; pVolume[0] = Params[1]; pVolume[1] = Params[1]; vol = Params[1]; vol -= AudParmP()[mode].voice_volume_max; /* Range -36 ~ 0 dB in DSP */ AUDCTRL_SetTelephonySpkrVolume(AUDIO_SINK_UNDEFINED, (vol * 100), AUDIO_GAIN_FORMAT_mB); aTrace(LOG_AUDIO_DRIVER, "%s pVolume[0] %d mode=%d vol %d\n", __func__, pVolume[0], mode, vol); return 0; default: aWarn("%s Unsupported cmd %ld\n", __func__, Params[0]); break; } return -1; }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //AUDIO_Policy_Get_Mode // Identifies the mode to be applied. //---------------------------------------------------------------- UInt32 AUDIO_Policy_Get_Mode(UInt32 mode) { AudioMode_t new_mode, cur_mode; cur_mode = AUDCTRL_GetAudioMode(); if ( cur_mode >= AUDIO_MODE_NUMBER ) cur_mode = (AudioMode_t) (cur_mode - AUDIO_MODE_NUMBER); if(tState == BRCM_STATE_INCALL) new_mode = cur_mode; else new_mode = mode; return new_mode; }
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; }
static long voip_ioctl(struct file *hw, unsigned int cmd, unsigned long arg) { bcm_caph_hwdep_voip_t *pvoip; voipdev *pvoipchrdevpvtdata; long ret = 0; Boolean enable = FALSE; Int32 size = 0; int data; voip_codec_type_data_t val; static UserCtrl_data_t *dataptr; brcm_alsa_chip_t *pchip = NULL; struct treq_sysparm_t *eq; struct snd_card *pcard = NULL; int rc; pvoipchrdevpvtdata = (voipdev *)hw->private_data; pvoip = (bcm_caph_hwdep_voip_t *)pvoipchrdevpvtdata->pvoip; pcard = (struct snd_card *)pvoipchrdevpvtdata->card; pchip = (brcm_alsa_chip_t *)pcard->private_data; aTrace(LOG_ALSA_INTERFACE, "ALSA-CAPH hwdep_ioctl cmd=%08X\n", cmd); switch (cmd) { case VoIP_Ioctl_GetVersion: /* ret = put_user(BrcmAACEncVersion, (int __user *)arg); */ break; case VoIP_Ioctl_Start: get_user(data, (int __user *)arg); aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start type=%d (2==UL)" "voipinstcnt=%u\n", data, voipinstcnt); rc = down_interruptible(&sVoipAction); if (rc) return rc; aTrace(LOG_ALSA_INTERFACE,"VoIP_Ioctl_Start: acquired sVoipAction\n"); if (voipinstcnt == 0) { /* start VoIP only once */ BRCM_AUDIO_Param_RateChange_t param_rate_change; BRCM_AUDIO_Param_Open_t param_open; BRCM_AUDIO_Param_Prepare_t parm_prepare; BRCM_AUDIO_Param_Start_t param_start; voipinstcnt++; aTrace(LOG_ALSA_INTERFACE,"voipinstcnt=%d\n", voipinstcnt); #if 0 hw->private_data = kzalloc(sizeof(bcm_caph_hwdep_voip_t), GFP_KERNEL); CAPH_ASSERT(hw->private_data); pvoip = (bcm_caph_hwdep_voip_t *) hw->private_data; #endif pvoipchrdevpvtdata->pvoip = kzalloc(sizeof(bcm_caph_hwdep_voip_t), GFP_KERNEL); pvoip = pvoipchrdevpvtdata->pvoip; CAPH_ASSERT(pvoip); init_waitqueue_head(&pvoip->sleep); pvoip->buffer_handle = (audio_voip_driver_t *) kzalloc(sizeof(audio_voip_driver_t), GFP_KERNEL); aTrace(LOG_ALSA_INTERFACE,"pvoip->buffer_handle=0x%x",pvoip->buffer_handle); if (pvoip->buffer_handle) memset((u8 *) pvoip->buffer_handle, 0, sizeof(audio_voip_driver_t)); else { pvoip->buffer_handle = NULL; voipinstcnt--; up(&sVoipAction); aError("voip_ioctl failed with ENOMEM 1"); return -ENOMEM; } /*ul data*/ if (pchip->voip_data.codec_type_ul == VoIP_Codec_None) { if (pchip->voip_data.codec_type_dl != VoIP_Codec_None) pchip->voip_data.codec_type_ul = pchip->voip_data.codec_type_dl; else pchip->voip_data.codec_type_ul = VoIP_Codec_PCM_16K; // by default aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start: VoIPCmd forced UL codec [0x%x]\n", pchip->voip_data.codec_type_ul); } pvoip->codec_type_ul = pchip->voip_data.codec_type_ul; pvoip->frame_size_ul = svoipframelen[pvoip-> codec_type_ul - 1]; pvoip->buffer_size_ul = pvoip->frame_size_ul * VOIP_FRAMES_IN_BUFFER; pvoip->buffer_handle->voip_data_ul_buf_ptr = kzalloc(pvoip->buffer_size_ul, GFP_KERNEL); aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start: voip_data_ul_buf_ptr=0x%x," "buffer_size_ul=%d\n", pvoip->buffer_handle->voip_data_ul_buf_ptr, pvoip->buffer_size_ul); if (pvoip->buffer_handle->voip_data_ul_buf_ptr) memset(pvoip->buffer_handle-> voip_data_ul_buf_ptr, 0, pvoip->buffer_size_ul); else { if (pvoip->buffer_handle-> voip_data_dl_buf_ptr) { kfree(pvoip->buffer_handle-> voip_data_dl_buf_ptr); pvoip->buffer_handle-> voip_data_dl_buf_ptr = NULL; } pvoip->buffer_handle->voip_data_ul_buf_ptr = NULL; kfree(pvoip->buffer_handle); pvoip->buffer_handle = NULL; voipinstcnt--; up(&sVoipAction); aError("voip_ioctl failed with ENOMEM 2"); return -ENOMEM; } /*dl data*/ if (pchip->voip_data.codec_type_dl == VoIP_Codec_None) { if (pchip->voip_data.codec_type_ul != VoIP_Codec_None) pchip->voip_data.codec_type_dl = pchip->voip_data.codec_type_ul; else pchip->voip_data.codec_type_dl = VoIP_Codec_PCM_16K; // by default aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start: VoIPCmd forced DL codec [0x%x]\n", pchip->voip_data.codec_type_dl); } pvoip->codec_type_dl = pchip->voip_data.codec_type_dl; pvoip->frame_size_dl = svoipframelen[pvoip-> codec_type_dl - 1]; pvoip->buffer_size_dl = pvoip->frame_size_dl * VOIP_FRAMES_IN_BUFFER; pvoip->buffer_handle->voip_data_dl_buf_ptr = kzalloc(pvoip->buffer_size_dl, GFP_KERNEL); if (pvoip->buffer_handle->voip_data_dl_buf_ptr) { memset(pvoip->buffer_handle-> voip_data_dl_buf_ptr, 0, pvoip->buffer_size_dl); } else { if (pvoip->buffer_handle-> voip_data_ul_buf_ptr) { kfree(pvoip->buffer_handle-> voip_data_ul_buf_ptr); pvoip->buffer_handle-> voip_data_ul_buf_ptr = NULL; } pvoip->buffer_handle->voip_data_dl_buf_ptr = NULL; kfree(pvoip->buffer_handle); pvoip->buffer_handle = NULL; voipinstcnt--; up(&sVoipAction); aError("voip_ioctl failed with ENOMEM 3"); return -ENOMEM; } param_open.drv_handle = NULL; param_open.drv_type = AUDIO_DRIVER_VOIP; AUDIO_Ctrl_Trigger(ACTION_AUD_OpenVoIP, ¶m_open, NULL, 1); pvoip->buffer_handle->drv_handle = param_open.drv_handle; if (!pvoip->buffer_handle->drv_handle) { kfree(pvoip->buffer_handle-> voip_data_dl_buf_ptr); pvoip->buffer_handle-> voip_data_dl_buf_ptr = NULL; kfree(pvoip->buffer_handle-> voip_data_ul_buf_ptr); pvoip->buffer_handle-> voip_data_ul_buf_ptr = NULL; kfree(pvoip->buffer_handle); pvoip->buffer_handle = NULL; voipinstcnt--; up(&sVoipAction); aError("voip_ioctl failed with ENOMEM 4"); return -ENOMEM; } /* set UL callback */ parm_prepare.drv_handle = pvoip->buffer_handle->drv_handle; parm_prepare.cbParams.voipULCallback = HWDEP_VOIP_DumpUL_CB; parm_prepare.cbParams.pPrivateData = (void *)pvoip; AUDIO_Ctrl_Trigger( ACTION_AUD_SET_VOIP_UL_CB, &parm_prepare, NULL, 0); /* set DL callback */ parm_prepare.drv_handle = pvoip->buffer_handle->drv_handle; parm_prepare.cbParams.voipDLCallback = HWDEP_VOIP_FillDL_CB; parm_prepare.cbParams.pPrivateData = (void *)pvoip; AUDIO_Ctrl_Trigger( ACTION_AUD_SET_VOIP_DL_CB, &parm_prepare, NULL, 0); /* VoIP is always 16K. No need to set the codec type here*/ if (isvolte) { if (((data == VoIP_UL) && ((pvoip->codec_type_ul == VoIP_Codec_PCM_16K) || (pvoip->codec_type_ul == VOIP_Codec_AMR_WB_7K))) || ((data == VoIP_DL) && ((pvoip->codec_type_dl == VoIP_Codec_PCM_16K) || (pvoip->codec_type_dl == VOIP_Codec_AMR_WB_7K)))) { /* VOIP_PCM_16K or VOIP_AMR_WB_MODE_7k */ param_rate_change.codecID = 0x0A; } else param_rate_change.codecID = 0x06; AUDIO_Ctrl_Trigger(ACTION_AUD_RateChange, ¶m_rate_change, NULL, 0); } param_start.drv_handle = pvoip->buffer_handle->drv_handle; param_start.data = (void *)&pchip->voip_data; AUDIO_Ctrl_Trigger(ACTION_AUD_StartVoIP, ¶m_start, NULL, 0); pvoip->writecount = VOIP_FRAMES_IN_BUFFER; pvoip->status = voip_hwdep_status_started; aTrace(LOG_ALSA_INTERFACE, "Status made to voip_hwdep_status_started"); } else { voipinstcnt++; /*Limit Voip instance to two*/ if (voipinstcnt > 2) voipinstcnt = 2; aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start -> just increment " "the count, voip already started voipinstcnt=%d\n", voipinstcnt); } if (pvoip != NULL) { if (data == VoIP_UL) pvoip->ulstarted = 1; else pvoip->dlstarted = 1; } up(&sVoipAction); aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Start END voipinstcnt=%d\n",voipinstcnt); break; case VoIP_Ioctl_Stop: get_user(data, (int __user *)arg); aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Stop type=%d (2==UL) " "voipinstcnt=%u\n", data, voipinstcnt); rc = down_interruptible(&sVoipAction); if (rc) return rc; aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Stop acquired sVoipAction"); if (data == VoIP_UL) pvoip->ulstarted = 0; else pvoip->dlstarted = 0; if (voipinstcnt >= 2) { voipinstcnt--; aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Stop--1--voipinstcnt=%d\n", voipinstcnt); } else if ((voipinstcnt < 2) || (pvoip->ulstarted == 0 && pvoip->dlstarted == 0)) { BRCM_AUDIO_Param_Stop_t param_stop; BRCM_AUDIO_Param_Close_t param_close; voipinstcnt = 0; aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_Stop--2--voipinstcnt=%d\n", voipinstcnt); if (pvoip->buffer_handle) param_stop.drv_handle = pvoip->buffer_handle->drv_handle; else param_stop.drv_handle = NULL; AUDIO_Ctrl_Trigger(ACTION_AUD_StopVoIP, ¶m_stop, NULL, 0); if (pvoip->buffer_handle) param_close.drv_handle = pvoip->buffer_handle->drv_handle; else param_close.drv_handle = NULL; AUDIO_Ctrl_Trigger(ACTION_AUD_CloseVoIP, ¶m_close, NULL, 1); if (pvoip->buffer_handle) { kfree(pvoip->buffer_handle->voip_data_dl_buf_ptr); pvoip->buffer_handle->voip_data_dl_buf_ptr = NULL; kfree(pvoip->buffer_handle->voip_data_ul_buf_ptr); pvoip->buffer_handle->voip_data_ul_buf_ptr = NULL; kfree(pvoip->buffer_handle); pvoip->buffer_handle = NULL; } pvoip->status = voip_hwdep_status_stopped; wake_up(&pvoip->sleep); } up(&sVoipAction); break; case VoIP_Ioctl_SetSource: aTrace(LOG_ALSA_INTERFACE , " Warning: VoIP_Ioctl_SetSource" "is depreciated , please" "use mixer control VC-SEL instead\n"); break; case VoIP_Ioctl_SetSink: aTrace(LOG_ALSA_INTERFACE , " Warning: VoIP_Ioctl_SetSink" "is depreciated, please" "use mixer control VC-SEL instead\n"); break; case VoIP_Ioctl_SetCodecType: aTrace(LOG_ALSA_INTERFACE, "VoIP_Ioctl_SetCodecType\n"); copy_from_user(&val, (int __user *)arg, sizeof(voip_codec_type_data_t)); if (val.ul_dl_type == VoIP_UL) { pchip->voip_data.codec_type_ul = val.codec_type; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_SetCodecType (UL) codec_type %ld\n", pchip->voip_data.codec_type_ul); /*pvoip = (bcm_caph_hwdep_voip_t *) hw->private_data;*/ if (!pvoip) break; pvoip->codec_type_ul = pchip->voip_data.codec_type_ul; } else { pchip->voip_data.codec_type_dl = val.codec_type; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_SetCodecType (DL) codec_type %ld\n", pchip->voip_data.codec_type_dl); /*pvoip = (bcm_caph_hwdep_voip_t *) hw->private_data;*/ if (!pvoip) break; pvoip->codec_type_dl = pchip->voip_data.codec_type_dl; } /*Check whether in a VoLTE call*/ /*If no, do nothing.*/ /*If yes, do the NB<->WB switching*/ if (isvolte) { BRCM_AUDIO_Param_RateChange_t param_rate_change; if (pvoip->ulstarted == 0 && pvoip->dlstarted == 0) break; if (!(pvoip->buffer_handle)) break; if (!(pvoip->buffer_handle->drv_handle)) break; AUDIO_DRIVER_Ctrl(pvoip->buffer_handle->drv_handle, AUDIO_DRIVER_SET_AMR, &pchip->voip_data); if (((val.ul_dl_type == VoIP_UL) && ((pvoip->codec_type_ul == VoIP_Codec_PCM_16K) || (pvoip->codec_type_ul == VOIP_Codec_AMR_WB_7K))) || ((val.ul_dl_type == VoIP_DL) && ((pvoip->codec_type_dl == VoIP_Codec_PCM_16K) || (pvoip->codec_type_dl == VOIP_Codec_AMR_WB_7K)))) /* VOIP_PCM_16K or VOIP_AMR_WB_MODE_7k */ param_rate_change.codecID = 0x0A; else param_rate_change.codecID = 0x06; AUDIO_Ctrl_Trigger(ACTION_AUD_RateChange, ¶m_rate_change, NULL, 0); } break; case VoIP_Ioctl_SetBitrate: get_user(data, (int __user *)arg); pchip->voip_data.bitrate_index = (u32) data; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_SetBitrate bitrate_index %ld,\n", pchip->voip_data.bitrate_index); /*pvoip = (bcm_caph_hwdep_voip_t *) hw->private_data;*/ if (!pvoip) break; if (isvolte) { if (pvoip->ulstarted == 0 && pvoip->dlstarted == 0) break; if (!(pvoip->buffer_handle)) break; if (!(pvoip->buffer_handle->drv_handle)) break; AUDIO_DRIVER_Ctrl(pvoip->buffer_handle->drv_handle, AUDIO_DRIVER_SET_AMR, &pchip->voip_data); } break; case VoIP_Ioctl_GetSource: { s32 *psel; psel = pchip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1] .iLineSelect; data = (int)psel[0]; put_user(data, (int __user *)arg); } break; case VoIP_Ioctl_GetSink: { s32 *psel; psel = pchip->streamCtl[CTL_STREAM_PANEL_VOICECALL - 1] .iLineSelect; data = (int)psel[1]; put_user(data, (int __user *)arg); } break; case VoIP_Ioctl_GetCodecType: aTrace(LOG_ALSA_INTERFACE, "voip_ioctl in VoIP_Ioctl_GetCodecType"); copy_from_user(&val, (int __user *)arg, sizeof(voip_codec_type_data_t)); if (val.ul_dl_type == VoIP_UL) val.codec_type = (int)pchip->voip_data.codec_type_ul; else val.codec_type = (int)pchip->voip_data.codec_type_dl; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_GetCodecType (UL:DL) codec_type %ld:%ld\n", pchip->voip_data.codec_type_ul, pchip->voip_data.codec_type_dl); copy_to_user((int __user *)arg, &val, sizeof(voip_codec_type_data_t)); break; case VoIP_Ioctl_GetBitrate: data = (int)pchip->voip_data.bitrate_index; put_user(data, (int __user *)arg); break; case VoIP_Ioctl_GetMode: { AudioMode_t mode = AUDCTRL_GetAudioMode(); put_user((int)mode, (int __user *)arg); aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_GetMode mode %d,\n", mode); } break; case VoIP_Ioctl_SetMode: aTrace(LOG_ALSA_INTERFACE , " Warning: VoIP_Ioctl_SetMode" "is depreciated, please " "use mixer control VC-SEL instead\n"); break; case VoIP_Ioctl_SetVoLTEDTX: get_user(data, (int __user *)arg); pchip->voip_data.isDTXEnabled = (u8) data; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_SetVoLTEDTX %d,\n", pchip->voip_data.isDTXEnabled); /*pvoip = (bcm_caph_hwdep_voip_t *) hw->private_data;*/ if (!pvoip) break; if (!(pvoip->buffer_handle)) break; if (!(pvoip->buffer_handle->drv_handle)) break; AUDIO_DRIVER_Ctrl(pvoip->buffer_handle->drv_handle, AUDIO_DRIVER_SET_DTX, &pchip->voip_data); break; case VoIP_Ioctl_SetVoLTEFlag: get_user(data, (int __user *)arg); pchip->voip_data.isVoLTE = (u8) data; aTrace(LOG_ALSA_INTERFACE, " VoIP_Ioctl_SetFlag isVoLTE %d,\n", pchip->voip_data.isVoLTE); isvolte = pchip->voip_data.isVoLTE; break; case VoIP_Ioctl_GetVoLTEFlag: data = (int)pchip->voip_data.isVoLTE; put_user(data, (int __user *)arg); break; case DSPCtrl_Ioctl_SPCtrl: if (dataptr == NULL) dataptr = kzalloc(sizeof(UserCtrl_data_t), GFP_KERNEL); else memset(dataptr, 0, sizeof(UserCtrl_data_t)); if (!dataptr) return -ENOMEM; ret = copy_from_user(dataptr, (int __user *)arg, sizeof(UserCtrl_data_t)); enable = (Boolean) dataptr->data[0]; size = dataptr->data[1]; ret = AUDDRV_User_CtrlDSP(AUDDRV_USER_SP_CTRL, enable, size, (void *)&(dataptr->data[2])); if (!enable) { kfree(dataptr); dataptr = NULL; } break; case DSPCtrl_Ioctl_SPSetVar: /* * Will move this part later after we separate the voip and * dspctrl connections. */ if (dataptr == NULL) dataptr = kzalloc(sizeof(UserCtrl_data_t), GFP_KERNEL); else memset(dataptr, 0, sizeof(UserCtrl_data_t)); if (!dataptr) return -ENOMEM; ret = copy_from_user(dataptr, (int __user *)arg, sizeof(UserCtrl_data_t)); size = dataptr->data[0]; ret = AUDDRV_User_CtrlDSP(AUDDRV_USER_SP_VAR, enable, size, (void *)&(dataptr->data[2])); break; case DSPCtrl_Ioctl_SPQuery: if (dataptr == NULL) dataptr = kzalloc(sizeof(UserCtrl_data_t), GFP_KERNEL); else memset(dataptr, 0, sizeof(UserCtrl_data_t)); if (!dataptr) return -ENOMEM; ret = AUDDRV_User_CtrlDSP(AUDDRV_USER_SP_QUERY, enable, size, (void *)dataptr); if (ret < 0) return ret; if (copy_to_user ((int __user *)arg, dataptr, sizeof(UserCtrl_data_t))) return -EFAULT; break; case DSPCtrl_Ioctl_EQCtrl: if (dataptr == NULL) dataptr = kzalloc(sizeof(UserCtrl_data_t), GFP_KERNEL); else memset(dataptr, 0, sizeof(UserCtrl_data_t)); if (!dataptr) return -ENOMEM; if (copy_from_user (dataptr, (int __user *)arg, sizeof(UserCtrl_data_t))) return -EFAULT; enable = (Boolean) dataptr->data[0]; ret = AUDDRV_User_CtrlDSP(AUDDRV_USER_EQ_CTRL, enable, size, (void *)&(dataptr->data[2])); if (!enable) { kfree(dataptr); dataptr = NULL; } break; case Ctrl_Ioctl_SWEQParm: aTrace(LOG_ALSA_INTERFACE, "ALSA-CAPH hwdep_ioctl Ctrl_Ioctl_SWEQParm"); eq = kzalloc(sizeof(*eq), GFP_KERNEL); if (eq == NULL) { aError("treq_sysparm_t mem alloc failed"); return -ENOMEM; } /* get the sysparm from driver SW EQ is only for music playback for now*/ if (copy_from_user(eq, (int __user *)arg, sizeof(struct treq_sysparm_t))) { if (eq != NULL) { kfree(eq); eq = NULL; } return -EFAULT; } ret = AUDDRV_Get_TrEqParm((void *)eq, sizeof(*eq), AUDIO_APP_MUSIC, (eq->data)[TREQ_DATA_SIZE-1]); if (!ret) { if (copy_to_user((void __user *)arg, eq, sizeof(*eq))) { if (eq != NULL) { kfree(eq); eq = NULL; } return -EFAULT; } } if (eq != NULL) { kfree(eq); eq = NULL; } break; default: ret = -ENOTTY; break; } return ret; }
void AUDIO_Ctrl_Process( BRCM_AUDIO_ACTION_en_t action_code, void *arg_param, void *callback, int block ) { TMsgAudioCtrl msgAudioCtrl; unsigned int len; AUDIO_DRIVER_TYPE_t drv_type; UInt32 app_profile = 0 ; static AudioApp_t prev_app_profile = 0; static AudioMode_t prev_mode_profile = 0; static bool mode_restore = FALSE; if(arg_param == NULL) { DEBUG("AUDIO_Ctrl_Process: arg_param is NULL \n"); return; } switch (action_code) { case ACTION_AUD_StartPlay: { BRCM_AUDIO_Param_Start_t* param_start = (BRCM_AUDIO_Param_Start_t*) arg_param; //20110905 //prev_app_profile = AUDDRV_GetAudioApp(); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_MUSIC); AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_START,NULL); AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type); if (AUDIO_Policy_GetState() == BRCM_STATE_INCALL) { DEBUG("Play Music During Voice call \n"); musicduringcall = TRUE; if ( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_HEADSET || sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM ) { DEBUG("Play Music During Voice call to HEADSET or BTM\n"); if ( app_profile == AUDIO_APP_VOICE_CALL ) { DEBUG(" Play music during Voice call with BT Tap at 8k \r\n"); AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000); } else { DEBUG(" Play music during Voice call with BT Tap at 16k \r\n"); if ( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000); } else { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 16000); } } AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].hw_id, AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, param_start->channels, param_start->rate ); } else { DEBUG("Play Music During Voice call to HANDSET or LOUDSPEAKER\n"); if ( app_profile == AUDIO_APP_VOICE_CALL ) { DEBUG(" Play music during Voice call with BT Tap at 8k \r\n"); AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 8000); } else { DEBUG(" Play music during Voice call with BT Tap at 16k \r\n"); AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 16000); } AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].hw_id, AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, param_start->channels, param_start->rate ); } } else { AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfDev[param_start->substream_number].speaker,app_profile); if( sgTableIDChannelOfDev[param_start->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_start->substream_number].speaker, 8000); // Enable the playback the path AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].hw_id, AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_start->substream_number].speaker, param_start->channels, param_start->rate ); } else { // Enable the playback the path AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].hw_id, AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].speaker, param_start->channels, param_start->rate ); //if (param_start->substream_number == 5) // Ring case if(extra_speaker) { DEBUG("Play to speaker as well \n"); AUDCTRL_AddPlaySpk(sgTableIDChannelOfDev[param_start->substream_number].hw_id, // AUDIO_HW_ID_t sink, AUDCTRL_SPK_LOUDSPK // AUDCTRL_SPEAKER_t spk ); } } } // set the slopgain register to max value AUDCTRL_SetPlayVolume(sgTableIDChannelOfDev[param_start->substream_number].hw_id, sgTableIDChannelOfDev[param_start->substream_number].speaker, AUDIO_GAIN_FORMAT_VOL_LEVEL, AUDIO_VOLUME_MAX, AUDIO_VOLUME_MAX ); // start DMA now AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_RESUME,NULL); playback_prev_time = 0; playback_triggered = 1; } break; case ACTION_AUD_StopPlay: { BRCM_AUDIO_Param_Stop_t* param_stop = (BRCM_AUDIO_Param_Stop_t*) arg_param; // stop DMA first AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_PAUSE,NULL); AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type); //if (param_stop->substream_number == 5) // Ring case if(extra_speaker) { DEBUG(" REMOVING LOUDSPK \n"); AUDCTRL_RemovePlaySpk(sgTableIDChannelOfDev[param_stop->substream_number].hw_id, // AUDIO_HW_ID_t sink, AUDCTRL_SPK_LOUDSPK // AUDCTRL_SPEAKER_t spk ); } //20110905 //AUDCTRL_SaveAudioModeFlag( AUDDRV_GetAudioMode(), prev_app_profile ); //disable the playback path if (AUDIO_Policy_GetState() == BRCM_STATE_INCALL) { musicduringcall = FALSE; if ( sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_HEADSET || sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_DisablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_stop->substream_number].hw_id, AUDCTRL_SPK_BTM ); } else { AUDCTRL_DisablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_stop->substream_number].hw_id, AUDCTRL_SPK_HEADSET ); } AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE); } else { if( sgTableIDChannelOfDev[param_stop->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_DisablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_stop->substream_number].hw_id, sgTableIDChannelOfDev[param_stop->substream_number].speaker ); AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE); } else { AUDCTRL_DisablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_stop->substream_number].hw_id, sgTableIDChannelOfDev[param_stop->substream_number].speaker ); } } AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_STOP,NULL); playback_prev_time = 0; playback_triggered = 0; } break; case ACTION_AUD_PausePlay: { BRCM_AUDIO_Param_Pause_t* param_pause = (BRCM_AUDIO_Param_Pause_t*) arg_param; AUDIO_DRIVER_Ctrl(param_pause->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type); //disable the playback path AUDCTRL_DisablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_pause->substream_number].hw_id, sgTableIDChannelOfDev[param_pause->substream_number].speaker ); if( sgTableIDChannelOfDev[param_pause->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE); } AUDIO_DRIVER_Ctrl(param_pause->drv_handle,AUDIO_DRIVER_PAUSE,NULL); } break; case ACTION_AUD_ResumePlay: { BRCM_AUDIO_Param_Resume_t* param_resume = (BRCM_AUDIO_Param_Resume_t*) arg_param; AUDIO_DRIVER_Ctrl(param_resume->drv_handle,AUDIO_DRIVER_GET_DRV_TYPE,(void*)&drv_type); AUDIO_DRIVER_Ctrl(param_resume->drv_handle,AUDIO_DRIVER_RESUME,NULL); if( sgTableIDChannelOfDev[param_resume->substream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_resume->substream_number].speaker, param_resume->rate); // Enable the playback the path AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_resume->substream_number].hw_id, AUDIO_HW_TAP_VOICE, sgTableIDChannelOfDev[param_resume->substream_number].speaker, param_resume->channels, param_resume->rate ); } else { // Enable the playback the path AUDCTRL_EnablePlay(AUDIO_HW_NONE, sgTableIDChannelOfDev[param_resume->substream_number].hw_id, AUDIO_HW_NONE, sgTableIDChannelOfDev[param_resume->substream_number].speaker, param_resume->channels, param_resume->rate ); } } break; case ACTION_AUD_StartRecord: { AudioApp_t app_prof = AUDIO_APP_RECORDING; AudioMode_t new_mode = AUDIO_MODE_SPEAKERPHONE; AudioMode_t cur_mode; BRCM_AUDIO_Param_Start_t* param_start = (BRCM_AUDIO_Param_Start_t*) arg_param; DEBUG("ACTION_AUD_StartRecord : param_start->substream_number - %d \n",param_start->substream_number); prev_app_profile = AUDDRV_GetAudioApp(); cur_mode = AUDCTRL_GetAudioMode(); if ( cur_mode >= AUDIO_MODE_NUMBER ) cur_mode = (AudioMode_t) (cur_mode - AUDIO_MODE_NUMBER); if (param_start->substream_number == 6 || param_start->substream_number == 7) // record request with Google voice search profile { app_prof = AUDIO_APP_RECORDING_GVS; mode_restore = TRUE; prev_mode_profile = cur_mode; DEBUG("ACTION_AUD_StartRecord : [%d, %d]", prev_app_profile, prev_mode_profile); } if (param_start->substream_number == 9 || param_start->substream_number == 10) // record request with voip profile { app_prof = AUDIO_APP_VOIP; new_mode = cur_mode; // use current mode based on earpiece or speaker } if (param_start->substream_number == 11 || param_start->substream_number == 12) // record request with voip incomm profile { app_prof = AUDIO_APP_VOIP_INCOMM; new_mode = cur_mode; // use current mode based on earpiece or speaker } if (param_start->substream_number == 1 || param_start->substream_number == 7 || param_start->substream_number == 8 || param_start->substream_number == 10 || param_start->substream_number == 12) // record request with auxilary mic new_mode = AUDIO_MODE_HEADSET; app_profile = AUDIO_Policy_Get_Profile(app_prof); new_mode = AUDIO_Policy_Get_Mode(new_mode); AUDCTRL_SaveAudioModeFlag(new_mode,app_profile); AUDCTRL_EnableRecord(sgTableIDChannelOfCaptDev[param_start->substream_number].hw_id, AUDIO_HW_NONE, sgTableIDChannelOfCaptDev[param_start->substream_number].mic, param_start->channels, param_start->rate); AUDIO_DRIVER_Ctrl(param_start->drv_handle,AUDIO_DRIVER_START,NULL); AUDIO_Policy_SetState(BRCM_STATE_RECORD); } break; case ACTION_AUD_StopRecord: { BRCM_AUDIO_Param_Stop_t* param_stop = (BRCM_AUDIO_Param_Stop_t*) arg_param; AUDIO_DRIVER_Ctrl(param_stop->drv_handle,AUDIO_DRIVER_STOP,NULL); if (mode_restore) { mode_restore = FALSE; AUDCTRL_SaveAudioModeFlag( prev_mode_profile, prev_app_profile ); DEBUG("ACTION_AUD_StartRecord : [%d, %d]", prev_app_profile, prev_mode_profile); } else { AUDCTRL_SaveAudioModeFlag( AUDDRV_GetAudioMode(), prev_app_profile ); } AUDCTRL_DisableRecord(sgTableIDChannelOfCaptDev[param_stop->substream_number].hw_id, AUDIO_HW_NONE, sgTableIDChannelOfCaptDev[param_stop->substream_number].mic); AUDIO_Policy_RestoreState(); } break; case ACTION_AUD_OpenPlay: { BRCM_AUDIO_Param_Open_t* param_open = (BRCM_AUDIO_Param_Open_t*) arg_param; param_open->drv_handle = AUDIO_DRIVER_Open(sgTableIDChannelOfDev[param_open->substream_number].drv_type); DEBUG("param_open->drv_handle - 0x%x \n",param_open->drv_handle); } break; case ACTION_AUD_ClosePlay: { BRCM_AUDIO_Param_Close_t* param_close = (BRCM_AUDIO_Param_Close_t*) arg_param; DEBUG("param_close->drv_handle - 0x%x \n",param_close->drv_handle); AUDIO_DRIVER_Close(param_close->drv_handle); } break; case ACTION_AUD_OpenRecord: { BRCM_AUDIO_Param_Open_t* param_open = (BRCM_AUDIO_Param_Open_t*) arg_param; param_open->drv_handle = AUDIO_DRIVER_Open(sgTableIDChannelOfCaptDev[param_open->substream_number].drv_type); DEBUG("param_open->drv_handle - 0x%x \n",param_open->drv_handle); } break; case ACTION_AUD_CloseRecord: { BRCM_AUDIO_Param_Close_t* param_close = (BRCM_AUDIO_Param_Close_t*) arg_param; DEBUG("param_close->drv_handle - 0x%x \n",param_close->drv_handle); AUDIO_DRIVER_Close(param_close->drv_handle); } break; case ACTON_VOICECALL_START: { BRCM_VOICE_Param_Start_t* param_voice_start = (BRCM_VOICE_Param_Start_t*)arg_param; int vol_level; telephony_stream_number = param_voice_start->substream_number; if ( telephony_codecId == 10 ) { DEBUG("Enable telephony WB Call \r\n"); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker + AUDIO_MODE_NUMBER,app_profile); } else if ( telephony_codecId == 6 ) { DEBUG("Enable telephony NB Call \r\n"); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker,app_profile); } else { DEBUG("Enable telephony Invalid Codec : Setting as NB \r\n"); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker,app_profile); } if ( (telephony_stream_number-VOICE_CALL_SUB_DEVICE) == 4 ) { if ( telephony_codecId == 10 ) { DEBUG("Enable telephony WB Call for BT NREC \r\n"); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB); AUDCTRL_SaveAudioModeFlag(AUDCTRL_SPK_HANDSFREE, app_profile); } else if ( telephony_codecId == 6 ) { DEBUG("Enable telephony NB Call BT NREC \r\n"); app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL); AUDCTRL_SaveAudioModeFlag(AUDCTRL_SPK_HANDSFREE, app_profile); } DEBUG(" Telephony : Turning Off EC and NS \r\n"); //AUDCTRL_EC(FALSE, 0); //AUDCTRL_NS(FALSE); } else { DEBUG(" Telephony : Turning On EC and NS \r\n"); //AUDCTRL_EC(TRUE, 0); //AUDCTRL_NS(TRUE); } vol_level= GetCtrlValue(BRCM_CTL_EAR_Playback_Volume); if(vol_level > 5) vol_level = 5; AUDCTRL_SetPlayVolume(AUDIO_HW_VOICE_OUT,AUDCTRL_SPK_HANDSET,AUDIO_GAIN_FORMAT_DSP_VOICE_VOL_GAIN,vol_level,vol_level); AUDCTRL_RateChangeTelephony(); AUDCTRL_EnableTelephony(AUDIO_HW_VOICE_IN,AUDIO_HW_VOICE_OUT,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].mic,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker); telephony_started = 1; if(TRUE==GetCtrlValue(BRCM_CTL_Mic_Capture_Mute)) { DEBUG("Muting device \r\n"); AUDCTRL_SetTelephonyMicMute(AUDIO_HW_VOICE_OUT,AUDCTRL_MIC_MAIN,TRUE);; } AUDIO_Policy_SetState(BRCM_STATE_INCALL); } break; case ACTON_VOICECALL_STOP: { BRCM_VOICE_Param_Stop_t* param_voice_stop = (BRCM_VOICE_Param_Stop_t*)arg_param; telephony_stream_number = param_voice_stop->substream_number; DEBUG("DISABLE TELEPHONY substream = %d \r\n", telephony_stream_number); AUDCTRL_DisableTelephony(AUDIO_HW_VOICE_IN,AUDIO_HW_VOICE_OUT,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].mic,sgTableIDChannelOfVoiceCallDev[telephony_stream_number-VOICE_CALL_SUB_DEVICE].speaker); telephony_started = 0; AUDIO_Policy_RestoreState(); } break; case ACTON_VOICECALL_UPDATE: { int local_sub_stream_number = 0; BRCM_VOICE_Param_Update_t* param_voice_update = (BRCM_VOICE_Param_Update_t*)arg_param; DEBUG("TELEPHONY UPDATE codecId = %d \r\n", param_voice_update->voicecall_codecId); if ( telephony_codecId != param_voice_update->voicecall_codecId ) { telephony_codecId = param_voice_update->voicecall_codecId; if (telephony_started) { if ( telephony_codecId == 10 ) { app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL_WB); DEBUG("call_CodedId_hander : changing Mode to AMR-WB ===>\r\n"); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number - VOICE_CALL_SUB_DEVICE].speaker + AUDIO_MODE_NUMBER,app_profile); DEBUG("call_CodedId_hander : changing Mode to AMR-WB <===\r\n"); } else { app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_VOICE_CALL); DEBUG("call_CodedId_hander : changing Mode to AMR-NB ===>\r\n"); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfVoiceCallDev[telephony_stream_number - VOICE_CALL_SUB_DEVICE].speaker,app_profile ); DEBUG("call_CodedId_hander : changing Mode to AMR-NB <===\r\n"); } DEBUG("call_CodedId_hander : AUDCTRL_RateChangeTelephony ===>\r\n"); if ( musicduringcall == TRUE ) { local_sub_stream_number = (telephony_stream_number - VOICE_CALL_SUB_DEVICE)*2; // wired headphone if(telephony_stream_number == 17) { // set the substream number to same as headset local_sub_stream_number = 4; } AUDCTRL_DisableTap (AUDIO_HW_TAP_VOICE); if ( app_profile == AUDIO_APP_VOICE_CALL ) { AUDCTRL_RateChangeTelephony(); if( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_HEADSET || sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000); } else { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 8000); } } else { AUDCTRL_RateChangeTelephony(); if( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_HEADSET ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 16000); } else if ( sgTableIDChannelOfDev[local_sub_stream_number].speaker == AUDCTRL_SPK_BTM ) { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_BTM, 8000); } else { AUDCTRL_EnableTap (AUDIO_HW_TAP_VOICE, AUDCTRL_SPK_HEADSET, 16000); } } } else { AUDCTRL_RateChangeTelephony(); } DEBUG("call_CodedId_hander : AUDCTRL_RateChangeTelephony <===\r\n"); } } } break; case ACTON_FM_START: { BRCM_FM_Param_Start_t* param_start = (BRCM_FM_Param_Start_t*) arg_param; app_profile = AUDIO_Policy_Get_Profile(AUDIO_APP_FM); AUDCTRL_SaveAudioModeFlag( sgTableIDChannelOfDev[param_start->substream_number].speaker,app_profile); // Enable the FM playback the path AUDCTRL_EnablePlay(AUDIO_HW_I2S_IN, sgTableIDChannelOfDev[param_start->substream_number].hw_id, AUDIO_HW_NONE, sgTableIDChannelOfDev[param_start->substream_number].speaker, param_start->channels, param_start->rate ); // set the slopgain register to max value // 20110530 FM radio volume is controlled by FM radio chip. AUDCTRL_SetPlayVolume(sgTableIDChannelOfDev[param_start->substream_number].hw_id, sgTableIDChannelOfDev[param_start->substream_number].speaker, AUDIO_GAIN_FORMAT_FM_RADIO_DIGITAL_VOLUME_TABLE, AUDIO_VOLUME_MAX, AUDIO_VOLUME_MAX ); AUDIO_Policy_SetState(BRCM_STATE_FM); } break; case ACTON_FM_STOP: { BRCM_FM_Param_Stop_t* param_fm_stop = (BRCM_FM_Param_Stop_t*)arg_param; //disable the FM playback path AUDCTRL_DisablePlay(AUDIO_HW_I2S_IN, sgTableIDChannelOfDev[param_fm_stop->substream_number].hw_id, sgTableIDChannelOfDev[param_fm_stop->substream_number].speaker ); AUDIO_Policy_RestoreState(); } break; case ACTON_ROUTE: { BRCM_AUDIO_Param_Route_t* parm_route = (BRCM_AUDIO_Param_Route_t*)arg_param; DEBUG("ACTON_ROUTE \n"); if(playback_triggered == 1){ if(parm_route->command == 1) { DEBUG(" ADDING SPK - %d \n",parm_route->speaker); AUDCTRL_AddPlaySpk(AUDIO_HW_PLR_OUT, parm_route->speaker ); extra_speaker = 1; } else if (parm_route->command == 0) { DEBUG(" REMOVING SPK - %d \n",parm_route->speaker); AUDCTRL_RemovePlaySpk(AUDIO_HW_PLR_OUT, parm_route->speaker ); extra_speaker = 0; } } else { if(parm_route->command == 1) extra_speaker = 1; else if (parm_route->command == 0) extra_speaker = 0; } } break; default: DEBUG("Error AUDIO_Ctrl_Process Invalid acction command \n"); } if(block) { // put the message in output fifo if waiting msgAudioCtrl.action_code = action_code; if(arg_param) memcpy(&msgAudioCtrl.param, arg_param, sizeof(BRCM_AUDIO_Control_Params_un_t)); else memset(&msgAudioCtrl.param, 0, sizeof(BRCM_AUDIO_Control_Params_un_t)); msgAudioCtrl.pCallBack = callback; msgAudioCtrl.block = block; len = kfifo_in_locked(&sgThreadData.m_pkfifo_out, (unsigned char *)&msgAudioCtrl, sizeof(TMsgAudioCtrl), &sgThreadData.m_lock_out); if(len != sizeof(TMsgAudioCtrl)) DEBUG("Error AUDIO_Ctrl_Process len=%d expected %d \n", len, sizeof(TMsgAudioCtrl)); #if 1 // release the semaphore DEBUG("Semaphore released - %d \n",action_code); OSSEMAPHORE_Release(sgThreadData.action_complete); #endif } }