void KPDP_DeactivatePdpHandler(void *pdp_cmd, Kpdp_CAPI2Info_t *capi2_rsp)
{
    KPDP_CmdList_t *pdata = (KPDP_CmdList_t *)pdp_cmd;

    if((pdata->handler_state!= BCM_SendCAPI2Cmd)&& (capi2_rsp == NULL))
    {
        KPDP_DEBUG(DBG_ERROR,"capi2_rsp is NULL=%d\n");
        pdata->handler_state = BCM_ErrorCAPI2Cmd;
        return;                            
    }

    switch(pdata->handler_state)
    {
        case BCM_SendCAPI2Cmd:
        {
            char *cid = (char *)(pdata->pdp_cmd->data);
            UInt8 ContextID = (UInt8)(*cid - 0x30);
            UInt8 i;

            KPDP_DEBUG(DBG_INFO, "KPDP_DeactivatePdpHandler - length %d, Cid:%d \n", pdata->pdp_cmd->datalen, ContextID);
            pdata->bcm_pdp_rsp = kmalloc(sizeof(KpdpPdpData_t), GFP_KERNEL);
            if(!pdata->bcm_pdp_rsp) {
                KPDP_DEBUG(DBG_ERROR, "unable to allocate bcm_pdp_rsp buf\n");
                pdata->handler_state = BCM_ErrorCAPI2Cmd;
                return;
            }
            pdata->rsp_len = sizeof(KpdpPdpData_t);
            memset(pdata->bcm_pdp_rsp, 0, pdata->rsp_len);
            for (i=0 ; i<BCM_NET_MAX_DUN_PDP_CNTXS ; i++)
            {
                if (ContextID == Kpdp_pdp_resp[pdata->pdp_cmd->SimId][i].cid) // To find the contextID in Kpdp_pdp_resp list, need to deactivate the context
                {
                    KPDP_DEBUG(DBG_INFO, "ReleaseDunPdpContext[%d]=%d \n", i, Kpdp_pdp_resp[pdata->pdp_cmd->SimId][i].cid);
                    break;
                }
                else if ((BCM_NET_MAX_DUN_PDP_CNTXS-1) == i) // Return finish state if can't find the contestID in Kpdp_pdp_resp list.
                {
                    KPDP_DEBUG(DBG_INFO, "Can't find corresponding cid = %d\n", ContextID);
                    pdata->handler_state = BCM_FinishCAPI2Cmd;
                    return;
                }
            }
            {
                CAPI2_PchExApi_SendPDPDeactivateReq( KPDPInitClientInfo(pdata->pdp_cmd->SimId), ContextID );
            }
            ReleaseDunPdpContext(pdata->pdp_cmd->SimId, ContextID);
            pdata->handler_state = BCM_RESPCAPI2Cmd;
        }
        break;

        case BCM_RESPCAPI2Cmd:
        {
        	   KPDP_DEBUG(DBG_INFO, "result:0x%x\n", capi2_rsp->result);
            if(RESULT_OK != capi2_rsp->result)
            {
                KPDP_DEBUG(DBG_ERROR, "PDPDeActivate Fail to SendPDPDeActivateReq \n");
                pdata->result = RESULT_ERROR;
                pdata->handler_state = BCM_ErrorCAPI2Cmd;
                break;
            }

            if(NULL != capi2_rsp->dataBuf)
            {
                PDP_SendPDPDeactivateReq_Rsp_t *rsp = (PDP_SendPDPDeactivateReq_Rsp_t *)capi2_rsp->dataBuf;
                KpdpPdpData_t *rdata = pdata->bcm_pdp_rsp;
                if(rsp->response != PCH_REQ_ACCEPTED)
                {
                    KPDP_DEBUG(DBG_ERROR, "PDPDeActivate Fail resp(1 accept) %d, cid %d\r\n", rsp->response, rsp->cid);
                    pdata->result = RESULT_ERROR;
                    rdata->cause = rsp->cause;
                    pdata->handler_state = BCM_ErrorCAPI2Cmd;
                    break;
                }

                rdata->cid = rsp->cid;
                KPDP_DEBUG(DBG_INFO, "PDP Deactivate Resp - cid %d \n", rsp->cid);

                pdata->result = RESULT_OK;
                pdata->handler_state = BCM_FinishCAPI2Cmd;
            }
            else
            {
                pdata->result = RESULT_ERROR;
                pdata->handler_state = BCM_ErrorCAPI2Cmd;
            }
        }
        break;

        default:
        {
            KPDP_DEBUG(DBG_ERROR, "handler_state:%lu error...!\n", pdata->handler_state);
            pdata->handler_state = BCM_ErrorCAPI2Cmd;
            break;
        }
    }
}
Exemple #2
0
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;
        }
    }
}