/******************************************************************************* ################################################################################ # Copyright (c) [2017-2019] [Radisys] # # # # Licensed under the Apache License, Version 2.0 (the "License"); # # you may not use this file except in compliance with the License. # # You may obtain a copy of the License at # # # # http://www.apache.org/licenses/LICENSE-2.0 # # # # Unless required by applicable law or agreed to in writing, software # # distributed under the License is distributed on an "AS IS" BASIS, # # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # # See the License for the specific language governing permissions and # # limitations under the License. # ################################################################################ *******************************************************************************/ /********************************************************************20** Name: RLC service user (PDCP) lower interface Type: C file Desc: This file Contains the RLC service user lower interface primitive implementain File: pj_ptlib.c *********************************************************************21*/ /* header (.h) include files */ #include "envopt.h" /* environment options */ #include "envdep.h" /* environment dependent */ #include "envind.h" /* environment independent */ #include "gen.h" /* general */ #include "ssi.h" /* system services */ #include "cm5.h" /* common timer defines */ #include "cm_tkns.h" /* common tokens defines */ #include "cm_mblk.h" /* common memory allocation library defines */ #include "cm_llist.h" /* common link list defines */ #include "cm_hash.h" /* common hash list defines */ #include "cm_lte.h" /* common LTE defines */ #include "kwu.h" /* KWU defines */ #include "pju.h" /* PJU defines */ /*#include "rgu.h"*/ /* RGU defines */ #include "cpj.h" /* CPJ defines */ #include "lpj.h" /* LPJ defines */ #include "pju.h" /* PJU defines */ #include "pj_env.h" /* RLC environment options */ #include "pj.h" /* RLC defines */ #include "pj_dl.h" #include "pj_ptsec.h" #ifdef INTEL_NATIVE_SPACC #include "elpspaccusr.h" #endif /* extern (.x) include files */ #include "gen.x" /* general */ #include "ssi.x" /* system services */ #if (defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF)) #include "ss_rbuf.h" #include "ss_rbuf.x" #include "kwu.h" /* PJU */ #include "ss_queue.h" #include "ss_queue.x" #include "ss_task.h" #include "ss_task.x" #include "ss_timer.x" /* System services */ #include "ss_msg.h" /* System services */ #include "ss_msg.x" /* System services */ #include "ss_mem.h" /* System services */ #include "ss_mem.x" /* System services */ #include "ss_drvr.x" #include "ss_gen.h" #include "ss_gen.x" #endif #include "cm5.x" /* common timer library */ #include "cm_tkns.x" /* common tokens */ #include "cm_mblk.x" /* common memory allocation */ #include "cm_llist.x" /* common link list */ #include "cm_hash.x" /* common hash list */ #include "cm_lte.x" /* common LTE includes */ #include "cm_lib.x" /* common memory allocation library */ #ifdef TENB_AS_SECURITY #include "mt_plat_t33.h" #include "mt_plat_t33.x" #endif #include "kwu.x" /* KWU */ #include "pju.x" /* PJU */ /*#include "rgu.x" */ /* RGU */ #include "cpj.x" /* CPJ */ #include "lpj.x" /* LPJ */ #include "pju.x" /* PJU */ #include "pj.x" #include "pj_udx.h" /* LIB */ #include "pj_udx.x" /* LIB */ #include "pj_dl.x" #include "pj_ul.x" #include "pj_ptsec.x" #include "pj_lib.x" /* LIB */ #ifdef TENB_AS_SECURITY static const char* RLOG_MODULE_NAME="PDCP"; static int RLOG_FILE_ID=293; static int RLOG_MODULE_ID=1024; #endif #ifdef TENB_T2K3K_SPECIFIC_CHANGES extern U32 isMemThreshReached(Region region); #endif #ifdef TENB_AS_SECURITY PUBLIC U32 pjMsSpaccHdlOpenReq(PTR *fd); PUBLIC U32 pjMsSpaccHdlCloseReq(PTR *fd); PUBLIC U32 pjMsSpaccCipherPkt(PjMsSecInfo *pSec, Buffer *mBuf); PUBLIC U32 pjMsSpaccIntegProtPkt(PjLibTrans *libTrans, Buffer **mBuf); PRIVATE S16 pjExtractTxEntRbCbUsingSpaccMappingInfo ARGS (( PjMsSPACCOutputMapInfo *spaccInfo, PjCb **gCb, PjDlRbCb **pjRbCb, PjTxEnt **txEnt )); PRIVATE Void pjMsSpaccProcessDlBatchOutput ARGS ((Void)); PRIVATE Void pjMsSpaccProcessUlBatchOutput ARGS((Void)); PUBLIC U32 pjMsCheckSpaccQueue(Bool isUl); PUBLIC Void pjSpaccDeInitCiphQ(Void); PUBLIC Void pjSpaccDeInitDeCipherQ(Void); #endif #ifdef PTPJLIB #ifdef PJ_CMP_ASYNC /************************************************************************ PJU Interface Matrices ************************************************************************/ /**************************************************************************** * PJU Interface Mt functions ***************************************************************************/ #ifdef ANSI PUBLIC S16 PjLibObdCmpInitReq ( Pst * pst, PjCmpCxt cmpCxt, PjRohc rohc ) #else PUBLIC S16 PjLibObdCmpInitReq(pst, cmpCxt, rohc) Pst * pst; PjCmpCxt cmpCxt; PjRohc rohc; #endif { TRC3(PjLibObdCmpInitReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdCmpReq ( Pst * pst, PTR cmpCxtId, PjLibTrans libTrans, Buffer * mBuf ) #else PUBLIC S16 PjLibObdCmpReq(pst, cmpCxtId, libTrans, mBuf) Pst * pst; PTR cmpCxtId; PjLibTrans libTrans; Buffer * mBuf; #endif { TRC3(PjLibObdCmpReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdDecmpReq ( Pst * pst, PTR cmpCxtId, PjLibTrans libTrans, Buffer * mBuf ) #else PUBLIC S16 PjLibObdDecmpReq(pst, cmpCxtId, libTrans, mBuf) Pst * pst; PTR cmpCxtId; PjLibTrans libTrans; Buffer * mBuf; #endif { TRC3(PjLibObdDecmpReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdCmpCloseReq ( Pst * pst, PTR cmpCxtId ) #else PUBLIC S16 PjLibObdCmpCloseReq(pst, cmpCxtId) Pst * pst; PTR cmpCxtId; #endif { TRC3(PjLibObdCmpCloseReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdCmpResetReq ( Pst * pst, PTR cmpCxtId ) #else PUBLIC S16 PjLibObdCmpResetReq(pst, cmpCxtId) Pst * pst; PTR cmpCxtId; #endif { TRC3(PjLibObdCmpResetReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdCmpFbReq ( Pst * pst, PTR cmpCxtId, PjLibTrans libTrans, Buffer *feedback ) #else PUBLIC S16 PjLibObdCmpFbReq(pst, cmpCxtId, libTrans, feedback) Pst * pst; PTR cmpCxtId; PjLibTrans libTrans; Buffer *feedback; #endif { TRC3(PjLibObdCmpFbReq) RETVALUE(ROK); } #else #ifdef ANSI PUBLIC S16 PjLibObdCipherCloseReq ( Void *cpCxtId ) #else PUBLIC S16 PjLibObdCipherCloseReq(cpCxtId) Void *cpCxtId #endif { TRC3(PjLibObdCipherCloseReq) #ifdef INTEL_SPACC_IV_OPTIMIZATION pjNSpaccReturnStreamIdToPool(cpCxtId); #endif RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 pjLibCmpInitReq ( PjCmpCxt cmpCxt, /* Context for ROHC */ PjRohc rohc, /* ROHC Config Info */ PTR *cmpCxtId /* Compression Context ID */ ) #else PUBLIC S16 pjLibCmpInitReq(cmpCxt, rohc, cmpCxtId) PjCmpCxt cmpCxt; /* Context for ROHC */ PjRohc rohc; /* ROHC Config Info */ PTR *cmpCxtId; /* Compression Context ID */ #endif { TRC3(pjLibCmpInitReq) RETVALUE(ROK); } /* end of pjLibCmpInitReq */ #ifdef ANSI PUBLIC S16 pjLibCmpReq ( PTR cmpCxtId, /* Context Id for compression */ Buffer *mBuf, /* SDU to be compressed */ Buffer **opSdu /* Compressed SDU */ ) #else PUBLIC S16 pjLibCmpReq(cmpCxtId, mBuf, opSdu) PTR cmpCxtId; /* Context Id for compression */ Buffer *mBuf; /* SDU to be compressed */ Buffer **opSdu; /* Compressed SDU */ #endif { TRC3(pjLibCmpReq) RETVALUE(ROK); } /* end of pjLibCmpReq */ #ifdef ANSI PUBLIC S16 pjLibDecmpReq ( PTR cmpCxtId, /* Context Id for compression */ Buffer *mBuf, /* SDU to be decompressed */ Buffer **feedback, /* Decompressed SDU */ Buffer **opSdu /* ROHC feedback buffer */ ) #else PUBLIC S16 pjLibDecmpReq(cmpCxtId, mBuf, feedback, opSdu) PTR cmpCxtId; /* Context Id for compression */ Buffer *mBuf; /* SDU to be decompressed */ Buffer **feedback; /* Decompressed SDU */ Buffer **opSdu; /* ROHC feedback buffer */ #endif { TRC3(pjLibDecmpReq) RETVALUE(ROK); } /* end of pjLibDecmpReq */ #ifdef ANSI PUBLIC S16 pjLibCmpCloseReq ( PTR cmpCxtId /* ROHC Context to be closed */ ) #else PUBLIC S16 pjLibCmpCloseReq(cmpCxtId) PTR cmpCxtId; /* ROHC Context to be closed */ #endif { TRC3(pjLibCmpCloseReq) RETVALUE(ROK); } /* end of pjLibCmpCloseReq */ #ifdef ANSI PUBLIC S16 pjLibCmpResetReq ( PTR cmpCxtId /* ROHC Context to be closed */ ) #else PUBLIC S16 pjLibCmpResetReq(cmpCxtId) PTR cmpCxtId; /* ROHC Context to be closed */ #endif { TRC3(pjLibCmpResetReq) RETVALUE(ROK); } /* end of pjLibCmpResetReq */ #ifdef ANSI PUBLIC S16 pjLibCmpFbReq ( PTR cmpCxtId, /* ROHC Context to be closed */ Buffer *feedback /* Feed back */ ) #else PUBLIC S16 pjLibCmpFbReq(cmpCxtId, feedback) PTR cmpCxtId; /* ROHC Context to be closed */ Buffer *feedback; /* Feed back */ #endif { TRC3(pjLibCmpFbReq) RETVALUE(ROK); } /* end of pjLibCmpFbReq */ #endif /* PJ_CMP_ASYNC */ #ifdef ANSI PUBLIC S16 pjLibIntInitReq ( PjSecCxt secCxt, /* Context for Intg protection/verification */ PjIntInfo intInfo, /* Integrity Cfg Info */ Void **cxtId /* FD */ ) #else PUBLIC S16 pjLibIntInitReq(secCxt, intInfo, cxtId) PjSecCxt secCxt; /* Context for Intg protection/verification */ PjIntInfo intInfo; /* Integrity Cfg Info */ Void **cxtId; /* FD */ #endif { S16 ret = ROK; TRC3(pjLibIntInitReq) RETVALUE(ret); } /* end of pjLibIntInitReq */ #ifdef ANSI PUBLIC S16 pjLibCpInitReq ( PjSecCxt secCxt, /* Context for Intg protection/verificatino */ U8 algoType, /* Type of the algorithm */ U8 *cpKey, /* Control plane ciphering key */ Void **cxtId /* FD */ ) #else PUBLIC S16 pjLibCpInitReq(secCxt, algoType, cpKey, cxtId) PjSecCxt secCxt; /* Context for Intg protection/verificatino */ U8 algoType; /* Type of the algorithm */ U8 *cpKey; /* Control plane ciphering key */ Void **cxtId; /* FD */ #endif { S16 ret = ROK; TRC3(pjLibCpInitReq) RETVALUE(ret); } /* end of pjLibCpInitReq */ #ifdef ANSI PUBLIC S16 pjLibUpInitReq ( PjSecCxt secCxt, /* Context for Intg protection/verificatino */ U8 algoType, /* Type of the algorithm */ U8 *upKey, /* User plane ciphering key */ Void **cxtId /* FD */ ) #else PUBLIC S16 pjLibUpInitReq(secCxt, algoType, upKey, cxtId) PjSecCxt secCxt; /* Context for Intg protection/verificatino */ U8 algoType; /* Type of the algorithm */ U8 *upKey; /* User plane ciphering key */ Void **cxtId; /* FD */ #endif { TRC3(pjLibUpInitReq) #ifdef INTEL_SPACC_IV_OPTIMIZATION if(PJ_SEC_DIR_DL == secCxt.dir) { pjMsNSpaccIVPrepStreamIdForDl(cxtId); } else { pjMsNSpaccIVPrepStreamIdForUl(cxtId); } #endif RETVALUE(ROK); } /* end of pjLibUpInitReq */ #ifdef ANSI PUBLIC S16 PjLibObdCpInitReq ( PjSec *secInp ) #else PUBLIC S16 PjLibObdCpInitReq(*secInp) PjSec *secInp; #endif { TRC3(PjLibObdCpInitReq) RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdUpInitReq ( PjSec *secInp ) #else PUBLIC S16 PjLibObdUpInitReq(*secInp) PjSec *secInp #endif { TRC3(PjLibObdUpInitReq) RETVALUE(ROK); } #ifdef TENB_AS_SECURITY /** * * @brief Extracting gCb, rbCb, txEnt from SPAcc Mapping Information. * * * @b Description: This function extracts gCb, rbCb, txEnt from SPAcc mapping * info which is passed as one of the input params. * * * @param[in] spaccInfo : Information required to map o/p PDU from SPACc to * PDCP TxEnt. * @param[in] gCb : PDCP Control Block * @param[in] pjRbCb : PDCP rbCb * @param[in] txEnt : PDCP TxEnt * * * @return Void */ #ifdef ANSI PRIVATE S16 pjExtractTxEntRbCbUsingSpaccMappingInfo ( PjMsSPACCOutputMapInfo *spaccInfo, PjCb **gCb, PjDlRbCb **pjRbCb, PjTxEnt **txEnt ) #else PRIVATE S16 pjExtractTxEntRbCbUsingSpaccMappingInfo(spaccInfo, gCb, pjRbCb, txEnt) PjMsSPACCOutputMapInfo *spaccInfo; PjCb **gCb; PjDlRbCb **pjRbCb; PjTxEnt **txEnt; #endif { PjDlUeCb *ueCb = NULLP; *gCb = PJ_GET_PJCB(spaccInfo->pdcpInstance); pjDbmFetchDlUeCb(*gCb, spaccInfo->pdcpId.ueId,spaccInfo->pdcpId.cellId, &ueCb); if(ueCb == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccInfo->pdcpId.ueId,"UECB not found !!!! "); RETVALUE(RFAILED); } pjDbmFetchPjDlRbCb(ueCb, spaccInfo->pdcpId.rbId, spaccInfo->pdcpId.rbType, pjRbCb); if(*pjRbCb == NULLP) { RLOG_ARG2(L_ERROR, DBG_UEID,spaccInfo->pdcpId.ueId, "CellId[%u]:RbId[%d] not found", spaccInfo->pdcpId.cellId, spaccInfo->pdcpId.rbId); RETVALUE(RFAILED); } *txEnt = (PjTxEnt *)pjDbmGetTxEnt(*gCb, &((*pjRbCb)->dlCb.txBuf), spaccInfo->count); if(*txEnt == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccInfo->pdcpId.ueId,"!!!!rxEnt is NULL!!!!"); RETVALUE(RFAILED); } RETVALUE(ROK); } /** * * @brief Handler for Processing Ciphered PDU's from SPAcc. * * * @b Description: This function processes and extracts the required control * blocks for the ciphered PDU and calls the function for to be processed * further. * * @param[in] spaccOpInfo : Information required to process PDU * @param[in] opSdu : Ciphered buffer * * @return S16 * -# ROK * -# RFAILED */ #ifdef ANSI PUBLIC S16 pjProcCiphPdu ( Buffer *opSdu, PjMsSPACCOutputMapInfo *spaccOpInfo ) #else PUBLIC S16 pjProcCiphPdu(opSdu, spaccOpInfo) Buffer *opSdu; PjMsSPACCOutputMapInfo *spaccOpInfo; #endif { U32 ret; PjCb *gCb = NULLP; PjDlRbCb *pjRbCb = NULLP; PjTxEnt *txEnt = NULLP; /* Extract gCb, rbCb and txEnt for further processing */ ret = pjExtractTxEntRbCbUsingSpaccMappingInfo(spaccOpInfo, &gCb, &pjRbCb, &txEnt); if(ret != ROK) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId, "pjExtractTxEntRbCbUsingSpaccMappingInfo: returned failure "); PJ_FREE_BUF(opSdu); RETVALUE(RFAILED); } else { if(pjRbCb->rbType == PJ_SRB) { if(txEnt->pdu != NULLP) { PJ_FREE_BUF(txEnt->pdu); } } /* In case of Reestablish/HO , dropping the ciphered packets. These packets * are processed again when events EVTCPJDATRESUMEREQ/EVTPJUDATFWDREQ are * received from upper layer */ if((pjRbCb->ueCb->libInfo.state != PJ_STATE_NORMAL) && (pjRbCb->rbType != PJ_SRB)) { RLOG_ARG0(L_INFO,DBG_UEID,spaccOpInfo->pdcpId.ueId, "Dropping the packet in reestablish state "); PJ_FREE_BUF(opSdu); RETVALUE(RFAILED); } txEnt->pdu = opSdu; /* Call to deliver PDU to RLC */ ret = pjDlmDeliverPdu(gCb, pjRbCb, txEnt); if(ret != ROK) { RETVALUE(RFAILED); RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId, "pjProcCiphPdu: pjDlmDeliverPdu failed !!!!"); } } RETVALUE(ROK); } /** * * @brief Handler for Ciphering failure * * * @b Description: This function handles the steps to be taken on failure of * ciphering * * * @param[in] procInfo : Information required to process PDU * * * @return Void */ #ifdef ANSI PUBLIC S16 pjHndlCiphFail ( PjMsSPACCOutputMapInfo *spaccInfo ) #else PUBLIC S16 pjHndlCiphFail(spaccInfo) PjMsSPACCOutputMapInfo *spaccInfo; #endif { PjCb *gCb = NULLP; PjDlRbCb *pjRbCb = NULLP; PjTxEnt *txEnt = NULLP; /* Extract gCb, rbCb and txEnt for further processing */ if((pjExtractTxEntRbCbUsingSpaccMappingInfo(spaccInfo, &gCb, &pjRbCb, &txEnt)) != ROK) { RETVALUE(RFAILED); } else { PJ_UPD_DL_VAR(gCb, pjRbCb, txEnt->count); if ( pjRbCb->dlCb.cfmReqd) { PJ_SND_CFM(gCb,pjRbCb, txEnt, PJU_CIPHER_FAILED); } else { pjDbmDelTxEnt(gCb, &(pjRbCb->dlCb.txBuf), txEnt->count); } gCb->pjGenSts.numCiphFails++; } RETVALUE(ROK); } #ifdef SPACC_THREADED PRIVATE U32 globPollCount = 50; /** * * @brief Handler for SPACC Reset * * * @b Description: This is triggeres when the processing of batch at SPACC * is delayed * * * * @return Void */ #ifdef ANSI PRIVATE Void pjMsSpaccReset(Void) #else PRIVATE Void pjMsSpaccReset() #endif { U32 ret=ROK; U32 jobNum=1; Buffer *opSdu=NULLP; PjMsSPACCOutputMapInfo spaccInfo; RLOG0(L_DEBUG,"Restarting SPACC"); // PjLibObdDlCloseReq(); pjMsSPAccRestart(); RLOG0(L_DEBUG,"SPACC Restarted"); for(;;) { ret = pjMsSpaccFetchDlPduInfo(&spaccInfo, &opSdu, jobNum, RFAILED); if(ret == ROKDNA) { RLOG1(L_ERROR, "NUM DL jobs at failure:%ld",jobNum); break; } pjHndlCiphFail(&spaccInfo); jobNum++; } pjMsSetQFreeDl(); jobNum = 1; for(;;) { ret = pjMsSpaccFetchUlPduInfo(&spaccInfo, &opSdu, jobNum, RFAILED); if(ret == ROKDNA) { RLOG1(L_ERROR,"NUM UL jobs at failure:%ld",jobNum); break; } pjHdlDecipherFailure(&spaccInfo); jobNum++; } pjMsSetQFreeUl(); //RLOG0(L_DEBUG, "pjMsSetQFreeUl done"); //RLOG0(L_DEBUG, "Reopening SPACC DL"); //pjMsSpaccHdlDlfdOpenReq(); // RLOG0(L_DEBUG, "Reopened SPACC DL"); RETVOID; } #endif /** * * @brief Handler for NRT TTI Indication to PDCP for DL batch processing * * * @b Description: Triggers batch processing to SPAcc. Fetches the ciphered PDUs * from SPAcc and triggers sending the PDU's RLC. * * * * @return Void */ #ifdef ANSI PUBLIC Void PjDlSpaccTrigger(Void) #else PUBLIC Void PjDlSpaccTrigger() #endif { U32 ret=ROK; U32 jobNum=1; Buffer *opSdu=NULLP; PjMsSPACCOutputMapInfo spaccInfo; #ifdef SPACC_NONBLOCKING static U32 dlPollCount = 0; S32 pollop; pollop = pjMsSpaccPollDlQueue(); if(PJ_MS_POLL_NOT_REQUIRED == pollop) { ret = pjMsSpaccBatchAndCipherPackets(); // pjMsSpaccSetResetDlQueueFree(0); /* Set to FALSE */ } else { if(PJ_MS_POLL_COMPLETE == pollop) { dlPollCount = 0; /* Process the o/p from SPAcc */ pjMsSpaccProcessDlBatchOutput(); // pjMsSpaccSetResetDlQueueFree(1); /* Set to TRUE */ /* Send next set of data to SPAcc after processing */ ret = pjMsSpaccBatchAndCipherPackets(); // pjMsSpaccSetResetDlQueueFree(0); /* Set to FALSE */ } else { #ifdef SPACC_THREADED /*Workaround for the SPACC issue of "unexpected job"*/ dlPollCount++; if(dlPollCount >= globPollCount) { U32 numUnexpJobs = 0; dlPollCount = 0; numUnexpJobs = pjMsCheckUnExpJobs(); if(numUnexpJobs != 0) { pjMsSpaccReset(); } } #endif /* Do nothing as SPAcc is not done with processing */ } } /* This condition is executed when SPAcc returns failure for whatever * reason.So once failure is returned, we fetch all the PDU's we had sent * for ciphering and process them as failure */ if(ret != ROK) { RLOG0(L_ERROR,"Error leg in DL Spacc trigger hit "); for(;;) { ret = pjMsSpaccFetchDlPduInfo(&spaccInfo, &opSdu, jobNum, ret); if(ret == ROKDNA) { break; } pjHndlCiphFail(&spaccInfo); jobNum++; } } #else ret = pjMsSpaccBatchAndCipherPackets(); /* This condition is executed when SPAcc returns failure for whatever * reason.So once failure is returned, we fetch all the PDU's we had sent * for ciphering and process them as failure */ if(ret != ROK) { for(;;) { ret = pjMsSpaccFetchDlPduInfo(&spaccInfo, &opSdu, jobNum, ret); if(ret == ROKDNA) { break; } pjHndlCiphFail(&spaccInfo); RETVOID; } } pjMsSpaccProcessDlBatchOutput(); #endif RETVOID; } /** * * @brief Handler for processing of Decipher Failure * * * @b Description: This function handles decipher failures by deleting the * RxEnt, send STA_IND to upper layer and updation of general statistics. * * * @param[in] spaccOpInfo : Information required to process PDU * * * @return Void */ #ifdef ANSI PUBLIC S16 pjHdlDecipherFailure ( PjMsSPACCOutputMapInfo *spaccOpInfo ) #else PUBLIC S16 pjHdlDecipherFailure() PjMsSPACCOutputMapInfo *spaccOpInfo; #endif { PjCb *gCb; PjUlUeCb *ueCb = NULLP; PjUlRbCb *pjRbCb = NULLP; PjRxEnt *rxEnt = NULLP; gCb = PJ_GET_PJCB(spaccOpInfo->pdcpInstance); pjDbmFetchUlUeCb(gCb, spaccOpInfo->pdcpId.ueId, spaccOpInfo->pdcpId.cellId, &ueCb); if(ueCb == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"UECB not found !!!! "); RETVALUE(RFAILED); } /* RLOG_ARG4(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId, * "At PDCP: : RBTYPE:%d, CELLID:%d, RBID:%d, COUNT:%d", spaccOpInfo->pdcpId.rbType, spaccOpInfo->pdcpId.cellId, spaccOpInfo->pdcpId.rbId, spaccOpInfo->count);*/ /* RLOG_ARG2(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId, "SNLEN:%d, numjobs %d "spaccOpInfo->pdcpId.ueId, \ spaccOpInfo->snLen, numJobs); */ pjDbmFetchPjUlRbCb(ueCb, spaccOpInfo->pdcpId.rbId, spaccOpInfo->pdcpId.rbType, &pjRbCb); if(pjRbCb == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"RBCB not found !!!!"); RETVALUE(RFAILED); } rxEnt = (PjRxEnt *)pjDbmGetRxEnt(gCb, &(pjRbCb->ulCb.recBuf), spaccOpInfo->count); if(rxEnt == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"!!!!rxEnt is NULL!!!!"); RETVALUE(RFAILED); } PJ_SND_PJU_STA_IND(gCb,pjRbCb, rxEnt); pjDbmDelRxEnt(gCb, &(pjRbCb->ulCb.recBuf), rxEnt->count); PJ_STS_INC_GEN_CNT(gCb,numDeciphFails); RETVALUE(ROK); } /** * * @brief Handler for processing deciphered PDU * * * @b Description: This function processes and sends the ciphered PDU to RLC * * * @param[in] spaccOpInfo : Information required to process PDU * @param[in] opSdu : Deciphered buffer * * * @return S16 * -# ROK * -# RFAILED */ #ifdef ANSI PUBLIC S16 pjProcDeCipherPdu ( PjMsSPACCOutputMapInfo *spaccOpInfo, Buffer *opSdu ) #else PUBLIC S16 pjProcDeCipherPdu() PjMsSPACCOutputMapInfo *spaccOpInfo; Buffer *opSdu; #endif { U32 ret; PjCb *gCb; PjUlUeCb *ueCb = NULLP; PjUlRbCb *pjRbCb = NULLP; PjRxEnt *rxEnt = NULLP; gCb = PJ_GET_PJCB(spaccOpInfo->pdcpInstance); pjDbmFetchUlUeCb(gCb, spaccOpInfo->pdcpId.ueId, spaccOpInfo->pdcpId.cellId, &ueCb); if(ueCb == NULLP) { RLOG_ARG0(L_WARNING,DBG_UEID,spaccOpInfo->pdcpId.ueId,"UECB not found !!!! "); RETVALUE(RFAILED); } /* RLOG_ARG4(L_ERROR, DBG_UEID,spaccOpInfo->pdcpId.ueId, "UDAY: At PDCP: : RBTYPE:%d, CELLID:%d, RBID:%d, COUNT:%d", spaccOpInfo->pdcpId.rbType, spaccOpInfo->pdcpId.cellId, spaccOpInfo->pdcpId.rbId, spaccOpInfo->count,);*/ /* RLOG_ARG2(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId, " SNLEN:%d, numjobs %d ",spaccOpInfo->snLen, numJobs); */ pjDbmFetchPjUlRbCb(ueCb, spaccOpInfo->pdcpId.rbId, spaccOpInfo->pdcpId.rbType, &pjRbCb); if(pjRbCb == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"RBCB not found !!!! "); RETVALUE(RFAILED); } rxEnt = (PjRxEnt *)pjDbmGetRxEnt(gCb, &(pjRbCb->ulCb.recBuf), spaccOpInfo->count); /* To be used for debugging. Will be removed once verified */ if(rxEnt == NULLP) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"!!!!rxEnt is NULL!!!!"); RETVALUE(RFAILED); } /*Free the source buffer here*/ if(rxEnt->mBuf) { PJ_FREE_BUF(rxEnt->mBuf); } rxEnt->mBuf = opSdu; if(pjRbCb->rbType == PJ_DRB) { rxEnt->state = PJ_RDY_TO_DCOMP; ret = pjUlmHdlDeCmp(gCb, pjRbCb, rxEnt); } else { rxEnt->state = PJ_RDY_TO_INTVER; ret = pjUlmHdlIntVer(gCb, pjRbCb, rxEnt); } if(rxEnt->dupEntry == TRUE) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId," 3. Deleting RxEnt"); /* duplicate entry */ PJ_FREE_BUF(rxEnt->mBuf); PJ_FREE(gCb,rxEnt, sizeof(PjRxEnt)); } else if(rxEnt->discFlag == TRUE) { RLOG_ARG0(L_ERROR,DBG_UEID,spaccOpInfo->pdcpId.ueId,"4. Deleting RxEnt"); /* duplicate entry */ pjDbmDelRxEnt(gCb, &pjRbCb->ulCb.recBuf, rxEnt->count); } RETVALUE(ROK); } /** * * @brief Handler for NRT TTI Indication to PDCP for UL batch processing * * * @b Description: Triggers batch processing of packets lined up for * deciphering. Fetches the ciphered PDUs * and triggers further processing at PDCP. * * * * @return Void */ #ifdef ANSI PUBLIC Void PjUlSpaccTrigger(Void) #else PUBLIC Void PjUlSpaccTrigger(Void) #endif { U32 ret=ROK; U32 jobNum=1; Buffer *opSdu=NULLP; PjMsSPACCOutputMapInfo spaccInfo; #ifdef SPACC_NONBLOCKING static U32 ulPollCount = 0; S32 pollop; pollop = pjMsSpaccPollUlQueue(); if(PJ_MS_POLL_NOT_REQUIRED == pollop) { ret = pjMsSpaccBatchAndDeCipherPackets(); } else { if(PJ_MS_POLL_COMPLETE == pollop) { ulPollCount = 0; /* Process the o/p from SPAcc */ pjMsSpaccProcessUlBatchOutput(); pjMsSpaccSetResetUlQueueFree(1); /* Set to TRUE */ /* Send next set of data to SPAcc after processing */ ret = pjMsSpaccBatchAndDeCipherPackets(); } else { #ifdef SPACC_THREADED /*SPACC Workaround when SPACC is not able to complete BATCH*/ ulPollCount++; if(ulPollCount >= globPollCount) { U32 numUnexpJobs = 0; ulPollCount = 0; numUnexpJobs = pjMsCheckUnExpJobs(); if(numUnexpJobs != 0) { pjMsSpaccReset(); } } #endif } } /* This condition is executed when SPAcc returns failure for whatever * reason.So once failure is returned, we fetch all the PDU's we had sent * for Deciphering and process them as failure */ if(ret != ROK) { RLOG0(L_ERROR, "Error leg in uL Spacc trigger hit "); for(;;) { ret = pjMsSpaccFetchUlPduInfo(&spaccInfo, &opSdu, jobNum, ret); if(ret == ROKDNA) { break; } pjHdlDecipherFailure(&spaccInfo); jobNum++; } } #else ret = pjMsSpaccBatchAndDeCipherPackets(); /* This condition is executed when SPAcc returns failure for whatever * reason.So once failure is returned, we fetch all the PDU's we had sent * for Deciphering and process them as failure */ if(ret != ROK) { for(;;) { ret = pjMsSpaccFetchUlPduInfo(&spaccInfo, &opSdu, jobNum, ret); if(ret == ROKDNA) { break; } pjHdlDecipherFailure(&spaccInfo); } RETVOID; } pjMsSpaccProcessUlBatchOutput(); #endif RETVOID; } /** *@brief * This function calls the function which interfaces with SPAcc * for opening of the fd. Also, it initializes the SPAcc DL Queues. * *@inparam[in] gCb PDCP Instance Control Block *@return S16 */ #ifdef ANSI PUBLIC S16 PjLibObdDlInitReq ( PjCb *gCb ) #else PUBLIC S16 PjLibObdDlInitReq(gCb) PjCb *gCb; #endif { TRC3(PjLibObdDlInitReq) #ifdef INTEL_NATIVE_SPACC S32 ret = RFAILED; ret = pjMsSpaccRegIccDlHndl(); if(ret != ROK) { printf("Registration of ICC DL handle has failed\n"); RETVALUE(ret); } printf("Registration of ICC DL handle has succeeded\n"); ret = pjMsSpaccThreadActivation(appContext.hUAII_Dl); if(ret != 0) { printf("Spacc thread activation has failed\n"); RETVALUE(ret); } printf("Spacc thread activation is done again\n"); /* Init Mem region and Pool */ pjMsSPAccInitDlMemRegionPool(gCb->init.region, gCb->init.pool); #ifdef INTEL_SPACC_IV_OPTIMIZATION pjMsNSpaccDlInitForSpaccIV(gCb); #endif #else /*Call to open file descriptors for interfacing with SPACC*/ if(pjMsSpaccHdlDlfdOpenReq() != ROK) { RETVALUE(RFAILED); } /*Call to initialise the DL/UL SPAcc queues*/ pjMsSPAccInitDlQue(); /* Init Mem region and Pool */ pjMsSPAccInitDlMemRegionPool(gCb->init.region, gCb->init.pool); #endif RETVALUE(ROK); } /** *@brief * This function calls the function which interfaces with SPAcc * for opening of the fd. Also, it initializes the SPAcc UL Queues. * *@inparam[in] gCb PDCP Instance Control Block *@return S16 * */ #ifdef ANSI PUBLIC S16 PjLibObdUlInitReq ( PjCb *gCb ) #else PUBLIC S16 PjLibObdUlInitReq(gCb) PjCb *gCb; #endif { TRC3(PjLibObdUlInitReq) #ifdef INTEL_NATIVE_SPACC S32 ret = RFAILED; ret = pjMsSpaccRegIccUlHndl(); if(ret != ROK) { printf("Registration of ICC UL handle has failed\n"); RETVALUE(ret); } printf("Registration of ICC UL handle has succeeded\n"); ret = pjMsSpaccThreadActivation(appContext.hUAII_Ul); if(ret != 0) { printf("Spacc thread activation has failed\n"); RETVALUE(ret); } printf("Spacc thread activation is done\n"); /* Init Mem region and Pool */ pjMsSPAccInitUlMemRegionPool(gCb->init.region, gCb->init.pool); #ifdef INTEL_SPACC_IV_OPTIMIZATION pjMsNSpaccUlInitForSpaccIV(gCb); #endif #else /*Call to open file descriptors for interfacing with SPACC*/ if(pjMsSpaccHdlUlfdOpenReq() != ROK) { RETVALUE(RFAILED); } /*Call to initialise the UL SPAcc queues*/ pjMsSPAccInitUlQue(); /* Init Mem region and Pool */ pjMsSPAccInitUlMemRegionPool(gCb->init.region, gCb->init.pool); #endif RETVALUE(ROK); } /** * * @brief Handler for invoking key derivation function for KeNB*. This is used * for Handover cases. * * * @Description: When the eNB decides to perform an intra-eNB handover it * shall derive KeNB* using target PCI, its frequency EARFCN-DL, and * either NH or the current KeNB. * * @input: gCb - Control Block * kenbInf - Input structure for KeNB* derivation. * kdfCfm - Output filled into this structure after derivation. * * @return S16 */ #ifdef ANSI PUBLIC S16 pjLibObdPrcKenbStarCfg ( PjCb *gCb, CpjKenbStarInfo* kenbInf, CpjKenbStarCfmInfo *kdfCfm ) #else PUBLIC S16 pjLibObdPrcKenbStarCfg(gCb, kenbInf, kdfCfm) PjCb *gCb; CpjKenbStarInfo* kenbInf; CpjKenbStarCfmInfo *kdfCfm; #endif { PjMsSecInfo *pSecInfo; U32 ret=ROK; TRC2(pjLibObdPrcKenbStarCfg) PJ_ALLOC(gCb, pSecInfo , sizeof(PjMsSecInfo)); if(pSecInfo == NULLP) { RLOG1(L_ERROR, "YsMsUlmPrcKenbStarCfg failed line %d ", __LINE__); RETVALUE(RFAILED); } cmMemcpy(pSecInfo->hash_key, kenbInf->secKey, CPJ_SEC_KEY_LEN); /* Building the String S = FC || P0 || L0 || P1 || L1 */ /*Values are initialized as per section A7 33.401*/ pSecInfo->strS[0] = 0x13; pSecInfo->strS[3] = 0x00; pSecInfo->strS[4] = 0x02; pSecInfo->strS[7] = 0x00; pSecInfo->strS[8] = 0x02; RLOG2(L_DEBUG,"Value of Cellid, dl Freq is %d %d ", kenbInf->physCellId, kenbInf->dlCarrFreq); /******************************************* *************kENB* from kENB************* *******************************************/ /*PCI*/ pSecInfo->strS[1] = kenbInf->physCellId >> 8; pSecInfo->strS[2] = (U8)kenbInf->physCellId; /*DL frequency*/ pSecInfo->strS[5] = kenbInf->dlCarrFreq >> 8; pSecInfo->strS[6] = (U8)kenbInf->dlCarrFreq; pSecInfo->strSlen = 9; if((pjSendToKeyDeriveFunc(pSecInfo, kdfCfm->secKey)) != ROK) { RLOG0(L_ERROR, "In pjLibObdPrcKenbStarCfg: pjMsKDF failed"); ret = RFAILED; }/*End of if(ret!=ROK)*/ PJ_FREE(gCb, pSecInfo, sizeof(PjMsSecInfo)); RETVALUE(ret); }/*End of function*/ /** * * @brief Handler for invoking key derivation function for KeNB. KeNB is Key * derivation funtion. This is normal Ciphering/Integrity Key derivation at * eNB. * * * @Description: For Security to be enabled, Integrity and Ciphering keys need * to be derived. These are applied on SRB/DRB data and the Ciphered/Integrity * protected PDU are sent to UE. * * @input: gCb - Control Block * kenbInf - Input structure for KeNB* derivation. * kdfCfm - Output filled into this structure after derivation. * * @return S16 */ #ifdef ANSI PUBLIC S16 pjLibObdPrcKenbCfg ( PjCb *gCb, CpjAsKeyInfo* kenbInf, CpjAskeyCfmInfo *kdfCfm ) #else PUBLIC S16 pjLibObdPrcKenbCfg(kenbInf) PjCb *gCb; CpjAsKeyInfo* kenbInf; CpjAskeyCfmInfo *kdfCfm; #endif { S16 ret; PjMsSecInfo *pSecInfo; TRC2(pjLibObdPrcKenbCfg) ret = ROK; PJ_ALLOC(gCb, pSecInfo, sizeof(PjMsSecInfo)); if(pSecInfo == NULLP) { RLOG1(L_ERROR, "YsMsUlmPrcKenbCfg failed line %d ", __LINE__); RETVALUE(RFAILED); } cmMemcpy(pSecInfo->hash_key, kenbInf->secKey, CPJ_SEC_KEY_LEN); /* Building the String S = FC || P0 || L0 || P1 || L1 */ /*Values are initialized as per section A7 33.401*/ pSecInfo->strS[0] = 0x15; pSecInfo->strS[2] = 0x00; pSecInfo->strS[3] = 0x01; pSecInfo->strS[5] = 0x00; pSecInfo->strS[6] = 0x01; pSecInfo->strSlen = 7; /******************************************* *************CP Ciphering key************* *******************************************/ pSecInfo->strS[1] = 0x3; pSecInfo->strS[4] = kenbInf->ciphAlgoType; ret = pjSendToKeyDeriveFunc(pSecInfo, kdfCfm->cpCiphKey); if(ret!=ROK) { RLOG0(L_ERROR, "Control Plane Cipher Key derivation failed"); PJ_FREE(gCb, pSecInfo, sizeof(PjMsSecInfo)); RETVALUE(RFAILED); }/*End of if(ret!=ROK)*/ /******************************************* *************UP Ciphering key************* *******************************************/ pSecInfo->strS[1] = 0x5; pSecInfo->strS[4] = kenbInf->ciphAlgoType; ret = pjSendToKeyDeriveFunc(pSecInfo, kdfCfm->upCiphKey); if(ret!=ROK) { RLOG0(L_ERROR, "User Plane Cipher Key derivation failed"); PJ_FREE(gCb, pSecInfo, sizeof(PjMsSecInfo)); RETVALUE(RFAILED); }/*End of if(ret!=ROK)*/ RLOG0(L_DEBUG, "Ciphering Key (UP) Derived"); /******************************************* ************RRC Integrity key************* *******************************************/ pSecInfo->strS[1] = 0x4; pSecInfo->strS[4] = kenbInf->intgAlgoType; ret = pjSendToKeyDeriveFunc(pSecInfo, kdfCfm->intKey); if(ret!=ROK) { RLOG0(L_ERROR, "Integrity Key derivation failed"); PJ_FREE(gCb, pSecInfo, sizeof(PjMsSecInfo)); RETVALUE(RFAILED); }/*End of if(ret!=ROK)*/ RLOG0(L_DEBUG, "Integrity Key Derived"); PJ_FREE(gCb, pSecInfo, sizeof(PjMsSecInfo)); RETVALUE(ROK); }/*End of function*/ /** * * @brief * * Provides input params like Keys, RbId, direction which would be used * as input for creation of SPAcc i/p structure.. * * @b Description: * * This function sends Intergrity protection request with elevant input parameters. * * @param[in] pjRbCb PDCP RbCb * @param[in] intCxtId Input parameters for integrity * @param[in] mBuf SDU to be compressed * @param[out] libTrans Input to integrity algo (RbId, Count, Direction) * * @return S16 * -# ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdIntProtReq ( PjLibTrans *libTrans, Buffer **mBuf ) #else PUBLIC S16 PjLibObdIntProtReq(libTrans, mBuf) PjLibTrans *libTrans; Buffer **mBuf; #endif { U32 ret = ROK; U32 dummyMacI =0 ; TRC3(PjLibObdIntProtReq) if(libTrans->intAlgoType == PJ_SPACC_EIA1) { ret = pjMsSpaccIntegProtPkt(libTrans, mBuf); } else if (libTrans->intAlgoType == PJ_SPACC_EIA2) { ret = pjMsSpaccAesIntegProtPkt(libTrans, mBuf); } else if (libTrans->intAlgoType == PJ_SPACC_EIA3) { ret = pjMsSpaccIntegProtPkt(libTrans, mBuf); } else { /* NULL Algorithm */ PJ_PACK_MACI(*mBuf, dummyMacI); } RETVALUE(ret); } /** * * @brief * * Handler for redirecing Integration request to SPAcc module. * * @b Description: * * This function sends Intergrity verification request along with relevant input parameters. * * @param[in] PjCb PDCP Cb * @param[in] PTR Handle for Integrity verification (handle opened during spacc_dev_open) * @param[in] PjLibTrans Input parameters for integrity * @param[in] mBuf SDU to be compressed * @param[out] macI MAC-I * * @return S16 * -# ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdIntVerReq ( PjLibTrans *libTrans, Buffer *mBuf, U32 macI ) #else PUBLIC S16 PjLibObdIntVerReq(libTrans, mBuf, macI) PjLibTrans *libTrans; Buffer *mBuf; U32 macI; #endif { U32 ret = ROK; TRC3(PjLibObdIntVerReq) if(libTrans->intAlgoType != 0) { ret = pjMsSpaccIntegVerifyPkt(libTrans, &mBuf, macI); } else { RLOG_ARG0(L_ERROR,DBG_UEID,libTrans->ueId,"Integrity protection Algo type is == 0 "); } RETVALUE(ret); } /** *@brief * This function calls the function which interfaces with SPAcc * for closing the DL fd. * *@return S16 * -ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdDlCloseReq(Void) #else PUBLIC S16 PjLibObdDlCloseReq(Void) #endif { TRC3(PjLibObdDlCloseReq) pjSpaccDeInitCiphQ(); pjMsSPAccDlfdCloseReq(); RETVALUE(ROK); } /** *@brief * This function calls the function which interfaces with SPAcc * for closing the UL fd. * *@return S16 * -ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdUlCloseReq(Void) #else PUBLIC S16 PjLibObdUlCloseReq(Void) #endif { TRC3(PjLibObdUlCloseReq) pjSpaccDeInitDeCipherQ(); pjMsSPAccUlfdCloseReq(); RETVALUE(ROK); } /** * * @brief * * Handler for redirecing ciphering request to SPAcc Module. * * @b Description: * * This function sends ciphering protection request along with relevant input parameters. * * @param[in] PjCb PDCP Cb * @param[in] PjLibTrans libTrans( Input parameters for deciphering ) * @param[in] mBuf Data to be deciphered * @param[in] opSdu Deciphered SDU * @param[in] cxtId Handle for ciphering either for User/Control plane. * * @return S16 * -# ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdCipherReq ( PjLibTrans *libTrans, Buffer *mBuf, Buffer **opSdu ) #else PUBLIC S16 PjLibObdCipherReq(libTrans, mBuf, opSdu) PjLibTrans *libTrans; Buffer *mBuf; Buffer **opSdu; #endif { U32 ret = ROK; TRC3(PjLibObdCipherReq) ret = pjSendToCipher(libTrans, mBuf); RETVALUE(ret); } #ifdef FLAT_BUFFER_OPT /** * * @brief * * Handler for redirecing ciphering request to SPAcc Module. * * @b Description: * * This function sends ciphering protection request along with relevant input parameters. * * @param[in] PjCb PDCP Cb * @param[in] PjLibTrans libTrans( Input parameters for deciphering ) * @param[in] mBuf Flat Buffer to be deciphered * @param[in] opSdu Deciphered SDU * @param[in] cxtId Handle for ciphering either for User/Control plane. * * @return S16 * -# ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdCipherReqFB ( PjLibTrans *libTrans, FlatBuffer *mBuf, Buffer **opSdu ) #else PUBLIC S16 PjLibObdCipherReqFB(libTrans, mBuf, opSdu) PjLibTrans *libTrans; FlatBuffer *mBuf; Buffer **opSdu; #endif { U32 ret = ROK; TRC3(PjLibObdCipherReqFB) ret = pjSendToCipherFB(libTrans, mBuf); RETVALUE(ret); } #endif /** * * @brief * * Handler for redirecing deciphering request to SPAcc module. * * @b Description: * * This function sends deciphering request along with relevant input parameters. * * @param[in] PjCb PDCP Cb * @param[in] PTR Handle for Deciphering (stored during spacc_dev_open) * @param[in] PjLibTrans Input parameters for deciphering * @param[in] mBuf Data to be deciphered * @param[in] opSdu Deciphered SDU * * @return S16 * -# ROK * */ #ifdef ANSI PUBLIC S16 PjLibObdDecipherReq ( PjLibTrans *libTrans, Buffer *mBuf, Buffer **opSdu ) #else PUBLIC S16 PjLibObdDecipherReq(libTrans, mBuf, opSdu) PjLibTrans *libTrans; Buffer *mBuf; Buffer **opSdu; #endif { U32 ret = ROK; TRC3(PjLibObdDecipherReq) ret = pjSendToDeCipher(libTrans, mBuf); RETVALUE(ret); } #else #ifdef ANSI PUBLIC S16 pjLibObdPrcKenbCfg ( PjCb *gCb, CpjAsKeyInfo* kenbInf, CpjAskeyCfmInfo *kdfCfm ) #else PUBLIC S16 pjLibObdPrcKenbCfg(gCb, kenbInf, kdfCfm) PjCb *gCb; CpjAsKeyInfo* kenbInf; CpjAskeyCfmInfo *kdfCfm; #endif { TRC2(pjLibObdPrcKenbCfg); RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 pjLibObdPrcKenbStarCfg ( PjCb *gCb, CpjKenbStarInfo* kenbInf, CpjKenbStarCfmInfo *kdfCfm ) #else PUBLIC S16 pjLibObdPrcKenbStarCfg(gCb, kenbInf, kdfCfm) PjCb *gCb; CpjKenbStarInfo* kenbInf; CpjKenbStarCfmInfo *kdfCfm; #endif { TRC2(pjLibObdPrcKenbStarCfg); RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 pjLibDecipherReq ( PTR intCxtId, /* Context Id for compression */ PjSecInp secInp, /* Input for Deciphering */ Buffer *mBuf, /* SDU to be deciphered */ Buffer **opSdu /* deciphered SDU */ ) #else PUBLIC S16 pjLibDecipherReq(intCxtId, secInp, mBuf, opSdu) PTR intCxtId; /* Context Id for Deciphering */ PjSecInp secInp; /* Input for Deciphering */ Buffer *mBuf; /* SDU to be Deciphering */ Buffer **opSdu; /* Deciphering SDU */ #endif { TRC3(pjLibDecipherReq) #ifdef LTE_PAL_ENB *opSdu = mBuf; #endif RETVALUE(ROK); } /* end of pjLibDecipherReq */ #ifdef ANSI PUBLIC S16 pjLibIntVerReq ( PTR intCxtId, /* Context Id for compression */ PjSecInp secInp, /* Input for Integrity protection */ Buffer *mBuf, /* SDU to be compressed */ U32 macI, /* Message authentication code for the SDU */ Status *status /* Status of the Integrity verification */ ) #else PUBLIC S16 pjLibIntVerReq(intCxtId, secInp, mBuf, macI, status) PTR intCxtId; /* Context Id for compression */ PjSecInp secInp; /* Input for Integrity protection */ Buffer *mBuf; /* SDU to be compressed */ U32 macI; /* Message authentication code for the SDU */ Status *status; /* Status of the Integrity verification */ #endif { TRC3(pjLibIntVerReq) RETVALUE(ROK); } /* end of pjLibIntVerReq */ #ifdef ANSI PUBLIC S16 PjLibObdIntProtReq ( PjLibTrans *libTrans, Buffer **mBuf ) #else PUBLIC S16 PjLibObdIntProtReq(libTrans, mBuf) PjLibTrans *libTrans; Buffer **mBuf; #endif { #ifdef LTE_PAL_ENB Buffer *mBuf1; #endif TRC3(PjLibObdIntProtReq); #ifdef LTE_PAL_ENB SAddMsgRef(*mBuf, 0,0, &mBuf1); *mBuf = mBuf1; #endif RETVALUE(ROK); } #ifdef ANSI PUBLIC S16 PjLibObdCipherReq ( PjLibTrans *libTrans, Buffer *mBuf, Buffer **opSdu ) #else PUBLIC S16 PjLibObdCipherReq(libTrans, mBuf, opSdu) PjLibTrans *libTrans; Buffer *mBuf; Buffer **opSdu; #endif { TRC3(PjLibObdCipherReq); #ifdef LTE_PAL_ENB SAddMsgRef(mBuf, 0,0, opSdu); #endif RETVALUE(ROK); } #endif #ifdef TENB_T2K3K_SPECIFIC_CHANGES #define PJ_MAX_SDUS_TO_WAIT_FOR_ACK 1200 PRIVATE U32 gMemoryAlarm; /* 384MB => 768M total cat /sys/devices/virtual/icc/iccserv/mm ============ Partition_7f1c7890 - type: LOCAL PART Split logic is currently disabled Part start address_9a200000, end address_ca1fffff Size ...................... 786432 KiB nBlocks ................... 304085 Number of pools ........... 4 GAP (between sectors) ..... 128 Bytes Pools info: Pool_0: BlkSize_(useful_384, total_512), BlkCnt_104856, FreeBlkCnt_97177 Pool_1: BlkSize_(useful_1920, total_2048), BlkCnt_157285, FreeBlkCnt_130668 Pool_2: BlkSize_(useful_3968, total_4096), BlkCnt_20970, FreeBlkCnt_11245 Pool_3: BlkSize_(useful_16256, total_16384), BlkCnt_20970, FreeBlkCnt_12122 ============*/ #endif PUBLIC U32 dbgSpaccThreshHoldDropCnt = 0; PUBLIC U32 dbgPdcpQSizeThreshHoldDropCnt = 0; PUBLIC U32 dbgPdcpMemCount = 0; PUBLIC U32 pdcpDropMemTh = 0; PUBLIC U32 dbgICCMemThreshHoldDropCnt = 0; PUBLIC U32 dbgSSIMemThreshHoldDropCnt = 0; PUBLIC U32 dbgICCMemAlarm; PUBLIC U32 dbgPdcpQMsSpaccQFull = 0; PUBLIC U32 dbgPdcpRbOverload = 0; /* kw003.201 This function is for admission control at packet level */ #ifdef ANSI PUBLIC S16 pjLibPktAdmCtrl ( PjDlRbCb *pjRbCb, Buffer *pkt ) #else PUBLIC S16 pjLibPktAdmCtrl(pjRbCb, pkt) PjDlRbCb *pjRbCb; Buffer *pkt; #endif { TRC3(pjLibPktAdmCtrl) /* Patch kw004.201 */ #ifdef SS_CAVIUM if(pjRbCb->dlCb.txBuf.numEntries > 450) { RETVALUE(RFAILED); } #endif #ifdef LTE_PAL_ENB if(pjRbCb->dlCb.txBuf.numEntries > 1200) { RETVALUE(RFAILED); } #endif #ifdef TENB_T2K3K_SPECIFIC_CHANGES if(pjRbCb->dlCb.txBuf.numEntries > PJ_MAX_SDUS_TO_WAIT_FOR_ACK) { dbgPdcpQSizeThreshHoldDropCnt++; /*This is for AM bearers only. FC for UDP on AM will also be taken care here. */ #ifdef TENB_STATS if (pjRbCb->ueCb->tenbStats) { pjRbCb->ueCb->tenbStats->stats.nonPersistent.pdcp.dlPdcpAckWaitDropCnt++; } #endif RETVALUE(RFAILED); } /* Check the SPAcc queue too as we need to start dropping the PDUs in case * if SPAcc queue is waiting more number of PDUs */ if(FALSE == (pjMsCheckSpaccQueue(FALSE))) { dbgSpaccThreshHoldDropCnt++; dbgPdcpQMsSpaccQFull++; RETVALUE(RFAILED); } /* Memory threshold is reached then drop the packet */ if(isMemThreshReached(pjCb[1]->init.region) != ROK) { { extern U32 pdcpdrop; pdcpdrop++; //MSPD_LOG("at PDCPdrop %d new %d\n",pdcpdrop); } RETVALUE(RFAILED); } dbgICCMemAlarm=gMemoryAlarm; #endif if (pjRbCb->dropOnlyOne) { #ifdef TENB_STATS /*FC for AM bearers*/ if (pjRbCb->ueCb->tenbStats) { pjRbCb->ueCb->tenbStats->stats.nonPersistent.pdcp.dlPdcpDropCnt++; } #endif dbgPdcpMemCount++; pjRbCb->dropOnlyOne = 0; RETVALUE(RFAILED); } if ((pjRbCb->pktAdmitCnt) && (pjRbCb->pktCnt > pjRbCb->pktAdmitCnt)) { /* FC for UM bearers */ #ifdef TENB_STATS /*FC for AM bearers*/ if (pjRbCb->ueCb->tenbStats) { pjRbCb->ueCb->tenbStats->stats.nonPersistent.pdcp.dlPdcpDropCnt++; } #endif RETVALUE(RFAILED); } /* Pkt admitted. Counting it in.*/ pjRbCb->pktCnt++; RETVALUE(ROK); } /* end of pjLibPktAdmCtrl */ #ifdef TENB_AS_SECURITY /** * @brief This function is used to Process the o/p from SPAcc. * * @details This function is used to Process ciphered PDU's from SPAcc. We * check if SPAcc has ciphered all PDU's successfully or not. If success we * pass it to lower layers. If Failure, we initimate failure. * * @param[in] - Void * * @return - Void */ #ifdef ANSI PUBLIC Void pjMsSpaccProcessDlBatchOutput(Void) #else PUBLIC Void pjMsSpaccProcessDlBatchOutput(Void) #endif { U32 ret=ROK; U32 jobNum=1; Buffer *opSdu=NULLP; PjMsSPACCOutputMapInfo spaccInfo; for(;;) { /* Fetch Ciphered PDU's one by one from SPAcc */ ret = pjMsSpaccFetchDlPduInfo(&spaccInfo, &opSdu, jobNum, ROK); /*No further packets for processing so break from here*/ if(ret == ROKDNA) { break; } if(ret == RFAILED) { /* Handling of failure of any of the Deciphered PDU's */ if((pjHndlCiphFail(&spaccInfo)) != ROK) { /* We get to this scenario when ueCb/RbCb/TxEnt is deleted already due to either re-establishment or any other scenario. So we just drop the packets for these */ PJ_FREE_BUF(opSdu); } } else { /*Send the packet to RLC*/ pjProcCiphPdu(opSdu, &spaccInfo); } jobNum++; /* Num PDU's sent to SPAcc cant be greater than the below condition. * Hence break */ if(jobNum > (PJ_MS_MAX_JOBS_IN_QUEUE + 2)) { RLOG1(L_ERROR, "Num Jobs in pjMsSpaccProcessDlBatchOutput " "exceeds %ld, hence exiting!!!!", jobNum); break; } } } /** * @brief This function is used to Process the o/p from SPAcc. * * @details This function is used to Process Deciphered PDU's from SPAcc. We * check if SPAcc has deciphered all PDU's successfully or not. If success we * pass it to lower layers. If Failure, we initimate failure. * * @param[in] - Void * * @return - Void */ #ifdef ANSI PUBLIC Void pjMsSpaccProcessUlBatchOutput(Void) #else PUBLIC Void pjMsSpaccProcessUlBatchOutput(Void) #endif { U32 ret=ROK; U32 retval = ROK; U32 jobNum=1; Buffer *opSdu=NULLP; PjMsSPACCOutputMapInfo spaccInfo; for(;;) { ret = pjMsSpaccFetchUlPduInfo(&spaccInfo, &opSdu, jobNum, ROK); if(ret == ROKDNA) { break; } if(ret == RFAILED) { /* If one of the packets sent to SPAcc returns a failure, trigger * handling of this failure scenario */ retval = pjHdlDecipherFailure(&spaccInfo); } else { /* Success case */ retval = pjProcDeCipherPdu(&spaccInfo, opSdu); } if(retval != ROK) { /* Drop o/p pdu's as either ueCb/RbCb/RxEnt is already deleted due to reestablishment or other scenario */ PJ_FREE_BUF(opSdu); } jobNum++; if(jobNum > (PJ_MS_MAX_JOBS_IN_QUEUE + 2)) { RLOG1(L_ERROR, "Num Jobs in PjUlSpaccTrigger exceeds %ld," " hence aborting!!!!", jobNum); break; } } } /** * @brief This function is used to deInit the CipherQ * * @details * * @param[in] - Void * * @return - Void */ #ifdef ANSI PUBLIC Void pjSpaccDeInitCiphQ(Void) #else PUBLIC Void pjSpaccDeInitCiphQ(Void) #endif { #ifdef INTEL_NATIVE_SPACC pjMsNativeSpaccDeInitCiphQ(); #else pjMsSpaccDeInitCiphQ(); #endif RETVOID; } /** * @brief This function is used to deInit the DeCipherQ * * @details * * @param[in] - Void * * @return - Void */ #ifdef ANSI PUBLIC Void pjSpaccDeInitDeCipherQ(Void) #else PUBLIC Void pjSpaccDeInitDeCipherQ(Void) #endif { #ifdef INTEL_NATIVE_SPACC pjMsNativeSpaccDeInitDeCiphQ(); #else /*pjMsSpaccDeInitCiphQ();*/ pjMsSpaccDeInitDeCipherQ(); #endif RETVOID; } #endif /** * * @brief * * pjUlBatchProcSplit- Process rbuf messages * * @return S16 * -# ROK */ #if defined(L2_L3_SPLIT) && defined(ICC_RECV_TSK_RBUF) #ifdef ANSI PUBLIC S16 pjUlBatchProcSplit ( Void ) #else PUBLIC S16 pjUlBatchProcSplit() Void; #endif { S16 ret1; /* Read from Ring Buffer and process PDCP packets */ Void *elmIndx = NULLP; RxmBufReq *datInd = NULLP; elmIndx = SRngGetRIndx(SS_RNG_BUF_RX_TO_ULPDCP); while(NULLP != elmIndx) { datInd = (RxmBufReq *)elmIndx; if(datInd->mBuf != NULLP) { ret1 = cmUnpkKwuDatInd(PjLiKwuDatInd, &datInd->pst, datInd->mBuf); if(ret1 != ROK) { #if (ERRCLASS & ERRCLS_DEBUG) SLogError(ENTPJ, 0, SFndProcId(), __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG, (ErrVal)EPJXXX, (ErrVal)ERRZERO, "UNPACK ERROR\n"); #endif /* (ERRCLASS & ERRCLS_DEBUG) */ } } else { #if (ERRCLASS & ERRCLS_DEBUG) SLogError(ENTPJ, 0, SFndProcId(), __FILE__, __LINE__, (ErrCls)ERRCLS_DEBUG, (ErrVal)EPJXXX, (ErrVal)ERRZERO, "pjUlBatchProcSplit: mBuf NULL\n"); #endif /* (ERRCLASS & ERRCLS_DEBUG) */ if(datInd->mBuf) cmUnpkKwuDatInd(PjLiKwuDatInd, &datInd->pst, datInd->mBuf); } SsRngInfoTbl[SS_RNG_BUF_RX_TO_ULPDCP].nPktProc++;;//Number of pkt processed in tti datInd->mBuf = NULLP; SRngIncrRIndx(SS_RNG_BUF_RX_TO_ULPDCP); if((elmIndx = SRngGetRIndx(SS_RNG_BUF_RX_TO_ULPDCP)) == NULLP) break; } RETVALUE(ROK); } #endif #endif /* PTPJLIB */ #ifdef ANSI PUBLIC S16 PjLibObdIntCloseReq ( Void *intCxtId ) #else PUBLIC S16 PjLibObdIntCloseReq(*intCxtId) Void *intCxtId; #endif { TRC3(PjLibObdIntCloseReq) RETVALUE(ROK); } /********************************************************************30** End of file **********************************************************************/