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