Boolean RPC_IsRegisteredClient(UInt8 channel, PACKET_BufHandle_t dataBufHandle)
{
Boolean ret = FALSE;
UInt8 xdrReqClient =
RPC_PACKET_GetContext(INTERFACE_CAPI2, dataBufHandle);
UInt16 msgId = RPC_PACKET_GetContextEx(INTERFACE_CAPI2, dataBufHandle);
Boolean isValid = RPC_IsValidMsg((MsgType_t)msgId);
UInt8 clientHandle = RPC_SYS_GetClientHandle(channel);
UInt8 clientAckHandle = RPC_SYS_GetClientHandle(xdrReqClient);
if (msgId == MSG_CAPI2_ACK_RSP) {
ret = (xdrReqClient > 0 && clientAckHandle > 0);
} else {
if (channel > 0)
ret = (clientHandle != 0) ? TRUE : FALSE;
else
ret = isValid;
}
if (ret)
_DBG_(RPC_TRACE
("RPC_IsRegisteredClient[ret=%d] ch=%d xdrClient=%d msgId=0x%x validMsg=%d validClient=%d validAckClient=%d",
ret, channel, xdrReqClient, msgId, isValid, clientHandle,
clientAckHandle));
return ret;
}
void RPC_AckCPReset(UInt8 clientID)
{
UInt8 index = RPC_SYS_GetClientHandle(clientID);
int i;
Boolean bReady = TRUE;
_DBG_(RPC_TRACE("RPC_AckCPReset client %d index %d\n",
clientID, index));
if (index <= gClientIndex)
gClientLocalMap[index].ackdCPReset = TRUE;
/* check if all for given PACKET_InterfaceType_t have ack'd;
if so, ack to rpc_ipc layer
*/
for (i = 1; i <= gClientIndex; i++)
if (gClientMap[index].iType == gClientMap[i].iType &&
gClientMap[i].cpResetCb &&
!gClientLocalMap[i].ackdCPReset) {
/* at least one client for given
interface type has not yet ack'd
so we're not ready yet
*/
_DBG_(RPC_TRACE("RPC_AckCPReset fail index %d\n", i));
bReady = FALSE;
break;
} else {
_DBG_(RPC_TRACE("RPC_AckCPReset %d %d %d %d %d\n",
i, index, gClientMap[index].iType,
gClientMap[i].iType,
gClientLocalMap[i].ackdCPReset));
}
if (bReady) {
_DBG_(RPC_TRACE
("RPC_AckCPReset calling RPC_PACKET_AckReadyForCPReset\n"));
RPC_PACKET_AckReadyForCPReset(0,
(PACKET_InterfaceType_t)
gClientMap[index].iType);
}
}
/****************************************************************************
*
* CAPI2_ClientInit(void);
*
* Register IPC module.
*
***************************************************************************/
UInt32 KPDPCAPI2_ClientInit(void)
{
UInt32 ret = 0;
UInt8 clientID;
Boolean bEnabled;
clientID = CAPI2_SYS_RegisterClient(NULL, KPDP_RPC_RespCbk, KPDP_Capi2HandleAckCbk, KPDP_Capi2HandleFlowCtrl);
bEnabled = RPC_EnableUnsolicitedMsgs(RPC_SYS_GetClientHandle(clientID), TRUE);
KPDPSetClientID(clientID);
KPDP_DEBUG(DBG_INFO, "CAPI2_ClientInit clientID:0x%x UnsolEnabled:%s\n", clientID, (bEnabled?"TRUE":"FALSE"));
// initialize additional RPC interfaces needed for CIB
// **FIXME** capirpc channel appears to no longer be required (only had SMS ME, which
// isn't needed under Android)
// KPDP_CapiRpc_Init();
//KPDP_SysRpc_Init();
//KPDP_ADCRpc_Init();
return(ret);
}
/* cp silent reset callback for sync rpc layer */
static void RPC_SyncNotification(
struct RpcNotificationEvent_t event, UInt8 clientID)
{
TaskRequestMap_t *taskMap = (TaskRequestMap_t *) NULL;
UInt8 i;
RPC_SyncParams_t *internalParam;
UInt8 clientIndex;
_DBG_(RPC_TRACE("RPC_SyncNotification event %d param %d",
(int) event.event, (int) event.param));
switch (event.event) {
case RPC_CPRESET_EVT:
for (i = 0; i < MAX_TASKS_NUM; i++) {
taskMap = (sTaskRequestMap + i);
if (taskMap != NULL &&
taskMap->task != NULL) {
_DBG_(RPC_TRACE(
"RPC_SyncNotification i=%d tid=%d msg=%d ack=%d\r\n",
i, (int)taskMap->tid, (int)taskMap->msgType,
taskMap->ack));
_DBG_(RPC_TRACE(
"RPC_SyncNotification pend=%d sz=%d rs=%d task=0x%p\r\n",
taskMap->isResultPending, (int)taskMap->rspSize,
(int)taskMap->result, (void *)taskMap->task));
if (event.param == RPC_CPRESET_START) {
switch (taskMap->state) {
case RPC_SYNC_STATE_WAITING_FOR_ACK:
_DBG_(RPC_TRACE(
"RPC_SyncNotification waiting for ack\n"));
taskMap->ack = ACK_CRITICAL_ERROR;
taskMap->state = RPC_SYNC_STATE_DONE;
if (taskMap->ackSema)
OSSEMAPHORE_Release(taskMap->
ackSema);
_DBG_(RPC_TRACE(
"RPC_SyncNotification after sema rel\n"));
break;
case RPC_SYNC_STATE_WAITING_FOR_RSP:
_DBG_(RPC_TRACE(
"RPC_SyncNotification waiting for rsp\n"));
taskMap->result = RESULT_ERROR;
taskMap->tid = 0;
taskMap->state = RPC_SYNC_STATE_DONE;
OSSEMAPHORE_Release(taskMap->rspSema);
break;
default:
_DBG_(RPC_TRACE(
"RPC_SyncNotification state=%d\n",
taskMap->state));
break;
}
} else {
}
}
}
clientIndex = RPC_SYS_GetClientHandle(clientID);
internalParam = (RPC_SyncParams_t *)
RPC_GetUserData(clientIndex);
if (internalParam && internalParam->clientParams.rpcNtfFn)
internalParam->clientParams.rpcNtfFn(event, clientID);
break;
default:
_DBG_(RPC_TRACE(
"RPC_SyncNotification: Unsupported event %d\n",
(int) event.event));
break;
}
}
