void APlayerConnectionHandler::UpdatePlayerLives(int8 PlayerID, int32 Lives)
{
int32 ClientID = GetClientID(PlayerID);
SendData(ClientID, OutputData(SC_Lives, Lives));
}
void APlayerConnectionHandler::SendData(int8 PlayerID, OutputData Output)
{
int32 ClientID = GetClientID(PlayerID);
NetworkHandler::sendCommandToClient(ClientID, Output);
}
void APlayerConnectionHandler::UpdatePlayerMoney(int8 PlayerID, int32 Money)
{
int32 ClientID = GetClientID(PlayerID);
SendData(ClientID, OutputData(SC_AmountOfMoney, Money));
}
void KRIL_QuerySimEmergencyNumberHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t*)ril_cmd;
if (capi2_rsp != NULL)
{
KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::msgType:%d result:%d\n", pdata->handler_state, capi2_rsp->msgType, capi2_rsp->result);
if(capi2_rsp->result != RESULT_OK)
{
pdata->result = RILErrorResult(capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
pdata->bcm_ril_rsp = kmalloc(sizeof(Kril_SIMEmergency), GFP_KERNEL);
pdata->rsp_len = sizeof(Kril_SIMEmergency);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
CAPI2_PBK_SendInfoReq(GetNewTID(), GetClientID(), PB_EN);
pdata->handler_state = BCM_PBK_SendInfoReq;
break;
}
case BCM_PBK_SendInfoReq:
{
PBK_INFO_RSP_t *rsp = (PBK_INFO_RSP_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO,"total_entries:[%d] result:[%d]\n", rsp->total_entries, rsp->result);
if (0 == rsp->total_entries ||FALSE == rsp->result)
{
Kril_SIMEmergency *rdata = (Kril_SIMEmergency *)pdata->bcm_ril_rsp;
rdata->simAppType = KRIL_GetSimAppType();
KRIL_SendNotify(BRIL_UNSOL_EMERGENCY_NUMBER, pdata->bcm_ril_rsp, pdata->rsp_len);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
else
{
CAPI2_PBK_SendReadEntryReq(GetNewTID(), GetClientID(), PB_EN, 0, (rsp->total_entries-1));
pdata->handler_state = BCM_PBK_ReadENEnteryReq;
}
break;
}
case BCM_PBK_ReadENEnteryReq:
{
PBK_ENTRY_DATA_RSP_t *rsp = (PBK_ENTRY_DATA_RSP_t *) capi2_rsp->dataBuf;
Kril_SIMEmergency *rdata = (Kril_SIMEmergency *)pdata->bcm_ril_rsp;
if(rsp == NULL || rdata == NULL)
{
KRIL_DEBUG(DBG_INFO,"rsp or rdata is NULL. ERROR!!");
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
KRIL_DEBUG(DBG_INFO,"rsp->data_result:%d\n", rsp->data_result);
if (rsp->data_result == PBK_ENTRY_VALID_IS_LAST || rsp->data_result == PBK_ENTRY_VALID_NOT_LAST)
{
KRIL_DEBUG(DBG_INFO,"simecclist:[%s] number:[%s] numlen:%d\n", rdata->simecclist, rsp->pbk_rec.number, strlen(rsp->pbk_rec.number));
if (strlen(rsp->pbk_rec.number) != 0 &&
!(strcmp("112", rsp->pbk_rec.number) == 0 || strcmp("911", rsp->pbk_rec.number) == 0))
{
if (strlen(rdata->simecclist) != 0)
{
sprintf(&rdata->simecclist[0], "%s%s%s", rdata->simecclist, ",", rsp->pbk_rec.number);
}
else
{
strcpy(rdata->simecclist, rsp->pbk_rec.number);
}
}
if (rsp->data_result == PBK_ENTRY_VALID_IS_LAST)
{
rdata->simAppType = KRIL_GetSimAppType();
KRIL_SendNotify(BRIL_UNSOL_EMERGENCY_NUMBER, pdata->bcm_ril_rsp, pdata->rsp_len);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
}
else
{
rdata->simAppType = KRIL_GetSimAppType();
KRIL_SendNotify(BRIL_UNSOL_EMERGENCY_NUMBER, pdata->bcm_ril_rsp, pdata->rsp_len);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
break;
}
default:
{
KRIL_DEBUG(DBG_ERROR,"Error handler_state:0x%lX\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void KRIL_GetCurrentSimVoltageHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
ClientInfo_t clientInfo;
KRIL_CmdList_t *pdata = (KRIL_CmdList_t*)ril_cmd;
KRIL_DEBUG(DBG_INFO,"pdata->handler_state:0x%lX\n", pdata->handler_state);
if (capi2_rsp && capi2_rsp->result != RESULT_OK)
{
KRIL_DEBUG(DBG_ERROR,"CAPI2 response failed:%d\n", capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_SimApi_GetCurrentSimVoltage(&clientInfo);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
UInt8 *resp = NULL;
SimVoltage_t *voltage = (SimVoltage_t*)capi2_rsp->dataBuf;
if (!voltage)
{
KRIL_DEBUG(DBG_ERROR,"capi2_rsp->dataBuf is NULL, Error!!\n");
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
pdata->bcm_ril_rsp = kmalloc(sizeof(UInt8)*6, GFP_KERNEL);
if (!pdata->bcm_ril_rsp)
{
KRIL_DEBUG(DBG_ERROR,"Allocate bcm_ril_rsp memory failed!!\n");
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
pdata->rsp_len = sizeof(UInt8)*6 ;
resp = (UInt8*)pdata->bcm_ril_rsp;
resp[0] = (UInt8)'B';
resp[1] = (UInt8)'R';
resp[2] = (UInt8)'C';
resp[3] = (UInt8)'M';
resp[4] = (UInt8)BRIL_HOOK_GET_SIM_VOLTAGE;
resp[5] = (UInt8)*voltage;
pdata->handler_state = BCM_FinishCAPI2Cmd;
break;
}
default:
KRIL_DEBUG(DBG_ERROR,"Error handler_state:0x%lX\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
/*
this function is implemented for meeting customer's requirement:
If SIM card is locked, the PIN is required when the Airplane mode is turned off.
But the PIN is NOT required if using CAPI2_SYS_ProcessPowerUpReq to turned off Airplane mode.
Workaround: Power off and then on the sim card, the CP will do the unlock sim process.
*/
void KRIL_RadioPowerHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
ClientInfo_t clientInfo;
if (capi2_rsp != NULL)
KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result);
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
int *OnOff = (int *)(pdata->ril_cmd->data);
KRIL_DEBUG(DBG_INFO, "On-Off:%d\n", *OnOff);
if(gIsStkRefreshReset == TRUE){
if(*OnOff == 0){
KRIL_DEBUG(DBG_INFO, "Power off Sim card - Refresh\n");
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_SimApi_PowerOnOffCard (&clientInfo, FALSE, SIM_POWER_OFF_FORCE_MODE);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}else{
KRIL_DEBUG(DBG_INFO, "Power on Sim card - Refresh\n");
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_SimApi_PowerOnOffCard (&clientInfo, TRUE, SIM_POWER_ON_NORMAL_MODE);
pdata->handler_state = BCM_RESPCAPI2Cmd;
gIsStkRefreshReset = FALSE;
}
break;
}
else {
if (*OnOff == 1)
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_PhoneCtrlApi_ProcessPowerUpReq(&clientInfo);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
else{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_PhoneCtrlApi_ProcessNoRfReq(&clientInfo);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
}
}
case BCM_RESPCAPI2Cmd:
{
//Irine_22June_airplanemode
int *OnOff = (int *)(pdata->ril_cmd->data);
KRIL_DEBUG(DBG_TRACE, "handler state:%lu\n", pdata->handler_state);
pdata->bcm_ril_rsp = NULL;
pdata->rsp_len = 0;
pdata->handler_state = BCM_FinishCAPI2Cmd;
KRIL_DEBUG(DBG_INFO, "On-Off:%d\n", *OnOff);
if (1 == *OnOff)
{
KRIL_DEBUG(DBG_ERROR, "KRIL_RadioPowerHandler: Offline off\n");
KRIL_DEBUG(DBG_ERROR, "satk_setup_menu_tlv_data_string: %s\n",satk_setup_menu_tlv_data_string);
KRIL_DEBUG(DBG_ERROR, "satk_setup_menu_tlv_length: %d\n",satk_setup_menu_tlv_length);
if(satk_setup_menu_tlv_length!=0)
KRIL_SendNotify(BRCM_RIL_UNSOL_STK_PROACTIVE_COMMAND, satk_setup_menu_tlv_data_string, (satk_setup_menu_tlv_length * 2 + 1));
}
break;
}
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
if (pdata->handler_state == BCM_ErrorCAPI2Cmd || pdata->handler_state == BCM_FinishCAPI2Cmd)
{
/* allow to send the radio state change notification to Android framework when request is done. */
gIsFlightModeOnBoot = FALSE;
}
}
void KRIL_InitCmdHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
ClientInfo_t clientInfo;
CAPI2_MS_Element_t data;
if (capi2_rsp != NULL)
{
KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result);
if(capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
}
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
KrilInit_t *pInitData = (KrilInit_t *)(pdata->ril_cmd->data);
// if there is a valid IMEI, make appropriate CAPI2 call to set
// IMEI on CP, otherwise fall through to next init command
if (pInitData->is_valid_imei)
{
KRIL_DEBUG(DBG_INFO, "OTP IMEI:%s\n", pInitData->imei);
#ifdef CONFIG_BRCM_SIM_SECURE_ENABLE
// Record IMEI1 infomation
if (FALSE == ProcessImei((UInt8*)pInitData->imei, sImei_Info))
{
KRIL_DEBUG(DBG_ERROR,"Process IMEI:%s Failed!!!", pInitData->imei);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
kernel_power_off();
}
#endif //CONFIG_BRCM_SIM_SECURE_ENABLE
memset(&data, 0, sizeof(CAPI2_MS_Element_t));
memcpy(data.data_u.imeidata, pInitData->imei, IMEI_DIGITS);
data.inElemType = MS_LOCAL_PHCTRL_ELEM_IMEI;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SET_HSDPA_PHY_CATEGORY;
break;
}
#ifdef CONFIG_BRCM_SIM_SECURE_ENABLE
else
{
// For secure boot, the IMEI is important inform for verifying SIM lock data.
KRIL_DEBUG(DBG_ERROR, "IMEI is invalid. Error!!!\n");
kernel_power_off();
}
#endif //CONFIG_BRCM_SIM_SECURE_ENABLE
// if OTP IMEI passed from URIL is not valid, we skip the
// CAPI2_MS_SetElement() call and fall through to execute the
// next CAPI2 init call instead...
}
case BCM_SET_HSDPA_PHY_CATEGORY:
{
struct file *filp;
mm_segment_t fs;
int ret;
int hsdpa_phy_cat = 8;
filp = filp_open("/data/hsdpa.dat", O_RDWR|O_SYNC, 0);
if (IS_ERR(filp))
{
// Do not set hsdpa phy category value. just go next case. (Normal operaton)
pdata->handler_state = BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS;
}
else
{
// hsdpa phy category is changed to do Vodafone test
fs = get_fs();
set_fs(get_ds());
ret = filp->f_op->read(filp, (char __user *)&hsdpa_phy_cat, sizeof(hsdpa_phy_cat), &filp->f_pos);
set_fs(fs);
filp_close(filp, NULL);
KRIL_DEBUG(DBG_ERROR,"BCM_SET_HSDPA_PHY_CATEGORY\n");
CAPI2_SYSPARM_SetHSDPAPHYCategory(GetNewTID(), GetClientID(), hsdpa_phy_cat );
pdata->handler_state = BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS;
break;
}
}
case BCM_SMS_ELEM_CLIENT_HANDLE_MT_SMS:
{
memset((UInt8*)&data, 0, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SMS_ELEM_CLIENT_HANDLE_MT_SMS;
data.data_u.bData = TRUE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SMS_SetSmsReadStatusChangeMode;
break;
}
case BCM_SMS_SetSmsReadStatusChangeMode:
{
CAPI2_SMS_SetSmsReadStatusChangeMode(GetNewTID(), GetClientID(), FALSE);
pdata->handler_state = BCM_SYS_SetFilteredEventMask;
break;
}
case BCM_SYS_SetFilteredEventMask:
{
UInt16 filterList[]={MSG_RSSI_IND, MSG_CELL_INFO_IND, MSG_LCS_RRC_UE_STATE_IND,
MSG_DATE_TIMEZONE_IND, MSG_DATA_SUSPEND_IND,
MSG_DATA_RESUME_IND, MSG_CAPI2_AT_RESPONSE_IND,
MSG_UE_3G_STATUS_IND};
CAPI2_SYS_SetFilteredEventMask(GetNewTID(), GetClientID(), &filterList[0], sizeof(filterList)/sizeof(UInt16), SYS_AP_DEEP_SLEEP_MSG_FILTER);
pdata->handler_state = BCM_SYS_SetRssiThreshold;
break;
}
case BCM_SYS_SetRssiThreshold:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_PhoneCtrlApi_SetRssiThreshold(&clientInfo, g_RSSIThreshold, 20, g_RSSIThreshold, 20);
pdata->handler_state = BCM_TIMEZONE_SetTZUpdateMode;
break;
}
case BCM_TIMEZONE_SetTZUpdateMode:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_NetRegApi_SetTZUpdateMode(&clientInfo, TIMEZONE_UPDATEMODE_NO_TZ_UPDATE);
pdata->handler_state = BCM_SATK_SetTermProfile;
break;
}
case BCM_SATK_SetTermProfile:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_SatkApi_SetTermProfile(&clientInfo, terminal_profile_data,
sizeof(terminal_profile_data)/sizeof(UInt8));
pdata->handler_state = BCM_SATK_SETUP_CALL_CTR;
break;
}
case BCM_SATK_SETUP_CALL_CTR:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_SETUP_CALL_CTR;
#ifdef OEM_RIL_ENABLE
data.data_u.bData = FALSE;
pdata->handler_state = BCM_SATK_SEND_SS_CTR;
#else
data.data_u.bData = TRUE;
pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG;
#endif
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SATK_ICON_DISP_SUPPORTED;
break;
}
case BCM_SATK_ICON_DISP_SUPPORTED:
{
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_ICON_DISP_SUPPORTED;
data.data_u.bData = TRUE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
#ifdef OEM_RIL_ENABLE
pdata->handler_state = BCM_SATK_SEND_SS_CTR;
#else
pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG;
#endif
break;
}
#ifdef OEM_RIL_ENABLE
case BCM_SATK_SEND_SS_CTR:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_SEND_SS_CTR;
data.data_u.bData = FALSE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SATK_SEND_USSD_CTR;
break;
}
case BCM_SATK_SEND_USSD_CTR:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_SEND_USSD_CTR;
data.data_u.bData = FALSE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SATK_SEND_SMS_CTR;
break;
}
case BCM_SATK_SEND_SMS_CTR:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_SEND_SMS_CTR;
data.data_u.bData = FALSE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SATK_SEND_ENABLE_7BIT_CONVERSIONS;
break;
}
case BCM_SATK_SEND_ENABLE_7BIT_CONVERSIONS:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_ENABLE_7BIT_CONVERSIONS;
data.data_u.bData = FALSE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SATK_SEND_SETUP_EVENT_LIST_CTR;
break;
}
case BCM_SATK_SEND_SETUP_EVENT_LIST_CTR:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SATK_ELEM_SETUP_EVENT_LIST_CTR;
data.data_u.bData = FALSE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_CFG_SIM_LOCK_SUPPORTED;
break;
}
case BCM_CFG_SIM_LOCK_SUPPORTED:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_CFG_ELEM_SIM_LOCK_SUPPORTED ;
data.data_u.bData = TRUE;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SS_SET_ENABLE_OLD_SS_MSG;
break;
}
#endif
case BCM_SS_SET_ENABLE_OLD_SS_MSG:
{
// enabled sending of "old" supp svcs messages
// NOTE: this should go away when we move to the new SS apis
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SS_ELEM_ENABLE_OLD_SS_MSG;
data.data_u.u8Data = 1;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SS_SET_ELEM_FDN_CHECK;
break;
}
case BCM_SS_SET_ELEM_FDN_CHECK:
{
// enable FDN check for SS dialing
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SS_ELEM_FDN_CHECK;
data.data_u.u8Data = 1;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_SET_SupportedRATandBand;
break;
}
case BCM_SET_SupportedRATandBand:
{
KrilInit_t *pInitData = (KrilInit_t *)(pdata->ril_cmd->data);
KRIL_SetPreferredNetworkType(pInitData->networktype);
KRIL_SetBandMode(pInitData->band);
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
KRIL_DEBUG(DBG_INFO,"BCM_SET_SupportedRATandBand network type %d\n", pInitData->networktype);
KRIL_DEBUG(DBG_INFO,"BCM_SET_SupportedRATandBand band %d conv band %d\n", pInitData->band, ConvertBandMode(pInitData->band));
//TODO jw check this new api last two extra parameter.
CAPI2_NetRegApi_SetSupportedRATandBand(&clientInfo, ConvertNetworkType(pInitData->networktype), ConvertBandMode(pInitData->band), ConvertNetworkType(pInitData->networktype), ConvertBandMode(pInitData->band) );
//++ JSHAN Attach for next power on
vGprsAttachMode = pInitData->gprs_attach_init;
if (vGprsAttachMode == 1 || vGprsAttachMode == 2)
pdata->handler_state = BCM_SET_AttachMode;
else
pdata->handler_state = BCM_SET_RADIO_OFF;
//-- JSHAN Attach for next power on
break;
}
//++ JSHAN Attach for next power on
case BCM_SET_AttachMode:
{
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_PHCTRL_ELEM_ATTACH_MODE;
data.data_u.u8Data = vGprsAttachMode;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement ( &clientInfo,&data);
pdata->handler_state = BCM_SET_RADIO_OFF;
break;
}
//-- JSHAN Attach for next power on
case BCM_SET_RADIO_OFF:
{
// For flight mode power up battery ADC & deep sleep issue (MobC00131482), set the initial CP state to RADIO_OFF.
// If MS is powered up in normal mode, Android framework will send BRCM_RIL_REQUEST_RADIO_POWER to RIL.
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_PhoneCtrlApi_ProcessNoRfReq(&clientInfo);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
pdata->handler_state = BCM_FinishCAPI2Cmd;
break;
}
default:
{
KRIL_DEBUG(DBG_ERROR,"Error handler_state:0x%lX\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void CServerConnect::ConnectionEstablished(CServerSocket* sender)
{
if (!connecting) {
// we are already connected to another server
DestroySocket(sender);
return;
}
InitLocalIP();
if (sender->GetConnectionState() == CS_WAITFORLOGIN)
{
AddLogLine(false, GetResString(IDS_CONNECTEDTOREQ), sender->cur_server->GetListName(), sender->cur_server->GetAddress(), sender->IsServerCryptEnabledConnection() ? sender->cur_server->GetObfuscationPortTCP() : sender->cur_server->GetPort());
CServer* pServer = theApp.serverlist->GetServerByAddress(sender->cur_server->GetAddress(), sender->cur_server->GetPort());
if (pServer) {
pServer->ResetFailedCount();
theApp.emuledlg->serverwnd->serverlistctrl.RefreshServer(pServer);
}
// Send login packet
CSafeMemFile data(256);
data.WriteHash16(thePrefs.GetUserHash());
data.WriteUInt32(GetClientID());
data.WriteUInt16(thePrefs.GetPort());
UINT tagcount = 4;
data.WriteUInt32(tagcount);
CTag tagName(CT_NAME, thePrefs.GetUserNick());
tagName.WriteTagToFile(&data);
CTag tagVersion(CT_VERSION, EDONKEYVERSION);
tagVersion.WriteTagToFile(&data);
uint32 dwCryptFlags = 0;
if (thePrefs.IsClientCryptLayerSupported())
dwCryptFlags |= SRVCAP_SUPPORTCRYPT;
if (thePrefs.IsClientCryptLayerRequested())
dwCryptFlags |= SRVCAP_REQUESTCRYPT;
if (thePrefs.IsClientCryptLayerRequired())
dwCryptFlags |= SRVCAP_REQUIRECRYPT;
CTag tagFlags(CT_SERVER_FLAGS, SRVCAP_ZLIB | SRVCAP_NEWTAGS | SRVCAP_LARGEFILES | SRVCAP_UNICODE | dwCryptFlags);
tagFlags.WriteTagToFile(&data);
// eMule Version (14-Mar-2004: requested by lugdunummaster (need for LowID clients which have no chance
// to send an Hello packet to the server during the callback test))
CTag tagMuleVersion(CT_EMULE_VERSION,
//(uCompatibleClientID << 24) |
(CemuleApp::m_nVersionMjr << 17) |
(CemuleApp::m_nVersionMin << 10) |
(CemuleApp::m_nVersionUpd << 7) );
tagMuleVersion.WriteTagToFile(&data);
Packet* packet = new Packet(&data);
packet->opcode = OP_LOGINREQUEST;
if (thePrefs.GetDebugServerTCPLevel() > 0)
Debug(_T(">>> Sending OP__LoginRequest\n"));
theStats.AddUpDataOverheadServer(packet->size);
SendPacket(packet, true, sender);
}
else if (sender->GetConnectionState() == CS_CONNECTED)
{
theStats.reconnects++;
theStats.serverConnectTime = GetTickCount();
connected = true;
CString strMsg;
if (sender->IsObfusicating())
strMsg.Format(GetResString(IDS_CONNECTEDTOOBFUSCATED) + _T(" (%s:%u)"), sender->cur_server->GetListName(), sender->cur_server->GetAddress(), sender->cur_server->GetObfuscationPortTCP());
else
strMsg.Format(GetResString(IDS_CONNECTEDTO) + _T(" (%s:%u)"), sender->cur_server->GetListName(), sender->cur_server->GetAddress(), sender->cur_server->GetPort());
Log(LOG_SUCCESS | LOG_STATUSBAR, strMsg);
theApp.emuledlg->ShowConnectionState();
connectedsocket = sender;
StopConnectionTry();
theApp.sharedfiles->ClearED2KPublishInfo();
theApp.sharedfiles->SendListToServer();
theApp.emuledlg->serverwnd->serverlistctrl.RemoveAllDeadServers();
// tecxx 1609 2002 - serverlist update
if (thePrefs.GetAddServersFromServer())
{
Packet* packet = new Packet(OP_GETSERVERLIST,0);
if (thePrefs.GetDebugServerTCPLevel() > 0)
Debug(_T(">>> Sending OP__GetServerList\n"));
theStats.AddUpDataOverheadServer(packet->size);
SendPacket(packet, true);
}
CServer* pServer = theApp.serverlist->GetServerByAddress(sender->cur_server->GetAddress(), sender->cur_server->GetPort());
if (pServer)
theApp.emuledlg->serverwnd->serverlistctrl.RefreshServer(pServer);
}
theApp.emuledlg->ShowConnectionState();
}
void KRIL_SendDataHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
static KrilSendData_t gSendData;
KRIL_DEBUG(DBG_INFO, "KRIL_SendDataHandler Entered \n");
if (capi2_rsp != NULL)
KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
UInt32 tid_test;
ClientInfo_t clientInfo;
KRIL_DEBUG(DBG_INFO, "KRIL_SendDataHandler Entered::BCM_SendCAPI2Cmd \n");
if (NULL == pdata->ril_cmd->data)
{
KRIL_DEBUG(DBG_ERROR, "Send Data Fail with NULL data\n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
memcpy(&gSendData, (KrilSendData_t *)(pdata->ril_cmd->data), sizeof(KrilSendData_t));
KRIL_DEBUG(DBG_INFO, "KRIL_SendDataHandler - Send Data : CID %d \n", gSendData.cid);
// KRIL_DEBUG(DBG_ERROR, "KRIL_SendDataHandler - Send Data : NumberofBytes %d \n", gSendData.numberBytes);
tid_test = GetNewTID();
CAPI2_InitClientInfo(&clientInfo, tid_test, GetClientID());
CAPI2_PdpApi_GetPCHContextState(&clientInfo,gSendData.cid);
KRIL_DEBUG(DBG_INFO, "My new tid_test is %d\n", tid_test);
pdata->handler_state = BCM_PDP_Verify;
}
break;
case BCM_PDP_Verify:
{
UInt32 tid_test;
ClientInfo_t clientInfo;
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "KRIL_DataStateHandler - Fail to send Enter Data State \n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
if(NULL != capi2_rsp->dataBuf)
{
PCHContextState_t *rsp = (PCHContextState_t *)capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "[BCM_PDP_Verify] - rsp:: %d *rsp:: %d \n", rsp, *rsp);
if((gSendData.cid != NULL) && (*rsp== CONTEXT_UNDEFINED))
{
KRIL_DEBUG(DBG_ERROR, "[BCM_PDP_Verify]::CONTEXT_UNDEFINED\n");
// KRIL_DEBUG(DBG_ERROR, "%d CID not supported\n", gDataState.cid);
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
tid_test = GetNewTID();
CAPI2_InitClientInfo(&clientInfo, tid_test, GetClientID());
CAPI2_PdpApi_SendTBFData(&clientInfo, gSendData.cid, gSendData.numberBytes);
KRIL_DEBUG(DBG_INFO, "My new tid_test is %d\n", tid_test);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "KRIL_SendDataHandler - Fail to send data \n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
else
{
KRIL_DEBUG(DBG_ERROR, "KRIL_DataStateHandler - RESULT_OK-> result:0x%x\n\n", capi2_rsp->result);
}
pdata->result = BCM_E_SUCCESS;
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
break;
}
}
void KRIL_DataStateHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
static KrilDataState_t gDataState;
if (capi2_rsp != NULL)
KRIL_DEBUG(DBG_INFO, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
UInt16 tid_test;
ClientInfo_t clientInfo;
if (NULL == pdata->ril_cmd->data)
{
KRIL_DEBUG(DBG_ERROR, "Enter Data State Fail with NULL data\n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
tid_test = GetNewTID();
CAPI2_InitClientInfo( &clientInfo, tid_test, GetClientID());
memcpy(&gDataState, (KrilDataState_t *)(pdata->ril_cmd->data), sizeof(KrilDataState_t));
CAPI2_PdpApi_GetPCHContextState(&clientInfo, gDataState.cid);
pdata->handler_state = BCM_PDP_Verify;
}
break;
case BCM_PDP_Verify:
{
UInt16 tid_test = BCM_TID_INIT;
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "Fail to send Enter Data State \n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
if(NULL != capi2_rsp->dataBuf)
{
PCHContextState_t *rsp = (PCHContextState_t *)capi2_rsp->dataBuf;
ClientInfo_t clientInfo;
KRIL_DEBUG(DBG_INFO, "[BCM_PDP_Verify] - rsp:: %d *rsp:: %d \n", rsp, *rsp);
if((gDataState.cid != NULL) && (*rsp== CONTEXT_UNDEFINED))
{
KRIL_DEBUG(DBG_ERROR, "[BCM_PDP_Verify]::CONTEXT_UNDEFINED\n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
tid_test = GetNewTID();
CAPI2_InitClientInfo( &clientInfo, tid_test, GetClientID());
CAPI2_PdpApi_DeactivateSNDCPConnection( &clientInfo, gDataState.cid );
}
KRIL_DEBUG(DBG_INFO, "New tid_test is %d\n", tid_test);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "KRIL_DataStateHandler - Fail to send Enter Data State \n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
else
{
KRIL_DEBUG(DBG_INFO, "Enter data state Successful\r\n");
pdata->result = BCM_E_SUCCESS;
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
}
break;
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void KRIL_DeactivatePdpHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
if (NULL != capi2_rsp)
KRIL_DEBUG(DBG_INFO, "BCM_RESPCAPI2Cmd::result:0x%x\n", capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
ClientInfo_t clientInfo;
char *cid = (char *)(pdata->ril_cmd->data);
UInt8 ContextID = 0;
UInt8 i;
if (pdata->ril_cmd->datalen == 3)
{
ContextID = (UInt8)((*(cid) - 0x30) * 10 + (*(cid+1) - 0x30));
}
else
{
ContextID = (UInt8)(*cid - 0x30);
}
KRIL_DEBUG(DBG_INFO, "KRIL_DeactivatePdpHandler - length %d, Cid:%d \n", pdata->ril_cmd->datalen, ContextID);
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilPdpData_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilPdpData_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
for (i=0 ; i<BCM_NET_MAX_RIL_PDP_CNTXS ; i++)
{
if (ContextID == pdp_resp[i].cid)
{
// found the active context we're looking for...
KRIL_DEBUG(DBG_INFO, "ReleasePdpContext[%d]=%d \n", i, pdp_resp[i].cid);
break;
}
else if ((BCM_NET_MAX_RIL_PDP_CNTXS-1) == i)
{
// no match, so we assume context has already been deactivated...
KrilPdpData_t* rspData = pdata->bcm_ril_rsp;
// pass the cid back down to URIL; will be required for shutting down
// network interface
rspData->cid = ContextID;
KRIL_DEBUG(DBG_INFO, "no active context with cid %d \n", ContextID);
pdata->handler_state = BCM_FinishCAPI2Cmd;
return;
}
}
CAPI2_InitClientInfo( &clientInfo, GetNewTID(), GetClientID());
CAPI2_PchExApi_SendPDPDeactivateReq( &clientInfo, ContextID );
ReleasePdpContext(ContextID);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "PDPDeActivate Fail to SendPDPDeActivateReq \n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
if(NULL != capi2_rsp->dataBuf)
{
PDP_SendPDPDeactivateReq_Rsp_t *rsp = (PDP_SendPDPDeactivateReq_Rsp_t *)capi2_rsp->dataBuf;
KrilPdpData_t *rdata = pdata->bcm_ril_rsp;
if(rsp->response != PCH_REQ_ACCEPTED)
{
KRIL_DEBUG(DBG_ERROR, "PDPDeActivate Fail resp(1 accept) %d, cid %d\r\n", rsp->response, rsp->cid);
pdata->result = BCM_E_RADIO_NOT_AVAILABLE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
rdata->cid = rsp->cid;
KRIL_DEBUG(DBG_INFO, "PDP Deactivate Resp - cid %d \n", rsp->cid);
pdata->result = BCM_E_SUCCESS;
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
else
{
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
}
break;
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void KRIL_SetupPdpHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd;
static KrilPdpContext_t gContext;
UInt8 i;
if (NULL != capi2_rsp)
KRIL_DEBUG(DBG_INFO, "BCM_RESPCAPI2Cmd::result:0x%x\n", capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
UInt8 pindex;
char chPdpType[PDP_TYPE_LEN_MAX] = "IP";
if (NULL == pdata->ril_cmd->data)
{
KRIL_DEBUG(DBG_ERROR, "PDPActivate Fail with NULL data\n");
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
memcpy(&gContext, (KrilPdpContext_t *)(pdata->ril_cmd->data), sizeof(KrilPdpContext_t));
if (gContext.apn != NULL)
{
for (i=0; i<BCM_NET_MAX_RIL_PDP_CNTXS; i++)
{
if (strcmp(gContext.apn, pdp_resp[i].apn) == 0)
{
if (pdp_resp[i].active == 2) // connected
{
KrilPdpData_t *rdata;
KRIL_DEBUG(DBG_ERROR, "KRIL_SetupPdpHandler - Data already setup : apn %s \n", gContext.apn);
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilPdpData_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilPdpData_t);
rdata = pdata->bcm_ril_rsp;
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
if (pdp_resp[i].address != NULL)
{
memcpy(rdata->pdpAddress, pdp_resp[i].address, PDP_ADDRESS_LEN_MAX);
}
if (pdp_resp[i].apn != NULL)
{
memcpy(rdata->apn, pdp_resp[i].apn, PDP_APN_LEN_MAX);
}
rdata->cid = pdp_resp[i].cid;
pdata->result = BCM_E_SUCCESS;
pdata->handler_state = BCM_FinishCAPI2Cmd;
return;
}
else if (pdp_resp[i].active == 3)// connecting
{
KRIL_DEBUG(DBG_ERROR, "KRIL_SetupPdpHandler - Ignore due to state(Connecting) : apn %s \n", gContext.apn);
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
}
}
if (BCM_NET_MAX_RIL_PDP_CNTXS == (pindex = GetFreePdpContext()))
{
KRIL_DEBUG(DBG_ERROR, "PDPActivate Fail with over max cid[%d]\n", pindex);
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
KRIL_DEBUG(DBG_INFO, "KRIL_SetupPdpHandler - Set PDP Context : apn %s \n", gContext.apn);
{
ClientInfo_t clientInfo;
UInt8 numParms = (gContext.apn == NULL)?2:3;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
gContext.cid = pdp_resp[pindex].cid;
FillDataResponseTypeApn(gContext.cid, chPdpType, gContext.apn);
KRIL_DEBUG(DBG_INFO,"**Calling CAPI2_PdpApi_SetPDPContext numParms %d type:%s apn:%s pindex %d cid %d\n",numParms, chPdpType, (gContext.apn==NULL)?"NULL":gContext.apn, pindex,pdp_resp[pindex].cid );
KRIL_SetInSetupPDPHandler(TRUE);
CAPI2_PdpApi_SetPDPContext( &clientInfo,
pdp_resp[pindex].cid,
numParms,
chPdpType,
gContext.apn,
"",
0,
0);
}
pdp_resp[pindex].active = 3; //connecting
pdata->handler_state = BCM_PDP_SetPdpContext;
}
break;
case BCM_PDP_SetPdpContext:
{
PCHProtConfig_t t_PCHP;
char *username = gContext.username;
char *password = gContext.password;
IPConfigAuthType_t t_Authtype = REQUIRE_PAP;/*default setting*/
//UInt8 ContextID = 1;
KRIL_DEBUG(DBG_INFO, "KRIL_SetupPdpHandler - Activate PDP context \n");
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "PDPActivate Fail to SetPDPContext[%d]\n", gContext.cid);
ReleasePdpContext(gContext.cid);
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
KRIL_SetInSetupPDPHandler(FALSE);
break;
}
if (AUTH_PAP == gContext.authtype)
t_Authtype = REQUIRE_PAP;
else if (AUTH_CHAP == gContext.authtype)
t_Authtype = REQUIRE_CHAP;
memset(&t_PCHP, 0, sizeof(PCHProtConfig_t));
// **FIXME** MAG - update this to use CAPI2_PCHEx_BuildIpConfigOptions() when api
// is fixed in CIB CP (likely .30 release or so)
Capi2BuildIpConfigOptions(&t_PCHP, username, password, t_Authtype);
{
ClientInfo_t clientInfo;
CAPI2_InitClientInfo( &clientInfo, GetNewTID(), GetClientID());
CAPI2_PchExApi_SendPDPActivateReq( &clientInfo, gContext.cid, ACTIVATE_MMI_IP_RELAY, &t_PCHP );
}
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
UInt32 u_pDNS1, u_sDNS1, u_pDNS2, u_sDNS2, u_act_pDNS, u_act_sDNS;
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilPdpData_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilPdpData_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
KRIL_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
if(RESULT_OK != capi2_rsp->result)
{
KRIL_DEBUG(DBG_ERROR, "PDPActivate Fail to SendPDPActivateReq[%d] \n", gContext.cid);
ReleasePdpContext(gContext.cid);
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
KRIL_SetInSetupPDPHandler(FALSE);
break;
}
if(NULL != capi2_rsp->dataBuf)
{
PDP_SendPDPActivateReq_Rsp_t *rsp = (PDP_SendPDPActivateReq_Rsp_t *)capi2_rsp->dataBuf;
KrilPdpData_t *rdata = pdata->bcm_ril_rsp;
if((rsp->cause != RESULT_OK) || (rsp->response != PCH_REQ_ACCEPTED))
{
KRIL_DEBUG(DBG_ERROR, "PDPActivate Fail cause %d, resp(1 accept) %d, cid %d\r\n",
rsp->cause, rsp->response, rsp->activatedContext.cid);
ReleasePdpContext(gContext.cid);
rdata->cause = ParsePdpFailCause(rsp->cause);
pdata->result = BCM_E_RADIO_NOT_AVAILABLE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
KRIL_SetInSetupPDPHandler(FALSE);
break;
}
if (NULL != rsp->activatedContext.pdpAddress)
{
memcpy(rdata->pdpAddress, rsp->activatedContext.pdpAddress, PDP_ADDRESS_LEN_MAX);
KRIL_DEBUG(DBG_INFO, "PDP Activate: PDP Address %s \r\n", rdata->pdpAddress);
}
u_pDNS1 = u_sDNS1 = u_pDNS2 = u_sDNS2 = u_act_pDNS = u_act_sDNS = 0;
Capi2ReadDnsSrv(&(rsp->activatedContext.protConfig), &u_pDNS1, &u_sDNS1, &u_pDNS2, &u_sDNS2);
KRIL_DEBUG(DBG_INFO, "PDP Activate: pDns1 0x%x, sDns1 0x%x, pDns2 0x%x, sDns2 0x%x \r\n",
(unsigned int)u_pDNS1, (unsigned int)u_sDNS1, (unsigned int)u_pDNS2, (unsigned int)u_sDNS2);
if((u_act_pDNS = u_pDNS1) == 0)
{
u_act_pDNS = u_pDNS2;
}
if((u_act_sDNS = u_sDNS1) == 0)
{
u_act_sDNS = u_sDNS2;
}
rdata->priDNS = u_act_pDNS;
rdata->secDNS = u_act_sDNS;
rdata->cid = rsp->activatedContext.cid;
KRIL_DEBUG(DBG_INFO, "PDP Activate Resp - cid %d \n", rsp->activatedContext.cid);
FillDataResponseAddress(rdata->cid, rdata->pdpAddress);
for (i=0; i<BCM_NET_MAX_RIL_PDP_CNTXS; i++)
{
if (rdata->cid == pdp_resp[i].cid)
{
if (pdp_resp[i].apn != NULL)
{
memcpy(rdata->apn, pdp_resp[i].apn, PDP_APN_LEN_MAX);
}
break;
}
}
pdata->result = BCM_E_SUCCESS;
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
else
{
pdata->result = BCM_E_GENERIC_FAILURE;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
KRIL_SetInSetupPDPHandler(FALSE);
}
break;
default:
{
KRIL_SetInSetupPDPHandler(FALSE);
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
