//****************************************************************************** // // Function Name: STK_SendEnvelopeCmd // // Description: Handle Send Envelope command // Notes: // //****************************************************************************** int STK_SendEnvelopeCmd(KRIL_Command_t *ril_cmd) { UInt8 *envelopeCmd = (UInt8*)ril_cmd->data; RawDataPrintfun(envelopeCmd, ril_cmd->datalen, "envelopeCmd"); // Parse tag KRIL_DEBUG(DBG_INFO,"tag:0x%X\n", envelopeCmd[0]); switch (envelopeCmd[0]) { case 0xD3: if (!STK_MenuSelection(ril_cmd->SimId, envelopeCmd)) return 0; break; case 0xD6: if (!STK_EventDownload(ril_cmd->SimId, envelopeCmd)) return 0; break; default: KRIL_DEBUG(DBG_ERROR,"Not suppported tag:0x%X\n", envelopeCmd[0]); return 0; } return 1; }
//****************************************************************************** // // Function Name: STK_ParseDeviceIdentities // // Description: Parse Device Identities(refer to 11.14 section 12.7) // // Notes: // //****************************************************************************** int STK_ParseDeviceIdentities(UInt8 *byte) { // Check tag if (!(byte[0] == 0x82 || byte[0] == 0x02)) { KRIL_DEBUG(DBG_ERROR,"Error Device details tag:0x%X\n", byte[5]); return 0; } // Check source device identity if (!(byte[2] == 0x82 || byte[2] == 0x01 || byte[2] == 0x02)) { KRIL_DEBUG(DBG_ERROR,"Error Source Device identity:0x%X\n", byte[7]); return 0; } // Check destination device identity if (byte[3] != 0x81) { KRIL_DEBUG(DBG_ERROR,"Error Destination Device identity:0x%X\n", byte[8]); return 0; } return 1; }
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; } } }
Result_t Handle_CAPI2_SYSRPC_PMU_IsSIMReady(RPC_Msg_t *pReqMsg, PMU_SIMLDO_t simldo) { Result_t result = RESULT_OK; SYS_ReqRep_t data; int ret = 0; RegulatorInfo_t *curReg = &gRegulatorList[REG_INDEX(simldo)]; if (!IS_ERR(curReg->handle)) { ret = regulator_is_enabled(curReg->handle); KRIL_DEBUG(DBG_INFO, " Handle_CAPI2_PMU_IsSIMReady ldo=%d handle=%p ret=%d\n\n", (int)simldo, curReg->handle, (int)ret); } else KRIL_DEBUG(DBG_INFO, " regulator_is_enabled Invalid Handle %d\n", (int)IS_ERR(curReg->handle)); memset(&data, 0, sizeof(SYS_ReqRep_t)); data.req_rep_u.CAPI2_SYSRPC_PMU_IsSIMReady_Rsp.val = curReg->isSimInit; /*(Boolean)(regulator_is_enabled > 0); */ data.result = result; Send_SYS_RspForRequest(pReqMsg, MSG_PMU_IS_SIM_READY_RSP, &data); KRIL_DEBUG(DBG_INFO, " Handle_CAPI2_PMU_IsSIMReady DONE active=%d\n", (int)curReg->isSimInit); return result; }
//****************************************************************************** // // Function Name: KRIL_StkService_Running // // Description: // Notes: // //****************************************************************************** void KRIL_StkService_Running(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp) // gearn fix java sim card { 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_SatkApi_SendTerminalProfileReq (InitClientInfo(pdata->ril_cmd->SimId),17, terminal_profile_data); pdata->handler_state = BCM_RESPCAPI2Cmd; } case BCM_RESPCAPI2Cmd: pdata->result = BCM_E_SUCCESS; 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_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; } } }
//****************************************************************************** // // Function Name: STK_ParseTextString // // Description: Parse Text String(refer to 11.14 section 12.15) // // Notes: // //****************************************************************************** int STK_ParseTextString(UInt8 *byte, SATKString_t *intext) { // Check Text string tag UInt8 add_len; UInt8 DCS; if (!(byte[0] == 0x8D || byte[0] == 0x0D)) { KRIL_DEBUG(DBG_ERROR,"Error Text string tag:0x%X\n", byte[0]); return 0; } // Check Length //intext->len = byte[1] - 1; add_len = byte[1]; if (add_len == 0x81) // gearn large get input { intext->len= byte[2]- 1; DCS = byte[3]; // Parse Text string memcpy(intext->string, &byte[4], intext->len); KRIL_DEBUG(DBG_ERROR,"STK_ParseTextString DCS:0x%X add_len:%d intext->len:%d\n", DCS, add_len, intext->len); } else { intext->len = byte[1] - 1; DCS = byte[2]; memcpy(intext->string, &byte[3], intext->len); KRIL_DEBUG(DBG_ERROR,"STK_ParseTextString DCS:0x%X add_len:%d intext->len:%d\n", DCS, add_len, intext->len); } // Check Data coding scheme switch (DCS) { case 0x00: intext->unicode_type = UNICODE_GSM; break; case 0x04: intext->unicode_type = UNICODE_UCS1; break; case 0x08: intext->unicode_type = UNICODE_80; break; default: KRIL_DEBUG(DBG_ERROR,"Not supported coding scheme:0x%02X Error!\n", byte[2]); return 0; } return 1; }
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; } } }
//****************************************************************************** // // Function Name: STK_ParseEventList // // Description: Parse Event List(refer to 11.14 section 12.25) // // Notes: // //****************************************************************************** int STK_ParseEventList(SimNumber_t SimId, UInt8 *byte) { // Check Event List tag if (!(byte[0] == 0x19 || byte[0] == 0x99)) { KRIL_DEBUG(DBG_ERROR,"Error Event List tag:0x%X\n", byte[0]); return 0; } if (0 == byte[1]) { KRIL_DEBUG(DBG_ERROR,"Event list length is 0 Error!!!\n"); return 0; } KRIL_DEBUG(DBG_INFO,"Event Id:%d\n",byte[2]); switch (byte[2]) { case 4: { // User activity CAPI2_SatkApi_SendUserActivityEvent (InitClientInfo(SimId)); break; } case 5: { // Idle screen available CAPI2_SatkApi_SendIdleScreenAvaiEvent (InitClientInfo(SimId)); break; } case 7: { // Language selection if (!STK_ParseLanguageSelection(SimId, &byte[7])) return 0; break; } default: KRIL_DEBUG(DBG_ERROR,"Unknow Enevt ID:%d\n", byte[2]); return 0; } return 1; }
//RIL_REQUEST_AGPS_CLOSE_PKCS15 void KRIL_AgpsClosePkcs15Handler(void *ril_cmd, Kril_CAPI2Info_t *capi2_rsp) { KRIL_CmdList_t *pdata = (KRIL_CmdList_t *)ril_cmd; unsigned char *pSockId = (unsigned char *)pdata->ril_cmd->data; if (capi2_rsp != NULL) KRIL_DEBUG(DBG_ERROR, "handler_state:0x%lX::result:%d\n", pdata->handler_state, capi2_rsp->result); switch(pdata->handler_state) { case BCM_SendCAPI2Cmd: { ClientInfo_t* pLcsClientInfo = InitClientInfo(pdata->ril_cmd->SimId); KRIL_DEBUG(DBG_ERROR, "KRIL_AgpsClosePkcs15Handler, sockID=%d \n", (unsigned char)(*pSockId)); CAPI2_SimApi_SendDeactivateAppiReq(pLcsClientInfo, (UInt8) (*pSockId)); pdata->handler_state = BCM_AGPS_DESELECT_PKCS15; break; } case BCM_AGPS_DESELECT_PKCS15: { //MsgType_t: ::MSG_SIM_DEACTIVATE_APPLI_RSP //ResultData: ::SIM_DEACTIVATE_APPLI_RES_t SIM_DEACTIVATE_APPLI_RES_t * rsp = (SIM_DEACTIVATE_APPLI_RES_t *) capi2_rsp->dataBuf; ClientInfo_t* pLcsClientInfo = InitClientInfo(pdata->ril_cmd->SimId); KRIL_DEBUG(DBG_ERROR, "KRIL_Agps SendDeactivateAppiReq, result=%d \n", rsp->result); CAPI2_SimApi_SendCloseSocketReq(pLcsClientInfo, (UInt8) (*pSockId)); pdata->handler_state = BCM_RESPCAPI2Cmd; break; } case BCM_RESPCAPI2Cmd: { //MsgType_t: ::MSG_SIM_CLOSE_SOCKET_RSP //ResultData: ::SIM_CLOSE_SOCKET_RES_t SIM_CLOSE_SOCKET_RES_t * rsp = (SIM_CLOSE_SOCKET_RES_t *) capi2_rsp->dataBuf; KRIL_DEBUG(DBG_ERROR, "KRIL_Agps SendCloseSocketReq, result=%d \n", rsp->result); 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; } } }
/**************************************************************************** * * bcm_fuse_kril_init_module(void); * * Init module. * ***************************************************************************/ static int __init bcm_fuse_kril_init_module(void) { int ret = 0; pr_info("KRIL Support 1.00 (BUILD TIME "__DATE__" "__TIME__")\n" ); // check for AP only boot mode if ( AP_ONLY_BOOT == get_ap_boot_mode() ) { // AP only, so don't continue with KRIL init KRIL_DEBUG(DBG_INFO, "bcm_fuse_kril_init_module: AP only; don't register driver\n"); return ret; } if (( ret = register_chrdev( BCM_KRIL_MAJOR, "bcm_kril", &kril_ops )) < 0 ) { KRIL_DEBUG(DBG_ERROR, "kril: register_chrdev failed for major %d\n", BCM_KRIL_MAJOR ); goto out; } kril_class = class_create(THIS_MODULE, "bcm_kril"); if (IS_ERR(kril_class)) { return PTR_ERR(kril_class); } device_create(kril_class, NULL, MKDEV(BCM_KRIL_MAJOR, 0),NULL, "bcm_kril"); KRIL_DEBUG(DBG_INFO, "%s driver(major %d) installed.\n", "bcm_kril", BCM_KRIL_MAJOR); /** Register callbacks with the IPC module Note: does not depend on the channel */ ret = CAPI2_ClientInit(); /** Init KRIL Driver */ ret = KRIL_Init(); if (ret) { ret = -1; KRIL_DEBUG(DBG_ERROR, "KRIL_Init fail...!\n"); goto out_unregister; } return ret; out_unregister: unregister_chrdev( BCM_KRIL_MAJOR, "bcm_kril"); out: return(ret); }
void SysRpc_OpenRegulator(PMU_SIMLDO_t ldo) { RegulatorInfo_t *curReg = &gRegulatorList[REG_INDEX(ldo)]; curReg->handle = regulator_get(NULL, curReg->devName); if (IS_ERR(curReg->handle)) { KRIL_DEBUG(DBG_ERROR, " **regulator_get (dev=%s) FAILED h=%p\n", curReg->devName, curReg->handle); } else { KRIL_DEBUG(DBG_INFO, " **regulator_get (dev=%s) PASS handle=%p\n", curReg->devName, curReg->handle); } }
//****************************************************************************** // // Function Name: STK_ParseItemIdentifier // // Description: Parse Item Identifier(refer to 11.14 section 12.10) // // Notes: // //****************************************************************************** int STK_ParseItemIdentifier(UInt8 *byte, UInt8 *itemId) { // Check item identifier tag if (!(byte[0] == 0x90 || byte[0] == 0x10)) { KRIL_DEBUG(DBG_ERROR,"Error Item identifier tag:0x%X\n", byte[0]); return 0; } // Check identifier of item chosen *itemId = byte[2]; KRIL_DEBUG(DBG_INFO,"itemId:%d\n",*itemId); return 1; }
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; } } }
/* CAPI2 callback functions */ void CAPI2_PMU_IsSIMReady(UInt32 tid, UInt8 clientID) { if (tid || clientID) { } //fixes warnings /* NOT implemented yet */ KRIL_DEBUG(DBG_TRACE, " --->Capi2 Callback\n"); CAPI2_PMU_IsSIMReady_RSP(tid, clientID, pmu_is_sim_ready()); }
void _DEF(CAPI2_SOCKET_ParseIPAddr)(UInt32 tid, UInt8 clientID, char_ptr_t ipString) { if (tid || clientID) { } //fixes warnings /* NOT implemented yet */ KRIL_DEBUG(DBG_TRACE, " --->Capi2 Callback!\n"); }
//CAPI2_LINUX_INTEGRATION_CHANGE 1.2.10.2 TEMPORARY void CAPI2_GPIO_ConfigOutput_64Pin(UInt32 tid, UInt8 clientID, UInt32 mask) { if (tid || clientID || mask) { } //fixes warnings KRIL_DEBUG(DBG_TRACE," --->Capi2 Callback\n"); CAPI2_GPIO_ConfigOutput_64Pin_RSP(tid, clientID, FALSE); }
void _DEF(CAPI2_RTC_GetDST)(UInt32 tid, UInt8 clientID) { UInt8 dst = 0; KRIL_DEBUG(DBG_TRACE," --->CAPI2_RTC_GetDST::Callback!\n"); CAPI2_RTC_GetDST_RSP(tid, clientID, dst); }
void CAPI2_GPIO_Set_Low_64Pin(UInt32 tid, UInt8 clientID, UInt32 gpio_pin) { if (tid || clientID || gpio_pin) { } //fixes warnings KRIL_DEBUG(DBG_TRACE," --->Capi2 Callback\n"); CAPI2_GPIO_Set_Low_64Pin_RSP(tid, clientID, FALSE); }
//****************************************************************************** // // Function Name: STK_SelectItemRsp // // Description: Handle Select Item response // // Notes: // //****************************************************************************** int STK_SelectItemRsp(SimNumber_t SimId, UInt8 *byte, UInt8 cmdlen) { SATK_ResultCode_t resultcode = SATK_Result_CmdSuccess; SATK_ResultCode2_t resultcode2 = SATK_Result_NoCause; UInt8 itemId = 0; // Parse device identities if (!STK_ParseDeviceIdentities(&byte[5])) return 0; // Parse Result if (!STK_ParseResult(&byte[9], &resultcode, &resultcode2)) return 0; cmdlen -= (STK_COMMAND_DETAILS_LEN + STK_DEVICE_IDENTITIES_LEN + STK_RESULT_LEN + (byte[10] - 1)); byte += (STK_COMMAND_DETAILS_LEN + STK_DEVICE_IDENTITIES_LEN + STK_RESULT_LEN + (byte[10] - 1)); KRIL_DEBUG(DBG_INFO,"After parsing result: byte[0]:0x%02X cmdlen:%d\n", byte[0], cmdlen); // Parse Item identifier if (cmdlen > 0) { if (!STK_ParseItemIdentifier(byte, &itemId)) return 0; } CAPI2_SatkApi_CmdResp(InitClientInfo(SimId), SATK_EVENT_SELECT_ITEM, resultcode, resultcode2, NULL, itemId); return 1; }
uint32 EncDec(uint8 *outDataPtr, const uint8 *inDataPtr, uint32 inDataSize, uint32 inEncDec) { uint8 key[HUK_LEN]; uint32 x; /* Check for invalid parameters */ if ( (outDataPtr == NULL) || (inDataSize < AES_BLOCK_SIZE) || ((inDataSize % AES_BLOCK_SIZE) != 0) || ( (inEncDec != AES_OPERATION_ENCRYPT) && (inEncDec != AES_OPERATION_DECRYPT) ) ) { KRIL_DEBUG(DBG_ERROR,"outDataPtr = NULL:%d inDataSize:%d inEncDec:%d Failed!!!\n", (outDataPtr == NULL), inDataSize, inEncDec); return(0); } /* Set the key to bet the HUK XORed with a fixed string */ if (GetHuk(key) == 1) { for (x=0; x<HUK_LEN; x++) { key[x] ^= HukStringSimLockCKData[x]; } } else { return(0); } /* Encrypt in AES-CBC-128 mode */ return(Aes(outDataPtr, inDataPtr, inDataSize, (const uint8 *) key, AES_KEY_SIZE_128, EncDecIv, AES_MODE_CBC, inEncDec)); }
static unsigned int KRIL_Poll(struct file *filp, poll_table *wait) { KRIL_Param_t *priv = filp->private_data; UInt32 mask = 0; UInt32 flags; #ifdef CONFIG_HAS_WAKELOCK if (wake_lock_active(&kril_result_wake_lock) != 0 && TRUE == list_empty(&(gKrilResultQueue.list))) // if wake lock exist and result queue is empty, need to do wake_unlock { do { KRIL_DEBUG(DBG_INFO, "wake_lock_active(&kril_result_wake_lock):%d wake_unlock\n", wake_lock_active(&kril_result_wake_lock)); wake_unlock(&kril_result_wake_lock); } while (wake_lock_active(&kril_result_wake_lock) != 0 && TRUE == list_empty(&(gKrilResultQueue.list))); // don't need to unlock wake_lock if no lock state and result is empty } #endif poll_wait(filp, &gKrilParam.read_wait, wait); spin_lock_irqsave(&priv->recv_lock, flags); if (!list_empty(&(gKrilResultQueue.list))) mask |= (POLLIN | POLLRDNORM); spin_unlock_irqrestore(&priv->recv_lock, flags); return mask; }
void CAPI2_CP2AP_PedestalMode_Control(UInt32 tid, UInt8 clientID, UInt32 enable) { if (enable) { } //fixes compiler warning //TBD: Call pedestal mode function here KRIL_DEBUG(DBG_TRACE, " --->Capi2 Callback volt:%ld!\n", enable); CAPI2_CP2AP_PedestalMode_Control_RSP(tid, clientID, TRUE); }
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 _DEF(CAPI2_DATA_SetPassword)(UInt32 tid, UInt8 clientID, UInt8 acctID, uchar_ptr_t password) { if (tid || clientID) { } //fixes warnings /* NOT implemented yet */ KRIL_DEBUG(DBG_TRACE, " --->Capi2 Callback!\n"); CAPI2_DATA_SetPassword_RSP(tid, clientID, TRUE); }
void _DEF(CAPI2_DATA_GetStaticIPAddr)(UInt32 tid, UInt8 clientID, UInt8 acctID) { if (tid || clientID) { } //fixes warnings /* NOT implemented yet */ KRIL_DEBUG(DBG_TRACE, " --->Capi2 Callback!\n"); CAPI2_DATA_GetStaticIPAddr_RSP(tid, clientID, NULL); }
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; } } }
int KRIL_Read(struct file *filp, char __user *buf, size_t size, loff_t *offset) { /*buffer copy to user*/ int rc = 0; KRIL_DEBUG(DBG_INFO, "KRIL_Read Enter %s\n", __func__); return rc; }
int KRIL_Write(struct file *filp, const char __user *buf, size_t size, loff_t *offset) { /*buffer copy from user*/ int rc = 0; KRIL_DEBUG(DBG_INFO, "KRIL_Write %s: count %d pos %lld\n", __func__, size, *offset); return rc; }