void KRIL_GetDeviceIdentityHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
ClientInfo_t clientInfo;
KRIL_CmdList_t *pdata = (KRIL_CmdList_t*)ril_cmd;
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->result = RILErrorResult(capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_GetElement(&clientInfo, MS_LOCAL_PHCTRL_ELEM_IMEI);
pdata->handler_state = BCM_GetIMEIInfo;
break;
}
case BCM_GetIMEIInfo:
{
ParseIMEIData(pdata, capi2_rsp);
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_GetElement(&clientInfo, MS_LOCAL_PHCTRL_ELEM_SW_VERSION);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
CAPI2_MS_Element_t *rsp = (CAPI2_MS_Element_t *) capi2_rsp->dataBuf;
KrilImeiData_t *imeisv_result = (KrilImeiData_t *)pdata->bcm_ril_rsp;
strcpy(imeisv_result->imeisv, rsp->data_u.u3Bytes);
KRIL_DEBUG(DBG_INFO, "u3Bytes:[%s] imeisv:[%s]\n", rsp->data_u.u3Bytes, imeisv_result->imeisv);
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_GetIMEIHandler(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);
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_GetElement(&clientInfo, MS_LOCAL_PHCTRL_ELEM_IMEI);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
ParseIMEIData(pdata, capi2_rsp);
break;
}
default:
{
KRIL_DEBUG(DBG_ERROR,"Error handler_state:0x%lX\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void AGPS_CP_Init(void)
{
ClientInfo_t lcsClientInfo;
CAPI2_InitClientInfo(&lcsClientInfo, GetNewTID(), GetClientID());
lcsClientInfo.simId = SIM_DUAL_FIRST;
CAPI2_LcsApi_RrlpRegisterDataHandler(&lcsClientInfo);
CAPI2_LcsApi_RrcRegisterDataHandler(&lcsClientInfo);
KRIL_DEBUG(DBG_ERROR, "CAPI2_LCS_RegisterRrlpDataHandler ClientID:0x%x\n", lcsClientInfo.clientId);
}
void KRIL_SRIL_requestOemSimOut(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
KRIL_CmdList_t *pdata = (KRIL_CmdList_t*)ril_cmd;
KRIL_DEBUG(DBG_ERROR,"KRIL_SRIL_requestOemSimOut \n");
switch (pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
ClientInfo_t clientInfo;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
clientInfo.simId = pdata->ril_cmd->SimId;
if(clientInfo.simId == SIM_ALL)
{
KRIL_DEBUG(DBG_ERROR,"KRIL_SRIL_requestOemSimOut SIM_ALL \n");
CAPI2_SimApi_PowerOnOffCard (InitClientInfo(SIM_DUAL_FIRST), FALSE, SIM_POWER_ON_INVALID_MODE);
CAPI2_SimApi_PowerOnOffCard (InitClientInfo(SIM_DUAL_SECOND), FALSE, SIM_POWER_ON_INVALID_MODE);
}
else
{
KRIL_DEBUG(DBG_ERROR,"KRIL_SRIL_requestOemSimOut SIM_SINGLE \n");
CAPI2_SimApi_PowerOnOffCard (InitClientInfo(SIM_DUAL_FIRST), FALSE, SIM_POWER_ON_INVALID_MODE);
}
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;
}
return;
}
void KRIL_SetCLIRHandler(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::result:%d\n", pdata->handler_state, capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
KrilCLIRValue_t *tdata = (KrilCLIRValue_t *)pdata->ril_cmd->data;
KRIL_DEBUG(DBG_INFO, "value:%d\n", tdata->value);
if(tdata->value == 1)
{
CAPI2_SS_SetCallingLineRestrictionStatus(GetNewTID(), GetClientID(), CLIRMODE_INVOKED);
}
else if(tdata->value == 2)
{
CAPI2_SS_SetCallingLineRestrictionStatus(GetNewTID(), GetClientID(), CLIRMODE_SUPPRESSED);
}
else if(tdata->value == 0)
{
CAPI2_SS_SetCallingLineRestrictionStatus(GetNewTID(), GetClientID(), CLIRMODE_DEFAULT);
}
else
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
pdata->handler_state = BCM_SS_SetElement;
}
break;
case BCM_SS_SetElement:
{
KrilCLIRValue_t *tdata = (KrilCLIRValue_t *)pdata->ril_cmd->data;
if(capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
else if(capi2_rsp->msgType == MSG_SS_CALL_REQ_FAIL)
{
SsCallReqFail_t *rsp = (SsCallReqFail_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "result:%d\n", rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
else
{
ClientInfo_t clientInfo;
MS_LocalElemNotifyInd_t *rsp = (MS_LocalElemNotifyInd_t *) capi2_rsp->dataBuf;
CAPI2_MS_Element_t data;
KRIL_DEBUG(DBG_INFO, "elementType:%d\n", rsp->elementType);
memset((UInt8*)&data, 0x00, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SS_ELEM_CLIR;
data.data_u.u8Data = tdata->value;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
CAPI2_MsDbApi_SetElement(&clientInfo, &data);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
}
break;
case BCM_RESPCAPI2Cmd:
{
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_GetCLIRHandler(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::result:%d\n", pdata->handler_state, capi2_rsp->result);
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilCLIRInfo_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilCLIRInfo_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
KRIL_SetInSsQueryHandler(TRUE);
CAPI2_SS_QueryCallingLineRestrictionStatus(GetNewTID(), GetClientID());
pdata->handler_state = BCM_SS_GetElement;
}
break;
case BCM_SS_GetElement:
{
KrilCLIRInfo_t *rdata = (KrilCLIRInfo_t *) pdata->bcm_ril_rsp;
if (capi2_rsp->result != RESULT_OK)
{
rdata->value2 = SS_SERVICE_STATUS_UKNOWN;
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
else
{
SS_ProvisionStatus_t *rsp = (SS_ProvisionStatus_t*) capi2_rsp->dataBuf;
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
ClientInfo_t clientInfo;
KRIL_DEBUG(DBG_INFO, "provision_status:%d serviceStatus:%d netCause:%d\n", rsp->provision_status, rsp->serviceStatus, rsp->netCause);
rdata->value2 = rsp->serviceStatus;
CAPI2_InitClientInfo(&clientInfo, GetNewTID(), GetClientID());
// Get the CLIR value from CAPI.
CAPI2_MsDbApi_GetElement(&clientInfo, MS_LOCAL_SS_ELEM_CLIR);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
else
{
rdata->value2 = SS_SERVICE_STATUS_UKNOWN;
KRIL_DEBUG(DBG_INFO, "netCause:%d \n", rsp->netCause);
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
}
}
break;
case BCM_RESPCAPI2Cmd:
{
CAPI2_MS_Element_t *rsp = (CAPI2_MS_Element_t *) capi2_rsp->dataBuf;
KrilCLIRInfo_t *rdata = (KrilCLIRInfo_t *) pdata->bcm_ril_rsp;
rdata->value1 = rsp->data_u.u8Data;
KRIL_DEBUG(DBG_INFO, "CLIR:%d\n", rdata->value1);
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
break;
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
KRIL_SetInSsQueryHandler(FALSE);
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;
}
}
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 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 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){
RadioDuringRefresh ++;
KRIL_DEBUG(DBG_INFO, "Refresh : RadioDuringRefresh %d\n",RadioDuringRefresh);
if(RadioDuringRefresh >= 3){
if(RadioDuringRefresh == 4){
RadioDuringRefresh = 0;
gIsStkRefreshReset = FALSE;
}
KRIL_DEBUG(DBG_INFO, "Skip power on-off - Refresh\n");
pdata->bcm_ril_rsp = NULL;
pdata->rsp_len = 0;
pdata->handler_state = BCM_FinishCAPI2Cmd;
break;
}
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_ON_INVALID_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(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_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;
}
}
}
