/*******************************************************************************
################################################################################
#   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:    PDCP - Database module file
    
        Type:    C source file
  
        Desc:    Source code for Database Module functions such as, 

                  -  pjDbmBufInit
                  -  pjDbmInsTxEnt
                  -  pjDbmGetTxEnt
                  -  pjDbmGetTxEntSn
                  -  pjDbmDelTxEnt
                  -  pjDbmTxDeInit
                  -  pjDbmInsRxEnt
                  -  pjDbmGetRxEnt
                  -  pjDbmDelRxEnt
                  -  pjDbmRxDeInit

        File:    pj_dbm_ul.c
  
*********************************************************************21*/
static const char* RLOG_MODULE_NAME="PDCP";
static int RLOG_MODULE_ID=1024;
static int RLOG_FILE_ID=216;


/* 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 interface */
#include "cm5.h"                /* Timer Functions */
#include "cm_lte.h"             /* common LTE header file */
#include "cm_hash.h"            /* common hash module  file */
#include "cm_llist.h"           /* common list header file */
#include "cpj.h"                /* RRC layer */
#include "pju.h"                /* PDCP service user */
#include "lpj.h"                /* RRC layer */
#include "pj_env.h"             /* RLC environment options */
#include "pj.h"                 /* RLC layer */
#include "pj_ul.h"                 /* RLC layer */
#include "pj_err.h"
/* extern (.x) include files */
#include "gen.x"                /* general */
#include "ssi.x"                /* system services interface */
#include "cm_lib.x"             /* common library */
#include "cm5.x"                /* Timer Functions */
#include "cm_hash.x"            /* common hash module */
#include "cm_lte.x"             /* common LTE file */
#include "cm_llist.x"           /* common list header file */
#include "cpj.x"                /* RRC layer */
#include "pju.x"                /* PDCP service user */
#include "lpj.x"                /* LM Interface */
#include "pj.x"                 /* RLC layer */
#include "pj_udx.h"
#include "pj_udx.x"
#include "pj_dl.x"
#include "pj_ul.x"


/* local defines */

/* local externs */

/* forward references */

/* public variable declarations */
PUBLIC S16 pjDeciphStateChek ARGS ((PjCb *gCb, PjRxEnt *delEnt));
/* This structure holds all the global structs we need. */

/* private variable declarations */

/* private function declarations */

/** @file gp_pj_dbm.c
@brief PDCP DBM Module
**/

/*****************************************************************************
 *                  HANDLER FOR THE TRANSMISSION BUFFER
 ****************************************************************************/

/*****************************************************************************
 *                  HANDLERS FOR THE RECEPTION BUFFER
 ****************************************************************************/

/**
 * @brief Handler to insert packets In-Sequence into RX Buffer
 *
 *
 */
#ifdef ANSI
PRIVATE S16 pjDbmInsInSeqRxEnt
(
PjBuf       *buf,          /* !< Rx Buffer  */
PjRxEnt     *rxEnt         /* !< Rx Entry   */              
)
#else
PRIVATE S16 pjDbmInsInSeqRxEnt(buf, rxEnt)
PjBuf       *buf;
PjRxEnt     *rxEnt;
#endif
{

   PjRxEnt     *tmpEnt = NULLP;

   tmpEnt = (PjRxEnt *) cmLListNode(cmLListFirst(&buf->datPktQ));
   if((rxEnt->count) < (tmpEnt->count))
   {         
      rxEnt->datPktEnt.node = (PTR) rxEnt;
      cmLListInsCrnt(&buf->datPktQ, &rxEnt->datPktEnt);
   }
   else
   {
      tmpEnt = (PjRxEnt *) cmLListNode(cmLListLast(&buf->datPktQ));
      while((rxEnt->count) < (tmpEnt->count))
      {
         cmLListPrev(&buf->datPktQ);
         tmpEnt = (PjRxEnt *) cmLListNode(cmLListCrnt(&buf->datPktQ));
      }
      rxEnt->datPktEnt.node = (PTR) rxEnt;
      cmLListInsAfterCrnt(&buf->datPktQ, &rxEnt->datPktEnt);
   }
   RETVALUE(ROK);
}



/**
 *
 * @brief Handler to insert into a RX Buffer
 *
 * @b Description
 *        This function is invoked by to insert into
 *         the reception buffer hash List
 *
 *  @param[in]  buf      Rx Buffer 
 *  @param[in]  rxEnt    Reception Entry
 *  @param[in]  dupFlag  Search for duplicates(Should be TRUE for AM)
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmInsRxEnt
(
PjCb        *gCb,
PjBuf       *buf,          /* !< Rx Buffer  */
PjRxEnt     *rxEnt,        /* !< Rx Entry   */              
Bool        dupFlag        /* !< Boolean to check for duplicate  entries */
)
#else
PUBLIC S16 pjDbmInsRxEnt(gCb, buf, rxEnt, dupFlag)
PjCb        *gCb;
PjBuf       *buf;          /* !< Rx Buffer  */
PjRxEnt     *rxEnt;        /* !< Rx Entry   */                              
Bool        dupFlag;       /* !< Boolean to check for duplicate  entries */ 
#endif
{
   U8       hashKey;          /* Computed hash key */
   PjRxEnt  *tmpEnt = NULLP;  /* Rx Entry Ptr */

   TRC3(pjDbmInsRxEnt)
#ifndef ALIGN_64BIT
   PJDBGP(gCb,(PJ_DBGMASK_UTL | PJ_DBGMASK_DETAIL), (gCb->init.prntBuf,\
            "pjDbmInsRxEnt buf, rxEnt(%ld), dupFlag(%d)\n",\
            rxEnt->count, dupFlag));
#else
   PJDBGP(gCb,(PJ_DBGMASK_UTL | PJ_DBGMASK_DETAIL), (gCb->init.prntBuf,\
            "pjDbmInsRxEnt buf, rxEnt(%d), dupFlag(%d)\n",\
            rxEnt->count, dupFlag));
#endif

   if(dupFlag)
   {
      /* Search for duplicates */
      tmpEnt = pjDbmGetRxEnt(gCb, buf, rxEnt->count);
      if(tmpEnt != NULLP)
      {
         RETVALUE(ROKDUP);
      }
   }

   /* Compute the hash index */
   hashKey = (U8)PJ_HASH_FN(buf, rxEnt->count);  /*KW_FIX*/

   rxEnt->lstEnt.node   =  (PTR) rxEnt;
   cmLListAdd2Tail(&buf->datQ[hashKey], &rxEnt->lstEnt);
   buf->numEntries ++;

   if(buf->datPktQ.count == 0)
   {
      rxEnt->datPktEnt.node = (PTR) rxEnt;
      cmLListAdd2Tail(&buf->datPktQ, &rxEnt->datPktEnt);
   }
   else
   {
      pjDbmInsInSeqRxEnt(buf, rxEnt);
   }

   RETVALUE(ROK);
} /* pjDbmRxBufIns */


/**
 *
 * @brief Handler to fetch from a RX Buffer
 *
 * @b Description
 *        This function is invoked to fetch an entry from
 *         the transaction buffer hash List
 *
 *  @param[in]    buf         Rx Buffer 
 *  @param[in]    count       Count value of the entry to retrieve
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC PjRxEnt* pjDbmGetRxEnt
(
PjCb   *gCb,
PjBuf  *buf,       /* !< Rx Buffer  */                               
U32    count       /* !< Count value of the entry to retrieve */                               
)
#else
PUBLIC PjRxEnt* pjDbmGetRxEnt(gCb, buf, count)
PjCb   *gCb;
PjBuf  *buf;       /* !< Rx Buffer  */                               
U32    count;      /* !< Count value of the entry to retrieve */   
#endif
{
   U8         hashKey;   /* Computed hashKey */
   CmLListCp *datQ;      /* Ptr to the CmLListCp */
   PjRxEnt   *tmpEnt = NULLP;  /* Loop var - Rx Entr Ptr */

   TRC3(pjDbmGetRxEnt)
   /* Compute the hask key*/
   hashKey = (U8)PJ_HASH_FN(buf, count); /*KW_FIX*/

   datQ = &buf->datQ[hashKey];

   /* Loop through and search */
   cmLListFirst(datQ);
   while(cmLListCrnt(datQ))
   {
      tmpEnt = (PjRxEnt *)cmLListNode(cmLListCrnt(datQ));
      if((tmpEnt->count) == count)
      {
         RETVALUE(tmpEnt);
      }
      cmLListNext(datQ);
   }
   RETVALUE(NULLP);
} /* pjDbmGetRxEnt */
/**
 *  @brief This fn is called to chek the state of the PDCP pkts in UL before Deciphering operation
 *         and appropriate action is taken accordingly
 *
 *  @details
 *      Function : pjDeciphStateChek
 *
 *  Processing Steps:
 *
 *
 * @return  S16
 *        -# Success : ROK
 *        -# Failure : RFAILED
*/

/* ccpu00136902 */
#if (defined (LTE_PAL_ENB) || defined (TENB_ACC))
#ifdef ANSI
PUBLIC S16 pjDeciphStateChek
(
PjCb        *gCb,
PjRxEnt     *delEnt
)
#else
PUBLIC S16 pjDeciphStateChek(gCb, delEnt)
PjCb        *gCb;
PjRxEnt     *delEnt;
#endif
{
  TRC3(pjDeciphStateChek);
  PJ_FREE_BUF(delEnt->mBuf);
  PJ_FREE(gCb, delEnt, sizeof(PjRxEnt));
  RETVALUE(ROK);
}
#endif


/**
 *
 * @brief Handler to delete from a RX Buffer
 *
 * @b Description
 *        This function is invoked by to delete from
 *         the transaction buffer hash List
 *
 *  @param[in]    buf         Rx Buffer Control Point
 *  @param[in]    count       Count value of the Rx Entry to delete
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelRxEnt
(
PjCb   *gCb,
PjBuf  *buf,        /* !< Rx Buffer  */                                                          
U32    count        /* !< Count value of the entry to retrieve */                                
)
#else
PUBLIC S16 pjDbmDelRxEnt(gCb, buf, count)
PjCb   *gCb;
PjBuf  *buf;        /* !< Rx Buffer  */                                                          
U32    count;       /* !< Count value of the entry to retrieve */                                
#endif
{
   U8          hashKey;      /* Computed hash value */
   CmLListCp   *datQ;        /* Pointer to the the ListCp */
   PjRxEnt     *delEnt;      /* Loop var - entry to be deleted */

   TRC3(pjDbmDelRxEnt)
#ifndef ALIGN_64BIT
   PJDBGP(gCb,(PJ_DBGMASK_UTL | PJ_DBGMASK_DETAIL), (gCb->init.prntBuf,\
            "pjDbmDelRxEnt(buf, count(%ld)\n", count));
#else
   PJDBGP(gCb,(PJ_DBGMASK_UTL | PJ_DBGMASK_DETAIL), (gCb->init.prntBuf,\
            "pjDbmDelRxEnt(buf, count(%d)\n", count));
#endif

   /* Get the node */
   delEnt   =  pjDbmGetRxEnt(gCb, buf, count);

   if(delEnt == NULLP)
   {
      RETVALUE(ROK);
   }

   hashKey = (U8)PJ_HASH_FN(buf, count); /*KW_FIX*/
   datQ = &buf->datQ[hashKey];

   /* delete the entity and free it*/
   cmLListDelFrm(datQ, &delEnt->lstEnt);
   if(delEnt->datPktEnt.node != NULLP)
   {
      cmLListDelFrm(&buf->datPktQ, &delEnt->datPktEnt);
      delEnt->datPktEnt.node = NULLP;
   }
   /* ccpu00136902 */
   pjDeciphStateChek(gCb, delEnt);
   buf->numEntries --;

   RETVALUE(ROK);
} /* pjDbmDelRxEnt */


/**
 *
 * @brief Handler to Delete all the elements in the hashlist
 *       
 *
 * @b Description
 *        This function is invoked by delete all the elements in th3
 *        hash List
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmRxDelAll
(
PjCb  *gCb,
PjBuf *buf        /* !< Rx Buffer  */                                                          
)                 
#else
PUBLIC S16 pjDbmRxDelAll(gCb,buf)
PjCb  *gCb;
PjBuf *buf;       /* !< Rx Buffer  */                                                          
#endif
{
   U8         listInd;   /* loop index */
   CmLListCp *datQ;      /* CmLListCp Ptr */
   CmLList   *lstEnt;   /* loop ptr to CmLlistEnt */
   PjRxEnt   *delEnt;    /* loop ptr to entry to be deleted */

   TRC3(pjDbmRxDelAll);

   RLOG0(L_DEBUG, "pjDbmRxDelAll(buf)");

   for(listInd = 0; listInd< buf->numBins; listInd++)
   {
      datQ = &buf->datQ[listInd];
      while(cmLListFirst(datQ))
      {
         lstEnt = cmLListDelFrm(datQ, cmLListCrnt(datQ));
         if(lstEnt != NULLP)
         {
            delEnt   =  (PjRxEnt *)cmLListNode(lstEnt);
            if(delEnt->datPktEnt.node != NULLP)
            {
               cmLListDelFrm(&buf->datPktQ, &delEnt->datPktEnt);
               delEnt->datPktEnt.node = NULLP;
            }
            /* ccpu00136902 */
            pjDeciphStateChek(gCb, delEnt);
         }
      }
      cmLListInit(datQ);
   }

   RETVALUE(ROK);
} /* pjDbmRxDelAll */

/**
 *
 * @brief Handler to De initialize hash list
 *       
 *
 * @b Description
 *        This function is invoked by LMM to De initialize the 
 *        hash List
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmRxDeInit
(
PjCb  *gCb,
PjBuf *buf        /* !< Rx Buffer  */                                                          
)                 
#else
PUBLIC S16 pjDbmRxDeInit(gCb,buf)
PjCb  *gCb;
PjBuf *buf;       /* !< Rx Buffer  */                                                          
#endif
{

   TRC3(pjDbmRxDeInit);

   RLOG0(L_DEBUG, "pjDbmRxDeInit(buf)");

   /* Cleanup all entries */
   pjDbmRxDelAll(gCb,buf);

   /* Cleanup hashlist */
   PJ_FREE(gCb, buf->datQ, (sizeof(CmLListCp) * buf->numBins));
   buf->numBins   =  NULLP;

   RETVALUE(ROK);
} /* pjDbmDeInit */


/**
 *
 * @brief Handler to initialize hash list
 *       
 *
 * @b Description
 *        This function is invoked by LMM to initialize the UeCb and CellCb
 *        hash List
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmUlInit  
(
PjCb *gCb
)
#else
PUBLIC S16 pjDbmUlInit(gCb)
PjCb *gCb;
#endif
{
   S16      ret;              /* Return Value */

   TRC3(pjDbmUlInit)

#ifdef DEBUGP
   RLOG0(L_DEBUG, "pjDbmInit()");
#endif

   /* Initialize ueCb Hash List */
   ret = cmHashListInit(&(gCb->u.ulCb->ueLstCp), (U16) PJ_UE_LIST_BUCKET_SIZE,
         (U16) 0, (Bool) FALSE, (U16) CM_HASH_KEYTYPE_DEF,
         gCb->init.region, gCb->init.pool);
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR, "cmHashListInit Failed for gCb.ueLstCp.");
#endif
      RETVALUE(ret);
   }

   ret = cmHashListInit(&(gCb->u.ulCb->transIdLstCp), 
                        (U16) PJ_TRANS_ID_LST_BKT_SIZE,
         (U16) 0, (Bool) FALSE, (U16) CM_HASH_KEYTYPE_DEF,
         PJ_GET_MEM_REGION(gCb), PJ_GET_MEM_POOL(gCb));
   if (ret != ROK)
   {
      cmHashListDeinit(&gCb->u.ulCb->ueLstCp);
#ifdef DEBUGP
      RLOG0(L_ERROR, "cmHashListInit Failed for pjCb.transIdLstCp.");
#endif
   }


   RETVALUE(ROK);
} /* pjDbmInit */


/**
 *
 * @brief Handler to De initialize hash list
 *       
 *
 * @b Description
 *        This function is invoked by LMM to De initialize the UeCb and CellCb
 *        hash List
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmUlDeInit
(
PjCb *gCb
)
#else
PUBLIC S16 pjDbmUlDeInit(gCb)
PjCb *gCb;
#endif
{
   S16      ret;                       /* Return Value */

   TRC3(pjDbmUlDeInit);

#ifdef DEBUGP
   RLOG0(L_DEBUG, "pjDbmDeInit()");
#endif

   /* Initialize ueCb Hash List */
   ret = cmHashListDeinit(&(gCb->u.ulCb->ueLstCp));
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR, "cmHashListDeinit Failed for gCb.ueLstCp.");
#endif
      RETVALUE(ret);
   }
   /* Initialize transId Hash List */
   /*MEM_LEAK_FIX*/
   ret = cmHashListDeinit(&(gCb->u.ulCb->transIdLstCp));
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR, "cmHashListDeinit Failed for gCb.transIdLstCp.");
#endif
      RETVALUE(ret);
   }

   ret = cmHashListDeinit(&(gCb->u.ulCb->transIdLstCp));
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR, "cmHashListDeinit Failed for gCb->u.ulCb->transIdLstCp");
#endif
      RETVALUE(ret);
   }
   RETVALUE(ROK);
} /* pjDbmDeInit */


/**
 *
 * @brief Handler to fetch rbCb in the Upper Interface
 *       
 *
 * @b Description
 *        This function is invoked by CFG to fetch rbCb from the cellCb/ueCb in
 *        the upper interface (CPJ/PJU).
 *
 *  @param[in]    rlcId    RLC Identifier 
 *  @param[out]   rbCb     RB Control Block
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmFetchUlRbCb
(
PjCb           *gCb,
CmLteRlcId     rlcId,      /* RLC Identifier */
PjUlRbCb       **rbCb       /* RB Cb */
)
#else
PUBLIC S16 pjDbmFetchUlRbCb(gCb, rlcId, rbCb)
PjCb           *gCb;
CmLteRlcId     rlcId;      /* RLC Identifier */
PjUlRbCb         **rbCb;      /* RB Cb */
#endif
{
   PjUlUeCb      *ueCb;                  /* UE Control Block */
   PjUlRbCb        *tRbCb;                 /* Local RB CB */
   S16         ret;                    /* Return Value */

   TRC3(pjDbmFetchUlRbCb)

   ueCb = NULLP;
   ret = ROK;

   /* Validate the RBID in case of TM/UM/AM */
   PJ_VALIDATE_RBID(rlcId.ueId, rlcId.rbId, rlcId.rbType, ret);
   if (ret != ROK)
   {
#ifdef DEBUGP
      /* DEBUG_PRINT EROR */
      RLOG_ARG2(L_ERROR,DBG_UEID,rlcId.ueId, 
            "PJ_VALIDATE_RBID Failed rbId(%d), cellId(%d)",
                       rlcId.rbId, rlcId.cellId);
#endif
      RETVALUE(ret);
   }
   if (pjDbmFetchUlUeCb(gCb, rlcId.ueId, rlcId.cellId, &ueCb) != ROK)
   {
#ifdef DEBUGP
      RLOG_ARG0(L_ERROR,DBG_UEID,rlcId.ueId, "Failed to Fetch UE Cb");
#endif
      RETVALUE(RFAILED);
   }
   else
   {
      PJ_DBM_FETCH_UL_RBCB(rlcId.rbId, rlcId.rbType, ueCb, tRbCb);
   }

   if (tRbCb == NULLP)
   {
      RLOG_ARG2(L_ERROR, DBG_UEID,rlcId.ueId, "CellId[%u]:RbId[%d] not found",
            rlcId.cellId, rlcId.rbId);
      RETVALUE(RFAILED);
   }

   *rbCb = tRbCb;

   RETVALUE(ROK);
} /* pjDbmFetchRbCb */



/**
 *
 * @brief Handler to delete RbCb
 *       
 *
 * @b Description
 *        This function is invoked by CFG to remove RbCb from Ue/Cell hashlist 
 *
 *
 *  @param[in] rbCbLst   - Rb Cb List
 *  @param[in] numRbCb   - Number of rbCbs
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelAllUlRb
(
PjCb             *gCb,
PjUlRbCb         **rbCbLst,              /* RB Cb list */
U8             numRbCb                 /* Number of rbCbs */
)
#else
PUBLIC S16 pjDbmDelAllUlRb(gCb,rbCbLst, numRbCb)
PjCb             *gCb;
PjUlRbCb         **rbCbLst;              /* RB Cb list */
U8             numRbCb;                /* Number of rbCbs */
#endif
{
   U8          idx;                    /* Index */
   PjUlRbCb        *rbCb;                  /* RB Control Block */

   TRC3(pjDbmDelAllUlRb)

#ifdef DEBUGP
   RLOG1(L_DEBUG, "pjDbmDelAllRb(rbCbLst, numRbCb(%d))", numRbCb);
#endif

   for (idx = 0; idx < numRbCb; idx++)
   {
      rbCb = rbCbLst[idx];
      if (rbCb != NULLP)
      {
         PJ_DBM_DELETE_UL_RBCB(gCb,rbCb);
         rbCbLst[idx] = NULLP;
      }
   }

   RETVALUE(ROK);
} /* pjDbmDelAllRb */


/**
 *
 * @brief Handler to create an UeCb
 *       
 *
 * @b Description
 *        This function is invoked by CFG to create UeCb and insert into the Ue hashlist 
 *        of PjCb.
 *
 *
 *  @param[in] ueId     UE Identifier 
 *  @param[in] cellId   Cell Identifier 
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmCreateUlUeCb
(
PjCb              *gCb,
CmLteRnti         ueId,       /* UE Identifier */
CmLteCellId       cellId,     /* Cell Identifier */
PjUlUeCb            **ueCb       /* UE Control Block */
)
#else
PUBLIC S16 pjDbmCreateUlUeCb(gCb, ueId, cellId, ueCb)
PjCb              *gCb; 
CmLteRnti         ueId;       /* UE Identifier */
CmLteCellId       cellId;     /* Cell Identifier */
PjUlUeCb            **ueCb;     /* UE Control Block */
#endif
{
   S16      ret;              /* Return Value */
   PjUlUeCb   *tUeCb;           /* UE Control Block */

   TRC3(pjDbmCreateUlUeCb)

#ifdef DEBUGP
   RLOG2(L_DEBUG, "pjDbmCreateUeCb(ueId(%d), cellId(%d))", ueId, cellId);
#endif

   PJ_ALLOC(gCb, *ueCb, sizeof(PjUlUeCb));

#if (ERRCLASS & ERRCLS_ADD_RES)
   if (*ueCb == NULLP)
   {
      ret = RFAILED;
      RLOG0(L_FATAL, "Memory Allocation failure");
      RETVALUE(ret);
   }
#endif /* ERRCLASS & ERRCLS_ADD_RES */

   tUeCb = *ueCb;
   tUeCb->key.ueId = ueId;
   tUeCb->key.cellId = cellId;

   ret = cmHashListInsert(&(gCb->u.ulCb->ueLstCp), (PTR)tUeCb, (U8 *)&(tUeCb->key),
         (U16) sizeof(PjUeKey));
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG_ARG1(L_ERROR,DBG_UEID,ueId,"Ul UeCb Hash Insert Failed : cellId(%d)",
                            cellId);
#endif
      RETVALUE(ret);
   }

   /* kw005.201 ccpu00117318, updating the statistics */
   gCb->pjGenSts.numUe++;

   (*ueCb)->libInfo.state =  PJ_STATE_NORMAL;
   cmInitTimers(&((*ueCb)->libInfo.obdTmr), 1);
   RETVALUE(ret);
} /* kwDbmCreateUeCb */


/**
 *
 * @brief Handler to Fetch an UeCb
 *       
 *
 * @b Description
 *        This function is invoked by CFG to fetch UeCb from the Ue hashlist 
 *        of PjCb.
 *
 *
 *  @param[in]    ueId     UE Identifier 
 *  @param[in]    cellId   Cell Identifier 
 *  @param[out]   ueCb     UE Control Block
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmFetchUlUeCb
(
PjCb              *gCb,
CmLteRnti         ueId,       /* UE Identifier */
CmLteCellId       cellId,     /* Cell Identifier */
PjUlUeCb            **ueCb       /* UE Control Block */
)
#else
PUBLIC S16 pjDbmFetchUlUeCb(gCb, ueId, cellId, ueCb)
PjCb              *gCb;
CmLteRnti         ueId;       /* UE Identifier */
CmLteCellId       cellId;     /* Cell Identifier */
PjUlUeCb            **ueCb;      /* UE Control Block */
#endif
{
   S16      ret;              /* Return Value */
   PjUeKey  key;              /* Key for UE Hash List */

   TRC3(pjDbmFetchUlUeCb)


   key.ueId = ueId;
   key.cellId = cellId;

   ret = cmHashListFind(&(gCb->u.ulCb->ueLstCp), (U8 *)&(key), sizeof(PjUeKey),
         PJ_DEF_SEQ_NUM, (PTR *) ueCb);
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG_ARG0(L_INFO,DBG_UEID,ueId, "Hash Find Failed for fetching ueCb");
#endif
      RETVALUE(ret);
   }

   RETVALUE(ROK);
} /* pjDbmFetchUeCb */


/**
 *
 * @brief Handler to delete an UeCb
 *       
 *
 * @b Description
 *        This function is invoked by CFG to delete UeCb from the Ue hashlist 
 *        of PjCb.
 *
 *
 *  @param[in] ueCb     UE Control Block
 *  @param[in] abrtFlag Abort Flag
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelUlUeCb
(
PjCb        *gCb,
PjUlUeCb      *ueCb,       /* UE Identifier */
Bool        abortFlag    /* Abort Flag */
)
#else
PUBLIC S16 pjDbmDelUlUeCb(gCb, ueCb, abortFlag)
PjCb        *gCb;
PjUlUeCb      *ueCb;       /* UE Identifier */
Bool        abortFlag;   /* Abort Flag */
#endif
{
   S16         ret;      /* Return Value */
   U8          idx;      /* Index */

   TRC3(pjDbmDelUlUeCb)

#ifdef DEBUGP
   RLOG2(L_DEBUG, "pjDbmDelUeCb(ueId(%d), cellId(%d))",
            ueCb->key.ueId, ueCb->key.cellId);
#endif

/* kw005.201 Check to see if there is atleast one logical channel */

   for ( idx = 0; idx< PJ_MAX_SRB_PER_UE; idx++)
       pjCfgDelPjUlRbCb(gCb, ueCb, ueCb->srbCb[idx]);

   for ( idx = 0; idx< PJ_MAX_DRB_PER_UE; idx++) 
       pjCfgDelPjUlRbCb(gCb, ueCb, ueCb->drbCb[idx]);

   /* Close the Integrity/Ciphering channels */
   if(ueCb->secInfo.secAct)
   {
#ifdef INTEL_QAT_DP
      pjUtlUlIntClose(gCb,ueCb->secInfo.cpIntSessCxtId);
      pjUtlUlCipherClose(gCb,ueCb->secInfo.cpCiphSessCxtId);
      pjUtlUlCipherClose(gCb,ueCb->secInfo.upCiphSessCxtId);
#else
      pjUtlUlIntClose(gCb,ueCb->secInfo.intCxtId); 
      pjUtlUlCipherClose(gCb,ueCb->secInfo.cpCxtId);
      pjUtlUlCipherClose(gCb,ueCb->secInfo.upCxtId);
#endif
   }

   /* Delete hoInfo if present */
   if (ueCb->hoInfo != NULLP)
   {
      for (idx = 0; idx < PJ_MAX_DRB_PER_UE; idx++)
      {
         if (ueCb->hoInfo->hoCfmInfo[idx].pres == TRUE)
         {
            PJ_FREE(gCb, ueCb->hoInfo->hoCfmInfo[idx].ulBitMap,
                  (ueCb->hoInfo->hoCfmInfo[idx].numBits % 8)?
                  ((ueCb->hoInfo->hoCfmInfo[idx].numBits / 8) + 1):
                  (ueCb->hoInfo->hoCfmInfo[idx].numBits / 8 ));
         }
      }

      PJ_FREE(gCb, ueCb->hoInfo->hoCfmInfo, 
                 (PJ_MAX_DRB_PER_UE * sizeof(PjUlHoCfmInfo)));
      PJ_FREE(gCb, ueCb->hoInfo, sizeof(PjUlHoInfo));  
   }

   /* Delete ueCb entry from ueLstCp */
   ret = cmHashListDelete(&(gCb->u.ulCb->ueLstCp), (PTR) ueCb);
   if (ret != ROK)
   {

#ifdef DEBUGP
      RLOG_ARG0(L_ERROR,DBG_UEID,ueCb->key.ueId, 
            "Hash Delete Failed for deleting ueCb.");
#endif
   }
   /* kw005.201 ccpu00117318, updating the statistics */
   gCb->pjGenSts.numUe--;

   /* Deallocate ueCb */
   PJ_FREE(gCb, ueCb, sizeof(PjUlUeCb));

   RETVALUE(ret);
} /* pjDbmDelUeCb */


/**
 *
 * @brief Handler to delete all UeCbs
 *       
 *
 * @b Description
 *        This function is invoked by CFG to delete all UeCbs from the Ue
 *        hashlist of PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelAllUlUe
(
PjCb  *gCb
)
#else
PUBLIC S16 pjDbmDelAllUlUe(gCb)
PjCb  *gCb;
#endif
{
   S16         ret;
   PjUlUeCb      *ueCb;            /* UE Control Block */

   TRC3(pjDbmDelAllUlUe)

#ifdef DEBUGP
   RLOG0(L_DEBUG, "pjDbmDelAllUe()");
#endif

   ret = ROK;
   ueCb = NULLP;

   /* Until no more ueCb is ueLstCp hash list get and delete ueCb */
   while (cmHashListGetNext(&(gCb->u.ulCb->ueLstCp), (PTR) ueCb, (PTR *)&ueCb) == ROK)
   {
      /* Delete ueCb */
      ret = pjDbmDelUlUeCb(gCb,ueCb, TRUE);
      if (ret != ROK)
      {
#ifdef DEBUGP
         RLOG_ARG0(L_ERROR,DBG_UEID,ueCb->key.ueId, "UE deletion Failed");
#endif
         RETVALUE(ret);
      }
      ueCb = NULLP;
   }

   RETVALUE(ret);
} /* pjDbmDelAllUe */

/**
 *
 * @brief Handler to Shutdown all UeCbs
 *       
 *
 * @b Description
 *        This function is invoked by CFG to shutdown UeCbs from the PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmUlShutdown 
(
PjCb *gCb
)
#else
PUBLIC S16 pjDbmUlShutdown(gCb)
PjCb *gCb;
#endif
{
#if (ERRCLASS & ERRCLS_DEBUG)
S16  ret
#endif

   TRC3(pjDbmUlShutdown)

#if (ERRCLASS & ERRCLS_DEBUG)
   ret = pjDbmUlDeInit(gCb);
   if (ret != ROK)
   {
      RLOG0(L_FATAL, "UL DeInitialization Failed");
   }
#else
   pjDbmUlDeInit(gCb);
#endif /* ERRCLASS & ERRCLS_DEBUG */

   RETVALUE(ROK);
} /* pjDbmShutdown */

/**
 *
 * @brief Handler to create a RB control block.
 *       
 *
 * @b Description
 *        This function is called to create a RLC control block or PDCP 
 *        control block based on rb flag and update the pointers in RbCb.
 *        If the RbCb is already allocated, the rbId is updated in PjRbCb
 *        or PjUlRbCb based on rb. If the RbCb has not been allocated earlier,
 *        a new RbCb is created and the pointers are updated along with the
 *        rbIds.
 *
 *  @param[in] rbId      RB ID of the entity
 *  @param[in] rbCbLst   List of the RBs in the UeCb
 *  @param[in] rb        The RB to be created. This can be
 *                       PJ_CFG_PDCP when PDCP is created
 *                       or PJ_CFG_RLC when RLC is being
 *                       created. 
 *  
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC PjUlRbCb* pjDbmCreateUlRbCb
(
PjCb    *gCb,
U8      rbId,
U8      rbType, 
PjUlUeCb  *ueCb, 
U8      rb
)
#else
PUBLIC PjUlRbCb* pjDbmCreateUlRbCb(gCb,rbId,rbType,ueCb,rb)
PjCb    *gCb;
U8      rbId; 
U8      rbType;
PjUlUeCb  *ueCb; 
U8      rb;
#endif
{
   PjUlRbCb   *rbCb;
   PjUlRbCb   **rbCbLst;

   TRC2(pjDbmCreateUlRbCb)

   rbCb = NULLP;
   rbCbLst = NULLP;
   PJ_ALLOC(gCb, rbCb, sizeof(PjUlRbCb) );
   if ( rbCb == NULLP )
   {
      RLOG0(L_FATAL, "Memory Allocation failed");
      RETVALUE(rbCb);
   }
   rbCb->rbId   = rbId;
   rbCb->rbType = rbType;

   rbCbLst = ((rbType == CM_LTE_SRB)? ueCb->srbCb:ueCb->drbCb); 
   rbCbLst[rbId] = rbCb;
   /* kw005.201 ccpu00117318, updating the statistics */   
   PJ_LMM_RB_STS_INC(gCb);                                    
   
   RETVALUE(rbCb); 
   
} /* pjDbmCreateRbCb */

/**
 *
 * @brief Handler to fetch a  PDCP RB control block.
 *       
 *
 * @b Description
 *        This function is used to fetch the PDCP RB control block based on 
 *        the RB id. The pointer to PjUlRbCb is returned.
 *       
 *  @param[in]  ueCb    UE control block of the PDCP RB
 *  @param[in]  rbId    RB ID of the required PDCP entity.
 *  @param[out] pjRbCb  PDCP RB Control Block.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
 */
#ifdef ANSI
PUBLIC S16 pjDbmFetchPjUlRbCb
(
PjUlUeCb  *ueCb,
U8       rbId,
U8       rbType,
PjUlRbCb  **pjRbCb 
)
#else
PUBLIC S16 pjDbmFetchPjUlRbCb(ueCb,rbId,rbType,pjRbCb)
PjUlUeCb  *ueCb;      
U8       rbId;
U8       rbType;
PjUlRbCb  **pjRbCb;
#endif
{
   PjUlRbCb    *rbCb;

   TRC2(pjDbmFetchPjUlRbCb)

   *pjRbCb = NULLP;

   PJ_DBM_FETCH_UL_RBCB(rbId, rbType, ueCb, rbCb);
   if ( rbCb != NULLP )
   {
      *pjRbCb = rbCb;
   }

   RETVALUE(ROK);

} /* pjDbmFetchPjUlRbCb */

/**
 *
 * @brief Handler to delete a PDCP/RLC RB control block.
 *       
 *
 * @b Description
 *        This function is used to delete the PDCP/RLC RB control block based 
 *        on RB id and the RB type (PDCP/RLC). If the corresponding RB is 
 *        present, the cfgStat flag is unset. If the cfgStat flag is zero,
 *        the RBCB is freed.
 *
 *  @param[in]  rbId    RB ID of the to be deleted RB
 *  @param[in]  rbCbLst RbCb list in UE CB
 *  @param[in]  rb      The RB to be deleted. This can be
 *                      PJ_CFG_PDCP when PDCP is created
 *                      or PJ_CFG_RLC when RLC is being
 *                      created.
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
 */
#ifdef ANSI
PUBLIC S16 pjDbmDelUlRbCb
(
PjCb   *gCb,
U8      rbId,
U8      rbType,
PjUlRbCb   **rbCb, 
U8      rb,
PjUlUeCb  *ueCb
)
#else
PUBLIC S16 pjDbmDelUlRbCb(gCb,rbId,rbType,rbCb,rb)
PjCb   *gCb;
U8      rbId;
U8      rbType;
PjUlRbCb   **rbCb;
U8      rb;
PjUlUeCb  *ueCb;
#endif
{
   S16      ret;
   PjUlRbCb   **rbCbLst;
   rbCbLst = NULLP;     
 
   TRC2(pjDbmDelUlRbCb)

   ret   = RFAILED;
   /*updating rbCbList */                              
   rbCbLst = ((rbType == CM_LTE_SRB)? ueCb->srbCb:ueCb->drbCb); 
   if ( (*rbCb) != NULLP )
   {
      PJ_DBM_DELETE_UL_RBCB(gCb,(*rbCb));
      ret = ROK;
      /*updating rbCbList */
      rbCbLst[rbId] = NULLP;         
   }
   RETVALUE(ret);

} /* pjDbmDelRbCb */

/**
 *
 * @brief Handler to add UL Transaction Id to List 
 *       
 *
 * @b Description
 *        This function is invoked by CFG to add all itransaction IDs to
 *        hashlist of PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmAddUlTransIdLst
(
PjCb              *gCb,
PjCfgInfo         *cfg       /* UE Control Block */
)
#else
PUBLIC S16 pjDbmAddUlTransIdLst(gCb,cfg)
PjCb              *gCb;
PjCfgInfo         *cfg;     /* UE Control Block */
#endif
{
   S16      ret;              /* Return Value */

   TRC3(pjDbmAddUlTransIdLst)

#ifdef DEBUGP
#ifndef ALIGN_64BIT
   RLOG1(L_UNUSED, "pjDbmAddUlTransIdLst(transId(%ld))", cfg->transId);
#else
   RLOG1(L_UNUSED, "pjDbmAddUlTransIdLst(transId(%d))", cfg->transId);
#endif
#endif

   ret = cmHashListInsert(&(gCb->u.ulCb->transIdLstCp), (PTR)cfg, 
         (U8 *)&(cfg->transId), (U16) sizeof(cfg->transId));
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR, "Hash Insert Failed for Inserting UL transId");
#endif
      RETVALUE(ret);
   }

   RETVALUE(ret);
} /* pjDbmAddUlTransIdLst */

/**
 *
 * @brief Handler to Find UL Transaction Id in the List 
 *       
 *
 * @b Description
 *        This function is invoked by CFG to Find transaction IDs in the
 *        hashlist of PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmFindUlTransIdLst
(
PjCb              *gCb,
U32               transId,
PjCfgInfo         **cfg       /* UE Control Block */
)
#else
PUBLIC S16 pjDbmFindUlTransIdLst(gCb,cfg)
PjCb              *gCb;
U32                transId;
PjCfgInfo         *cfg;     /* UE Control Block */
#endif
{
   S16      ret;              /* Return Value */

   TRC3(pjDbmFindUlTransIdLst)

#ifdef DEBUGP
#ifndef ALIGN_64BIT
   RLOG1(L_DEBUG, "pjDbmFindUlTransIdLst(transId(%ld))", transId);
#else
   RLOG1(L_DEBUG, "pjDbmFindUlTransIdLst(transId(%d))", transId);
#endif
#endif

   ret = cmHashListFind(&(gCb->u.ulCb->transIdLstCp),(U8 *) &transId, 
                  sizeof (transId), PJ_DEF_SEQ_NUM,(PTR *) cfg); 
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG1(L_ERROR,"Hash Find Failed Fetch for transId [%d]", transId);
#endif
   }
   ret = pjDbmDelUlTransIdLst(gCb, cfg);
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG0(L_ERROR,"Deleting Trans ID Failed");
#endif
      RETVALUE(ret);
   }

   RETVALUE(ret);
} /* pjDbmAddUlTransIdLst */

/**
 *
 * @brief Handler to Delete UL Transaction Id to List 
 *       
 *
 * @b Description
 *        This function is invoked by CFG to Delete transaction IDs From the
 *        hashlist of PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelUlTransIdLst
(
PjCb              *gCb,
PjCfgInfo         **cfg       /* UE Control Block */
)
#else
PUBLIC S16 pjDbmDelUlTransIdLst(gCb,cfg)
PjCb              *gCb;
PjCfgInfo         **cfg;     /* UE Control Block */
#endif
{
   S16      ret;              /* Return Value */

   TRC3(pjDbmDelUlTransIdLst)

#ifdef DEBUGP
   RLOG0(L_DEBUG, "pjDbmFindUlTransIdLst(transId()" );
#endif

   ret = cmHashListDelete(&(gCb->u.ulCb->transIdLstCp),(PTR) (*cfg)); 
   if (ret != ROK)
   {
#ifdef DEBUGP
      RLOG1(L_ERROR," Hash Delete Failed for transId(%d)",(*cfg)->transId);
#endif
   }

   RETVALUE(ret);
} /* pjDbmAddUlTransIdLst */

/**
 *
 * @brief Handler to Delete All  UL Transaction Ids from the List 
 *       
 *
 * @b Description
 *        This function is invoked by CFG to Delete all itransaction IDs from the
 *        hashlist of PjCb.
 *
 *  @return  S16
 *      -# ROK 
 *      -# RFAILED 
 *
*/
#ifdef ANSI
PUBLIC S16 pjDbmDelAllUlTransIdLst
(
PjCb              *gCb
)
#else
PUBLIC S16 pjDbmDelAllUlTransIdLst(gCb)
PjCb              *gCb;
#endif
{
   S16      ret;              /* Return Value */
   PjCfgInfo *cfg;

   TRC3(pjDbmDelAllUlTransIdLst)

#ifdef DEBUGP
   RLOG0(L_DEBUG, "pjDbmFindUlTransIdLst");
#endif
   ret = ROK;
   cfg = NULLP; /*KW_FIX*/
   /* Until no more ueCb is ueLstCp hash list get and delete ueCb */
   while (cmHashListGetNext(&(gCb->u.ulCb->transIdLstCp), 
               (PTR) cfg, (PTR *)&cfg) == ROK)

   {
      /* Delete ueCb */
      ret = pjDbmDelUlTransIdLst(gCb,&cfg);
      if (ret != ROK)
      {
#ifdef DEBUGP
         RLOG0(L_ERROR, " pjDbmDelTransIdLst Failed.");
#endif
         RETVALUE(ret);
      }
      
      cfg = NULLP;
   }

   RETVALUE(ret);
} /* pjDbmAddUlTransIdLst */






/********************************************************************30**
  
         End of file
**********************************************************************/