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; } } }