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 KRIL_GetIMSIHandler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp)
{
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_SIM_GetIMSI(GetNewTID(), GetClientID());
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
ParseIMSIData(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 KRIL_CancelUSSDHandler(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);
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:
{
KRIL_DEBUG(DBG_INFO, "gUssdID:%d\n", gUssdID);
if(gUssdID != CALLINDEX_INVALID)
{
CAPI2_SS_EndUSSDConnectReq(GetNewTID(), GetClientID(), gUssdID);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
else
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
}
break;
case BCM_RESPCAPI2Cmd:
{
if (capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
gUssdID = CALLINDEX_INVALID;
if(gPreviousUssdID != CALLINDEX_INVALID)
{
gUssdID = gPreviousUssdID;
gPreviousUssdID = CALLINDEX_INVALID;
}
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 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_ChangeBarringPasswordHandler(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);
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:
{
KrilCallBarringPasswd_t *tdata = (KrilCallBarringPasswd_t *)pdata->ril_cmd->data;
KRIL_DEBUG(DBG_INFO, "fac_id:%d OldPasswd:%s NewPasswd:%s NewPassConfirm:%s\n",
tdata->fac_id, tdata->OldPasswd, tdata->NewPasswd, tdata->NewPassConfirm);
CAPI2_SS_SendCallBarringPWDChangeReq(GetNewTID(), GetClientID(), ssBarringTypes[tdata->fac_id], (UInt8*) tdata->OldPasswd, (UInt8*) tdata->NewPasswd, (UInt8*) tdata->NewPassConfirm);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
NetworkCause_t *presult = (NetworkCause_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "NetworkCause:%d\n", *presult);
pdata->handler_state = BCM_FinishCAPI2Cmd;
if(GSMCAUSE_SUCCESS != *presult)
{
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;
}
}
}
int STK_SendMOSMSRsp(UInt8 *byte, UInt8 cmdlen)
{
SATK_ResultCode_t resultcode = SATK_Result_CmdSuccess;
SATK_ResultCode2_t resultcode2 = SATK_Result_NoCause;
// Parse device identities
if (!STK_ParseDeviceIdentities(&byte[5]))
return 0;
// Parse Result
if (!STK_ParseResult(&byte[9], &resultcode, &resultcode2))
return 0;
CAPI2_SATKCmdResp(GetNewTID(), GetClientID(), SATK_EVENT_SEND_SHORT_MSG, resultcode, resultcode2, NULL, 0);
return 1;
}
void KRIL_SetSuppSvcNotificationHandler(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);
if(capi2_rsp->result != RESULT_OK)
{
pdata->result = RILErrorResult(capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
switch(pdata->handler_state)
{
// **FIXME** MAG - MS_LOCAL_SS_ELEM_NOTIFICATION_SWITCH not currently included in CIB; need to be integrated from 2157?
#ifndef CONFIG_BRCM_FUSE_RIL_CIB
case BCM_SendCAPI2Cmd:
{
int *iEnable = (int *)(pdata->ril_cmd->data);
CAPI2_MS_Element_t data;
memset((UInt8*)&data, 0, sizeof(CAPI2_MS_Element_t));
data.inElemType = MS_LOCAL_SS_ELEM_NOTIFICATION_SWITCH;
data.data_u.u8Data = *iEnable;
KRIL_DEBUG(DBG_INFO, "iEnable:%d\n", *iEnable);
CAPI2_MS_SetElement(GetNewTID(), GetClientID(), &data);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
pdata->handler_state = BCM_FinishCAPI2Cmd;
break;
}
#endif
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
break;
}
}
}
void KRIL_BasebandVersionHandler(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);
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(krilQueryBaseBandVersion_t), GFP_KERNEL);
pdata->rsp_len = sizeof(krilQueryBaseBandVersion_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
CAPI2_SYSPARM_GetSWVersion(GetNewTID(), GetClientID());
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
UInt8 *version = (UInt8 *)capi2_rsp->dataBuf;
UInt32 rdata_len = pdata->rsp_len;
krilQueryBaseBandVersion_t *rdata = (krilQueryBaseBandVersion_t *)pdata->bcm_ril_rsp;
strncpy(rdata->version, (char *)version, MIN(rdata_len, strlen((char *)version)));
KRIL_DEBUG(DBG_INFO, "BCM_RESPCAPI2Cmd:: rdata->version:[%s] version:[%s]\n", (char *)rdata->version, (char *)version);
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_QueryTTYModeHandler(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(krilQueryTTYModeType_t), GFP_KERNEL);
pdata->rsp_len = sizeof(krilQueryTTYModeType_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
CAPI2_CC_IsTTYEnable(GetNewTID(), GetClientID());
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
if(capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
else
{
Boolean mode = *(Boolean *)capi2_rsp->dataBuf;
krilQueryTTYModeType_t *rdata = (krilQueryTTYModeType_t *)pdata->bcm_ril_rsp;
rdata->mode = (int)mode;
KRIL_DEBUG(DBG_TRACE, "BCM_RESPCAPI2Cmd:: rdata->mode:%d mode:%d\n", rdata->mode, 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;
}
}
}
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_SetTTYModeHandler(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:
{
int *mode = (int *)(pdata->ril_cmd->data);
KRIL_DEBUG(DBG_INFO, "mode:%d\n", *mode);
CAPI2_CC_SetTTYCall(GetNewTID(), GetClientID(), (Boolean) *mode);
pdata->handler_state = BCM_RESPCAPI2Cmd;
break;
}
case BCM_RESPCAPI2Cmd:
{
if(capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
else
{
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_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_SendUSSDHandler(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);
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:
{
KrilSendUSSDInfo_t *tdata = (KrilSendUSSDInfo_t *)pdata->ril_cmd->data;
if(tdata->StringSize <= 0)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
KRIL_DEBUG(DBG_INFO, "gUssdID:%d m_USSDString:%s used_size:%d\n", gUssdID, tdata->USSDString, tdata->StringSize);
if(gUssdID == CALLINDEX_INVALID) //new USSD request
{
USSDString_t *ussd = kmalloc(sizeof(USSDString_t), GFP_KERNEL);
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilReceiveUSSDInfo_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilReceiveUSSDInfo_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
memset (ussd, 0x00, sizeof(USSDString_t));
ussd->used_size = tdata->StringSize;
ussd->dcs = 0x0F;
memcpy((void*)ussd->string, (void*)tdata->USSDString, ussd->used_size);
CAPI2_SS_SendUSSDConnectReq(GetNewTID(), GetClientID(), ussd);
kfree(ussd);
}
else
{
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilReceiveUSSDInfo_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilReceiveUSSDInfo_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
CAPI2_SS_SendUSSDData(GetNewTID(), GetClientID(), gUssdID, 0x0F, tdata->StringSize, (UInt8 *) tdata->USSDString);
}
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
if (capi2_rsp->result != RESULT_OK)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
else
{
int i;
USSDataInfo_t *rsp = (USSDataInfo_t *) capi2_rsp->dataBuf;
KrilReceiveUSSDInfo_t *rdata = (KrilReceiveUSSDInfo_t *) pdata->bcm_ril_rsp;
KRIL_DEBUG(DBG_INFO, "call_index:%d service_type:%d oldindex:%d newindex:%d prob_tag:%d prob_code:%d err_code:%d code_type:0x%x used_size:%d\n", rsp->call_index,rsp->ussd_data.service_type,rsp->ussd_data.oldindex,rsp->ussd_data.newindex,rsp->ussd_data.prob_tag,
rsp->ussd_data.prob_code,rsp->ussd_data.err_code,rsp->ussd_data.code_type,rsp->ussd_data.used_size);
if (USSD_REQUEST == rsp->ussd_data.service_type ||
USSD_REGISTRATION == rsp->ussd_data.service_type)
{
rdata->type = 1;
}
else if (USSD_NOTIFICATION == rsp->ussd_data.service_type)
{
rdata->type = 0;
}
else if (USSD_RELEASE_COMPLETE_RETURN_RESULT == rsp->ussd_data.service_type)
{
rdata->type = 0;
rdata->codetype = rsp->ussd_data.code_type;
rdata->Length = rsp->ussd_data.used_size;
memset(rdata->USSDString, 0, PHASE1_MAX_USSD_STRING_SIZE+1);
if (rsp->ussd_data.used_size > 0)
{
memcpy(rdata->USSDString, rsp->ussd_data.string, rdata->Length);
}
pdata->handler_state = BCM_FinishCAPI2Cmd;
return;
}
else if (USSD_FACILITY_RETURN_RESULT == rsp->ussd_data.service_type)
{
if (rsp->ussd_data.used_size > 0)
{
rdata->type = 1;
}
if (rsp->ussd_data.used_size < 0)
{
rdata->type = 0;
memset(rdata->USSDString, 0, PHASE1_MAX_USSD_STRING_SIZE+1);
pdata->handler_state = BCM_FinishCAPI2Cmd;
return;
}
}
else if (USSD_FACILITY_REJECT == rsp->ussd_data.service_type ||
USSD_RELEASE_COMPLETE_REJECT == rsp->ussd_data.service_type)
{
gUssdID = CALLINDEX_INVALID;
rdata->type = 4;
pdata->handler_state = BCM_FinishCAPI2Cmd;
return;
}
else if (USSD_FACILITY_RETURN_ERROR == rsp->ussd_data.service_type ||
USSD_RELEASE_COMPLETE_RETURN_ERROR == rsp->ussd_data.service_type)
{
gUssdID = CALLINDEX_INVALID;
rdata->type = 5;
}
else if (USSD_RESEND == rsp->ussd_data.service_type)
{
if (gUssdID == rsp->ussd_data.oldindex)
{
KrilSendUSSDInfo_t *tdata = (KrilSendUSSDInfo_t *)pdata->ril_cmd->data;
gUssdID = rsp->ussd_data.newindex;
CAPI2_SS_SendUSSDData(GetNewTID(), GetClientID(), gUssdID, 0x0F, tdata->StringSize, (UInt8 *) tdata->USSDString);
}
else
{
gUssdID = CALLINDEX_INVALID;
gPreviousUssdID = CALLINDEX_INVALID;
pdata->handler_state = BCM_ErrorCAPI2Cmd;
}
return;
}
rdata->Length = rsp->ussd_data.used_size;
rdata->codetype = rsp->ussd_data.code_type;
for (i = 0 ; i < rdata->Length ; i++)
KRIL_DEBUG(DBG_TRACE2, "string:0x%x\n", rsp->ussd_data.string[i]);
memset(rdata->USSDString, 0, PHASE1_MAX_USSD_STRING_SIZE+1);
memcpy(rdata->USSDString, rsp->ussd_data.string, rdata->Length);
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_QueryCLIPHandler(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);
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(KrilCLIPInfo_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilCLIPInfo_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
CAPI2_SS_QueryCallingLineIDStatus(GetNewTID(), GetClientID());
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KrilCLIPInfo_t *rdata = (KrilCLIPInfo_t *)pdata->bcm_ril_rsp;
if(capi2_rsp->result != RESULT_OK)
{
KRIL_DEBUG(DBG_INFO, "LastCLIP:%d\n", KRIL_GetCLIPValue());
rdata->value = SS_SERVICE_STATUS_UKNOWN;
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
else
{
SS_ProvisionStatus_t *rsp = (SS_ProvisionStatus_t*) capi2_rsp->dataBuf;
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
KRIL_DEBUG(DBG_INFO, "provision_status:%d serviceStatus:%d netCause:%d\n", rsp->provision_status, rsp->serviceStatus, rsp->netCause);
rdata->value = rsp->serviceStatus;
}
else
{
rdata->value = SS_SERVICE_STATUS_UKNOWN;
KRIL_DEBUG(DBG_INFO, "netCause:%d LastCLIP:%d\n", rsp->netCause, KRIL_GetCLIPValue());
}
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_SetCallWaitingHandler(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);
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:
{
KrilCallWaitingInfo_t *tdata = (KrilCallWaitingInfo_t *)pdata->ril_cmd->data;
SS_Mode_t SS_Mode;
KRIL_DEBUG(DBG_INFO, "state:%d GetServiceClass(%d):%d\n", tdata->state, tdata->ss_class, GetServiceClass(tdata->ss_class));
if (1 == tdata->state)
SS_Mode = SS_MODE_ENABLE;
else
SS_Mode = SS_MODE_DISABLE;
CAPI2_SS_SendCallWaitingReq(GetNewTID(), GetClientID(), SS_Mode, GetServiceClass(tdata->ss_class));
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "msgType:0x%x\n", capi2_rsp->msgType);
if (capi2_rsp->msgType == MSG_SS_CALL_WAITING_RSP)
{
NetworkCause_t *rsp = (NetworkCause_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_ERROR, "MSG_SS_CALL_FORWARD_RSP::netCause:%d\n", *rsp);
if(*rsp != GSMCAUSE_SUCCESS)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else if (capi2_rsp->msgType == MSG_SS_CALL_WAITING_STATUS_RSP)
{
SS_ActivationStatus_t *rsp = (SS_ActivationStatus_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "netCause:%d\n", rsp->netCause);
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
int i;
KRIL_DEBUG(DBG_INFO, "class_size:%d\n", rsp->class_size);
for(i = 0 ; i < rsp->class_size ; i++)
{
KRIL_DEBUG(DBG_INFO, "activated:%d ss_class:%d\n", rsp->ss_activation_class_info[i].activated, rsp->ss_activation_class_info[i].ss_class);
}
}
else
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
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_SetCallForwardStatusHandler(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);
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:
{
KrilCallForwardStatus_t *tdata = (KrilCallForwardStatus_t *)pdata->ril_cmd->data;
SS_Mode_t mode = Kril_FwdMode[tdata->mode];
KRIL_DEBUG(DBG_INFO, "Kril_FwdMode[%d]:%d Kril_FwdReason[%d]:%d ss_class:%d timeSeconds:%d number:%s\n", tdata->mode, Kril_FwdMode[tdata->mode], tdata->reason, Kril_FwdReason[tdata->reason], GetServiceClass(tdata->ss_class), tdata->timeSeconds, tdata->number);
// if number is provided with request, we need to use SS_MODE_REGISTER even if SS_MODE_ENABLE is
// specified by Android framework (see MobC00149600)
if ( tdata->number && (strlen(tdata->number)) && (mode == SS_MODE_ENABLE) )
{
KRIL_DEBUG(DBG_INFO,"changing mode to SS_MODE_REGISTER...\n");
mode = SS_MODE_REGISTER;
}
CAPI2_SS_SendCallForwardReq(GetNewTID(), GetClientID(), mode, Kril_FwdReason[tdata->reason], GetServiceClass(tdata->ss_class), tdata->timeSeconds, (UInt8 *)tdata->number);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "msgType:0x%x\n", capi2_rsp->msgType);
if (capi2_rsp->msgType == MSG_SS_CALL_FORWARD_RSP)
{
NetworkCause_t *rsp = (NetworkCause_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "MSG_SS_CALL_FORWARD_RSP::netCause:%d\n", *rsp);
if(*rsp != GSMCAUSE_SUCCESS)
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else if (capi2_rsp->msgType == MSG_SS_CALL_FORWARD_STATUS_RSP)
{
CallForwardStatus_t *rsp = (CallForwardStatus_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "netCause:%d reason:%d\n", rsp->netCause, rsp->reason);
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
int i;
KRIL_DEBUG(DBG_INFO, "class_size:%d\n", rsp->class_size);
for(i = 0 ; i < rsp->class_size ; i++)
{
KRIL_DEBUG(DBG_INFO, "activated:%d ss_class:%d noReplyTime:%d\n", rsp->call_forward_class_info_list[i].activated, rsp->call_forward_class_info_list[i].ss_class, rsp->call_forward_class_info_list[i].noReplyTime);
KRIL_DEBUG(DBG_INFO, "ton:%d npi:%d number:%s\n", rsp->call_forward_class_info_list[i].forwarded_to_number.ton, rsp->call_forward_class_info_list[i].forwarded_to_number.npi, rsp->call_forward_class_info_list[i].forwarded_to_number.number);
}
}
else
{
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else
{
KRIL_DEBUG(DBG_ERROR, "Receive error MsgType:0x%x...!\n", capi2_rsp->msgType);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
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_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_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_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_QueryCallForwardStatusHandler(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);
if(capi2_rsp->result != RESULT_OK)
{
KRIL_SetInSsQueryHandler(FALSE);
KRIL_SetServiceClassValue(0);
pdata->result = RILErrorResult(capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
KrilCallForwardStatus_t *tdata = (KrilCallForwardStatus_t *)pdata->ril_cmd->data;
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilCallForwardinfo_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilCallForwardinfo_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
KRIL_DEBUG(DBG_INFO, "Kril_FwdReason[%d]:%d ss_class:%d\n", tdata->reason, Kril_FwdReason[tdata->reason], GetServiceClass(tdata->ss_class));
KRIL_SetInSsQueryHandler(TRUE);
KRIL_SetServiceClassValue(tdata->ss_class);
CAPI2_SS_QueryCallForwardStatus(GetNewTID(), GetClientID(), Kril_FwdReason[tdata->reason], GetServiceClass(tdata->ss_class));
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "msgType:0x%x\n", capi2_rsp->msgType);
if (capi2_rsp->msgType == MSG_SS_CALL_FORWARD_RSP)
{
NetworkCause_t *rsp = (NetworkCause_t *) capi2_rsp->dataBuf;
KRIL_DEBUG(DBG_INFO, "MSG_SS_CALL_FORWARD_RSP::netCause:%d\n", *rsp);
if(*rsp != GSMCAUSE_SUCCESS)
{
KRIL_SetInSsQueryHandler(FALSE);
KRIL_SetServiceClassValue(0);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else if (capi2_rsp->msgType == MSG_SS_CALL_FORWARD_STATUS_RSP)
{
CallForwardStatus_t *rsp = (CallForwardStatus_t *) capi2_rsp->dataBuf;
KrilCallForwardinfo_t *rdata = (KrilCallForwardinfo_t *)pdata->bcm_ril_rsp;
KRIL_DEBUG(DBG_ERROR, "netCause:%d rsp size:%d\n", rsp->netCause,pdata->rsp_len);
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
int i;
rdata->class_size = rsp->class_size;
/* restore Kril_FwdReason to Framework flavor */
rdata->reason = rsp->reason - 1;
KRIL_DEBUG(DBG_INFO, "reason:%d class_size:%d\n", rsp->reason, rsp->class_size);
for(i = 0 ; i < rsp->class_size ; i++)
{
rdata->call_forward_class_info_list[i].activated = rsp->call_forward_class_info_list[i].activated;
rdata->call_forward_class_info_list[i].ss_class = SvcClassToATClass(rsp->call_forward_class_info_list[i].ss_class);
rdata->call_forward_class_info_list[i].ton = rsp->call_forward_class_info_list[i].forwarded_to_number.ton;
rdata->call_forward_class_info_list[i].npi = rsp->call_forward_class_info_list[i].forwarded_to_number.npi;
strcpy(rdata->call_forward_class_info_list[i].number, rsp->call_forward_class_info_list[i].forwarded_to_number.number);
rdata->call_forward_class_info_list[i].noReplyTime = rsp->call_forward_class_info_list[i].noReplyTime;
/* if ss_class is '0' when service is deactivated, set the ss_class for all services to display properly */
if( (rdata->call_forward_class_info_list[i].activated == 0)
&& (rdata->call_forward_class_info_list[i].ss_class == 0) )
{
if( KRIL_GetServiceClassValue() != 0 )
rdata->call_forward_class_info_list[i].ss_class = KRIL_GetServiceClassValue();
else
rdata->call_forward_class_info_list[i].ss_class = 0xff; // all services
}
KRIL_DEBUG(DBG_INFO, "activated:%d ss_class:%d noReplyTime:%d\n", rsp->call_forward_class_info_list[i].activated, rsp->call_forward_class_info_list[i].ss_class, rsp->call_forward_class_info_list[i].noReplyTime);
KRIL_DEBUG(DBG_INFO, "ton:%d npi:%d number:%s\n", rsp->call_forward_class_info_list[i].forwarded_to_number.ton, rsp->call_forward_class_info_list[i].forwarded_to_number.npi, rsp->call_forward_class_info_list[i].forwarded_to_number.number);
}
}
else
{
KRIL_SetInSsQueryHandler(FALSE);
KRIL_SetServiceClassValue(0);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
KRIL_SetInSsQueryHandler(FALSE);
KRIL_SetServiceClassValue(0);
pdata->handler_state = BCM_FinishCAPI2Cmd;
}
break;
default:
{
KRIL_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
KRIL_SetInSsQueryHandler(FALSE);
KRIL_SetServiceClassValue(0);
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_QueryCallWaitingHandler(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);
if(capi2_rsp->result != RESULT_OK)
{
KRIL_SetInSsQueryHandler(FALSE);
pdata->result = RILErrorResult(capi2_rsp->result);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
switch(pdata->handler_state)
{
case BCM_SendCAPI2Cmd:
{
KrilCallWaitingInfo_t *tdata = (KrilCallWaitingInfo_t *)pdata->ril_cmd->data;
pdata->bcm_ril_rsp = kmalloc(sizeof(KrilCallWaitingClass_t), GFP_KERNEL);
pdata->rsp_len = sizeof(KrilCallWaitingClass_t);
memset(pdata->bcm_ril_rsp, 0, pdata->rsp_len);
KRIL_DEBUG(DBG_INFO, "GetServiceClass(%d):%d\n", tdata->ss_class, GetServiceClass(tdata->ss_class));
KRIL_SetInSsQueryHandler(TRUE);
CAPI2_SS_QueryCallWaitingStatus(GetNewTID(), GetClientID(), tdata->ss_class);
pdata->handler_state = BCM_RESPCAPI2Cmd;
}
break;
case BCM_RESPCAPI2Cmd:
{
KRIL_DEBUG(DBG_INFO, "msgType:0x%x\n", capi2_rsp->msgType);
if (capi2_rsp->msgType == MSG_SS_CALL_WAITING_RSP)
{
NetworkCause_t *rsp = (NetworkCause_t *) capi2_rsp->dataBuf;
if(*rsp != GSMCAUSE_SUCCESS)
{
KRIL_DEBUG(DBG_ERROR, "MSG_SS_CALL_WAITING_RSP::netCause:%d\n", *rsp);
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else if (capi2_rsp->msgType == MSG_SS_CALL_WAITING_STATUS_RSP)
{
SS_ActivationStatus_t *rsp = (SS_ActivationStatus_t *) capi2_rsp->dataBuf;
KrilCallWaitingInfo_t *tdata = (KrilCallWaitingInfo_t *)pdata->ril_cmd->data;
KrilCallWaitingClass_t *rdata = (KrilCallWaitingClass_t *)pdata->bcm_ril_rsp;
KRIL_DEBUG(DBG_INFO, "netCause:%d\n", rsp->netCause);
if(rsp->netCause == GSMCAUSE_SUCCESS)
{
int i;
KRIL_DEBUG(DBG_INFO, "class_size:%d\n", rsp->class_size);
for(i = 0 ; i < rsp->class_size ; i++)
{
KRIL_DEBUG(DBG_INFO, "activated:%d ss_class:%d\n", rsp->ss_activation_class_info[i].activated, rsp->ss_activation_class_info[i].ss_class);
if (TRUE == rsp->ss_activation_class_info[i].activated)
{
if ((SvcClassToATClass(rsp->ss_activation_class_info[i].ss_class) == tdata->ss_class) || (SS_SVCCLS_NOTSPECIFIED == tdata->ss_class))
{
rdata->activated = 1;
rdata->ss_class |= SvcClassToATClass(rsp->ss_activation_class_info[i].ss_class);
}
}
}
KRIL_DEBUG(DBG_INFO, "Final state activated:%d ss_class:%d\n", rdata->activated, rdata->ss_class);
}
else
{
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
}
else
{
KRIL_SetInSsQueryHandler(FALSE);
pdata->handler_state = BCM_ErrorCAPI2Cmd;
return;
}
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_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_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_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;
}
}
}
